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 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"
40 /* Various flags to control the mangling process. */
46 /* The thing we are presently mangling is part of a template type,
47 rather than a fully instantiated type. Therefore, we may see
48 complex expressions where we would normally expect to see a
49 simple integer constant. */
50 mf_maybe_uninstantiated
= 1,
51 /* When mangling a numeric value, use the form `_XX_' (instead of
52 just `XX') if the value has more than one digit. */
53 mf_use_underscores_around_value
= 2
56 typedef enum mangling_flags mangling_flags
;
58 static tree
thunk_adjust (tree
, bool, HOST_WIDE_INT
, tree
);
59 static void do_build_assign_ref (tree
);
60 static void do_build_copy_constructor (tree
);
61 static tree
synthesize_exception_spec (tree
, tree (*) (tree
, void *), void *);
62 static tree
locate_dtor (tree
, void *);
63 static tree
locate_ctor (tree
, void *);
64 static tree
locate_copy (tree
, 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 (FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
130 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
131 cxx_dup_lang_specific_decl (thunk
);
132 DECL_THUNKS (thunk
) = NULL_TREE
;
134 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
135 TREE_READONLY (thunk
) = TREE_READONLY (function
);
136 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
137 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
139 comdat_linkage (thunk
);
140 SET_DECL_THUNK_P (thunk
, this_adjusting
);
141 THUNK_TARGET (thunk
) = function
;
142 THUNK_FIXED_OFFSET (thunk
) = d
;
143 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
144 THUNK_ALIAS (thunk
) = NULL_TREE
;
146 /* The thunk itself is not a constructor or destructor, even if
147 the thing it is thunking to is. */
148 DECL_INTERFACE_KNOWN (thunk
) = 1;
149 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
150 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
151 DECL_DESTRUCTOR_P (thunk
) = 0;
152 DECL_CONSTRUCTOR_P (thunk
) = 0;
153 DECL_EXTERNAL (thunk
) = 1;
154 DECL_ARTIFICIAL (thunk
) = 1;
155 /* Even if this thunk is a member of a local class, we don't
156 need a static chain. */
157 DECL_NO_STATIC_CHAIN (thunk
) = 1;
158 /* The THUNK is not a pending inline, even if the FUNCTION is. */
159 DECL_PENDING_INLINE_P (thunk
) = 0;
160 DECL_INLINE (thunk
) = 0;
161 DECL_DECLARED_INLINE_P (thunk
) = 0;
162 /* Nor has it been deferred. */
163 DECL_DEFERRED_FN (thunk
) = 0;
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_thunk (tree function
)
266 ASM_GENERATE_INTERNAL_LABEL (buf
, "LTHUNK", thunk_labelno
);
268 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
269 TREE_TYPE (function
));
270 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
271 cxx_dup_lang_specific_decl (alias
);
272 DECL_CONTEXT (alias
) = NULL
;
273 TREE_READONLY (alias
) = TREE_READONLY (function
);
274 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
275 TREE_PUBLIC (alias
) = 0;
276 DECL_INTERFACE_KNOWN (alias
) = 1;
277 DECL_NOT_REALLY_EXTERN (alias
) = 1;
278 DECL_THIS_STATIC (alias
) = 1;
279 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
280 DECL_DESTRUCTOR_P (alias
) = 0;
281 DECL_CONSTRUCTOR_P (alias
) = 0;
282 DECL_CLONED_FUNCTION (alias
) = NULL_TREE
;
283 DECL_EXTERNAL (alias
) = 0;
284 DECL_ARTIFICIAL (alias
) = 1;
285 DECL_NO_STATIC_CHAIN (alias
) = 1;
286 DECL_PENDING_INLINE_P (alias
) = 0;
287 DECL_INLINE (alias
) = 0;
288 DECL_DECLARED_INLINE_P (alias
) = 0;
289 DECL_DEFERRED_FN (alias
) = 0;
290 DECL_USE_TEMPLATE (alias
) = 0;
291 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
292 DECL_TEMPLATE_INFO (alias
) = NULL
;
293 DECL_INITIAL (alias
) = error_mark_node
;
294 TREE_ADDRESSABLE (alias
) = 1;
295 TREE_USED (alias
) = 1;
296 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
297 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
298 if (!flag_syntax_only
)
299 assemble_alias (alias
, DECL_ASSEMBLER_NAME (function
));
303 /* Emit the definition of a C++ multiple inheritance or covariant
304 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
308 use_thunk (tree thunk_fndecl
, bool emit_p
)
310 tree a
, t
, function
, alias
;
312 HOST_WIDE_INT fixed_offset
, virtual_value
;
313 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
315 /* We should have called finish_thunk to give it a name. */
316 gcc_assert (DECL_NAME (thunk_fndecl
));
318 /* We should never be using an alias, always refer to the
320 gcc_assert (!THUNK_ALIAS (thunk_fndecl
));
322 if (TREE_ASM_WRITTEN (thunk_fndecl
))
325 function
= THUNK_TARGET (thunk_fndecl
);
326 if (DECL_RESULT (thunk_fndecl
))
327 /* We already turned this thunk into an ordinary function.
328 There's no need to process this thunk again. */
331 /* Thunks are always addressable; they only appear in vtables. */
332 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
334 /* Figure out what function is being thunked to. It's referenced in
335 this translation unit. */
336 TREE_ADDRESSABLE (function
) = 1;
337 mark_used (function
);
341 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
))
342 alias
= make_alias_for_thunk (function
);
346 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
347 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
352 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
353 virtual_value
= tree_low_cst (virtual_offset
, /*pos=*/0);
354 gcc_assert (virtual_value
);
359 /* And, if we need to emit the thunk, it's used. */
360 mark_used (thunk_fndecl
);
361 /* This thunk is actually defined. */
362 DECL_EXTERNAL (thunk_fndecl
) = 0;
363 /* The linkage of the function may have changed. FIXME in linkage
365 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
366 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
367 DECL_VISIBILITY_SPECIFIED (thunk_fndecl
)
368 = DECL_VISIBILITY_SPECIFIED (function
);
369 if (flag_weak
&& TREE_PUBLIC (thunk_fndecl
))
370 comdat_linkage (thunk_fndecl
);
372 if (flag_syntax_only
)
374 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
378 push_to_top_level ();
380 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
381 && targetm
.have_named_sections
)
383 resolve_unique_section (function
, 0, flag_function_sections
);
385 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
387 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
389 /* Output the thunk into the same section as function. */
390 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
394 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
396 DECL_INITIAL (thunk_fndecl
) = make_node (BLOCK
);
398 /* Set up cloned argument trees for the thunk. */
400 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
402 tree x
= copy_node (a
);
404 DECL_CONTEXT (x
) = thunk_fndecl
;
405 SET_DECL_RTL (x
, NULL_RTX
);
409 DECL_ARGUMENTS (thunk_fndecl
) = a
;
410 BLOCK_VARS (DECL_INITIAL (thunk_fndecl
)) = a
;
413 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
414 virtual_value
, alias
))
417 current_function_decl
= thunk_fndecl
;
418 DECL_RESULT (thunk_fndecl
)
419 = build_decl (RESULT_DECL
, 0, integer_type_node
);
420 fnname
= XSTR (XEXP (DECL_RTL (thunk_fndecl
), 0), 0);
421 init_function_start (thunk_fndecl
);
422 current_function_is_thunk
= 1;
423 assemble_start_function (thunk_fndecl
, fnname
);
425 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
426 fixed_offset
, virtual_value
, alias
);
428 assemble_end_function (thunk_fndecl
, fnname
);
429 current_function_decl
= 0;
431 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
435 /* If this is a covariant thunk, or we don't have the necessary
436 code for efficient thunks, generate a thunk function that
437 just makes a call to the real function. Unfortunately, this
438 doesn't work for varargs. */
440 if (varargs_function_p (function
))
441 error ("generic thunk code fails for method %q#D which uses %<...%>",
444 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
446 start_preparsed_function (thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
447 /* We don't bother with a body block for thunks. */
449 /* There's no need to check accessibility inside the thunk body. */
450 push_deferring_access_checks (dk_no_check
);
454 t
= thunk_adjust (t
, /*this_adjusting=*/1,
455 fixed_offset
, virtual_offset
);
457 /* Build up the call to the real function. */
458 t
= tree_cons (NULL_TREE
, t
, NULL_TREE
);
459 for (a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
))
460 t
= tree_cons (NULL_TREE
, a
, t
);
462 t
= build_call (alias
, t
);
463 CALL_FROM_THUNK_P (t
) = 1;
465 if (VOID_TYPE_P (TREE_TYPE (t
)))
466 finish_expr_stmt (t
);
469 t
= force_target_expr (TREE_TYPE (t
), t
);
471 t
= thunk_adjust (t
, /*this_adjusting=*/0,
472 fixed_offset
, virtual_offset
);
473 finish_return_stmt (t
);
476 /* Since we want to emit the thunk, we explicitly mark its name as
478 mark_decl_referenced (thunk_fndecl
);
480 /* But we don't want debugging information about it. */
481 DECL_IGNORED_P (thunk_fndecl
) = 1;
483 /* Re-enable access control. */
484 pop_deferring_access_checks ();
486 expand_body (finish_function (0));
489 pop_from_top_level ();
492 /* Code for synthesizing methods which have default semantics defined. */
494 /* Generate code for default X(X&) constructor. */
497 do_build_copy_constructor (tree fndecl
)
499 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
501 parm
= convert_from_reference (parm
);
503 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
504 && is_empty_class (current_class_type
))
505 /* Don't copy the padding byte; it might not have been allocated
506 if *this is a base subobject. */;
507 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
509 tree t
= build2 (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
510 finish_expr_stmt (t
);
514 tree fields
= TYPE_FIELDS (current_class_type
);
515 tree member_init_list
= NULL_TREE
;
516 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
518 tree binfo
, base_binfo
;
521 /* Initialize all the base-classes with the parameter converted
522 to their type so that we get their copy constructor and not
523 another constructor that takes current_class_type. We must
524 deal with the binfo's directly as a direct base might be
525 inaccessible due to ambiguity. */
526 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
527 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
531 build_tree_list (NULL_TREE
,
532 build_base_path (PLUS_EXPR
, parm
,
537 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
538 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
540 if (BINFO_VIRTUAL_P (base_binfo
))
544 = tree_cons (base_binfo
,
545 build_tree_list (NULL_TREE
,
546 build_base_path (PLUS_EXPR
, parm
,
551 for (; fields
; fields
= TREE_CHAIN (fields
))
557 if (TREE_CODE (field
) != FIELD_DECL
)
560 expr_type
= TREE_TYPE (field
);
561 if (DECL_NAME (field
))
563 if (VFIELD_NAME_P (DECL_NAME (field
)))
566 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
567 /* Just use the field; anonymous types can't have
568 nontrivial copy ctors or assignment ops. */;
572 /* Compute the type of "init->field". If the copy-constructor
573 parameter is, for example, "const S&", and the type of
574 the field is "T", then the type will usually be "const
575 T". (There are no cv-qualified variants of reference
577 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
581 if (DECL_MUTABLE_P (field
))
582 quals
&= ~TYPE_QUAL_CONST
;
583 expr_type
= cp_build_qualified_type (expr_type
, quals
);
586 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
587 init
= build_tree_list (NULL_TREE
, init
);
589 member_init_list
= tree_cons (field
, init
, member_init_list
);
591 finish_mem_initializers (member_init_list
);
596 do_build_assign_ref (tree fndecl
)
598 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
601 compound_stmt
= begin_compound_stmt (0);
602 parm
= convert_from_reference (parm
);
604 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
605 && is_empty_class (current_class_type
))
606 /* Don't copy the padding byte; it might not have been allocated
607 if *this is a base subobject. */;
608 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
610 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
611 finish_expr_stmt (t
);
616 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
618 tree binfo
, base_binfo
;
620 /* Assign to each of the direct base classes. */
621 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
622 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
626 /* We must convert PARM directly to the base class
627 explicitly since the base class may be ambiguous. */
628 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
629 /* Call the base class assignment operator. */
631 (build_special_member_call (current_class_ref
,
632 ansi_assopname (NOP_EXPR
),
633 build_tree_list (NULL_TREE
,
636 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
));
639 /* Assign to each of the non-static data members. */
640 for (fields
= TYPE_FIELDS (current_class_type
);
642 fields
= TREE_CHAIN (fields
))
644 tree comp
= current_class_ref
;
650 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
653 expr_type
= TREE_TYPE (field
);
655 if (CP_TYPE_CONST_P (expr_type
))
657 error ("non-static const member %q#D, can't use default "
658 "assignment operator", field
);
661 else if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
663 error ("non-static reference member %q#D, can't use "
664 "default assignment operator", field
);
668 if (DECL_NAME (field
))
670 if (VFIELD_NAME_P (DECL_NAME (field
)))
673 else if (ANON_AGGR_TYPE_P (expr_type
)
674 && TYPE_FIELDS (expr_type
) != NULL_TREE
)
675 /* Just use the field; anonymous types can't have
676 nontrivial copy ctors or assignment ops. */;
680 comp
= build3 (COMPONENT_REF
, expr_type
, comp
, field
, NULL_TREE
);
682 /* Compute the type of init->field */
684 if (DECL_MUTABLE_P (field
))
685 quals
&= ~TYPE_QUAL_CONST
;
686 expr_type
= cp_build_qualified_type (expr_type
, quals
);
688 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
690 if (DECL_NAME (field
))
691 init
= build_modify_expr (comp
, NOP_EXPR
, init
);
693 init
= build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
694 finish_expr_stmt (init
);
697 finish_return_stmt (current_class_ref
);
698 finish_compound_stmt (compound_stmt
);
702 synthesize_method (tree fndecl
)
704 bool nested
= (current_function_decl
!= NULL_TREE
);
705 tree context
= decl_function_context (fndecl
);
706 bool need_body
= true;
709 /* If we've been asked to synthesize a clone, just synthesize the
710 cloned function instead. Doing so will automatically fill in the
711 body for the clone. */
712 if (DECL_CLONED_FUNCTION_P (fndecl
))
714 synthesize_method (DECL_CLONED_FUNCTION (fndecl
));
718 /* We may be in the middle of deferred access check. Disable
720 push_deferring_access_checks (dk_no_deferred
);
723 push_to_top_level ();
725 push_function_context_to (context
);
727 /* Put the function definition at the position where it is needed,
728 rather than within the body of the class. That way, an error
729 during the generation of the implicit body points at the place
730 where the attempt to generate the function occurs, giving the
731 user a hint as to why we are attempting to generate the
733 DECL_SOURCE_LOCATION (fndecl
) = input_location
;
735 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
736 stmt
= begin_function_body ();
738 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
740 do_build_assign_ref (fndecl
);
743 else if (DECL_CONSTRUCTOR_P (fndecl
))
745 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
746 if (arg_chain
!= void_list_node
)
747 do_build_copy_constructor (fndecl
);
748 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type
))
749 finish_mem_initializers (NULL_TREE
);
752 /* If we haven't yet generated the body of the function, just
753 generate an empty compound statement. */
757 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
758 finish_compound_stmt (compound_stmt
);
761 finish_function_body (stmt
);
762 expand_or_defer_fn (finish_function (0));
765 pop_from_top_level ();
767 pop_function_context_from (context
);
769 pop_deferring_access_checks ();
772 /* Use EXTRACTOR to locate the relevant function called for each base &
773 class field of TYPE. CLIENT allows additional information to be passed
774 to EXTRACTOR. Generates the union of all exceptions generated by those
775 functions. Note that we haven't updated TYPE_FIELDS and such of any
776 variants yet, so we need to look at the main one. */
779 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
782 tree raises
= empty_except_spec
;
783 tree fields
= TYPE_FIELDS (type
);
784 tree binfo
, base_binfo
;
787 for (binfo
= TYPE_BINFO (type
), i
= 0;
788 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
790 tree fn
= (*extractor
) (BINFO_TYPE (base_binfo
), client
);
793 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
795 raises
= merge_exception_specifiers (raises
, fn_raises
);
798 for (; fields
; fields
= TREE_CHAIN (fields
))
800 tree type
= TREE_TYPE (fields
);
803 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
805 while (TREE_CODE (type
) == ARRAY_TYPE
)
806 type
= TREE_TYPE (type
);
807 if (TREE_CODE (type
) != RECORD_TYPE
)
810 fn
= (*extractor
) (type
, client
);
813 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
815 raises
= merge_exception_specifiers (raises
, fn_raises
);
821 /* Locate the dtor of TYPE. */
824 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
826 return (CLASSTYPE_METHOD_VEC (type
)
827 ? CLASSTYPE_DESTRUCTORS (type
)
831 /* Locate the default ctor of TYPE. */
834 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
838 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
841 /* Call lookup_fnfields_1 to create the constructor declarations, if
843 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
844 return lazily_declare_fn (sfk_constructor
, type
);
846 for (fns
= CLASSTYPE_CONSTRUCTORS (type
); fns
; fns
= OVL_NEXT (fns
))
848 tree fn
= OVL_CURRENT (fns
);
849 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
851 if (sufficient_parms_p (TREE_CHAIN (parms
)))
863 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
864 points to a COPY_DATA holding the name (NULL for the ctor)
865 and desired qualifiers of the source operand. */
868 locate_copy (tree type
, void *client_
)
870 struct copy_data
*client
= (struct copy_data
*)client_
;
872 tree best
= NULL_TREE
;
873 bool excess_p
= false;
878 ix
= lookup_fnfields_1 (type
, client
->name
);
881 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
883 else if (TYPE_HAS_INIT_REF (type
))
885 /* If construction of the copy constructor was postponed, create
887 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
888 lazily_declare_fn (sfk_copy_constructor
, type
);
889 fns
= CLASSTYPE_CONSTRUCTORS (type
);
893 for (; fns
; fns
= OVL_NEXT (fns
))
895 tree fn
= OVL_CURRENT (fns
);
896 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
901 parms
= TREE_CHAIN (parms
);
904 src_type
= non_reference (TREE_VALUE (parms
));
905 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
907 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
909 quals
= cp_type_quals (src_type
);
910 if (client
->quals
& ~quals
)
912 excess
= quals
& ~client
->quals
;
913 if (!best
|| (excess_p
&& !excess
))
925 /* Implicitly declare the special function indicated by KIND, as a
926 member of TYPE. For copy constructors and assignment operators,
927 CONST_P indicates whether these functions should take a const
928 reference argument or a non-const reference. Returns the
929 FUNCTION_DECL for the implicitly declared function. */
932 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
935 tree parameter_types
= void_list_node
;
938 tree raises
= empty_except_spec
;
939 tree rhs_parm_type
= NULL_TREE
;
942 type
= TYPE_MAIN_VARIANT (type
);
944 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
946 if (kind
== sfk_destructor
)
947 /* See comment in check_special_function_return_type. */
948 return_type
= build_pointer_type (void_type_node
);
950 return_type
= build_pointer_type (type
);
953 return_type
= void_type_node
;
959 name
= constructor_name (type
);
960 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
963 case sfk_constructor
:
964 /* Default constructor. */
965 name
= constructor_name (type
);
966 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
969 case sfk_copy_constructor
:
970 case sfk_assignment_operator
:
972 struct copy_data data
;
976 if (kind
== sfk_assignment_operator
)
978 return_type
= build_reference_type (type
);
979 name
= ansi_assopname (NOP_EXPR
);
983 name
= constructor_name (type
);
987 data
.quals
= TYPE_QUAL_CONST
;
988 rhs_parm_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
991 rhs_parm_type
= type
;
992 rhs_parm_type
= build_reference_type (rhs_parm_type
);
993 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
994 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1001 /* Create the function. */
1002 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1004 fn_type
= build_exception_variant (fn_type
, raises
);
1005 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1006 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1007 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
)
1008 DECL_CONSTRUCTOR_P (fn
) = 1;
1009 else if (kind
== sfk_destructor
)
1010 DECL_DESTRUCTOR_P (fn
) = 1;
1013 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1014 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1016 /* Create the argument list. The call to "grokclassfn" will add the
1017 "this" parameter and any other implicit parameters. */
1020 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1021 want its type to be included in the mangled function
1023 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1024 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1027 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
,
1029 grok_special_member_properties (fn
);
1030 set_linkage_according_to_type (type
, fn
);
1031 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1032 DECL_IN_AGGR_P (fn
) = 1;
1033 DECL_ARTIFICIAL (fn
) = 1;
1034 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1035 DECL_DECLARED_INLINE_P (fn
) = 1;
1036 DECL_INLINE (fn
) = 1;
1037 gcc_assert (!TREE_USED (fn
));
1042 /* Add an implicit declaration to TYPE for the kind of function
1043 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1047 lazily_declare_fn (special_function_kind sfk
, tree type
)
1052 /* Figure out whether or not the argument has a const reference
1054 if (sfk
== sfk_copy_constructor
)
1055 const_p
= TYPE_HAS_CONST_INIT_REF (type
);
1056 else if (sfk
== sfk_assignment_operator
)
1057 const_p
= TYPE_HAS_CONST_ASSIGN_REF (type
);
1059 /* In this case, CONST_P will be ignored. */
1061 /* Declare the function. */
1062 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1063 /* Add it to CLASSTYPE_METHOD_VEC. */
1064 add_method (type
, fn
);
1065 /* Add it to TYPE_METHODS. */
1066 TREE_CHAIN (fn
) = TYPE_METHODS (type
);
1067 TYPE_METHODS (type
) = fn
;
1068 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1069 if (sfk
== sfk_constructor
|| sfk
== sfk_copy_constructor
)
1071 /* Remember that the function has been created. */
1072 if (sfk
== sfk_constructor
)
1073 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1075 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1076 /* Create appropriate clones. */
1077 clone_function_decl (fn
, /*update_method_vec=*/true);
1079 else if (sfk
== sfk_assignment_operator
)
1080 CLASSTYPE_LAZY_ASSIGNMENT_OP (type
) = 0;
1085 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1086 as there are artificial parms in FN. */
1089 skip_artificial_parms_for (tree fn
, tree list
)
1091 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1092 list
= TREE_CHAIN (list
);
1096 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1097 list
= TREE_CHAIN (list
);
1098 if (DECL_HAS_VTT_PARM_P (fn
))
1099 list
= TREE_CHAIN (list
);
1103 #include "gt-cp-method.h"