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 *);
66 static tree
make_alias_for_thunk (tree
);
69 /* Called once to initialize method.c. */
78 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL. */
81 set_mangled_name_for_decl (tree decl
)
83 if (processing_template_decl
)
84 /* There's no need to mangle the name of a template function. */
91 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
92 indicates whether it is a this or result adjusting thunk.
93 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
94 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
95 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
96 adjusting thunks, we scale it to a byte offset. For covariant
97 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
98 the returned thunk with finish_thunk. */
101 make_thunk (tree function
, bool this_adjusting
,
102 tree fixed_offset
, tree virtual_offset
)
107 my_friendly_assert (TREE_CODE (function
) == FUNCTION_DECL
, 20021025);
108 /* We can have this thunks to covariant thunks, but not vice versa. */
109 my_friendly_assert (!DECL_THIS_THUNK_P (function
), 20021127);
110 my_friendly_assert (!DECL_RESULT_THUNK_P (function
) || this_adjusting
,
113 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
114 if (this_adjusting
&& virtual_offset
)
116 = size_binop (MULT_EXPR
,
119 TYPE_SIZE_UNIT (vtable_entry_type
)));
121 d
= tree_low_cst (fixed_offset
, 0);
123 /* See if we already have the thunk in question. For this_adjusting
124 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
126 for (thunk
= DECL_THUNKS (function
); thunk
; thunk
= TREE_CHAIN (thunk
))
127 if (DECL_THIS_THUNK_P (thunk
) == this_adjusting
128 && THUNK_FIXED_OFFSET (thunk
) == d
129 && !virtual_offset
== !THUNK_VIRTUAL_OFFSET (thunk
)
132 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk
),
134 : THUNK_VIRTUAL_OFFSET (thunk
) == virtual_offset
)))
137 /* All thunks must be created before FUNCTION is actually emitted;
138 the ABI requires that all thunks be emitted together with the
139 function to which they transfer control. */
140 my_friendly_assert (!TREE_ASM_WRITTEN (function
), 20021025);
141 /* Likewise, we can only be adding thunks to a function declared in
142 the class currently being laid out. */
143 my_friendly_assert (TYPE_SIZE (DECL_CONTEXT (function
))
144 && TYPE_BEING_DEFINED (DECL_CONTEXT (function
)),
147 thunk
= build_decl (FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
148 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
149 cxx_dup_lang_specific_decl (thunk
);
150 DECL_THUNKS (thunk
) = NULL_TREE
;
152 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
153 TREE_READONLY (thunk
) = TREE_READONLY (function
);
154 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
155 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
157 comdat_linkage (thunk
);
158 SET_DECL_THUNK_P (thunk
, this_adjusting
);
159 THUNK_TARGET (thunk
) = function
;
160 THUNK_FIXED_OFFSET (thunk
) = d
;
161 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
162 THUNK_ALIAS (thunk
) = NULL_TREE
;
164 /* The thunk itself is not a constructor or destructor, even if
165 the thing it is thunking to is. */
166 DECL_INTERFACE_KNOWN (thunk
) = 1;
167 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
168 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
169 DECL_DESTRUCTOR_P (thunk
) = 0;
170 DECL_CONSTRUCTOR_P (thunk
) = 0;
171 /* And neither is it a clone. */
172 DECL_CLONED_FUNCTION (thunk
) = NULL_TREE
;
173 DECL_EXTERNAL (thunk
) = 1;
174 DECL_ARTIFICIAL (thunk
) = 1;
175 /* Even if this thunk is a member of a local class, we don't
176 need a static chain. */
177 DECL_NO_STATIC_CHAIN (thunk
) = 1;
178 /* The THUNK is not a pending inline, even if the FUNCTION is. */
179 DECL_PENDING_INLINE_P (thunk
) = 0;
180 DECL_INLINE (thunk
) = 0;
181 DECL_DECLARED_INLINE_P (thunk
) = 0;
182 /* Nor has it been deferred. */
183 DECL_DEFERRED_FN (thunk
) = 0;
185 /* Add it to the list of thunks associated with FUNCTION. */
186 TREE_CHAIN (thunk
) = DECL_THUNKS (function
);
187 DECL_THUNKS (function
) = thunk
;
192 /* Finish THUNK, a thunk decl. */
195 finish_thunk (tree thunk
)
198 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
199 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
201 my_friendly_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
), 20021127);
202 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
203 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
204 function
= THUNK_TARGET (thunk
);
205 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
206 fixed_offset
, virtual_offset
);
208 /* We can end up with declarations of (logically) different
209 covariant thunks, that do identical adjustments. The two thunks
210 will be adjusting between within different hierarchies, which
211 happen to have the same layout. We must nullify one of them to
212 refer to the other. */
213 if (DECL_RESULT_THUNK_P (thunk
))
217 for (cov_probe
= DECL_THUNKS (function
);
218 cov_probe
; cov_probe
= TREE_CHAIN (cov_probe
))
219 if (DECL_NAME (cov_probe
) == name
)
221 my_friendly_assert (!DECL_THUNKS (thunk
), 20031023);
222 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
223 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
228 DECL_NAME (thunk
) = name
;
229 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
232 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
233 offset indicated by VIRTUAL_OFFSET, if that is
234 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
235 zero for a result adjusting thunk. */
238 thunk_adjust (tree ptr
, bool this_adjusting
,
239 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
242 /* Adjust the pointer by the constant. */
243 ptr
= fold (build (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
244 ssize_int (fixed_offset
)));
246 /* If there's a virtual offset, look up that value in the vtable and
247 adjust the pointer again. */
252 ptr
= save_expr (ptr
);
253 /* The vptr is always at offset zero in the object. */
254 vtable
= build1 (NOP_EXPR
,
255 build_pointer_type (build_pointer_type
256 (vtable_entry_type
)),
258 /* Form the vtable address. */
259 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
260 /* Find the entry with the vcall offset. */
261 vtable
= build (PLUS_EXPR
, TREE_TYPE (vtable
), vtable
, virtual_offset
);
262 /* Get the offset itself. */
263 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
264 /* Adjust the `this' pointer. */
265 ptr
= fold (build (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
, vtable
));
269 /* Adjust the pointer by the constant. */
270 ptr
= fold (build (PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
271 ssize_int (fixed_offset
)));
276 /* Garbage collector tables contains thunk_labelno even when places
277 inside ifdef block. */
278 static GTY (()) int thunk_labelno
;
279 #ifdef ASM_OUTPUT_DEF
281 /* Create a static alias to function. */
284 make_alias_for_thunk (tree function
)
289 #if defined (TARGET_IS_PE_COFF)
290 if (DECL_ONE_ONLY (function
))
294 ASM_GENERATE_INTERNAL_LABEL (buf
, "LTHUNK", thunk_labelno
);
296 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
297 TREE_TYPE (function
));
298 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
299 cxx_dup_lang_specific_decl (alias
);
300 DECL_CONTEXT (alias
) = NULL
;
301 TREE_READONLY (alias
) = TREE_READONLY (function
);
302 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
303 TREE_PUBLIC (alias
) = 0;
304 DECL_INTERFACE_KNOWN (alias
) = 1;
305 DECL_NOT_REALLY_EXTERN (alias
) = 1;
306 DECL_THIS_STATIC (alias
) = 1;
307 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
308 DECL_DESTRUCTOR_P (alias
) = 0;
309 DECL_CONSTRUCTOR_P (alias
) = 0;
310 DECL_CLONED_FUNCTION (alias
) = NULL_TREE
;
311 DECL_EXTERNAL (alias
) = 0;
312 DECL_ARTIFICIAL (alias
) = 1;
313 DECL_NO_STATIC_CHAIN (alias
) = 1;
314 DECL_PENDING_INLINE_P (alias
) = 0;
315 DECL_INLINE (alias
) = 0;
316 DECL_DECLARED_INLINE_P (alias
) = 0;
317 DECL_DEFERRED_FN (alias
) = 0;
318 DECL_USE_TEMPLATE (alias
) = 0;
319 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
320 DECL_TEMPLATE_INFO (alias
) = NULL
;
321 DECL_INITIAL (alias
) = error_mark_node
;
322 TREE_ADDRESSABLE (alias
) = 1;
323 TREE_USED (alias
) = 1;
324 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
325 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
326 if (!flag_syntax_only
)
327 assemble_alias (alias
, DECL_ASSEMBLER_NAME (function
));
332 /* Emit the definition of a C++ multiple inheritance or covariant
333 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
337 use_thunk (tree thunk_fndecl
, bool emit_p
)
339 tree function
, alias
;
341 HOST_WIDE_INT fixed_offset
, virtual_value
;
342 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
344 /* We should have called finish_thunk to give it a name. */
345 my_friendly_assert (DECL_NAME (thunk_fndecl
), 20021127);
347 /* We should never be using an alias, always refer to the
349 my_friendly_assert (!THUNK_ALIAS (thunk_fndecl
), 20031023);
351 if (TREE_ASM_WRITTEN (thunk_fndecl
))
354 function
= THUNK_TARGET (thunk_fndecl
);
355 if (DECL_RESULT (thunk_fndecl
))
356 /* We already turned this thunk into an ordinary function.
357 There's no need to process this thunk again. */
360 if (DECL_THUNK_P (function
))
361 /* The target is itself a thunk, process it now. */
362 use_thunk (function
, emit_p
);
364 /* Thunks are always addressable; they only appear in vtables. */
365 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
367 /* Figure out what function is being thunked to. It's referenced in
368 this translation unit. */
369 TREE_ADDRESSABLE (function
) = 1;
370 mark_used (function
);
374 #ifdef ASM_OUTPUT_DEF
375 alias
= make_alias_for_thunk (function
);
380 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
381 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
386 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
387 virtual_value
= tree_low_cst (virtual_offset
, /*pos=*/0);
388 my_friendly_assert (virtual_value
, 20021026);
393 /* And, if we need to emit the thunk, it's used. */
394 mark_used (thunk_fndecl
);
395 /* This thunk is actually defined. */
396 DECL_EXTERNAL (thunk_fndecl
) = 0;
397 /* The linkage of the function may have changed. FIXME in linkage
399 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
400 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
402 if (flag_syntax_only
)
404 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
408 push_to_top_level ();
410 #if defined (ASM_OUTPUT_DEF) \
411 && !defined (TARGET_IS_PE_COFF)
412 if (targetm
.have_named_sections
)
414 resolve_unique_section (function
, 0, flag_function_sections
);
416 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
418 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
420 /* Output the thunk into the same section as function. */
421 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
426 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
428 DECL_INITIAL (thunk_fndecl
) = make_node (BLOCK
);
429 BLOCK_VARS (DECL_INITIAL (thunk_fndecl
)) = DECL_ARGUMENTS (thunk_fndecl
);
432 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
433 virtual_value
, alias
))
436 current_function_decl
= thunk_fndecl
;
437 DECL_RESULT (thunk_fndecl
)
438 = build_decl (RESULT_DECL
, 0, integer_type_node
);
439 fnname
= XSTR (XEXP (DECL_RTL (thunk_fndecl
), 0), 0);
440 init_function_start (thunk_fndecl
);
441 current_function_is_thunk
= 1;
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 current_function_decl
= 0;
450 /* Because init_function_start increments this, we must
452 immediate_size_expand
--;
453 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
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. */
464 if (varargs_function_p (function
))
465 error ("generic thunk code fails for method `%#D' which uses `...'",
468 /* Set up cloned argument trees for the thunk. */
470 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
472 tree x
= copy_node (a
);
474 DECL_CONTEXT (x
) = thunk_fndecl
;
475 SET_DECL_RTL (x
, NULL_RTX
);
479 DECL_ARGUMENTS (thunk_fndecl
) = a
;
480 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
482 start_function (NULL_TREE
, thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
483 /* We don't bother with a body block for thunks. */
485 /* There's no need to check accessibility inside the thunk body. */
486 push_deferring_access_checks (dk_no_check
);
490 t
= thunk_adjust (t
, /*this_adjusting=*/1,
491 fixed_offset
, virtual_offset
);
493 /* Build up the call to the real function. */
494 t
= tree_cons (NULL_TREE
, t
, NULL_TREE
);
495 for (a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
))
496 t
= tree_cons (NULL_TREE
, a
, t
);
498 t
= build_call (alias
, t
);
499 CALL_FROM_THUNK_P (t
) = 1;
500 t
= force_target_expr (TREE_TYPE (t
), t
);
502 t
= thunk_adjust (t
, /*this_adjusting=*/0,
503 fixed_offset
, virtual_offset
);
505 if (VOID_TYPE_P (TREE_TYPE (t
)))
506 finish_expr_stmt (t
);
508 finish_return_stmt (t
);
510 /* Since we want to emit the thunk, we explicitly mark its name as
512 mark_referenced (DECL_ASSEMBLER_NAME (thunk_fndecl
));
514 /* But we don't want debugging information about it. */
515 DECL_IGNORED_P (thunk_fndecl
) = 1;
517 /* Re-enable access control. */
518 pop_deferring_access_checks ();
520 expand_body (finish_function (0));
523 pop_from_top_level ();
526 /* Code for synthesizing methods which have default semantics defined. */
528 /* Generate code for default X(X&) constructor. */
531 do_build_copy_constructor (tree fndecl
)
533 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
536 parm
= convert_from_reference (parm
);
538 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
539 && is_empty_class (current_class_type
))
540 /* Don't copy the padding byte; it might not have been allocated
541 if *this is a base subobject. */;
542 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
544 t
= build (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
545 finish_expr_stmt (t
);
549 tree fields
= TYPE_FIELDS (current_class_type
);
550 int n_bases
= CLASSTYPE_N_BASECLASSES (current_class_type
);
551 tree binfos
= TYPE_BINFO_BASETYPES (current_class_type
);
552 tree member_init_list
= NULL_TREE
;
553 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
556 /* Initialize all the base-classes with the parameter converted
557 to their type so that we get their copy constructor and not
558 another constructor that takes current_class_type. We must
559 deal with the binfo's directly as a direct base might be
560 inaccessible due to ambiguity. */
561 for (t
= CLASSTYPE_VBASECLASSES (current_class_type
); t
;
564 tree binfo
= TREE_VALUE (t
);
568 build_tree_list (NULL_TREE
,
569 build_base_path (PLUS_EXPR
, parm
,
574 for (i
= 0; i
< n_bases
; ++i
)
576 tree binfo
= TREE_VEC_ELT (binfos
, i
);
577 if (TREE_VIA_VIRTUAL (binfo
))
582 build_tree_list (NULL_TREE
,
583 build_base_path (PLUS_EXPR
, parm
,
588 for (; fields
; fields
= TREE_CHAIN (fields
))
594 if (TREE_CODE (field
) != FIELD_DECL
)
597 expr_type
= TREE_TYPE (field
);
598 if (DECL_NAME (field
))
600 if (VFIELD_NAME_P (DECL_NAME (field
)))
603 /* True for duplicate members. */
604 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != 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
= build (COMPONENT_REF
, expr_type
, init
, field
);
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 (/*has_no_scope=*/false);
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
= build (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
652 finish_expr_stmt (t
);
657 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
660 /* Assign to each of the direct base classes. */
661 for (i
= 0; i
< CLASSTYPE_N_BASECLASSES (current_class_type
); ++i
)
666 binfo
= BINFO_BASETYPE (TYPE_BINFO (current_class_type
), i
);
667 /* We must convert PARM directly to the base class
668 explicitly since the base class may be ambiguous. */
669 converted_parm
= build_base_path (PLUS_EXPR
, parm
, binfo
, 1);
670 /* Call the base class assignment operator. */
672 (build_special_member_call (current_class_ref
,
673 ansi_assopname (NOP_EXPR
),
674 build_tree_list (NULL_TREE
,
677 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
));
680 /* Assign to each of the non-static data members. */
681 for (fields
= TYPE_FIELDS (current_class_type
);
683 fields
= TREE_CHAIN (fields
))
685 tree comp
= current_class_ref
;
691 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
694 expr_type
= TREE_TYPE (field
);
695 if (CP_TYPE_CONST_P (expr_type
))
697 error ("non-static const member `%#D', can't use default assignment operator", field
);
700 else if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
702 error ("non-static reference member `%#D', can't use default assignment operator", field
);
706 if (DECL_NAME (field
))
708 if (VFIELD_NAME_P (DECL_NAME (field
)))
711 /* True for duplicate members. */
712 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != field
)
715 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
716 /* Just use the field; anonymous types can't have
717 nontrivial copy ctors or assignment ops. */;
721 comp
= build (COMPONENT_REF
, TREE_TYPE (field
), comp
, field
);
723 /* Compute the type of init->field */
725 if (DECL_MUTABLE_P (field
))
726 quals
&= ~TYPE_QUAL_CONST
;
727 expr_type
= cp_build_qualified_type (expr_type
, quals
);
729 init
= build (COMPONENT_REF
, expr_type
, init
, field
);
731 if (DECL_NAME (field
))
732 init
= build_modify_expr (comp
, NOP_EXPR
, init
);
734 init
= build (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
735 finish_expr_stmt (init
);
738 finish_return_stmt (current_class_ref
);
739 finish_compound_stmt (compound_stmt
);
743 synthesize_method (tree fndecl
)
745 bool nested
= (current_function_decl
!= NULL_TREE
);
746 tree context
= decl_function_context (fndecl
);
747 bool need_body
= true;
751 import_export_decl (fndecl
);
753 /* If we've been asked to synthesize a clone, just synthesize the
754 cloned function instead. Doing so will automatically fill in the
755 body for the clone. */
756 if (DECL_CLONED_FUNCTION_P (fndecl
))
758 synthesize_method (DECL_CLONED_FUNCTION (fndecl
));
762 /* We may be in the middle of deferred access check. Disable
764 push_deferring_access_checks (dk_no_deferred
);
767 push_to_top_level ();
769 push_function_context_to (context
);
771 /* Put the function definition at the position where it is needed,
772 rather than within the body of the class. That way, an error
773 during the generation of the implicit body points at the place
774 where the attempt to generate the function occurs, giving the
775 user a hint as to why we are attempting to generate the
777 DECL_SOURCE_LOCATION (fndecl
) = input_location
;
779 interface_unknown
= 1;
780 start_function (NULL_TREE
, 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
);
794 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type
))
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 (/*has_no_scope=*/false);
804 finish_compound_stmt (compound_stmt
);
807 finish_function_body (stmt
);
808 expand_or_defer_fn (finish_function (0));
810 extract_interface_info ();
812 pop_from_top_level ();
814 pop_function_context_from (context
);
816 pop_deferring_access_checks ();
819 /* Use EXTRACTOR to locate the relevant function called for each base &
820 class field of TYPE. CLIENT allows additional information to be passed
821 to EXTRACTOR. Generates the union of all exceptions generated by those
822 functions. Note that we haven't updated TYPE_FIELDS and such of any
823 variants yet, so we need to look at the main one. */
826 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
829 tree raises
= empty_except_spec
;
830 tree fields
= TYPE_FIELDS (type
);
831 int i
, n_bases
= CLASSTYPE_N_BASECLASSES (type
);
832 tree binfos
= TYPE_BINFO_BASETYPES (type
);
834 for (i
= 0; i
!= n_bases
; i
++)
836 tree base
= BINFO_TYPE (TREE_VEC_ELT (binfos
, i
));
837 tree fn
= (*extractor
) (base
, client
);
840 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
842 raises
= merge_exception_specifiers (raises
, fn_raises
);
845 for (; fields
; fields
= TREE_CHAIN (fields
))
847 tree type
= TREE_TYPE (fields
);
850 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
852 while (TREE_CODE (type
) == ARRAY_TYPE
)
853 type
= TREE_TYPE (type
);
854 if (!CLASS_TYPE_P (type
))
857 fn
= (*extractor
) (type
, client
);
860 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
862 raises
= merge_exception_specifiers (raises
, fn_raises
);
868 /* Locate the dtor of TYPE. */
871 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
875 if (!TYPE_HAS_DESTRUCTOR (type
))
877 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
),
878 CLASSTYPE_DESTRUCTOR_SLOT
);
882 /* Locate the default ctor of TYPE. */
885 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
889 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
892 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
),
893 CLASSTYPE_CONSTRUCTOR_SLOT
);
894 for (; fns
; fns
= OVL_NEXT (fns
))
896 tree fn
= OVL_CURRENT (fns
);
897 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
899 parms
= skip_artificial_parms_for (fn
, parms
);
901 if (sufficient_parms_p (parms
))
913 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
914 points to a COPY_DATA holding the name (NULL for the ctor)
915 and desired qualifiers of the source operand. */
918 locate_copy (tree type
, void *client_
)
920 struct copy_data
*client
= (struct copy_data
*)client_
;
923 tree best
= NULL_TREE
;
924 bool excess_p
= false;
928 if (TYPE_HAS_ASSIGN_REF (type
))
929 ix
= lookup_fnfields_1 (type
, client
->name
);
931 else if (TYPE_HAS_INIT_REF (type
))
932 ix
= CLASSTYPE_CONSTRUCTOR_SLOT
;
935 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), ix
);
937 for (; fns
; fns
= OVL_NEXT (fns
))
939 tree fn
= OVL_CURRENT (fns
);
940 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
945 parms
= skip_artificial_parms_for (fn
, parms
);
948 src_type
= non_reference (TREE_VALUE (parms
));
949 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
951 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
953 quals
= cp_type_quals (src_type
);
954 if (client
->quals
& ~quals
)
956 excess
= quals
& ~client
->quals
;
957 if (!best
|| (excess_p
&& !excess
))
969 /* Implicitly declare the special function indicated by KIND, as a
970 member of TYPE. For copy constructors and assignment operators,
971 CONST_P indicates whether these functions should take a const
972 reference argument or a non-const reference. */
975 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
977 tree declspecs
= NULL_TREE
;
978 tree fn
, args
= NULL_TREE
;
979 tree raises
= empty_except_spec
;
981 bool has_parm
= false;
982 tree name
= constructor_name (type
);
988 name
= build_nt (BIT_NOT_EXPR
, name
);
989 args
= void_list_node
;
990 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
993 case sfk_constructor
:
994 /* Default constructor. */
995 args
= void_list_node
;
996 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
999 case sfk_copy_constructor
:
1000 case sfk_assignment_operator
:
1002 struct copy_data data
;
1003 tree argtype
= type
;
1008 if (kind
== sfk_assignment_operator
)
1011 declspecs
= build_tree_list (NULL_TREE
, type
);
1013 name
= ansi_assopname (NOP_EXPR
);
1018 data
.quals
= TYPE_QUAL_CONST
;
1019 argtype
= build_qualified_type (argtype
, TYPE_QUAL_CONST
);
1022 argtype
= build_reference_type (argtype
);
1023 args
= build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1024 get_identifier ("_ctor_arg"));
1025 args
= tree_cons (NULL_TREE
, args
, void_list_node
);
1027 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1034 TREE_PARMLIST (args
) = 1;
1037 tree declarator
= make_call_declarator (name
, args
, NULL_TREE
, raises
);
1040 declarator
= build_nt (ADDR_EXPR
, declarator
);
1042 fn
= grokfield (declarator
, declspecs
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
1044 TREE_USED (FUNCTION_FIRST_USER_PARM (fn
)) = 1;
1047 my_friendly_assert (TREE_CODE (fn
) == FUNCTION_DECL
, 20000408);
1049 DECL_ARTIFICIAL (fn
) = 1;
1050 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1051 DECL_DECLARED_INLINE_P (fn
) = 1;
1052 DECL_INLINE (fn
) = 1;
1058 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1059 as there are artificial parms in FN. */
1062 skip_artificial_parms_for (tree fn
, tree list
)
1064 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1065 list
= TREE_CHAIN (list
);
1069 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1070 list
= TREE_CHAIN (list
);
1071 if (DECL_HAS_VTT_PARM_P (fn
))
1072 list
= TREE_CHAIN (list
);
1076 #include "gt-cp-method.h"