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 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
40 /* Various flags to control the mangling process. */
46 /* The thing we are presently mangling is part of a template type,
47 rather than a fully instantiated type. Therefore, we may see
48 complex expressions where we would normally expect to see a
49 simple integer constant. */
50 mf_maybe_uninstantiated = 1,
51 /* When mangling a numeric value, use the form `_XX_' (instead of
52 just `XX') if the value has more than one digit. */
53 mf_use_underscores_around_value = 2
56 typedef enum mangling_flags mangling_flags;
58 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
59 static void do_build_assign_ref (tree);
60 static void do_build_copy_constructor (tree);
61 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
62 static tree locate_dtor (tree, void *);
63 static tree locate_ctor (tree, void *);
64 static tree locate_copy (tree, void *);
66 static tree make_alias_for_thunk (tree);
69 /* Called once to initialize method.c. */
78 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL. */
81 set_mangled_name_for_decl (tree decl)
83 if (processing_template_decl)
84 /* There's no need to mangle the name of a template function. */
91 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
92 indicates whether it is a this or result adjusting thunk.
93 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
94 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
95 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
96 adjusting thunks, we scale it to a byte offset. For covariant
97 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
98 the returned thunk with finish_thunk. */
101 make_thunk (tree function, bool this_adjusting,
102 tree fixed_offset, tree virtual_offset)
107 my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 20021025);
108 /* We can have this thunks to covariant thunks, but not vice versa. */
109 my_friendly_assert (!DECL_THIS_THUNK_P (function), 20021127);
111 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
112 if (this_adjusting && virtual_offset)
114 = size_binop (MULT_EXPR,
117 TYPE_SIZE_UNIT (vtable_entry_type)));
119 d = tree_low_cst (fixed_offset, 0);
121 /* See if we already have the thunk in question. For this_adjusting
122 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
124 for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
125 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
126 && THUNK_FIXED_OFFSET (thunk) == d
128 ? (!THUNK_VIRTUAL_OFFSET (thunk) == !virtual_offset
130 || tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
132 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset))
135 /* All thunks must be created before FUNCTION is actually emitted;
136 the ABI requires that all thunks be emitted together with the
137 function to which they transfer control. */
138 my_friendly_assert (!TREE_ASM_WRITTEN (function), 20021025);
140 thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
141 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
142 cxx_dup_lang_specific_decl (thunk);
143 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
144 TREE_READONLY (thunk) = TREE_READONLY (function);
145 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
146 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
148 comdat_linkage (thunk);
149 SET_DECL_THUNK_P (thunk, this_adjusting);
150 THUNK_TARGET (thunk) = function;
151 THUNK_FIXED_OFFSET (thunk) = d;
152 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
154 /* The thunk itself is not a constructor or destructor, even if
155 the thing it is thunking to is. */
156 DECL_INTERFACE_KNOWN (thunk) = 1;
157 DECL_NOT_REALLY_EXTERN (thunk) = 1;
158 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
159 DECL_DESTRUCTOR_P (thunk) = 0;
160 DECL_CONSTRUCTOR_P (thunk) = 0;
161 /* And neither is it a clone. */
162 DECL_CLONED_FUNCTION (thunk) = NULL_TREE;
163 DECL_EXTERNAL (thunk) = 1;
164 DECL_ARTIFICIAL (thunk) = 1;
165 /* Even if this thunk is a member of a local class, we don't
166 need a static chain. */
167 DECL_NO_STATIC_CHAIN (thunk) = 1;
168 /* The THUNK is not a pending inline, even if the FUNCTION is. */
169 DECL_PENDING_INLINE_P (thunk) = 0;
170 DECL_INLINE (thunk) = 0;
171 DECL_DECLARED_INLINE_P (thunk) = 0;
172 /* Nor has it been deferred. */
173 DECL_DEFERRED_FN (thunk) = 0;
174 /* Add it to the list of thunks associated with FUNCTION. */
175 TREE_CHAIN (thunk) = DECL_THUNKS (function);
176 DECL_THUNKS (function) = thunk;
181 /* Finish THUNK, a thunk decl. */
184 finish_thunk (tree thunk)
187 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
188 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
190 my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
191 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
192 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
193 function = THUNK_TARGET (thunk);
194 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
195 fixed_offset, virtual_offset);
196 DECL_NAME (thunk) = name;
197 SET_DECL_ASSEMBLER_NAME (thunk, name);
200 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
201 offset indicated by VIRTUAL_OFFSET, if that is
202 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
203 zero for a result adjusting thunk. */
206 thunk_adjust (tree ptr, bool this_adjusting,
207 HOST_WIDE_INT fixed_offset, tree virtual_offset)
210 /* Adjust the pointer by the constant. */
211 ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
212 ssize_int (fixed_offset)));
214 /* If there's a virtual offset, look up that value in the vtable and
215 adjust the pointer again. */
220 ptr = save_expr (ptr);
221 /* The vptr is always at offset zero in the object. */
222 vtable = build1 (NOP_EXPR,
223 build_pointer_type (build_pointer_type
224 (vtable_entry_type)),
226 /* Form the vtable address. */
227 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
228 /* Find the entry with the vcall offset. */
229 vtable = build (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
230 /* Get the offset itself. */
231 vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
232 /* Adjust the `this' pointer. */
233 ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable));
237 /* Adjust the pointer by the constant. */
238 ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
239 ssize_int (fixed_offset)));
244 /* Garbage collector tables contains thunk_labelno even when places
245 inside ifdef block. */
246 static GTY (()) int thunk_labelno;
247 #ifdef ASM_OUTPUT_DEF
249 /* Create a static alias to function. */
252 make_alias_for_thunk (tree function)
257 ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
259 alias = build_decl (FUNCTION_DECL, get_identifier (buf),
260 TREE_TYPE (function));
261 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
262 cxx_dup_lang_specific_decl (alias);
263 DECL_CONTEXT (alias) = NULL;
264 TREE_READONLY (alias) = TREE_READONLY (function);
265 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
266 TREE_PUBLIC (alias) = 0;
267 DECL_INTERFACE_KNOWN (alias) = 1;
268 DECL_NOT_REALLY_EXTERN (alias) = 1;
269 DECL_THIS_STATIC (alias) = 1;
270 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
271 DECL_DESTRUCTOR_P (alias) = 0;
272 DECL_CONSTRUCTOR_P (alias) = 0;
273 DECL_CLONED_FUNCTION (alias) = NULL_TREE;
274 DECL_EXTERNAL (alias) = 0;
275 DECL_ARTIFICIAL (alias) = 1;
276 DECL_NO_STATIC_CHAIN (alias) = 1;
277 DECL_PENDING_INLINE_P (alias) = 0;
278 DECL_INLINE (alias) = 0;
279 DECL_DECLARED_INLINE_P (alias) = 0;
280 DECL_DEFERRED_FN (alias) = 0;
281 DECL_USE_TEMPLATE (alias) = 0;
282 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
283 DECL_TEMPLATE_INFO (alias) = NULL;
284 DECL_INITIAL (alias) = error_mark_node;
285 TREE_ADDRESSABLE (alias) = 1;
286 TREE_USED (alias) = 1;
287 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
288 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
289 if (!flag_syntax_only)
290 assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
295 /* Emit the definition of a C++ multiple inheritance or covariant
296 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
300 use_thunk (tree thunk_fndecl, bool emit_p)
302 tree function, alias;
304 HOST_WIDE_INT fixed_offset, virtual_value;
305 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
307 /* We should have called finish_thunk to give it a name. */
308 my_friendly_assert (DECL_NAME (thunk_fndecl), 20021127);
310 if (TREE_ASM_WRITTEN (thunk_fndecl))
313 function = THUNK_TARGET (thunk_fndecl);
314 if (DECL_RESULT (thunk_fndecl))
315 /* We already turned this thunk into an ordinary function.
316 There's no need to process this thunk again. */
319 /* Thunks are always addressable; they only appear in vtables. */
320 TREE_ADDRESSABLE (thunk_fndecl) = 1;
322 /* Figure out what function is being thunked to. It's referenced in
323 this translation unit. */
324 TREE_ADDRESSABLE (function) = 1;
325 mark_used (function);
326 mark_referenced (DECL_ASSEMBLER_NAME (function));
330 #ifdef ASM_OUTPUT_DEF
331 alias = make_alias_for_thunk (function);
336 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
337 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
342 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
343 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
344 my_friendly_assert (virtual_value, 20021026);
349 /* And, if we need to emit the thunk, it's used. */
350 mark_used (thunk_fndecl);
351 /* This thunk is actually defined. */
352 DECL_EXTERNAL (thunk_fndecl) = 0;
353 /* The linkage of the function may have changed. FIXME in linkage
355 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
357 if (flag_syntax_only)
359 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
363 push_to_top_level ();
365 #ifdef ASM_OUTPUT_DEF
366 if (targetm.have_named_sections)
368 resolve_unique_section (function, 0, flag_function_sections);
370 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
372 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
374 /* Output the thunk into the same section as function. */
375 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
380 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
382 DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
383 BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = DECL_ARGUMENTS (thunk_fndecl);
386 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
387 virtual_value, alias))
390 current_function_decl = thunk_fndecl;
391 DECL_RESULT (thunk_fndecl)
392 = build_decl (RESULT_DECL, 0, integer_type_node);
393 fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
394 init_function_start (thunk_fndecl);
395 current_function_is_thunk = 1;
396 assemble_start_function (thunk_fndecl, fnname);
398 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
399 fixed_offset, virtual_value, alias);
401 assemble_end_function (thunk_fndecl, fnname);
402 current_function_decl = 0;
404 /* Because init_function_start increments this, we must
406 immediate_size_expand--;
407 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
411 /* If this is a covariant thunk, or we don't have the necessary
412 code for efficient thunks, generate a thunk function that
413 just makes a call to the real function. Unfortunately, this
414 doesn't work for varargs. */
418 if (varargs_function_p (function))
419 error ("generic thunk code fails for method `%#D' which uses `...'",
422 /* Set up cloned argument trees for the thunk. */
424 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
426 tree x = copy_node (a);
428 DECL_CONTEXT (x) = thunk_fndecl;
429 SET_DECL_RTL (x, NULL_RTX);
433 DECL_ARGUMENTS (thunk_fndecl) = a;
434 DECL_RESULT (thunk_fndecl) = NULL_TREE;
436 start_function (NULL_TREE, thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
437 /* We don't bother with a body block for thunks. */
439 /* There's no need to check accessibility inside the thunk body. */
440 push_deferring_access_checks (dk_no_check);
444 t = thunk_adjust (t, /*this_adjusting=*/1,
445 fixed_offset, virtual_offset);
447 /* Build up the call to the real function. */
448 t = tree_cons (NULL_TREE, t, NULL_TREE);
449 for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
450 t = tree_cons (NULL_TREE, a, t);
452 t = build_call (alias, t);
454 t = thunk_adjust (t, /*this_adjusting=*/0,
455 fixed_offset, virtual_offset);
457 if (VOID_TYPE_P (TREE_TYPE (t)))
458 finish_expr_stmt (t);
460 finish_return_stmt (t);
462 /* Since we want to emit the thunk, we explicitly mark its name as
464 mark_referenced (DECL_ASSEMBLER_NAME (thunk_fndecl));
466 /* But we don't want debugging information about it. */
467 DECL_IGNORED_P (thunk_fndecl) = 1;
469 /* Re-enable access control. */
470 pop_deferring_access_checks ();
472 expand_body (finish_function (0));
475 pop_from_top_level ();
478 /* Code for synthesizing methods which have default semantics defined. */
480 /* Generate code for default X(X&) constructor. */
483 do_build_copy_constructor (tree fndecl)
485 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
488 parm = convert_from_reference (parm);
490 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
491 && is_empty_class (current_class_type))
492 /* Don't copy the padding byte; it might not have been allocated
493 if *this is a base subobject. */;
494 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
496 t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
497 finish_expr_stmt (t);
501 tree fields = TYPE_FIELDS (current_class_type);
502 int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
503 tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
504 tree member_init_list = NULL_TREE;
505 int cvquals = cp_type_quals (TREE_TYPE (parm));
508 /* Initialize all the base-classes with the parameter converted
509 to their type so that we get their copy constructor and not
510 another constructor that takes current_class_type. We must
511 deal with the binfo's directly as a direct base might be
512 inaccessible due to ambiguity. */
513 for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
516 tree binfo = TREE_VALUE (t);
520 build_tree_list (NULL_TREE,
521 build_base_path (PLUS_EXPR, parm,
526 for (i = 0; i < n_bases; ++i)
528 tree binfo = TREE_VEC_ELT (binfos, i);
529 if (TREE_VIA_VIRTUAL (binfo))
534 build_tree_list (NULL_TREE,
535 build_base_path (PLUS_EXPR, parm,
540 for (; fields; fields = TREE_CHAIN (fields))
546 if (TREE_CODE (field) != FIELD_DECL)
550 if (DECL_NAME (field))
552 if (VFIELD_NAME_P (DECL_NAME (field)))
555 /* True for duplicate members. */
556 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
559 else if ((t = TREE_TYPE (field)) != NULL_TREE
560 && ANON_AGGR_TYPE_P (t)
561 && TYPE_FIELDS (t) != NULL_TREE)
562 /* Just use the field; anonymous types can't have
563 nontrivial copy ctors or assignment ops. */;
567 /* Compute the type of "init->field". If the copy-constructor
568 parameter is, for example, "const S&", and the type of
569 the field is "T", then the type will usually be "const
570 T". (There are no cv-qualified variants of reference
572 expr_type = TREE_TYPE (field);
573 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
574 expr_type = cp_build_qualified_type (expr_type, cvquals);
575 init = build (COMPONENT_REF, expr_type, init, field);
576 init = build_tree_list (NULL_TREE, init);
579 = tree_cons (field, init, member_init_list);
581 finish_mem_initializers (member_init_list);
586 do_build_assign_ref (tree fndecl)
588 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
591 compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
592 parm = convert_from_reference (parm);
594 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
595 && is_empty_class (current_class_type))
596 /* Don't copy the padding byte; it might not have been allocated
597 if *this is a base subobject. */;
598 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
600 tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm);
601 finish_expr_stmt (t);
606 int cvquals = cp_type_quals (TREE_TYPE (parm));
609 /* Assign to each of the direct base classes. */
610 for (i = 0; i < CLASSTYPE_N_BASECLASSES (current_class_type); ++i)
615 binfo = BINFO_BASETYPE (TYPE_BINFO (current_class_type), i);
616 /* We must convert PARM directly to the base class
617 explicitly since the base class may be ambiguous. */
618 converted_parm = build_base_path (PLUS_EXPR, parm, binfo, 1);
619 /* Call the base class assignment operator. */
621 (build_special_member_call (current_class_ref,
622 ansi_assopname (NOP_EXPR),
623 build_tree_list (NULL_TREE,
626 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
629 /* Assign to each of the non-static data members. */
630 for (fields = TYPE_FIELDS (current_class_type);
632 fields = TREE_CHAIN (fields))
637 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
640 if (CP_TYPE_CONST_P (TREE_TYPE (field)))
642 error ("non-static const member `%#D', can't use default assignment operator", field);
645 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
647 error ("non-static reference member `%#D', can't use default assignment operator", field);
651 comp = current_class_ref;
654 if (DECL_NAME (field))
656 if (VFIELD_NAME_P (DECL_NAME (field)))
659 /* True for duplicate members. */
660 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
663 else if ((t = TREE_TYPE (field)) != NULL_TREE
664 && ANON_AGGR_TYPE_P (t)
665 && TYPE_FIELDS (t) != NULL_TREE)
666 /* Just use the field; anonymous types can't have
667 nontrivial copy ctors or assignment ops. */;
671 comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
672 init = build (COMPONENT_REF,
673 cp_build_qualified_type (TREE_TYPE (field), cvquals),
676 if (DECL_NAME (field))
677 finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
679 finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
683 finish_return_stmt (current_class_ref);
684 finish_compound_stmt (compound_stmt);
688 synthesize_method (tree fndecl)
690 bool nested = (current_function_decl != NULL_TREE);
691 tree context = decl_function_context (fndecl);
692 bool need_body = true;
696 import_export_decl (fndecl);
698 /* If we've been asked to synthesize a clone, just synthesize the
699 cloned function instead. Doing so will automatically fill in the
700 body for the clone. */
701 if (DECL_CLONED_FUNCTION_P (fndecl))
703 synthesize_method (DECL_CLONED_FUNCTION (fndecl));
707 /* We may be in the middle of deferred access check. Disable
709 push_deferring_access_checks (dk_no_deferred);
712 push_to_top_level ();
714 push_function_context_to (context);
716 /* Put the function definition at the position where it is needed,
717 rather than within the body of the class. That way, an error
718 during the generation of the implicit body points at the place
719 where the attempt to generate the function occurs, giving the
720 user a hint as to why we are attempting to generate the
722 DECL_SOURCE_LOCATION (fndecl) = input_location;
724 interface_unknown = 1;
725 start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
727 stmt = begin_function_body ();
729 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
731 do_build_assign_ref (fndecl);
734 else if (DECL_CONSTRUCTOR_P (fndecl))
736 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
737 if (arg_chain != void_list_node)
738 do_build_copy_constructor (fndecl);
739 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
740 finish_mem_initializers (NULL_TREE);
743 /* If we haven't yet generated the body of the function, just
744 generate an empty compound statement. */
748 compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
749 finish_compound_stmt (compound_stmt);
752 finish_function_body (stmt);
753 expand_or_defer_fn (finish_function (0));
755 extract_interface_info ();
757 pop_from_top_level ();
759 pop_function_context_from (context);
761 pop_deferring_access_checks ();
764 /* Use EXTRACTOR to locate the relevant function called for each base &
765 class field of TYPE. CLIENT allows additional information to be passed
766 to EXTRACTOR. Generates the union of all exceptions generated by those
767 functions. Note that we haven't updated TYPE_FIELDS and such of any
768 variants yet, so we need to look at the main one. */
771 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
774 tree raises = empty_except_spec;
775 tree fields = TYPE_FIELDS (type);
776 int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
777 tree binfos = TYPE_BINFO_BASETYPES (type);
779 for (i = 0; i != n_bases; i++)
781 tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
782 tree fn = (*extractor) (base, client);
785 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
787 raises = merge_exception_specifiers (raises, fn_raises);
790 for (; fields; fields = TREE_CHAIN (fields))
792 tree type = TREE_TYPE (fields);
795 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
797 while (TREE_CODE (type) == ARRAY_TYPE)
798 type = TREE_TYPE (type);
799 if (TREE_CODE (type) != RECORD_TYPE)
802 fn = (*extractor) (type, client);
805 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
807 raises = merge_exception_specifiers (raises, fn_raises);
813 /* Locate the dtor of TYPE. */
816 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
820 if (!TYPE_HAS_DESTRUCTOR (type))
822 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
823 CLASSTYPE_DESTRUCTOR_SLOT);
827 /* Locate the default ctor of TYPE. */
830 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
834 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
837 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
838 CLASSTYPE_CONSTRUCTOR_SLOT);
839 for (; fns; fns = OVL_NEXT (fns))
841 tree fn = OVL_CURRENT (fns);
842 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
844 if (sufficient_parms_p (TREE_CHAIN (parms)))
856 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
857 points to a COPY_DATA holding the name (NULL for the ctor)
858 and desired qualifiers of the source operand. */
861 locate_copy (tree type, void *client_)
863 struct copy_data *client = (struct copy_data *)client_;
866 tree best = NULL_TREE;
867 bool excess_p = false;
871 if (TYPE_HAS_ASSIGN_REF (type))
872 ix = lookup_fnfields_1 (type, client->name);
874 else if (TYPE_HAS_INIT_REF (type))
875 ix = CLASSTYPE_CONSTRUCTOR_SLOT;
878 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
880 for (; fns; fns = OVL_NEXT (fns))
882 tree fn = OVL_CURRENT (fns);
883 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
888 parms = TREE_CHAIN (parms);
891 src_type = non_reference (TREE_VALUE (parms));
892 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
894 if (!sufficient_parms_p (TREE_CHAIN (parms)))
896 quals = cp_type_quals (src_type);
897 if (client->quals & ~quals)
899 excess = quals & ~client->quals;
900 if (!best || (excess_p && !excess))
912 /* Implicitly declare the special function indicated by KIND, as a
913 member of TYPE. For copy constructors and assignment operators,
914 CONST_P indicates whether these functions should take a const
915 reference argument or a non-const reference. */
918 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
920 tree declspecs = NULL_TREE;
921 tree fn, args = NULL_TREE;
922 tree raises = empty_except_spec;
924 bool has_parm = false;
925 tree name = constructor_name (type);
931 name = build_nt (BIT_NOT_EXPR, name);
932 args = void_list_node;
933 raises = synthesize_exception_spec (type, &locate_dtor, 0);
936 case sfk_constructor:
937 /* Default constructor. */
938 args = void_list_node;
939 raises = synthesize_exception_spec (type, &locate_ctor, 0);
942 case sfk_copy_constructor:
943 case sfk_assignment_operator:
945 struct copy_data data;
951 if (kind == sfk_assignment_operator)
954 declspecs = build_tree_list (NULL_TREE, type);
956 name = ansi_assopname (NOP_EXPR);
961 data.quals = TYPE_QUAL_CONST;
962 argtype = build_qualified_type (argtype, TYPE_QUAL_CONST);
965 argtype = build_reference_type (argtype);
966 args = build_tree_list (hash_tree_chain (argtype, NULL_TREE),
967 get_identifier ("_ctor_arg"));
968 args = tree_cons (NULL_TREE, args, void_list_node);
970 raises = synthesize_exception_spec (type, &locate_copy, &data);
977 TREE_PARMLIST (args) = 1;
980 tree declarator = make_call_declarator (name, args, NULL_TREE, raises);
983 declarator = build_nt (ADDR_EXPR, declarator);
985 fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
987 TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1;
990 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408);
992 DECL_ARTIFICIAL (fn) = 1;
993 DECL_NOT_REALLY_EXTERN (fn) = 1;
994 DECL_DECLARED_INLINE_P (fn) = 1;
995 DECL_INLINE (fn) = 1;
1001 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1002 as there are artificial parms in FN. */
1005 skip_artificial_parms_for (tree fn, tree list)
1007 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1008 list = TREE_CHAIN (list);
1012 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1013 list = TREE_CHAIN (list);
1014 if (DECL_HAS_VTT_PARM_P (fn))
1015 list = TREE_CHAIN (list);
1019 #include "gt-cp-method.h"