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. */
76 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL. */
79 set_mangled_name_for_decl (tree decl
)
81 if (processing_template_decl
)
82 /* There's no need to mangle the name of a template function. */
89 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
90 indicates whether it is a this or result adjusting thunk.
91 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
92 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
93 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
94 adjusting thunks, we scale it to a byte offset. For covariant
95 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
96 the returned thunk with finish_thunk. */
99 make_thunk (tree function
, bool this_adjusting
,
100 tree fixed_offset
, tree virtual_offset
)
105 my_friendly_assert (TREE_CODE (function
) == FUNCTION_DECL
, 20021025);
106 /* We can have this thunks to covariant thunks, but not vice versa. */
107 my_friendly_assert (!DECL_THIS_THUNK_P (function
), 20021127);
108 my_friendly_assert (!DECL_RESULT_THUNK_P (function
) || this_adjusting
,
111 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
112 if (this_adjusting
&& virtual_offset
)
114 = size_binop (MULT_EXPR
,
117 TYPE_SIZE_UNIT (vtable_entry_type
)));
119 d
= tree_low_cst (fixed_offset
, 0);
121 /* See if we already have the thunk in question. For this_adjusting
122 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
124 for (thunk
= DECL_THUNKS (function
); thunk
; thunk
= TREE_CHAIN (thunk
))
125 if (DECL_THIS_THUNK_P (thunk
) == this_adjusting
126 && THUNK_FIXED_OFFSET (thunk
) == d
127 && !virtual_offset
== !THUNK_VIRTUAL_OFFSET (thunk
)
130 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk
),
132 : THUNK_VIRTUAL_OFFSET (thunk
) == virtual_offset
)))
135 /* All thunks must be created before FUNCTION is actually emitted;
136 the ABI requires that all thunks be emitted together with the
137 function to which they transfer control. */
138 my_friendly_assert (!TREE_ASM_WRITTEN (function
), 20021025);
139 /* Likewise, we can only be adding thunks to a function declared in
140 the class currently being laid out. */
141 my_friendly_assert (TYPE_SIZE (DECL_CONTEXT (function
))
142 && TYPE_BEING_DEFINED (DECL_CONTEXT (function
)),
145 thunk
= build_decl (FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
146 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
147 cxx_dup_lang_specific_decl (thunk
);
148 DECL_THUNKS (thunk
) = NULL_TREE
;
150 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
151 TREE_READONLY (thunk
) = TREE_READONLY (function
);
152 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
153 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
155 comdat_linkage (thunk
);
156 SET_DECL_THUNK_P (thunk
, this_adjusting
);
157 THUNK_TARGET (thunk
) = function
;
158 THUNK_FIXED_OFFSET (thunk
) = d
;
159 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
160 THUNK_ALIAS (thunk
) = NULL_TREE
;
162 /* The thunk itself is not a constructor or destructor, even if
163 the thing it is thunking to is. */
164 DECL_INTERFACE_KNOWN (thunk
) = 1;
165 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
166 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
167 DECL_DESTRUCTOR_P (thunk
) = 0;
168 DECL_CONSTRUCTOR_P (thunk
) = 0;
169 /* And neither is it a clone. */
170 DECL_CLONED_FUNCTION (thunk
) = NULL_TREE
;
171 DECL_EXTERNAL (thunk
) = 1;
172 DECL_ARTIFICIAL (thunk
) = 1;
173 /* Even if this thunk is a member of a local class, we don't
174 need a static chain. */
175 DECL_NO_STATIC_CHAIN (thunk
) = 1;
176 /* The THUNK is not a pending inline, even if the FUNCTION is. */
177 DECL_PENDING_INLINE_P (thunk
) = 0;
178 DECL_INLINE (thunk
) = 0;
179 DECL_DECLARED_INLINE_P (thunk
) = 0;
180 /* Nor has it been deferred. */
181 DECL_DEFERRED_FN (thunk
) = 0;
183 /* Add it to the list of thunks associated with FUNCTION. */
184 TREE_CHAIN (thunk
) = DECL_THUNKS (function
);
185 DECL_THUNKS (function
) = thunk
;
190 /* Finish THUNK, a thunk decl. */
193 finish_thunk (tree thunk
)
196 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
197 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
199 my_friendly_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
), 20021127);
200 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
201 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
202 function
= THUNK_TARGET (thunk
);
203 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
204 fixed_offset
, virtual_offset
);
206 /* We can end up with declarations of (logically) different
207 covariant thunks, that do identical adjustments. The two thunks
208 will be adjusting between within different hierarchies, which
209 happen to have the same layout. We must nullify one of them to
210 refer to the other. */
211 if (DECL_RESULT_THUNK_P (thunk
))
215 for (cov_probe
= DECL_THUNKS (function
);
216 cov_probe
; cov_probe
= TREE_CHAIN (cov_probe
))
217 if (DECL_NAME (cov_probe
) == name
)
219 my_friendly_assert (!DECL_THUNKS (thunk
), 20031023);
220 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
221 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
226 DECL_NAME (thunk
) = name
;
227 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
230 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
231 offset indicated by VIRTUAL_OFFSET, if that is
232 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
233 zero for a result adjusting thunk. */
236 thunk_adjust (tree ptr
, bool this_adjusting
,
237 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
240 /* Adjust the pointer by the constant. */
241 ptr
= fold (build (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
242 ssize_int (fixed_offset
)));
244 /* If there's a virtual offset, look up that value in the vtable and
245 adjust the pointer again. */
250 ptr
= save_expr (ptr
);
251 /* The vptr is always at offset zero in the object. */
252 vtable
= build1 (NOP_EXPR
,
253 build_pointer_type (build_pointer_type
254 (vtable_entry_type
)),
256 /* Form the vtable address. */
257 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
258 /* Find the entry with the vcall offset. */
259 vtable
= build (PLUS_EXPR
, TREE_TYPE (vtable
), vtable
, virtual_offset
);
260 /* Get the offset itself. */
261 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
262 /* Adjust the `this' pointer. */
263 ptr
= fold (build (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
, vtable
));
267 /* Adjust the pointer by the constant. */
268 ptr
= fold (build (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
269 ssize_int (fixed_offset
)));
274 static GTY (()) int thunk_labelno
;
276 /* Create a static alias to function. */
279 make_alias_for_thunk (tree function
)
284 ASM_GENERATE_INTERNAL_LABEL (buf
, "LTHUNK", thunk_labelno
);
286 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
287 TREE_TYPE (function
));
288 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
289 cxx_dup_lang_specific_decl (alias
);
290 DECL_CONTEXT (alias
) = NULL
;
291 TREE_READONLY (alias
) = TREE_READONLY (function
);
292 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
293 TREE_PUBLIC (alias
) = 0;
294 DECL_INTERFACE_KNOWN (alias
) = 1;
295 DECL_NOT_REALLY_EXTERN (alias
) = 1;
296 DECL_THIS_STATIC (alias
) = 1;
297 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
298 DECL_DESTRUCTOR_P (alias
) = 0;
299 DECL_CONSTRUCTOR_P (alias
) = 0;
300 DECL_CLONED_FUNCTION (alias
) = NULL_TREE
;
301 DECL_EXTERNAL (alias
) = 0;
302 DECL_ARTIFICIAL (alias
) = 1;
303 DECL_NO_STATIC_CHAIN (alias
) = 1;
304 DECL_PENDING_INLINE_P (alias
) = 0;
305 DECL_INLINE (alias
) = 0;
306 DECL_DECLARED_INLINE_P (alias
) = 0;
307 DECL_DEFERRED_FN (alias
) = 0;
308 DECL_USE_TEMPLATE (alias
) = 0;
309 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
310 DECL_TEMPLATE_INFO (alias
) = NULL
;
311 DECL_INITIAL (alias
) = error_mark_node
;
312 TREE_ADDRESSABLE (alias
) = 1;
313 TREE_USED (alias
) = 1;
314 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
315 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
316 if (!flag_syntax_only
)
317 assemble_alias (alias
, DECL_ASSEMBLER_NAME (function
));
321 /* Emit the definition of a C++ multiple inheritance or covariant
322 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
326 use_thunk (tree thunk_fndecl
, bool emit_p
)
328 tree a
, t
, function
, alias
;
330 HOST_WIDE_INT fixed_offset
, virtual_value
;
331 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
333 /* We should have called finish_thunk to give it a name. */
334 my_friendly_assert (DECL_NAME (thunk_fndecl
), 20021127);
336 /* We should never be using an alias, always refer to the
338 my_friendly_assert (!THUNK_ALIAS (thunk_fndecl
), 20031023);
340 if (TREE_ASM_WRITTEN (thunk_fndecl
))
343 function
= THUNK_TARGET (thunk_fndecl
);
344 if (DECL_RESULT (thunk_fndecl
))
345 /* We already turned this thunk into an ordinary function.
346 There's no need to process this thunk again. */
349 /* Thunks are always addressable; they only appear in vtables. */
350 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
352 /* Figure out what function is being thunked to. It's referenced in
353 this translation unit. */
354 TREE_ADDRESSABLE (function
) = 1;
355 mark_used (function
);
356 mark_decl_referenced (function
);
360 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
))
361 alias
= make_alias_for_thunk (function
);
365 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
366 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
371 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
372 virtual_value
= tree_low_cst (virtual_offset
, /*pos=*/0);
373 my_friendly_assert (virtual_value
, 20021026);
378 /* And, if we need to emit the thunk, it's used. */
379 mark_used (thunk_fndecl
);
380 /* This thunk is actually defined. */
381 DECL_EXTERNAL (thunk_fndecl
) = 0;
382 /* The linkage of the function may have changed. FIXME in linkage
384 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
385 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
386 if (flag_weak
&& TREE_PUBLIC (thunk_fndecl
))
387 comdat_linkage (thunk_fndecl
);
389 if (flag_syntax_only
)
391 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
395 push_to_top_level ();
397 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
398 && targetm
.have_named_sections
)
400 resolve_unique_section (function
, 0, flag_function_sections
);
402 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
404 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
406 /* Output the thunk into the same section as function. */
407 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
411 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
413 DECL_INITIAL (thunk_fndecl
) = make_node (BLOCK
);
415 /* Set up cloned argument trees for the thunk. */
417 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
419 tree x
= copy_node (a
);
421 DECL_CONTEXT (x
) = thunk_fndecl
;
422 SET_DECL_RTL (x
, NULL_RTX
);
426 DECL_ARGUMENTS (thunk_fndecl
) = a
;
427 BLOCK_VARS (DECL_INITIAL (thunk_fndecl
)) = a
;
430 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
431 virtual_value
, alias
))
434 current_function_decl
= thunk_fndecl
;
435 DECL_RESULT (thunk_fndecl
)
436 = build_decl (RESULT_DECL
, 0, integer_type_node
);
437 fnname
= XSTR (XEXP (DECL_RTL (thunk_fndecl
), 0), 0);
438 init_function_start (thunk_fndecl
);
439 current_function_is_thunk
= 1;
440 assemble_start_function (thunk_fndecl
, fnname
);
442 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
443 fixed_offset
, virtual_value
, alias
);
445 assemble_end_function (thunk_fndecl
, fnname
);
446 current_function_decl
= 0;
448 /* Because init_function_start increments this, we must
450 immediate_size_expand
--;
451 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
455 /* If this is a covariant thunk, or we don't have the necessary
456 code for efficient thunks, generate a thunk function that
457 just makes a call to the real function. Unfortunately, this
458 doesn't work for varargs. */
460 if (varargs_function_p (function
))
461 error ("generic thunk code fails for method `%#D' which uses `...'",
464 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
466 start_function (NULL_TREE
, thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
467 /* We don't bother with a body block for thunks. */
469 /* There's no need to check accessibility inside the thunk body. */
470 push_deferring_access_checks (dk_no_check
);
474 t
= thunk_adjust (t
, /*this_adjusting=*/1,
475 fixed_offset
, virtual_offset
);
477 /* Build up the call to the real function. */
478 t
= tree_cons (NULL_TREE
, t
, NULL_TREE
);
479 for (a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
))
480 t
= tree_cons (NULL_TREE
, a
, t
);
482 t
= build_call (alias
, t
);
483 CALL_FROM_THUNK_P (t
) = 1;
485 if (VOID_TYPE_P (TREE_TYPE (t
)))
486 finish_expr_stmt (t
);
489 t
= force_target_expr (TREE_TYPE (t
), t
);
491 t
= thunk_adjust (t
, /*this_adjusting=*/0,
492 fixed_offset
, virtual_offset
);
493 finish_return_stmt (t
);
496 /* Since we want to emit the thunk, we explicitly mark its name as
498 mark_decl_referenced (thunk_fndecl
);
500 /* But we don't want debugging information about it. */
501 DECL_IGNORED_P (thunk_fndecl
) = 1;
503 /* Re-enable access control. */
504 pop_deferring_access_checks ();
506 expand_body (finish_function (0));
509 pop_from_top_level ();
512 /* Code for synthesizing methods which have default semantics defined. */
514 /* Generate code for default X(X&) constructor. */
517 do_build_copy_constructor (tree fndecl
)
519 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
522 parm
= convert_from_reference (parm
);
524 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
525 && is_empty_class (current_class_type
))
526 /* Don't copy the padding byte; it might not have been allocated
527 if *this is a base subobject. */;
528 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
530 t
= build (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
531 finish_expr_stmt (t
);
535 tree fields
= TYPE_FIELDS (current_class_type
);
536 int n_bases
= CLASSTYPE_N_BASECLASSES (current_class_type
);
537 tree binfos
= TYPE_BINFO_BASETYPES (current_class_type
);
538 tree member_init_list
= NULL_TREE
;
539 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
542 /* Initialize all the base-classes with the parameter converted
543 to their type so that we get their copy constructor and not
544 another constructor that takes current_class_type. We must
545 deal with the binfo's directly as a direct base might be
546 inaccessible due to ambiguity. */
547 for (t
= CLASSTYPE_VBASECLASSES (current_class_type
); t
;
550 tree binfo
= TREE_VALUE (t
);
554 build_tree_list (NULL_TREE
,
555 build_base_path (PLUS_EXPR
, parm
,
560 for (i
= 0; i
< n_bases
; ++i
)
562 tree binfo
= TREE_VEC_ELT (binfos
, i
);
563 if (TREE_VIA_VIRTUAL (binfo
))
568 build_tree_list (NULL_TREE
,
569 build_base_path (PLUS_EXPR
, parm
,
574 for (; fields
; fields
= TREE_CHAIN (fields
))
580 if (TREE_CODE (field
) != FIELD_DECL
)
584 if (DECL_NAME (field
))
586 if (VFIELD_NAME_P (DECL_NAME (field
)))
589 /* True for duplicate members. */
590 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != field
)
593 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
594 && ANON_AGGR_TYPE_P (t
)
595 && TYPE_FIELDS (t
) != NULL_TREE
)
596 /* Just use the field; anonymous types can't have
597 nontrivial copy ctors or assignment ops. */;
601 /* Compute the type of "init->field". If the copy-constructor
602 parameter is, for example, "const S&", and the type of
603 the field is "T", then the type will usually be "const
604 T". (There are no cv-qualified variants of reference
606 expr_type
= TREE_TYPE (field
);
607 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
608 expr_type
= cp_build_qualified_type (expr_type
, cvquals
);
609 init
= build (COMPONENT_REF
, expr_type
, init
, field
);
610 init
= build_tree_list (NULL_TREE
, init
);
613 = tree_cons (field
, init
, member_init_list
);
615 finish_mem_initializers (member_init_list
);
620 do_build_assign_ref (tree fndecl
)
622 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
625 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/false);
626 parm
= convert_from_reference (parm
);
628 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
629 && is_empty_class (current_class_type
))
630 /* Don't copy the padding byte; it might not have been allocated
631 if *this is a base subobject. */;
632 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
634 tree t
= build (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
635 finish_expr_stmt (t
);
640 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
643 /* Assign to each of the direct base classes. */
644 for (i
= 0; i
< CLASSTYPE_N_BASECLASSES (current_class_type
); ++i
)
649 binfo
= BINFO_BASETYPE (TYPE_BINFO (current_class_type
), i
);
650 /* We must convert PARM directly to the base class
651 explicitly since the base class may be ambiguous. */
652 converted_parm
= build_base_path (PLUS_EXPR
, parm
, binfo
, 1);
653 /* Call the base class assignment operator. */
655 (build_special_member_call (current_class_ref
,
656 ansi_assopname (NOP_EXPR
),
657 build_tree_list (NULL_TREE
,
660 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
));
663 /* Assign to each of the non-static data members. */
664 for (fields
= TYPE_FIELDS (current_class_type
);
666 fields
= TREE_CHAIN (fields
))
671 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
674 if (CP_TYPE_CONST_P (TREE_TYPE (field
)))
676 error ("non-static const member `%#D', can't use default assignment operator", field
);
679 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
681 error ("non-static reference member `%#D', can't use default assignment operator", field
);
685 comp
= current_class_ref
;
688 if (DECL_NAME (field
))
690 if (VFIELD_NAME_P (DECL_NAME (field
)))
693 /* True for duplicate members. */
694 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != field
)
697 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
698 && ANON_AGGR_TYPE_P (t
)
699 && TYPE_FIELDS (t
) != NULL_TREE
)
700 /* Just use the field; anonymous types can't have
701 nontrivial copy ctors or assignment ops. */;
705 comp
= build (COMPONENT_REF
, TREE_TYPE (field
), comp
, field
);
706 init
= build (COMPONENT_REF
,
707 cp_build_qualified_type (TREE_TYPE (field
), cvquals
),
710 if (DECL_NAME (field
))
711 finish_expr_stmt (build_modify_expr (comp
, NOP_EXPR
, init
));
713 finish_expr_stmt (build (MODIFY_EXPR
, TREE_TYPE (comp
), comp
,
717 finish_return_stmt (current_class_ref
);
718 finish_compound_stmt (compound_stmt
);
722 synthesize_method (tree fndecl
)
724 bool nested
= (current_function_decl
!= NULL_TREE
);
725 tree context
= decl_function_context (fndecl
);
726 bool need_body
= true;
730 import_export_decl (fndecl
);
732 /* If we've been asked to synthesize a clone, just synthesize the
733 cloned function instead. Doing so will automatically fill in the
734 body for the clone. */
735 if (DECL_CLONED_FUNCTION_P (fndecl
))
737 synthesize_method (DECL_CLONED_FUNCTION (fndecl
));
741 /* We may be in the middle of deferred access check. Disable
743 push_deferring_access_checks (dk_no_deferred
);
746 push_to_top_level ();
748 push_function_context_to (context
);
750 /* Put the function definition at the position where it is needed,
751 rather than within the body of the class. That way, an error
752 during the generation of the implicit body points at the place
753 where the attempt to generate the function occurs, giving the
754 user a hint as to why we are attempting to generate the
756 DECL_SOURCE_LOCATION (fndecl
) = input_location
;
758 interface_unknown
= 1;
759 start_function (NULL_TREE
, fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
761 stmt
= begin_function_body ();
763 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
765 do_build_assign_ref (fndecl
);
768 else if (DECL_CONSTRUCTOR_P (fndecl
))
770 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
771 if (arg_chain
!= void_list_node
)
772 do_build_copy_constructor (fndecl
);
773 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type
))
774 finish_mem_initializers (NULL_TREE
);
777 /* If we haven't yet generated the body of the function, just
778 generate an empty compound statement. */
782 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/false);
783 finish_compound_stmt (compound_stmt
);
786 finish_function_body (stmt
);
787 expand_or_defer_fn (finish_function (0));
789 extract_interface_info ();
791 pop_from_top_level ();
793 pop_function_context_from (context
);
795 pop_deferring_access_checks ();
798 /* Use EXTRACTOR to locate the relevant function called for each base &
799 class field of TYPE. CLIENT allows additional information to be passed
800 to EXTRACTOR. Generates the union of all exceptions generated by those
801 functions. Note that we haven't updated TYPE_FIELDS and such of any
802 variants yet, so we need to look at the main one. */
805 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
808 tree raises
= empty_except_spec
;
809 tree fields
= TYPE_FIELDS (type
);
810 int i
, n_bases
= CLASSTYPE_N_BASECLASSES (type
);
811 tree binfos
= TYPE_BINFO_BASETYPES (type
);
813 for (i
= 0; i
!= n_bases
; i
++)
815 tree base
= BINFO_TYPE (TREE_VEC_ELT (binfos
, i
));
816 tree fn
= (*extractor
) (base
, client
);
819 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
821 raises
= merge_exception_specifiers (raises
, fn_raises
);
824 for (; fields
; fields
= TREE_CHAIN (fields
))
826 tree type
= TREE_TYPE (fields
);
829 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
831 while (TREE_CODE (type
) == ARRAY_TYPE
)
832 type
= TREE_TYPE (type
);
833 if (TREE_CODE (type
) != RECORD_TYPE
)
836 fn
= (*extractor
) (type
, client
);
839 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
841 raises
= merge_exception_specifiers (raises
, fn_raises
);
847 /* Locate the dtor of TYPE. */
850 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
854 if (!TYPE_HAS_DESTRUCTOR (type
))
856 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
),
857 CLASSTYPE_DESTRUCTOR_SLOT
);
861 /* Locate the default ctor of TYPE. */
864 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
868 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
871 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
),
872 CLASSTYPE_CONSTRUCTOR_SLOT
);
873 for (; fns
; fns
= OVL_NEXT (fns
))
875 tree fn
= OVL_CURRENT (fns
);
876 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
878 if (sufficient_parms_p (TREE_CHAIN (parms
)))
890 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
891 points to a COPY_DATA holding the name (NULL for the ctor)
892 and desired qualifiers of the source operand. */
895 locate_copy (tree type
, void *client_
)
897 struct copy_data
*client
= (struct copy_data
*)client_
;
900 tree best
= NULL_TREE
;
901 bool excess_p
= false;
905 if (TYPE_HAS_ASSIGN_REF (type
))
906 ix
= lookup_fnfields_1 (type
, client
->name
);
908 else if (TYPE_HAS_INIT_REF (type
))
909 ix
= CLASSTYPE_CONSTRUCTOR_SLOT
;
912 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), ix
);
914 for (; fns
; fns
= OVL_NEXT (fns
))
916 tree fn
= OVL_CURRENT (fns
);
917 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
922 parms
= TREE_CHAIN (parms
);
925 src_type
= non_reference (TREE_VALUE (parms
));
926 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
928 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
930 quals
= cp_type_quals (src_type
);
931 if (client
->quals
& ~quals
)
933 excess
= quals
& ~client
->quals
;
934 if (!best
|| (excess_p
&& !excess
))
946 /* Implicitly declare the special function indicated by KIND, as a
947 member of TYPE. For copy constructors and assignment operators,
948 CONST_P indicates whether these functions should take a const
949 reference argument or a non-const reference. */
952 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
954 tree declspecs
= NULL_TREE
;
955 tree fn
, args
= NULL_TREE
;
956 tree raises
= empty_except_spec
;
958 bool has_parm
= false;
959 tree name
= constructor_name (type
);
965 name
= build_nt (BIT_NOT_EXPR
, name
);
966 args
= void_list_node
;
967 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
970 case sfk_constructor
:
971 /* Default constructor. */
972 args
= void_list_node
;
973 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
976 case sfk_copy_constructor
:
977 case sfk_assignment_operator
:
979 struct copy_data data
;
985 if (kind
== sfk_assignment_operator
)
988 declspecs
= build_tree_list (NULL_TREE
, type
);
990 name
= ansi_assopname (NOP_EXPR
);
995 data
.quals
= TYPE_QUAL_CONST
;
996 argtype
= build_qualified_type (argtype
, TYPE_QUAL_CONST
);
999 argtype
= build_reference_type (argtype
);
1000 args
= build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1001 get_identifier ("_ctor_arg"));
1002 args
= tree_cons (NULL_TREE
, args
, void_list_node
);
1004 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1011 TREE_PARMLIST (args
) = 1;
1014 tree declarator
= make_call_declarator (name
, args
, NULL_TREE
, raises
);
1017 declarator
= build_nt (ADDR_EXPR
, declarator
);
1019 fn
= grokfield (declarator
, declspecs
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
1021 TREE_USED (FUNCTION_FIRST_USER_PARM (fn
)) = 1;
1024 my_friendly_assert (TREE_CODE (fn
) == FUNCTION_DECL
, 20000408);
1026 DECL_ARTIFICIAL (fn
) = 1;
1027 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1028 DECL_DECLARED_INLINE_P (fn
) = 1;
1029 DECL_INLINE (fn
) = 1;
1036 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1037 as there are artificial parms in FN. */
1040 skip_artificial_parms_for (tree fn
, tree list
)
1042 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1043 list
= TREE_CHAIN (list
);
1047 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1048 list
= TREE_CHAIN (list
);
1049 if (DECL_HAS_VTT_PARM_P (fn
))
1050 list
= TREE_CHAIN (list
);
1054 #include "gt-cp-method.h"