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 make_alias_for_thunk (tree);
66 /* Called once to initialize method.c. */
74 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
75 indicates whether it is a this or result adjusting thunk.
76 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
77 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
78 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
79 adjusting thunks, we scale it to a byte offset. For covariant
80 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
81 the returned thunk with finish_thunk. */
84 make_thunk (tree function, bool this_adjusting,
85 tree fixed_offset, tree virtual_offset)
90 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
91 /* We can have this thunks to covariant thunks, but not vice versa. */
92 gcc_assert (!DECL_THIS_THUNK_P (function));
93 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
95 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
96 if (this_adjusting && virtual_offset)
98 = size_binop (MULT_EXPR,
101 TYPE_SIZE_UNIT (vtable_entry_type)));
103 d = tree_low_cst (fixed_offset, 0);
105 /* See if we already have the thunk in question. For this_adjusting
106 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
108 for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
109 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
110 && THUNK_FIXED_OFFSET (thunk) == d
111 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
114 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
116 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
119 /* All thunks must be created before FUNCTION is actually emitted;
120 the ABI requires that all thunks be emitted together with the
121 function to which they transfer control. */
122 gcc_assert (!TREE_ASM_WRITTEN (function));
123 /* Likewise, we can only be adding thunks to a function declared in
124 the class currently being laid out. */
125 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
126 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
128 thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
129 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
130 cxx_dup_lang_specific_decl (thunk);
131 DECL_THUNKS (thunk) = NULL_TREE;
133 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
134 TREE_READONLY (thunk) = TREE_READONLY (function);
135 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
136 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
137 SET_DECL_THUNK_P (thunk, this_adjusting);
138 THUNK_TARGET (thunk) = function;
139 THUNK_FIXED_OFFSET (thunk) = d;
140 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
141 THUNK_ALIAS (thunk) = NULL_TREE;
143 /* The thunk itself is not a constructor or destructor, even if
144 the thing it is thunking to is. */
145 DECL_INTERFACE_KNOWN (thunk) = 1;
146 DECL_NOT_REALLY_EXTERN (thunk) = 1;
147 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
148 DECL_DESTRUCTOR_P (thunk) = 0;
149 DECL_CONSTRUCTOR_P (thunk) = 0;
150 DECL_EXTERNAL (thunk) = 1;
151 DECL_ARTIFICIAL (thunk) = 1;
152 /* Even if this thunk is a member of a local class, we don't
153 need a static chain. */
154 DECL_NO_STATIC_CHAIN (thunk) = 1;
155 /* The THUNK is not a pending inline, even if the FUNCTION is. */
156 DECL_PENDING_INLINE_P (thunk) = 0;
157 DECL_INLINE (thunk) = 0;
158 DECL_DECLARED_INLINE_P (thunk) = 0;
159 /* Nor has it been deferred. */
160 DECL_DEFERRED_FN (thunk) = 0;
161 /* Nor is it a template instantiation. */
162 DECL_USE_TEMPLATE (thunk) = 0;
163 DECL_TEMPLATE_INFO (thunk) = NULL;
165 /* Add it to the list of thunks associated with FUNCTION. */
166 TREE_CHAIN (thunk) = DECL_THUNKS (function);
167 DECL_THUNKS (function) = thunk;
172 /* Finish THUNK, a thunk decl. */
175 finish_thunk (tree thunk)
178 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
179 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
181 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
182 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
183 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
184 function = THUNK_TARGET (thunk);
185 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
186 fixed_offset, virtual_offset);
188 /* We can end up with declarations of (logically) different
189 covariant thunks, that do identical adjustments. The two thunks
190 will be adjusting between within different hierarchies, which
191 happen to have the same layout. We must nullify one of them to
192 refer to the other. */
193 if (DECL_RESULT_THUNK_P (thunk))
197 for (cov_probe = DECL_THUNKS (function);
198 cov_probe; cov_probe = TREE_CHAIN (cov_probe))
199 if (DECL_NAME (cov_probe) == name)
201 gcc_assert (!DECL_THUNKS (thunk));
202 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
203 ? THUNK_ALIAS (cov_probe) : cov_probe);
208 DECL_NAME (thunk) = name;
209 SET_DECL_ASSEMBLER_NAME (thunk, name);
212 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
213 offset indicated by VIRTUAL_OFFSET, if that is
214 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
215 zero for a result adjusting thunk. */
218 thunk_adjust (tree ptr, bool this_adjusting,
219 HOST_WIDE_INT fixed_offset, tree virtual_offset)
222 /* Adjust the pointer by the constant. */
223 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
224 ssize_int (fixed_offset));
226 /* If there's a virtual offset, look up that value in the vtable and
227 adjust the pointer again. */
232 ptr = save_expr (ptr);
233 /* The vptr is always at offset zero in the object. */
234 vtable = build1 (NOP_EXPR,
235 build_pointer_type (build_pointer_type
236 (vtable_entry_type)),
238 /* Form the vtable address. */
239 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
240 /* Find the entry with the vcall offset. */
241 vtable = build2 (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
242 /* Get the offset itself. */
243 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
244 /* Adjust the `this' pointer. */
245 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable);
249 /* Adjust the pointer by the constant. */
250 ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
251 ssize_int (fixed_offset));
256 static GTY (()) int thunk_labelno;
258 /* Create a static alias to function. */
261 make_alias_for (tree function, tree newid)
263 tree alias = build_decl (FUNCTION_DECL, newid, TREE_TYPE (function));
264 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
265 cxx_dup_lang_specific_decl (alias);
266 DECL_CONTEXT (alias) = NULL;
267 TREE_READONLY (alias) = TREE_READONLY (function);
268 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
269 TREE_PUBLIC (alias) = 0;
270 DECL_INTERFACE_KNOWN (alias) = 1;
271 DECL_NOT_REALLY_EXTERN (alias) = 1;
272 DECL_THIS_STATIC (alias) = 1;
273 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
274 DECL_DESTRUCTOR_P (alias) = 0;
275 DECL_CONSTRUCTOR_P (alias) = 0;
276 DECL_CLONED_FUNCTION (alias) = NULL_TREE;
277 DECL_EXTERNAL (alias) = 0;
278 DECL_ARTIFICIAL (alias) = 1;
279 DECL_NO_STATIC_CHAIN (alias) = 1;
280 DECL_PENDING_INLINE_P (alias) = 0;
281 DECL_INLINE (alias) = 0;
282 DECL_DECLARED_INLINE_P (alias) = 0;
283 DECL_DEFERRED_FN (alias) = 0;
284 DECL_USE_TEMPLATE (alias) = 0;
285 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
286 DECL_TEMPLATE_INFO (alias) = NULL;
287 DECL_INITIAL (alias) = error_mark_node;
288 TREE_ADDRESSABLE (alias) = 1;
289 TREE_USED (alias) = 1;
290 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
291 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
296 make_alias_for_thunk (tree function)
301 ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
304 alias = make_alias_for (function, get_identifier (buf));
306 if (!flag_syntax_only)
307 assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
312 /* Emit the definition of a C++ multiple inheritance or covariant
313 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
317 use_thunk (tree thunk_fndecl, bool emit_p)
319 tree a, t, function, alias;
321 HOST_WIDE_INT fixed_offset, virtual_value;
322 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
324 /* We should have called finish_thunk to give it a name. */
325 gcc_assert (DECL_NAME (thunk_fndecl));
327 /* We should never be using an alias, always refer to the
329 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
331 if (TREE_ASM_WRITTEN (thunk_fndecl))
334 function = THUNK_TARGET (thunk_fndecl);
335 if (DECL_RESULT (thunk_fndecl))
336 /* We already turned this thunk into an ordinary function.
337 There's no need to process this thunk again. */
340 if (DECL_THUNK_P (function))
341 /* The target is itself a thunk, process it now. */
342 use_thunk (function, emit_p);
344 /* Thunks are always addressable; they only appear in vtables. */
345 TREE_ADDRESSABLE (thunk_fndecl) = 1;
347 /* Figure out what function is being thunked to. It's referenced in
348 this translation unit. */
349 TREE_ADDRESSABLE (function) = 1;
350 mark_used (function);
354 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
355 alias = make_alias_for_thunk (function);
359 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
360 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
365 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
366 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
367 gcc_assert (virtual_value);
372 /* And, if we need to emit the thunk, it's used. */
373 mark_used (thunk_fndecl);
374 /* This thunk is actually defined. */
375 DECL_EXTERNAL (thunk_fndecl) = 0;
376 /* The linkage of the function may have changed. FIXME in linkage
378 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
379 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
380 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
381 = DECL_VISIBILITY_SPECIFIED (function);
382 if (DECL_ONE_ONLY (function))
383 make_decl_one_only (thunk_fndecl);
385 if (flag_syntax_only)
387 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
391 push_to_top_level ();
393 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
394 && targetm.have_named_sections)
396 resolve_unique_section (function, 0, flag_function_sections);
398 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
400 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
402 /* Output the thunk into the same section as function. */
403 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
407 /* Set up cloned argument trees for the thunk. */
409 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
411 tree x = copy_node (a);
413 DECL_CONTEXT (x) = thunk_fndecl;
414 SET_DECL_RTL (x, NULL_RTX);
415 DECL_HAS_VALUE_EXPR_P (x) = 0;
419 DECL_ARGUMENTS (thunk_fndecl) = a;
422 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
423 virtual_value, alias))
428 current_function_decl = thunk_fndecl;
429 DECL_RESULT (thunk_fndecl)
430 = build_decl (RESULT_DECL, 0, integer_type_node);
431 fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
432 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
434 fn_block = make_node (BLOCK);
435 BLOCK_VARS (fn_block) = a;
436 DECL_INITIAL (thunk_fndecl) = fn_block;
437 init_function_start (thunk_fndecl);
438 current_function_is_thunk = 1;
439 assemble_start_function (thunk_fndecl, fnname);
441 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
442 fixed_offset, virtual_value, alias);
444 assemble_end_function (thunk_fndecl, fnname);
445 init_insn_lengths ();
446 current_function_decl = 0;
448 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
453 tree *argarray = (tree *) alloca (list_length (a) * sizeof (tree));
454 /* If this is a covariant thunk, or we don't have the necessary
455 code for efficient thunks, generate a thunk function that
456 just makes a call to the real function. Unfortunately, this
457 doesn't work for varargs. */
459 if (varargs_function_p (function))
460 error ("generic thunk code fails for method %q#D which uses %<...%>",
463 DECL_RESULT (thunk_fndecl) = NULL_TREE;
465 start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
466 /* We don't bother with a body block for thunks. */
468 /* There's no need to check accessibility inside the thunk body. */
469 push_deferring_access_checks (dk_no_check);
473 t = thunk_adjust (t, /*this_adjusting=*/1,
474 fixed_offset, virtual_offset);
476 /* Build up the call to the real function. */
478 for (i = 1, a = TREE_CHAIN (a); a; a = TREE_CHAIN (a), i++)
480 t = build_call_a (alias, i, argarray);
481 CALL_FROM_THUNK_P (t) = 1;
483 if (VOID_TYPE_P (TREE_TYPE (t)))
484 finish_expr_stmt (t);
489 tree cond = NULL_TREE;
491 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
493 /* If the return type is a pointer, we need to
494 protect against NULL. We know there will be an
495 adjustment, because that's why we're emitting a
498 cond = cp_convert (boolean_type_node, t);
501 t = thunk_adjust (t, /*this_adjusting=*/0,
502 fixed_offset, virtual_offset);
504 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
505 cp_convert (TREE_TYPE (t), integer_zero_node));
507 if (IS_AGGR_TYPE (TREE_TYPE (t)))
508 t = build_cplus_new (TREE_TYPE (t), t);
509 finish_return_stmt (t);
512 /* Since we want to emit the thunk, we explicitly mark its name as
514 mark_decl_referenced (thunk_fndecl);
516 /* But we don't want debugging information about it. */
517 DECL_IGNORED_P (thunk_fndecl) = 1;
519 /* Re-enable access control. */
520 pop_deferring_access_checks ();
522 thunk_fndecl = finish_function (0);
523 tree_lowering_passes (thunk_fndecl);
524 expand_body (thunk_fndecl);
527 pop_from_top_level ();
530 /* Code for synthesizing methods which have default semantics defined. */
532 /* Generate code for default X(X&) constructor. */
535 do_build_copy_constructor (tree fndecl)
537 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
539 parm = convert_from_reference (parm);
541 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
542 && is_empty_class (current_class_type))
543 /* Don't copy the padding byte; it might not have been allocated
544 if *this is a base subobject. */;
545 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
547 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
548 finish_expr_stmt (t);
552 tree fields = TYPE_FIELDS (current_class_type);
553 tree member_init_list = NULL_TREE;
554 int cvquals = cp_type_quals (TREE_TYPE (parm));
556 tree binfo, base_binfo;
557 VEC(tree,gc) *vbases;
559 /* Initialize all the base-classes with the parameter converted
560 to their type so that we get their copy constructor and not
561 another constructor that takes current_class_type. We must
562 deal with the binfo's directly as a direct base might be
563 inaccessible due to ambiguity. */
564 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
565 VEC_iterate (tree, vbases, i, binfo); i++)
569 build_tree_list (NULL_TREE,
570 build_base_path (PLUS_EXPR, parm,
575 for (binfo = TYPE_BINFO (current_class_type), i = 0;
576 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
578 if (BINFO_VIRTUAL_P (base_binfo))
582 = tree_cons (base_binfo,
583 build_tree_list (NULL_TREE,
584 build_base_path (PLUS_EXPR, parm,
589 for (; fields; fields = TREE_CHAIN (fields))
595 if (TREE_CODE (field) != FIELD_DECL)
598 expr_type = TREE_TYPE (field);
599 if (DECL_NAME (field))
601 if (VFIELD_NAME_P (DECL_NAME (field)))
604 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
605 /* Just use the field; anonymous types can't have
606 nontrivial copy ctors or assignment ops. */;
610 /* Compute the type of "init->field". If the copy-constructor
611 parameter is, for example, "const S&", and the type of
612 the field is "T", then the type will usually be "const
613 T". (There are no cv-qualified variants of reference
615 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
619 if (DECL_MUTABLE_P (field))
620 quals &= ~TYPE_QUAL_CONST;
621 expr_type = cp_build_qualified_type (expr_type, quals);
624 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
625 init = build_tree_list (NULL_TREE, init);
627 member_init_list = tree_cons (field, init, member_init_list);
629 finish_mem_initializers (member_init_list);
634 do_build_assign_ref (tree fndecl)
636 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
639 compound_stmt = begin_compound_stmt (0);
640 parm = convert_from_reference (parm);
642 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
643 && is_empty_class (current_class_type))
644 /* Don't copy the padding byte; it might not have been allocated
645 if *this is a base subobject. */;
646 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
648 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
649 finish_expr_stmt (t);
654 int cvquals = cp_type_quals (TREE_TYPE (parm));
656 tree binfo, base_binfo;
658 /* Assign to each of the direct base classes. */
659 for (binfo = TYPE_BINFO (current_class_type), i = 0;
660 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
664 /* We must convert PARM directly to the base class
665 explicitly since the base class may be ambiguous. */
666 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
667 /* Call the base class assignment operator. */
669 (build_special_member_call (current_class_ref,
670 ansi_assopname (NOP_EXPR),
671 build_tree_list (NULL_TREE,
674 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
677 /* Assign to each of the non-static data members. */
678 for (fields = TYPE_FIELDS (current_class_type);
680 fields = TREE_CHAIN (fields))
682 tree comp = current_class_ref;
688 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
691 expr_type = TREE_TYPE (field);
693 if (CP_TYPE_CONST_P (expr_type))
695 error ("non-static const member %q#D, can't use default "
696 "assignment operator", field);
699 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
701 error ("non-static reference member %q#D, can't use "
702 "default assignment operator", field);
706 if (DECL_NAME (field))
708 if (VFIELD_NAME_P (DECL_NAME (field)))
711 else if (ANON_AGGR_TYPE_P (expr_type)
712 && TYPE_FIELDS (expr_type) != NULL_TREE)
713 /* Just use the field; anonymous types can't have
714 nontrivial copy ctors or assignment ops. */;
718 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
720 /* Compute the type of init->field */
722 if (DECL_MUTABLE_P (field))
723 quals &= ~TYPE_QUAL_CONST;
724 expr_type = cp_build_qualified_type (expr_type, quals);
726 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
728 if (DECL_NAME (field))
729 init = build_modify_expr (comp, NOP_EXPR, init);
731 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
732 finish_expr_stmt (init);
735 finish_return_stmt (current_class_ref);
736 finish_compound_stmt (compound_stmt);
739 /* Synthesize FNDECL, a non-static member function. */
742 synthesize_method (tree fndecl)
744 bool nested = (current_function_decl != NULL_TREE);
745 tree context = decl_function_context (fndecl);
746 bool need_body = true;
748 location_t save_input_location = input_location;
749 int error_count = errorcount;
750 int warning_count = warningcount;
752 /* Reset the source location, we might have been previously
753 deferred, and thus have saved where we were first needed. */
754 DECL_SOURCE_LOCATION (fndecl)
755 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
757 /* If we've been asked to synthesize a clone, just synthesize the
758 cloned function instead. Doing so will automatically fill in the
759 body for the clone. */
760 if (DECL_CLONED_FUNCTION_P (fndecl))
761 fndecl = DECL_CLONED_FUNCTION (fndecl);
763 /* We may be in the middle of deferred access check. Disable
765 push_deferring_access_checks (dk_no_deferred);
768 push_to_top_level ();
770 push_function_context_to (context);
772 input_location = DECL_SOURCE_LOCATION (fndecl);
774 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
775 stmt = begin_function_body ();
777 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
779 do_build_assign_ref (fndecl);
782 else if (DECL_CONSTRUCTOR_P (fndecl))
784 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
785 if (arg_chain != void_list_node)
786 do_build_copy_constructor (fndecl);
788 finish_mem_initializers (NULL_TREE);
791 /* If we haven't yet generated the body of the function, just
792 generate an empty compound statement. */
796 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
797 finish_compound_stmt (compound_stmt);
800 finish_function_body (stmt);
801 expand_or_defer_fn (finish_function (0));
803 input_location = save_input_location;
806 pop_from_top_level ();
808 pop_function_context_from (context);
810 pop_deferring_access_checks ();
812 if (error_count != errorcount || warning_count != warningcount)
813 inform ("%Hsynthesized method %qD first required here ",
814 &input_location, fndecl);
817 /* Use EXTRACTOR to locate the relevant function called for each base &
818 class field of TYPE. CLIENT allows additional information to be passed
819 to EXTRACTOR. Generates the union of all exceptions generated by those
820 functions. Note that we haven't updated TYPE_FIELDS and such of any
821 variants yet, so we need to look at the main one. */
824 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
827 tree raises = empty_except_spec;
828 tree fields = TYPE_FIELDS (type);
829 tree binfo, base_binfo;
832 for (binfo = TYPE_BINFO (type), i = 0;
833 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
835 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
838 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
840 raises = merge_exception_specifiers (raises, fn_raises);
843 for (; fields; fields = TREE_CHAIN (fields))
845 tree type = TREE_TYPE (fields);
848 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
850 while (TREE_CODE (type) == ARRAY_TYPE)
851 type = TREE_TYPE (type);
852 if (!CLASS_TYPE_P (type))
855 fn = (*extractor) (type, client);
858 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
860 raises = merge_exception_specifiers (raises, fn_raises);
866 /* Locate the dtor of TYPE. */
869 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
871 return CLASSTYPE_DESTRUCTORS (type);
874 /* Locate the default ctor of TYPE. */
877 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
881 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
884 /* Call lookup_fnfields_1 to create the constructor declarations, if
886 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
887 return lazily_declare_fn (sfk_constructor, type);
889 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
891 tree fn = OVL_CURRENT (fns);
892 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
894 parms = skip_artificial_parms_for (fn, parms);
896 if (sufficient_parms_p (parms))
908 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
909 points to a COPY_DATA holding the name (NULL for the ctor)
910 and desired qualifiers of the source operand. */
913 locate_copy (tree type, void *client_)
915 struct copy_data *client = (struct copy_data *)client_;
917 tree best = NULL_TREE;
918 bool excess_p = false;
923 ix = lookup_fnfields_1 (type, client->name);
926 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
928 else if (TYPE_HAS_INIT_REF (type))
930 /* If construction of the copy constructor was postponed, create
932 if (CLASSTYPE_LAZY_COPY_CTOR (type))
933 lazily_declare_fn (sfk_copy_constructor, type);
934 fns = CLASSTYPE_CONSTRUCTORS (type);
938 for (; fns; fns = OVL_NEXT (fns))
940 tree fn = OVL_CURRENT (fns);
941 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
946 parms = skip_artificial_parms_for (fn, parms);
949 src_type = non_reference (TREE_VALUE (parms));
951 if (src_type == error_mark_node)
954 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
956 if (!sufficient_parms_p (TREE_CHAIN (parms)))
958 quals = cp_type_quals (src_type);
959 if (client->quals & ~quals)
961 excess = quals & ~client->quals;
962 if (!best || (excess_p && !excess))
974 /* Implicitly declare the special function indicated by KIND, as a
975 member of TYPE. For copy constructors and assignment operators,
976 CONST_P indicates whether these functions should take a const
977 reference argument or a non-const reference. Returns the
978 FUNCTION_DECL for the implicitly declared function. */
981 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
984 tree parameter_types = void_list_node;
987 tree raises = empty_except_spec;
988 tree rhs_parm_type = NULL_TREE;
991 HOST_WIDE_INT saved_processing_template_decl;
993 /* Because we create declarations for implicitly declared functions
994 lazily, we may be creating the declaration for a member of TYPE
995 while in some completely different context. However, TYPE will
996 never be a dependent class (because we never want to do lookups
997 for implicitly defined functions in a dependent class).
998 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
999 because we only create clones for constructors and destructors
1000 when not in a template. */
1001 gcc_assert (!dependent_type_p (type));
1002 saved_processing_template_decl = processing_template_decl;
1003 processing_template_decl = 0;
1005 type = TYPE_MAIN_VARIANT (type);
1007 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1009 if (kind == sfk_destructor)
1010 /* See comment in check_special_function_return_type. */
1011 return_type = build_pointer_type (void_type_node);
1013 return_type = build_pointer_type (type);
1016 return_type = void_type_node;
1020 case sfk_destructor:
1022 name = constructor_name (type);
1023 raises = synthesize_exception_spec (type, &locate_dtor, 0);
1026 case sfk_constructor:
1027 /* Default constructor. */
1028 name = constructor_name (type);
1029 raises = synthesize_exception_spec (type, &locate_ctor, 0);
1032 case sfk_copy_constructor:
1033 case sfk_assignment_operator:
1035 struct copy_data data;
1039 if (kind == sfk_assignment_operator)
1041 return_type = build_reference_type (type);
1042 name = ansi_assopname (NOP_EXPR);
1046 name = constructor_name (type);
1050 data.quals = TYPE_QUAL_CONST;
1051 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1054 rhs_parm_type = type;
1055 rhs_parm_type = build_reference_type (rhs_parm_type);
1056 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1057 raises = synthesize_exception_spec (type, &locate_copy, &data);
1064 /* Create the function. */
1065 fn_type = build_method_type_directly (type, return_type, parameter_types);
1067 fn_type = build_exception_variant (fn_type, raises);
1068 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1069 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1070 if (kind == sfk_constructor || kind == sfk_copy_constructor)
1071 DECL_CONSTRUCTOR_P (fn) = 1;
1072 else if (kind == sfk_destructor)
1073 DECL_DESTRUCTOR_P (fn) = 1;
1076 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1077 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1079 /* Create the explicit arguments. */
1082 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1083 want its type to be included in the mangled function
1085 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1086 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1088 /* Add the "this" parameter. */
1089 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1090 TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1091 DECL_ARGUMENTS (fn) = this_parm;
1093 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1094 set_linkage_according_to_type (type, fn);
1095 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1096 DECL_IN_AGGR_P (fn) = 1;
1097 DECL_ARTIFICIAL (fn) = 1;
1098 DECL_NOT_REALLY_EXTERN (fn) = 1;
1099 DECL_DECLARED_INLINE_P (fn) = 1;
1100 DECL_INLINE (fn) = 1;
1101 gcc_assert (!TREE_USED (fn));
1103 /* Restore PROCESSING_TEMPLATE_DECL. */
1104 processing_template_decl = saved_processing_template_decl;
1109 /* Add an implicit declaration to TYPE for the kind of function
1110 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1114 lazily_declare_fn (special_function_kind sfk, tree type)
1119 /* Figure out whether or not the argument has a const reference
1121 if (sfk == sfk_copy_constructor)
1122 const_p = TYPE_HAS_CONST_INIT_REF (type);
1123 else if (sfk == sfk_assignment_operator)
1124 const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1126 /* In this case, CONST_P will be ignored. */
1128 /* Declare the function. */
1129 fn = implicitly_declare_fn (sfk, type, const_p);
1130 /* A destructor may be virtual. */
1131 if (sfk == sfk_destructor)
1132 check_for_override (fn, type);
1133 /* Add it to CLASSTYPE_METHOD_VEC. */
1134 add_method (type, fn, NULL_TREE);
1135 /* Add it to TYPE_METHODS. */
1136 if (sfk == sfk_destructor
1137 && DECL_VIRTUAL_P (fn)
1138 && abi_version_at_least (2))
1139 /* The ABI requires that a virtual destructor go at the end of the
1141 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1144 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1145 TYPE_METHODS list, which cause the destructor to be emitted
1146 in an incorrect location in the vtable. */
1147 if (warn_abi && DECL_VIRTUAL_P (fn))
1148 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1149 "and may change in a future version of GCC due to "
1150 "implicit virtual destructor",
1152 TREE_CHAIN (fn) = TYPE_METHODS (type);
1153 TYPE_METHODS (type) = fn;
1155 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1156 if (sfk == sfk_assignment_operator)
1157 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1160 /* Remember that the function has been created. */
1161 if (sfk == sfk_constructor)
1162 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1163 else if (sfk == sfk_copy_constructor)
1164 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1165 else if (sfk == sfk_destructor)
1166 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1167 /* Create appropriate clones. */
1168 clone_function_decl (fn, /*update_method_vec=*/true);
1174 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1175 as there are artificial parms in FN. */
1178 skip_artificial_parms_for (tree fn, tree list)
1180 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1181 list = TREE_CHAIN (list);
1185 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1186 list = TREE_CHAIN (list);
1187 if (DECL_HAS_VTT_PARM_P (fn))
1188 list = TREE_CHAIN (list);
1192 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1193 artificial parms in FN. */
1196 num_artificial_parms_for (tree fn)
1200 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1205 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1207 if (DECL_HAS_VTT_PARM_P (fn))
1213 #include "gt-cp-method.h"