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, 2007, 2008, 2009
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
39 #include "tree-pass.h"
40 #include "diagnostic.h"
43 /* Various flags to control the mangling process. */
49 /* The thing we are presently mangling is part of a template type,
50 rather than a fully instantiated type. Therefore, we may see
51 complex expressions where we would normally expect to see a
52 simple integer constant. */
53 mf_maybe_uninstantiated
= 1,
54 /* When mangling a numeric value, use the form `_XX_' (instead of
55 just `XX') if the value has more than one digit. */
56 mf_use_underscores_around_value
= 2
59 typedef enum mangling_flags mangling_flags
;
61 static tree
thunk_adjust (tree
, bool, HOST_WIDE_INT
, tree
);
62 static void do_build_assign_ref (tree
);
63 static void do_build_copy_constructor (tree
);
64 static tree
synthesize_exception_spec (tree
, tree (*) (tree
, void *), void *);
65 static tree
make_alias_for_thunk (tree
);
67 /* Called once to initialize method.c. */
75 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
76 indicates whether it is a this or result adjusting thunk.
77 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
78 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
79 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
80 adjusting thunks, we scale it to a byte offset. For covariant
81 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
82 the returned thunk with finish_thunk. */
85 make_thunk (tree function
, bool this_adjusting
,
86 tree fixed_offset
, tree virtual_offset
)
91 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
);
92 /* We can have this thunks to covariant thunks, but not vice versa. */
93 gcc_assert (!DECL_THIS_THUNK_P (function
));
94 gcc_assert (!DECL_RESULT_THUNK_P (function
) || this_adjusting
);
96 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
97 if (this_adjusting
&& virtual_offset
)
99 = size_binop (MULT_EXPR
,
102 TYPE_SIZE_UNIT (vtable_entry_type
)));
104 d
= tree_low_cst (fixed_offset
, 0);
106 /* See if we already have the thunk in question. For this_adjusting
107 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
109 for (thunk
= DECL_THUNKS (function
); thunk
; thunk
= TREE_CHAIN (thunk
))
110 if (DECL_THIS_THUNK_P (thunk
) == this_adjusting
111 && THUNK_FIXED_OFFSET (thunk
) == d
112 && !virtual_offset
== !THUNK_VIRTUAL_OFFSET (thunk
)
115 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk
),
117 : THUNK_VIRTUAL_OFFSET (thunk
) == virtual_offset
)))
120 /* All thunks must be created before FUNCTION is actually emitted;
121 the ABI requires that all thunks be emitted together with the
122 function to which they transfer control. */
123 gcc_assert (!TREE_ASM_WRITTEN (function
));
124 /* Likewise, we can only be adding thunks to a function declared in
125 the class currently being laid out. */
126 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function
))
127 && TYPE_BEING_DEFINED (DECL_CONTEXT (function
)));
129 thunk
= build_decl (DECL_SOURCE_LOCATION (function
),
130 FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
131 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
132 cxx_dup_lang_specific_decl (thunk
);
133 DECL_THUNKS (thunk
) = NULL_TREE
;
135 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
136 TREE_READONLY (thunk
) = TREE_READONLY (function
);
137 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
138 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
139 SET_DECL_THUNK_P (thunk
, this_adjusting
);
140 THUNK_TARGET (thunk
) = function
;
141 THUNK_FIXED_OFFSET (thunk
) = d
;
142 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
143 THUNK_ALIAS (thunk
) = NULL_TREE
;
145 /* The thunk itself is not a constructor or destructor, even if
146 the thing it is thunking to is. */
147 DECL_INTERFACE_KNOWN (thunk
) = 1;
148 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
149 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
150 DECL_DESTRUCTOR_P (thunk
) = 0;
151 DECL_CONSTRUCTOR_P (thunk
) = 0;
152 DECL_EXTERNAL (thunk
) = 1;
153 DECL_ARTIFICIAL (thunk
) = 1;
154 /* Even if this thunk is a member of a local class, we don't
155 need a static chain. */
156 DECL_NO_STATIC_CHAIN (thunk
) = 1;
157 /* The THUNK is not a pending inline, even if the FUNCTION is. */
158 DECL_PENDING_INLINE_P (thunk
) = 0;
159 DECL_DECLARED_INLINE_P (thunk
) = 0;
160 /* Nor has it been deferred. */
161 DECL_DEFERRED_FN (thunk
) = 0;
162 /* Nor is it a template instantiation. */
163 DECL_USE_TEMPLATE (thunk
) = 0;
164 DECL_TEMPLATE_INFO (thunk
) = NULL
;
166 /* Add it to the list of thunks associated with FUNCTION. */
167 TREE_CHAIN (thunk
) = DECL_THUNKS (function
);
168 DECL_THUNKS (function
) = thunk
;
173 /* Finish THUNK, a thunk decl. */
176 finish_thunk (tree thunk
)
179 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
180 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
182 gcc_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
));
183 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
184 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
185 function
= THUNK_TARGET (thunk
);
186 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
187 fixed_offset
, virtual_offset
);
189 /* We can end up with declarations of (logically) different
190 covariant thunks, that do identical adjustments. The two thunks
191 will be adjusting between within different hierarchies, which
192 happen to have the same layout. We must nullify one of them to
193 refer to the other. */
194 if (DECL_RESULT_THUNK_P (thunk
))
198 for (cov_probe
= DECL_THUNKS (function
);
199 cov_probe
; cov_probe
= TREE_CHAIN (cov_probe
))
200 if (DECL_NAME (cov_probe
) == name
)
202 gcc_assert (!DECL_THUNKS (thunk
));
203 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
204 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
209 DECL_NAME (thunk
) = name
;
210 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
213 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
214 offset indicated by VIRTUAL_OFFSET, if that is
215 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
216 zero for a result adjusting thunk. */
219 thunk_adjust (tree ptr
, bool this_adjusting
,
220 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
223 /* Adjust the pointer by the constant. */
224 ptr
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
225 size_int (fixed_offset
));
227 /* If there's a virtual offset, look up that value in the vtable and
228 adjust the pointer again. */
233 ptr
= save_expr (ptr
);
234 /* The vptr is always at offset zero in the object. */
235 vtable
= build1 (NOP_EXPR
,
236 build_pointer_type (build_pointer_type
237 (vtable_entry_type
)),
239 /* Form the vtable address. */
240 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
241 /* Find the entry with the vcall offset. */
242 vtable
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (vtable
), vtable
,
243 fold_convert (sizetype
, 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 (POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
248 fold_convert (sizetype
, vtable
));
252 /* Adjust the pointer by the constant. */
253 ptr
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
254 size_int (fixed_offset
));
259 static GTY (()) int thunk_labelno
;
261 /* Create a static alias to function. */
264 make_alias_for (tree function
, tree newid
)
266 tree alias
= build_decl (DECL_SOURCE_LOCATION (function
),
267 FUNCTION_DECL
, newid
, TREE_TYPE (function
));
268 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
269 cxx_dup_lang_specific_decl (alias
);
270 DECL_CONTEXT (alias
) = NULL
;
271 TREE_READONLY (alias
) = TREE_READONLY (function
);
272 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
273 TREE_PUBLIC (alias
) = 0;
274 DECL_INTERFACE_KNOWN (alias
) = 1;
275 DECL_NOT_REALLY_EXTERN (alias
) = 1;
276 DECL_THIS_STATIC (alias
) = 1;
277 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
278 DECL_DESTRUCTOR_P (alias
) = 0;
279 DECL_CONSTRUCTOR_P (alias
) = 0;
280 DECL_EXTERNAL (alias
) = 0;
281 DECL_ARTIFICIAL (alias
) = 1;
282 DECL_NO_STATIC_CHAIN (alias
) = 1;
283 DECL_PENDING_INLINE_P (alias
) = 0;
284 DECL_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 (DECL_ONE_ONLY (function
))
385 make_decl_one_only (thunk_fndecl
, cxx_comdat_group (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 /* Set up cloned argument trees for the thunk. */
411 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
413 tree x
= copy_node (a
);
415 DECL_CONTEXT (x
) = thunk_fndecl
;
416 SET_DECL_RTL (x
, NULL_RTX
);
417 DECL_HAS_VALUE_EXPR_P (x
) = 0;
421 DECL_ARGUMENTS (thunk_fndecl
) = a
;
424 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
425 virtual_value
, alias
))
430 current_function_decl
= thunk_fndecl
;
431 DECL_RESULT (thunk_fndecl
)
432 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
433 RESULT_DECL
, 0, integer_type_node
);
434 fnname
= IDENTIFIER_POINTER (DECL_NAME (thunk_fndecl
));
435 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
437 fn_block
= make_node (BLOCK
);
438 BLOCK_VARS (fn_block
) = a
;
439 DECL_INITIAL (thunk_fndecl
) = fn_block
;
440 init_function_start (thunk_fndecl
);
442 assemble_start_function (thunk_fndecl
, fnname
);
444 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
445 fixed_offset
, virtual_value
, alias
);
447 assemble_end_function (thunk_fndecl
, fnname
);
448 init_insn_lengths ();
449 current_function_decl
= 0;
451 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
456 tree
*argarray
= (tree
*) alloca (list_length (a
) * sizeof (tree
));
457 /* If this is a covariant thunk, or we don't have the necessary
458 code for efficient thunks, generate a thunk function that
459 just makes a call to the real function. Unfortunately, this
460 doesn't work for varargs. */
462 if (varargs_function_p (function
))
463 error ("generic thunk code fails for method %q#D which uses %<...%>",
466 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
468 start_preparsed_function (thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
469 /* We don't bother with a body block for thunks. */
471 /* There's no need to check accessibility inside the thunk body. */
472 push_deferring_access_checks (dk_no_check
);
476 t
= thunk_adjust (t
, /*this_adjusting=*/1,
477 fixed_offset
, virtual_offset
);
479 /* Build up the call to the real function. */
481 for (i
= 1, a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
), i
++)
483 t
= build_call_a (alias
, i
, argarray
);
484 CALL_FROM_THUNK_P (t
) = 1;
485 CALL_CANNOT_INLINE_P (t
) = 1;
487 if (VOID_TYPE_P (TREE_TYPE (t
)))
488 finish_expr_stmt (t
);
493 tree cond
= NULL_TREE
;
495 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
497 /* If the return type is a pointer, we need to
498 protect against NULL. We know there will be an
499 adjustment, because that's why we're emitting a
502 cond
= cp_convert (boolean_type_node
, t
);
505 t
= thunk_adjust (t
, /*this_adjusting=*/0,
506 fixed_offset
, virtual_offset
);
508 t
= build3 (COND_EXPR
, TREE_TYPE (t
), cond
, t
,
509 cp_convert (TREE_TYPE (t
), integer_zero_node
));
511 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (t
)))
512 t
= build_cplus_new (TREE_TYPE (t
), t
);
513 finish_return_stmt (t
);
516 /* Since we want to emit the thunk, we explicitly mark its name as
518 mark_decl_referenced (thunk_fndecl
);
520 /* But we don't want debugging information about it. */
521 DECL_IGNORED_P (thunk_fndecl
) = 1;
523 /* Re-enable access control. */
524 pop_deferring_access_checks ();
526 thunk_fndecl
= finish_function (0);
527 cgraph_add_new_function (thunk_fndecl
, false);
530 pop_from_top_level ();
533 /* Code for synthesizing methods which have default semantics defined. */
535 /* Generate code for default X(X&) constructor. */
538 do_build_copy_constructor (tree fndecl
)
540 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
542 parm
= convert_from_reference (parm
);
544 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
545 && is_empty_class (current_class_type
))
546 /* Don't copy the padding byte; it might not have been allocated
547 if *this is a base subobject. */;
548 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
550 tree t
= build2 (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
551 finish_expr_stmt (t
);
555 tree fields
= TYPE_FIELDS (current_class_type
);
556 tree member_init_list
= NULL_TREE
;
557 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
559 tree binfo
, base_binfo
;
560 VEC(tree
,gc
) *vbases
;
562 /* Initialize all the base-classes with the parameter converted
563 to their type so that we get their copy constructor and not
564 another constructor that takes current_class_type. We must
565 deal with the binfo's directly as a direct base might be
566 inaccessible due to ambiguity. */
567 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
568 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
572 build_tree_list (NULL_TREE
,
573 build_base_path (PLUS_EXPR
, parm
,
578 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
579 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
581 if (BINFO_VIRTUAL_P (base_binfo
))
585 = tree_cons (base_binfo
,
586 build_tree_list (NULL_TREE
,
587 build_base_path (PLUS_EXPR
, parm
,
592 for (; fields
; fields
= TREE_CHAIN (fields
))
598 if (TREE_CODE (field
) != FIELD_DECL
)
601 expr_type
= TREE_TYPE (field
);
602 if (DECL_NAME (field
))
604 if (VFIELD_NAME_P (DECL_NAME (field
)))
607 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
608 /* Just use the field; anonymous types can't have
609 nontrivial copy ctors or assignment ops. */;
613 /* Compute the type of "init->field". If the copy-constructor
614 parameter is, for example, "const S&", and the type of
615 the field is "T", then the type will usually be "const
616 T". (There are no cv-qualified variants of reference
618 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
622 if (DECL_MUTABLE_P (field
))
623 quals
&= ~TYPE_QUAL_CONST
;
624 expr_type
= cp_build_qualified_type (expr_type
, quals
);
627 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
628 init
= build_tree_list (NULL_TREE
, init
);
630 member_init_list
= tree_cons (field
, init
, member_init_list
);
632 finish_mem_initializers (member_init_list
);
637 do_build_assign_ref (tree fndecl
)
639 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
642 compound_stmt
= begin_compound_stmt (0);
643 parm
= convert_from_reference (parm
);
645 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
646 && is_empty_class (current_class_type
))
647 /* Don't copy the padding byte; it might not have been allocated
648 if *this is a base subobject. */;
649 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
651 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
652 finish_expr_stmt (t
);
657 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
659 tree binfo
, base_binfo
;
661 /* Assign to each of the direct base classes. */
662 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
663 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
666 VEC(tree
,gc
) *parmvec
;
668 /* We must convert PARM directly to the base class
669 explicitly since the base class may be ambiguous. */
670 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
671 /* Call the base class assignment operator. */
672 parmvec
= make_tree_vector_single (converted_parm
);
674 (build_special_member_call (current_class_ref
,
675 ansi_assopname (NOP_EXPR
),
678 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
679 tf_warning_or_error
));
680 release_tree_vector (parmvec
);
683 /* Assign to each of the non-static data members. */
684 for (fields
= TYPE_FIELDS (current_class_type
);
686 fields
= TREE_CHAIN (fields
))
688 tree comp
= current_class_ref
;
694 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
697 expr_type
= TREE_TYPE (field
);
699 if (CP_TYPE_CONST_P (expr_type
))
701 error ("non-static const member %q#D, can't use default "
702 "assignment operator", field
);
705 else if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
707 error ("non-static reference member %q#D, can't use "
708 "default assignment operator", field
);
712 if (DECL_NAME (field
))
714 if (VFIELD_NAME_P (DECL_NAME (field
)))
717 else if (ANON_AGGR_TYPE_P (expr_type
)
718 && TYPE_FIELDS (expr_type
) != NULL_TREE
)
719 /* Just use the field; anonymous types can't have
720 nontrivial copy ctors or assignment ops. */;
724 comp
= build3 (COMPONENT_REF
, expr_type
, comp
, field
, NULL_TREE
);
726 /* Compute the type of init->field */
728 if (DECL_MUTABLE_P (field
))
729 quals
&= ~TYPE_QUAL_CONST
;
730 expr_type
= cp_build_qualified_type (expr_type
, quals
);
732 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
734 if (DECL_NAME (field
))
735 init
= cp_build_modify_expr (comp
, NOP_EXPR
, init
,
736 tf_warning_or_error
);
738 init
= build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
739 finish_expr_stmt (init
);
742 finish_return_stmt (current_class_ref
);
743 finish_compound_stmt (compound_stmt
);
746 /* Synthesize FNDECL, a non-static member function. */
749 synthesize_method (tree fndecl
)
751 bool nested
= (current_function_decl
!= NULL_TREE
);
752 tree context
= decl_function_context (fndecl
);
753 bool need_body
= true;
755 location_t save_input_location
= input_location
;
756 int error_count
= errorcount
;
757 int warning_count
= warningcount
;
759 /* Reset the source location, we might have been previously
760 deferred, and thus have saved where we were first needed. */
761 DECL_SOURCE_LOCATION (fndecl
)
762 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl
)));
764 /* If we've been asked to synthesize a clone, just synthesize the
765 cloned function instead. Doing so will automatically fill in the
766 body for the clone. */
767 if (DECL_CLONED_FUNCTION_P (fndecl
))
768 fndecl
= DECL_CLONED_FUNCTION (fndecl
);
770 /* We may be in the middle of deferred access check. Disable
772 push_deferring_access_checks (dk_no_deferred
);
775 push_to_top_level ();
777 push_function_context ();
779 input_location
= DECL_SOURCE_LOCATION (fndecl
);
781 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
782 stmt
= begin_function_body ();
784 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
786 do_build_assign_ref (fndecl
);
789 else if (DECL_CONSTRUCTOR_P (fndecl
))
791 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
792 if (arg_chain
!= void_list_node
)
793 do_build_copy_constructor (fndecl
);
795 finish_mem_initializers (NULL_TREE
);
798 /* If we haven't yet generated the body of the function, just
799 generate an empty compound statement. */
803 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
804 finish_compound_stmt (compound_stmt
);
807 finish_function_body (stmt
);
808 expand_or_defer_fn (finish_function (0));
810 input_location
= save_input_location
;
813 pop_from_top_level ();
815 pop_function_context ();
817 pop_deferring_access_checks ();
819 if (error_count
!= errorcount
|| warning_count
!= warningcount
)
820 inform (input_location
, "synthesized method %qD first required here ",
824 /* Use EXTRACTOR to locate the relevant function called for each base &
825 class field of TYPE. CLIENT allows additional information to be passed
826 to EXTRACTOR. Generates the union of all exceptions generated by those
827 functions. Note that we haven't updated TYPE_FIELDS and such of any
828 variants yet, so we need to look at the main one. */
831 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
834 tree raises
= empty_except_spec
;
835 tree fields
= TYPE_FIELDS (type
);
836 tree binfo
, base_binfo
;
839 for (binfo
= TYPE_BINFO (type
), i
= 0;
840 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
842 tree fn
= (*extractor
) (BINFO_TYPE (base_binfo
), client
);
845 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
847 raises
= merge_exception_specifiers (raises
, fn_raises
);
850 for (; fields
; fields
= TREE_CHAIN (fields
))
852 tree type
= TREE_TYPE (fields
);
855 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
857 while (TREE_CODE (type
) == ARRAY_TYPE
)
858 type
= TREE_TYPE (type
);
859 if (!CLASS_TYPE_P (type
))
862 fn
= (*extractor
) (type
, client
);
865 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
867 raises
= merge_exception_specifiers (raises
, fn_raises
);
873 /* Locate the dtor of TYPE. */
876 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
878 return CLASSTYPE_DESTRUCTORS (type
);
881 /* Locate the default ctor of TYPE. */
884 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
888 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
891 /* Call lookup_fnfields_1 to create the constructor declarations, if
893 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
894 return lazily_declare_fn (sfk_constructor
, type
);
896 for (fns
= CLASSTYPE_CONSTRUCTORS (type
); fns
; fns
= OVL_NEXT (fns
))
898 tree fn
= OVL_CURRENT (fns
);
899 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
901 parms
= skip_artificial_parms_for (fn
, parms
);
903 if (sufficient_parms_p (parms
))
915 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
916 points to a COPY_DATA holding the name (NULL for the ctor)
917 and desired qualifiers of the source operand. */
920 locate_copy (tree type
, void *client_
)
922 struct copy_data
*client
= (struct copy_data
*)client_
;
924 tree best
= NULL_TREE
;
925 bool excess_p
= false;
930 ix
= lookup_fnfields_1 (type
, client
->name
);
933 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
935 else if (TYPE_HAS_INIT_REF (type
))
937 /* If construction of the copy constructor was postponed, create
939 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
940 lazily_declare_fn (sfk_copy_constructor
, type
);
941 fns
= CLASSTYPE_CONSTRUCTORS (type
);
945 for (; fns
; fns
= OVL_NEXT (fns
))
947 tree fn
= OVL_CURRENT (fns
);
948 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
953 parms
= skip_artificial_parms_for (fn
, parms
);
956 src_type
= non_reference (TREE_VALUE (parms
));
958 if (src_type
== error_mark_node
)
961 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
963 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
965 quals
= cp_type_quals (src_type
);
966 if (client
->quals
& ~quals
)
968 excess
= quals
& ~client
->quals
;
969 if (!best
|| (excess_p
&& !excess
))
981 /* Implicitly declare the special function indicated by KIND, as a
982 member of TYPE. For copy constructors and assignment operators,
983 CONST_P indicates whether these functions should take a const
984 reference argument or a non-const reference. Returns the
985 FUNCTION_DECL for the implicitly declared function. */
988 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
991 tree parameter_types
= void_list_node
;
994 tree raises
= empty_except_spec
;
995 tree rhs_parm_type
= NULL_TREE
;
998 HOST_WIDE_INT saved_processing_template_decl
;
1000 /* Because we create declarations for implicitly declared functions
1001 lazily, we may be creating the declaration for a member of TYPE
1002 while in some completely different context. However, TYPE will
1003 never be a dependent class (because we never want to do lookups
1004 for implicitly defined functions in a dependent class).
1005 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1006 because we only create clones for constructors and destructors
1007 when not in a template. */
1008 gcc_assert (!dependent_type_p (type
));
1009 saved_processing_template_decl
= processing_template_decl
;
1010 processing_template_decl
= 0;
1012 type
= TYPE_MAIN_VARIANT (type
);
1014 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
1016 if (kind
== sfk_destructor
)
1017 /* See comment in check_special_function_return_type. */
1018 return_type
= build_pointer_type (void_type_node
);
1020 return_type
= build_pointer_type (type
);
1023 return_type
= void_type_node
;
1027 case sfk_destructor
:
1029 name
= constructor_name (type
);
1030 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
1033 case sfk_constructor
:
1034 /* Default constructor. */
1035 name
= constructor_name (type
);
1036 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
1039 case sfk_copy_constructor
:
1040 case sfk_assignment_operator
:
1042 struct copy_data data
;
1046 if (kind
== sfk_assignment_operator
)
1048 return_type
= build_reference_type (type
);
1049 name
= ansi_assopname (NOP_EXPR
);
1053 name
= constructor_name (type
);
1057 data
.quals
= TYPE_QUAL_CONST
;
1058 rhs_parm_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
1061 rhs_parm_type
= type
;
1062 rhs_parm_type
= build_reference_type (rhs_parm_type
);
1063 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
1064 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1071 /* Create the function. */
1072 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1074 fn_type
= build_exception_variant (fn_type
, raises
);
1075 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1076 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1077 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
)
1078 DECL_CONSTRUCTOR_P (fn
) = 1;
1079 else if (kind
== sfk_destructor
)
1080 DECL_DESTRUCTOR_P (fn
) = 1;
1083 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1084 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1087 /* If pointers to member functions use the least significant bit to
1088 indicate whether a function is virtual, ensure a pointer
1089 to this function will have that bit clear. */
1090 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
1091 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
1092 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
1094 /* Create the explicit arguments. */
1097 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1098 want its type to be included in the mangled function
1100 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1101 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1103 /* Add the "this" parameter. */
1104 this_parm
= build_this_parm (fn_type
, TYPE_UNQUALIFIED
);
1105 TREE_CHAIN (this_parm
) = DECL_ARGUMENTS (fn
);
1106 DECL_ARGUMENTS (fn
) = this_parm
;
1108 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
);
1109 set_linkage_according_to_type (type
, fn
);
1110 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1111 DECL_IN_AGGR_P (fn
) = 1;
1112 DECL_ARTIFICIAL (fn
) = 1;
1113 DECL_DEFAULTED_FN (fn
) = 1;
1114 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1115 DECL_DECLARED_INLINE_P (fn
) = 1;
1116 gcc_assert (!TREE_USED (fn
));
1118 /* Restore PROCESSING_TEMPLATE_DECL. */
1119 processing_template_decl
= saved_processing_template_decl
;
1124 /* Add an implicit declaration to TYPE for the kind of function
1125 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1129 lazily_declare_fn (special_function_kind sfk
, tree type
)
1134 /* Figure out whether or not the argument has a const reference
1136 if (sfk
== sfk_copy_constructor
)
1137 const_p
= TYPE_HAS_CONST_INIT_REF (type
);
1138 else if (sfk
== sfk_assignment_operator
)
1139 const_p
= TYPE_HAS_CONST_ASSIGN_REF (type
);
1141 /* In this case, CONST_P will be ignored. */
1143 /* Declare the function. */
1144 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1145 /* A destructor may be virtual. */
1146 if (sfk
== sfk_destructor
)
1147 check_for_override (fn
, type
);
1148 /* Add it to CLASSTYPE_METHOD_VEC. */
1149 add_method (type
, fn
, NULL_TREE
);
1150 /* Add it to TYPE_METHODS. */
1151 if (sfk
== sfk_destructor
1152 && DECL_VIRTUAL_P (fn
)
1153 && abi_version_at_least (2))
1154 /* The ABI requires that a virtual destructor go at the end of the
1156 TYPE_METHODS (type
) = chainon (TYPE_METHODS (type
), fn
);
1159 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1160 TYPE_METHODS list, which cause the destructor to be emitted
1161 in an incorrect location in the vtable. */
1162 if (warn_abi
&& DECL_VIRTUAL_P (fn
))
1163 warning (OPT_Wabi
, "vtable layout for class %qT may not be ABI-compliant"
1164 "and may change in a future version of GCC due to "
1165 "implicit virtual destructor",
1167 TREE_CHAIN (fn
) = TYPE_METHODS (type
);
1168 TYPE_METHODS (type
) = fn
;
1170 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1171 if (sfk
== sfk_assignment_operator
)
1172 CLASSTYPE_LAZY_ASSIGNMENT_OP (type
) = 0;
1175 /* Remember that the function has been created. */
1176 if (sfk
== sfk_constructor
)
1177 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1178 else if (sfk
== sfk_copy_constructor
)
1179 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1180 else if (sfk
== sfk_destructor
)
1181 CLASSTYPE_LAZY_DESTRUCTOR (type
) = 0;
1182 /* Create appropriate clones. */
1183 clone_function_decl (fn
, /*update_method_vec=*/true);
1189 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1190 as there are artificial parms in FN. */
1193 skip_artificial_parms_for (const_tree fn
, tree list
)
1195 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1196 list
= TREE_CHAIN (list
);
1200 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1201 list
= TREE_CHAIN (list
);
1202 if (DECL_HAS_VTT_PARM_P (fn
))
1203 list
= TREE_CHAIN (list
);
1207 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1208 artificial parms in FN. */
1211 num_artificial_parms_for (const_tree fn
)
1215 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1220 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1222 if (DECL_HAS_VTT_PARM_P (fn
))
1228 #include "gt-cp-method.h"