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 (FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
130 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
131 cxx_dup_lang_specific_decl (thunk
);
132 DECL_THUNKS (thunk
) = NULL_TREE
;
134 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
135 TREE_READONLY (thunk
) = TREE_READONLY (function
);
136 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
137 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
138 SET_DECL_THUNK_P (thunk
, this_adjusting
);
139 THUNK_TARGET (thunk
) = function
;
140 THUNK_FIXED_OFFSET (thunk
) = d
;
141 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
142 THUNK_ALIAS (thunk
) = NULL_TREE
;
144 /* The thunk itself is not a constructor or destructor, even if
145 the thing it is thunking to is. */
146 DECL_INTERFACE_KNOWN (thunk
) = 1;
147 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
148 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
149 DECL_DESTRUCTOR_P (thunk
) = 0;
150 DECL_CONSTRUCTOR_P (thunk
) = 0;
151 DECL_EXTERNAL (thunk
) = 1;
152 DECL_ARTIFICIAL (thunk
) = 1;
153 /* Even if this thunk is a member of a local class, we don't
154 need a static chain. */
155 DECL_NO_STATIC_CHAIN (thunk
) = 1;
156 /* The THUNK is not a pending inline, even if the FUNCTION is. */
157 DECL_PENDING_INLINE_P (thunk
) = 0;
158 DECL_DECLARED_INLINE_P (thunk
) = 0;
159 /* Nor has it been deferred. */
160 DECL_DEFERRED_FN (thunk
) = 0;
161 /* Nor is it a template instantiation. */
162 DECL_USE_TEMPLATE (thunk
) = 0;
163 DECL_TEMPLATE_INFO (thunk
) = NULL
;
165 /* Add it to the list of thunks associated with FUNCTION. */
166 TREE_CHAIN (thunk
) = DECL_THUNKS (function
);
167 DECL_THUNKS (function
) = thunk
;
172 /* Finish THUNK, a thunk decl. */
175 finish_thunk (tree thunk
)
178 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
179 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
181 gcc_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
));
182 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
183 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
184 function
= THUNK_TARGET (thunk
);
185 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
186 fixed_offset
, virtual_offset
);
188 /* We can end up with declarations of (logically) different
189 covariant thunks, that do identical adjustments. The two thunks
190 will be adjusting between within different hierarchies, which
191 happen to have the same layout. We must nullify one of them to
192 refer to the other. */
193 if (DECL_RESULT_THUNK_P (thunk
))
197 for (cov_probe
= DECL_THUNKS (function
);
198 cov_probe
; cov_probe
= TREE_CHAIN (cov_probe
))
199 if (DECL_NAME (cov_probe
) == name
)
201 gcc_assert (!DECL_THUNKS (thunk
));
202 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
203 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
208 DECL_NAME (thunk
) = name
;
209 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
212 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
213 offset indicated by VIRTUAL_OFFSET, if that is
214 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
215 zero for a result adjusting thunk. */
218 thunk_adjust (tree ptr
, bool this_adjusting
,
219 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
222 /* Adjust the pointer by the constant. */
223 ptr
= fold_build2 (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 (POINTER_PLUS_EXPR
, TREE_TYPE (vtable
), vtable
,
242 fold_convert (sizetype
, virtual_offset
));
243 /* Get the offset itself. */
244 vtable
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (vtable
)), vtable
);
245 /* Adjust the `this' pointer. */
246 ptr
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
247 fold_convert (sizetype
, vtable
));
251 /* Adjust the pointer by the constant. */
252 ptr
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
253 size_int (fixed_offset
));
258 static GTY (()) int thunk_labelno
;
260 /* Create a static alias to function. */
263 make_alias_for (tree function
, tree newid
)
265 tree alias
= build_decl (FUNCTION_DECL
, newid
, TREE_TYPE (function
));
266 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (function
);
267 cxx_dup_lang_specific_decl (alias
);
268 DECL_CONTEXT (alias
) = NULL
;
269 TREE_READONLY (alias
) = TREE_READONLY (function
);
270 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (function
);
271 TREE_PUBLIC (alias
) = 0;
272 DECL_INTERFACE_KNOWN (alias
) = 1;
273 DECL_NOT_REALLY_EXTERN (alias
) = 1;
274 DECL_THIS_STATIC (alias
) = 1;
275 DECL_SAVED_FUNCTION_DATA (alias
) = NULL
;
276 DECL_DESTRUCTOR_P (alias
) = 0;
277 DECL_CONSTRUCTOR_P (alias
) = 0;
278 DECL_CLONED_FUNCTION (alias
) = NULL_TREE
;
279 DECL_EXTERNAL (alias
) = 0;
280 DECL_ARTIFICIAL (alias
) = 1;
281 DECL_NO_STATIC_CHAIN (alias
) = 1;
282 DECL_PENDING_INLINE_P (alias
) = 0;
283 DECL_DECLARED_INLINE_P (alias
) = 0;
284 DECL_DEFERRED_FN (alias
) = 0;
285 DECL_USE_TEMPLATE (alias
) = 0;
286 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
287 DECL_TEMPLATE_INFO (alias
) = NULL
;
288 DECL_INITIAL (alias
) = error_mark_node
;
289 TREE_ADDRESSABLE (alias
) = 1;
290 TREE_USED (alias
) = 1;
291 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
292 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
297 make_alias_for_thunk (tree function
)
302 ASM_GENERATE_INTERNAL_LABEL (buf
, "LTHUNK", thunk_labelno
);
305 alias
= make_alias_for (function
, get_identifier (buf
));
307 if (!flag_syntax_only
)
308 assemble_alias (alias
, DECL_ASSEMBLER_NAME (function
));
313 /* Emit the definition of a C++ multiple inheritance or covariant
314 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
318 use_thunk (tree thunk_fndecl
, bool emit_p
)
320 tree a
, t
, function
, alias
;
322 HOST_WIDE_INT fixed_offset
, virtual_value
;
323 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
325 /* We should have called finish_thunk to give it a name. */
326 gcc_assert (DECL_NAME (thunk_fndecl
));
328 /* We should never be using an alias, always refer to the
330 gcc_assert (!THUNK_ALIAS (thunk_fndecl
));
332 if (TREE_ASM_WRITTEN (thunk_fndecl
))
335 function
= THUNK_TARGET (thunk_fndecl
);
336 if (DECL_RESULT (thunk_fndecl
))
337 /* We already turned this thunk into an ordinary function.
338 There's no need to process this thunk again. */
341 if (DECL_THUNK_P (function
))
342 /* The target is itself a thunk, process it now. */
343 use_thunk (function
, emit_p
);
345 /* Thunks are always addressable; they only appear in vtables. */
346 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
348 /* Figure out what function is being thunked to. It's referenced in
349 this translation unit. */
350 TREE_ADDRESSABLE (function
) = 1;
351 mark_used (function
);
355 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
))
356 alias
= make_alias_for_thunk (function
);
360 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
361 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
366 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
367 virtual_value
= tree_low_cst (virtual_offset
, /*pos=*/0);
368 gcc_assert (virtual_value
);
373 /* And, if we need to emit the thunk, it's used. */
374 mark_used (thunk_fndecl
);
375 /* This thunk is actually defined. */
376 DECL_EXTERNAL (thunk_fndecl
) = 0;
377 /* The linkage of the function may have changed. FIXME in linkage
379 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
380 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
381 DECL_VISIBILITY_SPECIFIED (thunk_fndecl
)
382 = DECL_VISIBILITY_SPECIFIED (function
);
383 if (DECL_ONE_ONLY (function
))
384 make_decl_one_only (thunk_fndecl
);
386 if (flag_syntax_only
)
388 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
392 push_to_top_level ();
394 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
395 && targetm
.have_named_sections
)
397 resolve_unique_section (function
, 0, flag_function_sections
);
399 if (DECL_SECTION_NAME (function
) != NULL
&& DECL_ONE_ONLY (function
))
401 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
403 /* Output the thunk into the same section as function. */
404 DECL_SECTION_NAME (thunk_fndecl
) = DECL_SECTION_NAME (function
);
408 /* Set up cloned argument trees for the thunk. */
410 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
412 tree x
= copy_node (a
);
414 DECL_CONTEXT (x
) = thunk_fndecl
;
415 SET_DECL_RTL (x
, NULL_RTX
);
416 DECL_HAS_VALUE_EXPR_P (x
) = 0;
420 DECL_ARGUMENTS (thunk_fndecl
) = a
;
423 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
424 virtual_value
, alias
))
429 current_function_decl
= thunk_fndecl
;
430 DECL_RESULT (thunk_fndecl
)
431 = build_decl (RESULT_DECL
, 0, integer_type_node
);
432 fnname
= IDENTIFIER_POINTER (DECL_NAME (thunk_fndecl
));
433 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
435 fn_block
= make_node (BLOCK
);
436 BLOCK_VARS (fn_block
) = a
;
437 DECL_INITIAL (thunk_fndecl
) = fn_block
;
438 init_function_start (thunk_fndecl
);
440 assemble_start_function (thunk_fndecl
, fnname
);
442 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
443 fixed_offset
, virtual_value
, alias
);
445 assemble_end_function (thunk_fndecl
, fnname
);
446 init_insn_lengths ();
447 current_function_decl
= 0;
449 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
454 tree
*argarray
= (tree
*) alloca (list_length (a
) * sizeof (tree
));
455 /* If this is a covariant thunk, or we don't have the necessary
456 code for efficient thunks, generate a thunk function that
457 just makes a call to the real function. Unfortunately, this
458 doesn't work for varargs. */
460 if (varargs_function_p (function
))
461 error ("generic thunk code fails for method %q#D which uses %<...%>",
464 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
466 start_preparsed_function (thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
467 /* We don't bother with a body block for thunks. */
469 /* There's no need to check accessibility inside the thunk body. */
470 push_deferring_access_checks (dk_no_check
);
474 t
= thunk_adjust (t
, /*this_adjusting=*/1,
475 fixed_offset
, virtual_offset
);
477 /* Build up the call to the real function. */
479 for (i
= 1, a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
), i
++)
481 t
= build_call_a (alias
, i
, argarray
);
482 CALL_FROM_THUNK_P (t
) = 1;
483 CALL_CANNOT_INLINE_P (t
) = 1;
485 if (VOID_TYPE_P (TREE_TYPE (t
)))
486 finish_expr_stmt (t
);
491 tree cond
= NULL_TREE
;
493 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
495 /* If the return type is a pointer, we need to
496 protect against NULL. We know there will be an
497 adjustment, because that's why we're emitting a
500 cond
= cp_convert (boolean_type_node
, t
);
503 t
= thunk_adjust (t
, /*this_adjusting=*/0,
504 fixed_offset
, virtual_offset
);
506 t
= build3 (COND_EXPR
, TREE_TYPE (t
), cond
, t
,
507 cp_convert (TREE_TYPE (t
), integer_zero_node
));
509 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (t
)))
510 t
= build_cplus_new (TREE_TYPE (t
), t
);
511 finish_return_stmt (t
);
514 /* Since we want to emit the thunk, we explicitly mark its name as
516 mark_decl_referenced (thunk_fndecl
);
518 /* But we don't want debugging information about it. */
519 DECL_IGNORED_P (thunk_fndecl
) = 1;
521 /* Re-enable access control. */
522 pop_deferring_access_checks ();
524 thunk_fndecl
= finish_function (0);
525 cgraph_add_new_function (thunk_fndecl
, false);
528 pop_from_top_level ();
531 /* Code for synthesizing methods which have default semantics defined. */
533 /* Generate code for default X(X&) constructor. */
536 do_build_copy_constructor (tree fndecl
)
538 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
540 parm
= convert_from_reference (parm
);
542 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
543 && is_empty_class (current_class_type
))
544 /* Don't copy the padding byte; it might not have been allocated
545 if *this is a base subobject. */;
546 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
548 tree t
= build2 (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
549 finish_expr_stmt (t
);
553 tree fields
= TYPE_FIELDS (current_class_type
);
554 tree member_init_list
= NULL_TREE
;
555 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
557 tree binfo
, base_binfo
;
558 VEC(tree
,gc
) *vbases
;
560 /* Initialize all the base-classes with the parameter converted
561 to their type so that we get their copy constructor and not
562 another constructor that takes current_class_type. We must
563 deal with the binfo's directly as a direct base might be
564 inaccessible due to ambiguity. */
565 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
566 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
570 build_tree_list (NULL_TREE
,
571 build_base_path (PLUS_EXPR
, parm
,
576 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
577 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
579 if (BINFO_VIRTUAL_P (base_binfo
))
583 = tree_cons (base_binfo
,
584 build_tree_list (NULL_TREE
,
585 build_base_path (PLUS_EXPR
, parm
,
590 for (; fields
; fields
= TREE_CHAIN (fields
))
596 if (TREE_CODE (field
) != FIELD_DECL
)
599 expr_type
= TREE_TYPE (field
);
600 if (DECL_NAME (field
))
602 if (VFIELD_NAME_P (DECL_NAME (field
)))
605 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
606 /* Just use the field; anonymous types can't have
607 nontrivial copy ctors or assignment ops. */;
611 /* Compute the type of "init->field". If the copy-constructor
612 parameter is, for example, "const S&", and the type of
613 the field is "T", then the type will usually be "const
614 T". (There are no cv-qualified variants of reference
616 if (TREE_CODE (expr_type
) != REFERENCE_TYPE
)
620 if (DECL_MUTABLE_P (field
))
621 quals
&= ~TYPE_QUAL_CONST
;
622 expr_type
= cp_build_qualified_type (expr_type
, quals
);
625 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
626 init
= build_tree_list (NULL_TREE
, init
);
628 member_init_list
= tree_cons (field
, init
, member_init_list
);
630 finish_mem_initializers (member_init_list
);
635 do_build_assign_ref (tree fndecl
)
637 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
640 compound_stmt
= begin_compound_stmt (0);
641 parm
= convert_from_reference (parm
);
643 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
644 && is_empty_class (current_class_type
))
645 /* Don't copy the padding byte; it might not have been allocated
646 if *this is a base subobject. */;
647 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
649 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
650 finish_expr_stmt (t
);
655 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
657 tree binfo
, base_binfo
;
659 /* Assign to each of the direct base classes. */
660 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
661 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
664 VEC(tree
,gc
) *parmvec
;
666 /* We must convert PARM directly to the base class
667 explicitly since the base class may be ambiguous. */
668 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1);
669 /* Call the base class assignment operator. */
670 parmvec
= make_tree_vector_single (converted_parm
);
672 (build_special_member_call (current_class_ref
,
673 ansi_assopname (NOP_EXPR
),
676 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
,
677 tf_warning_or_error
));
678 release_tree_vector (parmvec
);
681 /* Assign to each of the non-static data members. */
682 for (fields
= TYPE_FIELDS (current_class_type
);
684 fields
= TREE_CHAIN (fields
))
686 tree comp
= current_class_ref
;
692 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
695 expr_type
= TREE_TYPE (field
);
697 if (CP_TYPE_CONST_P (expr_type
))
699 error ("non-static const member %q#D, can't use default "
700 "assignment operator", field
);
703 else if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
705 error ("non-static reference member %q#D, can't use "
706 "default assignment operator", field
);
710 if (DECL_NAME (field
))
712 if (VFIELD_NAME_P (DECL_NAME (field
)))
715 else if (ANON_AGGR_TYPE_P (expr_type
)
716 && TYPE_FIELDS (expr_type
) != NULL_TREE
)
717 /* Just use the field; anonymous types can't have
718 nontrivial copy ctors or assignment ops. */;
722 comp
= build3 (COMPONENT_REF
, expr_type
, comp
, field
, NULL_TREE
);
724 /* Compute the type of init->field */
726 if (DECL_MUTABLE_P (field
))
727 quals
&= ~TYPE_QUAL_CONST
;
728 expr_type
= cp_build_qualified_type (expr_type
, quals
);
730 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
732 if (DECL_NAME (field
))
733 init
= cp_build_modify_expr (comp
, NOP_EXPR
, init
,
734 tf_warning_or_error
);
736 init
= build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
737 finish_expr_stmt (init
);
740 finish_return_stmt (current_class_ref
);
741 finish_compound_stmt (compound_stmt
);
744 /* Synthesize FNDECL, a non-static member function. */
747 synthesize_method (tree fndecl
)
749 bool nested
= (current_function_decl
!= NULL_TREE
);
750 tree context
= decl_function_context (fndecl
);
751 bool need_body
= true;
753 location_t save_input_location
= input_location
;
754 int error_count
= errorcount
;
755 int warning_count
= warningcount
;
757 /* Reset the source location, we might have been previously
758 deferred, and thus have saved where we were first needed. */
759 DECL_SOURCE_LOCATION (fndecl
)
760 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl
)));
762 /* If we've been asked to synthesize a clone, just synthesize the
763 cloned function instead. Doing so will automatically fill in the
764 body for the clone. */
765 if (DECL_CLONED_FUNCTION_P (fndecl
))
766 fndecl
= DECL_CLONED_FUNCTION (fndecl
);
768 /* We may be in the middle of deferred access check. Disable
770 push_deferring_access_checks (dk_no_deferred
);
773 push_to_top_level ();
775 push_function_context ();
777 input_location
= DECL_SOURCE_LOCATION (fndecl
);
779 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
780 stmt
= begin_function_body ();
782 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
784 do_build_assign_ref (fndecl
);
787 else if (DECL_CONSTRUCTOR_P (fndecl
))
789 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
790 if (arg_chain
!= void_list_node
)
791 do_build_copy_constructor (fndecl
);
793 finish_mem_initializers (NULL_TREE
);
796 /* If we haven't yet generated the body of the function, just
797 generate an empty compound statement. */
801 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
802 finish_compound_stmt (compound_stmt
);
805 finish_function_body (stmt
);
806 expand_or_defer_fn (finish_function (0));
808 input_location
= save_input_location
;
811 pop_from_top_level ();
813 pop_function_context ();
815 pop_deferring_access_checks ();
817 if (error_count
!= errorcount
|| warning_count
!= warningcount
)
818 inform (input_location
, "synthesized method %qD first required here ",
822 /* Use EXTRACTOR to locate the relevant function called for each base &
823 class field of TYPE. CLIENT allows additional information to be passed
824 to EXTRACTOR. Generates the union of all exceptions generated by those
825 functions. Note that we haven't updated TYPE_FIELDS and such of any
826 variants yet, so we need to look at the main one. */
829 synthesize_exception_spec (tree type
, tree (*extractor
) (tree
, void*),
832 tree raises
= empty_except_spec
;
833 tree fields
= TYPE_FIELDS (type
);
834 tree binfo
, base_binfo
;
837 for (binfo
= TYPE_BINFO (type
), i
= 0;
838 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
840 tree fn
= (*extractor
) (BINFO_TYPE (base_binfo
), client
);
843 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
845 raises
= merge_exception_specifiers (raises
, fn_raises
);
848 for (; fields
; fields
= TREE_CHAIN (fields
))
850 tree type
= TREE_TYPE (fields
);
853 if (TREE_CODE (fields
) != FIELD_DECL
|| DECL_ARTIFICIAL (fields
))
855 while (TREE_CODE (type
) == ARRAY_TYPE
)
856 type
= TREE_TYPE (type
);
857 if (!CLASS_TYPE_P (type
))
860 fn
= (*extractor
) (type
, client
);
863 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
865 raises
= merge_exception_specifiers (raises
, fn_raises
);
871 /* Locate the dtor of TYPE. */
874 locate_dtor (tree type
, void *client ATTRIBUTE_UNUSED
)
876 return CLASSTYPE_DESTRUCTORS (type
);
879 /* Locate the default ctor of TYPE. */
882 locate_ctor (tree type
, void *client ATTRIBUTE_UNUSED
)
886 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
889 /* Call lookup_fnfields_1 to create the constructor declarations, if
891 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
892 return lazily_declare_fn (sfk_constructor
, type
);
894 for (fns
= CLASSTYPE_CONSTRUCTORS (type
); 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_
;
922 tree best
= NULL_TREE
;
923 bool excess_p
= false;
928 ix
= lookup_fnfields_1 (type
, client
->name
);
931 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
933 else if (TYPE_HAS_INIT_REF (type
))
935 /* If construction of the copy constructor was postponed, create
937 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
938 lazily_declare_fn (sfk_copy_constructor
, type
);
939 fns
= CLASSTYPE_CONSTRUCTORS (type
);
943 for (; fns
; fns
= OVL_NEXT (fns
))
945 tree fn
= OVL_CURRENT (fns
);
946 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
951 parms
= skip_artificial_parms_for (fn
, parms
);
954 src_type
= non_reference (TREE_VALUE (parms
));
956 if (src_type
== error_mark_node
)
959 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
961 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
963 quals
= cp_type_quals (src_type
);
964 if (client
->quals
& ~quals
)
966 excess
= quals
& ~client
->quals
;
967 if (!best
|| (excess_p
&& !excess
))
979 /* Implicitly declare the special function indicated by KIND, as a
980 member of TYPE. For copy constructors and assignment operators,
981 CONST_P indicates whether these functions should take a const
982 reference argument or a non-const reference. Returns the
983 FUNCTION_DECL for the implicitly declared function. */
986 implicitly_declare_fn (special_function_kind kind
, tree type
, bool const_p
)
989 tree parameter_types
= void_list_node
;
992 tree raises
= empty_except_spec
;
993 tree rhs_parm_type
= NULL_TREE
;
996 HOST_WIDE_INT saved_processing_template_decl
;
998 /* Because we create declarations for implicitly declared functions
999 lazily, we may be creating the declaration for a member of TYPE
1000 while in some completely different context. However, TYPE will
1001 never be a dependent class (because we never want to do lookups
1002 for implicitly defined functions in a dependent class).
1003 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1004 because we only create clones for constructors and destructors
1005 when not in a template. */
1006 gcc_assert (!dependent_type_p (type
));
1007 saved_processing_template_decl
= processing_template_decl
;
1008 processing_template_decl
= 0;
1010 type
= TYPE_MAIN_VARIANT (type
);
1012 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (type
))
1014 if (kind
== sfk_destructor
)
1015 /* See comment in check_special_function_return_type. */
1016 return_type
= build_pointer_type (void_type_node
);
1018 return_type
= build_pointer_type (type
);
1021 return_type
= void_type_node
;
1025 case sfk_destructor
:
1027 name
= constructor_name (type
);
1028 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
1031 case sfk_constructor
:
1032 /* Default constructor. */
1033 name
= constructor_name (type
);
1034 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
1037 case sfk_copy_constructor
:
1038 case sfk_assignment_operator
:
1040 struct copy_data data
;
1044 if (kind
== sfk_assignment_operator
)
1046 return_type
= build_reference_type (type
);
1047 name
= ansi_assopname (NOP_EXPR
);
1051 name
= constructor_name (type
);
1055 data
.quals
= TYPE_QUAL_CONST
;
1056 rhs_parm_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
1059 rhs_parm_type
= type
;
1060 rhs_parm_type
= build_reference_type (rhs_parm_type
);
1061 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
1062 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1069 /* Create the function. */
1070 fn_type
= build_method_type_directly (type
, return_type
, parameter_types
);
1072 fn_type
= build_exception_variant (fn_type
, raises
);
1073 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
1074 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
1075 if (kind
== sfk_constructor
|| kind
== sfk_copy_constructor
)
1076 DECL_CONSTRUCTOR_P (fn
) = 1;
1077 else if (kind
== sfk_destructor
)
1078 DECL_DESTRUCTOR_P (fn
) = 1;
1081 DECL_ASSIGNMENT_OPERATOR_P (fn
) = 1;
1082 SET_OVERLOADED_OPERATOR_CODE (fn
, NOP_EXPR
);
1085 /* If pointers to member functions use the least significant bit to
1086 indicate whether a function is virtual, ensure a pointer
1087 to this function will have that bit clear. */
1088 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
1089 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
1090 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
1092 /* Create the explicit arguments. */
1095 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1096 want its type to be included in the mangled function
1098 DECL_ARGUMENTS (fn
) = cp_build_parm_decl (NULL_TREE
, rhs_parm_type
);
1099 TREE_READONLY (DECL_ARGUMENTS (fn
)) = 1;
1101 /* Add the "this" parameter. */
1102 this_parm
= build_this_parm (fn_type
, TYPE_UNQUALIFIED
);
1103 TREE_CHAIN (this_parm
) = DECL_ARGUMENTS (fn
);
1104 DECL_ARGUMENTS (fn
) = this_parm
;
1106 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
);
1107 set_linkage_according_to_type (type
, fn
);
1108 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
1109 DECL_IN_AGGR_P (fn
) = 1;
1110 DECL_ARTIFICIAL (fn
) = 1;
1111 DECL_DEFAULTED_FN (fn
) = 1;
1112 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1113 DECL_DECLARED_INLINE_P (fn
) = 1;
1114 gcc_assert (!TREE_USED (fn
));
1116 /* Restore PROCESSING_TEMPLATE_DECL. */
1117 processing_template_decl
= saved_processing_template_decl
;
1122 /* Add an implicit declaration to TYPE for the kind of function
1123 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1127 lazily_declare_fn (special_function_kind sfk
, tree type
)
1132 /* Figure out whether or not the argument has a const reference
1134 if (sfk
== sfk_copy_constructor
)
1135 const_p
= TYPE_HAS_CONST_INIT_REF (type
);
1136 else if (sfk
== sfk_assignment_operator
)
1137 const_p
= TYPE_HAS_CONST_ASSIGN_REF (type
);
1139 /* In this case, CONST_P will be ignored. */
1141 /* Declare the function. */
1142 fn
= implicitly_declare_fn (sfk
, type
, const_p
);
1143 /* A destructor may be virtual. */
1144 if (sfk
== sfk_destructor
)
1145 check_for_override (fn
, type
);
1146 /* Add it to CLASSTYPE_METHOD_VEC. */
1147 add_method (type
, fn
, NULL_TREE
);
1148 /* Add it to TYPE_METHODS. */
1149 if (sfk
== sfk_destructor
1150 && DECL_VIRTUAL_P (fn
)
1151 && abi_version_at_least (2))
1152 /* The ABI requires that a virtual destructor go at the end of the
1154 TYPE_METHODS (type
) = chainon (TYPE_METHODS (type
), fn
);
1157 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1158 TYPE_METHODS list, which cause the destructor to be emitted
1159 in an incorrect location in the vtable. */
1160 if (warn_abi
&& DECL_VIRTUAL_P (fn
))
1161 warning (OPT_Wabi
, "vtable layout for class %qT may not be ABI-compliant"
1162 "and may change in a future version of GCC due to "
1163 "implicit virtual destructor",
1165 TREE_CHAIN (fn
) = TYPE_METHODS (type
);
1166 TYPE_METHODS (type
) = fn
;
1168 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
1169 if (sfk
== sfk_assignment_operator
)
1170 CLASSTYPE_LAZY_ASSIGNMENT_OP (type
) = 0;
1173 /* Remember that the function has been created. */
1174 if (sfk
== sfk_constructor
)
1175 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
1176 else if (sfk
== sfk_copy_constructor
)
1177 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
1178 else if (sfk
== sfk_destructor
)
1179 CLASSTYPE_LAZY_DESTRUCTOR (type
) = 0;
1180 /* Create appropriate clones. */
1181 clone_function_decl (fn
, /*update_method_vec=*/true);
1187 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1188 as there are artificial parms in FN. */
1191 skip_artificial_parms_for (const_tree fn
, tree list
)
1193 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1194 list
= TREE_CHAIN (list
);
1198 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1199 list
= TREE_CHAIN (list
);
1200 if (DECL_HAS_VTT_PARM_P (fn
))
1201 list
= TREE_CHAIN (list
);
1205 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1206 artificial parms in FN. */
1209 num_artificial_parms_for (const_tree fn
)
1213 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1218 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1220 if (DECL_HAS_VTT_PARM_P (fn
))
1226 #include "gt-cp-method.h"