1 /* Handle the hair of processing (but not expanding) inline functions.
2 Also manage function and variable name overloading.
3 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
39 #include "tree-pass.h"
40 #include "diagnostic.h"
43 /* Various flags to control the mangling process. */
49 /* The thing we are presently mangling is part of a template type,
50 rather than a fully instantiated type. Therefore, we may see
51 complex expressions where we would normally expect to see a
52 simple integer constant. */
53 mf_maybe_uninstantiated
= 1,
54 /* When mangling a numeric value, use the form `_XX_' (instead of
55 just `XX') if the value has more than one digit. */
56 mf_use_underscores_around_value
= 2
59 typedef enum mangling_flags mangling_flags
;
61 static tree
thunk_adjust (tree
, bool, HOST_WIDE_INT
, tree
);
62 static void do_build_assign_ref (tree
);
63 static void do_build_copy_constructor (tree
);
64 static tree
synthesize_exception_spec (tree
, tree (*) (tree
, void *), void *);
65 static tree
make_alias_for_thunk (tree
);
67 /* Called once to initialize method.c. */
75 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
76 indicates whether it is a this or result adjusting thunk.
77 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
78 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
79 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
80 adjusting thunks, we scale it to a byte offset. For covariant
81 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
82 the returned thunk with finish_thunk. */
85 make_thunk (tree function
, bool this_adjusting
,
86 tree fixed_offset
, tree virtual_offset
)
91 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
);
92 /* We can have this thunks to covariant thunks, but not vice versa. */
93 gcc_assert (!DECL_THIS_THUNK_P (function
));
94 gcc_assert (!DECL_RESULT_THUNK_P (function
) || this_adjusting
);
96 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
97 if (this_adjusting
&& virtual_offset
)
99 = size_binop (MULT_EXPR
,
102 TYPE_SIZE_UNIT (vtable_entry_type
)));
104 d
= tree_low_cst (fixed_offset
, 0);
106 /* See if we already have the thunk in question. For this_adjusting
107 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
109 for (thunk
= DECL_THUNKS (function
); thunk
; thunk
= TREE_CHAIN (thunk
))
110 if (DECL_THIS_THUNK_P (thunk
) == this_adjusting
111 && THUNK_FIXED_OFFSET (thunk
) == d
112 && !virtual_offset
== !THUNK_VIRTUAL_OFFSET (thunk
)
115 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk
),
117 : THUNK_VIRTUAL_OFFSET (thunk
) == virtual_offset
)))
120 /* All thunks must be created before FUNCTION is actually emitted;
121 the ABI requires that all thunks be emitted together with the
122 function to which they transfer control. */
123 gcc_assert (!TREE_ASM_WRITTEN (function
));
124 /* Likewise, we can only be adding thunks to a function declared in
125 the class currently being laid out. */
126 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function
))
127 && TYPE_BEING_DEFINED (DECL_CONTEXT (function
)));
129 thunk
= build_decl (DECL_SOURCE_LOCATION (function
),
130 FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
131 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
132 cxx_dup_lang_specific_decl (thunk
);
133 DECL_THUNKS (thunk
) = NULL_TREE
;
135 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
136 TREE_READONLY (thunk
) = TREE_READONLY (function
);
137 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
138 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
139 SET_DECL_THUNK_P (thunk
, this_adjusting
);
140 THUNK_TARGET (thunk
) = function
;
141 THUNK_FIXED_OFFSET (thunk
) = d
;
142 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
143 THUNK_ALIAS (thunk
) = NULL_TREE
;
145 /* The thunk itself is not a constructor or destructor, even if
146 the thing it is thunking to is. */
147 DECL_INTERFACE_KNOWN (thunk
) = 1;
148 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
149 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
150 DECL_DESTRUCTOR_P (thunk
) = 0;
151 DECL_CONSTRUCTOR_P (thunk
) = 0;
152 DECL_EXTERNAL (thunk
) = 1;
153 DECL_ARTIFICIAL (thunk
) = 1;
154 /* Even if this thunk is a member of a local class, we don't
155 need a static chain. */
156 DECL_NO_STATIC_CHAIN (thunk
) = 1;
157 /* The THUNK is not a pending inline, even if the FUNCTION is. */
158 DECL_PENDING_INLINE_P (thunk
) = 0;
159 DECL_DECLARED_INLINE_P (thunk
) = 0;
160 /* Nor has it been deferred. */
161 DECL_DEFERRED_FN (thunk
) = 0;
162 /* Nor is it a template instantiation. */
163 DECL_USE_TEMPLATE (thunk
) = 0;
164 DECL_TEMPLATE_INFO (thunk
) = NULL
;
166 /* Add it to the list of thunks associated with FUNCTION. */
167 TREE_CHAIN (thunk
) = DECL_THUNKS (function
);
168 DECL_THUNKS (function
) = thunk
;
173 /* Finish THUNK, a thunk decl. */
176 finish_thunk (tree thunk
)
179 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
180 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
182 gcc_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
));
183 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
184 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
185 function
= THUNK_TARGET (thunk
);
186 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
187 fixed_offset
, virtual_offset
);
189 /* We can end up with declarations of (logically) different
190 covariant thunks, that do identical adjustments. The two thunks
191 will be adjusting between within different hierarchies, which
192 happen to have the same layout. We must nullify one of them to
193 refer to the other. */
194 if (DECL_RESULT_THUNK_P (thunk
))
198 for (cov_probe
= DECL_THUNKS (function
);
199 cov_probe
; cov_probe
= TREE_CHAIN (cov_probe
))
200 if (DECL_NAME (cov_probe
) == name
)
202 gcc_assert (!DECL_THUNKS (thunk
));
203 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
204 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
209 DECL_NAME (thunk
) = name
;
210 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
213 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
214 offset indicated by VIRTUAL_OFFSET, if that is
215 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
216 zero for a result adjusting thunk. */
219 thunk_adjust (tree ptr
, bool this_adjusting
,
220 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
223 /* Adjust the pointer by the constant. */
224 ptr
= fold_build2_loc (input_location
,
225 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
226 size_int (fixed_offset
));
228 /* If there's a virtual offset, look up that value in the vtable and
229 adjust the pointer again. */
234 ptr
= save_expr (ptr
);
235 /* The vptr is always at offset zero in the object. */
236 vtable
= build1 (NOP_EXPR
,
237 build_pointer_type (build_pointer_type
238 (vtable_entry_type
)),
240 /* Form the vtable address. */
241 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
242 /* Find the entry with the vcall offset. */
243 vtable
= fold_build2_loc (input_location
,
244 POINTER_PLUS_EXPR
, TREE_TYPE (vtable
), vtable
,
245 fold_convert (sizetype
, 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_loc (input_location
,
250 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
251 fold_convert (sizetype
, vtable
));
255 /* Adjust the pointer by the constant. */
256 ptr
= fold_build2_loc (input_location
,
257 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
258 size_int (fixed_offset
));
263 static GTY (()) int thunk_labelno
;
265 /* Create a static alias to function. */
268 make_alias_for (tree function
, tree newid
)
270 tree alias
= build_decl (DECL_SOURCE_LOCATION (function
),
271 FUNCTION_DECL
, newid
, TREE_TYPE (function
));
272 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
273 cxx_dup_lang_specific_decl (alias
);
274 DECL_CONTEXT (alias
) = NULL
;
275 TREE_READONLY (alias
) = TREE_READONLY (function
);
276 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
277 TREE_PUBLIC (alias
) = 0;
278 DECL_INTERFACE_KNOWN (alias
) = 1;
279 DECL_NOT_REALLY_EXTERN (alias
) = 1;
280 DECL_THIS_STATIC (alias
) = 1;
281 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
282 DECL_DESTRUCTOR_P (alias
) = 0;
283 DECL_CONSTRUCTOR_P (alias
) = 0;
284 DECL_EXTERNAL (alias
) = 0;
285 DECL_ARTIFICIAL (alias
) = 1;
286 DECL_NO_STATIC_CHAIN (alias
) = 1;
287 DECL_PENDING_INLINE_P (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;
302 make_alias_for_thunk (tree function
)
307 ASM_GENERATE_INTERNAL_LABEL (buf
, "LTHUNK", thunk_labelno
);
310 alias
= make_alias_for (function
, get_identifier (buf
));
312 if (!flag_syntax_only
)
313 assemble_alias (alias
, DECL_ASSEMBLER_NAME (function
));
318 /* Emit the definition of a C++ multiple inheritance or covariant
319 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
323 use_thunk (tree thunk_fndecl
, bool emit_p
)
325 tree a
, t
, function
, alias
;
327 HOST_WIDE_INT fixed_offset
, virtual_value
;
328 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
330 /* We should have called finish_thunk to give it a name. */
331 gcc_assert (DECL_NAME (thunk_fndecl
));
333 /* We should never be using an alias, always refer to the
335 gcc_assert (!THUNK_ALIAS (thunk_fndecl
));
337 if (TREE_ASM_WRITTEN (thunk_fndecl
))
340 function
= THUNK_TARGET (thunk_fndecl
);
341 if (DECL_RESULT (thunk_fndecl
))
342 /* We already turned this thunk into an ordinary function.
343 There's no need to process this thunk again. */
346 if (DECL_THUNK_P (function
))
347 /* The target is itself a thunk, process it now. */
348 use_thunk (function
, emit_p
);
350 /* Thunks are always addressable; they only appear in vtables. */
351 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
353 /* Figure out what function is being thunked to. It's referenced in
354 this translation unit. */
355 TREE_ADDRESSABLE (function
) = 1;
356 mark_used (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 gcc_assert (virtual_value
);
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 DECL_VISIBILITY_SPECIFIED (thunk_fndecl
)
387 = DECL_VISIBILITY_SPECIFIED (function
);
388 if (DECL_ONE_ONLY (function
))
389 make_decl_one_only (thunk_fndecl
, cxx_comdat_group (thunk_fndecl
));
391 if (flag_syntax_only
)
393 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
397 push_to_top_level ();
399 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
400 && targetm
.have_named_sections
)
402 resolve_unique_section (function
, 0, flag_function_sections
);
404 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
406 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
408 /* Output the thunk into the same section as function. */
409 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
413 /* Set up cloned argument trees for the thunk. */
415 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
417 tree x
= copy_node (a
);
419 DECL_CONTEXT (x
) = thunk_fndecl
;
420 SET_DECL_RTL (x
, NULL_RTX
);
421 DECL_HAS_VALUE_EXPR_P (x
) = 0;
425 DECL_ARGUMENTS (thunk_fndecl
) = a
;
428 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
429 virtual_value
, alias
))
434 current_function_decl
= thunk_fndecl
;
435 DECL_RESULT (thunk_fndecl
)
436 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
437 RESULT_DECL
, 0, integer_type_node
);
438 fnname
= IDENTIFIER_POINTER (DECL_NAME (thunk_fndecl
));
439 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
441 fn_block
= make_node (BLOCK
);
442 BLOCK_VARS (fn_block
) = a
;
443 DECL_INITIAL (thunk_fndecl
) = fn_block
;
444 init_function_start (thunk_fndecl
);
446 assemble_start_function (thunk_fndecl
, fnname
);
448 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
449 fixed_offset
, virtual_value
, alias
);
451 assemble_end_function (thunk_fndecl
, fnname
);
452 init_insn_lengths ();
453 free_after_compilation (cfun
);
454 current_function_decl
= 0;
456 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
461 tree
*argarray
= (tree
*) alloca (list_length (a
) * sizeof (tree
));
462 /* If this is a covariant thunk, or we don't have the necessary
463 code for efficient thunks, generate a thunk function that
464 just makes a call to the real function. Unfortunately, this
465 doesn't work for varargs. */
467 if (varargs_function_p (function
))
468 error ("generic thunk code fails for method %q#D which uses %<...%>",
471 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
473 start_preparsed_function (thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
474 /* We don't bother with a body block for thunks. */
476 /* There's no need to check accessibility inside the thunk body. */
477 push_deferring_access_checks (dk_no_check
);
481 t
= thunk_adjust (t
, /*this_adjusting=*/1,
482 fixed_offset
, virtual_offset
);
484 /* Build up the call to the real function. */
486 for (i
= 1, a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
), i
++)
488 t
= build_call_a (alias
, i
, argarray
);
489 CALL_FROM_THUNK_P (t
) = 1;
490 CALL_CANNOT_INLINE_P (t
) = 1;
492 if (VOID_TYPE_P (TREE_TYPE (t
)))
493 finish_expr_stmt (t
);
498 tree cond
= NULL_TREE
;
500 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
502 /* If the return type is a pointer, we need to
503 protect against NULL. We know there will be an
504 adjustment, because that's why we're emitting a
507 cond
= cp_convert (boolean_type_node
, t
);
510 t
= thunk_adjust (t
, /*this_adjusting=*/0,
511 fixed_offset
, virtual_offset
);
513 t
= build3 (COND_EXPR
, TREE_TYPE (t
), cond
, t
,
514 cp_convert (TREE_TYPE (t
), integer_zero_node
));
516 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (t
)))
517 t
= build_cplus_new (TREE_TYPE (t
), t
);
518 finish_return_stmt (t
);
521 /* Since we want to emit the thunk, we explicitly mark its name as
523 mark_decl_referenced (thunk_fndecl
);
525 /* But we don't want debugging information about it. */
526 DECL_IGNORED_P (thunk_fndecl
) = 1;
528 /* Re-enable access control. */
529 pop_deferring_access_checks ();
531 thunk_fndecl
= finish_function (0);
532 cgraph_add_new_function (thunk_fndecl
, false);
535 pop_from_top_level ();
538 /* Code for synthesizing methods which have default semantics defined. */
540 /* Generate code for default X(X&) constructor. */
543 do_build_copy_constructor (tree fndecl
)
545 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
547 parm
= convert_from_reference (parm
);
549 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
550 && is_empty_class (current_class_type
))
551 /* Don't copy the padding byte; it might not have been allocated
552 if *this is a base subobject. */;
553 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
555 tree t
= build2 (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
556 finish_expr_stmt (t
);
560 tree fields
= TYPE_FIELDS (current_class_type
);
561 tree member_init_list
= NULL_TREE
;
562 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
564 tree binfo
, base_binfo
;
565 VEC(tree
,gc
) *vbases
;
567 /* Initialize all the base-classes with the parameter converted
568 to their type so that we get their copy constructor and not
569 another constructor that takes current_class_type. We must
570 deal with the binfo's directly as a direct base might be
571 inaccessible due to ambiguity. */
572 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
573 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
577 build_tree_list (NULL_TREE
,
578 build_base_path (PLUS_EXPR
, parm
,
583 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
584 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
586 if (BINFO_VIRTUAL_P (base_binfo
))
590 = tree_cons (base_binfo
,
591 build_tree_list (NULL_TREE
,
592 build_base_path (PLUS_EXPR
, parm
,
597 for (; fields
; fields
= TREE_CHAIN (fields
))
603 if (TREE_CODE (field
) != FIELD_DECL
)
606 expr_type
= TREE_TYPE (field
);
607 if (DECL_NAME (field
))
609 if (VFIELD_NAME_P (DECL_NAME (field
)))
612 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
613 /* Just use the field; anonymous types can't have
614 nontrivial copy ctors or assignment ops. */;
618 /* Compute the type of "init->field". If the copy-constructor
619 parameter is, for example, "const S&", and the type of
620 the field is "T", then the type will usually be "const
621 T". (There are no cv-qualified variants of reference
623 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
627 if (DECL_MUTABLE_P (field
))
628 quals
&= ~TYPE_QUAL_CONST
;
629 expr_type
= cp_build_qualified_type (expr_type
, quals
);
632 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
633 init
= build_tree_list (NULL_TREE
, init
);
635 member_init_list
= tree_cons (field
, init
, member_init_list
);
637 finish_mem_initializers (member_init_list
);
642 do_build_assign_ref (tree fndecl
)
644 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
647 compound_stmt
= begin_compound_stmt (0);
648 parm
= convert_from_reference (parm
);
650 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
651 && is_empty_class (current_class_type
))
652 /* Don't copy the padding byte; it might not have been allocated
653 if *this is a base subobject. */;
654 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
656 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
657 finish_expr_stmt (t
);
662 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
664 tree binfo
, base_binfo
;
666 /* Assign to each of the direct base classes. */
667 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
668 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
671 VEC(tree
,gc
) *parmvec
;
673 /* We must convert PARM directly to the base class
674 explicitly since the base class may be ambiguous. */
675 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
676 /* Call the base class assignment operator. */
677 parmvec
= make_tree_vector_single (converted_parm
);
679 (build_special_member_call (current_class_ref
,
680 ansi_assopname (NOP_EXPR
),
683 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
684 tf_warning_or_error
));
685 release_tree_vector (parmvec
);
688 /* Assign to each of the non-static data members. */
689 for (fields
= TYPE_FIELDS (current_class_type
);
691 fields
= TREE_CHAIN (fields
))
693 tree comp
= current_class_ref
;
699 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
702 expr_type
= TREE_TYPE (field
);
704 if (CP_TYPE_CONST_P (expr_type
))
706 error ("non-static const member %q#D, can't use default "
707 "assignment operator", field
);
710 else if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
712 error ("non-static reference member %q#D, can't use "
713 "default assignment operator", field
);
717 if (DECL_NAME (field
))
719 if (VFIELD_NAME_P (DECL_NAME (field
)))
722 else if (ANON_AGGR_TYPE_P (expr_type
)
723 && TYPE_FIELDS (expr_type
) != NULL_TREE
)
724 /* Just use the field; anonymous types can't have
725 nontrivial copy ctors or assignment ops. */;
729 comp
= build3 (COMPONENT_REF
, expr_type
, comp
, field
, NULL_TREE
);
731 /* Compute the type of init->field */
733 if (DECL_MUTABLE_P (field
))
734 quals
&= ~TYPE_QUAL_CONST
;
735 expr_type
= cp_build_qualified_type (expr_type
, quals
);
737 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
739 if (DECL_NAME (field
))
740 init
= cp_build_modify_expr (comp
, NOP_EXPR
, init
,
741 tf_warning_or_error
);
743 init
= build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
744 finish_expr_stmt (init
);
747 finish_return_stmt (current_class_ref
);
748 finish_compound_stmt (compound_stmt
);
751 /* Synthesize FNDECL, a non-static member function. */
754 synthesize_method (tree fndecl
)
756 bool nested
= (current_function_decl
!= NULL_TREE
);
757 tree context
= decl_function_context (fndecl
);
758 bool need_body
= true;
760 location_t save_input_location
= input_location
;
761 int error_count
= errorcount
;
762 int warning_count
= warningcount
;
764 /* Reset the source location, we might have been previously
765 deferred, and thus have saved where we were first needed. */
766 DECL_SOURCE_LOCATION (fndecl
)
767 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl
)));
769 /* If we've been asked to synthesize a clone, just synthesize the
770 cloned function instead. Doing so will automatically fill in the
771 body for the clone. */
772 if (DECL_CLONED_FUNCTION_P (fndecl
))
773 fndecl
= DECL_CLONED_FUNCTION (fndecl
);
775 /* We may be in the middle of deferred access check. Disable
777 push_deferring_access_checks (dk_no_deferred
);
780 push_to_top_level ();
782 push_function_context ();
784 input_location
= DECL_SOURCE_LOCATION (fndecl
);
786 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
787 stmt
= begin_function_body ();
789 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
791 do_build_assign_ref (fndecl
);
794 else if (DECL_CONSTRUCTOR_P (fndecl
))
796 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
797 if (arg_chain
!= void_list_node
)
798 do_build_copy_constructor (fndecl
);
800 finish_mem_initializers (NULL_TREE
);
803 /* If we haven't yet generated the body of the function, just
804 generate an empty compound statement. */
808 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
809 finish_compound_stmt (compound_stmt
);
812 finish_function_body (stmt
);
813 expand_or_defer_fn (finish_function (0));
815 input_location
= save_input_location
;
818 pop_from_top_level ();
820 pop_function_context ();
822 pop_deferring_access_checks ();
824 if (error_count
!= errorcount
|| warning_count
!= warningcount
)
825 inform (input_location
, "synthesized method %qD first required here ",
829 /* Use EXTRACTOR to locate the relevant function called for each base &
830 class field of TYPE. CLIENT allows additional information to be passed
831 to EXTRACTOR. Generates the union of all exceptions generated by those
832 functions. Note that we haven't updated TYPE_FIELDS and such of any
833 variants yet, so we need to look at the main one. */
836 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
839 tree raises
= empty_except_spec
;
840 tree fields
= TYPE_FIELDS (type
);
841 tree binfo
, base_binfo
;
844 for (binfo
= TYPE_BINFO (type
), i
= 0;
845 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
847 tree fn
= (*extractor
) (BINFO_TYPE (base_binfo
), client
);
850 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
852 raises
= merge_exception_specifiers (raises
, fn_raises
);
855 for (; fields
; fields
= TREE_CHAIN (fields
))
857 tree type
= TREE_TYPE (fields
);
860 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
862 while (TREE_CODE (type
) == ARRAY_TYPE
)
863 type
= TREE_TYPE (type
);
864 if (!CLASS_TYPE_P (type
))
867 fn
= (*extractor
) (type
, client
);
870 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
872 raises
= merge_exception_specifiers (raises
, fn_raises
);
878 /* Locate the dtor of TYPE. */
881 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
883 return CLASSTYPE_DESTRUCTORS (type
);
886 /* Locate the default ctor of TYPE. */
889 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
893 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
896 /* Call lookup_fnfields_1 to create the constructor declarations, if
898 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
899 return lazily_declare_fn (sfk_constructor
, type
);
901 for (fns
= CLASSTYPE_CONSTRUCTORS (type
); fns
; fns
= OVL_NEXT (fns
))
903 tree fn
= OVL_CURRENT (fns
);
904 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
906 parms
= skip_artificial_parms_for (fn
, parms
);
908 if (sufficient_parms_p (parms
))
920 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
921 points to a COPY_DATA holding the name (NULL for the ctor)
922 and desired qualifiers of the source operand. */
925 locate_copy (tree type
, void *client_
)
927 struct copy_data
*client
= (struct copy_data
*)client_
;
929 tree best
= NULL_TREE
;
930 bool excess_p
= false;
935 ix
= lookup_fnfields_1 (type
, client
->name
);
938 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
940 else if (TYPE_HAS_INIT_REF (type
))
942 /* If construction of the copy constructor was postponed, create
944 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
945 lazily_declare_fn (sfk_copy_constructor
, type
);
946 fns
= CLASSTYPE_CONSTRUCTORS (type
);
950 for (; fns
; fns
= OVL_NEXT (fns
))
952 tree fn
= OVL_CURRENT (fns
);
953 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
958 parms
= skip_artificial_parms_for (fn
, parms
);
961 src_type
= non_reference (TREE_VALUE (parms
));
963 if (src_type
== error_mark_node
)
966 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
968 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
970 quals
= cp_type_quals (src_type
);
971 if (client
->quals
& ~quals
)
973 excess
= quals
& ~client
->quals
;
974 if (!best
|| (excess_p
&& !excess
))
986 /* Implicitly declare the special function indicated by KIND, as a
987 member of TYPE. For copy constructors and assignment operators,
988 CONST_P indicates whether these functions should take a const
989 reference argument or a non-const reference. Returns the
990 FUNCTION_DECL for the implicitly declared function. */
993 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
996 tree parameter_types
= void_list_node
;
999 tree raises
= empty_except_spec
;
1000 tree rhs_parm_type
= NULL_TREE
;
1003 HOST_WIDE_INT saved_processing_template_decl
;
1005 /* Because we create declarations for implicitly declared functions
1006 lazily, we may be creating the declaration for a member of TYPE
1007 while in some completely different context. However, TYPE will
1008 never be a dependent class (because we never want to do lookups
1009 for implicitly defined functions in a dependent class).
1010 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1011 because we only create clones for constructors and destructors
1012 when not in a template. */
1013 gcc_assert (!dependent_type_p (type
));
1014 saved_processing_template_decl
= processing_template_decl
;
1015 processing_template_decl
= 0;
1017 type
= TYPE_MAIN_VARIANT (type
);
1019 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
1021 if (kind
== sfk_destructor
)
1022 /* See comment in check_special_function_return_type. */
1023 return_type
= build_pointer_type (void_type_node
);
1025 return_type
= build_pointer_type (type
);
1028 return_type
= void_type_node
;
1032 case sfk_destructor
:
1034 name
= constructor_name (type
);
1035 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
1038 case sfk_constructor
:
1039 /* Default constructor. */
1040 name
= constructor_name (type
);
1041 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
1044 case sfk_copy_constructor
:
1045 case sfk_assignment_operator
:
1047 struct copy_data data
;
1051 if (kind
== sfk_assignment_operator
)
1053 return_type
= build_reference_type (type
);
1054 name
= ansi_assopname (NOP_EXPR
);
1058 name
= constructor_name (type
);
1062 data
.quals
= TYPE_QUAL_CONST
;
1063 rhs_parm_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
1066 rhs_parm_type
= type
;
1067 rhs_parm_type
= build_reference_type (rhs_parm_type
);
1068 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
1069 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1076 /* Create the function. */
1077 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1079 fn_type
= build_exception_variant (fn_type
, raises
);
1080 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1081 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1082 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
)
1083 DECL_CONSTRUCTOR_P (fn
) = 1;
1084 else if (kind
== sfk_destructor
)
1085 DECL_DESTRUCTOR_P (fn
) = 1;
1088 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1089 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1092 /* If pointers to member functions use the least significant bit to
1093 indicate whether a function is virtual, ensure a pointer
1094 to this function will have that bit clear. */
1095 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
1096 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
1097 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
1099 /* Create the explicit arguments. */
1102 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1103 want its type to be included in the mangled function
1105 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1106 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1108 /* Add the "this" parameter. */
1109 this_parm
= build_this_parm (fn_type
, TYPE_UNQUALIFIED
);
1110 TREE_CHAIN (this_parm
) = DECL_ARGUMENTS (fn
);
1111 DECL_ARGUMENTS (fn
) = this_parm
;
1113 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
);
1114 set_linkage_according_to_type (type
, fn
);
1115 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1116 DECL_IN_AGGR_P (fn
) = 1;
1117 DECL_ARTIFICIAL (fn
) = 1;
1118 DECL_DEFAULTED_FN (fn
) = 1;
1119 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1120 DECL_DECLARED_INLINE_P (fn
) = 1;
1121 gcc_assert (!TREE_USED (fn
));
1123 /* Restore PROCESSING_TEMPLATE_DECL. */
1124 processing_template_decl
= saved_processing_template_decl
;
1129 /* Add an implicit declaration to TYPE for the kind of function
1130 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1134 lazily_declare_fn (special_function_kind sfk
, tree type
)
1139 /* Figure out whether or not the argument has a const reference
1141 if (sfk
== sfk_copy_constructor
)
1142 const_p
= TYPE_HAS_CONST_INIT_REF (type
);
1143 else if (sfk
== sfk_assignment_operator
)
1144 const_p
= TYPE_HAS_CONST_ASSIGN_REF (type
);
1146 /* In this case, CONST_P will be ignored. */
1148 /* Declare the function. */
1149 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1150 /* A destructor may be virtual. */
1151 if (sfk
== sfk_destructor
)
1152 check_for_override (fn
, type
);
1153 /* Add it to CLASSTYPE_METHOD_VEC. */
1154 add_method (type
, fn
, NULL_TREE
);
1155 /* Add it to TYPE_METHODS. */
1156 if (sfk
== sfk_destructor
1157 && DECL_VIRTUAL_P (fn
)
1158 && abi_version_at_least (2))
1159 /* The ABI requires that a virtual destructor go at the end of the
1161 TYPE_METHODS (type
) = chainon (TYPE_METHODS (type
), fn
);
1164 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1165 TYPE_METHODS list, which cause the destructor to be emitted
1166 in an incorrect location in the vtable. */
1167 if (warn_abi
&& DECL_VIRTUAL_P (fn
))
1168 warning (OPT_Wabi
, "vtable layout for class %qT may not be ABI-compliant"
1169 "and may change in a future version of GCC due to "
1170 "implicit virtual destructor",
1172 TREE_CHAIN (fn
) = TYPE_METHODS (type
);
1173 TYPE_METHODS (type
) = fn
;
1175 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1176 if (sfk
== sfk_assignment_operator
)
1177 CLASSTYPE_LAZY_ASSIGNMENT_OP (type
) = 0;
1180 /* Remember that the function has been created. */
1181 if (sfk
== sfk_constructor
)
1182 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1183 else if (sfk
== sfk_copy_constructor
)
1184 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1185 else if (sfk
== sfk_destructor
)
1186 CLASSTYPE_LAZY_DESTRUCTOR (type
) = 0;
1187 /* Create appropriate clones. */
1188 clone_function_decl (fn
, /*update_method_vec=*/true);
1194 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1195 as there are artificial parms in FN. */
1198 skip_artificial_parms_for (const_tree fn
, tree list
)
1200 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1201 list
= TREE_CHAIN (list
);
1205 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1206 list
= TREE_CHAIN (list
);
1207 if (DECL_HAS_VTT_PARM_P (fn
))
1208 list
= TREE_CHAIN (list
);
1212 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1213 artificial parms in FN. */
1216 num_artificial_parms_for (const_tree fn
)
1220 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1225 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1227 if (DECL_HAS_VTT_PARM_P (fn
))
1233 #include "gt-cp-method.h"