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
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
37 #include "tree-pass.h"
38 #include "diagnostic.h"
42 /* Various flags to control the mangling process. */
48 /* The thing we are presently mangling is part of a template type,
49 rather than a fully instantiated type. Therefore, we may see
50 complex expressions where we would normally expect to see a
51 simple integer constant. */
52 mf_maybe_uninstantiated
= 1,
53 /* When mangling a numeric value, use the form `_XX_' (instead of
54 just `XX') if the value has more than one digit. */
55 mf_use_underscores_around_value
= 2
58 typedef enum mangling_flags mangling_flags
;
60 static void do_build_copy_assign (tree
);
61 static void do_build_copy_constructor (tree
);
62 static tree
make_alias_for_thunk (tree
);
64 /* Called once to initialize method.c. */
72 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
73 indicates whether it is a this or result adjusting thunk.
74 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
75 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
76 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
77 adjusting thunks, we scale it to a byte offset. For covariant
78 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
79 the returned thunk with finish_thunk. */
82 make_thunk (tree function
, bool this_adjusting
,
83 tree fixed_offset
, tree virtual_offset
)
88 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
);
89 /* We can have this thunks to covariant thunks, but not vice versa. */
90 gcc_assert (!DECL_THIS_THUNK_P (function
));
91 gcc_assert (!DECL_RESULT_THUNK_P (function
) || this_adjusting
);
93 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
94 if (this_adjusting
&& virtual_offset
)
96 = size_binop (MULT_EXPR
,
99 TYPE_SIZE_UNIT (vtable_entry_type
)));
101 d
= tree_low_cst (fixed_offset
, 0);
103 /* See if we already have the thunk in question. For this_adjusting
104 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
106 for (thunk
= DECL_THUNKS (function
); thunk
; thunk
= DECL_CHAIN (thunk
))
107 if (DECL_THIS_THUNK_P (thunk
) == this_adjusting
108 && THUNK_FIXED_OFFSET (thunk
) == d
109 && !virtual_offset
== !THUNK_VIRTUAL_OFFSET (thunk
)
112 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk
),
114 : THUNK_VIRTUAL_OFFSET (thunk
) == virtual_offset
)))
117 /* All thunks must be created before FUNCTION is actually emitted;
118 the ABI requires that all thunks be emitted together with the
119 function to which they transfer control. */
120 gcc_assert (!TREE_ASM_WRITTEN (function
));
121 /* Likewise, we can only be adding thunks to a function declared in
122 the class currently being laid out. */
123 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function
))
124 && TYPE_BEING_DEFINED (DECL_CONTEXT (function
)));
126 thunk
= build_decl (DECL_SOURCE_LOCATION (function
),
127 FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
128 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
129 cxx_dup_lang_specific_decl (thunk
);
130 DECL_THUNKS (thunk
) = NULL_TREE
;
132 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
133 TREE_READONLY (thunk
) = TREE_READONLY (function
);
134 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
135 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
136 SET_DECL_THUNK_P (thunk
, this_adjusting
);
137 THUNK_TARGET (thunk
) = function
;
138 THUNK_FIXED_OFFSET (thunk
) = d
;
139 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
140 THUNK_ALIAS (thunk
) = NULL_TREE
;
142 /* The thunk itself is not a constructor or destructor, even if
143 the thing it is thunking to is. */
144 DECL_INTERFACE_KNOWN (thunk
) = 1;
145 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
146 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
147 DECL_DESTRUCTOR_P (thunk
) = 0;
148 DECL_CONSTRUCTOR_P (thunk
) = 0;
149 DECL_EXTERNAL (thunk
) = 1;
150 DECL_ARTIFICIAL (thunk
) = 1;
151 /* The THUNK is not a pending inline, even if the FUNCTION is. */
152 DECL_PENDING_INLINE_P (thunk
) = 0;
153 DECL_DECLARED_INLINE_P (thunk
) = 0;
154 /* Nor is it a template instantiation. */
155 DECL_USE_TEMPLATE (thunk
) = 0;
156 DECL_TEMPLATE_INFO (thunk
) = NULL
;
158 /* Add it to the list of thunks associated with FUNCTION. */
159 DECL_CHAIN (thunk
) = DECL_THUNKS (function
);
160 DECL_THUNKS (function
) = thunk
;
165 /* Finish THUNK, a thunk decl. */
168 finish_thunk (tree thunk
)
171 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
172 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
174 gcc_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
));
175 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
176 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
177 function
= THUNK_TARGET (thunk
);
178 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
179 fixed_offset
, virtual_offset
);
181 /* We can end up with declarations of (logically) different
182 covariant thunks, that do identical adjustments. The two thunks
183 will be adjusting between within different hierarchies, which
184 happen to have the same layout. We must nullify one of them to
185 refer to the other. */
186 if (DECL_RESULT_THUNK_P (thunk
))
190 for (cov_probe
= DECL_THUNKS (function
);
191 cov_probe
; cov_probe
= DECL_CHAIN (cov_probe
))
192 if (DECL_NAME (cov_probe
) == name
)
194 gcc_assert (!DECL_THUNKS (thunk
));
195 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
196 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
201 DECL_NAME (thunk
) = name
;
202 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
205 static GTY (()) int thunk_labelno
;
207 /* Create a static alias to target. */
210 make_alias_for (tree target
, tree newid
)
212 tree alias
= build_decl (DECL_SOURCE_LOCATION (target
),
213 TREE_CODE (target
), newid
, TREE_TYPE (target
));
214 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (target
);
215 cxx_dup_lang_specific_decl (alias
);
216 DECL_CONTEXT (alias
) = NULL
;
217 TREE_READONLY (alias
) = TREE_READONLY (target
);
218 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (target
);
219 TREE_PUBLIC (alias
) = 0;
220 DECL_INTERFACE_KNOWN (alias
) = 1;
221 if (DECL_LANG_SPECIFIC (alias
))
223 DECL_NOT_REALLY_EXTERN (alias
) = 1;
224 DECL_USE_TEMPLATE (alias
) = 0;
225 DECL_TEMPLATE_INFO (alias
) = NULL
;
227 DECL_EXTERNAL (alias
) = 0;
228 DECL_ARTIFICIAL (alias
) = 1;
229 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
230 if (TREE_CODE (alias
) == FUNCTION_DECL
)
232 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
233 DECL_DESTRUCTOR_P (alias
) = 0;
234 DECL_CONSTRUCTOR_P (alias
) = 0;
235 DECL_PENDING_INLINE_P (alias
) = 0;
236 DECL_DECLARED_INLINE_P (alias
) = 0;
237 DECL_INITIAL (alias
) = error_mark_node
;
238 DECL_ARGUMENTS (alias
) = copy_list (DECL_ARGUMENTS (target
));
241 TREE_STATIC (alias
) = 1;
242 TREE_ADDRESSABLE (alias
) = 1;
243 TREE_USED (alias
) = 1;
244 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
245 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
250 make_alias_for_thunk (tree function
)
255 targetm
.asm_out
.generate_internal_label (buf
, "LTHUNK", thunk_labelno
);
258 alias
= make_alias_for (function
, get_identifier (buf
));
260 if (!flag_syntax_only
)
262 struct cgraph_node
*aliasn
= cgraph_same_body_alias (alias
, function
);
263 DECL_ASSEMBLER_NAME (function
);
264 gcc_assert (aliasn
!= NULL
);
270 /* Emit the definition of a C++ multiple inheritance or covariant
271 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
275 use_thunk (tree thunk_fndecl
, bool emit_p
)
277 tree a
, t
, function
, alias
;
279 HOST_WIDE_INT fixed_offset
, virtual_value
;
280 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
282 /* We should have called finish_thunk to give it a name. */
283 gcc_assert (DECL_NAME (thunk_fndecl
));
285 /* We should never be using an alias, always refer to the
287 gcc_assert (!THUNK_ALIAS (thunk_fndecl
));
289 if (TREE_ASM_WRITTEN (thunk_fndecl
))
292 function
= THUNK_TARGET (thunk_fndecl
);
293 if (DECL_RESULT (thunk_fndecl
))
294 /* We already turned this thunk into an ordinary function.
295 There's no need to process this thunk again. */
298 if (DECL_THUNK_P (function
))
299 /* The target is itself a thunk, process it now. */
300 use_thunk (function
, emit_p
);
302 /* Thunks are always addressable; they only appear in vtables. */
303 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
305 /* Figure out what function is being thunked to. It's referenced in
306 this translation unit. */
307 TREE_ADDRESSABLE (function
) = 1;
308 mark_used (function
);
312 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
))
313 alias
= make_alias_for_thunk (function
);
317 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
318 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
323 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
324 virtual_value
= tree_low_cst (virtual_offset
, /*pos=*/0);
325 gcc_assert (virtual_value
);
330 /* And, if we need to emit the thunk, it's used. */
331 mark_used (thunk_fndecl
);
332 /* This thunk is actually defined. */
333 DECL_EXTERNAL (thunk_fndecl
) = 0;
334 /* The linkage of the function may have changed. FIXME in linkage
336 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
337 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
338 DECL_VISIBILITY_SPECIFIED (thunk_fndecl
)
339 = DECL_VISIBILITY_SPECIFIED (function
);
340 if (DECL_ONE_ONLY (function
) || DECL_WEAK (function
))
341 make_decl_one_only (thunk_fndecl
, cxx_comdat_group (thunk_fndecl
));
343 if (flag_syntax_only
)
345 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
349 push_to_top_level ();
351 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
352 && targetm
.have_named_sections
)
354 resolve_unique_section (function
, 0, flag_function_sections
);
356 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
358 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
360 /* Output the thunk into the same section as function. */
361 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
365 /* Set up cloned argument trees for the thunk. */
367 for (a
= DECL_ARGUMENTS (function
); a
; a
= DECL_CHAIN (a
))
369 tree x
= copy_node (a
);
371 DECL_CONTEXT (x
) = thunk_fndecl
;
372 SET_DECL_RTL (x
, NULL
);
373 DECL_HAS_VALUE_EXPR_P (x
) = 0;
377 DECL_ARGUMENTS (thunk_fndecl
) = a
;
378 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
379 cgraph_add_thunk (thunk_fndecl
, function
,
380 this_adjusting
, fixed_offset
, virtual_value
,
381 virtual_offset
, alias
);
384 || !targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
385 virtual_value
, alias
))
387 /* If this is a covariant thunk, or we don't have the necessary
388 code for efficient thunks, generate a thunk function that
389 just makes a call to the real function. Unfortunately, this
390 doesn't work for varargs. */
392 if (varargs_function_p (function
))
393 error ("generic thunk code fails for method %q#D which uses %<...%>",
397 pop_from_top_level ();
400 /* Code for synthesizing methods which have default semantics defined. */
402 /* True iff CTYPE has a trivial SFK. */
405 type_has_trivial_fn (tree ctype
, special_function_kind sfk
)
409 case sfk_constructor
:
410 return !TYPE_HAS_COMPLEX_DFLT (ctype
);
411 case sfk_copy_constructor
:
412 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype
);
413 case sfk_move_constructor
:
414 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype
);
415 case sfk_copy_assignment
:
416 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype
);
417 case sfk_move_assignment
:
418 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype
);
420 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
);
426 /* Note that CTYPE has a non-trivial SFK even though we previously thought
430 type_set_nontrivial_flag (tree ctype
, special_function_kind sfk
)
434 case sfk_constructor
:
435 TYPE_HAS_COMPLEX_DFLT (ctype
) = true;
437 case sfk_copy_constructor
:
438 TYPE_HAS_COMPLEX_COPY_CTOR (ctype
) = true;
440 case sfk_move_constructor
:
441 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype
) = true;
443 case sfk_copy_assignment
:
444 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype
) = true;
446 case sfk_move_assignment
:
447 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype
) = true;
450 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
) = true;
457 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
460 trivial_fn_p (tree fn
)
462 if (!DECL_DEFAULTED_FN (fn
))
465 /* If fn is a clone, get the primary variant. */
466 fn
= DECL_ORIGIN (fn
);
467 return type_has_trivial_fn (DECL_CONTEXT (fn
), special_function_p (fn
));
470 /* Generate code for default X(X&) or X(X&&) constructor. */
473 do_build_copy_constructor (tree fndecl
)
475 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
476 bool move_p
= DECL_MOVE_CONSTRUCTOR_P (fndecl
);
477 bool trivial
= trivial_fn_p (fndecl
);
479 parm
= convert_from_reference (parm
);
482 && is_empty_class (current_class_type
))
483 /* Don't copy the padding byte; it might not have been allocated
484 if *this is a base subobject. */;
487 tree t
= build2 (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
488 finish_expr_stmt (t
);
492 tree fields
= TYPE_FIELDS (current_class_type
);
493 tree member_init_list
= NULL_TREE
;
494 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
496 tree binfo
, base_binfo
;
498 VEC(tree
,gc
) *vbases
;
500 /* Initialize all the base-classes with the parameter converted
501 to their type so that we get their copy constructor and not
502 another constructor that takes current_class_type. We must
503 deal with the binfo's directly as a direct base might be
504 inaccessible due to ambiguity. */
505 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
506 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
508 init
= build_base_path (PLUS_EXPR
, parm
, binfo
, 1);
513 build_tree_list (NULL_TREE
, init
),
517 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
518 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
520 if (BINFO_VIRTUAL_P (base_binfo
))
523 init
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
527 = tree_cons (base_binfo
,
528 build_tree_list (NULL_TREE
, init
),
532 for (; fields
; fields
= DECL_CHAIN (fields
))
537 if (TREE_CODE (field
) != FIELD_DECL
)
540 expr_type
= TREE_TYPE (field
);
541 if (DECL_NAME (field
))
543 if (VFIELD_NAME_P (DECL_NAME (field
)))
546 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
547 /* Just use the field; anonymous types can't have
548 nontrivial copy ctors or assignment ops or this
549 function would be deleted. */;
553 /* Compute the type of "init->field". If the copy-constructor
554 parameter is, for example, "const S&", and the type of
555 the field is "T", then the type will usually be "const
556 T". (There are no cv-qualified variants of reference
558 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
562 if (DECL_MUTABLE_P (field
))
563 quals
&= ~TYPE_QUAL_CONST
;
564 quals
|= cp_type_quals (expr_type
);
565 expr_type
= cp_build_qualified_type (expr_type
, quals
);
568 init
= build3 (COMPONENT_REF
, expr_type
, parm
, field
, NULL_TREE
);
569 if (move_p
&& TREE_CODE (expr_type
) != REFERENCE_TYPE
)
571 init
= build_tree_list (NULL_TREE
, init
);
573 member_init_list
= tree_cons (field
, init
, member_init_list
);
575 finish_mem_initializers (member_init_list
);
580 do_build_copy_assign (tree fndecl
)
582 tree parm
= DECL_CHAIN (DECL_ARGUMENTS (fndecl
));
584 bool move_p
= move_fn_p (fndecl
);
585 bool trivial
= trivial_fn_p (fndecl
);
587 compound_stmt
= begin_compound_stmt (0);
588 parm
= convert_from_reference (parm
);
591 && is_empty_class (current_class_type
))
592 /* Don't copy the padding byte; it might not have been allocated
593 if *this is a base subobject. */;
596 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
597 finish_expr_stmt (t
);
602 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
604 tree binfo
, base_binfo
;
606 /* Assign to each of the direct base classes. */
607 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
608 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
611 VEC(tree
,gc
) *parmvec
;
613 /* We must convert PARM directly to the base class
614 explicitly since the base class may be ambiguous. */
615 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
617 converted_parm
= move (converted_parm
);
618 /* Call the base class assignment operator. */
619 parmvec
= make_tree_vector_single (converted_parm
);
621 (build_special_member_call (current_class_ref
,
622 ansi_assopname (NOP_EXPR
),
625 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
626 tf_warning_or_error
));
627 release_tree_vector (parmvec
);
630 /* Assign to each of the non-static data members. */
631 for (fields
= TYPE_FIELDS (current_class_type
);
633 fields
= DECL_CHAIN (fields
))
635 tree comp
= current_class_ref
;
641 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
644 expr_type
= TREE_TYPE (field
);
646 if (CP_TYPE_CONST_P (expr_type
))
648 error ("non-static const member %q#D, can%'t use default "
649 "assignment operator", field
);
652 else if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
654 error ("non-static reference member %q#D, can%'t use "
655 "default assignment operator", field
);
659 if (DECL_NAME (field
))
661 if (VFIELD_NAME_P (DECL_NAME (field
)))
664 else if (ANON_AGGR_TYPE_P (expr_type
)
665 && TYPE_FIELDS (expr_type
) != NULL_TREE
)
666 /* Just use the field; anonymous types can't have
667 nontrivial copy ctors or assignment ops or this
668 function would be deleted. */;
672 comp
= build3 (COMPONENT_REF
, expr_type
, comp
, field
, NULL_TREE
);
674 /* Compute the type of init->field */
676 if (DECL_MUTABLE_P (field
))
677 quals
&= ~TYPE_QUAL_CONST
;
678 expr_type
= cp_build_qualified_type (expr_type
, quals
);
680 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
681 if (move_p
&& TREE_CODE (expr_type
) != REFERENCE_TYPE
)
684 if (DECL_NAME (field
))
685 init
= cp_build_modify_expr (comp
, NOP_EXPR
, init
,
686 tf_warning_or_error
);
688 init
= build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
689 finish_expr_stmt (init
);
692 finish_return_stmt (current_class_ref
);
693 finish_compound_stmt (compound_stmt
);
696 /* Synthesize FNDECL, a non-static member function. */
699 synthesize_method (tree fndecl
)
701 bool nested
= (current_function_decl
!= NULL_TREE
);
702 tree context
= decl_function_context (fndecl
);
703 bool need_body
= true;
705 location_t save_input_location
= input_location
;
706 int error_count
= errorcount
;
707 int warning_count
= warningcount
;
709 /* Reset the source location, we might have been previously
710 deferred, and thus have saved where we were first needed. */
711 DECL_SOURCE_LOCATION (fndecl
)
712 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl
)));
714 /* If we've been asked to synthesize a clone, just synthesize the
715 cloned function instead. Doing so will automatically fill in the
716 body for the clone. */
717 if (DECL_CLONED_FUNCTION_P (fndecl
))
718 fndecl
= DECL_CLONED_FUNCTION (fndecl
);
720 /* We may be in the middle of deferred access check. Disable
722 push_deferring_access_checks (dk_no_deferred
);
725 push_to_top_level ();
727 push_function_context ();
729 input_location
= DECL_SOURCE_LOCATION (fndecl
);
731 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
732 stmt
= begin_function_body ();
734 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
736 do_build_copy_assign (fndecl
);
739 else if (DECL_CONSTRUCTOR_P (fndecl
))
741 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
742 if (arg_chain
!= void_list_node
)
743 do_build_copy_constructor (fndecl
);
745 finish_mem_initializers (NULL_TREE
);
748 /* If we haven't yet generated the body of the function, just
749 generate an empty compound statement. */
753 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
754 finish_compound_stmt (compound_stmt
);
757 finish_function_body (stmt
);
758 expand_or_defer_fn (finish_function (0));
760 input_location
= save_input_location
;
763 pop_from_top_level ();
765 pop_function_context ();
767 pop_deferring_access_checks ();
769 if (error_count
!= errorcount
|| warning_count
!= warningcount
)
770 inform (input_location
, "synthesized method %qD first required here ",
774 /* Build a reference to type TYPE with cv-quals QUALS, which is an
775 rvalue if RVALUE is true. */
778 build_stub_type (tree type
, int quals
, bool rvalue
)
780 tree argtype
= cp_build_qualified_type (type
, quals
);
781 return cp_build_reference_type (argtype
, rvalue
);
784 /* Build a dummy glvalue from dereferencing a dummy reference of type
788 build_stub_object (tree reftype
)
790 tree stub
= build1 (NOP_EXPR
, reftype
, integer_one_node
);
791 return convert_from_reference (stub
);
794 /* Determine which function will be called when looking up NAME in TYPE,
795 called with a single ARGTYPE argument, or no argument if ARGTYPE is
796 null. FLAGS and COMPLAIN are as for build_new_method_call.
798 Returns a FUNCTION_DECL if all is well.
799 Returns NULL_TREE if overload resolution failed.
800 Returns error_mark_node if the chosen function cannot be called. */
803 locate_fn_flags (tree type
, tree name
, tree argtype
, int flags
,
804 tsubst_flags_t complain
)
806 tree ob
, fn
, fns
, binfo
, rval
;
810 binfo
= TYPE_BINFO (type
);
814 type
= BINFO_TYPE (binfo
);
817 ob
= build_stub_object (cp_build_reference_type (type
, false));
818 args
= make_tree_vector ();
821 tree arg
= build_stub_object (argtype
);
822 VEC_quick_push (tree
, args
, arg
);
825 fns
= lookup_fnfields (binfo
, name
, 0);
826 rval
= build_new_method_call (ob
, fns
, &args
, binfo
, flags
, &fn
, complain
);
828 release_tree_vector (args
);
829 if (fn
&& rval
== error_mark_node
)
835 /* Locate the dtor of TYPE. */
840 tree fn
= locate_fn_flags (type
, complete_dtor_identifier
, NULL_TREE
,
841 LOOKUP_NORMAL
, tf_warning_or_error
);
842 if (fn
== error_mark_node
)
847 /* Locate the default ctor of TYPE. */
850 locate_ctor (tree type
)
854 push_deferring_access_checks (dk_no_check
);
855 fn
= locate_fn_flags (type
, complete_ctor_identifier
, NULL_TREE
,
856 LOOKUP_SPECULATIVE
, tf_none
);
857 pop_deferring_access_checks ();
858 if (fn
== error_mark_node
)
863 /* Likewise, but give any appropriate errors. */
866 get_default_ctor (tree type
)
868 tree fn
= locate_fn_flags (type
, complete_ctor_identifier
, NULL_TREE
,
869 LOOKUP_NORMAL
, tf_warning_or_error
);
870 if (fn
== error_mark_node
)
875 /* Locate the copy ctor of TYPE. */
878 get_copy_ctor (tree type
)
880 int quals
= (TYPE_HAS_CONST_COPY_CTOR (type
)
881 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
);
882 tree argtype
= build_stub_type (type
, quals
, false);
883 tree fn
= locate_fn_flags (type
, complete_ctor_identifier
, argtype
,
884 LOOKUP_NORMAL
, tf_warning_or_error
);
885 if (fn
== error_mark_node
)
890 /* Locate the copy assignment operator of TYPE. */
893 get_copy_assign (tree type
)
895 int quals
= (TYPE_HAS_CONST_COPY_ASSIGN (type
)
896 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
);
897 tree argtype
= build_stub_type (type
, quals
, false);
898 tree fn
= locate_fn_flags (type
, ansi_assopname (NOP_EXPR
), argtype
,
899 LOOKUP_NORMAL
, tf_warning_or_error
);
900 if (fn
== error_mark_node
)
905 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
906 DELETED_P or give an error message MSG with argument ARG. */
909 process_subob_fn (tree fn
, bool move_p
, tree
*spec_p
, bool *trivial_p
,
910 bool *deleted_p
, bool *constexpr_p
,
911 const char *msg
, tree arg
)
913 if (!fn
|| fn
== error_mark_node
)
918 tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
919 *spec_p
= merge_exception_specifiers (*spec_p
, raises
);
922 if (!trivial_fn_p (fn
))
926 if (TREE_CODE (arg
) == FIELD_DECL
927 && TREE_CODE (DECL_CONTEXT (arg
)) == UNION_TYPE
)
932 error ("union member %q+D with non-trivial %qD", arg
, fn
);
936 if (move_p
&& !move_fn_p (fn
) && !trivial_fn_p (fn
))
943 if (constexpr_p
&& !DECL_DECLARED_CONSTEXPR_P (fn
))
944 *constexpr_p
= false;
953 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
957 walk_field_subobs (tree fields
, tree fnname
, special_function_kind sfk
,
958 int quals
, bool copy_arg_p
, bool move_p
,
959 bool assign_p
, tree
*spec_p
, bool *trivial_p
,
960 bool *deleted_p
, bool *constexpr_p
, const char *msg
,
961 int flags
, tsubst_flags_t complain
)
964 for (field
= fields
; field
; field
= DECL_CHAIN (field
))
966 tree mem_type
, argtype
, rval
;
968 if (TREE_CODE (field
) != FIELD_DECL
969 || DECL_ARTIFICIAL (field
))
972 mem_type
= strip_array_types (TREE_TYPE (field
));
976 if (CP_TYPE_CONST_P (mem_type
) && !CLASS_TYPE_P (mem_type
))
979 error ("non-static const member %q#D, can%'t use default "
980 "assignment operator", field
);
982 else if (TREE_CODE (mem_type
) == REFERENCE_TYPE
)
985 error ("non-static reference member %q#D, can%'t use "
986 "default assignment operator", field
);
991 if (bad
&& deleted_p
)
994 else if (sfk
== sfk_constructor
)
997 if (CP_TYPE_CONST_P (mem_type
)
998 && (!CLASS_TYPE_P (mem_type
)
999 || !type_has_user_provided_default_constructor (mem_type
)))
1002 error ("uninitialized non-static const member %q#D",
1005 else if (TREE_CODE (mem_type
) == REFERENCE_TYPE
)
1008 error ("uninitialized non-static reference member %q#D",
1014 if (bad
&& deleted_p
)
1017 /* For an implicitly-defined default constructor to be constexpr,
1018 every member must have a user-provided default constructor. */
1019 /* FIXME will need adjustment for non-static data member
1021 if (constexpr_p
&& !CLASS_TYPE_P (mem_type
))
1022 *constexpr_p
= false;
1025 if (!CLASS_TYPE_P (mem_type
))
1028 if (ANON_AGGR_TYPE_P (mem_type
))
1030 walk_field_subobs (TYPE_FIELDS (mem_type
), fnname
, sfk
, quals
,
1031 copy_arg_p
, move_p
, assign_p
, spec_p
, trivial_p
,
1032 deleted_p
, constexpr_p
, msg
, flags
, complain
);
1038 int mem_quals
= cp_type_quals (mem_type
) | quals
;
1039 if (DECL_MUTABLE_P (field
))
1040 mem_quals
&= ~TYPE_QUAL_CONST
;
1041 argtype
= build_stub_type (mem_type
, mem_quals
, move_p
);
1044 argtype
= NULL_TREE
;
1046 rval
= locate_fn_flags (mem_type
, fnname
, argtype
, flags
, complain
);
1048 process_subob_fn (rval
, move_p
, spec_p
, trivial_p
, deleted_p
,
1049 constexpr_p
, msg
, field
);
1053 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1054 which is const if relevant and CONST_P is set. If spec_p, trivial_p and
1055 deleted_p are non-null, set their referent appropriately. If diag is
1056 true, we're being called from maybe_explain_implicit_delete to give
1060 synthesized_method_walk (tree ctype
, special_function_kind sfk
, bool const_p
,
1061 tree
*spec_p
, bool *trivial_p
, bool *deleted_p
,
1062 bool *constexpr_p
, bool diag
)
1064 tree binfo
, base_binfo
, scope
, fnname
, rval
, argtype
;
1065 bool move_p
, copy_arg_p
, assign_p
, expected_trivial
, check_vdtor
;
1066 VEC(tree
,gc
) *vbases
;
1067 int i
, quals
, flags
;
1068 tsubst_flags_t complain
;
1072 bool cleanup_trivial
= true;
1073 bool cleanup_deleted
= false;
1076 = (cxx_dialect
>= cxx0x
? noexcept_true_spec
: empty_except_spec
);
1078 *spec_p
= cleanup_spec
;
1082 /* "The closure type associated with a lambda-expression has a deleted
1083 default constructor and a deleted copy assignment operator."
1084 This is diagnosed in maybe_explain_implicit_delete. */
1085 if (LAMBDA_TYPE_P (ctype
)
1086 && (sfk
== sfk_constructor
1087 || sfk
== sfk_copy_assignment
))
1098 check_vdtor
= false;
1101 case sfk_move_assignment
:
1102 case sfk_copy_assignment
:
1104 fnname
= ansi_assopname (NOP_EXPR
);
1107 case sfk_destructor
:
1109 /* The synthesized method will call base dtors, but check complete
1110 here to avoid having to deal with VTT. */
1111 fnname
= complete_dtor_identifier
;
1114 case sfk_constructor
:
1115 case sfk_move_constructor
:
1116 case sfk_copy_constructor
:
1118 fnname
= complete_ctor_identifier
;
1125 /* If that user-written default constructor would satisfy the
1126 requirements of a constexpr constructor (7.1.5), the
1127 implicitly-defined default constructor is constexpr. */
1129 *constexpr_p
= ctor_p
;
1134 case sfk_constructor
:
1135 case sfk_destructor
:
1139 case sfk_move_constructor
:
1140 case sfk_move_assignment
:
1142 case sfk_copy_constructor
:
1143 case sfk_copy_assignment
:
1151 expected_trivial
= type_has_trivial_fn (ctype
, sfk
);
1153 *trivial_p
= expected_trivial
;
1155 #ifndef ENABLE_CHECKING
1156 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1157 class versions and other properties of the type. But a subobject
1158 class can be trivially copyable and yet have overload resolution
1159 choose a template constructor for initialization, depending on
1160 rvalueness and cv-quals. So we can't exit early for copy/move
1161 methods in C++0x. */
1162 if (expected_trivial
1163 && (!copy_arg_p
|| cxx_dialect
< cxx0x
))
1165 if (constexpr_p
&& sfk
== sfk_constructor
)
1166 *constexpr_p
= synthesized_default_constructor_is_constexpr (ctype
);
1171 ++cp_unevaluated_operand
;
1172 ++c_inhibit_evaluation_warnings
;
1174 scope
= push_scope (ctype
);
1178 flags
= LOOKUP_NORMAL
|LOOKUP_SPECULATIVE
;
1179 complain
= tf_warning_or_error
;
1183 flags
= LOOKUP_PROTECT
|LOOKUP_SPECULATIVE
;
1188 quals
= TYPE_QUAL_CONST
;
1190 quals
= TYPE_UNQUALIFIED
;
1191 argtype
= NULL_TREE
;
1196 msg
= ("base %qT does not have a move assignment operator or trivial "
1197 "copy assignment operator");
1199 msg
= ("base %qT does not have a move constructor or trivial "
1200 "copy constructor");
1202 for (binfo
= TYPE_BINFO (ctype
), i
= 0;
1203 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
1205 tree basetype
= BINFO_TYPE (base_binfo
);
1207 argtype
= build_stub_type (basetype
, quals
, move_p
);
1208 rval
= locate_fn_flags (base_binfo
, fnname
, argtype
, flags
, complain
);
1210 process_subob_fn (rval
, move_p
, spec_p
, trivial_p
, deleted_p
,
1211 constexpr_p
, msg
, basetype
);
1212 if (ctor_p
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
))
1214 /* In a constructor we also need to check the subobject
1215 destructors for cleanup of partially constructed objects. */
1216 rval
= locate_fn_flags (base_binfo
, complete_dtor_identifier
,
1217 NULL_TREE
, flags
, complain
);
1218 process_subob_fn (rval
, false, &cleanup_spec
, &cleanup_trivial
,
1219 &cleanup_deleted
, NULL
, NULL
,
1223 if (check_vdtor
&& type_has_virtual_destructor (basetype
))
1225 rval
= locate_fn_flags (ctype
, ansi_opname (DELETE_EXPR
),
1226 ptr_type_node
, flags
, complain
);
1227 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1228 to have a null rval (no class-specific op delete). */
1229 if (rval
&& rval
== error_mark_node
&& deleted_p
)
1231 check_vdtor
= false;
1235 vbases
= CLASSTYPE_VBASECLASSES (ctype
);
1236 if (vbases
&& assign_p
&& move_p
)
1238 /* Should the spec be changed to allow vbases that only occur once? */
1240 error ("%qT has virtual bases, default move assignment operator "
1241 "cannot be generated", ctype
);
1248 msg
= ("virtual base %qT does not have a move constructor "
1249 "or trivial copy constructor");
1250 if (vbases
&& constexpr_p
)
1251 *constexpr_p
= false;
1252 FOR_EACH_VEC_ELT (tree
, vbases
, i
, base_binfo
)
1254 tree basetype
= BINFO_TYPE (base_binfo
);
1256 argtype
= build_stub_type (basetype
, quals
, move_p
);
1257 rval
= locate_fn_flags (base_binfo
, fnname
, argtype
, flags
, complain
);
1259 process_subob_fn (rval
, move_p
, spec_p
, trivial_p
, deleted_p
,
1260 constexpr_p
, msg
, basetype
);
1261 if (ctor_p
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
))
1263 rval
= locate_fn_flags (base_binfo
, complete_dtor_identifier
,
1264 NULL_TREE
, flags
, complain
);
1265 process_subob_fn (rval
, false, &cleanup_spec
, &cleanup_trivial
,
1266 &cleanup_deleted
, NULL
, NULL
,
1272 /* Leave msg null. */;
1274 msg
= ("non-static data member %qD does not have a move "
1275 "assignment operator or trivial copy assignment operator");
1277 msg
= ("non-static data member %qD does not have a move "
1278 "constructor or trivial copy constructor");
1279 walk_field_subobs (TYPE_FIELDS (ctype
), fnname
, sfk
, quals
,
1280 copy_arg_p
, move_p
, assign_p
, spec_p
, trivial_p
,
1281 deleted_p
, constexpr_p
, msg
, flags
, complain
);
1283 walk_field_subobs (TYPE_FIELDS (ctype
), complete_dtor_identifier
,
1284 sfk_destructor
, TYPE_UNQUALIFIED
, false,
1285 false, false, &cleanup_spec
, &cleanup_trivial
,
1286 &cleanup_deleted
, NULL
,
1287 NULL
, flags
, complain
);
1291 --cp_unevaluated_operand
;
1292 --c_inhibit_evaluation_warnings
;
1294 /* If the constructor isn't trivial, consider the subobject cleanups. */
1295 if (ctor_p
&& trivial_p
&& !*trivial_p
)
1297 if (deleted_p
&& cleanup_deleted
)
1300 *spec_p
= merge_exception_specifiers (*spec_p
, cleanup_spec
);
1303 #ifdef ENABLE_CHECKING
1304 /* If we expected this to be trivial but it isn't, then either we're in
1305 C++0x mode and this is a copy/move ctor/op= or there's an error. */
1306 gcc_assert (!(trivial_p
&& expected_trivial
&& !*trivial_p
)
1307 || (copy_arg_p
&& cxx_dialect
>= cxx0x
)
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
)
1322 && DECL_INITIAL (decl
) == NULL_TREE
)
1324 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1325 static htab_t explained_htab
;
1328 special_function_kind sfk
;
1333 if (!explained_htab
)
1334 explained_htab
= htab_create (37, htab_hash_pointer
,
1335 htab_eq_pointer
, NULL
);
1336 slot
= htab_find_slot (explained_htab
, decl
, INSERT
);
1341 sfk
= special_function_p (decl
);
1342 ctype
= DECL_CONTEXT (decl
);
1343 loc
= input_location
;
1344 input_location
= DECL_SOURCE_LOCATION (decl
);
1347 if (LAMBDA_TYPE_P (ctype
))
1350 if (sfk
== sfk_constructor
)
1351 error ("a lambda closure type has a deleted default constructor");
1352 else if (sfk
== sfk_copy_assignment
)
1353 error ("a lambda closure type has a deleted copy assignment operator");
1359 tree parm_type
= TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl
));
1360 bool const_p
= CP_TYPE_CONST_P (non_reference (parm_type
));
1361 tree scope
= push_scope (ctype
);
1362 error ("%qD is implicitly deleted because the default "
1363 "definition would be ill-formed:", decl
);
1365 synthesized_method_walk (ctype
, sfk
, const_p
,
1366 NULL
, NULL
, NULL
, NULL
, true);
1369 input_location
= loc
;
1375 /* Implicitly declare the special function indicated by KIND, as a
1376 member of TYPE. For copy constructors and assignment operators,
1377 CONST_P indicates whether these functions should take a const
1378 reference argument or a non-const reference. Returns the
1379 FUNCTION_DECL for the implicitly declared function. */
1382 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
1385 tree parameter_types
= void_list_node
;
1388 tree raises
= empty_except_spec
;
1389 tree rhs_parm_type
= NULL_TREE
;
1392 HOST_WIDE_INT saved_processing_template_decl
;
1397 /* Because we create declarations for implicitly declared functions
1398 lazily, we may be creating the declaration for a member of TYPE
1399 while in some completely different context. However, TYPE will
1400 never be a dependent class (because we never want to do lookups
1401 for implicitly defined functions in a dependent class).
1402 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1403 because we only create clones for constructors and destructors
1404 when not in a template. */
1405 gcc_assert (!dependent_type_p (type
));
1406 saved_processing_template_decl
= processing_template_decl
;
1407 processing_template_decl
= 0;
1409 type
= TYPE_MAIN_VARIANT (type
);
1411 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
1413 if (kind
== sfk_destructor
)
1414 /* See comment in check_special_function_return_type. */
1415 return_type
= build_pointer_type (void_type_node
);
1417 return_type
= build_pointer_type (type
);
1420 return_type
= void_type_node
;
1424 case sfk_destructor
:
1426 name
= constructor_name (type
);
1429 case sfk_constructor
:
1430 /* Default constructor. */
1431 name
= constructor_name (type
);
1434 case sfk_copy_constructor
:
1435 case sfk_copy_assignment
:
1436 case sfk_move_constructor
:
1437 case sfk_move_assignment
:
1440 if (kind
== sfk_copy_assignment
1441 || kind
== sfk_move_assignment
)
1443 return_type
= build_reference_type (type
);
1444 name
= ansi_assopname (NOP_EXPR
);
1447 name
= constructor_name (type
);
1450 rhs_parm_type
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
1452 rhs_parm_type
= type
;
1453 move_p
= (kind
== sfk_move_assignment
1454 || kind
== sfk_move_constructor
);
1455 rhs_parm_type
= cp_build_reference_type (rhs_parm_type
, move_p
);
1457 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
1464 synthesized_method_walk (type
, kind
, const_p
, &raises
, &trivial_p
,
1465 &deleted_p
, &constexpr_p
, false);
1466 /* Don't bother marking a deleted constructor as constexpr. */
1468 constexpr_p
= false;
1469 /* A trivial copy/move constructor is also a constexpr constructor. */
1470 else if (trivial_p
&& cxx_dialect
>= cxx0x
1471 && (kind
== sfk_copy_constructor
1472 || kind
== sfk_move_constructor
))
1473 gcc_assert (constexpr_p
);
1475 if (!trivial_p
&& type_has_trivial_fn (type
, kind
))
1476 type_set_nontrivial_flag (type
, kind
);
1478 /* Create the function. */
1479 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1481 fn_type
= build_exception_variant (fn_type
, raises
);
1482 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1483 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1484 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
1485 || kind
== sfk_move_constructor
)
1486 DECL_CONSTRUCTOR_P (fn
) = 1;
1487 else if (kind
== sfk_destructor
)
1488 DECL_DESTRUCTOR_P (fn
) = 1;
1491 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1492 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1495 /* If pointers to member functions use the least significant bit to
1496 indicate whether a function is virtual, ensure a pointer
1497 to this function will have that bit clear. */
1498 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
1499 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
1500 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
1502 /* Create the explicit arguments. */
1505 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1506 want its type to be included in the mangled function
1508 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1509 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1511 /* Add the "this" parameter. */
1512 this_parm
= build_this_parm (fn_type
, TYPE_UNQUALIFIED
);
1513 DECL_CHAIN (this_parm
) = DECL_ARGUMENTS (fn
);
1514 DECL_ARGUMENTS (fn
) = this_parm
;
1516 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
);
1517 set_linkage_according_to_type (type
, fn
);
1518 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1519 DECL_IN_AGGR_P (fn
) = 1;
1520 DECL_ARTIFICIAL (fn
) = 1;
1521 DECL_DEFAULTED_FN (fn
) = 1;
1522 if (cxx_dialect
>= cxx0x
)
1524 DECL_DELETED_FN (fn
) = deleted_p
;
1525 DECL_DECLARED_CONSTEXPR_P (fn
) = constexpr_p
;
1527 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1528 DECL_DECLARED_INLINE_P (fn
) = 1;
1529 gcc_assert (!TREE_USED (fn
));
1531 /* Restore PROCESSING_TEMPLATE_DECL. */
1532 processing_template_decl
= saved_processing_template_decl
;
1537 /* Gives any errors about defaulted functions which need to be deferred
1538 until the containing class is complete. */
1541 defaulted_late_check (tree fn
)
1543 /* Complain about invalid signature for defaulted fn. */
1544 tree ctx
= DECL_CONTEXT (fn
);
1545 special_function_kind kind
= special_function_p (fn
);
1546 bool fn_const_p
= (copy_fn_p (fn
) == 2);
1547 tree implicit_fn
= implicitly_declare_fn (kind
, ctx
, fn_const_p
);
1549 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn
)),
1550 TREE_TYPE (TREE_TYPE (implicit_fn
)))
1551 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1552 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn
))))
1554 error ("defaulted declaration %q+D", fn
);
1555 error_at (DECL_SOURCE_LOCATION (fn
),
1556 "does not match expected signature %qD", implicit_fn
);
1559 /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1560 implicitly considered to have the same exception-specification as if
1561 it had been implicitly declared. */
1562 if (DECL_DEFAULTED_IN_CLASS_P (fn
))
1564 tree eh_spec
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn
));
1565 TREE_TYPE (fn
) = build_exception_variant (TREE_TYPE (fn
), eh_spec
);
1566 if (DECL_DECLARED_CONSTEXPR_P (implicit_fn
))
1567 /* Hmm...should we do this for out-of-class too? Should it be OK to
1568 add constexpr later like inline, rather than requiring
1569 declarations to match? */
1570 DECL_DECLARED_CONSTEXPR_P (fn
) = true;
1573 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn
)
1574 && DECL_DECLARED_CONSTEXPR_P (fn
))
1576 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
1577 error ("%qD cannot be declared as constexpr", fn
);
1578 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
1581 if (DECL_DELETED_FN (implicit_fn
))
1582 DECL_DELETED_FN (fn
) = 1;
1585 /* Returns true iff FN can be explicitly defaulted, and gives any
1586 errors if defaulting FN is ill-formed. */
1589 defaultable_fn_check (tree fn
)
1591 special_function_kind kind
= sfk_none
;
1593 if (DECL_CONSTRUCTOR_P (fn
))
1595 if (FUNCTION_FIRST_USER_PARMTYPE (fn
) == void_list_node
)
1596 kind
= sfk_constructor
;
1597 else if (copy_fn_p (fn
) > 0
1598 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn
))
1600 kind
= sfk_copy_constructor
;
1601 else if (move_fn_p (fn
))
1602 kind
= sfk_move_constructor
;
1604 else if (DECL_DESTRUCTOR_P (fn
))
1605 kind
= sfk_destructor
;
1606 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
1607 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
1610 kind
= sfk_copy_assignment
;
1611 else if (move_fn_p (fn
))
1612 kind
= sfk_move_assignment
;
1615 if (kind
== sfk_none
)
1617 error ("%qD cannot be defaulted", fn
);
1622 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
1623 for (; t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1624 if (TREE_PURPOSE (t
))
1626 error ("defaulted function %q+D with default argument", fn
);
1629 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn
)))
1631 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
)))
1632 error ("function %q+D defaulted on its first declaration "
1633 "must not have an exception-specification", fn
);
1634 if (DECL_VIRTUAL_P (fn
))
1635 error ("%qD declared virtual cannot be defaulted in the class "
1638 else if (!processing_template_decl
)
1639 defaulted_late_check (fn
);
1645 /* Add an implicit declaration to TYPE for the kind of function
1646 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1650 lazily_declare_fn (special_function_kind sfk
, tree type
)
1653 /* Whether or not the argument has a const reference type. */
1654 bool const_p
= false;
1658 case sfk_constructor
:
1659 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1661 case sfk_copy_constructor
:
1662 const_p
= TYPE_HAS_CONST_COPY_CTOR (type
);
1663 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1665 case sfk_move_constructor
:
1666 CLASSTYPE_LAZY_MOVE_CTOR (type
) = 0;
1668 case sfk_copy_assignment
:
1669 const_p
= TYPE_HAS_CONST_COPY_ASSIGN (type
);
1670 CLASSTYPE_LAZY_COPY_ASSIGN (type
) = 0;
1672 case sfk_move_assignment
:
1673 CLASSTYPE_LAZY_MOVE_ASSIGN (type
) = 0;
1675 case sfk_destructor
:
1676 CLASSTYPE_LAZY_DESTRUCTOR (type
) = 0;
1682 /* Declare the function. */
1683 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1685 /* For move variants, rather than declare them as deleted we just
1686 don't declare them at all. */
1687 if (DECL_DELETED_FN (fn
)
1688 && (sfk
== sfk_move_constructor
1689 || sfk
== sfk_move_assignment
))
1692 /* A destructor may be virtual. */
1693 if (sfk
== sfk_destructor
1694 || sfk
== sfk_move_assignment
1695 || sfk
== sfk_copy_assignment
)
1696 check_for_override (fn
, type
);
1697 /* Add it to CLASSTYPE_METHOD_VEC. */
1698 add_method (type
, fn
, NULL_TREE
);
1699 /* Add it to TYPE_METHODS. */
1700 if (sfk
== sfk_destructor
1701 && DECL_VIRTUAL_P (fn
)
1702 && abi_version_at_least (2))
1703 /* The ABI requires that a virtual destructor go at the end of the
1705 TYPE_METHODS (type
) = chainon (TYPE_METHODS (type
), fn
);
1708 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1709 TYPE_METHODS list, which cause the destructor to be emitted
1710 in an incorrect location in the vtable. */
1711 if (warn_abi
&& sfk
== sfk_destructor
&& DECL_VIRTUAL_P (fn
))
1712 warning (OPT_Wabi
, "vtable layout for class %qT may not be ABI-compliant"
1713 "and may change in a future version of GCC due to "
1714 "implicit virtual destructor",
1716 DECL_CHAIN (fn
) = TYPE_METHODS (type
);
1717 TYPE_METHODS (type
) = fn
;
1719 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1720 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
)
1721 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
))
1722 /* Create appropriate clones. */
1723 clone_function_decl (fn
, /*update_method_vec=*/true);
1728 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1729 as there are artificial parms in FN. */
1732 skip_artificial_parms_for (const_tree fn
, tree list
)
1734 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1735 list
= TREE_CHAIN (list
);
1739 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1740 list
= TREE_CHAIN (list
);
1741 if (DECL_HAS_VTT_PARM_P (fn
))
1742 list
= TREE_CHAIN (list
);
1746 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1747 artificial parms in FN. */
1750 num_artificial_parms_for (const_tree fn
)
1754 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1759 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1761 if (DECL_HAS_VTT_PARM_P (fn
))
1767 #include "gt-cp-method.h"