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"
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 current_function_decl = 0;
446 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
450 /* If this is a covariant thunk, or we don't have the necessary
451 code for efficient thunks, generate a thunk function that
452 just makes a call to the real function. Unfortunately, this
453 doesn't work for varargs. */
455 if (varargs_function_p (function))
456 error ("generic thunk code fails for method %q#D which uses %<...%>",
459 DECL_RESULT (thunk_fndecl) = NULL_TREE;
461 start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
462 /* We don't bother with a body block for thunks. */
464 /* There's no need to check accessibility inside the thunk body. */
465 push_deferring_access_checks (dk_no_check);
469 t = thunk_adjust (t, /*this_adjusting=*/1,
470 fixed_offset, virtual_offset);
472 /* Build up the call to the real function. */
473 t = tree_cons (NULL_TREE, t, NULL_TREE);
474 for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
475 t = tree_cons (NULL_TREE, a, t);
477 t = build_call (alias, t);
478 CALL_FROM_THUNK_P (t) = 1;
480 if (VOID_TYPE_P (TREE_TYPE (t)))
481 finish_expr_stmt (t);
486 tree cond = NULL_TREE;
488 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
490 /* If the return type is a pointer, we need to
491 protect against NULL. We know there will be an
492 adjustment, because that's why we're emitting a
495 cond = cp_convert (boolean_type_node, t);
498 t = thunk_adjust (t, /*this_adjusting=*/0,
499 fixed_offset, virtual_offset);
501 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
502 cp_convert (TREE_TYPE (t), integer_zero_node));
504 t = force_target_expr (TREE_TYPE (t), t);
505 finish_return_stmt (t);
508 /* Since we want to emit the thunk, we explicitly mark its name as
510 mark_decl_referenced (thunk_fndecl);
512 /* But we don't want debugging information about it. */
513 DECL_IGNORED_P (thunk_fndecl) = 1;
515 /* Re-enable access control. */
516 pop_deferring_access_checks ();
518 thunk_fndecl = finish_function (0);
519 tree_lowering_passes (thunk_fndecl);
520 expand_body (thunk_fndecl);
523 pop_from_top_level ();
526 /* Code for synthesizing methods which have default semantics defined. */
528 /* Generate code for default X(X&) constructor. */
531 do_build_copy_constructor (tree fndecl)
533 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
535 parm = convert_from_reference (parm);
537 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
538 && is_empty_class (current_class_type))
539 /* Don't copy the padding byte; it might not have been allocated
540 if *this is a base subobject. */;
541 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
543 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
544 finish_expr_stmt (t);
548 tree fields = TYPE_FIELDS (current_class_type);
549 tree member_init_list = NULL_TREE;
550 int cvquals = cp_type_quals (TREE_TYPE (parm));
552 tree binfo, base_binfo;
553 VEC(tree,gc) *vbases;
555 /* Initialize all the base-classes with the parameter converted
556 to their type so that we get their copy constructor and not
557 another constructor that takes current_class_type. We must
558 deal with the binfo's directly as a direct base might be
559 inaccessible due to ambiguity. */
560 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
561 VEC_iterate (tree, vbases, i, binfo); i++)
565 build_tree_list (NULL_TREE,
566 build_base_path (PLUS_EXPR, parm,
571 for (binfo = TYPE_BINFO (current_class_type), i = 0;
572 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
574 if (BINFO_VIRTUAL_P (base_binfo))
578 = tree_cons (base_binfo,
579 build_tree_list (NULL_TREE,
580 build_base_path (PLUS_EXPR, parm,
585 for (; fields; fields = TREE_CHAIN (fields))
591 if (TREE_CODE (field) != FIELD_DECL)
594 expr_type = TREE_TYPE (field);
595 if (DECL_NAME (field))
597 if (VFIELD_NAME_P (DECL_NAME (field)))
600 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
601 /* Just use the field; anonymous types can't have
602 nontrivial copy ctors or assignment ops. */;
606 /* Compute the type of "init->field". If the copy-constructor
607 parameter is, for example, "const S&", and the type of
608 the field is "T", then the type will usually be "const
609 T". (There are no cv-qualified variants of reference
611 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
615 if (DECL_MUTABLE_P (field))
616 quals &= ~TYPE_QUAL_CONST;
617 expr_type = cp_build_qualified_type (expr_type, quals);
620 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
621 init = build_tree_list (NULL_TREE, init);
623 member_init_list = tree_cons (field, init, member_init_list);
625 finish_mem_initializers (member_init_list);
630 do_build_assign_ref (tree fndecl)
632 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
635 compound_stmt = begin_compound_stmt (0);
636 parm = convert_from_reference (parm);
638 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
639 && is_empty_class (current_class_type))
640 /* Don't copy the padding byte; it might not have been allocated
641 if *this is a base subobject. */;
642 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
644 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
645 finish_expr_stmt (t);
650 int cvquals = cp_type_quals (TREE_TYPE (parm));
652 tree binfo, base_binfo;
654 /* Assign to each of the direct base classes. */
655 for (binfo = TYPE_BINFO (current_class_type), i = 0;
656 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
660 /* We must convert PARM directly to the base class
661 explicitly since the base class may be ambiguous. */
662 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
663 /* Call the base class assignment operator. */
665 (build_special_member_call (current_class_ref,
666 ansi_assopname (NOP_EXPR),
667 build_tree_list (NULL_TREE,
670 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
673 /* Assign to each of the non-static data members. */
674 for (fields = TYPE_FIELDS (current_class_type);
676 fields = TREE_CHAIN (fields))
678 tree comp = current_class_ref;
684 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
687 expr_type = TREE_TYPE (field);
689 if (CP_TYPE_CONST_P (expr_type))
691 error ("non-static const member %q#D, can't use default "
692 "assignment operator", field);
695 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
697 error ("non-static reference member %q#D, can't use "
698 "default assignment operator", field);
702 if (DECL_NAME (field))
704 if (VFIELD_NAME_P (DECL_NAME (field)))
707 else if (ANON_AGGR_TYPE_P (expr_type)
708 && TYPE_FIELDS (expr_type) != NULL_TREE)
709 /* Just use the field; anonymous types can't have
710 nontrivial copy ctors or assignment ops. */;
714 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
716 /* Compute the type of init->field */
718 if (DECL_MUTABLE_P (field))
719 quals &= ~TYPE_QUAL_CONST;
720 expr_type = cp_build_qualified_type (expr_type, quals);
722 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
724 if (DECL_NAME (field))
725 init = build_modify_expr (comp, NOP_EXPR, init);
727 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
728 finish_expr_stmt (init);
731 finish_return_stmt (current_class_ref);
732 finish_compound_stmt (compound_stmt);
735 /* Synthesize FNDECL, a non-static member function. */
738 synthesize_method (tree fndecl)
740 bool nested = (current_function_decl != NULL_TREE);
741 tree context = decl_function_context (fndecl);
742 bool need_body = true;
744 location_t save_input_location = input_location;
745 int error_count = errorcount;
746 int warning_count = warningcount;
748 /* Reset the source location, we might have been previously
749 deferred, and thus have saved where we were first needed. */
750 DECL_SOURCE_LOCATION (fndecl)
751 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
753 /* If we've been asked to synthesize a clone, just synthesize the
754 cloned function instead. Doing so will automatically fill in the
755 body for the clone. */
756 if (DECL_CLONED_FUNCTION_P (fndecl))
757 fndecl = DECL_CLONED_FUNCTION (fndecl);
759 /* We may be in the middle of deferred access check. Disable
761 push_deferring_access_checks (dk_no_deferred);
764 push_to_top_level ();
766 push_function_context_to (context);
768 input_location = DECL_SOURCE_LOCATION (fndecl);
770 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
771 stmt = begin_function_body ();
773 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
775 do_build_assign_ref (fndecl);
778 else if (DECL_CONSTRUCTOR_P (fndecl))
780 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
781 if (arg_chain != void_list_node)
782 do_build_copy_constructor (fndecl);
783 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
784 finish_mem_initializers (NULL_TREE);
787 /* If we haven't yet generated the body of the function, just
788 generate an empty compound statement. */
792 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
793 finish_compound_stmt (compound_stmt);
796 finish_function_body (stmt);
797 expand_or_defer_fn (finish_function (0));
799 input_location = save_input_location;
802 pop_from_top_level ();
804 pop_function_context_from (context);
806 pop_deferring_access_checks ();
808 if (error_count != errorcount || warning_count != warningcount)
809 inform ("%Hsynthesized method %qD first required here ",
810 &input_location, fndecl);
813 /* Use EXTRACTOR to locate the relevant function called for each base &
814 class field of TYPE. CLIENT allows additional information to be passed
815 to EXTRACTOR. Generates the union of all exceptions generated by those
816 functions. Note that we haven't updated TYPE_FIELDS and such of any
817 variants yet, so we need to look at the main one. */
820 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
823 tree raises = empty_except_spec;
824 tree fields = TYPE_FIELDS (type);
825 tree binfo, base_binfo;
828 for (binfo = TYPE_BINFO (type), i = 0;
829 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
831 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
834 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
836 raises = merge_exception_specifiers (raises, fn_raises);
839 for (; fields; fields = TREE_CHAIN (fields))
841 tree type = TREE_TYPE (fields);
844 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
846 while (TREE_CODE (type) == ARRAY_TYPE)
847 type = TREE_TYPE (type);
848 if (TREE_CODE (type) != RECORD_TYPE)
851 fn = (*extractor) (type, client);
854 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
856 raises = merge_exception_specifiers (raises, fn_raises);
862 /* Locate the dtor of TYPE. */
865 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
867 return CLASSTYPE_DESTRUCTORS (type);
870 /* Locate the default ctor of TYPE. */
873 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
877 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
880 /* Call lookup_fnfields_1 to create the constructor declarations, if
882 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
883 return lazily_declare_fn (sfk_constructor, type);
885 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
887 tree fn = OVL_CURRENT (fns);
888 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
890 if (sufficient_parms_p (TREE_CHAIN (parms)))
902 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
903 points to a COPY_DATA holding the name (NULL for the ctor)
904 and desired qualifiers of the source operand. */
907 locate_copy (tree type, void *client_)
909 struct copy_data *client = (struct copy_data *)client_;
911 tree best = NULL_TREE;
912 bool excess_p = false;
917 ix = lookup_fnfields_1 (type, client->name);
920 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
922 else if (TYPE_HAS_INIT_REF (type))
924 /* If construction of the copy constructor was postponed, create
926 if (CLASSTYPE_LAZY_COPY_CTOR (type))
927 lazily_declare_fn (sfk_copy_constructor, type);
928 fns = CLASSTYPE_CONSTRUCTORS (type);
932 for (; fns; fns = OVL_NEXT (fns))
934 tree fn = OVL_CURRENT (fns);
935 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
940 parms = TREE_CHAIN (parms);
943 src_type = non_reference (TREE_VALUE (parms));
944 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
946 if (!sufficient_parms_p (TREE_CHAIN (parms)))
948 quals = cp_type_quals (src_type);
949 if (client->quals & ~quals)
951 excess = quals & ~client->quals;
952 if (!best || (excess_p && !excess))
964 /* Implicitly declare the special function indicated by KIND, as a
965 member of TYPE. For copy constructors and assignment operators,
966 CONST_P indicates whether these functions should take a const
967 reference argument or a non-const reference. Returns the
968 FUNCTION_DECL for the implicitly declared function. */
971 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
974 tree parameter_types = void_list_node;
977 tree raises = empty_except_spec;
978 tree rhs_parm_type = NULL_TREE;
980 HOST_WIDE_INT saved_processing_template_decl;
982 /* Because we create declarations for implictly declared functions
983 lazily, we may be creating the declaration for a member of TYPE
984 while in some completely different context. However, TYPE will
985 never be a dependent class (because we never want to do lookups
986 for implicitly defined functions in a dependent class).
987 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
988 because we only create clones for constructors and destructors
989 when not in a template. */
990 gcc_assert (!dependent_type_p (type));
991 saved_processing_template_decl = processing_template_decl;
992 processing_template_decl = 0;
994 type = TYPE_MAIN_VARIANT (type);
996 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
998 if (kind == sfk_destructor)
999 /* See comment in check_special_function_return_type. */
1000 return_type = build_pointer_type (void_type_node);
1002 return_type = build_pointer_type (type);
1005 return_type = void_type_node;
1009 case sfk_destructor:
1011 name = constructor_name (type);
1012 raises = synthesize_exception_spec (type, &locate_dtor, 0);
1015 case sfk_constructor:
1016 /* Default constructor. */
1017 name = constructor_name (type);
1018 raises = synthesize_exception_spec (type, &locate_ctor, 0);
1021 case sfk_copy_constructor:
1022 case sfk_assignment_operator:
1024 struct copy_data data;
1028 if (kind == sfk_assignment_operator)
1030 return_type = build_reference_type (type);
1031 name = ansi_assopname (NOP_EXPR);
1035 name = constructor_name (type);
1039 data.quals = TYPE_QUAL_CONST;
1040 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1043 rhs_parm_type = type;
1044 rhs_parm_type = build_reference_type (rhs_parm_type);
1045 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1046 raises = synthesize_exception_spec (type, &locate_copy, &data);
1053 /* Create the function. */
1054 fn_type = build_method_type_directly (type, return_type, parameter_types);
1056 fn_type = build_exception_variant (fn_type, raises);
1057 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1058 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1059 if (kind == sfk_constructor || kind == sfk_copy_constructor)
1060 DECL_CONSTRUCTOR_P (fn) = 1;
1061 else if (kind == sfk_destructor)
1062 DECL_DESTRUCTOR_P (fn) = 1;
1065 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1066 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1068 /* Create the argument list. The call to "grokclassfn" will add the
1069 "this" parameter and any other implicit parameters. */
1072 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1073 want its type to be included in the mangled function
1075 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1076 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1079 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL,
1081 grok_special_member_properties (fn);
1082 set_linkage_according_to_type (type, fn);
1083 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1084 DECL_IN_AGGR_P (fn) = 1;
1085 DECL_ARTIFICIAL (fn) = 1;
1086 DECL_NOT_REALLY_EXTERN (fn) = 1;
1087 DECL_DECLARED_INLINE_P (fn) = 1;
1088 DECL_INLINE (fn) = 1;
1089 gcc_assert (!TREE_USED (fn));
1091 /* Restore PROCESSING_TEMPLATE_DECL. */
1092 processing_template_decl = saved_processing_template_decl;
1097 /* Add an implicit declaration to TYPE for the kind of function
1098 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1102 lazily_declare_fn (special_function_kind sfk, tree type)
1107 /* Figure out whether or not the argument has a const reference
1109 if (sfk == sfk_copy_constructor)
1110 const_p = TYPE_HAS_CONST_INIT_REF (type);
1111 else if (sfk == sfk_assignment_operator)
1112 const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1114 /* In this case, CONST_P will be ignored. */
1116 /* Declare the function. */
1117 fn = implicitly_declare_fn (sfk, type, const_p);
1118 /* A destructor may be virtual. */
1119 if (sfk == sfk_destructor)
1120 check_for_override (fn, type);
1121 /* Add it to CLASSTYPE_METHOD_VEC. */
1122 add_method (type, fn, NULL_TREE);
1123 /* Add it to TYPE_METHODS. */
1124 if (sfk == sfk_destructor
1125 && DECL_VIRTUAL_P (fn)
1126 && abi_version_at_least (2))
1127 /* The ABI requires that a virtual destructor go at the end of the
1129 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1132 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1133 TYPE_METHODS list, which cause the destructor to be emitted
1134 in an incorrect location in the vtable. */
1135 if (warn_abi && DECL_VIRTUAL_P (fn))
1136 warning (0, "vtable layout for class %qT may not be ABI-compliant"
1137 "and may change in a future version of GCC due to "
1138 "implicit virtual destructor",
1140 TREE_CHAIN (fn) = TYPE_METHODS (type);
1141 TYPE_METHODS (type) = fn;
1143 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1144 if (sfk == sfk_assignment_operator)
1145 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1148 /* Remember that the function has been created. */
1149 if (sfk == sfk_constructor)
1150 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1151 else if (sfk == sfk_copy_constructor)
1152 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1153 else if (sfk == sfk_destructor)
1154 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1155 /* Create appropriate clones. */
1156 clone_function_decl (fn, /*update_method_vec=*/true);
1162 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1163 as there are artificial parms in FN. */
1166 skip_artificial_parms_for (tree fn, tree list)
1168 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1169 list = TREE_CHAIN (list);
1173 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1174 list = TREE_CHAIN (list);
1175 if (DECL_HAS_VTT_PARM_P (fn))
1176 list = TREE_CHAIN (list);
1180 #include "gt-cp-method.h"