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 is it a template instantiation. */
161 DECL_USE_TEMPLATE (thunk
) = 0;
162 DECL_TEMPLATE_INFO (thunk
) = NULL
;
164 /* Add it to the list of thunks associated with FUNCTION. */
165 TREE_CHAIN (thunk
) = DECL_THUNKS (function
);
166 DECL_THUNKS (function
) = thunk
;
171 /* Finish THUNK, a thunk decl. */
174 finish_thunk (tree thunk
)
177 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
178 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
180 gcc_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
));
181 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
182 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
183 function
= THUNK_TARGET (thunk
);
184 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
185 fixed_offset
, virtual_offset
);
187 /* We can end up with declarations of (logically) different
188 covariant thunks, that do identical adjustments. The two thunks
189 will be adjusting between within different hierarchies, which
190 happen to have the same layout. We must nullify one of them to
191 refer to the other. */
192 if (DECL_RESULT_THUNK_P (thunk
))
196 for (cov_probe
= DECL_THUNKS (function
);
197 cov_probe
; cov_probe
= TREE_CHAIN (cov_probe
))
198 if (DECL_NAME (cov_probe
) == name
)
200 gcc_assert (!DECL_THUNKS (thunk
));
201 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
202 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
207 DECL_NAME (thunk
) = name
;
208 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
211 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
212 offset indicated by VIRTUAL_OFFSET, if that is
213 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
214 zero for a result adjusting thunk. */
217 thunk_adjust (tree ptr
, bool this_adjusting
,
218 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
221 /* Adjust the pointer by the constant. */
222 ptr
= fold_build2_loc (input_location
,
223 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
224 size_int (fixed_offset
));
226 /* If there's a virtual offset, look up that value in the vtable and
227 adjust the pointer again. */
232 ptr
= save_expr (ptr
);
233 /* The vptr is always at offset zero in the object. */
234 vtable
= build1 (NOP_EXPR
,
235 build_pointer_type (build_pointer_type
236 (vtable_entry_type
)),
238 /* Form the vtable address. */
239 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
240 /* Find the entry with the vcall offset. */
241 vtable
= fold_build2_loc (input_location
,
242 POINTER_PLUS_EXPR
, TREE_TYPE (vtable
), vtable
,
243 fold_convert (sizetype
, virtual_offset
));
244 /* Get the offset itself. */
245 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
246 /* Adjust the `this' pointer. */
247 ptr
= fold_build2_loc (input_location
,
248 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
249 fold_convert (sizetype
, vtable
));
253 /* Adjust the pointer by the constant. */
254 ptr
= fold_build2_loc (input_location
,
255 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
256 size_int (fixed_offset
));
261 static GTY (()) int thunk_labelno
;
263 /* Create a static alias to function. */
266 make_alias_for (tree function
, tree newid
)
268 tree alias
= build_decl (DECL_SOURCE_LOCATION (function
),
269 FUNCTION_DECL
, newid
, TREE_TYPE (function
));
270 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
271 cxx_dup_lang_specific_decl (alias
);
272 DECL_CONTEXT (alias
) = NULL
;
273 TREE_READONLY (alias
) = TREE_READONLY (function
);
274 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
275 TREE_PUBLIC (alias
) = 0;
276 DECL_INTERFACE_KNOWN (alias
) = 1;
277 DECL_NOT_REALLY_EXTERN (alias
) = 1;
278 DECL_THIS_STATIC (alias
) = 1;
279 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
280 DECL_DESTRUCTOR_P (alias
) = 0;
281 DECL_CONSTRUCTOR_P (alias
) = 0;
282 DECL_EXTERNAL (alias
) = 0;
283 DECL_ARTIFICIAL (alias
) = 1;
284 DECL_NO_STATIC_CHAIN (alias
) = 1;
285 DECL_PENDING_INLINE_P (alias
) = 0;
286 DECL_DECLARED_INLINE_P (alias
) = 0;
287 DECL_USE_TEMPLATE (alias
) = 0;
288 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
289 DECL_TEMPLATE_INFO (alias
) = NULL
;
290 DECL_INITIAL (alias
) = error_mark_node
;
291 TREE_ADDRESSABLE (alias
) = 1;
292 TREE_USED (alias
) = 1;
293 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
294 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
299 make_alias_for_thunk (tree function
)
304 ASM_GENERATE_INTERNAL_LABEL (buf
, "LTHUNK", thunk_labelno
);
307 alias
= make_alias_for (function
, get_identifier (buf
));
309 if (!flag_syntax_only
)
310 assemble_alias (alias
, DECL_ASSEMBLER_NAME (function
));
315 /* Emit the definition of a C++ multiple inheritance or covariant
316 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
320 use_thunk (tree thunk_fndecl
, bool emit_p
)
322 tree a
, t
, function
, alias
;
324 HOST_WIDE_INT fixed_offset
, virtual_value
;
325 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
327 /* We should have called finish_thunk to give it a name. */
328 gcc_assert (DECL_NAME (thunk_fndecl
));
330 /* We should never be using an alias, always refer to the
332 gcc_assert (!THUNK_ALIAS (thunk_fndecl
));
334 if (TREE_ASM_WRITTEN (thunk_fndecl
))
337 function
= THUNK_TARGET (thunk_fndecl
);
338 if (DECL_RESULT (thunk_fndecl
))
339 /* We already turned this thunk into an ordinary function.
340 There's no need to process this thunk again. */
343 if (DECL_THUNK_P (function
))
344 /* The target is itself a thunk, process it now. */
345 use_thunk (function
, emit_p
);
347 /* Thunks are always addressable; they only appear in vtables. */
348 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
350 /* Figure out what function is being thunked to. It's referenced in
351 this translation unit. */
352 TREE_ADDRESSABLE (function
) = 1;
353 mark_used (function
);
357 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
))
358 alias
= make_alias_for_thunk (function
);
362 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
363 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
368 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
369 virtual_value
= tree_low_cst (virtual_offset
, /*pos=*/0);
370 gcc_assert (virtual_value
);
375 /* And, if we need to emit the thunk, it's used. */
376 mark_used (thunk_fndecl
);
377 /* This thunk is actually defined. */
378 DECL_EXTERNAL (thunk_fndecl
) = 0;
379 /* The linkage of the function may have changed. FIXME in linkage
381 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
382 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
383 DECL_VISIBILITY_SPECIFIED (thunk_fndecl
)
384 = DECL_VISIBILITY_SPECIFIED (function
);
385 if (DECL_ONE_ONLY (function
))
386 make_decl_one_only (thunk_fndecl
, cxx_comdat_group (thunk_fndecl
));
388 if (flag_syntax_only
)
390 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
394 push_to_top_level ();
396 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
397 && targetm
.have_named_sections
)
399 resolve_unique_section (function
, 0, flag_function_sections
);
401 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
403 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
405 /* Output the thunk into the same section as function. */
406 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
410 /* Set up cloned argument trees for the thunk. */
412 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
414 tree x
= copy_node (a
);
416 DECL_CONTEXT (x
) = thunk_fndecl
;
417 SET_DECL_RTL (x
, NULL_RTX
);
418 DECL_HAS_VALUE_EXPR_P (x
) = 0;
422 DECL_ARGUMENTS (thunk_fndecl
) = a
;
425 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
426 virtual_value
, alias
))
431 current_function_decl
= thunk_fndecl
;
432 DECL_RESULT (thunk_fndecl
)
433 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
434 RESULT_DECL
, 0, integer_type_node
);
435 fnname
= IDENTIFIER_POINTER (DECL_NAME (thunk_fndecl
));
436 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
438 fn_block
= make_node (BLOCK
);
439 BLOCK_VARS (fn_block
) = a
;
440 DECL_INITIAL (thunk_fndecl
) = fn_block
;
441 init_function_start (thunk_fndecl
);
443 assemble_start_function (thunk_fndecl
, fnname
);
445 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
446 fixed_offset
, virtual_value
, alias
);
448 assemble_end_function (thunk_fndecl
, fnname
);
449 init_insn_lengths ();
450 free_after_compilation (cfun
);
451 current_function_decl
= 0;
453 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
458 tree
*argarray
= (tree
*) alloca (list_length (a
) * sizeof (tree
));
459 /* If this is a covariant thunk, or we don't have the necessary
460 code for efficient thunks, generate a thunk function that
461 just makes a call to the real function. Unfortunately, this
462 doesn't work for varargs. */
464 if (varargs_function_p (function
))
465 error ("generic thunk code fails for method %q#D which uses %<...%>",
468 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
470 start_preparsed_function (thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
471 /* We don't bother with a body block for thunks. */
473 /* There's no need to check accessibility inside the thunk body. */
474 push_deferring_access_checks (dk_no_check
);
478 t
= thunk_adjust (t
, /*this_adjusting=*/1,
479 fixed_offset
, virtual_offset
);
481 /* Build up the call to the real function. */
483 for (i
= 1, a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
), i
++)
485 t
= build_call_a (alias
, i
, argarray
);
486 CALL_FROM_THUNK_P (t
) = 1;
487 CALL_CANNOT_INLINE_P (t
) = 1;
489 if (VOID_TYPE_P (TREE_TYPE (t
)))
490 finish_expr_stmt (t
);
495 tree cond
= NULL_TREE
;
497 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
499 /* If the return type is a pointer, we need to
500 protect against NULL. We know there will be an
501 adjustment, because that's why we're emitting a
504 cond
= cp_convert (boolean_type_node
, t
);
507 t
= thunk_adjust (t
, /*this_adjusting=*/0,
508 fixed_offset
, virtual_offset
);
510 t
= build3 (COND_EXPR
, TREE_TYPE (t
), cond
, t
,
511 cp_convert (TREE_TYPE (t
), integer_zero_node
));
513 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (t
)))
514 t
= build_cplus_new (TREE_TYPE (t
), t
);
515 finish_return_stmt (t
);
518 /* Since we want to emit the thunk, we explicitly mark its name as
520 mark_decl_referenced (thunk_fndecl
);
522 /* But we don't want debugging information about it. */
523 DECL_IGNORED_P (thunk_fndecl
) = 1;
525 /* Re-enable access control. */
526 pop_deferring_access_checks ();
528 thunk_fndecl
= finish_function (0);
529 cgraph_add_new_function (thunk_fndecl
, false);
532 pop_from_top_level ();
535 /* Code for synthesizing methods which have default semantics defined. */
537 /* Generate code for default X(X&) constructor. */
540 do_build_copy_constructor (tree fndecl
)
542 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
544 parm
= convert_from_reference (parm
);
546 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
547 && is_empty_class (current_class_type
))
548 /* Don't copy the padding byte; it might not have been allocated
549 if *this is a base subobject. */;
550 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
552 tree t
= build2 (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
553 finish_expr_stmt (t
);
557 tree fields
= TYPE_FIELDS (current_class_type
);
558 tree member_init_list
= NULL_TREE
;
559 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
561 tree binfo
, base_binfo
;
562 VEC(tree
,gc
) *vbases
;
564 /* Initialize all the base-classes with the parameter converted
565 to their type so that we get their copy constructor and not
566 another constructor that takes current_class_type. We must
567 deal with the binfo's directly as a direct base might be
568 inaccessible due to ambiguity. */
569 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
570 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
574 build_tree_list (NULL_TREE
,
575 build_base_path (PLUS_EXPR
, parm
,
580 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
581 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
583 if (BINFO_VIRTUAL_P (base_binfo
))
587 = tree_cons (base_binfo
,
588 build_tree_list (NULL_TREE
,
589 build_base_path (PLUS_EXPR
, parm
,
594 for (; fields
; fields
= TREE_CHAIN (fields
))
600 if (TREE_CODE (field
) != FIELD_DECL
)
603 expr_type
= TREE_TYPE (field
);
604 if (DECL_NAME (field
))
606 if (VFIELD_NAME_P (DECL_NAME (field
)))
609 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
610 /* Just use the field; anonymous types can't have
611 nontrivial copy ctors or assignment ops. */;
615 /* Compute the type of "init->field". If the copy-constructor
616 parameter is, for example, "const S&", and the type of
617 the field is "T", then the type will usually be "const
618 T". (There are no cv-qualified variants of reference
620 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
624 if (DECL_MUTABLE_P (field
))
625 quals
&= ~TYPE_QUAL_CONST
;
626 expr_type
= cp_build_qualified_type (expr_type
, quals
);
629 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
630 init
= build_tree_list (NULL_TREE
, init
);
632 member_init_list
= tree_cons (field
, init
, member_init_list
);
634 finish_mem_initializers (member_init_list
);
639 do_build_assign_ref (tree fndecl
)
641 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
644 compound_stmt
= begin_compound_stmt (0);
645 parm
= convert_from_reference (parm
);
647 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
648 && is_empty_class (current_class_type
))
649 /* Don't copy the padding byte; it might not have been allocated
650 if *this is a base subobject. */;
651 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
653 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
654 finish_expr_stmt (t
);
659 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
661 tree binfo
, base_binfo
;
663 /* Assign to each of the direct base classes. */
664 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
665 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
668 VEC(tree
,gc
) *parmvec
;
670 /* We must convert PARM directly to the base class
671 explicitly since the base class may be ambiguous. */
672 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
673 /* Call the base class assignment operator. */
674 parmvec
= make_tree_vector_single (converted_parm
);
676 (build_special_member_call (current_class_ref
,
677 ansi_assopname (NOP_EXPR
),
680 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
681 tf_warning_or_error
));
682 release_tree_vector (parmvec
);
685 /* Assign to each of the non-static data members. */
686 for (fields
= TYPE_FIELDS (current_class_type
);
688 fields
= TREE_CHAIN (fields
))
690 tree comp
= current_class_ref
;
696 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
699 expr_type
= TREE_TYPE (field
);
701 if (CP_TYPE_CONST_P (expr_type
))
703 error ("non-static const member %q#D, can't use default "
704 "assignment operator", field
);
707 else if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
709 error ("non-static reference member %q#D, can't use "
710 "default assignment operator", field
);
714 if (DECL_NAME (field
))
716 if (VFIELD_NAME_P (DECL_NAME (field
)))
719 else if (ANON_AGGR_TYPE_P (expr_type
)
720 && TYPE_FIELDS (expr_type
) != NULL_TREE
)
721 /* Just use the field; anonymous types can't have
722 nontrivial copy ctors or assignment ops. */;
726 comp
= build3 (COMPONENT_REF
, expr_type
, comp
, field
, NULL_TREE
);
728 /* Compute the type of init->field */
730 if (DECL_MUTABLE_P (field
))
731 quals
&= ~TYPE_QUAL_CONST
;
732 expr_type
= cp_build_qualified_type (expr_type
, quals
);
734 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
736 if (DECL_NAME (field
))
737 init
= cp_build_modify_expr (comp
, NOP_EXPR
, init
,
738 tf_warning_or_error
);
740 init
= build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
741 finish_expr_stmt (init
);
744 finish_return_stmt (current_class_ref
);
745 finish_compound_stmt (compound_stmt
);
748 /* Synthesize FNDECL, a non-static member function. */
751 synthesize_method (tree fndecl
)
753 bool nested
= (current_function_decl
!= NULL_TREE
);
754 tree context
= decl_function_context (fndecl
);
755 bool need_body
= true;
757 location_t save_input_location
= input_location
;
758 int error_count
= errorcount
;
759 int warning_count
= warningcount
;
761 /* Reset the source location, we might have been previously
762 deferred, and thus have saved where we were first needed. */
763 DECL_SOURCE_LOCATION (fndecl
)
764 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl
)));
766 /* If we've been asked to synthesize a clone, just synthesize the
767 cloned function instead. Doing so will automatically fill in the
768 body for the clone. */
769 if (DECL_CLONED_FUNCTION_P (fndecl
))
770 fndecl
= DECL_CLONED_FUNCTION (fndecl
);
772 /* We may be in the middle of deferred access check. Disable
774 push_deferring_access_checks (dk_no_deferred
);
777 push_to_top_level ();
779 push_function_context ();
781 input_location
= DECL_SOURCE_LOCATION (fndecl
);
783 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
784 stmt
= begin_function_body ();
786 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
788 do_build_assign_ref (fndecl
);
791 else if (DECL_CONSTRUCTOR_P (fndecl
))
793 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
794 if (arg_chain
!= void_list_node
)
795 do_build_copy_constructor (fndecl
);
797 finish_mem_initializers (NULL_TREE
);
800 /* If we haven't yet generated the body of the function, just
801 generate an empty compound statement. */
805 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
806 finish_compound_stmt (compound_stmt
);
809 finish_function_body (stmt
);
810 expand_or_defer_fn (finish_function (0));
812 input_location
= save_input_location
;
815 pop_from_top_level ();
817 pop_function_context ();
819 pop_deferring_access_checks ();
821 if (error_count
!= errorcount
|| warning_count
!= warningcount
)
822 inform (input_location
, "synthesized method %qD first required here ",
826 /* Use EXTRACTOR to locate the relevant function called for each base &
827 class field of TYPE. CLIENT allows additional information to be passed
828 to EXTRACTOR. Generates the union of all exceptions generated by those
829 functions. Note that we haven't updated TYPE_FIELDS and such of any
830 variants yet, so we need to look at the main one. */
833 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
836 tree raises
= empty_except_spec
;
837 tree fields
= TYPE_FIELDS (type
);
838 tree binfo
, base_binfo
;
841 for (binfo
= TYPE_BINFO (type
), i
= 0;
842 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
844 tree fn
= (*extractor
) (BINFO_TYPE (base_binfo
), client
);
847 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
849 raises
= merge_exception_specifiers (raises
, fn_raises
);
852 for (; fields
; fields
= TREE_CHAIN (fields
))
854 tree type
= TREE_TYPE (fields
);
857 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
859 while (TREE_CODE (type
) == ARRAY_TYPE
)
860 type
= TREE_TYPE (type
);
861 if (!CLASS_TYPE_P (type
))
864 fn
= (*extractor
) (type
, client
);
867 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
869 raises
= merge_exception_specifiers (raises
, fn_raises
);
875 /* Locate the dtor of TYPE. */
878 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
880 return CLASSTYPE_DESTRUCTORS (type
);
883 /* Locate the default ctor of TYPE. */
886 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
890 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
893 /* Call lookup_fnfields_1 to create the constructor declarations, if
895 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
896 return lazily_declare_fn (sfk_constructor
, type
);
898 for (fns
= CLASSTYPE_CONSTRUCTORS (type
); fns
; fns
= OVL_NEXT (fns
))
900 tree fn
= OVL_CURRENT (fns
);
901 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
903 parms
= skip_artificial_parms_for (fn
, parms
);
905 if (sufficient_parms_p (parms
))
917 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
918 points to a COPY_DATA holding the name (NULL for the ctor)
919 and desired qualifiers of the source operand. */
922 locate_copy (tree type
, void *client_
)
924 struct copy_data
*client
= (struct copy_data
*)client_
;
926 tree best
= NULL_TREE
;
927 bool excess_p
= false;
932 ix
= lookup_fnfields_1 (type
, client
->name
);
935 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
937 else if (TYPE_HAS_INIT_REF (type
))
939 /* If construction of the copy constructor was postponed, create
941 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
942 lazily_declare_fn (sfk_copy_constructor
, type
);
943 fns
= CLASSTYPE_CONSTRUCTORS (type
);
947 for (; fns
; fns
= OVL_NEXT (fns
))
949 tree fn
= OVL_CURRENT (fns
);
950 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
955 parms
= skip_artificial_parms_for (fn
, parms
);
958 src_type
= non_reference (TREE_VALUE (parms
));
960 if (src_type
== error_mark_node
)
963 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
965 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
967 quals
= cp_type_quals (src_type
);
968 if (client
->quals
& ~quals
)
970 excess
= quals
& ~client
->quals
;
971 if (!best
|| (excess_p
&& !excess
))
983 /* Implicitly declare the special function indicated by KIND, as a
984 member of TYPE. For copy constructors and assignment operators,
985 CONST_P indicates whether these functions should take a const
986 reference argument or a non-const reference. Returns the
987 FUNCTION_DECL for the implicitly declared function. */
990 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
993 tree parameter_types
= void_list_node
;
996 tree raises
= empty_except_spec
;
997 tree rhs_parm_type
= NULL_TREE
;
1000 HOST_WIDE_INT saved_processing_template_decl
;
1002 /* Because we create declarations for implicitly declared functions
1003 lazily, we may be creating the declaration for a member of TYPE
1004 while in some completely different context. However, TYPE will
1005 never be a dependent class (because we never want to do lookups
1006 for implicitly defined functions in a dependent class).
1007 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1008 because we only create clones for constructors and destructors
1009 when not in a template. */
1010 gcc_assert (!dependent_type_p (type
));
1011 saved_processing_template_decl
= processing_template_decl
;
1012 processing_template_decl
= 0;
1014 type
= TYPE_MAIN_VARIANT (type
);
1016 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
1018 if (kind
== sfk_destructor
)
1019 /* See comment in check_special_function_return_type. */
1020 return_type
= build_pointer_type (void_type_node
);
1022 return_type
= build_pointer_type (type
);
1025 return_type
= void_type_node
;
1029 case sfk_destructor
:
1031 name
= constructor_name (type
);
1032 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
1035 case sfk_constructor
:
1036 /* Default constructor. */
1037 name
= constructor_name (type
);
1038 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
1041 case sfk_copy_constructor
:
1042 case sfk_assignment_operator
:
1044 struct copy_data data
;
1048 if (kind
== sfk_assignment_operator
)
1050 return_type
= build_reference_type (type
);
1051 name
= ansi_assopname (NOP_EXPR
);
1055 name
= constructor_name (type
);
1059 data
.quals
= TYPE_QUAL_CONST
;
1060 rhs_parm_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
1063 rhs_parm_type
= type
;
1064 rhs_parm_type
= build_reference_type (rhs_parm_type
);
1065 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
1066 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1073 /* Create the function. */
1074 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1076 fn_type
= build_exception_variant (fn_type
, raises
);
1077 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1078 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1079 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
)
1080 DECL_CONSTRUCTOR_P (fn
) = 1;
1081 else if (kind
== sfk_destructor
)
1082 DECL_DESTRUCTOR_P (fn
) = 1;
1085 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1086 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1089 /* If pointers to member functions use the least significant bit to
1090 indicate whether a function is virtual, ensure a pointer
1091 to this function will have that bit clear. */
1092 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
1093 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
1094 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
1096 /* Create the explicit arguments. */
1099 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1100 want its type to be included in the mangled function
1102 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1103 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1105 /* Add the "this" parameter. */
1106 this_parm
= build_this_parm (fn_type
, TYPE_UNQUALIFIED
);
1107 TREE_CHAIN (this_parm
) = DECL_ARGUMENTS (fn
);
1108 DECL_ARGUMENTS (fn
) = this_parm
;
1110 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
);
1111 set_linkage_according_to_type (type
, fn
);
1112 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1113 DECL_IN_AGGR_P (fn
) = 1;
1114 DECL_ARTIFICIAL (fn
) = 1;
1115 DECL_DEFAULTED_FN (fn
) = 1;
1116 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1117 DECL_DECLARED_INLINE_P (fn
) = 1;
1118 gcc_assert (!TREE_USED (fn
));
1120 /* Restore PROCESSING_TEMPLATE_DECL. */
1121 processing_template_decl
= saved_processing_template_decl
;
1126 /* Add an implicit declaration to TYPE for the kind of function
1127 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1131 lazily_declare_fn (special_function_kind sfk
, tree type
)
1136 /* Figure out whether or not the argument has a const reference
1138 if (sfk
== sfk_copy_constructor
)
1139 const_p
= TYPE_HAS_CONST_INIT_REF (type
);
1140 else if (sfk
== sfk_assignment_operator
)
1141 const_p
= TYPE_HAS_CONST_ASSIGN_REF (type
);
1143 /* In this case, CONST_P will be ignored. */
1145 /* Declare the function. */
1146 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1147 /* A destructor may be virtual. */
1148 if (sfk
== sfk_destructor
)
1149 check_for_override (fn
, type
);
1150 /* Add it to CLASSTYPE_METHOD_VEC. */
1151 add_method (type
, fn
, NULL_TREE
);
1152 /* Add it to TYPE_METHODS. */
1153 if (sfk
== sfk_destructor
1154 && DECL_VIRTUAL_P (fn
)
1155 && abi_version_at_least (2))
1156 /* The ABI requires that a virtual destructor go at the end of the
1158 TYPE_METHODS (type
) = chainon (TYPE_METHODS (type
), fn
);
1161 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1162 TYPE_METHODS list, which cause the destructor to be emitted
1163 in an incorrect location in the vtable. */
1164 if (warn_abi
&& sfk
== sfk_destructor
&& DECL_VIRTUAL_P (fn
))
1165 warning (OPT_Wabi
, "vtable layout for class %qT may not be ABI-compliant"
1166 "and may change in a future version of GCC due to "
1167 "implicit virtual destructor",
1169 TREE_CHAIN (fn
) = TYPE_METHODS (type
);
1170 TYPE_METHODS (type
) = fn
;
1172 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1173 if (sfk
== sfk_assignment_operator
)
1174 CLASSTYPE_LAZY_ASSIGNMENT_OP (type
) = 0;
1177 /* Remember that the function has been created. */
1178 if (sfk
== sfk_constructor
)
1179 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1180 else if (sfk
== sfk_copy_constructor
)
1181 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1182 else if (sfk
== sfk_destructor
)
1183 CLASSTYPE_LAZY_DESTRUCTOR (type
) = 0;
1184 /* Create appropriate clones. */
1185 clone_function_decl (fn
, /*update_method_vec=*/true);
1191 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1192 as there are artificial parms in FN. */
1195 skip_artificial_parms_for (const_tree fn
, tree list
)
1197 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1198 list
= TREE_CHAIN (list
);
1202 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1203 list
= TREE_CHAIN (list
);
1204 if (DECL_HAS_VTT_PARM_P (fn
))
1205 list
= TREE_CHAIN (list
);
1209 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1210 artificial parms in FN. */
1213 num_artificial_parms_for (const_tree fn
)
1217 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1222 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1224 if (DECL_HAS_VTT_PARM_P (fn
))
1230 #include "gt-cp-method.h"