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
)
927 maybe_instantiate_noexcept (fn
);
928 raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
929 *spec_p
= merge_exception_specifiers (*spec_p
, raises
);
932 if (!trivial_fn_p (fn
))
936 if (TREE_CODE (arg
) == FIELD_DECL
937 && TREE_CODE (DECL_CONTEXT (arg
)) == UNION_TYPE
)
942 error ("union member %q+D with non-trivial %qD", arg
, fn
);
946 if (move_p
&& !move_fn_p (fn
) && !trivial_fn_p (fn
))
955 /* If this is a specialization of a constexpr template, we need to
956 force the instantiation now so that we know whether or not it's
958 if (DECL_DECLARED_CONSTEXPR_P (fn
) && DECL_TEMPLATE_INSTANTIATION (fn
)
959 && !DECL_TEMPLATE_INSTANTIATED (fn
))
960 instantiate_decl (fn
, /*defer_ok*/false, /*expl_class*/false);
961 if (!DECL_DECLARED_CONSTEXPR_P (fn
))
962 *constexpr_p
= false;
972 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
976 walk_field_subobs (tree fields
, tree fnname
, special_function_kind sfk
,
977 int quals
, bool copy_arg_p
, bool move_p
,
978 bool assign_p
, tree
*spec_p
, bool *trivial_p
,
979 bool *deleted_p
, bool *constexpr_p
, const char *msg
,
980 int flags
, tsubst_flags_t complain
)
983 for (field
= fields
; field
; field
= DECL_CHAIN (field
))
985 tree mem_type
, argtype
, rval
;
987 if (TREE_CODE (field
) != FIELD_DECL
988 || DECL_ARTIFICIAL (field
))
991 mem_type
= strip_array_types (TREE_TYPE (field
));
995 if (CP_TYPE_CONST_P (mem_type
) && !CLASS_TYPE_P (mem_type
))
998 error ("non-static const member %q#D, can%'t use default "
999 "assignment operator", field
);
1001 else if (TREE_CODE (mem_type
) == REFERENCE_TYPE
)
1004 error ("non-static reference member %q#D, can%'t use "
1005 "default assignment operator", field
);
1010 if (bad
&& deleted_p
)
1013 else if (sfk
== sfk_constructor
)
1016 if (CP_TYPE_CONST_P (mem_type
)
1017 && (!CLASS_TYPE_P (mem_type
)
1018 || !type_has_user_provided_default_constructor (mem_type
)))
1021 error ("uninitialized non-static const member %q#D",
1024 else if (TREE_CODE (mem_type
) == REFERENCE_TYPE
)
1027 error ("uninitialized non-static reference member %q#D",
1033 if (bad
&& deleted_p
)
1036 /* For an implicitly-defined default constructor to be constexpr,
1037 every member must have a user-provided default constructor. */
1038 /* FIXME will need adjustment for non-static data member
1040 if (constexpr_p
&& !CLASS_TYPE_P (mem_type
))
1041 *constexpr_p
= false;
1044 if (!CLASS_TYPE_P (mem_type
))
1047 if (ANON_AGGR_TYPE_P (mem_type
))
1049 walk_field_subobs (TYPE_FIELDS (mem_type
), fnname
, sfk
, quals
,
1050 copy_arg_p
, move_p
, assign_p
, spec_p
, trivial_p
,
1051 deleted_p
, constexpr_p
, msg
, flags
, complain
);
1057 int mem_quals
= cp_type_quals (mem_type
) | quals
;
1058 if (DECL_MUTABLE_P (field
))
1059 mem_quals
&= ~TYPE_QUAL_CONST
;
1060 argtype
= build_stub_type (mem_type
, mem_quals
, move_p
);
1063 argtype
= NULL_TREE
;
1065 rval
= locate_fn_flags (mem_type
, fnname
, argtype
, flags
, complain
);
1067 process_subob_fn (rval
, move_p
, spec_p
, trivial_p
, deleted_p
,
1068 constexpr_p
, msg
, field
);
1072 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1073 which is const if relevant and CONST_P is set. If spec_p, trivial_p and
1074 deleted_p are non-null, set their referent appropriately. If diag is
1075 true, we're being called from maybe_explain_implicit_delete to give
1079 synthesized_method_walk (tree ctype
, special_function_kind sfk
, bool const_p
,
1080 tree
*spec_p
, bool *trivial_p
, bool *deleted_p
,
1081 bool *constexpr_p
, bool diag
)
1083 tree binfo
, base_binfo
, scope
, fnname
, rval
, argtype
;
1084 bool move_p
, copy_arg_p
, assign_p
, expected_trivial
, check_vdtor
;
1085 VEC(tree
,gc
) *vbases
;
1086 int i
, quals
, flags
;
1087 tsubst_flags_t complain
;
1092 *spec_p
= (cxx_dialect
>= cxx0x
? noexcept_true_spec
: empty_except_spec
);
1096 /* "The closure type associated with a lambda-expression has a deleted
1097 default constructor and a deleted copy assignment operator."
1098 This is diagnosed in maybe_explain_implicit_delete. */
1099 if (LAMBDA_TYPE_P (ctype
)
1100 && (sfk
== sfk_constructor
1101 || sfk
== sfk_copy_assignment
))
1112 check_vdtor
= false;
1115 case sfk_move_assignment
:
1116 case sfk_copy_assignment
:
1118 fnname
= ansi_assopname (NOP_EXPR
);
1121 case sfk_destructor
:
1123 /* The synthesized method will call base dtors, but check complete
1124 here to avoid having to deal with VTT. */
1125 fnname
= complete_dtor_identifier
;
1128 case sfk_constructor
:
1129 case sfk_move_constructor
:
1130 case sfk_copy_constructor
:
1132 fnname
= complete_ctor_identifier
;
1139 /* If that user-written default constructor would satisfy the
1140 requirements of a constexpr constructor (7.1.5), the
1141 implicitly-defined default constructor is constexpr. */
1143 *constexpr_p
= ctor_p
;
1148 case sfk_constructor
:
1149 case sfk_destructor
:
1153 case sfk_move_constructor
:
1154 case sfk_move_assignment
:
1156 case sfk_copy_constructor
:
1157 case sfk_copy_assignment
:
1165 expected_trivial
= type_has_trivial_fn (ctype
, sfk
);
1167 *trivial_p
= expected_trivial
;
1169 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1170 class versions and other properties of the type. But a subobject
1171 class can be trivially copyable and yet have overload resolution
1172 choose a template constructor for initialization, depending on
1173 rvalueness and cv-quals. So we can't exit early for copy/move
1174 methods in C++0x. The same considerations apply in C++98/03, but
1175 there the definition of triviality does not consider overload
1176 resolution, so a constructor can be trivial even if it would otherwise
1177 call a non-trivial constructor. */
1178 if (expected_trivial
1179 && (!copy_arg_p
|| cxx_dialect
< cxx0x
))
1181 if (constexpr_p
&& sfk
== sfk_constructor
)
1182 *constexpr_p
= synthesized_default_constructor_is_constexpr (ctype
);
1186 ++cp_unevaluated_operand
;
1187 ++c_inhibit_evaluation_warnings
;
1189 scope
= push_scope (ctype
);
1193 flags
= LOOKUP_NORMAL
|LOOKUP_SPECULATIVE
|LOOKUP_DEFAULTED
;
1194 complain
= tf_warning_or_error
;
1198 flags
= LOOKUP_PROTECT
|LOOKUP_SPECULATIVE
|LOOKUP_DEFAULTED
;
1203 quals
= TYPE_QUAL_CONST
;
1205 quals
= TYPE_UNQUALIFIED
;
1206 argtype
= NULL_TREE
;
1211 msg
= ("base %qT does not have a move assignment operator or trivial "
1212 "copy assignment operator");
1214 msg
= ("base %qT does not have a move constructor or trivial "
1215 "copy constructor");
1217 for (binfo
= TYPE_BINFO (ctype
), i
= 0;
1218 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
1220 tree basetype
= BINFO_TYPE (base_binfo
);
1222 argtype
= build_stub_type (basetype
, quals
, move_p
);
1223 rval
= locate_fn_flags (base_binfo
, fnname
, argtype
, flags
, complain
);
1225 process_subob_fn (rval
, move_p
, spec_p
, trivial_p
, deleted_p
,
1226 constexpr_p
, msg
, basetype
);
1227 if (ctor_p
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
))
1229 /* In a constructor we also need to check the subobject
1230 destructors for cleanup of partially constructed objects. */
1231 rval
= locate_fn_flags (base_binfo
, complete_dtor_identifier
,
1232 NULL_TREE
, flags
, complain
);
1233 /* Note that we don't pass down trivial_p; the subobject
1234 destructors don't affect triviality of the constructor. */
1235 process_subob_fn (rval
, false, spec_p
, NULL
,
1236 deleted_p
, NULL
, NULL
,
1240 if (check_vdtor
&& type_has_virtual_destructor (basetype
))
1242 rval
= locate_fn_flags (ctype
, ansi_opname (DELETE_EXPR
),
1243 ptr_type_node
, flags
, complain
);
1244 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1245 to have a null rval (no class-specific op delete). */
1246 if (rval
&& rval
== error_mark_node
&& deleted_p
)
1248 check_vdtor
= false;
1252 vbases
= CLASSTYPE_VBASECLASSES (ctype
);
1253 if (vbases
&& assign_p
&& move_p
)
1255 /* Should the spec be changed to allow vbases that only occur once? */
1257 error ("%qT has virtual bases, default move assignment operator "
1258 "cannot be generated", ctype
);
1265 msg
= ("virtual base %qT does not have a move constructor "
1266 "or trivial copy constructor");
1267 if (vbases
&& constexpr_p
)
1268 *constexpr_p
= false;
1269 FOR_EACH_VEC_ELT (tree
, vbases
, i
, base_binfo
)
1271 tree basetype
= BINFO_TYPE (base_binfo
);
1273 argtype
= build_stub_type (basetype
, quals
, move_p
);
1274 rval
= locate_fn_flags (base_binfo
, fnname
, argtype
, flags
, complain
);
1276 process_subob_fn (rval
, move_p
, spec_p
, trivial_p
, deleted_p
,
1277 constexpr_p
, msg
, basetype
);
1278 if (ctor_p
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
))
1280 rval
= locate_fn_flags (base_binfo
, complete_dtor_identifier
,
1281 NULL_TREE
, flags
, complain
);
1282 process_subob_fn (rval
, false, spec_p
, NULL
,
1283 deleted_p
, NULL
, NULL
,
1289 /* Leave msg null. */;
1291 msg
= ("non-static data member %qD does not have a move "
1292 "assignment operator or trivial copy assignment operator");
1294 msg
= ("non-static data member %qD does not have a move "
1295 "constructor or trivial copy constructor");
1296 walk_field_subobs (TYPE_FIELDS (ctype
), fnname
, sfk
, quals
,
1297 copy_arg_p
, move_p
, assign_p
, spec_p
, trivial_p
,
1298 deleted_p
, constexpr_p
, msg
, flags
, complain
);
1300 walk_field_subobs (TYPE_FIELDS (ctype
), complete_dtor_identifier
,
1301 sfk_destructor
, TYPE_UNQUALIFIED
, false,
1302 false, false, spec_p
, NULL
,
1304 NULL
, flags
, complain
);
1308 --cp_unevaluated_operand
;
1309 --c_inhibit_evaluation_warnings
;
1312 /* DECL is a deleted function. If it's implicitly deleted, explain why and
1313 return true; else return false. */
1316 maybe_explain_implicit_delete (tree decl
)
1318 /* If decl is a clone, get the primary variant. */
1319 decl
= DECL_ORIGIN (decl
);
1320 gcc_assert (DECL_DELETED_FN (decl
));
1321 if (DECL_DEFAULTED_FN (decl
))
1323 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1324 static htab_t explained_htab
;
1327 special_function_kind sfk
;
1332 if (!explained_htab
)
1333 explained_htab
= htab_create (37, htab_hash_pointer
,
1334 htab_eq_pointer
, NULL
);
1335 slot
= htab_find_slot (explained_htab
, decl
, INSERT
);
1340 sfk
= special_function_p (decl
);
1341 ctype
= DECL_CONTEXT (decl
);
1342 loc
= input_location
;
1343 input_location
= DECL_SOURCE_LOCATION (decl
);
1346 if (LAMBDA_TYPE_P (ctype
))
1349 if (sfk
== sfk_constructor
)
1350 error ("a lambda closure type has a deleted default constructor");
1351 else if (sfk
== sfk_copy_assignment
)
1352 error ("a lambda closure type has a deleted copy assignment operator");
1358 tree parm_type
= TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl
));
1359 bool const_p
= CP_TYPE_CONST_P (non_reference (parm_type
));
1360 tree scope
= push_scope (ctype
);
1361 error ("%qD is implicitly deleted because the default "
1362 "definition would be ill-formed:", decl
);
1364 synthesized_method_walk (ctype
, sfk
, const_p
,
1365 NULL
, NULL
, NULL
, NULL
, true);
1368 input_location
= loc
;
1374 /* Implicitly declare the special function indicated by KIND, as a
1375 member of TYPE. For copy constructors and assignment operators,
1376 CONST_P indicates whether these functions should take a const
1377 reference argument or a non-const reference. Returns the
1378 FUNCTION_DECL for the implicitly declared function. */
1381 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
1384 tree parameter_types
= void_list_node
;
1387 tree raises
= empty_except_spec
;
1388 tree rhs_parm_type
= NULL_TREE
;
1391 HOST_WIDE_INT saved_processing_template_decl
;
1396 /* Because we create declarations for implicitly declared functions
1397 lazily, we may be creating the declaration for a member of TYPE
1398 while in some completely different context. However, TYPE will
1399 never be a dependent class (because we never want to do lookups
1400 for implicitly defined functions in a dependent class).
1401 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1402 because we only create clones for constructors and destructors
1403 when not in a template. */
1404 gcc_assert (!dependent_type_p (type
));
1405 saved_processing_template_decl
= processing_template_decl
;
1406 processing_template_decl
= 0;
1408 type
= TYPE_MAIN_VARIANT (type
);
1410 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
1412 if (kind
== sfk_destructor
)
1413 /* See comment in check_special_function_return_type. */
1414 return_type
= build_pointer_type (void_type_node
);
1416 return_type
= build_pointer_type (type
);
1419 return_type
= void_type_node
;
1423 case sfk_destructor
:
1425 name
= constructor_name (type
);
1428 case sfk_constructor
:
1429 /* Default constructor. */
1430 name
= constructor_name (type
);
1433 case sfk_copy_constructor
:
1434 case sfk_copy_assignment
:
1435 case sfk_move_constructor
:
1436 case sfk_move_assignment
:
1439 if (kind
== sfk_copy_assignment
1440 || kind
== sfk_move_assignment
)
1442 return_type
= build_reference_type (type
);
1443 name
= ansi_assopname (NOP_EXPR
);
1446 name
= constructor_name (type
);
1449 rhs_parm_type
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
1451 rhs_parm_type
= type
;
1452 move_p
= (kind
== sfk_move_assignment
1453 || kind
== sfk_move_constructor
);
1454 rhs_parm_type
= cp_build_reference_type (rhs_parm_type
, move_p
);
1456 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
1463 synthesized_method_walk (type
, kind
, const_p
, &raises
, &trivial_p
,
1464 &deleted_p
, &constexpr_p
, false);
1465 /* Don't bother marking a deleted constructor as constexpr. */
1467 constexpr_p
= false;
1468 /* A trivial copy/move constructor is also a constexpr constructor. */
1469 else if (trivial_p
&& cxx_dialect
>= cxx0x
1470 && (kind
== sfk_copy_constructor
1471 || kind
== sfk_move_constructor
))
1472 gcc_assert (constexpr_p
);
1474 if (!trivial_p
&& type_has_trivial_fn (type
, kind
))
1475 type_set_nontrivial_flag (type
, kind
);
1477 /* Create the function. */
1478 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1480 fn_type
= build_exception_variant (fn_type
, raises
);
1481 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1482 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1483 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
1484 || kind
== sfk_move_constructor
)
1485 DECL_CONSTRUCTOR_P (fn
) = 1;
1486 else if (kind
== sfk_destructor
)
1487 DECL_DESTRUCTOR_P (fn
) = 1;
1490 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1491 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1494 /* If pointers to member functions use the least significant bit to
1495 indicate whether a function is virtual, ensure a pointer
1496 to this function will have that bit clear. */
1497 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
1498 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
1499 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
1501 /* Create the explicit arguments. */
1504 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1505 want its type to be included in the mangled function
1507 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1508 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1510 /* Add the "this" parameter. */
1511 this_parm
= build_this_parm (fn_type
, TYPE_UNQUALIFIED
);
1512 DECL_CHAIN (this_parm
) = DECL_ARGUMENTS (fn
);
1513 DECL_ARGUMENTS (fn
) = this_parm
;
1515 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
);
1516 set_linkage_according_to_type (type
, fn
);
1517 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1518 DECL_IN_AGGR_P (fn
) = 1;
1519 DECL_ARTIFICIAL (fn
) = 1;
1520 DECL_DEFAULTED_FN (fn
) = 1;
1521 if (cxx_dialect
>= cxx0x
)
1523 DECL_DELETED_FN (fn
) = deleted_p
;
1524 DECL_DECLARED_CONSTEXPR_P (fn
) = constexpr_p
;
1526 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1527 DECL_DECLARED_INLINE_P (fn
) = 1;
1528 gcc_assert (!TREE_USED (fn
));
1530 /* Restore PROCESSING_TEMPLATE_DECL. */
1531 processing_template_decl
= saved_processing_template_decl
;
1536 /* Gives any errors about defaulted functions which need to be deferred
1537 until the containing class is complete. */
1540 defaulted_late_check (tree fn
)
1542 /* Complain about invalid signature for defaulted fn. */
1543 tree ctx
= DECL_CONTEXT (fn
);
1544 special_function_kind kind
= special_function_p (fn
);
1545 bool fn_const_p
= (copy_fn_p (fn
) == 2);
1546 tree implicit_fn
= implicitly_declare_fn (kind
, ctx
, fn_const_p
);
1548 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn
)),
1549 TREE_TYPE (TREE_TYPE (implicit_fn
)))
1550 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1551 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn
))))
1553 error ("defaulted declaration %q+D", fn
);
1554 error_at (DECL_SOURCE_LOCATION (fn
),
1555 "does not match expected signature %qD", implicit_fn
);
1558 /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1559 implicitly considered to have the same exception-specification as if
1560 it had been implicitly declared. */
1561 if (DECL_DEFAULTED_IN_CLASS_P (fn
))
1564 maybe_instantiate_noexcept (fn
);
1565 eh_spec
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn
));
1566 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
))
1567 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
)),
1568 eh_spec
, ce_normal
))
1569 error ("function %q+D defaulted on its first declaration "
1570 "with an exception-specification that differs from "
1571 "the implicit declaration %q#D", fn
, implicit_fn
);
1572 TREE_TYPE (fn
) = build_exception_variant (TREE_TYPE (fn
), eh_spec
);
1573 if (DECL_DECLARED_CONSTEXPR_P (implicit_fn
))
1574 /* Hmm...should we do this for out-of-class too? Should it be OK to
1575 add constexpr later like inline, rather than requiring
1576 declarations to match? */
1577 DECL_DECLARED_CONSTEXPR_P (fn
) = true;
1580 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn
)
1581 && DECL_DECLARED_CONSTEXPR_P (fn
))
1583 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
1584 error ("%qD cannot be declared as constexpr", fn
);
1585 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
1588 if (DECL_DELETED_FN (implicit_fn
))
1589 DECL_DELETED_FN (fn
) = 1;
1592 /* Returns true iff FN can be explicitly defaulted, and gives any
1593 errors if defaulting FN is ill-formed. */
1596 defaultable_fn_check (tree fn
)
1598 special_function_kind kind
= sfk_none
;
1600 if (template_parm_scope_p ())
1602 error ("a template cannot be defaulted");
1606 if (DECL_CONSTRUCTOR_P (fn
))
1608 if (FUNCTION_FIRST_USER_PARMTYPE (fn
) == void_list_node
)
1609 kind
= sfk_constructor
;
1610 else if (copy_fn_p (fn
) > 0
1611 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn
))
1613 kind
= sfk_copy_constructor
;
1614 else if (move_fn_p (fn
))
1615 kind
= sfk_move_constructor
;
1617 else if (DECL_DESTRUCTOR_P (fn
))
1618 kind
= sfk_destructor
;
1619 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
1620 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
1623 kind
= sfk_copy_assignment
;
1624 else if (move_fn_p (fn
))
1625 kind
= sfk_move_assignment
;
1628 if (kind
== sfk_none
)
1630 error ("%qD cannot be defaulted", fn
);
1635 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
1636 for (; t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1637 if (TREE_PURPOSE (t
))
1639 error ("defaulted function %q+D with default argument", fn
);
1642 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn
)))
1643 /* Defer checking. */;
1644 else if (!processing_template_decl
)
1645 defaulted_late_check (fn
);
1651 /* Add an implicit declaration to TYPE for the kind of function
1652 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1656 lazily_declare_fn (special_function_kind sfk
, tree type
)
1659 /* Whether or not the argument has a const reference type. */
1660 bool const_p
= false;
1664 case sfk_constructor
:
1665 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1667 case sfk_copy_constructor
:
1668 const_p
= TYPE_HAS_CONST_COPY_CTOR (type
);
1669 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1671 case sfk_move_constructor
:
1672 CLASSTYPE_LAZY_MOVE_CTOR (type
) = 0;
1674 case sfk_copy_assignment
:
1675 const_p
= TYPE_HAS_CONST_COPY_ASSIGN (type
);
1676 CLASSTYPE_LAZY_COPY_ASSIGN (type
) = 0;
1678 case sfk_move_assignment
:
1679 CLASSTYPE_LAZY_MOVE_ASSIGN (type
) = 0;
1681 case sfk_destructor
:
1682 CLASSTYPE_LAZY_DESTRUCTOR (type
) = 0;
1688 /* Declare the function. */
1689 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1691 /* For move variants, rather than declare them as deleted we just
1692 don't declare them at all. */
1693 if (DECL_DELETED_FN (fn
)
1694 && (sfk
== sfk_move_constructor
1695 || sfk
== sfk_move_assignment
))
1698 /* A destructor may be virtual. */
1699 if (sfk
== sfk_destructor
1700 || sfk
== sfk_move_assignment
1701 || sfk
== sfk_copy_assignment
)
1702 check_for_override (fn
, type
);
1703 /* Add it to CLASSTYPE_METHOD_VEC. */
1704 add_method (type
, fn
, NULL_TREE
);
1705 /* Add it to TYPE_METHODS. */
1706 if (sfk
== sfk_destructor
1707 && DECL_VIRTUAL_P (fn
)
1708 && abi_version_at_least (2))
1709 /* The ABI requires that a virtual destructor go at the end of the
1711 TYPE_METHODS (type
) = chainon (TYPE_METHODS (type
), fn
);
1714 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1715 TYPE_METHODS list, which cause the destructor to be emitted
1716 in an incorrect location in the vtable. */
1717 if (warn_abi
&& sfk
== sfk_destructor
&& DECL_VIRTUAL_P (fn
))
1718 warning (OPT_Wabi
, "vtable layout for class %qT may not be ABI-compliant"
1719 "and may change in a future version of GCC due to "
1720 "implicit virtual destructor",
1722 DECL_CHAIN (fn
) = TYPE_METHODS (type
);
1723 TYPE_METHODS (type
) = fn
;
1725 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1726 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
)
1727 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
))
1728 /* Create appropriate clones. */
1729 clone_function_decl (fn
, /*update_method_vec=*/true);
1734 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1735 as there are artificial parms in FN. */
1738 skip_artificial_parms_for (const_tree fn
, tree list
)
1740 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1741 list
= TREE_CHAIN (list
);
1745 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1746 list
= TREE_CHAIN (list
);
1747 if (DECL_HAS_VTT_PARM_P (fn
))
1748 list
= TREE_CHAIN (list
);
1752 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1753 artificial parms in FN. */
1756 num_artificial_parms_for (const_tree fn
)
1760 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1765 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1767 if (DECL_HAS_VTT_PARM_P (fn
))
1773 #include "gt-cp-method.h"