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, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
39 #include "tree-pass.h"
41 /* Various flags to control the mangling process. */
47 /* The thing we are presently mangling is part of a template type,
48 rather than a fully instantiated type. Therefore, we may see
49 complex expressions where we would normally expect to see a
50 simple integer constant. */
51 mf_maybe_uninstantiated = 1,
52 /* When mangling a numeric value, use the form `_XX_' (instead of
53 just `XX') if the value has more than one digit. */
54 mf_use_underscores_around_value = 2
57 typedef enum mangling_flags mangling_flags;
59 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
60 static void do_build_assign_ref (tree);
61 static void do_build_copy_constructor (tree);
62 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
63 static tree locate_dtor (tree, void *);
64 static tree locate_ctor (tree, void *);
65 static tree locate_copy (tree, void *);
66 static tree make_alias_for_thunk (tree);
68 /* Called once to initialize method.c. */
76 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
77 indicates whether it is a this or result adjusting thunk.
78 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
79 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
80 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
81 adjusting thunks, we scale it to a byte offset. For covariant
82 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
83 the returned thunk with finish_thunk. */
86 make_thunk (tree function, bool this_adjusting,
87 tree fixed_offset, tree virtual_offset)
92 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
93 /* We can have this thunks to covariant thunks, but not vice versa. */
94 gcc_assert (!DECL_THIS_THUNK_P (function));
95 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
97 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
98 if (this_adjusting && virtual_offset)
100 = size_binop (MULT_EXPR,
103 TYPE_SIZE_UNIT (vtable_entry_type)));
105 d = tree_low_cst (fixed_offset, 0);
107 /* See if we already have the thunk in question. For this_adjusting
108 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
110 for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
111 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
112 && THUNK_FIXED_OFFSET (thunk) == d
113 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
116 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
118 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
121 /* All thunks must be created before FUNCTION is actually emitted;
122 the ABI requires that all thunks be emitted together with the
123 function to which they transfer control. */
124 gcc_assert (!TREE_ASM_WRITTEN (function));
125 /* Likewise, we can only be adding thunks to a function declared in
126 the class currently being laid out. */
127 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
128 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
130 thunk = build_decl (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);
140 comdat_linkage (thunk);
141 SET_DECL_THUNK_P (thunk, this_adjusting);
142 THUNK_TARGET (thunk) = function;
143 THUNK_FIXED_OFFSET (thunk) = d;
144 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
145 THUNK_ALIAS (thunk) = NULL_TREE;
147 /* The thunk itself is not a constructor or destructor, even if
148 the thing it is thunking to is. */
149 DECL_INTERFACE_KNOWN (thunk) = 1;
150 DECL_NOT_REALLY_EXTERN (thunk) = 1;
151 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
152 DECL_DESTRUCTOR_P (thunk) = 0;
153 DECL_CONSTRUCTOR_P (thunk) = 0;
154 DECL_EXTERNAL (thunk) = 1;
155 DECL_ARTIFICIAL (thunk) = 1;
156 /* Even if this thunk is a member of a local class, we don't
157 need a static chain. */
158 DECL_NO_STATIC_CHAIN (thunk) = 1;
159 /* The THUNK is not a pending inline, even if the FUNCTION is. */
160 DECL_PENDING_INLINE_P (thunk) = 0;
161 DECL_INLINE (thunk) = 0;
162 DECL_DECLARED_INLINE_P (thunk) = 0;
163 /* Nor has it been deferred. */
164 DECL_DEFERRED_FN (thunk) = 0;
166 /* Add it to the list of thunks associated with FUNCTION. */
167 TREE_CHAIN (thunk) = DECL_THUNKS (function);
168 DECL_THUNKS (function) = thunk;
173 /* Finish THUNK, a thunk decl. */
176 finish_thunk (tree thunk)
179 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
180 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
182 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
183 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
184 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
185 function = THUNK_TARGET (thunk);
186 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
187 fixed_offset, virtual_offset);
189 /* We can end up with declarations of (logically) different
190 covariant thunks, that do identical adjustments. The two thunks
191 will be adjusting between within different hierarchies, which
192 happen to have the same layout. We must nullify one of them to
193 refer to the other. */
194 if (DECL_RESULT_THUNK_P (thunk))
198 for (cov_probe = DECL_THUNKS (function);
199 cov_probe; cov_probe = TREE_CHAIN (cov_probe))
200 if (DECL_NAME (cov_probe) == name)
202 gcc_assert (!DECL_THUNKS (thunk));
203 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
204 ? THUNK_ALIAS (cov_probe) : cov_probe);
209 DECL_NAME (thunk) = name;
210 SET_DECL_ASSEMBLER_NAME (thunk, name);
213 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
214 offset indicated by VIRTUAL_OFFSET, if that is
215 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
216 zero for a result adjusting thunk. */
219 thunk_adjust (tree ptr, bool this_adjusting,
220 HOST_WIDE_INT fixed_offset, tree virtual_offset)
223 /* Adjust the pointer by the constant. */
224 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
225 ssize_int (fixed_offset));
227 /* If there's a virtual offset, look up that value in the vtable and
228 adjust the pointer again. */
233 ptr = save_expr (ptr);
234 /* The vptr is always at offset zero in the object. */
235 vtable = build1 (NOP_EXPR,
236 build_pointer_type (build_pointer_type
237 (vtable_entry_type)),
239 /* Form the vtable address. */
240 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
241 /* Find the entry with the vcall offset. */
242 vtable = build2 (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
243 /* Get the offset itself. */
244 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
245 /* Adjust the `this' pointer. */
246 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable);
250 /* Adjust the pointer by the constant. */
251 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
252 ssize_int (fixed_offset));
257 static GTY (()) int thunk_labelno;
259 /* Create a static alias to function. */
262 make_alias_for (tree function, tree newid)
264 tree alias = build_decl (FUNCTION_DECL, newid, TREE_TYPE (function));
265 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
266 cxx_dup_lang_specific_decl (alias);
267 DECL_CONTEXT (alias) = NULL;
268 TREE_READONLY (alias) = TREE_READONLY (function);
269 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
270 TREE_PUBLIC (alias) = 0;
271 DECL_INTERFACE_KNOWN (alias) = 1;
272 DECL_NOT_REALLY_EXTERN (alias) = 1;
273 DECL_THIS_STATIC (alias) = 1;
274 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
275 DECL_DESTRUCTOR_P (alias) = 0;
276 DECL_CONSTRUCTOR_P (alias) = 0;
277 DECL_CLONED_FUNCTION (alias) = NULL_TREE;
278 DECL_EXTERNAL (alias) = 0;
279 DECL_ARTIFICIAL (alias) = 1;
280 DECL_NO_STATIC_CHAIN (alias) = 1;
281 DECL_PENDING_INLINE_P (alias) = 0;
282 DECL_INLINE (alias) = 0;
283 DECL_DECLARED_INLINE_P (alias) = 0;
284 DECL_DEFERRED_FN (alias) = 0;
285 DECL_USE_TEMPLATE (alias) = 0;
286 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
287 DECL_TEMPLATE_INFO (alias) = NULL;
288 DECL_INITIAL (alias) = error_mark_node;
289 TREE_ADDRESSABLE (alias) = 1;
290 TREE_USED (alias) = 1;
291 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
292 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
297 make_alias_for_thunk (tree function)
302 ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
305 alias = make_alias_for (function, get_identifier (buf));
307 if (!flag_syntax_only)
308 assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
313 /* Emit the definition of a C++ multiple inheritance or covariant
314 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
318 use_thunk (tree thunk_fndecl, bool emit_p)
320 tree a, t, function, alias;
322 HOST_WIDE_INT fixed_offset, virtual_value;
323 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
325 /* We should have called finish_thunk to give it a name. */
326 gcc_assert (DECL_NAME (thunk_fndecl));
328 /* We should never be using an alias, always refer to the
330 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
332 if (TREE_ASM_WRITTEN (thunk_fndecl))
335 function = THUNK_TARGET (thunk_fndecl);
336 if (DECL_RESULT (thunk_fndecl))
337 /* We already turned this thunk into an ordinary function.
338 There's no need to process this thunk again. */
341 if (DECL_THUNK_P (function))
342 /* The target is itself a thunk, process it now. */
343 use_thunk (function, emit_p);
345 /* Thunks are always addressable; they only appear in vtables. */
346 TREE_ADDRESSABLE (thunk_fndecl) = 1;
348 /* Figure out what function is being thunked to. It's referenced in
349 this translation unit. */
350 TREE_ADDRESSABLE (function) = 1;
351 mark_used (function);
355 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
356 alias = make_alias_for_thunk (function);
360 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
361 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
366 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
367 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
368 gcc_assert (virtual_value);
373 /* And, if we need to emit the thunk, it's used. */
374 mark_used (thunk_fndecl);
375 /* This thunk is actually defined. */
376 DECL_EXTERNAL (thunk_fndecl) = 0;
377 /* The linkage of the function may have changed. FIXME in linkage
379 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
380 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
381 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
382 = DECL_VISIBILITY_SPECIFIED (function);
383 if (flag_weak && TREE_PUBLIC (thunk_fndecl))
384 comdat_linkage (thunk_fndecl);
386 if (flag_syntax_only)
388 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
392 push_to_top_level ();
394 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
395 && targetm.have_named_sections)
397 resolve_unique_section (function, 0, flag_function_sections);
399 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
401 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
403 /* Output the thunk into the same section as function. */
404 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
408 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
410 DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
412 /* Set up cloned argument trees for the thunk. */
414 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
416 tree x = copy_node (a);
418 DECL_CONTEXT (x) = thunk_fndecl;
419 SET_DECL_RTL (x, NULL_RTX);
423 DECL_ARGUMENTS (thunk_fndecl) = a;
424 BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a;
427 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
428 virtual_value, alias))
431 current_function_decl = thunk_fndecl;
432 DECL_RESULT (thunk_fndecl)
433 = build_decl (RESULT_DECL, 0, integer_type_node);
434 fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
435 init_function_start (thunk_fndecl);
436 current_function_is_thunk = 1;
437 assemble_start_function (thunk_fndecl, fnname);
439 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
440 fixed_offset, virtual_value, alias);
442 assemble_end_function (thunk_fndecl, fnname);
443 current_function_decl = 0;
445 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
449 /* If this is a covariant thunk, or we don't have the necessary
450 code for efficient thunks, generate a thunk function that
451 just makes a call to the real function. Unfortunately, this
452 doesn't work for varargs. */
454 if (varargs_function_p (function))
455 error ("generic thunk code fails for method %q#D which uses %<...%>",
458 DECL_RESULT (thunk_fndecl) = NULL_TREE;
460 start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
461 /* We don't bother with a body block for thunks. */
463 /* There's no need to check accessibility inside the thunk body. */
464 push_deferring_access_checks (dk_no_check);
468 t = thunk_adjust (t, /*this_adjusting=*/1,
469 fixed_offset, virtual_offset);
471 /* Build up the call to the real function. */
472 t = tree_cons (NULL_TREE, t, NULL_TREE);
473 for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
474 t = tree_cons (NULL_TREE, a, t);
476 t = build_call (alias, t);
477 CALL_FROM_THUNK_P (t) = 1;
479 if (VOID_TYPE_P (TREE_TYPE (t)))
480 finish_expr_stmt (t);
485 tree cond = NULL_TREE;
487 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
489 /* If the return type is a pointer, we need to
490 protect against NULL. We know there will be an
491 adjustment, because that's why we're emitting a
494 cond = cp_convert (boolean_type_node, t);
497 t = thunk_adjust (t, /*this_adjusting=*/0,
498 fixed_offset, virtual_offset);
500 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
501 cp_convert (TREE_TYPE (t), integer_zero_node));
503 t = force_target_expr (TREE_TYPE (t), t);
504 finish_return_stmt (t);
507 /* Since we want to emit the thunk, we explicitly mark its name as
509 mark_decl_referenced (thunk_fndecl);
511 /* But we don't want debugging information about it. */
512 DECL_IGNORED_P (thunk_fndecl) = 1;
514 /* Re-enable access control. */
515 pop_deferring_access_checks ();
517 thunk_fndecl = finish_function (0);
518 tree_lowering_passes (thunk_fndecl);
519 expand_body (thunk_fndecl);
522 pop_from_top_level ();
525 /* Code for synthesizing methods which have default semantics defined. */
527 /* Generate code for default X(X&) constructor. */
530 do_build_copy_constructor (tree fndecl)
532 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
534 parm = convert_from_reference (parm);
536 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
537 && is_empty_class (current_class_type))
538 /* Don't copy the padding byte; it might not have been allocated
539 if *this is a base subobject. */;
540 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
542 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
543 finish_expr_stmt (t);
547 tree fields = TYPE_FIELDS (current_class_type);
548 tree member_init_list = NULL_TREE;
549 int cvquals = cp_type_quals (TREE_TYPE (parm));
551 tree binfo, base_binfo;
552 VEC(tree,gc) *vbases;
554 /* Initialize all the base-classes with the parameter converted
555 to their type so that we get their copy constructor and not
556 another constructor that takes current_class_type. We must
557 deal with the binfo's directly as a direct base might be
558 inaccessible due to ambiguity. */
559 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
560 VEC_iterate (tree, vbases, i, binfo); i++)
564 build_tree_list (NULL_TREE,
565 build_base_path (PLUS_EXPR, parm,
570 for (binfo = TYPE_BINFO (current_class_type), i = 0;
571 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
573 if (BINFO_VIRTUAL_P (base_binfo))
577 = tree_cons (base_binfo,
578 build_tree_list (NULL_TREE,
579 build_base_path (PLUS_EXPR, parm,
584 for (; fields; fields = TREE_CHAIN (fields))
590 if (TREE_CODE (field) != FIELD_DECL)
593 expr_type = TREE_TYPE (field);
594 if (DECL_NAME (field))
596 if (VFIELD_NAME_P (DECL_NAME (field)))
599 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
600 /* Just use the field; anonymous types can't have
601 nontrivial copy ctors or assignment ops. */;
605 /* Compute the type of "init->field". If the copy-constructor
606 parameter is, for example, "const S&", and the type of
607 the field is "T", then the type will usually be "const
608 T". (There are no cv-qualified variants of reference
610 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
614 if (DECL_MUTABLE_P (field))
615 quals &= ~TYPE_QUAL_CONST;
616 expr_type = cp_build_qualified_type (expr_type, quals);
619 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
620 init = build_tree_list (NULL_TREE, init);
622 member_init_list = tree_cons (field, init, member_init_list);
624 finish_mem_initializers (member_init_list);
629 do_build_assign_ref (tree fndecl)
631 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
634 compound_stmt = begin_compound_stmt (0);
635 parm = convert_from_reference (parm);
637 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
638 && is_empty_class (current_class_type))
639 /* Don't copy the padding byte; it might not have been allocated
640 if *this is a base subobject. */;
641 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
643 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
644 finish_expr_stmt (t);
649 int cvquals = cp_type_quals (TREE_TYPE (parm));
651 tree binfo, base_binfo;
653 /* Assign to each of the direct base classes. */
654 for (binfo = TYPE_BINFO (current_class_type), i = 0;
655 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
659 /* We must convert PARM directly to the base class
660 explicitly since the base class may be ambiguous. */
661 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
662 /* Call the base class assignment operator. */
664 (build_special_member_call (current_class_ref,
665 ansi_assopname (NOP_EXPR),
666 build_tree_list (NULL_TREE,
669 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
672 /* Assign to each of the non-static data members. */
673 for (fields = TYPE_FIELDS (current_class_type);
675 fields = TREE_CHAIN (fields))
677 tree comp = current_class_ref;
683 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
686 expr_type = TREE_TYPE (field);
688 if (CP_TYPE_CONST_P (expr_type))
690 error ("non-static const member %q#D, can't use default "
691 "assignment operator", field);
694 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
696 error ("non-static reference member %q#D, can't use "
697 "default assignment operator", field);
701 if (DECL_NAME (field))
703 if (VFIELD_NAME_P (DECL_NAME (field)))
706 else if (ANON_AGGR_TYPE_P (expr_type)
707 && TYPE_FIELDS (expr_type) != NULL_TREE)
708 /* Just use the field; anonymous types can't have
709 nontrivial copy ctors or assignment ops. */;
713 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
715 /* Compute the type of init->field */
717 if (DECL_MUTABLE_P (field))
718 quals &= ~TYPE_QUAL_CONST;
719 expr_type = cp_build_qualified_type (expr_type, quals);
721 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
723 if (DECL_NAME (field))
724 init = build_modify_expr (comp, NOP_EXPR, init);
726 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
727 finish_expr_stmt (init);
730 finish_return_stmt (current_class_ref);
731 finish_compound_stmt (compound_stmt);
735 synthesize_method (tree fndecl)
737 bool nested = (current_function_decl != NULL_TREE);
738 tree context = decl_function_context (fndecl);
739 bool need_body = true;
741 location_t save_input_location = input_location;
743 /* If we've been asked to synthesize a clone, just synthesize the
744 cloned function instead. Doing so will automatically fill in the
745 body for the clone. */
746 if (DECL_CLONED_FUNCTION_P (fndecl))
748 DECL_SOURCE_LOCATION (DECL_CLONED_FUNCTION (fndecl)) =
749 DECL_SOURCE_LOCATION (fndecl);
750 synthesize_method (DECL_CLONED_FUNCTION (fndecl));
754 /* We may be in the middle of deferred access check. Disable
756 push_deferring_access_checks (dk_no_deferred);
759 push_to_top_level ();
761 push_function_context_to (context);
763 input_location = DECL_SOURCE_LOCATION (fndecl);
765 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
766 stmt = begin_function_body ();
768 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
770 do_build_assign_ref (fndecl);
773 else if (DECL_CONSTRUCTOR_P (fndecl))
775 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
776 if (arg_chain != void_list_node)
777 do_build_copy_constructor (fndecl);
778 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
779 finish_mem_initializers (NULL_TREE);
782 /* If we haven't yet generated the body of the function, just
783 generate an empty compound statement. */
787 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
788 finish_compound_stmt (compound_stmt);
791 finish_function_body (stmt);
792 expand_or_defer_fn (finish_function (0));
794 input_location = save_input_location;
797 pop_from_top_level ();
799 pop_function_context_from (context);
801 pop_deferring_access_checks ();
804 /* Use EXTRACTOR to locate the relevant function called for each base &
805 class field of TYPE. CLIENT allows additional information to be passed
806 to EXTRACTOR. Generates the union of all exceptions generated by those
807 functions. Note that we haven't updated TYPE_FIELDS and such of any
808 variants yet, so we need to look at the main one. */
811 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
814 tree raises = empty_except_spec;
815 tree fields = TYPE_FIELDS (type);
816 tree binfo, base_binfo;
819 for (binfo = TYPE_BINFO (type), i = 0;
820 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
822 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
825 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
827 raises = merge_exception_specifiers (raises, fn_raises);
830 for (; fields; fields = TREE_CHAIN (fields))
832 tree type = TREE_TYPE (fields);
835 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
837 while (TREE_CODE (type) == ARRAY_TYPE)
838 type = TREE_TYPE (type);
839 if (TREE_CODE (type) != RECORD_TYPE)
842 fn = (*extractor) (type, client);
845 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
847 raises = merge_exception_specifiers (raises, fn_raises);
853 /* Locate the dtor of TYPE. */
856 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
858 return CLASSTYPE_DESTRUCTORS (type);
861 /* Locate the default ctor of TYPE. */
864 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
868 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
871 /* Call lookup_fnfields_1 to create the constructor declarations, if
873 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
874 return lazily_declare_fn (sfk_constructor, type);
876 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
878 tree fn = OVL_CURRENT (fns);
879 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
881 if (sufficient_parms_p (TREE_CHAIN (parms)))
893 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
894 points to a COPY_DATA holding the name (NULL for the ctor)
895 and desired qualifiers of the source operand. */
898 locate_copy (tree type, void *client_)
900 struct copy_data *client = (struct copy_data *)client_;
902 tree best = NULL_TREE;
903 bool excess_p = false;
908 ix = lookup_fnfields_1 (type, client->name);
911 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
913 else if (TYPE_HAS_INIT_REF (type))
915 /* If construction of the copy constructor was postponed, create
917 if (CLASSTYPE_LAZY_COPY_CTOR (type))
918 lazily_declare_fn (sfk_copy_constructor, type);
919 fns = CLASSTYPE_CONSTRUCTORS (type);
923 for (; fns; fns = OVL_NEXT (fns))
925 tree fn = OVL_CURRENT (fns);
926 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
931 parms = TREE_CHAIN (parms);
934 src_type = non_reference (TREE_VALUE (parms));
935 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
937 if (!sufficient_parms_p (TREE_CHAIN (parms)))
939 quals = cp_type_quals (src_type);
940 if (client->quals & ~quals)
942 excess = quals & ~client->quals;
943 if (!best || (excess_p && !excess))
955 /* Implicitly declare the special function indicated by KIND, as a
956 member of TYPE. For copy constructors and assignment operators,
957 CONST_P indicates whether these functions should take a const
958 reference argument or a non-const reference. Returns the
959 FUNCTION_DECL for the implicitly declared function. */
962 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
965 tree parameter_types = void_list_node;
968 tree raises = empty_except_spec;
969 tree rhs_parm_type = NULL_TREE;
972 type = TYPE_MAIN_VARIANT (type);
974 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
976 if (kind == sfk_destructor)
977 /* See comment in check_special_function_return_type. */
978 return_type = build_pointer_type (void_type_node);
980 return_type = build_pointer_type (type);
983 return_type = void_type_node;
989 name = constructor_name (type);
990 raises = synthesize_exception_spec (type, &locate_dtor, 0);
993 case sfk_constructor:
994 /* Default constructor. */
995 name = constructor_name (type);
996 raises = synthesize_exception_spec (type, &locate_ctor, 0);
999 case sfk_copy_constructor:
1000 case sfk_assignment_operator:
1002 struct copy_data data;
1006 if (kind == sfk_assignment_operator)
1008 return_type = build_reference_type (type);
1009 name = ansi_assopname (NOP_EXPR);
1013 name = constructor_name (type);
1017 data.quals = TYPE_QUAL_CONST;
1018 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1021 rhs_parm_type = type;
1022 rhs_parm_type = build_reference_type (rhs_parm_type);
1023 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1024 raises = synthesize_exception_spec (type, &locate_copy, &data);
1031 /* Create the function. */
1032 fn_type = build_method_type_directly (type, return_type, parameter_types);
1034 fn_type = build_exception_variant (fn_type, raises);
1035 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1036 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1037 if (kind == sfk_constructor || kind == sfk_copy_constructor)
1038 DECL_CONSTRUCTOR_P (fn) = 1;
1039 else if (kind == sfk_destructor)
1040 DECL_DESTRUCTOR_P (fn) = 1;
1043 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1044 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1046 /* Create the argument list. The call to "grokclassfn" will add the
1047 "this" parameter and any other implicit parameters. */
1050 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1051 want its type to be included in the mangled function
1053 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1054 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1057 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL,
1059 grok_special_member_properties (fn);
1060 set_linkage_according_to_type (type, fn);
1061 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1062 DECL_IN_AGGR_P (fn) = 1;
1063 DECL_ARTIFICIAL (fn) = 1;
1064 DECL_NOT_REALLY_EXTERN (fn) = 1;
1065 DECL_DECLARED_INLINE_P (fn) = 1;
1066 DECL_INLINE (fn) = 1;
1067 gcc_assert (!TREE_USED (fn));
1072 /* Add an implicit declaration to TYPE for the kind of function
1073 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1077 lazily_declare_fn (special_function_kind sfk, tree type)
1082 /* Figure out whether or not the argument has a const reference
1084 if (sfk == sfk_copy_constructor)
1085 const_p = TYPE_HAS_CONST_INIT_REF (type);
1086 else if (sfk == sfk_assignment_operator)
1087 const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1089 /* In this case, CONST_P will be ignored. */
1091 /* Declare the function. */
1092 fn = implicitly_declare_fn (sfk, type, const_p);
1093 /* A destructor may be virtual. */
1094 if (sfk == sfk_destructor)
1095 check_for_override (fn, type);
1096 /* Add it to CLASSTYPE_METHOD_VEC. */
1097 add_method (type, fn);
1098 /* Add it to TYPE_METHODS. */
1099 if (sfk == sfk_destructor
1100 && DECL_VIRTUAL_P (fn)
1101 && abi_version_at_least (2))
1102 /* The ABI requires that a virtual destructor go at the end of the
1104 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1107 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1108 TYPE_METHODS list, which cause the destructor to be emitted
1109 in an incorrect location in the vtable. */
1110 if (warn_abi && DECL_VIRTUAL_P (fn))
1111 warning (0, "vtable layout for class %qT may not be ABI-compliant"
1112 "and may change in a future version of GCC due to "
1113 "implicit virtual destructor",
1115 TREE_CHAIN (fn) = TYPE_METHODS (type);
1116 TYPE_METHODS (type) = fn;
1118 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1119 if (sfk == sfk_assignment_operator)
1120 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1123 /* Remember that the function has been created. */
1124 if (sfk == sfk_constructor)
1125 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1126 else if (sfk == sfk_copy_constructor)
1127 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1128 else if (sfk == sfk_destructor)
1129 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1130 /* Create appropriate clones. */
1131 clone_function_decl (fn, /*update_method_vec=*/true);
1137 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1138 as there are artificial parms in FN. */
1141 skip_artificial_parms_for (tree fn, tree list)
1143 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1144 list = TREE_CHAIN (list);
1148 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1149 list = TREE_CHAIN (list);
1150 if (DECL_HAS_VTT_PARM_P (fn))
1151 list = TREE_CHAIN (list);
1155 #include "gt-cp-method.h"