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 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GNU CC.
9 GNU CC 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 GNU CC 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 GNU CC; 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. */
39 /* Various flags to control the mangling process. */
45 /* The thing we are presently mangling is part of a template type,
46 rather than a fully instantiated type. Therefore, we may see
47 complex expressions where we would normally expect to see a
48 simple integer constant. */
49 mf_maybe_uninstantiated
= 1,
50 /* When mangling a numeric value, use the form `_XX_' (instead of
51 just `XX') if the value has more than one digit. */
52 mf_use_underscores_around_value
= 2,
55 typedef enum mangling_flags mangling_flags
;
57 #define obstack_chunk_alloc xmalloc
58 #define obstack_chunk_free free
60 static void do_build_assign_ref
PARAMS ((tree
));
61 static void do_build_copy_constructor
PARAMS ((tree
));
62 static tree synthesize_exception_spec
PARAMS ((tree
, tree (*) (tree
, void *), void *));
63 static tree locate_dtor
PARAMS ((tree
, void *));
64 static tree locate_ctor
PARAMS ((tree
, void *));
65 static tree locate_copy
PARAMS ((tree
, void *));
67 /* Called once to initialize method.c. */
76 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL. */
79 set_mangled_name_for_decl (decl
)
82 if (processing_template_decl
)
83 /* There's no need to mangle the name of a template function. */
90 /* Given a tree_code CODE, and some arguments (at least one),
91 attempt to use an overloaded operator on the arguments.
93 For unary operators, only the first argument need be checked.
94 For binary operators, both arguments may need to be checked.
96 Member functions can convert class references to class pointers,
97 for one-level deep indirection. More than that is not supported.
98 Operators [](), ()(), and ->() must be member functions.
100 We call function call building calls with LOOKUP_COMPLAIN if they
101 are our only hope. This is true when we see a vanilla operator
102 applied to something of aggregate type. If this fails, we are free
103 to return `error_mark_node', because we will have reported the
106 Operators NEW and DELETE overload in funny ways: operator new takes
107 a single `size' parameter, and operator delete takes a pointer to the
108 storage being deleted. When overloading these operators, success is
109 assumed. If there is a failure, report an error message and return
110 `error_mark_node'. */
114 build_opfncall (code
, flags
, xarg1
, xarg2
, arg3
)
117 tree xarg1
, xarg2
, arg3
;
119 return build_new_op (code
, flags
, xarg1
, xarg2
, arg3
);
122 /* This function takes an identifier, ID, and attempts to figure out what
123 it means. There are a number of possible scenarios, presented in increasing
126 1) not in a class's scope
127 2) in class's scope, member name of the class's method
128 3) in class's scope, but not a member name of the class
129 4) in class's scope, member name of a class's variable
131 NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
132 VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
134 As a last ditch, try to look up the name as a label and return that
137 Values which are declared as being of REFERENCE_TYPE are
138 automatically dereferenced here (as a hack to make the
142 hack_identifier (value
, name
)
147 if (value
== error_mark_node
)
149 if (current_class_name
)
151 tree fields
= lookup_fnfields (TYPE_BINFO (current_class_type
),
153 if (fields
== error_mark_node
)
154 return error_mark_node
;
159 fndecl
= TREE_VALUE (fields
);
160 my_friendly_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
, 251);
161 /* I could not trigger this code. MvL */
162 my_friendly_abort (980325);
164 if (DECL_CHAIN (fndecl
) == NULL_TREE
)
166 warning ("methods cannot be converted to function pointers");
171 error ("ambiguous request for method pointer `%s'",
172 IDENTIFIER_POINTER (name
));
173 return error_mark_node
;
178 return error_mark_node
;
181 type
= TREE_TYPE (value
);
182 if (TREE_CODE (value
) == FIELD_DECL
)
184 if (current_class_ptr
== NULL_TREE
)
186 if (current_function_decl
187 && DECL_STATIC_FUNCTION_P (current_function_decl
))
188 cp_error ("invalid use of member `%D' in static member function",
191 /* We can get here when processing a bad default
193 struct S { int a; void f(int i = a); } */
194 cp_error ("invalid use of member `%D'", value
);
196 return error_mark_node
;
198 TREE_USED (current_class_ptr
) = 1;
200 /* Mark so that if we are in a constructor, and then find that
201 this field was initialized by a base initializer,
202 we can emit an error message. */
203 TREE_USED (value
) = 1;
204 value
= build_component_ref (current_class_ref
, name
, NULL_TREE
, 1);
206 else if ((TREE_CODE (value
) == FUNCTION_DECL
207 && DECL_FUNCTION_MEMBER_P (value
))
208 || (TREE_CODE (value
) == OVERLOAD
209 && DECL_FUNCTION_MEMBER_P (OVL_CURRENT (value
))))
213 if (TREE_CODE (value
) == OVERLOAD
)
214 value
= OVL_CURRENT (value
);
216 decl
= maybe_dummy_object (DECL_CONTEXT (value
), 0);
217 value
= build_component_ref (decl
, name
, NULL_TREE
, 1);
219 else if (really_overloaded_fn (value
))
221 else if (TREE_CODE (value
) == OVERLOAD
)
222 /* not really overloaded function */
223 mark_used (OVL_FUNCTION (value
));
224 else if (TREE_CODE (value
) == TREE_LIST
)
226 /* Ambiguous reference to base members, possibly other cases?. */
228 while (t
&& TREE_CODE (t
) == TREE_LIST
)
230 mark_used (TREE_VALUE (t
));
234 else if (TREE_CODE (value
) == NAMESPACE_DECL
)
236 cp_error ("use of namespace `%D' as expression", value
);
237 return error_mark_node
;
239 else if (DECL_CLASS_TEMPLATE_P (value
))
241 cp_error ("use of class template `%T' as expression", value
);
242 return error_mark_node
;
247 if (TREE_CODE (value
) == VAR_DECL
|| TREE_CODE (value
) == PARM_DECL
248 || TREE_CODE (value
) == RESULT_DECL
)
250 tree context
= decl_function_context (value
);
251 if (context
!= NULL_TREE
&& context
!= current_function_decl
252 && ! TREE_STATIC (value
))
254 cp_error ("use of %s from containing function",
255 (TREE_CODE (value
) == VAR_DECL
256 ? "`auto' variable" : "parameter"));
257 cp_error_at (" `%#D' declared here", value
);
258 value
= error_mark_node
;
262 if (DECL_P (value
) && DECL_NONLOCAL (value
))
264 if (DECL_CLASS_SCOPE_P (value
)
265 && DECL_CONTEXT (value
) != current_class_type
)
268 path
= currently_open_derived_class (DECL_CONTEXT (value
));
269 enforce_access (path
, value
);
272 else if (TREE_CODE (value
) == TREE_LIST
273 && TREE_TYPE (value
) == error_mark_node
)
276 request for member `%D' is ambiguous in multiple inheritance lattice",
278 print_candidates (value
);
279 return error_mark_node
;
282 if (! processing_template_decl
)
283 value
= convert_from_reference (value
);
288 /* Return a thunk to FUNCTION. For a virtual thunk, DELTA is the
289 offset to this used to locate the vptr, and VCALL_INDEX is used to
290 look up the eventual subobject location. For a non-virtual thunk,
291 DELTA is the offset to this and VCALL_INDEX is NULL. */
294 make_thunk (function
, delta
, vcall_index
)
305 /* Scale the VCALL_INDEX to be in terms of bytes. */
308 = size_binop (MULT_EXPR
,
311 TYPE_SIZE_UNIT (vtable_entry_type
)));
313 vcall_offset
= NULL_TREE
;
315 d
= tree_low_cst (delta
, 0);
317 if (TREE_CODE (function
) != ADDR_EXPR
)
319 func_decl
= TREE_OPERAND (function
, 0);
320 if (TREE_CODE (func_decl
) != FUNCTION_DECL
)
323 thunk_id
= mangle_thunk (TREE_OPERAND (function
, 0),
324 delta
, vcall_offset
);
325 thunk
= IDENTIFIER_GLOBAL_VALUE (thunk_id
);
326 if (thunk
&& !DECL_THUNK_P (thunk
))
328 cp_error ("implementation-reserved name `%D' used", thunk_id
);
330 SET_IDENTIFIER_GLOBAL_VALUE (thunk_id
, thunk
);
332 if (thunk
== NULL_TREE
)
334 thunk
= build_decl (FUNCTION_DECL
, thunk_id
, TREE_TYPE (func_decl
));
335 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (func_decl
);
336 copy_lang_decl (func_decl
);
337 SET_DECL_ASSEMBLER_NAME (thunk
, thunk_id
);
338 DECL_CONTEXT (thunk
) = DECL_CONTEXT (func_decl
);
339 TREE_READONLY (thunk
) = TREE_READONLY (func_decl
);
340 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (func_decl
);
341 comdat_linkage (thunk
);
342 SET_DECL_THUNK_P (thunk
);
343 DECL_INITIAL (thunk
) = function
;
344 THUNK_DELTA (thunk
) = d
;
345 THUNK_VCALL_OFFSET (thunk
) = vcall_offset
;
346 /* The thunk itself is not a constructor or destructor, even if
347 the thing it is thunking to is. */
348 DECL_INTERFACE_KNOWN (thunk
) = 1;
349 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
350 DECL_SAVED_FUNCTION_DATA (thunk
) = NULL
;
351 DECL_DESTRUCTOR_P (thunk
) = 0;
352 DECL_CONSTRUCTOR_P (thunk
) = 0;
353 /* And neither is it a clone. */
354 DECL_CLONED_FUNCTION (thunk
) = NULL_TREE
;
355 DECL_EXTERNAL (thunk
) = 1;
356 DECL_ARTIFICIAL (thunk
) = 1;
357 /* Even if this thunk is a member of a local class, we don't
358 need a static chain. */
359 DECL_NO_STATIC_CHAIN (thunk
) = 1;
360 /* The THUNK is not a pending inline, even if the FUNC_DECL is. */
361 DECL_PENDING_INLINE_P (thunk
) = 0;
362 /* Nor has it been deferred. */
363 DECL_DEFERRED_FN (thunk
) = 0;
364 /* So that finish_file can write out any thunks that need to be: */
365 pushdecl_top_level (thunk
);
366 SET_IDENTIFIER_GLOBAL_VALUE (thunk_id
, thunk
);
371 /* Emit the definition of a C++ multiple inheritance vtable thunk. If
372 EMIT_P is non-zero, the thunk is emitted immediately. */
375 use_thunk (thunk_fndecl
, emit_p
)
384 if (TREE_ASM_WRITTEN (thunk_fndecl
))
387 fnaddr
= DECL_INITIAL (thunk_fndecl
);
388 if (TREE_CODE (DECL_INITIAL (thunk_fndecl
)) != ADDR_EXPR
)
389 /* We already turned this thunk into an ordinary function.
390 There's no need to process this thunk again. */
393 /* Thunks are always addressable; they only appear in vtables. */
394 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
396 /* Figure out what function is being thunked to. It's referenced in
397 this translation unit. */
398 function
= TREE_OPERAND (fnaddr
, 0);
399 TREE_ADDRESSABLE (function
) = 1;
400 mark_used (function
);
401 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (function
)) = 1;
405 delta
= THUNK_DELTA (thunk_fndecl
);
406 vcall_offset
= THUNK_VCALL_OFFSET (thunk_fndecl
);
408 /* And, if we need to emit the thunk, it's used. */
409 mark_used (thunk_fndecl
);
410 /* This thunk is actually defined. */
411 DECL_EXTERNAL (thunk_fndecl
) = 0;
413 if (flag_syntax_only
)
415 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
419 push_to_top_level ();
421 #ifdef ASM_OUTPUT_MI_THUNK
425 current_function_decl
= thunk_fndecl
;
426 DECL_RESULT (thunk_fndecl
)
427 = build_decl (RESULT_DECL
, 0, integer_type_node
);
428 fnname
= XSTR (XEXP (DECL_RTL (thunk_fndecl
), 0), 0);
429 init_function_start (thunk_fndecl
, input_filename
, lineno
);
430 current_function_is_thunk
= 1;
431 assemble_start_function (thunk_fndecl
, fnname
);
432 ASM_OUTPUT_MI_THUNK (asm_out_file
, thunk_fndecl
, delta
, function
);
433 assemble_end_function (thunk_fndecl
, fnname
);
434 current_function_decl
= 0;
436 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
439 #endif /* ASM_OUTPUT_MI_THUNK */
441 /* If we don't have the necessary macro for efficient thunks, generate a
442 thunk function that just makes a call to the real function.
443 Unfortunately, this doesn't work for varargs. */
447 if (varargs_function_p (function
))
448 cp_error ("generic thunk code fails for method `%#D' which uses `...'",
451 /* Set up clone argument trees for the thunk. */
453 for (a
= DECL_ARGUMENTS (function
); a
; a
= TREE_CHAIN (a
))
455 tree x
= copy_node (a
);
457 DECL_CONTEXT (x
) = thunk_fndecl
;
461 DECL_ARGUMENTS (thunk_fndecl
) = a
;
462 DECL_RESULT (thunk_fndecl
) = NULL_TREE
;
464 start_function (NULL_TREE
, thunk_fndecl
, NULL_TREE
, SF_PRE_PARSED
);
466 /* Adjust the this pointer by the constant. */
467 t
= ssize_int (delta
);
468 t
= fold (build (PLUS_EXPR
, TREE_TYPE (a
), a
, t
));
469 /* If there's a vcall offset, look up that value in the vtable and
470 adjust the `this' pointer again. */
471 if (vcall_offset
&& !integer_zerop (vcall_offset
))
477 /* The vptr is always at offset zero in the object. */
478 t
= build1 (NOP_EXPR
,
479 build_pointer_type (build_pointer_type
480 (vtable_entry_type
)),
482 /* Form the vtable address. */
483 t
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (t
)), t
);
484 /* Find the entry with the vcall offset. */
485 t
= build (PLUS_EXPR
, TREE_TYPE (t
), t
, vcall_offset
);
486 /* Calculate the offset itself. */
487 t
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (t
)), t
);
488 /* Adjust the `this' pointer. */
489 t
= fold (build (PLUS_EXPR
,
490 TREE_TYPE (orig_this
),
495 /* Build up the call to the real function. */
496 t
= tree_cons (NULL_TREE
, t
, NULL_TREE
);
497 for (a
= TREE_CHAIN (a
); a
; a
= TREE_CHAIN (a
))
498 t
= tree_cons (NULL_TREE
, a
, t
);
500 t
= build_call (function
, t
);
501 if (VOID_TYPE_P (TREE_TYPE (t
)))
502 finish_expr_stmt (t
);
504 finish_return_stmt (t
);
506 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
508 DECL_INITIAL (thunk_fndecl
) = make_node (BLOCK
);
509 BLOCK_VARS (DECL_INITIAL (thunk_fndecl
))
510 = DECL_ARGUMENTS (thunk_fndecl
);
512 /* Since we want to emit the thunk, we explicitly mark its name as
514 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (thunk_fndecl
)) = 1;
516 /* But we don't want debugging information about it. */
517 DECL_IGNORED_P (thunk_fndecl
) = 1;
519 expand_body (finish_function (0));
522 pop_from_top_level ();
525 /* Code for synthesizing methods which have default semantics defined. */
527 /* Generate code for default X(X&) constructor. */
530 do_build_copy_constructor (fndecl
)
533 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
536 parm
= convert_from_reference (parm
);
538 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
)
539 && is_empty_class (current_class_type
))
540 /* Don't copy the padding byte; it might not have been allocated
541 if *this is a base subobject. */;
542 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type
))
544 t
= build (INIT_EXPR
, void_type_node
, current_class_ref
, parm
);
545 finish_expr_stmt (t
);
549 tree fields
= TYPE_FIELDS (current_class_type
);
550 int n_bases
= CLASSTYPE_N_BASECLASSES (current_class_type
);
551 tree binfos
= TYPE_BINFO_BASETYPES (current_class_type
);
552 tree member_init_list
= NULL_TREE
;
553 tree base_init_list
= NULL_TREE
;
554 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
557 /* Initialize all the base-classes with the parameter converted
558 to their type so that we get their copy constructor and not
559 another constructor that takes current_class_type. We must
560 deal with the binfo's directly as a direct base might be
561 inaccessible due to ambiguity. */
562 for (t
= CLASSTYPE_VBASECLASSES (current_class_type
); t
;
565 tree binfo
= TREE_VALUE (t
);
567 base_init_list
= tree_cons (binfo
,
568 build_base_path (PLUS_EXPR
, parm
,
573 for (i
= 0; i
< n_bases
; ++i
)
575 tree binfo
= TREE_VEC_ELT (binfos
, i
);
576 if (TREE_VIA_VIRTUAL (binfo
))
579 base_init_list
= tree_cons (binfo
,
580 build_base_path (PLUS_EXPR
, parm
,
585 for (; fields
; fields
= TREE_CHAIN (fields
))
590 if (TREE_CODE (field
) != FIELD_DECL
)
594 if (DECL_NAME (field
))
596 if (VFIELD_NAME_P (DECL_NAME (field
)))
599 /* True for duplicate members. */
600 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != field
)
603 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
604 && ANON_AGGR_TYPE_P (t
)
605 && TYPE_FIELDS (t
) != NULL_TREE
)
606 /* Just use the field; anonymous types can't have
607 nontrivial copy ctors or assignment ops. */;
611 init
= build (COMPONENT_REF
,
612 build_qualified_type (TREE_TYPE (field
), cvquals
),
614 init
= build_tree_list (NULL_TREE
, init
);
617 = tree_cons (field
, init
, member_init_list
);
619 member_init_list
= nreverse (member_init_list
);
620 base_init_list
= nreverse (base_init_list
);
621 setup_vtbl_ptr (member_init_list
, base_init_list
);
626 do_build_assign_ref (fndecl
)
629 tree parm
= TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
632 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
633 parm
= convert_from_reference (parm
);
635 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
)
636 && is_empty_class (current_class_type
))
637 /* Don't copy the padding byte; it might not have been allocated
638 if *this is a base subobject. */;
639 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type
))
641 tree t
= build (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
642 finish_expr_stmt (t
);
646 tree fields
= TYPE_FIELDS (current_class_type
);
647 int n_bases
= CLASSTYPE_N_BASECLASSES (current_class_type
);
648 tree binfos
= TYPE_BINFO_BASETYPES (current_class_type
);
649 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
652 for (i
= 0; i
< n_bases
; ++i
)
654 /* We must deal with the binfo's directly as a direct base
655 might be inaccessible due to ambiguity. */
656 tree binfo
= TREE_VEC_ELT (binfos
, i
);
657 tree src
= build_base_path (PLUS_EXPR
, parm
, binfo
, 1);
658 tree dst
= build_base_path (PLUS_EXPR
, current_class_ref
, binfo
, 1);
660 tree expr
= build_method_call (dst
,
661 ansi_assopname (NOP_EXPR
),
662 build_tree_list (NULL_TREE
, src
),
664 LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
);
665 finish_expr_stmt (expr
);
667 for (; fields
; fields
= TREE_CHAIN (fields
))
672 if (TREE_CODE (field
) != FIELD_DECL
)
675 if (CP_TYPE_CONST_P (TREE_TYPE (field
)))
677 cp_error ("non-static const member `%#D', can't use default assignment operator", field
);
680 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
682 cp_error ("non-static reference member `%#D', can't use default assignment operator", field
);
686 comp
= current_class_ref
;
689 if (DECL_NAME (field
))
691 if (VFIELD_NAME_P (DECL_NAME (field
)))
694 /* True for duplicate members. */
695 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field
)) != field
)
698 else if ((t
= TREE_TYPE (field
)) != NULL_TREE
699 && ANON_AGGR_TYPE_P (t
)
700 && TYPE_FIELDS (t
) != NULL_TREE
)
701 /* Just use the field; anonymous types can't have
702 nontrivial copy ctors or assignment ops. */;
706 comp
= build (COMPONENT_REF
, TREE_TYPE (field
), comp
, field
);
707 init
= build (COMPONENT_REF
,
708 build_qualified_type (TREE_TYPE (field
), cvquals
),
711 if (DECL_NAME (field
))
712 finish_expr_stmt (build_modify_expr (comp
, NOP_EXPR
, init
));
714 finish_expr_stmt (build (MODIFY_EXPR
, TREE_TYPE (comp
), comp
,
718 finish_return_stmt (current_class_ref
);
719 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
723 synthesize_method (fndecl
)
726 int nested
= (current_function_decl
!= NULL_TREE
);
727 tree context
= decl_function_context (fndecl
);
731 import_export_decl (fndecl
);
733 /* If we've been asked to synthesize a clone, just synthesize the
734 cloned function instead. Doing so will automatically fill in the
735 body for the clone. */
736 if (DECL_CLONED_FUNCTION_P (fndecl
))
738 synthesize_method (DECL_CLONED_FUNCTION (fndecl
));
743 push_to_top_level ();
745 push_function_context_to (context
);
747 /* Put the function definition at the position where it is needed,
748 rather than within the body of the class. That way, an error
749 during the generation of the implicit body points at the place
750 where the attempt to generate the function occurs, giving the
751 user a hint as to why we are attempting to generate the
753 DECL_SOURCE_LINE (fndecl
) = lineno
;
754 DECL_SOURCE_FILE (fndecl
) = input_filename
;
756 interface_unknown
= 1;
757 start_function (NULL_TREE
, fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
760 if (DECL_OVERLOADED_OPERATOR_P (fndecl
) == NOP_EXPR
)
762 do_build_assign_ref (fndecl
);
765 else if (DECL_DESTRUCTOR_P (fndecl
))
766 setup_vtbl_ptr (NULL_TREE
, NULL_TREE
);
769 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
770 if (arg_chain
!= void_list_node
)
771 do_build_copy_constructor (fndecl
);
772 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type
))
773 setup_vtbl_ptr (NULL_TREE
, NULL_TREE
);
776 /* If we haven't yet generated the body of the function, just
777 generate an empty compound statement. */
781 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
782 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
785 expand_body (finish_function (0));
787 extract_interface_info ();
789 pop_from_top_level ();
791 pop_function_context_from (context
);
794 /* Use EXTRACTOR to locate the relevant function called for each base &
795 class field of TYPE. CLIENT allows additional information to be passed
796 to EXTRACTOR. Generates the union of all exceptions generated by
800 synthesize_exception_spec (type
, extractor
, client
)
802 tree (*extractor
) (tree
, void *);
805 tree raises
= empty_except_spec
;
806 tree fields
= TYPE_FIELDS (type
);
807 int i
, n_bases
= CLASSTYPE_N_BASECLASSES (type
);
808 tree binfos
= TYPE_BINFO_BASETYPES (type
);
810 for (i
= 0; i
!= n_bases
; i
++)
812 tree base
= BINFO_TYPE (TREE_VEC_ELT (binfos
, i
));
813 tree fn
= (*extractor
) (base
, client
);
816 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
818 raises
= merge_exception_specifiers (raises
, fn_raises
);
821 for (; fields
; fields
= TREE_CHAIN (fields
))
823 tree type
= TREE_TYPE (fields
);
826 if (TREE_CODE (fields
) != FIELD_DECL
)
828 while (TREE_CODE (type
) == ARRAY_TYPE
)
829 type
= TREE_TYPE (type
);
830 if (TREE_CODE (type
) != RECORD_TYPE
)
833 fn
= (*extractor
) (type
, client
);
836 tree fn_raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
838 raises
= merge_exception_specifiers (raises
, fn_raises
);
844 /* Locate the dtor of TYPE. */
847 locate_dtor (type
, client
)
849 void *client ATTRIBUTE_UNUSED
;
853 if (!TYPE_HAS_DESTRUCTOR (type
))
855 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
),
856 CLASSTYPE_DESTRUCTOR_SLOT
);
860 /* Locate the default ctor of TYPE. */
863 locate_ctor (type
, client
)
865 void *client ATTRIBUTE_UNUSED
;
869 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
872 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
),
873 CLASSTYPE_CONSTRUCTOR_SLOT
);
874 for (; fns
; fns
= OVL_NEXT (fns
))
876 tree fn
= OVL_CURRENT (fns
);
877 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
879 if (sufficient_parms_p (TREE_CHAIN (parms
)))
891 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
892 points to a COPY_DATA holding the name (NULL for the ctor)
893 and desired qualifiers of the source operand. */
896 locate_copy (type
, client_
)
900 struct copy_data
*client
= (struct copy_data
*)client_
;
903 tree best
= NULL_TREE
;
908 if (TYPE_HAS_ASSIGN_REF (type
))
909 ix
= lookup_fnfields_1 (type
, client
->name
);
911 else if (TYPE_HAS_INIT_REF (type
))
912 ix
= CLASSTYPE_CONSTRUCTOR_SLOT
;
915 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), ix
);
917 for (; fns
; fns
= OVL_NEXT (fns
))
919 tree fn
= OVL_CURRENT (fns
);
920 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
925 parms
= TREE_CHAIN (parms
);
928 src_type
= TREE_VALUE (parms
);
929 if (TREE_CODE (src_type
) == REFERENCE_TYPE
)
930 src_type
= TREE_TYPE (src_type
);
931 if (!same_type_ignoring_top_level_qualifiers_p (src_type
, type
))
933 if (!sufficient_parms_p (TREE_CHAIN (parms
)))
935 quals
= cp_type_quals (src_type
);
936 if (client
->quals
& ~quals
)
938 excess
= quals
& ~client
->quals
;
939 if (!best
|| (excess_p
&& !excess
))
951 /* Implicitly declare the special function indicated by KIND, as a
952 member of TYPE. For copy constructors and assignment operators,
953 CONST_P indicates whether these functions should take a const
954 reference argument or a non-const reference. */
957 implicitly_declare_fn (kind
, type
, const_p
)
958 special_function_kind kind
;
962 tree declspecs
= NULL_TREE
;
963 tree fn
, args
= NULL_TREE
;
964 tree raises
= empty_except_spec
;
967 tree name
= constructor_name (TYPE_IDENTIFIER (type
));
973 name
= build_nt (BIT_NOT_EXPR
, name
);
974 args
= void_list_node
;
975 raises
= synthesize_exception_spec (type
, &locate_dtor
, 0);
978 case sfk_constructor
:
979 /* Default constructor. */
980 args
= void_list_node
;
981 raises
= synthesize_exception_spec (type
, &locate_ctor
, 0);
984 case sfk_copy_constructor
:
985 case sfk_assignment_operator
:
987 struct copy_data data
;
993 if (kind
== sfk_assignment_operator
)
996 declspecs
= build_tree_list (NULL_TREE
, type
);
998 name
= ansi_assopname (NOP_EXPR
);
1003 data
.quals
= TYPE_QUAL_CONST
;
1004 type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
1007 argtype
= build_reference_type (type
);
1008 args
= build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1009 get_identifier ("_ctor_arg"));
1010 args
= tree_cons (NULL_TREE
, args
, void_list_node
);
1012 raises
= synthesize_exception_spec (type
, &locate_copy
, &data
);
1016 my_friendly_abort (59);
1019 TREE_PARMLIST (args
) = 1;
1022 tree declarator
= make_call_declarator (name
, args
, NULL_TREE
, raises
);
1025 declarator
= build_nt (ADDR_EXPR
, declarator
);
1027 fn
= grokfield (declarator
, declspecs
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
1029 TREE_USED (FUNCTION_FIRST_USER_PARM (fn
)) = 1;
1032 my_friendly_assert (TREE_CODE (fn
) == FUNCTION_DECL
, 20000408);
1034 DECL_ARTIFICIAL (fn
) = 1;
1035 DECL_NOT_REALLY_EXTERN (fn
) = 1;
1036 DECL_DECLARED_INLINE_P (fn
) = 1;
1037 DECL_INLINE (fn
) = 1;
1043 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1044 as there are artificial parms in FN. */
1047 skip_artificial_parms_for (fn
, list
)
1050 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1051 list
= TREE_CHAIN (list
);
1055 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
1056 list
= TREE_CHAIN (list
);
1057 if (DECL_HAS_VTT_PARM_P (fn
))
1058 list
= TREE_CHAIN (list
);