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"
39 #include "tree-pass.h"
40 #include "diagnostic.h"
44 /* Various flags to control the mangling process. */
50 /* The thing we are presently mangling is part of a template type,
51 rather than a fully instantiated type. Therefore, we may see
52 complex expressions where we would normally expect to see a
53 simple integer constant. */
54 mf_maybe_uninstantiated = 1,
55 /* When mangling a numeric value, use the form `_XX_' (instead of
56 just `XX') if the value has more than one digit. */
57 mf_use_underscores_around_value = 2
60 typedef enum mangling_flags mangling_flags;
62 static void do_build_assign_ref (tree);
63 static void do_build_copy_constructor (tree);
64 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
65 static tree make_alias_for_thunk (tree);
67 /* Called once to initialize method.c. */
75 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
76 indicates whether it is a this or result adjusting thunk.
77 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
78 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
79 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
80 adjusting thunks, we scale it to a byte offset. For covariant
81 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
82 the returned thunk with finish_thunk. */
85 make_thunk (tree function, bool this_adjusting,
86 tree fixed_offset, tree virtual_offset)
91 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
92 /* We can have this thunks to covariant thunks, but not vice versa. */
93 gcc_assert (!DECL_THIS_THUNK_P (function));
94 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
96 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
97 if (this_adjusting && virtual_offset)
99 = size_binop (MULT_EXPR,
102 TYPE_SIZE_UNIT (vtable_entry_type)));
104 d = tree_low_cst (fixed_offset, 0);
106 /* See if we already have the thunk in question. For this_adjusting
107 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
109 for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
110 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
111 && THUNK_FIXED_OFFSET (thunk) == d
112 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
115 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
117 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
120 /* All thunks must be created before FUNCTION is actually emitted;
121 the ABI requires that all thunks be emitted together with the
122 function to which they transfer control. */
123 gcc_assert (!TREE_ASM_WRITTEN (function));
124 /* Likewise, we can only be adding thunks to a function declared in
125 the class currently being laid out. */
126 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
127 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
129 thunk = build_decl (DECL_SOURCE_LOCATION (function),
130 FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
131 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
132 cxx_dup_lang_specific_decl (thunk);
133 DECL_THUNKS (thunk) = NULL_TREE;
135 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
136 TREE_READONLY (thunk) = TREE_READONLY (function);
137 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
138 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
139 SET_DECL_THUNK_P (thunk, this_adjusting);
140 THUNK_TARGET (thunk) = function;
141 THUNK_FIXED_OFFSET (thunk) = d;
142 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
143 THUNK_ALIAS (thunk) = NULL_TREE;
145 /* The thunk itself is not a constructor or destructor, even if
146 the thing it is thunking to is. */
147 DECL_INTERFACE_KNOWN (thunk) = 1;
148 DECL_NOT_REALLY_EXTERN (thunk) = 1;
149 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
150 DECL_DESTRUCTOR_P (thunk) = 0;
151 DECL_CONSTRUCTOR_P (thunk) = 0;
152 DECL_EXTERNAL (thunk) = 1;
153 DECL_ARTIFICIAL (thunk) = 1;
154 /* The THUNK is not a pending inline, even if the FUNCTION is. */
155 DECL_PENDING_INLINE_P (thunk) = 0;
156 DECL_DECLARED_INLINE_P (thunk) = 0;
157 /* Nor is it a template instantiation. */
158 DECL_USE_TEMPLATE (thunk) = 0;
159 DECL_TEMPLATE_INFO (thunk) = NULL;
161 /* Add it to the list of thunks associated with FUNCTION. */
162 TREE_CHAIN (thunk) = DECL_THUNKS (function);
163 DECL_THUNKS (function) = thunk;
168 /* Finish THUNK, a thunk decl. */
171 finish_thunk (tree thunk)
174 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
175 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
177 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
178 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
179 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
180 function = THUNK_TARGET (thunk);
181 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
182 fixed_offset, virtual_offset);
184 /* We can end up with declarations of (logically) different
185 covariant thunks, that do identical adjustments. The two thunks
186 will be adjusting between within different hierarchies, which
187 happen to have the same layout. We must nullify one of them to
188 refer to the other. */
189 if (DECL_RESULT_THUNK_P (thunk))
193 for (cov_probe = DECL_THUNKS (function);
194 cov_probe; cov_probe = TREE_CHAIN (cov_probe))
195 if (DECL_NAME (cov_probe) == name)
197 gcc_assert (!DECL_THUNKS (thunk));
198 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
199 ? THUNK_ALIAS (cov_probe) : cov_probe);
204 DECL_NAME (thunk) = name;
205 SET_DECL_ASSEMBLER_NAME (thunk, name);
208 static GTY (()) int thunk_labelno;
210 /* Create a static alias to function. */
213 make_alias_for (tree function, tree newid)
215 tree alias = build_decl (DECL_SOURCE_LOCATION (function),
216 FUNCTION_DECL, newid, TREE_TYPE (function));
217 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
218 cxx_dup_lang_specific_decl (alias);
219 DECL_CONTEXT (alias) = NULL;
220 TREE_READONLY (alias) = TREE_READONLY (function);
221 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
222 TREE_PUBLIC (alias) = 0;
223 DECL_INTERFACE_KNOWN (alias) = 1;
224 DECL_NOT_REALLY_EXTERN (alias) = 1;
225 DECL_THIS_STATIC (alias) = 1;
226 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
227 DECL_DESTRUCTOR_P (alias) = 0;
228 DECL_CONSTRUCTOR_P (alias) = 0;
229 DECL_EXTERNAL (alias) = 0;
230 DECL_ARTIFICIAL (alias) = 1;
231 DECL_PENDING_INLINE_P (alias) = 0;
232 DECL_DECLARED_INLINE_P (alias) = 0;
233 DECL_USE_TEMPLATE (alias) = 0;
234 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
235 DECL_TEMPLATE_INFO (alias) = NULL;
236 DECL_INITIAL (alias) = error_mark_node;
237 TREE_ADDRESSABLE (alias) = 1;
238 TREE_USED (alias) = 1;
239 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
240 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
245 make_alias_for_thunk (tree function)
250 ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
253 alias = make_alias_for (function, get_identifier (buf));
255 if (!flag_syntax_only)
257 bool ok = cgraph_same_body_alias (alias, function);
258 DECL_ASSEMBLER_NAME (function);
265 /* Emit the definition of a C++ multiple inheritance or covariant
266 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
270 use_thunk (tree thunk_fndecl, bool emit_p)
272 tree a, t, function, alias;
274 HOST_WIDE_INT fixed_offset, virtual_value;
275 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
277 /* We should have called finish_thunk to give it a name. */
278 gcc_assert (DECL_NAME (thunk_fndecl));
280 /* We should never be using an alias, always refer to the
282 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
284 if (TREE_ASM_WRITTEN (thunk_fndecl))
287 function = THUNK_TARGET (thunk_fndecl);
288 if (DECL_RESULT (thunk_fndecl))
289 /* We already turned this thunk into an ordinary function.
290 There's no need to process this thunk again. */
293 if (DECL_THUNK_P (function))
294 /* The target is itself a thunk, process it now. */
295 use_thunk (function, emit_p);
297 /* Thunks are always addressable; they only appear in vtables. */
298 TREE_ADDRESSABLE (thunk_fndecl) = 1;
300 /* Figure out what function is being thunked to. It's referenced in
301 this translation unit. */
302 TREE_ADDRESSABLE (function) = 1;
303 mark_used (function);
307 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
308 alias = make_alias_for_thunk (function);
312 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
313 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
318 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
319 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
320 gcc_assert (virtual_value);
325 /* And, if we need to emit the thunk, it's used. */
326 mark_used (thunk_fndecl);
327 /* This thunk is actually defined. */
328 DECL_EXTERNAL (thunk_fndecl) = 0;
329 /* The linkage of the function may have changed. FIXME in linkage
331 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
332 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
333 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
334 = DECL_VISIBILITY_SPECIFIED (function);
335 if (DECL_ONE_ONLY (function) || DECL_WEAK (function))
336 make_decl_one_only (thunk_fndecl, cxx_comdat_group (thunk_fndecl));
338 if (flag_syntax_only)
340 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
344 push_to_top_level ();
346 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
347 && targetm.have_named_sections)
349 resolve_unique_section (function, 0, flag_function_sections);
351 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
353 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
355 /* Output the thunk into the same section as function. */
356 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
360 /* Set up cloned argument trees for the thunk. */
362 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
364 tree x = copy_node (a);
366 DECL_CONTEXT (x) = thunk_fndecl;
367 SET_DECL_RTL (x, NULL_RTX);
368 DECL_HAS_VALUE_EXPR_P (x) = 0;
372 DECL_ARGUMENTS (thunk_fndecl) = a;
373 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
374 cgraph_add_thunk (thunk_fndecl, function,
375 this_adjusting, fixed_offset, virtual_value,
376 virtual_offset, alias);
379 || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
380 virtual_value, alias))
382 /* If this is a covariant thunk, or we don't have the necessary
383 code for efficient thunks, generate a thunk function that
384 just makes a call to the real function. Unfortunately, this
385 doesn't work for varargs. */
387 if (varargs_function_p (function))
388 error ("generic thunk code fails for method %q#D which uses %<...%>",
392 pop_from_top_level ();
395 /* Code for synthesizing methods which have default semantics defined. */
397 /* Generate code for default X(X&) or X(X&&) constructor. */
400 do_build_copy_constructor (tree fndecl)
402 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
403 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
405 parm = convert_from_reference (parm);
407 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
408 && is_empty_class (current_class_type))
409 /* Don't copy the padding byte; it might not have been allocated
410 if *this is a base subobject. */;
411 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
413 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
414 finish_expr_stmt (t);
418 tree fields = TYPE_FIELDS (current_class_type);
419 tree member_init_list = NULL_TREE;
420 int cvquals = cp_type_quals (TREE_TYPE (parm));
422 tree binfo, base_binfo;
424 VEC(tree,gc) *vbases;
426 /* Initialize all the base-classes with the parameter converted
427 to their type so that we get their copy constructor and not
428 another constructor that takes current_class_type. We must
429 deal with the binfo's directly as a direct base might be
430 inaccessible due to ambiguity. */
431 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
432 VEC_iterate (tree, vbases, i, binfo); i++)
434 init = build_base_path (PLUS_EXPR, parm, binfo, 1);
439 build_tree_list (NULL_TREE, init),
443 for (binfo = TYPE_BINFO (current_class_type), i = 0;
444 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
446 if (BINFO_VIRTUAL_P (base_binfo))
449 init = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
453 = tree_cons (base_binfo,
454 build_tree_list (NULL_TREE, init),
458 for (; fields; fields = TREE_CHAIN (fields))
463 if (TREE_CODE (field) != FIELD_DECL)
466 expr_type = TREE_TYPE (field);
467 if (DECL_NAME (field))
469 if (VFIELD_NAME_P (DECL_NAME (field)))
472 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
473 /* Just use the field; anonymous types can't have
474 nontrivial copy ctors or assignment ops. */;
478 /* Compute the type of "init->field". If the copy-constructor
479 parameter is, for example, "const S&", and the type of
480 the field is "T", then the type will usually be "const
481 T". (There are no cv-qualified variants of reference
483 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
487 if (DECL_MUTABLE_P (field))
488 quals &= ~TYPE_QUAL_CONST;
489 quals |= TYPE_QUALS (expr_type);
490 expr_type = cp_build_qualified_type (expr_type, quals);
493 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
494 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
496 init = build_tree_list (NULL_TREE, init);
498 member_init_list = tree_cons (field, init, member_init_list);
500 finish_mem_initializers (member_init_list);
505 do_build_assign_ref (tree fndecl)
507 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
510 compound_stmt = begin_compound_stmt (0);
511 parm = convert_from_reference (parm);
513 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
514 && is_empty_class (current_class_type))
515 /* Don't copy the padding byte; it might not have been allocated
516 if *this is a base subobject. */;
517 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
519 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
520 finish_expr_stmt (t);
525 int cvquals = cp_type_quals (TREE_TYPE (parm));
527 tree binfo, base_binfo;
529 /* Assign to each of the direct base classes. */
530 for (binfo = TYPE_BINFO (current_class_type), i = 0;
531 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
534 VEC(tree,gc) *parmvec;
536 /* We must convert PARM directly to the base class
537 explicitly since the base class may be ambiguous. */
538 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
539 /* Call the base class assignment operator. */
540 parmvec = make_tree_vector_single (converted_parm);
542 (build_special_member_call (current_class_ref,
543 ansi_assopname (NOP_EXPR),
546 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
547 tf_warning_or_error));
548 release_tree_vector (parmvec);
551 /* Assign to each of the non-static data members. */
552 for (fields = TYPE_FIELDS (current_class_type);
554 fields = TREE_CHAIN (fields))
556 tree comp = current_class_ref;
562 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
565 expr_type = TREE_TYPE (field);
567 if (CP_TYPE_CONST_P (expr_type))
569 error ("non-static const member %q#D, can't use default "
570 "assignment operator", field);
573 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
575 error ("non-static reference member %q#D, can't use "
576 "default assignment operator", field);
580 if (DECL_NAME (field))
582 if (VFIELD_NAME_P (DECL_NAME (field)))
585 else if (ANON_AGGR_TYPE_P (expr_type)
586 && TYPE_FIELDS (expr_type) != NULL_TREE)
587 /* Just use the field; anonymous types can't have
588 nontrivial copy ctors or assignment ops. */;
592 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
594 /* Compute the type of init->field */
596 if (DECL_MUTABLE_P (field))
597 quals &= ~TYPE_QUAL_CONST;
598 expr_type = cp_build_qualified_type (expr_type, quals);
600 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
602 if (DECL_NAME (field))
603 init = cp_build_modify_expr (comp, NOP_EXPR, init,
604 tf_warning_or_error);
606 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
607 finish_expr_stmt (init);
610 finish_return_stmt (current_class_ref);
611 finish_compound_stmt (compound_stmt);
614 /* Synthesize FNDECL, a non-static member function. */
617 synthesize_method (tree fndecl)
619 bool nested = (current_function_decl != NULL_TREE);
620 tree context = decl_function_context (fndecl);
621 bool need_body = true;
623 location_t save_input_location = input_location;
624 int error_count = errorcount;
625 int warning_count = warningcount;
627 /* Reset the source location, we might have been previously
628 deferred, and thus have saved where we were first needed. */
629 DECL_SOURCE_LOCATION (fndecl)
630 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
632 /* If we've been asked to synthesize a clone, just synthesize the
633 cloned function instead. Doing so will automatically fill in the
634 body for the clone. */
635 if (DECL_CLONED_FUNCTION_P (fndecl))
636 fndecl = DECL_CLONED_FUNCTION (fndecl);
638 /* We may be in the middle of deferred access check. Disable
640 push_deferring_access_checks (dk_no_deferred);
643 push_to_top_level ();
645 push_function_context ();
647 input_location = DECL_SOURCE_LOCATION (fndecl);
649 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
650 stmt = begin_function_body ();
652 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
654 do_build_assign_ref (fndecl);
657 else if (DECL_CONSTRUCTOR_P (fndecl))
659 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
660 if (arg_chain != void_list_node)
661 do_build_copy_constructor (fndecl);
663 finish_mem_initializers (NULL_TREE);
666 /* If we haven't yet generated the body of the function, just
667 generate an empty compound statement. */
671 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
672 finish_compound_stmt (compound_stmt);
675 finish_function_body (stmt);
676 expand_or_defer_fn (finish_function (0));
678 input_location = save_input_location;
681 pop_from_top_level ();
683 pop_function_context ();
685 pop_deferring_access_checks ();
687 if (error_count != errorcount || warning_count != warningcount)
688 inform (input_location, "synthesized method %qD first required here ",
692 /* Use EXTRACTOR to locate the relevant function called for each base &
693 class field of TYPE. CLIENT allows additional information to be passed
694 to EXTRACTOR. Generates the union of all exceptions generated by those
695 functions. Note that we haven't updated TYPE_FIELDS and such of any
696 variants yet, so we need to look at the main one. */
699 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
702 tree raises = empty_except_spec;
703 tree fields = TYPE_FIELDS (type);
704 tree binfo, base_binfo;
707 for (binfo = TYPE_BINFO (type), i = 0;
708 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
710 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
713 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
715 raises = merge_exception_specifiers (raises, fn_raises);
718 for (; fields; fields = TREE_CHAIN (fields))
720 tree type = TREE_TYPE (fields);
723 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
725 while (TREE_CODE (type) == ARRAY_TYPE)
726 type = TREE_TYPE (type);
727 if (!CLASS_TYPE_P (type))
730 fn = (*extractor) (type, client);
733 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
735 raises = merge_exception_specifiers (raises, fn_raises);
741 /* Locate the dtor of TYPE. */
744 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
746 return CLASSTYPE_DESTRUCTORS (type);
749 /* Locate the default ctor of TYPE. */
752 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
756 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
759 /* Call lookup_fnfields_1 to create the constructor declarations, if
761 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
762 return lazily_declare_fn (sfk_constructor, type);
764 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
766 tree fn = OVL_CURRENT (fns);
767 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
769 parms = skip_artificial_parms_for (fn, parms);
771 if (sufficient_parms_p (parms))
783 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
784 points to a COPY_DATA holding the name (NULL for the ctor)
785 and desired qualifiers of the source operand. */
788 locate_copy (tree type, void *client_)
790 struct copy_data *client = (struct copy_data *)client_;
792 tree best = NULL_TREE;
793 bool excess_p = false;
798 ix = lookup_fnfields_1 (type, client->name);
801 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
803 else if (TYPE_HAS_INIT_REF (type))
805 /* If construction of the copy constructor was postponed, create
807 if (CLASSTYPE_LAZY_COPY_CTOR (type))
808 lazily_declare_fn (sfk_copy_constructor, type);
809 if (CLASSTYPE_LAZY_MOVE_CTOR (type))
810 lazily_declare_fn (sfk_move_constructor, type);
811 fns = CLASSTYPE_CONSTRUCTORS (type);
815 for (; fns; fns = OVL_NEXT (fns))
817 tree fn = OVL_CURRENT (fns);
818 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
823 parms = skip_artificial_parms_for (fn, parms);
826 src_type = non_reference (TREE_VALUE (parms));
828 if (src_type == error_mark_node)
831 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
833 if (!sufficient_parms_p (TREE_CHAIN (parms)))
835 quals = cp_type_quals (src_type);
836 if (client->quals & ~quals)
838 excess = quals & ~client->quals;
839 if (!best || (excess_p && !excess))
851 /* Implicitly declare the special function indicated by KIND, as a
852 member of TYPE. For copy constructors and assignment operators,
853 CONST_P indicates whether these functions should take a const
854 reference argument or a non-const reference. Returns the
855 FUNCTION_DECL for the implicitly declared function. */
858 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
861 tree parameter_types = void_list_node;
864 tree raises = empty_except_spec;
865 tree rhs_parm_type = NULL_TREE;
868 HOST_WIDE_INT saved_processing_template_decl;
870 /* Because we create declarations for implicitly declared functions
871 lazily, we may be creating the declaration for a member of TYPE
872 while in some completely different context. However, TYPE will
873 never be a dependent class (because we never want to do lookups
874 for implicitly defined functions in a dependent class).
875 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
876 because we only create clones for constructors and destructors
877 when not in a template. */
878 gcc_assert (!dependent_type_p (type));
879 saved_processing_template_decl = processing_template_decl;
880 processing_template_decl = 0;
882 type = TYPE_MAIN_VARIANT (type);
884 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
886 if (kind == sfk_destructor)
887 /* See comment in check_special_function_return_type. */
888 return_type = build_pointer_type (void_type_node);
890 return_type = build_pointer_type (type);
893 return_type = void_type_node;
899 name = constructor_name (type);
900 raises = synthesize_exception_spec (type, &locate_dtor, 0);
903 case sfk_constructor:
904 /* Default constructor. */
905 name = constructor_name (type);
906 raises = synthesize_exception_spec (type, &locate_ctor, 0);
909 case sfk_copy_constructor:
910 case sfk_assignment_operator:
911 case sfk_move_constructor:
913 struct copy_data data;
917 if (kind == sfk_assignment_operator)
919 return_type = build_reference_type (type);
920 name = ansi_assopname (NOP_EXPR);
924 name = constructor_name (type);
928 data.quals = TYPE_QUAL_CONST;
929 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
932 rhs_parm_type = type;
934 = cp_build_reference_type (rhs_parm_type,
935 kind == sfk_move_constructor);
936 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
937 raises = synthesize_exception_spec (type, &locate_copy, &data);
944 /* Create the function. */
945 fn_type = build_method_type_directly (type, return_type, parameter_types);
947 fn_type = build_exception_variant (fn_type, raises);
948 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
949 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
950 if (kind == sfk_constructor || kind == sfk_copy_constructor
951 || kind == sfk_move_constructor)
952 DECL_CONSTRUCTOR_P (fn) = 1;
953 else if (kind == sfk_destructor)
954 DECL_DESTRUCTOR_P (fn) = 1;
957 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
958 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
961 /* If pointers to member functions use the least significant bit to
962 indicate whether a function is virtual, ensure a pointer
963 to this function will have that bit clear. */
964 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
965 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
966 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
968 /* Create the explicit arguments. */
971 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
972 want its type to be included in the mangled function
974 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
975 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
977 /* Add the "this" parameter. */
978 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
979 TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
980 DECL_ARGUMENTS (fn) = this_parm;
982 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
983 set_linkage_according_to_type (type, fn);
984 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
985 DECL_IN_AGGR_P (fn) = 1;
986 DECL_ARTIFICIAL (fn) = 1;
987 DECL_DEFAULTED_FN (fn) = 1;
988 DECL_NOT_REALLY_EXTERN (fn) = 1;
989 DECL_DECLARED_INLINE_P (fn) = 1;
990 gcc_assert (!TREE_USED (fn));
992 /* Restore PROCESSING_TEMPLATE_DECL. */
993 processing_template_decl = saved_processing_template_decl;
998 /* Gives any errors about defaulted functions which need to be deferred
999 until the containing class is complete. */
1002 defaulted_late_check (tree fn)
1004 /* Complain about invalid signature for defaulted fn. */
1005 tree ctx = DECL_CONTEXT (fn);
1006 special_function_kind kind = special_function_p (fn);
1007 bool fn_const_p = (copy_fn_p (fn) == 2);
1008 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1010 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1011 TREE_TYPE (TREE_TYPE (implicit_fn)))
1012 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1013 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1015 error ("defaulted declaration %q+D", fn);
1016 error_at (DECL_SOURCE_LOCATION (fn),
1017 "does not match expected signature %qD", implicit_fn);
1021 /* Returns true iff FN can be explicitly defaulted, and gives any
1022 errors if defaulting FN is ill-formed. */
1025 defaultable_fn_check (tree fn)
1027 special_function_kind kind = sfk_none;
1029 if (DECL_CONSTRUCTOR_P (fn))
1031 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1032 kind = sfk_constructor;
1033 else if (copy_fn_p (fn) > 0
1034 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1036 kind = sfk_copy_constructor;
1037 else if (move_fn_p (fn))
1038 kind = sfk_move_constructor;
1040 else if (DECL_DESTRUCTOR_P (fn))
1041 kind = sfk_destructor;
1042 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1043 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
1045 kind = sfk_assignment_operator;
1047 if (kind == sfk_none)
1049 error ("%qD cannot be defaulted", fn);
1054 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1055 for (; t && t != void_list_node; t = TREE_CHAIN (t))
1056 if (TREE_PURPOSE (t))
1058 error ("defaulted function %q+D with default argument", fn);
1061 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1063 if (DECL_NONCONVERTING_P (fn))
1064 error ("%qD declared explicit cannot be defaulted in the class "
1066 if (current_access_specifier != access_public_node)
1067 error ("%qD declared with non-public access cannot be defaulted "
1068 "in the class body", fn);
1069 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
1070 error ("function %q+D defaulted on its first declaration "
1071 "must not have an exception-specification", fn);
1073 else if (!processing_template_decl)
1074 defaulted_late_check (fn);
1080 /* Add an implicit declaration to TYPE for the kind of function
1081 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1085 lazily_declare_fn (special_function_kind sfk, tree type)
1090 /* Figure out whether or not the argument has a const reference
1092 if (sfk == sfk_copy_constructor)
1093 const_p = TYPE_HAS_CONST_INIT_REF (type);
1094 else if (sfk == sfk_assignment_operator)
1095 const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1097 /* In this case, CONST_P will be ignored. */
1099 /* Declare the function. */
1100 fn = implicitly_declare_fn (sfk, type, const_p);
1101 /* A destructor may be virtual. */
1102 if (sfk == sfk_destructor)
1103 check_for_override (fn, type);
1104 /* Add it to CLASSTYPE_METHOD_VEC. */
1105 add_method (type, fn, NULL_TREE);
1106 /* Add it to TYPE_METHODS. */
1107 if (sfk == sfk_destructor
1108 && DECL_VIRTUAL_P (fn)
1109 && abi_version_at_least (2))
1110 /* The ABI requires that a virtual destructor go at the end of the
1112 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1115 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1116 TYPE_METHODS list, which cause the destructor to be emitted
1117 in an incorrect location in the vtable. */
1118 if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1119 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1120 "and may change in a future version of GCC due to "
1121 "implicit virtual destructor",
1123 TREE_CHAIN (fn) = TYPE_METHODS (type);
1124 TYPE_METHODS (type) = fn;
1126 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1127 if (sfk == sfk_assignment_operator)
1128 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1131 /* Remember that the function has been created. */
1132 if (sfk == sfk_constructor)
1133 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1134 else if (sfk == sfk_copy_constructor)
1135 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1136 else if (sfk == sfk_move_constructor)
1137 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1138 else if (sfk == sfk_destructor)
1139 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1140 /* Create appropriate clones. */
1141 clone_function_decl (fn, /*update_method_vec=*/true);
1147 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1148 as there are artificial parms in FN. */
1151 skip_artificial_parms_for (const_tree fn, tree list)
1153 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1154 list = TREE_CHAIN (list);
1158 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1159 list = TREE_CHAIN (list);
1160 if (DECL_HAS_VTT_PARM_P (fn))
1161 list = TREE_CHAIN (list);
1165 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1166 artificial parms in FN. */
1169 num_artificial_parms_for (const_tree fn)
1173 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1178 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1180 if (DECL_HAS_VTT_PARM_P (fn))
1186 #include "gt-cp-method.h"