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);
141 comdat_linkage (thunk);
142 SET_DECL_THUNK_P (thunk, this_adjusting);
143 THUNK_TARGET (thunk) = function;
144 THUNK_FIXED_OFFSET (thunk) = d;
145 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
146 THUNK_ALIAS (thunk) = NULL_TREE;
148 /* The thunk itself is not a constructor or destructor, even if
149 the thing it is thunking to is. */
150 DECL_INTERFACE_KNOWN (thunk) = 1;
151 DECL_NOT_REALLY_EXTERN (thunk) = 1;
152 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
153 DECL_DESTRUCTOR_P (thunk) = 0;
154 DECL_CONSTRUCTOR_P (thunk) = 0;
155 DECL_EXTERNAL (thunk) = 1;
156 DECL_ARTIFICIAL (thunk) = 1;
157 /* Even if this thunk is a member of a local class, we don't
158 need a static chain. */
159 DECL_NO_STATIC_CHAIN (thunk) = 1;
160 /* The THUNK is not a pending inline, even if the FUNCTION is. */
161 DECL_PENDING_INLINE_P (thunk) = 0;
162 DECL_INLINE (thunk) = 0;
163 DECL_DECLARED_INLINE_P (thunk) = 0;
164 /* Nor has it been deferred. */
165 DECL_DEFERRED_FN (thunk) = 0;
167 /* Add it to the list of thunks associated with FUNCTION. */
168 TREE_CHAIN (thunk) = DECL_THUNKS (function);
169 DECL_THUNKS (function) = thunk;
174 /* Finish THUNK, a thunk decl. */
177 finish_thunk (tree thunk)
180 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
181 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
183 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
184 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
185 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
186 function = THUNK_TARGET (thunk);
187 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
188 fixed_offset, virtual_offset);
190 /* We can end up with declarations of (logically) different
191 covariant thunks, that do identical adjustments. The two thunks
192 will be adjusting between within different hierarchies, which
193 happen to have the same layout. We must nullify one of them to
194 refer to the other. */
195 if (DECL_RESULT_THUNK_P (thunk))
199 for (cov_probe = DECL_THUNKS (function);
200 cov_probe; cov_probe = TREE_CHAIN (cov_probe))
201 if (DECL_NAME (cov_probe) == name)
203 gcc_assert (!DECL_THUNKS (thunk));
204 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
205 ? THUNK_ALIAS (cov_probe) : cov_probe);
210 DECL_NAME (thunk) = name;
211 SET_DECL_ASSEMBLER_NAME (thunk, name);
214 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
215 offset indicated by VIRTUAL_OFFSET, if that is
216 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
217 zero for a result adjusting thunk. */
220 thunk_adjust (tree ptr, bool this_adjusting,
221 HOST_WIDE_INT fixed_offset, tree virtual_offset)
224 /* Adjust the pointer by the constant. */
225 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
226 ssize_int (fixed_offset));
228 /* If there's a virtual offset, look up that value in the vtable and
229 adjust the pointer again. */
234 ptr = save_expr (ptr);
235 /* The vptr is always at offset zero in the object. */
236 vtable = build1 (NOP_EXPR,
237 build_pointer_type (build_pointer_type
238 (vtable_entry_type)),
240 /* Form the vtable address. */
241 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
242 /* Find the entry with the vcall offset. */
243 vtable = build2 (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
244 /* Get the offset itself. */
245 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
246 /* Adjust the `this' pointer. */
247 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable);
251 /* Adjust the pointer by the constant. */
252 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
253 ssize_int (fixed_offset));
258 static GTY (()) int thunk_labelno;
260 /* Create a static alias to function. */
263 make_alias_for (tree function, tree newid)
265 tree alias = build_decl (FUNCTION_DECL, newid, TREE_TYPE (function));
266 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
267 cxx_dup_lang_specific_decl (alias);
268 DECL_CONTEXT (alias) = NULL;
269 TREE_READONLY (alias) = TREE_READONLY (function);
270 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
271 TREE_PUBLIC (alias) = 0;
272 DECL_INTERFACE_KNOWN (alias) = 1;
273 DECL_NOT_REALLY_EXTERN (alias) = 1;
274 DECL_THIS_STATIC (alias) = 1;
275 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
276 DECL_DESTRUCTOR_P (alias) = 0;
277 DECL_CONSTRUCTOR_P (alias) = 0;
278 DECL_CLONED_FUNCTION (alias) = NULL_TREE;
279 DECL_EXTERNAL (alias) = 0;
280 DECL_ARTIFICIAL (alias) = 1;
281 DECL_NO_STATIC_CHAIN (alias) = 1;
282 DECL_PENDING_INLINE_P (alias) = 0;
283 DECL_INLINE (alias) = 0;
284 DECL_DECLARED_INLINE_P (alias) = 0;
285 DECL_DEFERRED_FN (alias) = 0;
286 DECL_USE_TEMPLATE (alias) = 0;
287 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
288 DECL_TEMPLATE_INFO (alias) = NULL;
289 DECL_INITIAL (alias) = error_mark_node;
290 TREE_ADDRESSABLE (alias) = 1;
291 TREE_USED (alias) = 1;
292 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
293 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
298 make_alias_for_thunk (tree function)
303 ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
306 alias = make_alias_for (function, get_identifier (buf));
308 if (!flag_syntax_only)
309 assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
314 /* Emit the definition of a C++ multiple inheritance or covariant
315 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
319 use_thunk (tree thunk_fndecl, bool emit_p)
321 tree a, t, function, alias;
323 HOST_WIDE_INT fixed_offset, virtual_value;
324 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
326 /* We should have called finish_thunk to give it a name. */
327 gcc_assert (DECL_NAME (thunk_fndecl));
329 /* We should never be using an alias, always refer to the
331 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
333 if (TREE_ASM_WRITTEN (thunk_fndecl))
336 function = THUNK_TARGET (thunk_fndecl);
337 if (DECL_RESULT (thunk_fndecl))
338 /* We already turned this thunk into an ordinary function.
339 There's no need to process this thunk again. */
342 if (DECL_THUNK_P (function))
343 /* The target is itself a thunk, process it now. */
344 use_thunk (function, emit_p);
346 /* Thunks are always addressable; they only appear in vtables. */
347 TREE_ADDRESSABLE (thunk_fndecl) = 1;
349 /* Figure out what function is being thunked to. It's referenced in
350 this translation unit. */
351 TREE_ADDRESSABLE (function) = 1;
352 mark_used (function);
356 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
357 alias = make_alias_for_thunk (function);
361 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
362 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
367 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
368 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
369 gcc_assert (virtual_value);
374 /* And, if we need to emit the thunk, it's used. */
375 mark_used (thunk_fndecl);
376 /* This thunk is actually defined. */
377 DECL_EXTERNAL (thunk_fndecl) = 0;
378 /* The linkage of the function may have changed. FIXME in linkage
380 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
381 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
382 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
383 = DECL_VISIBILITY_SPECIFIED (function);
384 if (flag_weak && TREE_PUBLIC (thunk_fndecl))
385 comdat_linkage (thunk_fndecl);
387 if (flag_syntax_only)
389 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
393 push_to_top_level ();
395 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
396 && targetm.have_named_sections)
398 resolve_unique_section (function, 0, flag_function_sections);
400 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
402 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
404 /* Output the thunk into the same section as function. */
405 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
409 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
411 DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
413 /* Set up cloned argument trees for the thunk. */
415 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
417 tree x = copy_node (a);
419 DECL_CONTEXT (x) = thunk_fndecl;
420 SET_DECL_RTL (x, NULL_RTX);
424 DECL_ARGUMENTS (thunk_fndecl) = a;
425 BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a;
428 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
429 virtual_value, alias))
432 current_function_decl = thunk_fndecl;
433 DECL_RESULT (thunk_fndecl)
434 = build_decl (RESULT_DECL, 0, integer_type_node);
435 fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
436 init_function_start (thunk_fndecl);
437 current_function_is_thunk = 1;
438 assemble_start_function (thunk_fndecl, fnname);
440 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
441 fixed_offset, virtual_value, alias);
443 assemble_end_function (thunk_fndecl, fnname);
444 init_insn_lengths ();
445 current_function_decl = 0;
447 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
451 /* If this is a covariant thunk, or we don't have the necessary
452 code for efficient thunks, generate a thunk function that
453 just makes a call to the real function. Unfortunately, this
454 doesn't work for varargs. */
456 if (varargs_function_p (function))
457 error ("generic thunk code fails for method %q#D which uses %<...%>",
460 DECL_RESULT (thunk_fndecl) = NULL_TREE;
462 start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
463 /* We don't bother with a body block for thunks. */
465 /* There's no need to check accessibility inside the thunk body. */
466 push_deferring_access_checks (dk_no_check);
470 t = thunk_adjust (t, /*this_adjusting=*/1,
471 fixed_offset, virtual_offset);
473 /* Build up the call to the real function. */
474 t = tree_cons (NULL_TREE, t, NULL_TREE);
475 for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
476 t = tree_cons (NULL_TREE, a, t);
478 t = build_call (alias, t);
479 CALL_FROM_THUNK_P (t) = 1;
481 if (VOID_TYPE_P (TREE_TYPE (t)))
482 finish_expr_stmt (t);
487 tree cond = NULL_TREE;
489 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
491 /* If the return type is a pointer, we need to
492 protect against NULL. We know there will be an
493 adjustment, because that's why we're emitting a
496 cond = cp_convert (boolean_type_node, t);
499 t = thunk_adjust (t, /*this_adjusting=*/0,
500 fixed_offset, virtual_offset);
502 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
503 cp_convert (TREE_TYPE (t), integer_zero_node));
505 if (IS_AGGR_TYPE (TREE_TYPE (t)))
506 t = build_cplus_new (TREE_TYPE (t), t);
507 finish_return_stmt (t);
510 /* Since we want to emit the thunk, we explicitly mark its name as
512 mark_decl_referenced (thunk_fndecl);
514 /* But we don't want debugging information about it. */
515 DECL_IGNORED_P (thunk_fndecl) = 1;
517 /* Re-enable access control. */
518 pop_deferring_access_checks ();
520 thunk_fndecl = finish_function (0);
521 tree_lowering_passes (thunk_fndecl);
522 expand_body (thunk_fndecl);
525 pop_from_top_level ();
528 /* Code for synthesizing methods which have default semantics defined. */
530 /* Generate code for default X(X&) constructor. */
533 do_build_copy_constructor (tree fndecl)
535 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
537 parm = convert_from_reference (parm);
539 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
540 && is_empty_class (current_class_type))
541 /* Don't copy the padding byte; it might not have been allocated
542 if *this is a base subobject. */;
543 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
545 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
546 finish_expr_stmt (t);
550 tree fields = TYPE_FIELDS (current_class_type);
551 tree member_init_list = NULL_TREE;
552 int cvquals = cp_type_quals (TREE_TYPE (parm));
554 tree binfo, base_binfo;
555 VEC(tree,gc) *vbases;
557 /* Initialize all the base-classes with the parameter converted
558 to their type so that we get their copy constructor and not
559 another constructor that takes current_class_type. We must
560 deal with the binfo's directly as a direct base might be
561 inaccessible due to ambiguity. */
562 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
563 VEC_iterate (tree, vbases, i, binfo); i++)
567 build_tree_list (NULL_TREE,
568 build_base_path (PLUS_EXPR, parm,
573 for (binfo = TYPE_BINFO (current_class_type), i = 0;
574 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
576 if (BINFO_VIRTUAL_P (base_binfo))
580 = tree_cons (base_binfo,
581 build_tree_list (NULL_TREE,
582 build_base_path (PLUS_EXPR, parm,
587 for (; fields; fields = TREE_CHAIN (fields))
593 if (TREE_CODE (field) != FIELD_DECL)
596 expr_type = TREE_TYPE (field);
597 if (DECL_NAME (field))
599 if (VFIELD_NAME_P (DECL_NAME (field)))
602 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
603 /* Just use the field; anonymous types can't have
604 nontrivial copy ctors or assignment ops. */;
608 /* Compute the type of "init->field". If the copy-constructor
609 parameter is, for example, "const S&", and the type of
610 the field is "T", then the type will usually be "const
611 T". (There are no cv-qualified variants of reference
613 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
617 if (DECL_MUTABLE_P (field))
618 quals &= ~TYPE_QUAL_CONST;
619 expr_type = cp_build_qualified_type (expr_type, quals);
622 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
623 init = build_tree_list (NULL_TREE, init);
625 member_init_list = tree_cons (field, init, member_init_list);
627 finish_mem_initializers (member_init_list);
632 do_build_assign_ref (tree fndecl)
634 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
637 compound_stmt = begin_compound_stmt (0);
638 parm = convert_from_reference (parm);
640 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
641 && is_empty_class (current_class_type))
642 /* Don't copy the padding byte; it might not have been allocated
643 if *this is a base subobject. */;
644 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
646 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
647 finish_expr_stmt (t);
652 int cvquals = cp_type_quals (TREE_TYPE (parm));
654 tree binfo, base_binfo;
656 /* Assign to each of the direct base classes. */
657 for (binfo = TYPE_BINFO (current_class_type), i = 0;
658 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
662 /* We must convert PARM directly to the base class
663 explicitly since the base class may be ambiguous. */
664 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
665 /* Call the base class assignment operator. */
667 (build_special_member_call (current_class_ref,
668 ansi_assopname (NOP_EXPR),
669 build_tree_list (NULL_TREE,
672 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
675 /* Assign to each of the non-static data members. */
676 for (fields = TYPE_FIELDS (current_class_type);
678 fields = TREE_CHAIN (fields))
680 tree comp = current_class_ref;
686 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
689 expr_type = TREE_TYPE (field);
691 if (CP_TYPE_CONST_P (expr_type))
693 error ("non-static const member %q#D, can't use default "
694 "assignment operator", field);
697 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
699 error ("non-static reference member %q#D, can't use "
700 "default assignment operator", field);
704 if (DECL_NAME (field))
706 if (VFIELD_NAME_P (DECL_NAME (field)))
709 else if (ANON_AGGR_TYPE_P (expr_type)
710 && TYPE_FIELDS (expr_type) != NULL_TREE)
711 /* Just use the field; anonymous types can't have
712 nontrivial copy ctors or assignment ops. */;
716 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
718 /* Compute the type of init->field */
720 if (DECL_MUTABLE_P (field))
721 quals &= ~TYPE_QUAL_CONST;
722 expr_type = cp_build_qualified_type (expr_type, quals);
724 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
726 if (DECL_NAME (field))
727 init = build_modify_expr (comp, NOP_EXPR, init);
729 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
730 finish_expr_stmt (init);
733 finish_return_stmt (current_class_ref);
734 finish_compound_stmt (compound_stmt);
737 /* Synthesize FNDECL, a non-static member function. */
740 synthesize_method (tree fndecl)
742 bool nested = (current_function_decl != NULL_TREE);
743 tree context = decl_function_context (fndecl);
744 bool need_body = true;
746 location_t save_input_location = input_location;
747 int error_count = errorcount;
748 int warning_count = warningcount;
750 /* Reset the source location, we might have been previously
751 deferred, and thus have saved where we were first needed. */
752 DECL_SOURCE_LOCATION (fndecl)
753 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
755 /* If we've been asked to synthesize a clone, just synthesize the
756 cloned function instead. Doing so will automatically fill in the
757 body for the clone. */
758 if (DECL_CLONED_FUNCTION_P (fndecl))
759 fndecl = DECL_CLONED_FUNCTION (fndecl);
761 /* We may be in the middle of deferred access check. Disable
763 push_deferring_access_checks (dk_no_deferred);
766 push_to_top_level ();
768 push_function_context_to (context);
770 input_location = DECL_SOURCE_LOCATION (fndecl);
772 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
773 stmt = begin_function_body ();
775 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
777 do_build_assign_ref (fndecl);
780 else if (DECL_CONSTRUCTOR_P (fndecl))
782 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
783 if (arg_chain != void_list_node)
784 do_build_copy_constructor (fndecl);
785 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
786 finish_mem_initializers (NULL_TREE);
789 /* If we haven't yet generated the body of the function, just
790 generate an empty compound statement. */
794 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
795 finish_compound_stmt (compound_stmt);
798 finish_function_body (stmt);
799 expand_or_defer_fn (finish_function (0));
801 input_location = save_input_location;
804 pop_from_top_level ();
806 pop_function_context_from (context);
808 pop_deferring_access_checks ();
810 if (error_count != errorcount || warning_count != warningcount)
811 inform ("%Hsynthesized method %qD first required here ",
812 &input_location, fndecl);
815 /* Use EXTRACTOR to locate the relevant function called for each base &
816 class field of TYPE. CLIENT allows additional information to be passed
817 to EXTRACTOR. Generates the union of all exceptions generated by those
818 functions. Note that we haven't updated TYPE_FIELDS and such of any
819 variants yet, so we need to look at the main one. */
822 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
825 tree raises = empty_except_spec;
826 tree fields = TYPE_FIELDS (type);
827 tree binfo, base_binfo;
830 for (binfo = TYPE_BINFO (type), i = 0;
831 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
833 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
836 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
838 raises = merge_exception_specifiers (raises, fn_raises);
841 for (; fields; fields = TREE_CHAIN (fields))
843 tree type = TREE_TYPE (fields);
846 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
848 while (TREE_CODE (type) == ARRAY_TYPE)
849 type = TREE_TYPE (type);
850 if (!CLASS_TYPE_P (type))
853 fn = (*extractor) (type, client);
856 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
858 raises = merge_exception_specifiers (raises, fn_raises);
864 /* Locate the dtor of TYPE. */
867 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
869 return CLASSTYPE_DESTRUCTORS (type);
872 /* Locate the default ctor of TYPE. */
875 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
879 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
882 /* Call lookup_fnfields_1 to create the constructor declarations, if
884 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
885 return lazily_declare_fn (sfk_constructor, type);
887 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
889 tree fn = OVL_CURRENT (fns);
890 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
892 parms = skip_artificial_parms_for (fn, parms);
894 if (sufficient_parms_p (parms))
906 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
907 points to a COPY_DATA holding the name (NULL for the ctor)
908 and desired qualifiers of the source operand. */
911 locate_copy (tree type, void *client_)
913 struct copy_data *client = (struct copy_data *)client_;
915 tree best = NULL_TREE;
916 bool excess_p = false;
921 ix = lookup_fnfields_1 (type, client->name);
924 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
926 else if (TYPE_HAS_INIT_REF (type))
928 /* If construction of the copy constructor was postponed, create
930 if (CLASSTYPE_LAZY_COPY_CTOR (type))
931 lazily_declare_fn (sfk_copy_constructor, type);
932 fns = CLASSTYPE_CONSTRUCTORS (type);
936 for (; fns; fns = OVL_NEXT (fns))
938 tree fn = OVL_CURRENT (fns);
939 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
944 parms = skip_artificial_parms_for (fn, parms);
947 src_type = non_reference (TREE_VALUE (parms));
948 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
950 if (!sufficient_parms_p (TREE_CHAIN (parms)))
952 quals = cp_type_quals (src_type);
953 if (client->quals & ~quals)
955 excess = quals & ~client->quals;
956 if (!best || (excess_p && !excess))
968 /* Implicitly declare the special function indicated by KIND, as a
969 member of TYPE. For copy constructors and assignment operators,
970 CONST_P indicates whether these functions should take a const
971 reference argument or a non-const reference. Returns the
972 FUNCTION_DECL for the implicitly declared function. */
975 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
978 tree parameter_types = void_list_node;
981 tree raises = empty_except_spec;
982 tree rhs_parm_type = NULL_TREE;
984 HOST_WIDE_INT saved_processing_template_decl;
986 /* Because we create declarations for implicitly declared functions
987 lazily, we may be creating the declaration for a member of TYPE
988 while in some completely different context. However, TYPE will
989 never be a dependent class (because we never want to do lookups
990 for implicitly defined functions in a dependent class).
991 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
992 because we only create clones for constructors and destructors
993 when not in a template. */
994 gcc_assert (!dependent_type_p (type));
995 saved_processing_template_decl = processing_template_decl;
996 processing_template_decl = 0;
998 type = TYPE_MAIN_VARIANT (type);
1000 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1002 if (kind == sfk_destructor)
1003 /* See comment in check_special_function_return_type. */
1004 return_type = build_pointer_type (void_type_node);
1006 return_type = build_pointer_type (type);
1009 return_type = void_type_node;
1013 case sfk_destructor:
1015 name = constructor_name (type);
1016 raises = synthesize_exception_spec (type, &locate_dtor, 0);
1019 case sfk_constructor:
1020 /* Default constructor. */
1021 name = constructor_name (type);
1022 raises = synthesize_exception_spec (type, &locate_ctor, 0);
1025 case sfk_copy_constructor:
1026 case sfk_assignment_operator:
1028 struct copy_data data;
1032 if (kind == sfk_assignment_operator)
1034 return_type = build_reference_type (type);
1035 name = ansi_assopname (NOP_EXPR);
1039 name = constructor_name (type);
1043 data.quals = TYPE_QUAL_CONST;
1044 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1047 rhs_parm_type = type;
1048 rhs_parm_type = build_reference_type (rhs_parm_type);
1049 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1050 raises = synthesize_exception_spec (type, &locate_copy, &data);
1057 /* Create the function. */
1058 fn_type = build_method_type_directly (type, return_type, parameter_types);
1060 fn_type = build_exception_variant (fn_type, raises);
1061 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1062 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1063 if (kind == sfk_constructor || kind == sfk_copy_constructor)
1064 DECL_CONSTRUCTOR_P (fn) = 1;
1065 else if (kind == sfk_destructor)
1066 DECL_DESTRUCTOR_P (fn) = 1;
1069 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1070 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1072 /* Create the argument list. The call to "grokclassfn" will add the
1073 "this" parameter and any other implicit parameters. */
1076 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1077 want its type to be included in the mangled function
1079 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1080 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1083 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL,
1085 grok_special_member_properties (fn);
1086 set_linkage_according_to_type (type, fn);
1087 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1088 DECL_IN_AGGR_P (fn) = 1;
1089 DECL_ARTIFICIAL (fn) = 1;
1090 DECL_NOT_REALLY_EXTERN (fn) = 1;
1091 DECL_DECLARED_INLINE_P (fn) = 1;
1092 DECL_INLINE (fn) = 1;
1093 gcc_assert (!TREE_USED (fn));
1095 /* Restore PROCESSING_TEMPLATE_DECL. */
1096 processing_template_decl = saved_processing_template_decl;
1101 /* Add an implicit declaration to TYPE for the kind of function
1102 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1106 lazily_declare_fn (special_function_kind sfk, tree type)
1111 /* Figure out whether or not the argument has a const reference
1113 if (sfk == sfk_copy_constructor)
1114 const_p = TYPE_HAS_CONST_INIT_REF (type);
1115 else if (sfk == sfk_assignment_operator)
1116 const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1118 /* In this case, CONST_P will be ignored. */
1120 /* Declare the function. */
1121 fn = implicitly_declare_fn (sfk, type, const_p);
1122 /* A destructor may be virtual. */
1123 if (sfk == sfk_destructor)
1124 check_for_override (fn, type);
1125 /* Add it to CLASSTYPE_METHOD_VEC. */
1126 add_method (type, fn, NULL_TREE);
1127 /* Add it to TYPE_METHODS. */
1128 if (sfk == sfk_destructor
1129 && DECL_VIRTUAL_P (fn)
1130 && abi_version_at_least (2))
1131 /* The ABI requires that a virtual destructor go at the end of the
1133 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1136 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1137 TYPE_METHODS list, which cause the destructor to be emitted
1138 in an incorrect location in the vtable. */
1139 if (warn_abi && DECL_VIRTUAL_P (fn))
1140 warning (0, "vtable layout for class %qT may not be ABI-compliant"
1141 "and may change in a future version of GCC due to "
1142 "implicit virtual destructor",
1144 TREE_CHAIN (fn) = TYPE_METHODS (type);
1145 TYPE_METHODS (type) = fn;
1147 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1148 if (sfk == sfk_assignment_operator)
1149 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1152 /* Remember that the function has been created. */
1153 if (sfk == sfk_constructor)
1154 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1155 else if (sfk == sfk_copy_constructor)
1156 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1157 else if (sfk == sfk_destructor)
1158 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1159 /* Create appropriate clones. */
1160 clone_function_decl (fn, /*update_method_vec=*/true);
1166 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1167 as there are artificial parms in FN. */
1170 skip_artificial_parms_for (tree fn, tree list)
1172 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1173 list = TREE_CHAIN (list);
1177 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1178 list = TREE_CHAIN (list);
1179 if (DECL_HAS_VTT_PARM_P (fn))
1180 list = TREE_CHAIN (list);
1184 #include "gt-cp-method.h"