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 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
39 #include "tree-pass.h"
40 #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 tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
61 static void do_build_assign_ref (tree);
62 static void do_build_copy_constructor (tree);
63 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
64 static tree locate_dtor (tree, void *);
65 static tree locate_ctor (tree, void *);
66 static tree locate_copy (tree, void *);
67 static tree make_alias_for_thunk (tree);
69 /* Called once to initialize method.c. */
77 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
78 indicates whether it is a this or result adjusting thunk.
79 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
80 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
81 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
82 adjusting thunks, we scale it to a byte offset. For covariant
83 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
84 the returned thunk with finish_thunk. */
87 make_thunk (tree function, bool this_adjusting,
88 tree fixed_offset, tree virtual_offset)
93 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
94 /* We can have this thunks to covariant thunks, but not vice versa. */
95 gcc_assert (!DECL_THIS_THUNK_P (function));
96 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
98 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
99 if (this_adjusting && virtual_offset)
101 = size_binop (MULT_EXPR,
104 TYPE_SIZE_UNIT (vtable_entry_type)));
106 d = tree_low_cst (fixed_offset, 0);
108 /* See if we already have the thunk in question. For this_adjusting
109 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
111 for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
112 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
113 && THUNK_FIXED_OFFSET (thunk) == d
114 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
117 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
119 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
122 /* All thunks must be created before FUNCTION is actually emitted;
123 the ABI requires that all thunks be emitted together with the
124 function to which they transfer control. */
125 gcc_assert (!TREE_ASM_WRITTEN (function));
126 /* Likewise, we can only be adding thunks to a function declared in
127 the class currently being laid out. */
128 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
129 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
131 thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
132 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
133 cxx_dup_lang_specific_decl (thunk);
134 DECL_THUNKS (thunk) = NULL_TREE;
136 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
137 TREE_READONLY (thunk) = TREE_READONLY (function);
138 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
139 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
140 SET_DECL_THUNK_P (thunk, this_adjusting);
141 THUNK_TARGET (thunk) = function;
142 THUNK_FIXED_OFFSET (thunk) = d;
143 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
144 THUNK_ALIAS (thunk) = NULL_TREE;
146 /* The thunk itself is not a constructor or destructor, even if
147 the thing it is thunking to is. */
148 DECL_INTERFACE_KNOWN (thunk) = 1;
149 DECL_NOT_REALLY_EXTERN (thunk) = 1;
150 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
151 DECL_DESTRUCTOR_P (thunk) = 0;
152 DECL_CONSTRUCTOR_P (thunk) = 0;
153 DECL_EXTERNAL (thunk) = 1;
154 DECL_ARTIFICIAL (thunk) = 1;
155 /* Even if this thunk is a member of a local class, we don't
156 need a static chain. */
157 DECL_NO_STATIC_CHAIN (thunk) = 1;
158 /* The THUNK is not a pending inline, even if the FUNCTION is. */
159 DECL_PENDING_INLINE_P (thunk) = 0;
160 DECL_INLINE (thunk) = 0;
161 DECL_DECLARED_INLINE_P (thunk) = 0;
162 /* Nor has it been deferred. */
163 DECL_DEFERRED_FN (thunk) = 0;
164 /* Nor is it a template instantiation. */
165 DECL_USE_TEMPLATE (thunk) = 0;
166 DECL_TEMPLATE_INFO (thunk) = NULL;
168 /* Add it to the list of thunks associated with FUNCTION. */
169 TREE_CHAIN (thunk) = DECL_THUNKS (function);
170 DECL_THUNKS (function) = thunk;
175 /* Finish THUNK, a thunk decl. */
178 finish_thunk (tree thunk)
181 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
182 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
184 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
185 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
186 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
187 function = THUNK_TARGET (thunk);
188 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
189 fixed_offset, virtual_offset);
191 /* We can end up with declarations of (logically) different
192 covariant thunks, that do identical adjustments. The two thunks
193 will be adjusting between within different hierarchies, which
194 happen to have the same layout. We must nullify one of them to
195 refer to the other. */
196 if (DECL_RESULT_THUNK_P (thunk))
200 for (cov_probe = DECL_THUNKS (function);
201 cov_probe; cov_probe = TREE_CHAIN (cov_probe))
202 if (DECL_NAME (cov_probe) == name)
204 gcc_assert (!DECL_THUNKS (thunk));
205 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
206 ? THUNK_ALIAS (cov_probe) : cov_probe);
211 DECL_NAME (thunk) = name;
212 SET_DECL_ASSEMBLER_NAME (thunk, name);
215 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
216 offset indicated by VIRTUAL_OFFSET, if that is
217 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
218 zero for a result adjusting thunk. */
221 thunk_adjust (tree ptr, bool this_adjusting,
222 HOST_WIDE_INT fixed_offset, tree virtual_offset)
225 /* Adjust the pointer by the constant. */
226 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
227 ssize_int (fixed_offset));
229 /* If there's a virtual offset, look up that value in the vtable and
230 adjust the pointer again. */
235 ptr = save_expr (ptr);
236 /* The vptr is always at offset zero in the object. */
237 vtable = build1 (NOP_EXPR,
238 build_pointer_type (build_pointer_type
239 (vtable_entry_type)),
241 /* Form the vtable address. */
242 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
243 /* Find the entry with the vcall offset. */
244 vtable = build2 (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
245 /* Get the offset itself. */
246 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
247 /* Adjust the `this' pointer. */
248 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable);
252 /* Adjust the pointer by the constant. */
253 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
254 ssize_int (fixed_offset));
259 static GTY (()) int thunk_labelno;
261 /* Create a static alias to function. */
264 make_alias_for (tree function, tree newid)
266 tree alias = build_decl (FUNCTION_DECL, newid, TREE_TYPE (function));
267 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
268 cxx_dup_lang_specific_decl (alias);
269 DECL_CONTEXT (alias) = NULL;
270 TREE_READONLY (alias) = TREE_READONLY (function);
271 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
272 TREE_PUBLIC (alias) = 0;
273 DECL_INTERFACE_KNOWN (alias) = 1;
274 DECL_NOT_REALLY_EXTERN (alias) = 1;
275 DECL_THIS_STATIC (alias) = 1;
276 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
277 DECL_DESTRUCTOR_P (alias) = 0;
278 DECL_CONSTRUCTOR_P (alias) = 0;
279 DECL_CLONED_FUNCTION (alias) = NULL_TREE;
280 DECL_EXTERNAL (alias) = 0;
281 DECL_ARTIFICIAL (alias) = 1;
282 DECL_NO_STATIC_CHAIN (alias) = 1;
283 DECL_PENDING_INLINE_P (alias) = 0;
284 DECL_INLINE (alias) = 0;
285 DECL_DECLARED_INLINE_P (alias) = 0;
286 DECL_DEFERRED_FN (alias) = 0;
287 DECL_USE_TEMPLATE (alias) = 0;
288 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
289 DECL_TEMPLATE_INFO (alias) = NULL;
290 DECL_INITIAL (alias) = error_mark_node;
291 TREE_ADDRESSABLE (alias) = 1;
292 TREE_USED (alias) = 1;
293 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
294 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
299 make_alias_for_thunk (tree function)
304 ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
307 alias = make_alias_for (function, get_identifier (buf));
309 if (!flag_syntax_only)
310 assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
315 /* Emit the definition of a C++ multiple inheritance or covariant
316 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
320 use_thunk (tree thunk_fndecl, bool emit_p)
322 tree a, t, function, alias;
324 HOST_WIDE_INT fixed_offset, virtual_value;
325 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
327 /* We should have called finish_thunk to give it a name. */
328 gcc_assert (DECL_NAME (thunk_fndecl));
330 /* We should never be using an alias, always refer to the
332 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
334 if (TREE_ASM_WRITTEN (thunk_fndecl))
337 function = THUNK_TARGET (thunk_fndecl);
338 if (DECL_RESULT (thunk_fndecl))
339 /* We already turned this thunk into an ordinary function.
340 There's no need to process this thunk again. */
343 if (DECL_THUNK_P (function))
344 /* The target is itself a thunk, process it now. */
345 use_thunk (function, emit_p);
347 /* Thunks are always addressable; they only appear in vtables. */
348 TREE_ADDRESSABLE (thunk_fndecl) = 1;
350 /* Figure out what function is being thunked to. It's referenced in
351 this translation unit. */
352 TREE_ADDRESSABLE (function) = 1;
353 mark_used (function);
357 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
358 alias = make_alias_for_thunk (function);
362 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
363 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
368 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
369 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
370 gcc_assert (virtual_value);
375 /* And, if we need to emit the thunk, it's used. */
376 mark_used (thunk_fndecl);
377 /* This thunk is actually defined. */
378 DECL_EXTERNAL (thunk_fndecl) = 0;
379 /* The linkage of the function may have changed. FIXME in linkage
381 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
382 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
383 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
384 = DECL_VISIBILITY_SPECIFIED (function);
385 if (DECL_ONE_ONLY (function))
386 make_decl_one_only (thunk_fndecl);
388 if (flag_syntax_only)
390 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
394 push_to_top_level ();
396 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
397 && targetm.have_named_sections)
399 resolve_unique_section (function, 0, flag_function_sections);
401 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
403 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
405 /* Output the thunk into the same section as function. */
406 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
410 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
412 DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
414 /* Set up cloned argument trees for the thunk. */
416 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
418 tree x = copy_node (a);
420 DECL_CONTEXT (x) = thunk_fndecl;
421 SET_DECL_RTL (x, NULL_RTX);
425 DECL_ARGUMENTS (thunk_fndecl) = a;
426 BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a;
429 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
430 virtual_value, alias))
433 current_function_decl = thunk_fndecl;
434 DECL_RESULT (thunk_fndecl)
435 = build_decl (RESULT_DECL, 0, integer_type_node);
436 fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
437 init_function_start (thunk_fndecl);
438 current_function_is_thunk = 1;
439 assemble_start_function (thunk_fndecl, fnname);
441 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
442 fixed_offset, virtual_value, alias);
444 assemble_end_function (thunk_fndecl, fnname);
445 init_insn_lengths ();
446 current_function_decl = 0;
448 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
452 /* If this is a covariant thunk, or we don't have the necessary
453 code for efficient thunks, generate a thunk function that
454 just makes a call to the real function. Unfortunately, this
455 doesn't work for varargs. */
457 if (varargs_function_p (function))
458 error ("generic thunk code fails for method %q#D which uses %<...%>",
461 DECL_RESULT (thunk_fndecl) = NULL_TREE;
463 start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
464 /* We don't bother with a body block for thunks. */
466 /* There's no need to check accessibility inside the thunk body. */
467 push_deferring_access_checks (dk_no_check);
471 t = thunk_adjust (t, /*this_adjusting=*/1,
472 fixed_offset, virtual_offset);
474 /* Build up the call to the real function. */
475 t = tree_cons (NULL_TREE, t, NULL_TREE);
476 for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
477 t = tree_cons (NULL_TREE, a, t);
479 t = build_call (alias, t);
480 CALL_FROM_THUNK_P (t) = 1;
482 if (VOID_TYPE_P (TREE_TYPE (t)))
483 finish_expr_stmt (t);
488 tree cond = NULL_TREE;
490 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
492 /* If the return type is a pointer, we need to
493 protect against NULL. We know there will be an
494 adjustment, because that's why we're emitting a
497 cond = cp_convert (boolean_type_node, t);
500 t = thunk_adjust (t, /*this_adjusting=*/0,
501 fixed_offset, virtual_offset);
503 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
504 cp_convert (TREE_TYPE (t), integer_zero_node));
506 if (IS_AGGR_TYPE (TREE_TYPE (t)))
507 t = build_cplus_new (TREE_TYPE (t), t);
508 finish_return_stmt (t);
511 /* Since we want to emit the thunk, we explicitly mark its name as
513 mark_decl_referenced (thunk_fndecl);
515 /* But we don't want debugging information about it. */
516 DECL_IGNORED_P (thunk_fndecl) = 1;
518 /* Re-enable access control. */
519 pop_deferring_access_checks ();
521 thunk_fndecl = finish_function (0);
522 tree_lowering_passes (thunk_fndecl);
523 expand_body (thunk_fndecl);
526 pop_from_top_level ();
529 /* Code for synthesizing methods which have default semantics defined. */
531 /* Generate code for default X(X&) constructor. */
534 do_build_copy_constructor (tree fndecl)
536 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
538 parm = convert_from_reference (parm);
540 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
541 && is_empty_class (current_class_type))
542 /* Don't copy the padding byte; it might not have been allocated
543 if *this is a base subobject. */;
544 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
546 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
547 finish_expr_stmt (t);
551 tree fields = TYPE_FIELDS (current_class_type);
552 tree member_init_list = NULL_TREE;
553 int cvquals = cp_type_quals (TREE_TYPE (parm));
555 tree binfo, base_binfo;
556 VEC(tree,gc) *vbases;
558 /* Initialize all the base-classes with the parameter converted
559 to their type so that we get their copy constructor and not
560 another constructor that takes current_class_type. We must
561 deal with the binfo's directly as a direct base might be
562 inaccessible due to ambiguity. */
563 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
564 VEC_iterate (tree, vbases, i, binfo); i++)
568 build_tree_list (NULL_TREE,
569 build_base_path (PLUS_EXPR, parm,
574 for (binfo = TYPE_BINFO (current_class_type), i = 0;
575 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
577 if (BINFO_VIRTUAL_P (base_binfo))
581 = tree_cons (base_binfo,
582 build_tree_list (NULL_TREE,
583 build_base_path (PLUS_EXPR, parm,
588 for (; fields; fields = TREE_CHAIN (fields))
594 if (TREE_CODE (field) != FIELD_DECL)
597 expr_type = TREE_TYPE (field);
598 if (DECL_NAME (field))
600 if (VFIELD_NAME_P (DECL_NAME (field)))
603 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
604 /* Just use the field; anonymous types can't have
605 nontrivial copy ctors or assignment ops. */;
609 /* Compute the type of "init->field". If the copy-constructor
610 parameter is, for example, "const S&", and the type of
611 the field is "T", then the type will usually be "const
612 T". (There are no cv-qualified variants of reference
614 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
618 if (DECL_MUTABLE_P (field))
619 quals &= ~TYPE_QUAL_CONST;
620 expr_type = cp_build_qualified_type (expr_type, quals);
623 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
624 init = build_tree_list (NULL_TREE, init);
626 member_init_list = tree_cons (field, init, member_init_list);
628 finish_mem_initializers (member_init_list);
633 do_build_assign_ref (tree fndecl)
635 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
638 compound_stmt = begin_compound_stmt (0);
639 parm = convert_from_reference (parm);
641 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
642 && is_empty_class (current_class_type))
643 /* Don't copy the padding byte; it might not have been allocated
644 if *this is a base subobject. */;
645 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
647 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
648 finish_expr_stmt (t);
653 int cvquals = cp_type_quals (TREE_TYPE (parm));
655 tree binfo, base_binfo;
657 /* Assign to each of the direct base classes. */
658 for (binfo = TYPE_BINFO (current_class_type), i = 0;
659 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
663 /* We must convert PARM directly to the base class
664 explicitly since the base class may be ambiguous. */
665 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
666 /* Call the base class assignment operator. */
668 (build_special_member_call (current_class_ref,
669 ansi_assopname (NOP_EXPR),
670 build_tree_list (NULL_TREE,
673 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
676 /* Assign to each of the non-static data members. */
677 for (fields = TYPE_FIELDS (current_class_type);
679 fields = TREE_CHAIN (fields))
681 tree comp = current_class_ref;
687 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
690 expr_type = TREE_TYPE (field);
692 if (CP_TYPE_CONST_P (expr_type))
694 error ("non-static const member %q#D, can't use default "
695 "assignment operator", field);
698 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
700 error ("non-static reference member %q#D, can't use "
701 "default assignment operator", field);
705 if (DECL_NAME (field))
707 if (VFIELD_NAME_P (DECL_NAME (field)))
710 else if (ANON_AGGR_TYPE_P (expr_type)
711 && TYPE_FIELDS (expr_type) != NULL_TREE)
712 /* Just use the field; anonymous types can't have
713 nontrivial copy ctors or assignment ops. */;
717 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
719 /* Compute the type of init->field */
721 if (DECL_MUTABLE_P (field))
722 quals &= ~TYPE_QUAL_CONST;
723 expr_type = cp_build_qualified_type (expr_type, quals);
725 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
727 if (DECL_NAME (field))
728 init = build_modify_expr (comp, NOP_EXPR, init);
730 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
731 finish_expr_stmt (init);
734 finish_return_stmt (current_class_ref);
735 finish_compound_stmt (compound_stmt);
738 /* Synthesize FNDECL, a non-static member function. */
741 synthesize_method (tree fndecl)
743 bool nested = (current_function_decl != NULL_TREE);
744 tree context = decl_function_context (fndecl);
745 bool need_body = true;
747 location_t save_input_location = input_location;
748 int error_count = errorcount;
749 int warning_count = warningcount;
751 /* Reset the source location, we might have been previously
752 deferred, and thus have saved where we were first needed. */
753 DECL_SOURCE_LOCATION (fndecl)
754 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
756 /* If we've been asked to synthesize a clone, just synthesize the
757 cloned function instead. Doing so will automatically fill in the
758 body for the clone. */
759 if (DECL_CLONED_FUNCTION_P (fndecl))
760 fndecl = DECL_CLONED_FUNCTION (fndecl);
762 /* We may be in the middle of deferred access check. Disable
764 push_deferring_access_checks (dk_no_deferred);
767 push_to_top_level ();
769 push_function_context_to (context);
771 input_location = DECL_SOURCE_LOCATION (fndecl);
773 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
774 stmt = begin_function_body ();
776 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
778 do_build_assign_ref (fndecl);
781 else if (DECL_CONSTRUCTOR_P (fndecl))
783 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
784 if (arg_chain != void_list_node)
785 do_build_copy_constructor (fndecl);
786 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
787 finish_mem_initializers (NULL_TREE);
790 /* If we haven't yet generated the body of the function, just
791 generate an empty compound statement. */
795 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
796 finish_compound_stmt (compound_stmt);
799 finish_function_body (stmt);
800 expand_or_defer_fn (finish_function (0));
802 input_location = save_input_location;
805 pop_from_top_level ();
807 pop_function_context_from (context);
809 pop_deferring_access_checks ();
811 if (error_count != errorcount || warning_count != warningcount)
812 inform ("%Hsynthesized method %qD first required here ",
813 &input_location, fndecl);
816 /* Use EXTRACTOR to locate the relevant function called for each base &
817 class field of TYPE. CLIENT allows additional information to be passed
818 to EXTRACTOR. Generates the union of all exceptions generated by those
819 functions. Note that we haven't updated TYPE_FIELDS and such of any
820 variants yet, so we need to look at the main one. */
823 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
826 tree raises = empty_except_spec;
827 tree fields = TYPE_FIELDS (type);
828 tree binfo, base_binfo;
831 for (binfo = TYPE_BINFO (type), i = 0;
832 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
834 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
837 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
839 raises = merge_exception_specifiers (raises, fn_raises);
842 for (; fields; fields = TREE_CHAIN (fields))
844 tree type = TREE_TYPE (fields);
847 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
849 while (TREE_CODE (type) == ARRAY_TYPE)
850 type = TREE_TYPE (type);
851 if (!CLASS_TYPE_P (type))
854 fn = (*extractor) (type, client);
857 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
859 raises = merge_exception_specifiers (raises, fn_raises);
865 /* Locate the dtor of TYPE. */
868 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
870 return CLASSTYPE_DESTRUCTORS (type);
873 /* Locate the default ctor of TYPE. */
876 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
880 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
883 /* Call lookup_fnfields_1 to create the constructor declarations, if
885 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
886 return lazily_declare_fn (sfk_constructor, type);
888 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
890 tree fn = OVL_CURRENT (fns);
891 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
893 parms = skip_artificial_parms_for (fn, parms);
895 if (sufficient_parms_p (parms))
907 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
908 points to a COPY_DATA holding the name (NULL for the ctor)
909 and desired qualifiers of the source operand. */
912 locate_copy (tree type, void *client_)
914 struct copy_data *client = (struct copy_data *)client_;
916 tree best = NULL_TREE;
917 bool excess_p = false;
922 ix = lookup_fnfields_1 (type, client->name);
925 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
927 else if (TYPE_HAS_INIT_REF (type))
929 /* If construction of the copy constructor was postponed, create
931 if (CLASSTYPE_LAZY_COPY_CTOR (type))
932 lazily_declare_fn (sfk_copy_constructor, type);
933 fns = CLASSTYPE_CONSTRUCTORS (type);
937 for (; fns; fns = OVL_NEXT (fns))
939 tree fn = OVL_CURRENT (fns);
940 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
945 parms = skip_artificial_parms_for (fn, parms);
948 src_type = non_reference (TREE_VALUE (parms));
949 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
951 if (!sufficient_parms_p (TREE_CHAIN (parms)))
953 quals = cp_type_quals (src_type);
954 if (client->quals & ~quals)
956 excess = quals & ~client->quals;
957 if (!best || (excess_p && !excess))
969 /* Implicitly declare the special function indicated by KIND, as a
970 member of TYPE. For copy constructors and assignment operators,
971 CONST_P indicates whether these functions should take a const
972 reference argument or a non-const reference. Returns the
973 FUNCTION_DECL for the implicitly declared function. */
976 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
979 tree parameter_types = void_list_node;
982 tree raises = empty_except_spec;
983 tree rhs_parm_type = NULL_TREE;
986 HOST_WIDE_INT saved_processing_template_decl;
988 /* Because we create declarations for implicitly declared functions
989 lazily, we may be creating the declaration for a member of TYPE
990 while in some completely different context. However, TYPE will
991 never be a dependent class (because we never want to do lookups
992 for implicitly defined functions in a dependent class).
993 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
994 because we only create clones for constructors and destructors
995 when not in a template. */
996 gcc_assert (!dependent_type_p (type));
997 saved_processing_template_decl = processing_template_decl;
998 processing_template_decl = 0;
1000 type = TYPE_MAIN_VARIANT (type);
1002 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1004 if (kind == sfk_destructor)
1005 /* See comment in check_special_function_return_type. */
1006 return_type = build_pointer_type (void_type_node);
1008 return_type = build_pointer_type (type);
1011 return_type = void_type_node;
1015 case sfk_destructor:
1017 name = constructor_name (type);
1018 raises = synthesize_exception_spec (type, &locate_dtor, 0);
1021 case sfk_constructor:
1022 /* Default constructor. */
1023 name = constructor_name (type);
1024 raises = synthesize_exception_spec (type, &locate_ctor, 0);
1027 case sfk_copy_constructor:
1028 case sfk_assignment_operator:
1030 struct copy_data data;
1034 if (kind == sfk_assignment_operator)
1036 return_type = build_reference_type (type);
1037 name = ansi_assopname (NOP_EXPR);
1041 name = constructor_name (type);
1045 data.quals = TYPE_QUAL_CONST;
1046 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1049 rhs_parm_type = type;
1050 rhs_parm_type = build_reference_type (rhs_parm_type);
1051 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1052 raises = synthesize_exception_spec (type, &locate_copy, &data);
1059 /* Create the function. */
1060 fn_type = build_method_type_directly (type, return_type, parameter_types);
1062 fn_type = build_exception_variant (fn_type, raises);
1063 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1064 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1065 if (kind == sfk_constructor || kind == sfk_copy_constructor)
1066 DECL_CONSTRUCTOR_P (fn) = 1;
1067 else if (kind == sfk_destructor)
1068 DECL_DESTRUCTOR_P (fn) = 1;
1071 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1072 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1074 /* Create the explicit arguments. */
1077 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1078 want its type to be included in the mangled function
1080 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1081 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1083 /* Add the "this" parameter. */
1084 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1085 TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1086 DECL_ARGUMENTS (fn) = this_parm;
1088 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1089 set_linkage_according_to_type (type, fn);
1090 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1091 DECL_IN_AGGR_P (fn) = 1;
1092 DECL_ARTIFICIAL (fn) = 1;
1093 DECL_NOT_REALLY_EXTERN (fn) = 1;
1094 DECL_DECLARED_INLINE_P (fn) = 1;
1095 DECL_INLINE (fn) = 1;
1096 gcc_assert (!TREE_USED (fn));
1098 /* Restore PROCESSING_TEMPLATE_DECL. */
1099 processing_template_decl = saved_processing_template_decl;
1104 /* Add an implicit declaration to TYPE for the kind of function
1105 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1109 lazily_declare_fn (special_function_kind sfk, tree type)
1114 /* Figure out whether or not the argument has a const reference
1116 if (sfk == sfk_copy_constructor)
1117 const_p = TYPE_HAS_CONST_INIT_REF (type);
1118 else if (sfk == sfk_assignment_operator)
1119 const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1121 /* In this case, CONST_P will be ignored. */
1123 /* Declare the function. */
1124 fn = implicitly_declare_fn (sfk, type, const_p);
1125 /* A destructor may be virtual. */
1126 if (sfk == sfk_destructor)
1127 check_for_override (fn, type);
1128 /* Add it to CLASSTYPE_METHOD_VEC. */
1129 add_method (type, fn, NULL_TREE);
1130 /* Add it to TYPE_METHODS. */
1131 if (sfk == sfk_destructor
1132 && DECL_VIRTUAL_P (fn)
1133 && abi_version_at_least (2))
1134 /* The ABI requires that a virtual destructor go at the end of the
1136 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1139 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1140 TYPE_METHODS list, which cause the destructor to be emitted
1141 in an incorrect location in the vtable. */
1142 if (warn_abi && DECL_VIRTUAL_P (fn))
1143 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1144 "and may change in a future version of GCC due to "
1145 "implicit virtual destructor",
1147 TREE_CHAIN (fn) = TYPE_METHODS (type);
1148 TYPE_METHODS (type) = fn;
1150 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1151 if (sfk == sfk_assignment_operator)
1152 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1155 /* Remember that the function has been created. */
1156 if (sfk == sfk_constructor)
1157 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1158 else if (sfk == sfk_copy_constructor)
1159 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1160 else if (sfk == sfk_destructor)
1161 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1162 /* Create appropriate clones. */
1163 clone_function_decl (fn, /*update_method_vec=*/true);
1169 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1170 as there are artificial parms in FN. */
1173 skip_artificial_parms_for (tree fn, tree list)
1175 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1176 list = TREE_CHAIN (list);
1180 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1181 list = TREE_CHAIN (list);
1182 if (DECL_HAS_VTT_PARM_P (fn))
1183 list = TREE_CHAIN (list);
1187 #include "gt-cp-method.h"