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 my_friendly_assert (TREE_CODE (function
) == FUNCTION_DECL
, 20021025);
92 /* We can have this thunks to covariant thunks, but not vice versa. */
93 my_friendly_assert (!DECL_THIS_THUNK_P (function
), 20021127);
94 my_friendly_assert (!DECL_RESULT_THUNK_P (function
) || this_adjusting
,
97 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
98 if (this_adjusting
&& virtual_offset
)
100 = size_binop (MULT_EXPR
,
103 TYPE_SIZE_UNIT (vtable_entry_type
)));
105 d
= tree_low_cst (fixed_offset
, 0);
107 /* See if we already have the thunk in question. For this_adjusting
108 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
110 for (thunk
= DECL_THUNKS (function
); thunk
; thunk
= TREE_CHAIN (thunk
))
111 if (DECL_THIS_THUNK_P (thunk
) == this_adjusting
112 && THUNK_FIXED_OFFSET (thunk
) == d
113 && !virtual_offset
== !THUNK_VIRTUAL_OFFSET (thunk
)
116 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk
),
118 : THUNK_VIRTUAL_OFFSET (thunk
) == virtual_offset
)))
121 /* All thunks must be created before FUNCTION is actually emitted;
122 the ABI requires that all thunks be emitted together with the
123 function to which they transfer control. */
124 my_friendly_assert (!TREE_ASM_WRITTEN (function
), 20021025);
125 /* Likewise, we can only be adding thunks to a function declared in
126 the class currently being laid out. */
127 my_friendly_assert (TYPE_SIZE (DECL_CONTEXT (function
))
128 && TYPE_BEING_DEFINED (DECL_CONTEXT (function
)),
131 thunk
= build_decl (FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
132 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
133 cxx_dup_lang_specific_decl (thunk
);
134 DECL_THUNKS (thunk
) = NULL_TREE
;
136 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
137 TREE_READONLY (thunk
) = TREE_READONLY (function
);
138 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
139 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
141 comdat_linkage (thunk
);
142 SET_DECL_THUNK_P (thunk
, this_adjusting
);
143 THUNK_TARGET (thunk
) = function
;
144 THUNK_FIXED_OFFSET (thunk
) = d
;
145 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
146 THUNK_ALIAS (thunk
) = NULL_TREE
;
148 /* The thunk itself is not a constructor or destructor, even if
149 the thing it is thunking to is. */
150 DECL_INTERFACE_KNOWN (thunk
) = 1;
151 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
152 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
153 DECL_DESTRUCTOR_P (thunk
) = 0;
154 DECL_CONSTRUCTOR_P (thunk
) = 0;
155 /* And neither is it a clone. */
156 DECL_CLONED_FUNCTION (thunk
) = NULL_TREE
;
157 DECL_EXTERNAL (thunk
) = 1;
158 DECL_ARTIFICIAL (thunk
) = 1;
159 /* Even if this thunk is a member of a local class, we don't
160 need a static chain. */
161 DECL_NO_STATIC_CHAIN (thunk
) = 1;
162 /* The THUNK is not a pending inline, even if the FUNCTION is. */
163 DECL_PENDING_INLINE_P (thunk
) = 0;
164 DECL_INLINE (thunk
) = 0;
165 DECL_DECLARED_INLINE_P (thunk
) = 0;
166 /* Nor has it been deferred. */
167 DECL_DEFERRED_FN (thunk
) = 0;
169 /* Add it to the list of thunks associated with FUNCTION. */
170 TREE_CHAIN (thunk
) = DECL_THUNKS (function
);
171 DECL_THUNKS (function
) = thunk
;
176 /* Finish THUNK, a thunk decl. */
179 finish_thunk (tree thunk
)
182 tree fixed_offset
= build_int_cst (ssizetype
, THUNK_FIXED_OFFSET (thunk
));
183 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
185 my_friendly_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
), 20021127);
186 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
187 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
188 function
= THUNK_TARGET (thunk
);
189 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
190 fixed_offset
, virtual_offset
);
192 /* We can end up with declarations of (logically) different
193 covariant thunks, that do identical adjustments. The two thunks
194 will be adjusting between within different hierarchies, which
195 happen to have the same layout. We must nullify one of them to
196 refer to the other. */
197 if (DECL_RESULT_THUNK_P (thunk
))
201 for (cov_probe
= DECL_THUNKS (function
);
202 cov_probe
; cov_probe
= TREE_CHAIN (cov_probe
))
203 if (DECL_NAME (cov_probe
) == name
)
205 my_friendly_assert (!DECL_THUNKS (thunk
), 20031023);
206 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
207 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
212 DECL_NAME (thunk
) = name
;
213 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
216 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
217 offset indicated by VIRTUAL_OFFSET, if that is
218 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
219 zero for a result adjusting thunk. */
222 thunk_adjust (tree ptr
, bool this_adjusting
,
223 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
226 /* Adjust the pointer by the constant. */
227 ptr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
228 ssize_int (fixed_offset
)));
230 /* If there's a virtual offset, look up that value in the vtable and
231 adjust the pointer again. */
236 ptr
= save_expr (ptr
);
237 /* The vptr is always at offset zero in the object. */
238 vtable
= build1 (NOP_EXPR
,
239 build_pointer_type (build_pointer_type
240 (vtable_entry_type
)),
242 /* Form the vtable address. */
243 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
244 /* Find the entry with the vcall offset. */
245 vtable
= build2 (PLUS_EXPR
, TREE_TYPE (vtable
), vtable
, virtual_offset
);
246 /* Get the offset itself. */
247 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
248 /* Adjust the `this' pointer. */
249 ptr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
, vtable
));
253 /* Adjust the pointer by the constant. */
254 ptr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
255 ssize_int (fixed_offset
)));
260 static GTY (()) int thunk_labelno
;
262 /* Create a static alias to function. */
265 make_alias_for_thunk (tree function
)
270 ASM_GENERATE_INTERNAL_LABEL (buf
, "LTHUNK", thunk_labelno
);
272 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
273 TREE_TYPE (function
));
274 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
275 cxx_dup_lang_specific_decl (alias
);
276 DECL_CONTEXT (alias
) = NULL
;
277 TREE_READONLY (alias
) = TREE_READONLY (function
);
278 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
279 TREE_PUBLIC (alias
) = 0;
280 DECL_INTERFACE_KNOWN (alias
) = 1;
281 DECL_NOT_REALLY_EXTERN (alias
) = 1;
282 DECL_THIS_STATIC (alias
) = 1;
283 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
284 DECL_DESTRUCTOR_P (alias
) = 0;
285 DECL_CONSTRUCTOR_P (alias
) = 0;
286 DECL_CLONED_FUNCTION (alias
) = NULL_TREE
;
287 DECL_EXTERNAL (alias
) = 0;
288 DECL_ARTIFICIAL (alias
) = 1;
289 DECL_NO_STATIC_CHAIN (alias
) = 1;
290 DECL_PENDING_INLINE_P (alias
) = 0;
291 DECL_INLINE (alias
) = 0;
292 DECL_DECLARED_INLINE_P (alias
) = 0;
293 DECL_DEFERRED_FN (alias
) = 0;
294 DECL_USE_TEMPLATE (alias
) = 0;
295 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
296 DECL_TEMPLATE_INFO (alias
) = NULL
;
297 DECL_INITIAL (alias
) = error_mark_node
;
298 TREE_ADDRESSABLE (alias
) = 1;
299 TREE_USED (alias
) = 1;
300 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
301 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
302 if (!flag_syntax_only
)
303 assemble_alias (alias
, DECL_ASSEMBLER_NAME (function
));
307 /* Emit the definition of a C++ multiple inheritance or covariant
308 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
312 use_thunk (tree thunk_fndecl
, bool emit_p
)
314 tree a
, t
, function
, alias
;
316 HOST_WIDE_INT fixed_offset
, virtual_value
;
317 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
319 /* We should have called finish_thunk to give it a name. */
320 my_friendly_assert (DECL_NAME (thunk_fndecl
), 20021127);
322 /* We should never be using an alias, always refer to the
324 my_friendly_assert (!THUNK_ALIAS (thunk_fndecl
), 20031023);
326 if (TREE_ASM_WRITTEN (thunk_fndecl
))
329 function
= THUNK_TARGET (thunk_fndecl
);
330 if (DECL_RESULT (thunk_fndecl
))
331 /* We already turned this thunk into an ordinary function.
332 There's no need to process this thunk again. */
335 /* Thunks are always addressable; they only appear in vtables. */
336 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
338 /* Figure out what function is being thunked to. It's referenced in
339 this translation unit. */
340 TREE_ADDRESSABLE (function
) = 1;
341 mark_used (function
);
345 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
))
346 alias
= make_alias_for_thunk (function
);
350 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
351 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
356 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
357 virtual_value
= tree_low_cst (virtual_offset
, /*pos=*/0);
358 my_friendly_assert (virtual_value
, 20021026);
363 /* And, if we need to emit the thunk, it's used. */
364 mark_used (thunk_fndecl
);
365 /* This thunk is actually defined. */
366 DECL_EXTERNAL (thunk_fndecl
) = 0;
367 /* The linkage of the function may have changed. FIXME in linkage
369 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
370 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
371 DECL_VISIBILITY_SPECIFIED (thunk_fndecl
)
372 = DECL_VISIBILITY_SPECIFIED (function
);
373 if (flag_weak
&& TREE_PUBLIC (thunk_fndecl
))
374 comdat_linkage (thunk_fndecl
);
376 if (flag_syntax_only
)
378 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
382 push_to_top_level ();
384 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
385 && targetm
.have_named_sections
)
387 resolve_unique_section (function
, 0, flag_function_sections
);
389 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
391 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
393 /* Output the thunk into the same section as function. */
394 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
398 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
400 DECL_INITIAL (thunk_fndecl
) = make_node (BLOCK
);
402 /* Set up cloned argument trees for the thunk. */
404 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
406 tree x
= copy_node (a
);
408 DECL_CONTEXT (x
) = thunk_fndecl
;
409 SET_DECL_RTL (x
, NULL_RTX
);
413 DECL_ARGUMENTS (thunk_fndecl
) = a
;
414 BLOCK_VARS (DECL_INITIAL (thunk_fndecl
)) = a
;
417 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
418 virtual_value
, alias
))
421 current_function_decl
= thunk_fndecl
;
422 DECL_RESULT (thunk_fndecl
)
423 = build_decl (RESULT_DECL
, 0, integer_type_node
);
424 fnname
= XSTR (XEXP (DECL_RTL (thunk_fndecl
), 0), 0);
425 init_function_start (thunk_fndecl
);
426 current_function_is_thunk
= 1;
427 assemble_start_function (thunk_fndecl
, fnname
);
429 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
430 fixed_offset
, virtual_value
, alias
);
432 assemble_end_function (thunk_fndecl
, fnname
);
433 current_function_decl
= 0;
435 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
439 /* If this is a covariant thunk, or we don't have the necessary
440 code for efficient thunks, generate a thunk function that
441 just makes a call to the real function. Unfortunately, this
442 doesn't work for varargs. */
444 if (varargs_function_p (function
))
445 error ("generic thunk code fails for method `%#D' which uses `...'",
448 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
450 start_preparsed_function (thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
451 /* We don't bother with a body block for thunks. */
453 /* There's no need to check accessibility inside the thunk body. */
454 push_deferring_access_checks (dk_no_check
);
458 t
= thunk_adjust (t
, /*this_adjusting=*/1,
459 fixed_offset
, virtual_offset
);
461 /* Build up the call to the real function. */
462 t
= tree_cons (NULL_TREE
, t
, NULL_TREE
);
463 for (a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
))
464 t
= tree_cons (NULL_TREE
, a
, t
);
466 t
= build_call (alias
, t
);
467 CALL_FROM_THUNK_P (t
) = 1;
469 if (VOID_TYPE_P (TREE_TYPE (t
)))
470 finish_expr_stmt (t
);
473 t
= force_target_expr (TREE_TYPE (t
), t
);
475 t
= thunk_adjust (t
, /*this_adjusting=*/0,
476 fixed_offset
, virtual_offset
);
477 finish_return_stmt (t
);
480 /* Since we want to emit the thunk, we explicitly mark its name as
482 mark_decl_referenced (thunk_fndecl
);
484 /* But we don't want debugging information about it. */
485 DECL_IGNORED_P (thunk_fndecl
) = 1;
487 /* Re-enable access control. */
488 pop_deferring_access_checks ();
490 expand_body (finish_function (0));
493 pop_from_top_level ();
496 /* Code for synthesizing methods which have default semantics defined. */
498 /* Generate code for default X(X&) constructor. */
501 do_build_copy_constructor (tree fndecl
)
503 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
506 parm
= convert_from_reference (parm
);
508 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
509 && is_empty_class (current_class_type
))
510 /* Don't copy the padding byte; it might not have been allocated
511 if *this is a base subobject. */;
512 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
514 t
= build2 (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
515 finish_expr_stmt (t
);
519 tree fields
= TYPE_FIELDS (current_class_type
);
520 tree member_init_list
= NULL_TREE
;
521 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
523 tree binfo
, base_binfo
;
526 /* Initialize all the base-classes with the parameter converted
527 to their type so that we get their copy constructor and not
528 another constructor that takes current_class_type. We must
529 deal with the binfo's directly as a direct base might be
530 inaccessible due to ambiguity. */
531 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
532 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
536 build_tree_list (NULL_TREE
,
537 build_base_path (PLUS_EXPR
, parm
,
542 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
543 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
545 if (BINFO_VIRTUAL_P (base_binfo
))
549 = tree_cons (base_binfo
,
550 build_tree_list (NULL_TREE
,
551 build_base_path (PLUS_EXPR
, parm
,
556 for (; fields
; fields
= TREE_CHAIN (fields
))
562 if (TREE_CODE (field
) != FIELD_DECL
)
566 if (DECL_NAME (field
))
568 if (VFIELD_NAME_P (DECL_NAME (field
)))
571 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
572 && ANON_AGGR_TYPE_P (t
)
573 && TYPE_FIELDS (t
) != NULL_TREE
)
574 /* Just use the field; anonymous types can't have
575 nontrivial copy ctors or assignment ops. */;
579 /* Compute the type of "init->field". If the copy-constructor
580 parameter is, for example, "const S&", and the type of
581 the field is "T", then the type will usually be "const
582 T". (There are no cv-qualified variants of reference
584 expr_type
= TREE_TYPE (field
);
585 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
586 expr_type
= cp_build_qualified_type (expr_type
, cvquals
);
587 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
588 init
= build_tree_list (NULL_TREE
, init
);
591 = tree_cons (field
, init
, member_init_list
);
593 finish_mem_initializers (member_init_list
);
598 do_build_assign_ref (tree fndecl
)
600 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
603 compound_stmt
= begin_compound_stmt (0);
604 parm
= convert_from_reference (parm
);
606 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
607 && is_empty_class (current_class_type
))
608 /* Don't copy the padding byte; it might not have been allocated
609 if *this is a base subobject. */;
610 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
612 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
613 finish_expr_stmt (t
);
618 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
620 tree binfo
, base_binfo
;
622 /* Assign to each of the direct base classes. */
623 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
624 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
628 /* We must convert PARM directly to the base class
629 explicitly since the base class may be ambiguous. */
630 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
631 /* Call the base class assignment operator. */
633 (build_special_member_call (current_class_ref
,
634 ansi_assopname (NOP_EXPR
),
635 build_tree_list (NULL_TREE
,
638 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
));
641 /* Assign to each of the non-static data members. */
642 for (fields
= TYPE_FIELDS (current_class_type
);
644 fields
= TREE_CHAIN (fields
))
649 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
652 if (CP_TYPE_CONST_P (TREE_TYPE (field
)))
654 error ("non-static const member `%#D', can't use default assignment operator", field
);
657 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
659 error ("non-static reference member `%#D', can't use default assignment operator", field
);
663 comp
= current_class_ref
;
666 if (DECL_NAME (field
))
668 if (VFIELD_NAME_P (DECL_NAME (field
)))
671 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
672 && ANON_AGGR_TYPE_P (t
)
673 && TYPE_FIELDS (t
) != NULL_TREE
)
674 /* Just use the field; anonymous types can't have
675 nontrivial copy ctors or assignment ops. */;
679 comp
= build3 (COMPONENT_REF
, TREE_TYPE (field
), comp
, field
,
681 init
= build3 (COMPONENT_REF
,
682 cp_build_qualified_type (TREE_TYPE (field
), cvquals
),
683 init
, field
, NULL_TREE
);
685 if (DECL_NAME (field
))
686 finish_expr_stmt (build_modify_expr (comp
, NOP_EXPR
, init
));
688 finish_expr_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
,
692 finish_return_stmt (current_class_ref
);
693 finish_compound_stmt (compound_stmt
);
697 synthesize_method (tree fndecl
)
699 bool nested
= (current_function_decl
!= NULL_TREE
);
700 tree context
= decl_function_context (fndecl
);
701 bool need_body
= true;
704 /* If we've been asked to synthesize a clone, just synthesize the
705 cloned function instead. Doing so will automatically fill in the
706 body for the clone. */
707 if (DECL_CLONED_FUNCTION_P (fndecl
))
709 synthesize_method (DECL_CLONED_FUNCTION (fndecl
));
713 /* We may be in the middle of deferred access check. Disable
715 push_deferring_access_checks (dk_no_deferred
);
718 push_to_top_level ();
720 push_function_context_to (context
);
722 /* Put the function definition at the position where it is needed,
723 rather than within the body of the class. That way, an error
724 during the generation of the implicit body points at the place
725 where the attempt to generate the function occurs, giving the
726 user a hint as to why we are attempting to generate the
728 DECL_SOURCE_LOCATION (fndecl
) = input_location
;
730 interface_unknown
= 1;
731 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
732 stmt
= begin_function_body ();
734 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
736 do_build_assign_ref (fndecl
);
739 else if (DECL_CONSTRUCTOR_P (fndecl
))
741 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
742 if (arg_chain
!= void_list_node
)
743 do_build_copy_constructor (fndecl
);
744 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type
))
745 finish_mem_initializers (NULL_TREE
);
748 /* If we haven't yet generated the body of the function, just
749 generate an empty compound statement. */
753 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
754 finish_compound_stmt (compound_stmt
);
757 finish_function_body (stmt
);
758 expand_or_defer_fn (finish_function (0));
760 extract_interface_info ();
762 pop_from_top_level ();
764 pop_function_context_from (context
);
766 pop_deferring_access_checks ();
769 /* Use EXTRACTOR to locate the relevant function called for each base &
770 class field of TYPE. CLIENT allows additional information to be passed
771 to EXTRACTOR. Generates the union of all exceptions generated by those
772 functions. Note that we haven't updated TYPE_FIELDS and such of any
773 variants yet, so we need to look at the main one. */
776 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
779 tree raises
= empty_except_spec
;
780 tree fields
= TYPE_FIELDS (type
);
781 tree binfo
, base_binfo
;
784 for (binfo
= TYPE_BINFO (type
), i
= 0;
785 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
787 tree fn
= (*extractor
) (BINFO_TYPE (base_binfo
), client
);
790 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
792 raises
= merge_exception_specifiers (raises
, fn_raises
);
795 for (; fields
; fields
= TREE_CHAIN (fields
))
797 tree type
= TREE_TYPE (fields
);
800 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
802 while (TREE_CODE (type
) == ARRAY_TYPE
)
803 type
= TREE_TYPE (type
);
804 if (TREE_CODE (type
) != RECORD_TYPE
)
807 fn
= (*extractor
) (type
, client
);
810 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
812 raises
= merge_exception_specifiers (raises
, fn_raises
);
818 /* Locate the dtor of TYPE. */
821 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
823 return (CLASSTYPE_METHOD_VEC (type
)
824 ? CLASSTYPE_DESTRUCTORS (type
)
828 /* Locate the default ctor of TYPE. */
831 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
835 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
838 /* Call lookup_fnfields_1 to create the constructor declarations, if
840 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
841 return lazily_declare_fn (sfk_constructor
, type
);
843 for (fns
= CLASSTYPE_CONSTRUCTORS (type
); fns
; fns
= OVL_NEXT (fns
))
845 tree fn
= OVL_CURRENT (fns
);
846 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
848 if (sufficient_parms_p (TREE_CHAIN (parms
)))
860 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
861 points to a COPY_DATA holding the name (NULL for the ctor)
862 and desired qualifiers of the source operand. */
865 locate_copy (tree type
, void *client_
)
867 struct copy_data
*client
= (struct copy_data
*)client_
;
869 tree best
= NULL_TREE
;
870 bool excess_p
= false;
875 ix
= lookup_fnfields_1 (type
, client
->name
);
878 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
880 else if (TYPE_HAS_INIT_REF (type
))
882 /* If construction of the copy constructor was postponed, create
884 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
885 lazily_declare_fn (sfk_copy_constructor
, type
);
886 fns
= CLASSTYPE_CONSTRUCTORS (type
);
890 for (; fns
; fns
= OVL_NEXT (fns
))
892 tree fn
= OVL_CURRENT (fns
);
893 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
898 parms
= TREE_CHAIN (parms
);
901 src_type
= non_reference (TREE_VALUE (parms
));
902 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
904 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
906 quals
= cp_type_quals (src_type
);
907 if (client
->quals
& ~quals
)
909 excess
= quals
& ~client
->quals
;
910 if (!best
|| (excess_p
&& !excess
))
922 /* Implicitly declare the special function indicated by KIND, as a
923 member of TYPE. For copy constructors and assignment operators,
924 CONST_P indicates whether these functions should take a const
925 reference argument or a non-const reference. */
928 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
931 tree parameter_types
= void_list_node
;
934 tree raises
= empty_except_spec
;
935 tree rhs_parm_type
= NULL_TREE
;
938 type
= TYPE_MAIN_VARIANT (type
);
940 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
942 if (kind
== sfk_destructor
)
943 /* See comment in check_special_function_return_type. */
944 return_type
= build_pointer_type (void_type_node
);
946 return_type
= build_pointer_type (type
);
949 return_type
= void_type_node
;
955 name
= constructor_name (type
);
956 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
959 case sfk_constructor
:
960 /* Default constructor. */
961 name
= constructor_name (type
);
962 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
965 case sfk_copy_constructor
:
966 case sfk_assignment_operator
:
968 struct copy_data data
;
972 if (kind
== sfk_assignment_operator
)
974 return_type
= build_reference_type (type
);
975 name
= ansi_assopname (NOP_EXPR
);
979 name
= constructor_name (type
);
983 data
.quals
= TYPE_QUAL_CONST
;
984 rhs_parm_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
987 rhs_parm_type
= type
;
988 rhs_parm_type
= build_reference_type (rhs_parm_type
);
989 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
990 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
997 /* Create the function. */
998 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1000 fn_type
= build_exception_variant (fn_type
, raises
);
1001 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1002 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1003 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
)
1004 DECL_CONSTRUCTOR_P (fn
) = 1;
1005 else if (kind
== sfk_destructor
)
1006 DECL_DESTRUCTOR_P (fn
) = 1;
1009 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1010 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1012 /* Create the argument list. The call to "grokclassfn" will add the
1013 "this" parameter and any other implicit parameters. */
1016 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1017 want its type to be included in the mangled function
1019 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1020 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1023 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
,
1025 grok_special_member_properties (fn
);
1026 set_linkage_according_to_type (type
, fn
);
1027 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1028 DECL_IN_AGGR_P (fn
) = 1;
1029 DECL_ARTIFICIAL (fn
) = 1;
1030 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1031 DECL_DECLARED_INLINE_P (fn
) = 1;
1032 DECL_INLINE (fn
) = 1;
1039 /* Add an implicit declaration to TYPE for the kind of function
1040 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1044 lazily_declare_fn (special_function_kind sfk
, tree type
)
1049 /* Figure out whether or not the argument has a const reference
1051 if (sfk
== sfk_copy_constructor
)
1052 const_p
= TYPE_HAS_CONST_INIT_REF (type
);
1053 else if (sfk
== sfk_assignment_operator
)
1054 const_p
= TYPE_HAS_CONST_ASSIGN_REF (type
);
1056 /* In this case, CONST_P will be ignored. */
1058 /* Declare the function. */
1059 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1060 /* Add it to CLASSTYPE_METHOD_VEC. */
1061 add_method (type
, fn
);
1062 /* Add it to TYPE_METHODS. */
1063 TREE_CHAIN (fn
) = TYPE_METHODS (type
);
1064 TYPE_METHODS (type
) = fn
;
1065 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1066 if (sfk
== sfk_constructor
|| sfk
== sfk_copy_constructor
)
1068 /* Remember that the function has been created. */
1069 if (sfk
== sfk_constructor
)
1070 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1072 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1073 /* Create appropriate clones. */
1074 clone_function_decl (fn
, /*update_method_vec=*/true);
1076 else if (sfk
== sfk_assignment_operator
)
1077 CLASSTYPE_LAZY_ASSIGNMENT_OP (type
) = 0;
1082 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1083 as there are artificial parms in FN. */
1086 skip_artificial_parms_for (tree fn
, tree list
)
1088 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1089 list
= TREE_CHAIN (list
);
1093 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1094 list
= TREE_CHAIN (list
);
1095 if (DECL_HAS_VTT_PARM_P (fn
))
1096 list
= TREE_CHAIN (list
);
1100 #include "gt-cp-method.h"