1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
5 modified by Brendan Kehoe (brendan@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 /* High-level class interface. */
29 #include "coretypes.h"
38 #include "diagnostic.h"
43 static tree build_field_call (tree, tree, tree);
44 static struct z_candidate * tourney (struct z_candidate *);
45 static int equal_functions (tree, tree);
46 static int joust (struct z_candidate *, struct z_candidate *, bool);
47 static int compare_ics (tree, tree);
48 static tree build_over_call (struct z_candidate *, int);
49 static tree build_java_interface_fn_ref (tree, tree);
50 #define convert_like(CONV, EXPR) \
51 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
52 /*issue_conversion_warnings=*/true)
53 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
54 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
55 /*issue_conversion_warnings=*/true)
56 static tree convert_like_real (tree, tree, tree, int, int, bool);
57 static void op_error (enum tree_code, enum tree_code, tree, tree,
59 static tree build_object_call (tree, tree);
60 static tree resolve_args (tree);
61 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
62 static void print_z_candidate (const char *, struct z_candidate *);
63 static void print_z_candidates (struct z_candidate *);
64 static tree build_this (tree);
65 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
66 static bool any_strictly_viable (struct z_candidate *);
67 static struct z_candidate *add_template_candidate
68 (struct z_candidate **, tree, tree, tree, tree, tree,
69 tree, tree, int, unification_kind_t);
70 static struct z_candidate *add_template_candidate_real
71 (struct z_candidate **, tree, tree, tree, tree, tree,
72 tree, tree, int, tree, unification_kind_t);
73 static struct z_candidate *add_template_conv_candidate
74 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
75 static void add_builtin_candidates
76 (struct z_candidate **, enum tree_code, enum tree_code,
78 static void add_builtin_candidate
79 (struct z_candidate **, enum tree_code, enum tree_code,
80 tree, tree, tree, tree *, tree *, int);
81 static bool is_complete (tree);
82 static void build_builtin_candidate
83 (struct z_candidate **, tree, tree, tree, tree *, tree *,
85 static struct z_candidate *add_conv_candidate
86 (struct z_candidate **, tree, tree, tree, tree, tree);
87 static struct z_candidate *add_function_candidate
88 (struct z_candidate **, tree, tree, tree, tree, tree, int);
89 static tree implicit_conversion (tree, tree, tree, int);
90 static tree standard_conversion (tree, tree, tree);
91 static tree reference_binding (tree, tree, tree, int);
92 static tree build_conv (enum tree_code, tree, tree);
93 static bool is_subseq (tree, tree);
94 static tree maybe_handle_ref_bind (tree *);
95 static void maybe_handle_implicit_object (tree *);
96 static struct z_candidate *add_candidate
97 (struct z_candidate **, tree, tree, tree, tree, tree, int);
98 static tree source_type (tree);
99 static void add_warning (struct z_candidate *, struct z_candidate *);
100 static bool reference_related_p (tree, tree);
101 static bool reference_compatible_p (tree, tree);
102 static tree convert_class_to_reference (tree, tree, tree);
103 static tree direct_reference_binding (tree, tree);
104 static bool promoted_arithmetic_type_p (tree);
105 static tree conditional_conversion (tree, tree);
106 static char *name_as_c_string (tree, tree, bool *);
107 static tree call_builtin_trap (tree);
108 static tree prep_operand (tree);
109 static void add_candidates (tree, tree, tree, bool, tree, tree,
110 int, struct z_candidate **);
111 static tree merge_conversion_sequences (tree, tree);
112 static bool magic_varargs_p (tree);
115 build_vfield_ref (tree datum, tree type)
117 if (datum == error_mark_node)
118 return error_mark_node;
120 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
121 datum = convert_from_reference (datum);
123 if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
124 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
125 datum = convert_to_base (datum, type, /*check_access=*/false);
127 return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
128 datum, TYPE_VFIELD (type));
131 /* Build a call to a member of an object. I.e., one that overloads
132 operator ()(), or is a pointer-to-function or pointer-to-method. */
135 build_field_call (tree instance_ptr, tree decl, tree parms)
139 if (decl == error_mark_node || decl == NULL_TREE)
142 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
144 /* If it's a field, try overloading operator (),
145 or calling if the field is a pointer-to-function. */
146 instance = build_indirect_ref (instance_ptr, NULL);
147 instance = build_class_member_access_expr (instance, decl,
148 /*access_path=*/NULL_TREE,
149 /*preserve_reference=*/false);
151 if (instance == error_mark_node)
152 return error_mark_node;
154 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
155 return build_new_op (CALL_EXPR, LOOKUP_NORMAL,
156 instance, parms, NULL_TREE);
157 else if (TREE_CODE (TREE_TYPE (instance)) == FUNCTION_TYPE
158 || (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE
159 && (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
161 return build_function_call (instance, parms);
167 /* Returns nonzero iff the destructor name specified in NAME
168 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
172 check_dtor_name (tree basetype, tree name)
174 name = TREE_OPERAND (name, 0);
176 /* Just accept something we've already complained about. */
177 if (name == error_mark_node)
180 if (TREE_CODE (name) == TYPE_DECL)
181 name = TREE_TYPE (name);
182 else if (TYPE_P (name))
184 else if (TREE_CODE (name) == IDENTIFIER_NODE)
186 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
187 || (TREE_CODE (basetype) == ENUMERAL_TYPE
188 && name == TYPE_IDENTIFIER (basetype)))
191 name = get_type_value (name);
195 template <class T> struct S { ~S(); };
199 NAME will be a class template. */
200 else if (DECL_CLASS_TEMPLATE_P (name))
205 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
210 /* We want the address of a function or method. We avoid creating a
211 pointer-to-member function. */
214 build_addr_func (tree function)
216 tree type = TREE_TYPE (function);
218 /* We have to do these by hand to avoid real pointer to member
220 if (TREE_CODE (type) == METHOD_TYPE)
222 if (TREE_CODE (function) == OFFSET_REF)
224 tree object = build_address (TREE_OPERAND (function, 0));
225 return get_member_function_from_ptrfunc (&object,
226 TREE_OPERAND (function, 1));
228 function = build_address (function);
231 function = decay_conversion (function);
236 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
237 POINTER_TYPE to those. Note, pointer to member function types
238 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
241 build_call (tree function, tree parms)
243 int is_constructor = 0;
250 function = build_addr_func (function);
252 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
254 sorry ("unable to call pointer to member function here");
255 return error_mark_node;
258 fntype = TREE_TYPE (TREE_TYPE (function));
259 result_type = TREE_TYPE (fntype);
261 if (TREE_CODE (function) == ADDR_EXPR
262 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
263 decl = TREE_OPERAND (function, 0);
267 /* We check both the decl and the type; a function may be known not to
268 throw without being declared throw(). */
269 nothrow = ((decl && TREE_NOTHROW (decl))
270 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
272 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
273 current_function_returns_abnormally = 1;
275 if (decl && TREE_DEPRECATED (decl))
276 warn_deprecated_use (decl);
277 require_complete_eh_spec_types (fntype, decl);
279 if (decl && DECL_CONSTRUCTOR_P (decl))
282 if (decl && ! TREE_USED (decl))
284 /* We invoke build_call directly for several library functions.
285 These may have been declared normally if we're building libgcc,
286 so we can't just check DECL_ARTIFICIAL. */
287 if (DECL_ARTIFICIAL (decl)
288 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
294 /* Don't pass empty class objects by value. This is useful
295 for tags in STL, which are used to control overload resolution.
296 We don't need to handle other cases of copying empty classes. */
297 if (! decl || ! DECL_BUILT_IN (decl))
298 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
299 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
300 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
302 tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
303 TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
304 TREE_VALUE (tmp), t);
307 function = build (CALL_EXPR, result_type, function, parms);
308 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
309 TREE_NOTHROW (function) = nothrow;
314 /* Build something of the form ptr->method (args)
315 or object.method (args). This can also build
316 calls to constructors, and find friends.
318 Member functions always take their class variable
321 INSTANCE is a class instance.
323 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
325 PARMS help to figure out what that NAME really refers to.
327 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
328 down to the real instance type to use for access checking. We need this
329 information to get protected accesses correct.
331 FLAGS is the logical disjunction of zero or more LOOKUP_
332 flags. See cp-tree.h for more info.
334 If this is all OK, calls build_function_call with the resolved
337 This function must also handle being called to perform
338 initialization, promotion/coercion of arguments, and
339 instantiation of default parameters.
341 Note that NAME may refer to an instance variable name. If
342 `operator()()' is defined for the type of that field, then we return
345 #ifdef GATHER_STATISTICS
346 extern int n_build_method_call;
350 build_method_call (tree instance, tree name, tree parms,
351 tree basetype_path, int flags)
355 tree template_args = NULL_TREE;
356 bool has_template_args = false;
358 #ifdef GATHER_STATISTICS
359 n_build_method_call++;
362 if (error_operand_p (instance)
363 || name == error_mark_node
364 || parms == error_mark_node)
365 return error_mark_node;
367 my_friendly_assert (!processing_template_decl, 20030707);
369 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
370 instance = convert_from_reference (instance);
371 object_type = TREE_TYPE (instance);
373 if (TREE_CODE (name) == BIT_NOT_EXPR)
378 error ("destructors take no parameters");
380 if (! check_dtor_name (object_type, name))
382 ("destructor name `~%T' does not match type `%T' of expression",
383 TREE_OPERAND (name, 0), object_type);
385 if (! TYPE_HAS_DESTRUCTOR (complete_type (object_type)))
386 return convert_to_void (instance, /*implicit=*/NULL);
387 instance = default_conversion (instance);
388 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
389 return build_delete (build_pointer_type (object_type),
390 instance_ptr, sfk_complete_destructor,
391 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
394 if (!CLASS_TYPE_P (object_type))
396 if ((flags & LOOKUP_COMPLAIN)
397 && TREE_TYPE (instance) != error_mark_node)
398 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
399 name, instance, object_type);
400 return error_mark_node;
403 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
405 template_args = TREE_OPERAND (name, 1);
406 has_template_args = true;
407 name = TREE_OPERAND (name, 0);
409 if (TREE_CODE (name) == OVERLOAD)
410 name = DECL_NAME (get_first_fn (name));
411 else if (DECL_P (name))
412 name = DECL_NAME (name);
413 if (has_template_args)
414 fn = lookup_fnfields (object_type, name, /*protect=*/2);
416 fn = lookup_member (object_type, name, /*protect=*/2, /*want_type=*/false);
418 if (fn && TREE_CODE (fn) == TREE_LIST)
420 error ("request for member `%D' is ambiguous", name);
421 print_candidates (fn);
422 return error_mark_node;
425 /* If the name could not be found, issue an error. */
427 return unqualified_name_lookup_error (name);
429 if (BASELINK_P (fn) && has_template_args)
430 BASELINK_FUNCTIONS (fn)
431 = build_nt (TEMPLATE_ID_EXPR,
432 BASELINK_FUNCTIONS (fn),
434 if (BASELINK_P (fn) && basetype_path)
435 BASELINK_ACCESS_BINFO (fn) = basetype_path;
437 return build_new_method_call (instance, fn, parms,
438 /*conversion_path=*/NULL_TREE, flags);
441 /* New overloading code. */
443 struct z_candidate GTY(()) {
444 /* The FUNCTION_DECL that will be called if this candidate is
445 selected by overload resolution. */
447 /* The arguments to use when calling this function. */
449 /* The implicit conversion sequences for each of the arguments to
452 /* If FN is a user-defined conversion, the standard conversion
453 sequence from the type returned by FN to the desired destination
457 /* If FN is a member function, the binfo indicating the path used to
458 qualify the name of FN at the call site. This path is used to
459 determine whether or not FN is accessible if it is selected by
460 overload resolution. The DECL_CONTEXT of FN will always be a
461 (possibly improper) base of this binfo. */
463 /* If FN is a non-static member function, the binfo indicating the
464 subobject to which the `this' pointer should be converted if FN
465 is selected by overload resolution. The type pointed to the by
466 the `this' pointer must correspond to the most derived class
467 indicated by the CONVERSION_PATH. */
468 tree conversion_path;
471 struct z_candidate *next;
474 #define IDENTITY_RANK 0
480 #define ELLIPSIS_RANK 6
483 #define ICS_RANK(NODE) \
484 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
485 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
486 : ICS_USER_FLAG (NODE) ? USER_RANK \
487 : ICS_STD_RANK (NODE))
489 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
491 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
492 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
493 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
494 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
496 /* In a REF_BIND or a BASE_CONV, this indicates that a temporary
497 should be created to hold the result of the conversion. */
498 #define NEED_TEMPORARY_P(NODE) TREE_LANG_FLAG_4 (NODE)
500 /* TRUE in an IDENTITY_CONV or BASE_CONV if the copy constructor must
501 be accessible, even though it is not being used. */
502 #define CHECK_COPY_CONSTRUCTOR_P(NODE) TREE_LANG_FLAG_5 (NODE)
504 #define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1))
505 #define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
508 null_ptr_cst_p (tree t)
512 A null pointer constant is an integral constant expression
513 (_expr.const_) rvalue of integer type that evaluates to zero. */
515 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
521 /* Returns nonzero if PARMLIST consists of only default parms and/or
525 sufficient_parms_p (tree parmlist)
527 for (; parmlist && parmlist != void_list_node;
528 parmlist = TREE_CHAIN (parmlist))
529 if (!TREE_PURPOSE (parmlist))
535 build_conv (enum tree_code code, tree type, tree from)
538 int rank = ICS_STD_RANK (from);
540 /* We can't use buildl1 here because CODE could be USER_CONV, which
541 takes two arguments. In that case, the caller is responsible for
542 filling in the second argument. */
543 t = make_node (code);
544 TREE_TYPE (t) = type;
545 TREE_OPERAND (t, 0) = from;
558 if (rank < EXACT_RANK)
564 ICS_STD_RANK (t) = rank;
565 ICS_USER_FLAG (t) = (code == USER_CONV || ICS_USER_FLAG (from));
566 ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);
571 strip_top_quals (tree t)
573 if (TREE_CODE (t) == ARRAY_TYPE)
575 return cp_build_qualified_type (t, 0);
578 /* Returns the standard conversion path (see [conv]) from type FROM to type
579 TO, if any. For proper handling of null pointer constants, you must
580 also pass the expression EXPR to convert from. */
583 standard_conversion (tree to, tree from, tree expr)
585 enum tree_code fcode, tcode;
587 bool fromref = false;
589 to = non_reference (to);
590 if (TREE_CODE (from) == REFERENCE_TYPE)
593 from = TREE_TYPE (from);
595 to = strip_top_quals (to);
596 from = strip_top_quals (from);
598 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
599 && expr && type_unknown_p (expr))
601 expr = instantiate_type (to, expr, tf_conv);
602 if (expr == error_mark_node)
604 from = TREE_TYPE (expr);
607 fcode = TREE_CODE (from);
608 tcode = TREE_CODE (to);
610 conv = build1 (IDENTITY_CONV, from, expr);
612 if (fcode == FUNCTION_TYPE)
614 from = build_pointer_type (from);
615 fcode = TREE_CODE (from);
616 conv = build_conv (LVALUE_CONV, from, conv);
618 else if (fcode == ARRAY_TYPE)
620 from = build_pointer_type (TREE_TYPE (from));
621 fcode = TREE_CODE (from);
622 conv = build_conv (LVALUE_CONV, from, conv);
624 else if (fromref || (expr && lvalue_p (expr)))
625 conv = build_conv (RVALUE_CONV, from, conv);
627 /* Allow conversion between `__complex__' data types. */
628 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
630 /* The standard conversion sequence to convert FROM to TO is
631 the standard conversion sequence to perform componentwise
633 tree part_conv = standard_conversion
634 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
638 conv = build_conv (TREE_CODE (part_conv), to, conv);
639 ICS_STD_RANK (conv) = ICS_STD_RANK (part_conv);
647 if (same_type_p (from, to))
650 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
651 && expr && null_ptr_cst_p (expr))
652 conv = build_conv (STD_CONV, to, conv);
653 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE
654 && TREE_CODE (TREE_TYPE (to)) == VECTOR_TYPE
655 && TREE_CODE (TREE_TYPE (from)) == VECTOR_TYPE
656 && ((*targetm.vector_opaque_p) (TREE_TYPE (to))
657 || (*targetm.vector_opaque_p) (TREE_TYPE (from))))
658 conv = build_conv (STD_CONV, to, conv);
659 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
660 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
662 /* For backwards brain damage compatibility, allow interconversion of
663 pointers and integers with a pedwarn. */
664 conv = build_conv (STD_CONV, to, conv);
665 ICS_BAD_FLAG (conv) = 1;
667 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
669 /* For backwards brain damage compatibility, allow interconversion of
670 enums and integers with a pedwarn. */
671 conv = build_conv (STD_CONV, to, conv);
672 ICS_BAD_FLAG (conv) = 1;
674 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
675 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
680 if (tcode == POINTER_TYPE
681 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
684 else if (VOID_TYPE_P (TREE_TYPE (to))
685 && !TYPE_PTRMEM_P (from)
686 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
688 from = build_pointer_type
689 (cp_build_qualified_type (void_type_node,
690 cp_type_quals (TREE_TYPE (from))));
691 conv = build_conv (PTR_CONV, from, conv);
693 else if (TYPE_PTRMEM_P (from))
695 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
696 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
698 if (DERIVED_FROM_P (fbase, tbase)
699 && (same_type_ignoring_top_level_qualifiers_p
700 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
701 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
703 from = build_ptrmem_type (tbase,
704 TYPE_PTRMEM_POINTED_TO_TYPE (from));
705 conv = build_conv (PMEM_CONV, from, conv);
708 else if (IS_AGGR_TYPE (TREE_TYPE (from))
709 && IS_AGGR_TYPE (TREE_TYPE (to))
712 An rvalue of type "pointer to cv D," where D is a
713 class type, can be converted to an rvalue of type
714 "pointer to cv B," where B is a base class (clause
715 _class.derived_) of D. If B is an inaccessible
716 (clause _class.access_) or ambiguous
717 (_class.member.lookup_) base class of D, a program
718 that necessitates this conversion is ill-formed. */
719 /* Therefore, we use DERIVED_FROM_P, and not
720 ACESSIBLY_UNIQUELY_DERIVED_FROM_P, in this test. */
721 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
724 cp_build_qualified_type (TREE_TYPE (to),
725 cp_type_quals (TREE_TYPE (from)));
726 from = build_pointer_type (from);
727 conv = build_conv (PTR_CONV, from, conv);
730 if (tcode == POINTER_TYPE)
732 to_pointee = TREE_TYPE (to);
733 from_pointee = TREE_TYPE (from);
737 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
738 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
741 if (same_type_p (from, to))
743 else if (comp_ptr_ttypes (to_pointee, from_pointee))
744 conv = build_conv (QUAL_CONV, to, conv);
745 else if (expr && string_conv_p (to, expr, 0))
746 /* converting from string constant to char *. */
747 conv = build_conv (QUAL_CONV, to, conv);
748 else if (ptr_reasonably_similar (to_pointee, from_pointee))
750 conv = build_conv (PTR_CONV, to, conv);
751 ICS_BAD_FLAG (conv) = 1;
758 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
760 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
761 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
762 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
763 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
765 if (!DERIVED_FROM_P (fbase, tbase)
766 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
767 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
768 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
769 || cp_type_quals (fbase) != cp_type_quals (tbase))
772 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
773 from = build_method_type_directly (from,
775 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
776 from = build_ptrmemfunc_type (build_pointer_type (from));
777 conv = build_conv (PMEM_CONV, from, conv);
779 else if (tcode == BOOLEAN_TYPE)
783 An rvalue of arithmetic, enumeration, pointer, or pointer to
784 member type can be converted to an rvalue of type bool. */
785 if (ARITHMETIC_TYPE_P (from)
786 || fcode == ENUMERAL_TYPE
787 || fcode == POINTER_TYPE
788 || TYPE_PTR_TO_MEMBER_P (from))
790 conv = build_conv (STD_CONV, to, conv);
791 if (fcode == POINTER_TYPE
792 || TYPE_PTRMEM_P (from)
793 || (TYPE_PTRMEMFUNC_P (from)
794 && ICS_STD_RANK (conv) < PBOOL_RANK))
795 ICS_STD_RANK (conv) = PBOOL_RANK;
801 /* We don't check for ENUMERAL_TYPE here because there are no standard
802 conversions to enum type. */
803 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
804 || tcode == REAL_TYPE)
806 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
808 conv = build_conv (STD_CONV, to, conv);
810 /* Give this a better rank if it's a promotion. */
811 if (same_type_p (to, type_promotes_to (from))
812 && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK)
813 ICS_STD_RANK (conv) = PROMO_RANK;
815 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
816 && ((*targetm.vector_opaque_p) (from)
817 || (*targetm.vector_opaque_p) (to)))
818 return build_conv (STD_CONV, to, conv);
819 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
820 && is_properly_derived_from (from, to))
822 if (TREE_CODE (conv) == RVALUE_CONV)
823 conv = TREE_OPERAND (conv, 0);
824 conv = build_conv (BASE_CONV, to, conv);
825 /* The derived-to-base conversion indicates the initialization
826 of a parameter with base type from an object of a derived
827 type. A temporary object is created to hold the result of
829 NEED_TEMPORARY_P (conv) = 1;
837 /* Returns nonzero if T1 is reference-related to T2. */
840 reference_related_p (tree t1, tree t2)
842 t1 = TYPE_MAIN_VARIANT (t1);
843 t2 = TYPE_MAIN_VARIANT (t2);
847 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
848 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
850 return (same_type_p (t1, t2)
851 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
852 && DERIVED_FROM_P (t1, t2)));
855 /* Returns nonzero if T1 is reference-compatible with T2. */
858 reference_compatible_p (tree t1, tree t2)
862 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
863 reference-related to T2 and cv1 is the same cv-qualification as,
864 or greater cv-qualification than, cv2. */
865 return (reference_related_p (t1, t2)
866 && at_least_as_qualified_p (t1, t2));
869 /* Determine whether or not the EXPR (of class type S) can be
870 converted to T as in [over.match.ref]. */
873 convert_class_to_reference (tree t, tree s, tree expr)
879 struct z_candidate *candidates;
880 struct z_candidate *cand;
883 conversions = lookup_conversions (s);
889 Assuming that "cv1 T" is the underlying type of the reference
890 being initialized, and "cv S" is the type of the initializer
891 expression, with S a class type, the candidate functions are
894 --The conversion functions of S and its base classes are
895 considered. Those that are not hidden within S and yield type
896 "reference to cv2 T2", where "cv1 T" is reference-compatible
897 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
899 The argument list has one argument, which is the initializer
904 /* Conceptually, we should take the address of EXPR and put it in
905 the argument list. Unfortunately, however, that can result in
906 error messages, which we should not issue now because we are just
907 trying to find a conversion operator. Therefore, we use NULL,
908 cast to the appropriate type. */
909 arglist = build_int_2 (0, 0);
910 TREE_TYPE (arglist) = build_pointer_type (s);
911 arglist = build_tree_list (NULL_TREE, arglist);
913 reference_type = build_reference_type (t);
917 tree fns = TREE_VALUE (conversions);
919 for (; fns; fns = OVL_NEXT (fns))
921 tree f = OVL_CURRENT (fns);
922 tree t2 = TREE_TYPE (TREE_TYPE (f));
926 /* If this is a template function, try to get an exact
928 if (TREE_CODE (f) == TEMPLATE_DECL)
930 cand = add_template_candidate (&candidates,
936 TREE_PURPOSE (conversions),
942 /* Now, see if the conversion function really returns
943 an lvalue of the appropriate type. From the
944 point of view of unification, simply returning an
945 rvalue of the right type is good enough. */
947 t2 = TREE_TYPE (TREE_TYPE (f));
948 if (TREE_CODE (t2) != REFERENCE_TYPE
949 || !reference_compatible_p (t, TREE_TYPE (t2)))
951 candidates = candidates->next;
956 else if (TREE_CODE (t2) == REFERENCE_TYPE
957 && reference_compatible_p (t, TREE_TYPE (t2)))
958 cand = add_function_candidate (&candidates, f, s, arglist,
960 TREE_PURPOSE (conversions),
964 /* Build a standard conversion sequence indicating the
965 binding from the reference type returned by the
966 function to the desired REFERENCE_TYPE. */
968 = (direct_reference_binding
970 build1 (IDENTITY_CONV,
971 TREE_TYPE (TREE_TYPE (TREE_TYPE (cand->fn))),
974 conversions = TREE_CHAIN (conversions);
977 candidates = splice_viable (candidates, pedantic, &any_viable_p);
978 /* If none of the conversion functions worked out, let our caller
983 cand = tourney (candidates);
987 /* Now that we know that this is the function we're going to use fix
988 the dummy first argument. */
989 cand->args = tree_cons (NULL_TREE,
991 TREE_CHAIN (cand->args));
993 /* Build a user-defined conversion sequence representing the
995 conv = build_conv (USER_CONV,
996 TREE_TYPE (TREE_TYPE (cand->fn)),
997 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
998 TREE_OPERAND (conv, 1) = build_zc_wrapper (cand);
1000 /* Merge it with the standard conversion sequence from the
1001 conversion function's return type to the desired type. */
1002 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1004 if (cand->viable == -1)
1005 ICS_BAD_FLAG (conv) = 1;
1007 return cand->second_conv;
1010 /* A reference of the indicated TYPE is being bound directly to the
1011 expression represented by the implicit conversion sequence CONV.
1012 Return a conversion sequence for this binding. */
1015 direct_reference_binding (tree type, tree conv)
1019 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
1020 my_friendly_assert (TREE_CODE (TREE_TYPE (conv)) != REFERENCE_TYPE,
1023 t = TREE_TYPE (type);
1027 When a parameter of reference type binds directly
1028 (_dcl.init.ref_) to an argument expression, the implicit
1029 conversion sequence is the identity conversion, unless the
1030 argument expression has a type that is a derived class of the
1031 parameter type, in which case the implicit conversion sequence is
1032 a derived-to-base Conversion.
1034 If the parameter binds directly to the result of applying a
1035 conversion function to the argument expression, the implicit
1036 conversion sequence is a user-defined conversion sequence
1037 (_over.ics.user_), with the second standard conversion sequence
1038 either an identity conversion or, if the conversion function
1039 returns an entity of a type that is a derived class of the
1040 parameter type, a derived-to-base conversion. */
1041 if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv)))
1043 /* Represent the derived-to-base conversion. */
1044 conv = build_conv (BASE_CONV, t, conv);
1045 /* We will actually be binding to the base-class subobject in
1046 the derived class, so we mark this conversion appropriately.
1047 That way, convert_like knows not to generate a temporary. */
1048 NEED_TEMPORARY_P (conv) = 0;
1050 return build_conv (REF_BIND, type, conv);
1053 /* Returns the conversion path from type FROM to reference type TO for
1054 purposes of reference binding. For lvalue binding, either pass a
1055 reference type to FROM or an lvalue expression to EXPR. If the
1056 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1057 the conversion returned. */
1060 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1062 tree conv = NULL_TREE;
1063 tree to = TREE_TYPE (rto);
1067 cp_lvalue_kind lvalue_p = clk_none;
1069 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1071 expr = instantiate_type (to, expr, tf_none);
1072 if (expr == error_mark_node)
1074 from = TREE_TYPE (expr);
1077 if (TREE_CODE (from) == REFERENCE_TYPE)
1079 /* Anything with reference type is an lvalue. */
1080 lvalue_p = clk_ordinary;
1081 from = TREE_TYPE (from);
1084 lvalue_p = real_lvalue_p (expr);
1086 /* Figure out whether or not the types are reference-related and
1087 reference compatible. We have do do this after stripping
1088 references from FROM. */
1089 related_p = reference_related_p (to, from);
1090 compatible_p = reference_compatible_p (to, from);
1092 if (lvalue_p && compatible_p)
1096 If the initializer expression
1098 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1099 is reference-compatible with "cv2 T2,"
1101 the reference is bound directly to the initializer expression
1103 conv = build1 (IDENTITY_CONV, from, expr);
1104 conv = direct_reference_binding (rto, conv);
1105 if ((lvalue_p & clk_bitfield) != 0
1106 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1107 /* For the purposes of overload resolution, we ignore the fact
1108 this expression is a bitfield or packed field. (In particular,
1109 [over.ics.ref] says specifically that a function with a
1110 non-const reference parameter is viable even if the
1111 argument is a bitfield.)
1113 However, when we actually call the function we must create
1114 a temporary to which to bind the reference. If the
1115 reference is volatile, or isn't const, then we cannot make
1116 a temporary, so we just issue an error when the conversion
1118 NEED_TEMPORARY_P (conv) = 1;
1122 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1126 If the initializer expression
1128 -- has a class type (i.e., T2 is a class type) can be
1129 implicitly converted to an lvalue of type "cv3 T3," where
1130 "cv1 T1" is reference-compatible with "cv3 T3". (this
1131 conversion is selected by enumerating the applicable
1132 conversion functions (_over.match.ref_) and choosing the
1133 best one through overload resolution. (_over.match_).
1135 the reference is bound to the lvalue result of the conversion
1136 in the second case. */
1137 conv = convert_class_to_reference (to, from, expr);
1142 /* From this point on, we conceptually need temporaries, even if we
1143 elide them. Only the cases above are "direct bindings". */
1144 if (flags & LOOKUP_NO_TEMP_BIND)
1149 When a parameter of reference type is not bound directly to an
1150 argument expression, the conversion sequence is the one required
1151 to convert the argument expression to the underlying type of the
1152 reference according to _over.best.ics_. Conceptually, this
1153 conversion sequence corresponds to copy-initializing a temporary
1154 of the underlying type with the argument expression. Any
1155 difference in top-level cv-qualification is subsumed by the
1156 initialization itself and does not constitute a conversion. */
1160 Otherwise, the reference shall be to a non-volatile const type. */
1161 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1166 If the initializer expression is an rvalue, with T2 a class type,
1167 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1168 is bound in one of the following ways:
1170 -- The reference is bound to the object represented by the rvalue
1171 or to a sub-object within that object.
1175 We use the first alternative. The implicit conversion sequence
1176 is supposed to be same as we would obtain by generating a
1177 temporary. Fortunately, if the types are reference compatible,
1178 then this is either an identity conversion or the derived-to-base
1179 conversion, just as for direct binding. */
1180 if (CLASS_TYPE_P (from) && compatible_p)
1182 conv = build1 (IDENTITY_CONV, from, expr);
1183 conv = direct_reference_binding (rto, conv);
1184 CHECK_COPY_CONSTRUCTOR_P (TREE_OPERAND (conv, 0)) = 1;
1190 Otherwise, a temporary of type "cv1 T1" is created and
1191 initialized from the initializer expression using the rules for a
1192 non-reference copy initialization. If T1 is reference-related to
1193 T2, cv1 must be the same cv-qualification as, or greater
1194 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1195 if (related_p && !at_least_as_qualified_p (to, from))
1198 conv = implicit_conversion (to, from, expr, flags);
1202 conv = build_conv (REF_BIND, rto, conv);
1203 /* This reference binding, unlike those above, requires the
1204 creation of a temporary. */
1205 NEED_TEMPORARY_P (conv) = 1;
1210 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1211 to type TO. The optional expression EXPR may affect the conversion.
1212 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1216 implicit_conversion (tree to, tree from, tree expr, int flags)
1220 if (from == error_mark_node || to == error_mark_node
1221 || expr == error_mark_node)
1224 if (TREE_CODE (to) == REFERENCE_TYPE)
1225 conv = reference_binding (to, from, expr, flags);
1227 conv = standard_conversion (to, from, expr);
1232 if (expr != NULL_TREE
1233 && (IS_AGGR_TYPE (from)
1234 || IS_AGGR_TYPE (to))
1235 && (flags & LOOKUP_NO_CONVERSION) == 0)
1237 struct z_candidate *cand;
1239 cand = build_user_type_conversion_1
1240 (to, expr, LOOKUP_ONLYCONVERTING);
1242 conv = cand->second_conv;
1244 /* We used to try to bind a reference to a temporary here, but that
1245 is now handled by the recursive call to this function at the end
1246 of reference_binding. */
1253 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1256 static struct z_candidate *
1257 add_candidate (struct z_candidate **candidates,
1258 tree fn, tree args, tree convs, tree access_path,
1259 tree conversion_path, int viable)
1261 struct z_candidate *cand = ggc_alloc_cleared (sizeof (struct z_candidate));
1265 cand->convs = convs;
1266 cand->access_path = access_path;
1267 cand->conversion_path = conversion_path;
1268 cand->viable = viable;
1269 cand->next = *candidates;
1275 /* Create an overload candidate for the function or method FN called with
1276 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1277 to implicit_conversion.
1279 CTYPE, if non-NULL, is the type we want to pretend this function
1280 comes from for purposes of overload resolution. */
1282 static struct z_candidate *
1283 add_function_candidate (struct z_candidate **candidates,
1284 tree fn, tree ctype, tree arglist,
1285 tree access_path, tree conversion_path,
1288 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1291 tree parmnode, argnode;
1295 /* Built-in functions that haven't been declared don't really
1297 if (DECL_ANTICIPATED (fn))
1300 /* The `this', `in_chrg' and VTT arguments to constructors are not
1301 considered in overload resolution. */
1302 if (DECL_CONSTRUCTOR_P (fn))
1304 parmlist = skip_artificial_parms_for (fn, parmlist);
1305 orig_arglist = arglist;
1306 arglist = skip_artificial_parms_for (fn, arglist);
1309 orig_arglist = arglist;
1311 len = list_length (arglist);
1312 convs = make_tree_vec (len);
1314 /* 13.3.2 - Viable functions [over.match.viable]
1315 First, to be a viable function, a candidate function shall have enough
1316 parameters to agree in number with the arguments in the list.
1318 We need to check this first; otherwise, checking the ICSes might cause
1319 us to produce an ill-formed template instantiation. */
1321 parmnode = parmlist;
1322 for (i = 0; i < len; ++i)
1324 if (parmnode == NULL_TREE || parmnode == void_list_node)
1326 parmnode = TREE_CHAIN (parmnode);
1329 if (i < len && parmnode)
1332 /* Make sure there are default args for the rest of the parms. */
1333 else if (!sufficient_parms_p (parmnode))
1339 /* Second, for F to be a viable function, there shall exist for each
1340 argument an implicit conversion sequence that converts that argument
1341 to the corresponding parameter of F. */
1343 parmnode = parmlist;
1346 for (i = 0; i < len; ++i)
1348 tree arg = TREE_VALUE (argnode);
1349 tree argtype = lvalue_type (arg);
1353 if (parmnode == void_list_node)
1356 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1357 && ! DECL_CONSTRUCTOR_P (fn));
1361 tree parmtype = TREE_VALUE (parmnode);
1363 /* The type of the implicit object parameter ('this') for
1364 overload resolution is not always the same as for the
1365 function itself; conversion functions are considered to
1366 be members of the class being converted, and functions
1367 introduced by a using-declaration are considered to be
1368 members of the class that uses them.
1370 Since build_over_call ignores the ICS for the `this'
1371 parameter, we can just change the parm type. */
1372 if (ctype && is_this)
1375 = build_qualified_type (ctype,
1376 TYPE_QUALS (TREE_TYPE (parmtype)));
1377 parmtype = build_pointer_type (parmtype);
1380 t = implicit_conversion (parmtype, argtype, arg, flags);
1384 t = build1 (IDENTITY_CONV, argtype, arg);
1385 ICS_ELLIPSIS_FLAG (t) = 1;
1389 ICS_THIS_FLAG (t) = 1;
1391 TREE_VEC_ELT (convs, i) = t;
1398 if (ICS_BAD_FLAG (t))
1402 parmnode = TREE_CHAIN (parmnode);
1403 argnode = TREE_CHAIN (argnode);
1407 return add_candidate (candidates, fn, orig_arglist, convs, access_path,
1408 conversion_path, viable);
1411 /* Create an overload candidate for the conversion function FN which will
1412 be invoked for expression OBJ, producing a pointer-to-function which
1413 will in turn be called with the argument list ARGLIST, and add it to
1414 CANDIDATES. FLAGS is passed on to implicit_conversion.
1416 Actually, we don't really care about FN; we care about the type it
1417 converts to. There may be multiple conversion functions that will
1418 convert to that type, and we rely on build_user_type_conversion_1 to
1419 choose the best one; so when we create our candidate, we record the type
1420 instead of the function. */
1422 static struct z_candidate *
1423 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1424 tree arglist, tree access_path, tree conversion_path)
1426 tree totype = TREE_TYPE (TREE_TYPE (fn));
1427 int i, len, viable, flags;
1428 tree parmlist, convs, parmnode, argnode;
1430 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1431 parmlist = TREE_TYPE (parmlist);
1432 parmlist = TYPE_ARG_TYPES (parmlist);
1434 len = list_length (arglist) + 1;
1435 convs = make_tree_vec (len);
1436 parmnode = parmlist;
1439 flags = LOOKUP_NORMAL;
1441 /* Don't bother looking up the same type twice. */
1442 if (*candidates && (*candidates)->fn == totype)
1445 for (i = 0; i < len; ++i)
1447 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1448 tree argtype = lvalue_type (arg);
1452 t = implicit_conversion (totype, argtype, arg, flags);
1453 else if (parmnode == void_list_node)
1456 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1459 t = build1 (IDENTITY_CONV, argtype, arg);
1460 ICS_ELLIPSIS_FLAG (t) = 1;
1463 TREE_VEC_ELT (convs, i) = t;
1467 if (ICS_BAD_FLAG (t))
1474 parmnode = TREE_CHAIN (parmnode);
1475 argnode = TREE_CHAIN (argnode);
1481 if (!sufficient_parms_p (parmnode))
1484 return add_candidate (candidates, totype, arglist, convs, access_path,
1485 conversion_path, viable);
1489 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1490 tree type1, tree type2, tree *args, tree *argtypes,
1500 convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
1502 for (i = 0; i < 2; ++i)
1507 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1511 /* We need something for printing the candidate. */
1512 t = build1 (IDENTITY_CONV, types[i], NULL_TREE);
1514 else if (ICS_BAD_FLAG (t))
1516 TREE_VEC_ELT (convs, i) = t;
1519 /* For COND_EXPR we rearranged the arguments; undo that now. */
1522 TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1);
1523 TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0);
1524 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1526 TREE_VEC_ELT (convs, 0) = t;
1531 add_candidate (candidates, fnname, /*args=*/NULL_TREE, convs,
1532 /*access_path=*/NULL_TREE,
1533 /*conversion_path=*/NULL_TREE,
1538 is_complete (tree t)
1540 return COMPLETE_TYPE_P (complete_type (t));
1543 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1546 promoted_arithmetic_type_p (tree type)
1550 In this section, the term promoted integral type is used to refer
1551 to those integral types which are preserved by integral promotion
1552 (including e.g. int and long but excluding e.g. char).
1553 Similarly, the term promoted arithmetic type refers to promoted
1554 integral types plus floating types. */
1555 return ((INTEGRAL_TYPE_P (type)
1556 && same_type_p (type_promotes_to (type), type))
1557 || TREE_CODE (type) == REAL_TYPE);
1560 /* Create any builtin operator overload candidates for the operator in
1561 question given the converted operand types TYPE1 and TYPE2. The other
1562 args are passed through from add_builtin_candidates to
1563 build_builtin_candidate.
1565 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1566 If CODE is requires candidates operands of the same type of the kind
1567 of which TYPE1 and TYPE2 are, we add both candidates
1568 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1571 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1572 enum tree_code code2, tree fnname, tree type1,
1573 tree type2, tree *args, tree *argtypes, int flags)
1577 case POSTINCREMENT_EXPR:
1578 case POSTDECREMENT_EXPR:
1579 args[1] = integer_zero_node;
1580 type2 = integer_type_node;
1589 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1590 and VQ is either volatile or empty, there exist candidate operator
1591 functions of the form
1592 VQ T& operator++(VQ T&);
1593 T operator++(VQ T&, int);
1594 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1595 type other than bool, and VQ is either volatile or empty, there exist
1596 candidate operator functions of the form
1597 VQ T& operator--(VQ T&);
1598 T operator--(VQ T&, int);
1599 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1600 complete object type, and VQ is either volatile or empty, there exist
1601 candidate operator functions of the form
1602 T*VQ& operator++(T*VQ&);
1603 T*VQ& operator--(T*VQ&);
1604 T* operator++(T*VQ&, int);
1605 T* operator--(T*VQ&, int); */
1607 case POSTDECREMENT_EXPR:
1608 case PREDECREMENT_EXPR:
1609 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1611 case POSTINCREMENT_EXPR:
1612 case PREINCREMENT_EXPR:
1613 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1615 type1 = build_reference_type (type1);
1620 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1621 exist candidate operator functions of the form
1625 8 For every function type T, there exist candidate operator functions of
1627 T& operator*(T*); */
1630 if (TREE_CODE (type1) == POINTER_TYPE
1631 && (TYPE_PTROB_P (type1)
1632 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1636 /* 9 For every type T, there exist candidate operator functions of the form
1639 10For every promoted arithmetic type T, there exist candidate operator
1640 functions of the form
1644 case CONVERT_EXPR: /* unary + */
1645 if (TREE_CODE (type1) == POINTER_TYPE)
1648 if (ARITHMETIC_TYPE_P (type1))
1652 /* 11For every promoted integral type T, there exist candidate operator
1653 functions of the form
1657 if (INTEGRAL_TYPE_P (type1))
1661 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1662 is the same type as C2 or is a derived class of C2, T is a complete
1663 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1664 there exist candidate operator functions of the form
1665 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1666 where CV12 is the union of CV1 and CV2. */
1669 if (TREE_CODE (type1) == POINTER_TYPE
1670 && TYPE_PTR_TO_MEMBER_P (type2))
1672 tree c1 = TREE_TYPE (type1);
1673 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1675 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1676 && (TYPE_PTRMEMFUNC_P (type2)
1677 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1682 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1683 didate operator functions of the form
1688 bool operator<(L, R);
1689 bool operator>(L, R);
1690 bool operator<=(L, R);
1691 bool operator>=(L, R);
1692 bool operator==(L, R);
1693 bool operator!=(L, R);
1694 where LR is the result of the usual arithmetic conversions between
1697 14For every pair of types T and I, where T is a cv-qualified or cv-
1698 unqualified complete object type and I is a promoted integral type,
1699 there exist candidate operator functions of the form
1700 T* operator+(T*, I);
1701 T& operator[](T*, I);
1702 T* operator-(T*, I);
1703 T* operator+(I, T*);
1704 T& operator[](I, T*);
1706 15For every T, where T is a pointer to complete object type, there exist
1707 candidate operator functions of the form112)
1708 ptrdiff_t operator-(T, T);
1710 16For every pointer or enumeration type T, there exist candidate operator
1711 functions of the form
1712 bool operator<(T, T);
1713 bool operator>(T, T);
1714 bool operator<=(T, T);
1715 bool operator>=(T, T);
1716 bool operator==(T, T);
1717 bool operator!=(T, T);
1719 17For every pointer to member type T, there exist candidate operator
1720 functions of the form
1721 bool operator==(T, T);
1722 bool operator!=(T, T); */
1725 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1727 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1729 type2 = ptrdiff_type_node;
1733 case TRUNC_DIV_EXPR:
1734 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1740 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1741 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1743 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1748 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1760 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1762 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1764 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1766 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1771 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1779 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1782 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1784 type1 = ptrdiff_type_node;
1787 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1789 type2 = ptrdiff_type_node;
1794 /* 18For every pair of promoted integral types L and R, there exist candi-
1795 date operator functions of the form
1802 where LR is the result of the usual arithmetic conversions between
1805 case TRUNC_MOD_EXPR:
1811 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1815 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1816 type, VQ is either volatile or empty, and R is a promoted arithmetic
1817 type, there exist candidate operator functions of the form
1818 VQ L& operator=(VQ L&, R);
1819 VQ L& operator*=(VQ L&, R);
1820 VQ L& operator/=(VQ L&, R);
1821 VQ L& operator+=(VQ L&, R);
1822 VQ L& operator-=(VQ L&, R);
1824 20For every pair T, VQ), where T is any type and VQ is either volatile
1825 or empty, there exist candidate operator functions of the form
1826 T*VQ& operator=(T*VQ&, T*);
1828 21For every pair T, VQ), where T is a pointer to member type and VQ is
1829 either volatile or empty, there exist candidate operator functions of
1831 VQ T& operator=(VQ T&, T);
1833 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1834 unqualified complete object type, VQ is either volatile or empty, and
1835 I is a promoted integral type, there exist candidate operator func-
1837 T*VQ& operator+=(T*VQ&, I);
1838 T*VQ& operator-=(T*VQ&, I);
1840 23For every triple L, VQ, R), where L is an integral or enumeration
1841 type, VQ is either volatile or empty, and R is a promoted integral
1842 type, there exist candidate operator functions of the form
1844 VQ L& operator%=(VQ L&, R);
1845 VQ L& operator<<=(VQ L&, R);
1846 VQ L& operator>>=(VQ L&, R);
1847 VQ L& operator&=(VQ L&, R);
1848 VQ L& operator^=(VQ L&, R);
1849 VQ L& operator|=(VQ L&, R); */
1856 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1858 type2 = ptrdiff_type_node;
1862 case TRUNC_DIV_EXPR:
1863 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1867 case TRUNC_MOD_EXPR:
1873 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1878 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1880 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1881 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1882 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1883 || ((TYPE_PTRMEMFUNC_P (type1)
1884 || TREE_CODE (type1) == POINTER_TYPE)
1885 && null_ptr_cst_p (args[1])))
1895 type1 = build_reference_type (type1);
1901 For every pair of promoted arithmetic types L and R, there
1902 exist candidate operator functions of the form
1904 LR operator?(bool, L, R);
1906 where LR is the result of the usual arithmetic conversions
1907 between types L and R.
1909 For every type T, where T is a pointer or pointer-to-member
1910 type, there exist candidate operator functions of the form T
1911 operator?(bool, T, T); */
1913 if (promoted_arithmetic_type_p (type1)
1914 && promoted_arithmetic_type_p (type2))
1918 /* Otherwise, the types should be pointers. */
1919 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1920 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1923 /* We don't check that the two types are the same; the logic
1924 below will actually create two candidates; one in which both
1925 parameter types are TYPE1, and one in which both parameter
1933 /* If we're dealing with two pointer types or two enumeral types,
1934 we need candidates for both of them. */
1935 if (type2 && !same_type_p (type1, type2)
1936 && TREE_CODE (type1) == TREE_CODE (type2)
1937 && (TREE_CODE (type1) == REFERENCE_TYPE
1938 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1939 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1940 || TYPE_PTRMEMFUNC_P (type1)
1941 || IS_AGGR_TYPE (type1)
1942 || TREE_CODE (type1) == ENUMERAL_TYPE))
1944 build_builtin_candidate
1945 (candidates, fnname, type1, type1, args, argtypes, flags);
1946 build_builtin_candidate
1947 (candidates, fnname, type2, type2, args, argtypes, flags);
1951 build_builtin_candidate
1952 (candidates, fnname, type1, type2, args, argtypes, flags);
1956 type_decays_to (tree type)
1958 if (TREE_CODE (type) == ARRAY_TYPE)
1959 return build_pointer_type (TREE_TYPE (type));
1960 if (TREE_CODE (type) == FUNCTION_TYPE)
1961 return build_pointer_type (type);
1965 /* There are three conditions of builtin candidates:
1967 1) bool-taking candidates. These are the same regardless of the input.
1968 2) pointer-pair taking candidates. These are generated for each type
1969 one of the input types converts to.
1970 3) arithmetic candidates. According to the standard, we should generate
1971 all of these, but I'm trying not to...
1973 Here we generate a superset of the possible candidates for this particular
1974 case. That is a subset of the full set the standard defines, plus some
1975 other cases which the standard disallows. add_builtin_candidate will
1976 filter out the invalid set. */
1979 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
1980 enum tree_code code2, tree fnname, tree *args,
1985 tree type, argtypes[3];
1986 /* TYPES[i] is the set of possible builtin-operator parameter types
1987 we will consider for the Ith argument. These are represented as
1988 a TREE_LIST; the TREE_VALUE of each node is the potential
1992 for (i = 0; i < 3; ++i)
1995 argtypes[i] = lvalue_type (args[i]);
1997 argtypes[i] = NULL_TREE;
2002 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2003 and VQ is either volatile or empty, there exist candidate operator
2004 functions of the form
2005 VQ T& operator++(VQ T&); */
2007 case POSTINCREMENT_EXPR:
2008 case PREINCREMENT_EXPR:
2009 case POSTDECREMENT_EXPR:
2010 case PREDECREMENT_EXPR:
2015 /* 24There also exist candidate operator functions of the form
2016 bool operator!(bool);
2017 bool operator&&(bool, bool);
2018 bool operator||(bool, bool); */
2020 case TRUTH_NOT_EXPR:
2021 build_builtin_candidate
2022 (candidates, fnname, boolean_type_node,
2023 NULL_TREE, args, argtypes, flags);
2026 case TRUTH_ORIF_EXPR:
2027 case TRUTH_ANDIF_EXPR:
2028 build_builtin_candidate
2029 (candidates, fnname, boolean_type_node,
2030 boolean_type_node, args, argtypes, flags);
2052 types[0] = types[1] = NULL_TREE;
2054 for (i = 0; i < 2; ++i)
2058 else if (IS_AGGR_TYPE (argtypes[i]))
2062 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2065 convs = lookup_conversions (argtypes[i]);
2067 if (code == COND_EXPR)
2069 if (real_lvalue_p (args[i]))
2070 types[i] = tree_cons
2071 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2073 types[i] = tree_cons
2074 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2080 for (; convs; convs = TREE_CHAIN (convs))
2082 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2085 && (TREE_CODE (type) != REFERENCE_TYPE
2086 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2089 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2090 types[i] = tree_cons (NULL_TREE, type, types[i]);
2092 type = non_reference (type);
2093 if (i != 0 || ! ref1)
2095 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2096 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2097 types[i] = tree_cons (NULL_TREE, type, types[i]);
2098 if (INTEGRAL_TYPE_P (type))
2099 type = type_promotes_to (type);
2102 if (! value_member (type, types[i]))
2103 types[i] = tree_cons (NULL_TREE, type, types[i]);
2108 if (code == COND_EXPR && real_lvalue_p (args[i]))
2109 types[i] = tree_cons
2110 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2111 type = non_reference (argtypes[i]);
2112 if (i != 0 || ! ref1)
2114 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2115 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2116 types[i] = tree_cons (NULL_TREE, type, types[i]);
2117 if (INTEGRAL_TYPE_P (type))
2118 type = type_promotes_to (type);
2120 types[i] = tree_cons (NULL_TREE, type, types[i]);
2124 /* Run through the possible parameter types of both arguments,
2125 creating candidates with those parameter types. */
2126 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2129 for (type = types[1]; type; type = TREE_CHAIN (type))
2130 add_builtin_candidate
2131 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2132 TREE_VALUE (type), args, argtypes, flags);
2134 add_builtin_candidate
2135 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2136 NULL_TREE, args, argtypes, flags);
2143 /* If TMPL can be successfully instantiated as indicated by
2144 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2146 TMPL is the template. EXPLICIT_TARGS are any explicit template
2147 arguments. ARGLIST is the arguments provided at the call-site.
2148 The RETURN_TYPE is the desired type for conversion operators. If
2149 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2150 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2151 add_conv_candidate. */
2153 static struct z_candidate*
2154 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2155 tree ctype, tree explicit_targs, tree arglist,
2156 tree return_type, tree access_path,
2157 tree conversion_path, int flags, tree obj,
2158 unification_kind_t strict)
2160 int ntparms = DECL_NTPARMS (tmpl);
2161 tree targs = make_tree_vec (ntparms);
2162 tree args_without_in_chrg = arglist;
2163 struct z_candidate *cand;
2167 /* We don't do deduction on the in-charge parameter, the VTT
2168 parameter or 'this'. */
2169 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2170 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2172 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2173 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2174 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
2175 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2177 i = fn_type_unification (tmpl, explicit_targs, targs,
2178 args_without_in_chrg,
2179 return_type, strict, -1);
2184 fn = instantiate_template (tmpl, targs, tf_none);
2185 if (fn == error_mark_node)
2190 A member function template is never instantiated to perform the
2191 copy of a class object to an object of its class type.
2193 It's a little unclear what this means; the standard explicitly
2194 does allow a template to be used to copy a class. For example,
2199 template <class T> A(const T&);
2202 void g () { A a (f ()); }
2204 the member template will be used to make the copy. The section
2205 quoted above appears in the paragraph that forbids constructors
2206 whose only parameter is (a possibly cv-qualified variant of) the
2207 class type, and a logical interpretation is that the intent was
2208 to forbid the instantiation of member templates which would then
2210 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2212 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2213 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2218 if (obj != NULL_TREE)
2219 /* Aha, this is a conversion function. */
2220 cand = add_conv_candidate (candidates, fn, obj, access_path,
2221 conversion_path, arglist);
2223 cand = add_function_candidate (candidates, fn, ctype,
2224 arglist, access_path,
2225 conversion_path, flags);
2226 if (DECL_TI_TEMPLATE (fn) != tmpl)
2227 /* This situation can occur if a member template of a template
2228 class is specialized. Then, instantiate_template might return
2229 an instantiation of the specialization, in which case the
2230 DECL_TI_TEMPLATE field will point at the original
2231 specialization. For example:
2233 template <class T> struct S { template <class U> void f(U);
2234 template <> void f(int) {}; };
2238 Here, TMPL will be template <class U> S<double>::f(U).
2239 And, instantiate template will give us the specialization
2240 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2241 for this will point at template <class T> template <> S<T>::f(int),
2242 so that we can find the definition. For the purposes of
2243 overload resolution, however, we want the original TMPL. */
2244 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2246 cand->template = DECL_TEMPLATE_INFO (fn);
2252 static struct z_candidate *
2253 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2254 tree explicit_targs, tree arglist, tree return_type,
2255 tree access_path, tree conversion_path, int flags,
2256 unification_kind_t strict)
2259 add_template_candidate_real (candidates, tmpl, ctype,
2260 explicit_targs, arglist, return_type,
2261 access_path, conversion_path,
2262 flags, NULL_TREE, strict);
2266 static struct z_candidate *
2267 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2268 tree obj, tree arglist, tree return_type,
2269 tree access_path, tree conversion_path)
2272 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2273 arglist, return_type, access_path,
2274 conversion_path, 0, obj, DEDUCE_CONV);
2277 /* The CANDS are the set of candidates that were considered for
2278 overload resolution. Return the set of viable candidates. If none
2279 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2280 is true if a candidate should be considered viable only if it is
2283 static struct z_candidate*
2284 splice_viable (struct z_candidate *cands,
2288 struct z_candidate *viable;
2289 struct z_candidate **last_viable;
2290 struct z_candidate **cand;
2293 last_viable = &viable;
2294 *any_viable_p = false;
2299 struct z_candidate *c = *cand;
2300 if (strict_p ? c->viable == 1 : c->viable)
2305 last_viable = &c->next;
2306 *any_viable_p = true;
2312 return viable ? viable : cands;
2316 any_strictly_viable (struct z_candidate *cands)
2318 for (; cands; cands = cands->next)
2319 if (cands->viable == 1)
2325 build_this (tree obj)
2327 /* Fix this to work on non-lvalues. */
2328 return build_unary_op (ADDR_EXPR, obj, 0);
2331 /* Returns true iff functions are equivalent. Equivalent functions are
2332 not '==' only if one is a function-local extern function or if
2333 both are extern "C". */
2336 equal_functions (tree fn1, tree fn2)
2338 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2339 || DECL_EXTERN_C_FUNCTION_P (fn1))
2340 return decls_match (fn1, fn2);
2344 /* Print information about one overload candidate CANDIDATE. MSGSTR
2345 is the text to print before the candidate itself.
2347 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2348 to have been run through gettext by the caller. This wart makes
2349 life simpler in print_z_candidates and for the translators. */
2352 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2354 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2356 if (TREE_VEC_LENGTH (candidate->convs) == 3)
2357 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2358 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2359 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)),
2360 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 2)));
2361 else if (TREE_VEC_LENGTH (candidate->convs) == 2)
2362 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2363 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2364 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)));
2366 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2367 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)));
2369 else if (TYPE_P (candidate->fn))
2370 inform ("%s %T <conversion>", msgstr, candidate->fn);
2371 else if (candidate->viable == -1)
2372 inform ("%J%s %+#D <near match>", candidate->fn, msgstr, candidate->fn);
2374 inform ("%J%s %+#D", candidate->fn, msgstr, candidate->fn);
2378 print_z_candidates (struct z_candidate *candidates)
2381 struct z_candidate *cand1;
2382 struct z_candidate **cand2;
2384 /* There may be duplicates in the set of candidates. We put off
2385 checking this condition as long as possible, since we have no way
2386 to eliminate duplicates from a set of functions in less than n^2
2387 time. Now we are about to emit an error message, so it is more
2388 permissible to go slowly. */
2389 for (cand1 = candidates; cand1; cand1 = cand1->next)
2391 tree fn = cand1->fn;
2392 /* Skip builtin candidates and conversion functions. */
2393 if (TREE_CODE (fn) != FUNCTION_DECL)
2395 cand2 = &cand1->next;
2398 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2399 && equal_functions (fn, (*cand2)->fn))
2400 *cand2 = (*cand2)->next;
2402 cand2 = &(*cand2)->next;
2409 str = _("candidates are:");
2410 print_z_candidate (str, candidates);
2411 if (candidates->next)
2413 /* Indent successive candidates by the width of the translation
2414 of the above string. */
2415 size_t len = gcc_gettext_width (str) + 1;
2416 char *spaces = alloca (len);
2417 memset (spaces, ' ', len-1);
2418 spaces[len - 1] = '\0';
2420 candidates = candidates->next;
2423 print_z_candidate (spaces, candidates);
2424 candidates = candidates->next;
2430 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2431 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2432 the result of the conversion function to convert it to the final
2433 desired type. Merge the the two sequences into a single sequence,
2434 and return the merged sequence. */
2437 merge_conversion_sequences (tree user_seq, tree std_seq)
2441 my_friendly_assert (TREE_CODE (user_seq) == USER_CONV,
2444 /* Find the end of the second conversion sequence. */
2446 while (TREE_CODE (*t) != IDENTITY_CONV)
2447 t = &TREE_OPERAND (*t, 0);
2449 /* Replace the identity conversion with the user conversion
2453 /* The entire sequence is a user-conversion sequence. */
2454 ICS_USER_FLAG (std_seq) = 1;
2459 /* Returns the best overload candidate to perform the requested
2460 conversion. This function is used for three the overloading situations
2461 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2462 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2463 per [dcl.init.ref], so we ignore temporary bindings. */
2465 static struct z_candidate *
2466 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2468 struct z_candidate *candidates, *cand;
2469 tree fromtype = TREE_TYPE (expr);
2470 tree ctors = NULL_TREE, convs = NULL_TREE;
2471 tree args = NULL_TREE;
2474 /* We represent conversion within a hierarchy using RVALUE_CONV and
2475 BASE_CONV, as specified by [over.best.ics]; these become plain
2476 constructor calls, as specified in [dcl.init]. */
2477 my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2478 || !DERIVED_FROM_P (totype, fromtype), 20011226);
2480 if (IS_AGGR_TYPE (totype))
2481 ctors = lookup_fnfields (TYPE_BINFO (totype),
2482 complete_ctor_identifier,
2485 if (IS_AGGR_TYPE (fromtype))
2486 convs = lookup_conversions (fromtype);
2489 flags |= LOOKUP_NO_CONVERSION;
2495 ctors = BASELINK_FUNCTIONS (ctors);
2497 t = build_int_2 (0, 0);
2498 TREE_TYPE (t) = build_pointer_type (totype);
2499 args = build_tree_list (NULL_TREE, expr);
2500 /* We should never try to call the abstract or base constructor
2502 my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2503 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),
2505 args = tree_cons (NULL_TREE, t, args);
2507 for (; ctors; ctors = OVL_NEXT (ctors))
2509 tree ctor = OVL_CURRENT (ctors);
2510 if (DECL_NONCONVERTING_P (ctor))
2513 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2514 cand = add_template_candidate (&candidates, ctor, totype,
2515 NULL_TREE, args, NULL_TREE,
2516 TYPE_BINFO (totype),
2517 TYPE_BINFO (totype),
2521 cand = add_function_candidate (&candidates, ctor, totype,
2522 args, TYPE_BINFO (totype),
2523 TYPE_BINFO (totype),
2527 cand->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE);
2531 args = build_tree_list (NULL_TREE, build_this (expr));
2533 for (; convs; convs = TREE_CHAIN (convs))
2536 tree conversion_path = TREE_PURPOSE (convs);
2537 int convflags = LOOKUP_NO_CONVERSION;
2539 /* If we are called to convert to a reference type, we are trying to
2540 find an lvalue binding, so don't even consider temporaries. If
2541 we don't find an lvalue binding, the caller will try again to
2542 look for a temporary binding. */
2543 if (TREE_CODE (totype) == REFERENCE_TYPE)
2544 convflags |= LOOKUP_NO_TEMP_BIND;
2546 for (fns = TREE_VALUE (convs); fns; fns = OVL_NEXT (fns))
2548 tree fn = OVL_CURRENT (fns);
2550 /* [over.match.funcs] For conversion functions, the function
2551 is considered to be a member of the class of the implicit
2552 object argument for the purpose of defining the type of
2553 the implicit object parameter.
2555 So we pass fromtype as CTYPE to add_*_candidate. */
2557 if (TREE_CODE (fn) == TEMPLATE_DECL)
2558 cand = add_template_candidate (&candidates, fn, fromtype,
2561 TYPE_BINFO (fromtype),
2566 cand = add_function_candidate (&candidates, fn, fromtype,
2568 TYPE_BINFO (fromtype),
2574 tree ics = implicit_conversion (totype,
2575 TREE_TYPE (TREE_TYPE (cand->fn)),
2578 cand->second_conv = ics;
2580 if (ics == NULL_TREE)
2582 else if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
2588 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2592 cand = tourney (candidates);
2595 if (flags & LOOKUP_COMPLAIN)
2597 error ("conversion from `%T' to `%T' is ambiguous",
2599 print_z_candidates (candidates);
2602 cand = candidates; /* any one will do */
2603 cand->second_conv = build1 (AMBIG_CONV, totype, expr);
2604 ICS_USER_FLAG (cand->second_conv) = 1;
2605 if (!any_strictly_viable (candidates))
2606 ICS_BAD_FLAG (cand->second_conv) = 1;
2607 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2608 ambiguous conversion is no worse than another user-defined
2614 /* Build the user conversion sequence. */
2617 (DECL_CONSTRUCTOR_P (cand->fn)
2618 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2619 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
2620 TREE_OPERAND (convs, 1) = build_zc_wrapper (cand);
2622 /* Combine it with the second conversion sequence. */
2623 cand->second_conv = merge_conversion_sequences (convs,
2626 if (cand->viable == -1)
2627 ICS_BAD_FLAG (cand->second_conv) = 1;
2633 build_user_type_conversion (tree totype, tree expr, int flags)
2635 struct z_candidate *cand
2636 = build_user_type_conversion_1 (totype, expr, flags);
2640 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
2641 return error_mark_node;
2642 return convert_from_reference (convert_like (cand->second_conv, expr));
2647 /* Do any initial processing on the arguments to a function call. */
2650 resolve_args (tree args)
2653 for (t = args; t; t = TREE_CHAIN (t))
2655 tree arg = TREE_VALUE (t);
2657 if (arg == error_mark_node)
2658 return error_mark_node;
2659 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2661 error ("invalid use of void expression");
2662 return error_mark_node;
2664 arg = convert_from_reference (arg);
2665 TREE_VALUE (t) = arg;
2670 /* Perform overload resolution on FN, which is called with the ARGS.
2672 Return the candidate function selected by overload resolution, or
2673 NULL if the event that overload resolution failed. In the case
2674 that overload resolution fails, *CANDIDATES will be the set of
2675 candidates considered, and ANY_VIABLE_P will be set to true or
2676 false to indicate whether or not any of the candidates were
2679 The ARGS should already have gone through RESOLVE_ARGS before this
2680 function is called. */
2682 static struct z_candidate *
2683 perform_overload_resolution (tree fn,
2685 struct z_candidate **candidates,
2688 struct z_candidate *cand;
2689 tree explicit_targs = NULL_TREE;
2690 int template_only = 0;
2693 *any_viable_p = true;
2695 /* Check FN and ARGS. */
2696 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
2697 || TREE_CODE (fn) == TEMPLATE_DECL
2698 || TREE_CODE (fn) == OVERLOAD
2699 || TREE_CODE (fn) == TEMPLATE_ID_EXPR,
2701 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
2704 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2706 explicit_targs = TREE_OPERAND (fn, 1);
2707 fn = TREE_OPERAND (fn, 0);
2711 /* Add the various candidate functions. */
2712 add_candidates (fn, args, explicit_targs, template_only,
2713 /*conversion_path=*/NULL_TREE,
2714 /*access_path=*/NULL_TREE,
2718 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2722 cand = tourney (*candidates);
2726 /* Return an expression for a call to FN (a namespace-scope function,
2727 or a static member function) with the ARGS. */
2730 build_new_function_call (tree fn, tree args)
2732 struct z_candidate *candidates, *cand;
2735 args = resolve_args (args);
2736 if (args == error_mark_node)
2737 return error_mark_node;
2739 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2743 if (!any_viable_p && candidates && ! candidates->next)
2744 return build_function_call (candidates->fn, args);
2745 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2746 fn = TREE_OPERAND (fn, 0);
2748 error ("no matching function for call to `%D(%A)'",
2749 DECL_NAME (OVL_CURRENT (fn)), args);
2751 error ("call of overloaded `%D(%A)' is ambiguous",
2752 DECL_NAME (OVL_CURRENT (fn)), args);
2754 print_z_candidates (candidates);
2755 return error_mark_node;
2758 return build_over_call (cand, LOOKUP_NORMAL);
2761 /* Build a call to a global operator new. FNNAME is the name of the
2762 operator (either "operator new" or "operator new[]") and ARGS are
2763 the arguments provided. *SIZE points to the total number of bytes
2764 required by the allocation, and is updated if that is changed here.
2765 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2766 function determines that no cookie should be used, after all,
2767 *COOKIE_SIZE is set to NULL_TREE. */
2770 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2773 struct z_candidate *candidates;
2774 struct z_candidate *cand;
2777 args = tree_cons (NULL_TREE, *size, args);
2778 args = resolve_args (args);
2779 if (args == error_mark_node)
2782 fns = lookup_function_nonclass (fnname, args);
2784 /* Figure out what function is being called. */
2785 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2787 /* If no suitable function could be found, issue an error message
2792 error ("no matching function for call to `%D(%A)'",
2793 DECL_NAME (OVL_CURRENT (fns)), args);
2795 error ("call of overloaded `%D(%A)' is ambiguous",
2796 DECL_NAME (OVL_CURRENT (fns)), args);
2798 print_z_candidates (candidates);
2799 return error_mark_node;
2802 /* If a cookie is required, add some extra space. Whether
2803 or not a cookie is required cannot be determined until
2804 after we know which function was called. */
2807 bool use_cookie = true;
2808 if (!abi_version_at_least (2))
2810 tree placement = TREE_CHAIN (args);
2811 /* In G++ 3.2, the check was implemented incorrectly; it
2812 looked at the placement expression, rather than the
2813 type of the function. */
2814 if (placement && !TREE_CHAIN (placement)
2815 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2823 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2824 /* Skip the size_t parameter. */
2825 arg_types = TREE_CHAIN (arg_types);
2826 /* Check the remaining parameters (if any). */
2828 && TREE_CHAIN (arg_types) == void_list_node
2829 && same_type_p (TREE_VALUE (arg_types),
2833 /* If we need a cookie, adjust the number of bytes allocated. */
2836 /* Update the total size. */
2837 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2838 /* Update the argument list to reflect the adjusted size. */
2839 TREE_VALUE (args) = *size;
2842 *cookie_size = NULL_TREE;
2845 /* Build the CALL_EXPR. */
2846 return build_over_call (cand, LOOKUP_NORMAL);
2850 build_object_call (tree obj, tree args)
2852 struct z_candidate *candidates = 0, *cand;
2853 tree fns, convs, mem_args = NULL_TREE;
2854 tree type = TREE_TYPE (obj);
2857 if (TYPE_PTRMEMFUNC_P (type))
2859 /* It's no good looking for an overloaded operator() on a
2860 pointer-to-member-function. */
2861 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2862 return error_mark_node;
2865 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2866 if (fns == error_mark_node)
2867 return error_mark_node;
2869 args = resolve_args (args);
2871 if (args == error_mark_node)
2872 return error_mark_node;
2876 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2877 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2879 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2881 tree fn = OVL_CURRENT (fns);
2882 if (TREE_CODE (fn) == TEMPLATE_DECL)
2883 add_template_candidate (&candidates, fn, base, NULL_TREE,
2884 mem_args, NULL_TREE,
2887 LOOKUP_NORMAL, DEDUCE_CALL);
2889 add_function_candidate
2890 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2891 TYPE_BINFO (type), LOOKUP_NORMAL);
2895 convs = lookup_conversions (type);
2897 for (; convs; convs = TREE_CHAIN (convs))
2899 tree fns = TREE_VALUE (convs);
2900 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2902 if ((TREE_CODE (totype) == POINTER_TYPE
2903 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2904 || (TREE_CODE (totype) == REFERENCE_TYPE
2905 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2906 || (TREE_CODE (totype) == REFERENCE_TYPE
2907 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2908 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
2909 for (; fns; fns = OVL_NEXT (fns))
2911 tree fn = OVL_CURRENT (fns);
2912 if (TREE_CODE (fn) == TEMPLATE_DECL)
2913 add_template_conv_candidate
2914 (&candidates, fn, obj, args, totype,
2915 /*access_path=*/NULL_TREE,
2916 /*conversion_path=*/NULL_TREE);
2918 add_conv_candidate (&candidates, fn, obj, args,
2919 /*conversion_path=*/NULL_TREE,
2920 /*access_path=*/NULL_TREE);
2924 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2927 error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
2928 print_z_candidates (candidates);
2929 return error_mark_node;
2932 cand = tourney (candidates);
2935 error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
2936 print_z_candidates (candidates);
2937 return error_mark_node;
2940 /* Since cand->fn will be a type, not a function, for a conversion
2941 function, we must be careful not to unconditionally look at
2943 if (TREE_CODE (cand->fn) == FUNCTION_DECL
2944 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
2945 return build_over_call (cand, LOOKUP_NORMAL);
2947 obj = convert_like_with_context
2948 (TREE_VEC_ELT (cand->convs, 0), obj, cand->fn, -1);
2951 return build_function_call (obj, args);
2955 op_error (enum tree_code code, enum tree_code code2,
2956 tree arg1, tree arg2, tree arg3, const char *problem)
2960 if (code == MODIFY_EXPR)
2961 opname = assignment_operator_name_info[code2].name;
2963 opname = operator_name_info[code].name;
2968 error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
2969 problem, arg1, arg2, arg3);
2972 case POSTINCREMENT_EXPR:
2973 case POSTDECREMENT_EXPR:
2974 error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname);
2978 error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2);
2983 error ("%s for '%s' in '%s %E'", problem, opname, opname, arg1);
2988 error ("%s for 'operator%s' in '%E %s %E'",
2989 problem, opname, arg1, opname, arg2);
2991 error ("%s for 'operator%s' in '%s%E'",
2992 problem, opname, opname, arg1);
2997 /* Return the implicit conversion sequence that could be used to
2998 convert E1 to E2 in [expr.cond]. */
3001 conditional_conversion (tree e1, tree e2)
3003 tree t1 = non_reference (TREE_TYPE (e1));
3004 tree t2 = non_reference (TREE_TYPE (e2));
3010 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3011 implicitly converted (clause _conv_) to the type "reference to
3012 T2", subject to the constraint that in the conversion the
3013 reference must bind directly (_dcl.init.ref_) to E1. */
3014 if (real_lvalue_p (e2))
3016 conv = implicit_conversion (build_reference_type (t2),
3019 LOOKUP_NO_TEMP_BIND);
3026 If E1 and E2 have class type, and the underlying class types are
3027 the same or one is a base class of the other: E1 can be converted
3028 to match E2 if the class of T2 is the same type as, or a base
3029 class of, the class of T1, and the cv-qualification of T2 is the
3030 same cv-qualification as, or a greater cv-qualification than, the
3031 cv-qualification of T1. If the conversion is applied, E1 is
3032 changed to an rvalue of type T2 that still refers to the original
3033 source class object (or the appropriate subobject thereof).
3035 FIXME we can't express an rvalue that refers to the original object;
3036 we have to create a new one. */
3037 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3038 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3040 if (good_base && at_least_as_qualified_p (t2, t1))
3042 conv = build1 (IDENTITY_CONV, t1, e1);
3043 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3044 TYPE_MAIN_VARIANT (t2)))
3046 conv = build_conv (BASE_CONV, t2, conv);
3047 NEED_TEMPORARY_P (conv) = 1;
3050 conv = build_conv (RVALUE_CONV, t2, conv);
3059 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3060 converted to the type that expression E2 would have if E2 were
3061 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3062 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3065 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3066 arguments to the conditional expression. */
3069 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3074 tree result_type = NULL_TREE;
3075 bool lvalue_p = true;
3076 struct z_candidate *candidates = 0;
3077 struct z_candidate *cand;
3079 /* As a G++ extension, the second argument to the conditional can be
3080 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3081 c'.) If the second operand is omitted, make sure it is
3082 calculated only once. */
3086 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3088 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3089 if (real_lvalue_p (arg1))
3090 arg2 = arg1 = stabilize_reference (arg1);
3092 arg2 = arg1 = save_expr (arg1);
3097 The first expr ession is implicitly converted to bool (clause
3099 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3101 /* If something has already gone wrong, just pass that fact up the
3103 if (error_operand_p (arg1)
3104 || error_operand_p (arg2)
3105 || error_operand_p (arg3))
3106 return error_mark_node;
3110 If either the second or the third operand has type (possibly
3111 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3112 array-to-pointer (_conv.array_), and function-to-pointer
3113 (_conv.func_) standard conversions are performed on the second
3114 and third operands. */
3115 arg2_type = TREE_TYPE (arg2);
3116 arg3_type = TREE_TYPE (arg3);
3117 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3119 /* Do the conversions. We don't these for `void' type arguments
3120 since it can't have any effect and since decay_conversion
3121 does not handle that case gracefully. */
3122 if (!VOID_TYPE_P (arg2_type))
3123 arg2 = decay_conversion (arg2);
3124 if (!VOID_TYPE_P (arg3_type))
3125 arg3 = decay_conversion (arg3);
3126 arg2_type = TREE_TYPE (arg2);
3127 arg3_type = TREE_TYPE (arg3);
3131 One of the following shall hold:
3133 --The second or the third operand (but not both) is a
3134 throw-expression (_except.throw_); the result is of the
3135 type of the other and is an rvalue.
3137 --Both the second and the third operands have type void; the
3138 result is of type void and is an rvalue. */
3139 if ((TREE_CODE (arg2) == THROW_EXPR)
3140 ^ (TREE_CODE (arg3) == THROW_EXPR))
3141 result_type = ((TREE_CODE (arg2) == THROW_EXPR)
3142 ? arg3_type : arg2_type);
3143 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3144 result_type = void_type_node;
3147 error ("`%E' has type `void' and is not a throw-expression",
3148 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3149 return error_mark_node;
3153 goto valid_operands;
3157 Otherwise, if the second and third operand have different types,
3158 and either has (possibly cv-qualified) class type, an attempt is
3159 made to convert each of those operands to the type of the other. */
3160 else if (!same_type_p (arg2_type, arg3_type)
3161 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3163 tree conv2 = conditional_conversion (arg2, arg3);
3164 tree conv3 = conditional_conversion (arg3, arg2);
3168 If both can be converted, or one can be converted but the
3169 conversion is ambiguous, the program is ill-formed. If
3170 neither can be converted, the operands are left unchanged and
3171 further checking is performed as described below. If exactly
3172 one conversion is possible, that conversion is applied to the
3173 chosen operand and the converted operand is used in place of
3174 the original operand for the remainder of this section. */
3175 if ((conv2 && !ICS_BAD_FLAG (conv2)
3176 && conv3 && !ICS_BAD_FLAG (conv3))
3177 || (conv2 && TREE_CODE (conv2) == AMBIG_CONV)
3178 || (conv3 && TREE_CODE (conv3) == AMBIG_CONV))
3180 error ("operands to ?: have different types");
3181 return error_mark_node;
3183 else if (conv2 && !ICS_BAD_FLAG (conv2))
3185 arg2 = convert_like (conv2, arg2);
3186 arg2 = convert_from_reference (arg2);
3187 if (!same_type_p (TREE_TYPE (arg2), arg3_type)
3188 && CLASS_TYPE_P (arg3_type))
3189 /* The types need to match if we're converting to a class type.
3190 If not, we don't care about cv-qual mismatches, since
3191 non-class rvalues are not cv-qualified. */
3193 arg2_type = TREE_TYPE (arg2);
3195 else if (conv3 && !ICS_BAD_FLAG (conv3))
3197 arg3 = convert_like (conv3, arg3);
3198 arg3 = convert_from_reference (arg3);
3199 if (!same_type_p (TREE_TYPE (arg3), arg2_type)
3200 && CLASS_TYPE_P (arg2_type))
3202 arg3_type = TREE_TYPE (arg3);
3208 If the second and third operands are lvalues and have the same
3209 type, the result is of that type and is an lvalue. */
3210 if (real_lvalue_p (arg2)
3211 && real_lvalue_p (arg3)
3212 && same_type_p (arg2_type, arg3_type))
3214 result_type = arg2_type;
3215 goto valid_operands;
3220 Otherwise, the result is an rvalue. If the second and third
3221 operand do not have the same type, and either has (possibly
3222 cv-qualified) class type, overload resolution is used to
3223 determine the conversions (if any) to be applied to the operands
3224 (_over.match.oper_, _over.built_). */
3226 if (!same_type_p (arg2_type, arg3_type)
3227 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3233 /* Rearrange the arguments so that add_builtin_candidate only has
3234 to know about two args. In build_builtin_candidates, the
3235 arguments are unscrambled. */
3239 add_builtin_candidates (&candidates,
3242 ansi_opname (COND_EXPR),
3248 If the overload resolution fails, the program is
3250 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3253 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3254 print_z_candidates (candidates);
3255 return error_mark_node;
3257 cand = tourney (candidates);
3260 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3261 print_z_candidates (candidates);
3262 return error_mark_node;
3267 Otherwise, the conversions thus determined are applied, and
3268 the converted operands are used in place of the original
3269 operands for the remainder of this section. */
3270 conv = TREE_VEC_ELT (cand->convs, 0);
3271 arg1 = convert_like (conv, arg1);
3272 conv = TREE_VEC_ELT (cand->convs, 1);
3273 arg2 = convert_like (conv, arg2);
3274 conv = TREE_VEC_ELT (cand->convs, 2);
3275 arg3 = convert_like (conv, arg3);
3280 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3281 and function-to-pointer (_conv.func_) standard conversions are
3282 performed on the second and third operands.
3284 We need to force the lvalue-to-rvalue conversion here for class types,
3285 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3286 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3289 We use ocp_convert rather than build_user_type_conversion because the
3290 latter returns NULL_TREE on failure, while the former gives an error. */
3292 arg2 = force_rvalue (arg2);
3293 arg2_type = TREE_TYPE (arg2);
3295 arg3 = force_rvalue (arg3);
3296 arg3_type = TREE_TYPE (arg3);
3298 if (arg2 == error_mark_node || arg3 == error_mark_node)
3299 return error_mark_node;
3303 After those conversions, one of the following shall hold:
3305 --The second and third operands have the same type; the result is of
3307 if (same_type_p (arg2_type, arg3_type))
3308 result_type = arg2_type;
3311 --The second and third operands have arithmetic or enumeration
3312 type; the usual arithmetic conversions are performed to bring
3313 them to a common type, and the result is of that type. */
3314 else if ((ARITHMETIC_TYPE_P (arg2_type)
3315 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3316 && (ARITHMETIC_TYPE_P (arg3_type)
3317 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3319 /* In this case, there is always a common type. */
3320 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3323 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3324 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3325 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3326 arg2_type, arg3_type);
3327 else if (extra_warnings
3328 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3329 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3330 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3331 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3332 warning ("enumeral and non-enumeral type in conditional expression");
3334 arg2 = perform_implicit_conversion (result_type, arg2);
3335 arg3 = perform_implicit_conversion (result_type, arg3);
3339 --The second and third operands have pointer type, or one has
3340 pointer type and the other is a null pointer constant; pointer
3341 conversions (_conv.ptr_) and qualification conversions
3342 (_conv.qual_) are performed to bring them to their composite
3343 pointer type (_expr.rel_). The result is of the composite
3346 --The second and third operands have pointer to member type, or
3347 one has pointer to member type and the other is a null pointer
3348 constant; pointer to member conversions (_conv.mem_) and
3349 qualification conversions (_conv.qual_) are performed to bring
3350 them to a common type, whose cv-qualification shall match the
3351 cv-qualification of either the second or the third operand.
3352 The result is of the common type. */
3353 else if ((null_ptr_cst_p (arg2)
3354 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3355 || (null_ptr_cst_p (arg3)
3356 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3357 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3358 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3359 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3361 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3362 arg3, "conditional expression");
3363 if (result_type == error_mark_node)
3364 return error_mark_node;
3365 arg2 = perform_implicit_conversion (result_type, arg2);
3366 arg3 = perform_implicit_conversion (result_type, arg3);
3371 error ("operands to ?: have different types");
3372 return error_mark_node;
3376 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3377 /* We can't use result_type below, as fold might have returned a
3380 /* Expand both sides into the same slot, hopefully the target of the
3381 ?: expression. We used to check for TARGET_EXPRs here, but now we
3382 sometimes wrap them in NOP_EXPRs so the test would fail. */
3383 if (!lvalue_p && IS_AGGR_TYPE (TREE_TYPE (result)))
3384 result = get_target_expr (result);
3386 /* If this expression is an rvalue, but might be mistaken for an
3387 lvalue, we must add a NON_LVALUE_EXPR. */
3388 if (!lvalue_p && real_lvalue_p (result))
3389 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3394 /* OPERAND is an operand to an expression. Perform necessary steps
3395 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3399 prep_operand (tree operand)
3403 operand = convert_from_reference (operand);
3404 if (CLASS_TYPE_P (TREE_TYPE (operand))
3405 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3406 /* Make sure the template type is instantiated now. */
3407 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3413 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3414 OVERLOAD) to the CANDIDATES, returning an updated list of
3415 CANDIDATES. The ARGS are the arguments provided to the call,
3416 without any implicit object parameter. The EXPLICIT_TARGS are
3417 explicit template arguments provided. TEMPLATE_ONLY is true if
3418 only template functions should be considered. CONVERSION_PATH,
3419 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3422 add_candidates (tree fns, tree args,
3423 tree explicit_targs, bool template_only,
3424 tree conversion_path, tree access_path,
3426 struct z_candidate **candidates)
3429 tree non_static_args;
3431 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3432 /* Delay creating the implicit this parameter until it is needed. */
3433 non_static_args = NULL_TREE;
3440 fn = OVL_CURRENT (fns);
3441 /* Figure out which set of arguments to use. */
3442 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3444 /* If this function is a non-static member, prepend the implicit
3445 object parameter. */
3446 if (!non_static_args)
3447 non_static_args = tree_cons (NULL_TREE,
3448 build_this (TREE_VALUE (args)),
3450 fn_args = non_static_args;
3453 /* Otherwise, just use the list of arguments provided. */
3456 if (TREE_CODE (fn) == TEMPLATE_DECL)
3457 add_template_candidate (candidates,
3467 else if (!template_only)
3468 add_function_candidate (candidates,
3475 fns = OVL_NEXT (fns);
3480 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3)
3482 struct z_candidate *candidates = 0, *cand;
3483 tree arglist, fnname;
3485 enum tree_code code2 = NOP_EXPR;
3490 if (error_operand_p (arg1)
3491 || error_operand_p (arg2)
3492 || error_operand_p (arg3))
3493 return error_mark_node;
3495 if (code == MODIFY_EXPR)
3497 code2 = TREE_CODE (arg3);
3499 fnname = ansi_assopname (code2);
3502 fnname = ansi_opname (code);
3504 arg1 = prep_operand (arg1);
3510 case VEC_DELETE_EXPR:
3512 /* Use build_op_new_call and build_op_delete_call instead. */
3516 return build_object_call (arg1, arg2);
3522 arg2 = prep_operand (arg2);
3523 arg3 = prep_operand (arg3);
3525 if (code == COND_EXPR)
3527 if (arg2 == NULL_TREE
3528 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3529 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3530 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3531 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3534 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3535 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3538 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3539 arg2 = integer_zero_node;
3541 arglist = NULL_TREE;
3543 arglist = tree_cons (NULL_TREE, arg3, arglist);
3545 arglist = tree_cons (NULL_TREE, arg2, arglist);
3546 arglist = tree_cons (NULL_TREE, arg1, arglist);
3548 /* Add namespace-scope operators to the list of functions to
3550 add_candidates (lookup_function_nonclass (fnname, arglist),
3551 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3552 flags, &candidates);
3553 /* Add class-member operators to the candidate set. */
3554 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3558 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3559 if (fns == error_mark_node)
3562 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3564 BASELINK_BINFO (fns),
3565 TYPE_BINFO (TREE_TYPE (arg1)),
3566 flags, &candidates);
3569 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3570 to know about two args; a builtin candidate will always have a first
3571 parameter of type bool. We'll handle that in
3572 build_builtin_candidate. */
3573 if (code == COND_EXPR)
3583 args[2] = NULL_TREE;
3586 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3592 /* For these, the built-in candidates set is empty
3593 [over.match.oper]/3. We don't want non-strict matches
3594 because exact matches are always possible with built-in
3595 operators. The built-in candidate set for COMPONENT_REF
3596 would be empty too, but since there are no such built-in
3597 operators, we accept non-strict matches for them. */
3602 strict_p = pedantic;
3606 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3611 case POSTINCREMENT_EXPR:
3612 case POSTDECREMENT_EXPR:
3613 /* Look for an `operator++ (int)'. If they didn't have
3614 one, then we fall back to the old way of doing things. */
3615 if (flags & LOOKUP_COMPLAIN)
3616 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3618 operator_name_info[code].name);
3619 if (code == POSTINCREMENT_EXPR)
3620 code = PREINCREMENT_EXPR;
3622 code = PREDECREMENT_EXPR;
3623 return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
3625 /* The caller will deal with these. */
3634 if (flags & LOOKUP_COMPLAIN)
3636 op_error (code, code2, arg1, arg2, arg3, "no match");
3637 print_z_candidates (candidates);
3639 return error_mark_node;
3642 cand = tourney (candidates);
3645 if (flags & LOOKUP_COMPLAIN)
3647 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3648 print_z_candidates (candidates);
3650 return error_mark_node;
3653 if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3656 && fnname == ansi_assopname (NOP_EXPR)
3657 && DECL_ARTIFICIAL (cand->fn)
3659 && ! candidates->next->next)
3661 warning ("using synthesized `%#D' for copy assignment",
3663 cp_warning_at (" where cfront would use `%#D'",
3665 ? candidates->next->fn
3669 return build_over_call (cand, LOOKUP_NORMAL);
3672 /* Check for comparison of different enum types. */
3681 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3682 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3683 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3684 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3686 warning ("comparison between `%#T' and `%#T'",
3687 TREE_TYPE (arg1), TREE_TYPE (arg2));
3694 /* We need to strip any leading REF_BIND so that bitfields don't cause
3695 errors. This should not remove any important conversions, because
3696 builtins don't apply to class objects directly. */
3697 conv = TREE_VEC_ELT (cand->convs, 0);
3698 if (TREE_CODE (conv) == REF_BIND)
3699 conv = TREE_OPERAND (conv, 0);
3700 arg1 = convert_like (conv, arg1);
3703 conv = TREE_VEC_ELT (cand->convs, 1);
3704 if (TREE_CODE (conv) == REF_BIND)
3705 conv = TREE_OPERAND (conv, 0);
3706 arg2 = convert_like (conv, arg2);
3710 conv = TREE_VEC_ELT (cand->convs, 2);
3711 if (TREE_CODE (conv) == REF_BIND)
3712 conv = TREE_OPERAND (conv, 0);
3713 arg3 = convert_like (conv, arg3);
3720 return build_modify_expr (arg1, code2, arg2);
3723 return build_indirect_ref (arg1, "unary *");
3728 case TRUNC_DIV_EXPR:
3739 case TRUNC_MOD_EXPR:
3743 case TRUTH_ANDIF_EXPR:
3744 case TRUTH_ORIF_EXPR:
3745 return cp_build_binary_op (code, arg1, arg2);
3750 case TRUTH_NOT_EXPR:
3751 case PREINCREMENT_EXPR:
3752 case POSTINCREMENT_EXPR:
3753 case PREDECREMENT_EXPR:
3754 case POSTDECREMENT_EXPR:
3757 return build_unary_op (code, arg1, candidates != 0);
3760 return build_array_ref (arg1, arg2);
3763 return build_conditional_expr (arg1, arg2, arg3);
3766 return build_m_component_ref
3767 (build_indirect_ref (arg1, NULL), arg2);
3769 /* The caller will deal with these. */
3781 /* Build a call to operator delete. This has to be handled very specially,
3782 because the restrictions on what signatures match are different from all
3783 other call instances. For a normal delete, only a delete taking (void *)
3784 or (void *, size_t) is accepted. For a placement delete, only an exact
3785 match with the placement new is accepted.
3787 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3788 ADDR is the pointer to be deleted.
3789 SIZE is the size of the memory block to be deleted.
3790 FLAGS are the usual overloading flags.
3791 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3794 build_op_delete_call (enum tree_code code, tree addr, tree size,
3795 int flags, tree placement)
3797 tree fn = NULL_TREE;
3798 tree fns, fnname, argtypes, args, type;
3801 if (addr == error_mark_node)
3802 return error_mark_node;
3804 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3806 fnname = ansi_opname (code);
3808 if (IS_AGGR_TYPE (type) && ! (flags & LOOKUP_GLOBAL))
3811 If the result of the lookup is ambiguous or inaccessible, or if
3812 the lookup selects a placement deallocation function, the
3813 program is ill-formed.
3815 Therefore, we ask lookup_fnfields to complain about ambiguity. */
3817 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3818 if (fns == error_mark_node)
3819 return error_mark_node;
3824 if (fns == NULL_TREE)
3825 fns = lookup_name_nonclass (fnname);
3832 /* Find the allocation function that is being called. */
3833 call_expr = placement;
3834 /* Extract the function. */
3835 alloc_fn = get_callee_fndecl (call_expr);
3836 my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
3837 /* Then the second parm type. */
3838 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3839 /* Also the second argument. */
3840 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3844 /* First try it without the size argument. */
3845 argtypes = void_list_node;
3849 /* Strip const and volatile from addr. */
3850 addr = cp_convert (ptr_type_node, addr);
3852 /* We make two tries at finding a matching `operator delete'. On
3853 the first pass, we look for a one-operator (or placement)
3854 operator delete. If we're not doing placement delete, then on
3855 the second pass we look for a two-argument delete. */
3856 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
3858 /* Go through the `operator delete' functions looking for one
3859 with a matching type. */
3860 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
3866 /* The first argument must be "void *". */
3867 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3868 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3871 /* On the first pass, check the rest of the arguments. */
3874 while (argtypes && t)
3876 if (!same_type_p (TREE_VALUE (argtypes),
3879 argtypes = TREE_CHAIN (argtypes);
3882 if (!argtypes && !t)
3885 /* On the second pass, the second argument must be
3888 && same_type_p (TREE_VALUE (t), sizetype)
3889 && TREE_CHAIN (t) == void_list_node)
3893 /* If we found a match, we're done. */
3898 /* If we have a matching function, call it. */
3901 /* Make sure we have the actual function, and not an
3903 fn = OVL_CURRENT (fn);
3905 /* If the FN is a member function, make sure that it is
3907 if (DECL_CLASS_SCOPE_P (fn))
3908 perform_or_defer_access_check (TYPE_BINFO (type), fn);
3911 args = tree_cons (NULL_TREE, addr, args);
3913 args = tree_cons (NULL_TREE, addr,
3914 build_tree_list (NULL_TREE, size));
3918 /* The placement args might not be suitable for overload
3919 resolution at this point, so build the call directly. */
3921 return build_cxx_call (fn, args, args);
3924 return build_function_call (fn, args);
3927 /* If we are doing placement delete we do nothing if we don't find a
3928 matching op delete. */
3932 error ("no suitable `operator %s' for `%T'",
3933 operator_name_info[(int)code].name, type);
3934 return error_mark_node;
3937 /* If the current scope isn't allowed to access DECL along
3938 BASETYPE_PATH, give an error. The most derived class in
3939 BASETYPE_PATH is the one used to qualify DECL. */
3942 enforce_access (tree basetype_path, tree decl)
3944 my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624);
3946 if (!accessible_p (basetype_path, decl))
3948 if (TREE_PRIVATE (decl))
3949 cp_error_at ("`%+#D' is private", decl);
3950 else if (TREE_PROTECTED (decl))
3951 cp_error_at ("`%+#D' is protected", decl);
3953 cp_error_at ("`%+#D' is inaccessible", decl);
3954 error ("within this context");
3961 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
3962 bitwise or of LOOKUP_* values. If any errors are warnings are
3963 generated, set *DIAGNOSTIC_FN to "error" or "warning",
3964 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
3968 build_temp (tree expr, tree type, int flags,
3969 void (**diagnostic_fn)(const char *, ...))
3973 savew = warningcount, savee = errorcount;
3974 expr = build_special_member_call (NULL_TREE,
3975 complete_ctor_identifier,
3976 build_tree_list (NULL_TREE, expr),
3979 if (warningcount > savew)
3980 *diagnostic_fn = warning;
3981 else if (errorcount > savee)
3982 *diagnostic_fn = error;
3984 *diagnostic_fn = NULL;
3989 /* Perform the conversions in CONVS on the expression EXPR. FN and
3990 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
3991 indicates the `this' argument of a method. INNER is nonzero when
3992 being called to continue a conversion chain. It is negative when a
3993 reference binding will be applied, positive otherwise. If
3994 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
3995 conversions will be emitted if appropriate. */
3998 convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner,
3999 bool issue_conversion_warnings)
4001 tree totype = TREE_TYPE (convs);
4002 void (*diagnostic_fn)(const char *, ...);
4004 if (ICS_BAD_FLAG (convs)
4005 && TREE_CODE (convs) != USER_CONV
4006 && TREE_CODE (convs) != AMBIG_CONV
4007 && TREE_CODE (convs) != REF_BIND)
4010 for (; t; t = TREE_OPERAND (t, 0))
4012 if (TREE_CODE (t) == USER_CONV || !ICS_BAD_FLAG (t))
4014 expr = convert_like_real (t, expr, fn, argnum, 1,
4015 /*issue_conversion_warnings=*/false);
4018 else if (TREE_CODE (t) == AMBIG_CONV)
4019 return convert_like_real (t, expr, fn, argnum, 1,
4020 /*issue_conversion_warnings=*/false);
4021 else if (TREE_CODE (t) == IDENTITY_CONV)
4024 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
4026 pedwarn (" initializing argument %P of `%D'", argnum, fn);
4027 return cp_convert (totype, expr);
4030 if (issue_conversion_warnings)
4031 expr = dubious_conversion_warnings
4032 (totype, expr, "argument", fn, argnum);
4033 switch (TREE_CODE (convs))
4037 struct z_candidate *cand = USER_CONV_CAND (convs);
4038 tree convfn = cand->fn;
4041 if (DECL_CONSTRUCTOR_P (convfn))
4043 tree t = build_int_2 (0, 0);
4044 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
4046 args = build_tree_list (NULL_TREE, expr);
4047 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
4048 || DECL_HAS_VTT_PARM_P (convfn))
4049 /* We should never try to call the abstract or base constructor
4052 args = tree_cons (NULL_TREE, t, args);
4055 args = build_this (expr);
4056 expr = build_over_call (cand, LOOKUP_NORMAL);
4058 /* If this is a constructor or a function returning an aggr type,
4059 we need to build up a TARGET_EXPR. */
4060 if (DECL_CONSTRUCTOR_P (convfn))
4061 expr = build_cplus_new (totype, expr);
4063 /* The result of the call is then used to direct-initialize the object
4064 that is the destination of the copy-initialization. [dcl.init]
4066 Note that this step is not reflected in the conversion sequence;
4067 it affects the semantics when we actually perform the
4068 conversion, but is not considered during overload resolution.
4070 If the target is a class, that means call a ctor. */
4071 if (IS_AGGR_TYPE (totype)
4072 && (inner >= 0 || !lvalue_p (expr)))
4076 /* Core issue 84, now a DR, says that we don't
4077 allow UDCs for these args (which deliberately
4078 breaks copy-init of an auto_ptr<Base> from an
4079 auto_ptr<Derived>). */
4080 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4087 (" initializing argument %P of `%D' from result of `%D'",
4088 argnum, fn, convfn);
4091 (" initializing temporary from result of `%D'", convfn);
4093 expr = build_cplus_new (totype, expr);
4098 if (type_unknown_p (expr))
4099 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4100 /* Convert a non-array constant variable to its underlying value, unless we
4101 are about to bind it to a reference, in which case we need to
4102 leave it as an lvalue. */
4104 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4105 expr = decl_constant_value (expr);
4106 if (CHECK_COPY_CONSTRUCTOR_P (convs))
4107 /* Generate a temporary copy purely to generate the required
4109 build_temp (build_dummy_object (totype), totype,
4110 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4114 /* Call build_user_type_conversion again for the error. */
4115 return build_user_type_conversion
4116 (totype, TREE_OPERAND (convs, 0), LOOKUP_NORMAL);
4122 expr = convert_like_real (TREE_OPERAND (convs, 0), expr, fn, argnum,
4123 TREE_CODE (convs) == REF_BIND ? -1 : 1,
4124 /*issue_conversion_warnings=*/false);
4125 if (expr == error_mark_node)
4126 return error_mark_node;
4128 switch (TREE_CODE (convs))
4131 if (! IS_AGGR_TYPE (totype))
4133 /* Else fall through. */
4135 if (TREE_CODE (convs) == BASE_CONV && !NEED_TEMPORARY_P (convs))
4137 /* We are going to bind a reference directly to a base-class
4138 subobject of EXPR. */
4139 if (CHECK_COPY_CONSTRUCTOR_P (convs))
4140 /* Generate a temporary copy purely to generate the required
4142 build_temp (build_dummy_object (TREE_TYPE (expr)),
4144 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4146 /* Build an expression for `*((base*) &expr)'. */
4147 expr = build_unary_op (ADDR_EXPR, expr, 0);
4148 expr = perform_implicit_conversion (build_pointer_type (totype),
4150 expr = build_indirect_ref (expr, "implicit conversion");
4154 /* Copy-initialization where the cv-unqualified version of the source
4155 type is the same class as, or a derived class of, the class of the
4156 destination [is treated as direct-initialization]. [dcl.init] */
4157 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4159 if (diagnostic_fn && fn)
4160 diagnostic_fn (" initializing argument %P of `%D'", argnum, fn);
4161 return build_cplus_new (totype, expr);
4165 tree ref_type = totype;
4167 /* If necessary, create a temporary. */
4168 if (NEED_TEMPORARY_P (convs) || !lvalue_p (expr))
4170 tree type = TREE_TYPE (TREE_OPERAND (convs, 0));
4172 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4174 /* If the reference is volatile or non-const, we
4175 cannot create a temporary. */
4176 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4178 if (lvalue & clk_bitfield)
4179 error ("cannot bind bitfield `%E' to `%T'",
4181 else if (lvalue & clk_packed)
4182 error ("cannot bind packed field `%E' to `%T'",
4185 error ("cannot bind rvalue `%E' to `%T'", expr, ref_type);
4186 return error_mark_node;
4188 expr = build_target_expr_with_type (expr, type);
4191 /* Take the address of the thing to which we will bind the
4193 expr = build_unary_op (ADDR_EXPR, expr, 1);
4194 if (expr == error_mark_node)
4195 return error_mark_node;
4197 /* Convert it to a pointer to the type referred to by the
4198 reference. This will adjust the pointer if a derived to
4199 base conversion is being performed. */
4200 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4202 /* Convert the pointer to the desired reference type. */
4203 return build_nop (ref_type, expr);
4207 return decay_conversion (expr);
4210 /* Warn about deprecated conversion if appropriate. */
4211 string_conv_p (totype, expr, 1);
4217 return ocp_convert (totype, expr, CONV_IMPLICIT,
4218 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4221 /* Build a call to __builtin_trap which can be used as an expression of
4225 call_builtin_trap (tree type)
4227 tree fn = IDENTIFIER_GLOBAL_VALUE (get_identifier ("__builtin_trap"));
4229 my_friendly_assert (fn != NULL, 20030927);
4230 fn = build_call (fn, NULL_TREE);
4231 fn = build (COMPOUND_EXPR, type, fn, error_mark_node);
4232 fn = force_target_expr (type, fn);
4236 /* ARG is being passed to a varargs function. Perform any conversions
4237 required. Return the converted value. */
4240 convert_arg_to_ellipsis (tree arg)
4244 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4245 standard conversions are performed. */
4246 arg = decay_conversion (arg);
4249 If the argument has integral or enumeration type that is subject
4250 to the integral promotions (_conv.prom_), or a floating point
4251 type that is subject to the floating point promotion
4252 (_conv.fpprom_), the value of the argument is converted to the
4253 promoted type before the call. */
4254 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4255 && (TYPE_PRECISION (TREE_TYPE (arg))
4256 < TYPE_PRECISION (double_type_node)))
4257 arg = convert_to_real (double_type_node, arg);
4258 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4259 arg = perform_integral_promotions (arg);
4261 arg = require_complete_type (arg);
4263 if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
4265 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4266 here and do a bitwise copy, but now cp_expr_size will abort if we
4268 warning ("cannot pass objects of non-POD type `%#T' through `...'; \
4269 call will abort at runtime",
4271 arg = call_builtin_trap (TREE_TYPE (arg));
4277 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4280 build_x_va_arg (tree expr, tree type)
4282 if (processing_template_decl)
4283 return build_min (VA_ARG_EXPR, type, expr);
4285 type = complete_type_or_else (type, NULL_TREE);
4287 if (expr == error_mark_node || !type)
4288 return error_mark_node;
4290 if (! pod_type_p (type))
4292 /* Undefined behavior [expr.call] 5.2.2/7. */
4293 warning ("cannot receive objects of non-POD type `%#T' through `...'; \
4294 call will abort at runtime",
4296 return call_builtin_trap (type);
4299 return build_va_arg (expr, type);
4302 /* TYPE has been given to va_arg. Apply the default conversions which
4303 would have happened when passed via ellipsis. Return the promoted
4304 type, or the passed type if there is no change. */
4307 cxx_type_promotes_to (tree type)
4311 /* Perform the array-to-pointer and function-to-pointer
4313 type = type_decays_to (type);
4315 promote = type_promotes_to (type);
4316 if (same_type_p (type, promote))
4322 /* ARG is a default argument expression being passed to a parameter of
4323 the indicated TYPE, which is a parameter to FN. Do any required
4324 conversions. Return the converted value. */
4327 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4329 /* If the ARG is an unparsed default argument expression, the
4330 conversion cannot be performed. */
4331 if (TREE_CODE (arg) == DEFAULT_ARG)
4333 error ("the default argument for parameter %d of `%D' has "
4334 "not yet been parsed",
4336 return error_mark_node;
4339 if (fn && DECL_TEMPLATE_INFO (fn))
4340 arg = tsubst_default_argument (fn, type, arg);
4342 arg = break_out_target_exprs (arg);
4344 if (TREE_CODE (arg) == CONSTRUCTOR)
4346 arg = digest_init (type, arg, 0);
4347 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4348 "default argument", fn, parmnum);
4352 /* This could get clobbered by the following call. */
4353 if (TREE_HAS_CONSTRUCTOR (arg))
4354 arg = copy_node (arg);
4356 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4357 "default argument", fn, parmnum);
4358 arg = convert_for_arg_passing (type, arg);
4364 /* Returns the type which will really be used for passing an argument of
4368 type_passed_as (tree type)
4370 /* Pass classes with copy ctors by invisible reference. */
4371 if (TREE_ADDRESSABLE (type))
4372 type = build_reference_type (type);
4373 else if (PROMOTE_PROTOTYPES
4374 && INTEGRAL_TYPE_P (type)
4375 && COMPLETE_TYPE_P (type)
4376 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4377 TYPE_SIZE (integer_type_node)))
4378 type = integer_type_node;
4383 /* Actually perform the appropriate conversion. */
4386 convert_for_arg_passing (tree type, tree val)
4388 if (val == error_mark_node)
4390 /* Pass classes with copy ctors by invisible reference. */
4391 else if (TREE_ADDRESSABLE (type))
4392 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4393 else if (PROMOTE_PROTOTYPES
4394 && INTEGRAL_TYPE_P (type)
4395 && COMPLETE_TYPE_P (type)
4396 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4397 TYPE_SIZE (integer_type_node)))
4398 val = perform_integral_promotions (val);
4402 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4403 which no conversions at all should be done. This is true for some
4404 builtins which don't act like normal functions. */
4407 magic_varargs_p (tree fn)
4409 if (DECL_BUILT_IN (fn))
4410 switch (DECL_FUNCTION_CODE (fn))
4412 case BUILT_IN_CLASSIFY_TYPE:
4413 case BUILT_IN_CONSTANT_P:
4414 case BUILT_IN_NEXT_ARG:
4415 case BUILT_IN_STDARG_START:
4416 case BUILT_IN_VA_START:
4425 /* Subroutine of the various build_*_call functions. Overload resolution
4426 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4427 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4428 bitmask of various LOOKUP_* flags which apply to the call itself. */
4431 build_over_call (struct z_candidate *cand, int flags)
4434 tree args = cand->args;
4435 tree convs = cand->convs;
4436 tree converted_args = NULL_TREE;
4437 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4438 tree conv, arg, val;
4442 /* Give any warnings we noticed during overload resolution. */
4444 for (val = cand->warnings; val; val = TREE_CHAIN (val))
4445 joust (cand, WRAPPER_ZC (TREE_VALUE (val)), 1);
4447 if (DECL_FUNCTION_MEMBER_P (fn))
4449 /* If FN is a template function, two cases must be considered.
4454 template <class T> void f();
4456 template <class T> struct B {
4460 struct C : A, B<int> {
4462 using B<int>::g; // #2
4465 In case #1 where `A::f' is a member template, DECL_ACCESS is
4466 recorded in the primary template but not in its specialization.
4467 We check access of FN using its primary template.
4469 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4470 because it is a member of class template B, DECL_ACCESS is
4471 recorded in the specialization `B<int>::g'. We cannot use its
4472 primary template because `B<T>::g' and `B<int>::g' may have
4473 different access. */
4474 if (DECL_TEMPLATE_INFO (fn)
4475 && is_member_template (DECL_TI_TEMPLATE (fn)))
4476 perform_or_defer_access_check (cand->access_path,
4477 DECL_TI_TEMPLATE (fn));
4479 perform_or_defer_access_check (cand->access_path, fn);
4482 if (args && TREE_CODE (args) != TREE_LIST)
4483 args = build_tree_list (NULL_TREE, args);
4486 /* The implicit parameters to a constructor are not considered by overload
4487 resolution, and must be of the proper type. */
4488 if (DECL_CONSTRUCTOR_P (fn))
4490 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4491 arg = TREE_CHAIN (arg);
4492 parm = TREE_CHAIN (parm);
4493 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4494 /* We should never try to call the abstract constructor. */
4496 if (DECL_HAS_VTT_PARM_P (fn))
4498 converted_args = tree_cons
4499 (NULL_TREE, TREE_VALUE (arg), converted_args);
4500 arg = TREE_CHAIN (arg);
4501 parm = TREE_CHAIN (parm);
4504 /* Bypass access control for 'this' parameter. */
4505 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4507 tree parmtype = TREE_VALUE (parm);
4508 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4512 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
4513 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4514 TREE_TYPE (argtype), fn);
4516 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4517 X is called for an object that is not of type X, or of a type
4518 derived from X, the behavior is undefined.
4520 So we can assume that anything passed as 'this' is non-null, and
4521 optimize accordingly. */
4522 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4523 /* Convert to the base in which the function was declared. */
4524 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4525 converted_arg = build_base_path (PLUS_EXPR,
4527 cand->conversion_path,
4529 /* Check that the base class is accessible. */
4530 if (!accessible_base_p (TREE_TYPE (argtype),
4531 BINFO_TYPE (cand->conversion_path)))
4532 error ("`%T' is not an accessible base of `%T'",
4533 BINFO_TYPE (cand->conversion_path),
4534 TREE_TYPE (argtype));
4535 /* If fn was found by a using declaration, the conversion path
4536 will be to the derived class, not the base declaring fn. We
4537 must convert from derived to base. */
4538 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4539 TREE_TYPE (parmtype), ba_ignore, NULL);
4540 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4543 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4544 parm = TREE_CHAIN (parm);
4545 arg = TREE_CHAIN (arg);
4551 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4553 tree type = TREE_VALUE (parm);
4555 conv = TREE_VEC_ELT (convs, i);
4556 val = convert_like_with_context
4557 (conv, TREE_VALUE (arg), fn, i - is_method);
4559 val = convert_for_arg_passing (type, val);
4560 converted_args = tree_cons (NULL_TREE, val, converted_args);
4563 /* Default arguments */
4564 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4566 = tree_cons (NULL_TREE,
4567 convert_default_arg (TREE_VALUE (parm),
4568 TREE_PURPOSE (parm),
4573 for (; arg; arg = TREE_CHAIN (arg))
4575 tree a = TREE_VALUE (arg);
4576 if (magic_varargs_p (fn))
4577 /* Do no conversions for magic varargs. */;
4579 a = convert_arg_to_ellipsis (a);
4580 converted_args = tree_cons (NULL_TREE, a, converted_args);
4583 converted_args = nreverse (converted_args);
4586 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4589 /* Avoid actually calling copy constructors and copy assignment operators,
4592 if (! flag_elide_constructors)
4593 /* Do things the hard way. */;
4594 else if (TREE_VEC_LENGTH (convs) == 1
4595 && DECL_COPY_CONSTRUCTOR_P (fn))
4598 arg = skip_artificial_parms_for (fn, converted_args);
4599 arg = TREE_VALUE (arg);
4601 /* Pull out the real argument, disregarding const-correctness. */
4603 while (TREE_CODE (targ) == NOP_EXPR
4604 || TREE_CODE (targ) == NON_LVALUE_EXPR
4605 || TREE_CODE (targ) == CONVERT_EXPR)
4606 targ = TREE_OPERAND (targ, 0);
4607 if (TREE_CODE (targ) == ADDR_EXPR)
4609 targ = TREE_OPERAND (targ, 0);
4610 if (!same_type_ignoring_top_level_qualifiers_p
4611 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4620 arg = build_indirect_ref (arg, 0);
4622 /* [class.copy]: the copy constructor is implicitly defined even if
4623 the implementation elided its use. */
4624 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4627 /* If we're creating a temp and we already have one, don't create a
4628 new one. If we're not creating a temp but we get one, use
4629 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4630 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4631 temp or an INIT_EXPR otherwise. */
4632 if (integer_zerop (TREE_VALUE (args)))
4634 if (TREE_CODE (arg) == TARGET_EXPR)
4636 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4637 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4639 else if (TREE_CODE (arg) == TARGET_EXPR
4640 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4643 tree to = stabilize_reference
4644 (build_indirect_ref (TREE_VALUE (args), 0));
4646 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4647 address = build_unary_op (ADDR_EXPR, val, 0);
4648 /* Avoid a warning about this expression, if the address is
4650 TREE_USED (address) = 1;
4654 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4656 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4658 tree to = stabilize_reference
4659 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4660 tree type = TREE_TYPE (to);
4661 tree as_base = CLASSTYPE_AS_BASE (type);
4663 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4664 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4665 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4668 /* We must only copy the non-tail padding parts. Use
4669 CLASSTYPE_AS_BASE for the bitwise copy. */
4670 tree to_ptr, arg_ptr, to_as_base, arg_as_base, base_ptr_type;
4673 to_ptr = save_expr (build_unary_op (ADDR_EXPR, to, 0));
4674 arg_ptr = build_unary_op (ADDR_EXPR, arg, 0);
4676 base_ptr_type = build_pointer_type (as_base);
4677 to_as_base = build_nop (base_ptr_type, to_ptr);
4678 to_as_base = build_indirect_ref (to_as_base, 0);
4679 arg_as_base = build_nop (base_ptr_type, arg_ptr);
4680 arg_as_base = build_indirect_ref (arg_as_base, 0);
4682 save_to = build_indirect_ref (to_ptr, 0);
4684 val = build (MODIFY_EXPR, as_base, to_as_base, arg_as_base);
4685 val = convert_to_void (val, NULL);
4686 val = build (COMPOUND_EXPR, type, val, save_to);
4687 TREE_NO_UNUSED_WARNING (val) = 1;
4695 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4697 tree t, *p = &TREE_VALUE (converted_args);
4698 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4701 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4703 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4704 if (TREE_SIDE_EFFECTS (*p))
4705 *p = save_expr (*p);
4706 t = build_pointer_type (TREE_TYPE (fn));
4707 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4708 fn = build_java_interface_fn_ref (fn, *p);
4710 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4713 else if (DECL_INLINE (fn))
4714 fn = inline_conversion (fn);
4716 fn = build_addr_func (fn);
4718 return build_cxx_call (fn, args, converted_args);
4721 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4722 gives the original form of the arguments. This function performs
4723 no overload resolution, conversion, or other high-level
4727 build_cxx_call(tree fn, tree args, tree converted_args)
4731 /* Recognize certain built-in functions so we can make tree-codes
4732 other than CALL_EXPR. We do this when it enables fold-const.c
4733 to do something useful. */
4734 if (TREE_CODE (fn) == ADDR_EXPR
4735 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4736 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4739 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4744 fn = build_call (fn, converted_args);
4746 /* If this call might throw an exception, note that fact. */
4747 fndecl = get_callee_fndecl (fn);
4748 if ((!fndecl || !TREE_NOTHROW (fndecl))
4749 && at_function_scope_p ()
4751 cp_function_chain->can_throw = 1;
4753 /* Some built-in function calls will be evaluated at compile-time in
4757 if (VOID_TYPE_P (TREE_TYPE (fn)))
4760 fn = require_complete_type (fn);
4761 if (fn == error_mark_node)
4762 return error_mark_node;
4764 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4765 fn = build_cplus_new (TREE_TYPE (fn), fn);
4766 return convert_from_reference (fn);
4769 static GTY(()) tree java_iface_lookup_fn;
4771 /* Make an expression which yields the address of the Java interface
4772 method FN. This is achieved by generating a call to libjava's
4773 _Jv_LookupInterfaceMethodIdx(). */
4776 build_java_interface_fn_ref (tree fn, tree instance)
4778 tree lookup_args, lookup_fn, method, idx;
4779 tree klass_ref, iface, iface_ref;
4782 if (!java_iface_lookup_fn)
4784 tree endlink = build_void_list_node ();
4785 tree t = tree_cons (NULL_TREE, ptr_type_node,
4786 tree_cons (NULL_TREE, ptr_type_node,
4787 tree_cons (NULL_TREE, java_int_type_node,
4789 java_iface_lookup_fn
4790 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4791 build_function_type (ptr_type_node, t),
4792 0, NOT_BUILT_IN, NULL, NULL_TREE);
4795 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4796 This is the first entry in the vtable. */
4797 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4800 /* Get the java.lang.Class pointer for the interface being called. */
4801 iface = DECL_CONTEXT (fn);
4802 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4803 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4804 || DECL_CONTEXT (iface_ref) != iface)
4806 error ("could not find class$ field in java interface type `%T'",
4808 return error_mark_node;
4810 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4812 /* Determine the itable index of FN. */
4814 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4816 if (!DECL_VIRTUAL_P (method))
4822 idx = build_int_2 (i, 0);
4824 lookup_args = tree_cons (NULL_TREE, klass_ref,
4825 tree_cons (NULL_TREE, iface_ref,
4826 build_tree_list (NULL_TREE, idx)));
4827 lookup_fn = build1 (ADDR_EXPR,
4828 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4829 java_iface_lookup_fn);
4830 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4833 /* Returns the value to use for the in-charge parameter when making a
4834 call to a function with the indicated NAME. */
4837 in_charge_arg_for_name (tree name)
4839 if (name == base_ctor_identifier
4840 || name == base_dtor_identifier)
4841 return integer_zero_node;
4842 else if (name == complete_ctor_identifier)
4843 return integer_one_node;
4844 else if (name == complete_dtor_identifier)
4845 return integer_two_node;
4846 else if (name == deleting_dtor_identifier)
4847 return integer_three_node;
4849 /* This function should only be called with one of the names listed
4855 /* Build a call to a constructor, destructor, or an assignment
4856 operator for INSTANCE, an expression with class type. NAME
4857 indicates the special member function to call; ARGS are the
4858 arguments. BINFO indicates the base of INSTANCE that is to be
4859 passed as the `this' parameter to the member function called.
4861 FLAGS are the LOOKUP_* flags to use when processing the call.
4863 If NAME indicates a complete object constructor, INSTANCE may be
4864 NULL_TREE. In this case, the caller will call build_cplus_new to
4865 store the newly constructed object into a VAR_DECL. */
4868 build_special_member_call (tree instance, tree name, tree args,
4869 tree binfo, int flags)
4872 /* The type of the subobject to be constructed or destroyed. */
4875 my_friendly_assert (name == complete_ctor_identifier
4876 || name == base_ctor_identifier
4877 || name == complete_dtor_identifier
4878 || name == base_dtor_identifier
4879 || name == deleting_dtor_identifier
4880 || name == ansi_assopname (NOP_EXPR),
4882 my_friendly_assert (binfo != NULL_TREE, 20020712);
4884 class_type = BINFO_TYPE (binfo);
4886 /* Handle the special case where INSTANCE is NULL_TREE. */
4887 if (name == complete_ctor_identifier && !instance)
4889 instance = build_int_2 (0, 0);
4890 TREE_TYPE (instance) = build_pointer_type (class_type);
4891 instance = build1 (INDIRECT_REF, class_type, instance);
4895 if (name == complete_dtor_identifier
4896 || name == base_dtor_identifier
4897 || name == deleting_dtor_identifier)
4898 my_friendly_assert (args == NULL_TREE, 20020712);
4900 /* Convert to the base class, if necessary. */
4901 if (!same_type_ignoring_top_level_qualifiers_p
4902 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
4904 if (name != ansi_assopname (NOP_EXPR))
4905 /* For constructors and destructors, either the base is
4906 non-virtual, or it is virtual but we are doing the
4907 conversion from a constructor or destructor for the
4908 complete object. In either case, we can convert
4910 instance = convert_to_base_statically (instance, binfo);
4912 /* However, for assignment operators, we must convert
4913 dynamically if the base is virtual. */
4914 instance = build_base_path (PLUS_EXPR, instance,
4915 binfo, /*nonnull=*/1);
4919 my_friendly_assert (instance != NULL_TREE, 20020712);
4921 /* Resolve the name. */
4922 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
4923 return error_mark_node;
4925 fns = lookup_fnfields (binfo, name, 1);
4927 /* When making a call to a constructor or destructor for a subobject
4928 that uses virtual base classes, pass down a pointer to a VTT for
4930 if ((name == base_ctor_identifier
4931 || name == base_dtor_identifier)
4932 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
4937 /* If the current function is a complete object constructor
4938 or destructor, then we fetch the VTT directly.
4939 Otherwise, we look it up using the VTT we were given. */
4940 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
4941 vtt = decay_conversion (vtt);
4942 vtt = build (COND_EXPR, TREE_TYPE (vtt),
4943 build (EQ_EXPR, boolean_type_node,
4944 current_in_charge_parm, integer_zero_node),
4947 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
4948 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
4949 BINFO_SUBVTT_INDEX (binfo));
4951 args = tree_cons (NULL_TREE, sub_vtt, args);
4954 return build_new_method_call (instance, fns, args,
4955 TYPE_BINFO (BINFO_TYPE (binfo)),
4959 /* Return the NAME, as a C string. The NAME indicates a function that
4960 is a member of TYPE. *FREE_P is set to true if the caller must
4961 free the memory returned.
4963 Rather than go through all of this, we should simply set the names
4964 of constructors and destructors appropriately, and dispense with
4965 ctor_identifier, dtor_identifier, etc. */
4968 name_as_c_string (tree name, tree type, bool *free_p)
4972 /* Assume that we will not allocate memory. */
4974 /* Constructors and destructors are special. */
4975 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4978 = (char *) IDENTIFIER_POINTER (constructor_name (type));
4979 /* For a destructor, add the '~'. */
4980 if (name == complete_dtor_identifier
4981 || name == base_dtor_identifier
4982 || name == deleting_dtor_identifier)
4984 pretty_name = concat ("~", pretty_name, NULL);
4985 /* Remember that we need to free the memory allocated. */
4990 pretty_name = (char *) IDENTIFIER_POINTER (name);
4995 /* Build a call to "INSTANCE.FN (ARGS)". */
4998 build_new_method_call (tree instance, tree fns, tree args,
4999 tree conversion_path, int flags)
5001 struct z_candidate *candidates = 0, *cand;
5002 tree explicit_targs = NULL_TREE;
5003 tree basetype = NULL_TREE;
5006 tree mem_args = NULL_TREE, instance_ptr;
5012 int template_only = 0;
5018 my_friendly_assert (instance != NULL_TREE, 20020729);
5020 if (error_operand_p (instance)
5021 || error_operand_p (fns)
5022 || args == error_mark_node)
5023 return error_mark_node;
5025 orig_instance = instance;
5029 if (processing_template_decl)
5031 instance = build_non_dependent_expr (instance);
5032 if (!BASELINK_P (fns)
5033 && TREE_CODE (fns) != PSEUDO_DTOR_EXPR
5034 && TREE_TYPE (fns) != unknown_type_node)
5035 fns = build_non_dependent_expr (fns);
5036 args = build_non_dependent_args (orig_args);
5039 /* Process the argument list. */
5041 args = resolve_args (args);
5042 if (args == error_mark_node)
5043 return error_mark_node;
5045 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5046 instance = convert_from_reference (instance);
5047 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5048 instance_ptr = build_this (instance);
5050 if (!BASELINK_P (fns))
5052 call = build_field_call (instance_ptr, fns, args);
5055 error ("call to non-function `%D'", fns);
5056 return error_mark_node;
5059 if (!conversion_path)
5060 conversion_path = BASELINK_BINFO (fns);
5061 access_binfo = BASELINK_ACCESS_BINFO (fns);
5062 optype = BASELINK_OPTYPE (fns);
5063 fns = BASELINK_FUNCTIONS (fns);
5065 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5067 explicit_targs = TREE_OPERAND (fns, 1);
5068 fns = TREE_OPERAND (fns, 0);
5072 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
5073 || TREE_CODE (fns) == TEMPLATE_DECL
5074 || TREE_CODE (fns) == OVERLOAD,
5077 /* XXX this should be handled before we get here. */
5078 if (! IS_AGGR_TYPE (basetype))
5080 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5081 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5082 fns, instance, basetype);
5084 return error_mark_node;
5087 fn = get_first_fn (fns);
5088 name = DECL_NAME (fn);
5090 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5092 /* Callers should explicitly indicate whether they want to construct
5093 the complete object or just the part without virtual bases. */
5094 my_friendly_assert (name != ctor_identifier, 20000408);
5095 /* Similarly for destructors. */
5096 my_friendly_assert (name != dtor_identifier, 20000408);
5099 /* It's OK to call destructors on cv-qualified objects. Therefore,
5100 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5101 if (DECL_DESTRUCTOR_P (fn))
5103 tree type = build_pointer_type (basetype);
5104 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5105 instance_ptr = build_nop (type, instance_ptr);
5108 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5109 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5111 for (fn = fns; fn; fn = OVL_NEXT (fn))
5113 tree t = OVL_CURRENT (fn);
5116 /* We can end up here for copy-init of same or base class. */
5117 if ((flags & LOOKUP_ONLYCONVERTING)
5118 && DECL_NONCONVERTING_P (t))
5121 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5122 this_arglist = mem_args;
5124 this_arglist = args;
5126 if (TREE_CODE (t) == TEMPLATE_DECL)
5127 /* A member template. */
5128 add_template_candidate (&candidates, t,
5131 this_arglist, optype,
5136 else if (! template_only)
5137 add_function_candidate (&candidates, t,
5145 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5148 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5149 if (flags & LOOKUP_SPECULATIVELY)
5151 if (!COMPLETE_TYPE_P (basetype))
5152 cxx_incomplete_type_error (instance_ptr, basetype);
5158 pretty_name = name_as_c_string (name, basetype, &free_p);
5159 error ("no matching function for call to `%T::%s(%A)%#V'",
5160 basetype, pretty_name, user_args,
5161 TREE_TYPE (TREE_TYPE (instance_ptr)));
5165 print_z_candidates (candidates);
5166 return error_mark_node;
5169 cand = tourney (candidates);
5175 pretty_name = name_as_c_string (name, basetype, &free_p);
5176 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
5178 print_z_candidates (candidates);
5181 return error_mark_node;
5184 if (DECL_PURE_VIRTUAL_P (cand->fn)
5185 && instance == current_class_ref
5186 && (DECL_CONSTRUCTOR_P (current_function_decl)
5187 || DECL_DESTRUCTOR_P (current_function_decl))
5188 && ! (flags & LOOKUP_NONVIRTUAL)
5189 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
5190 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5191 "abstract virtual `%#D' called from constructor"
5192 : "abstract virtual `%#D' called from destructor"),
5194 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5195 && is_dummy_object (instance_ptr))
5197 error ("cannot call member function `%D' without object", cand->fn);
5198 return error_mark_node;
5201 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5202 && resolves_to_fixed_type_p (instance, 0))
5203 flags |= LOOKUP_NONVIRTUAL;
5205 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE)
5206 call = build_over_call (cand, flags);
5209 call = build_over_call (cand, flags);
5210 /* In an expression of the form `a->f()' where `f' turns out to
5211 be a static member function, `a' is none-the-less evaluated. */
5212 if (!is_dummy_object (instance_ptr) && TREE_SIDE_EFFECTS (instance))
5213 call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call);
5217 if (processing_template_decl && call != error_mark_node)
5218 return build_min_non_dep
5220 build_min_nt (COMPONENT_REF, orig_instance, orig_fns),
5225 /* Returns true iff standard conversion sequence ICS1 is a proper
5226 subsequence of ICS2. */
5229 is_subseq (tree ics1, tree ics2)
5231 /* We can assume that a conversion of the same code
5232 between the same types indicates a subsequence since we only get
5233 here if the types we are converting from are the same. */
5235 while (TREE_CODE (ics1) == RVALUE_CONV
5236 || TREE_CODE (ics1) == LVALUE_CONV)
5237 ics1 = TREE_OPERAND (ics1, 0);
5241 while (TREE_CODE (ics2) == RVALUE_CONV
5242 || TREE_CODE (ics2) == LVALUE_CONV)
5243 ics2 = TREE_OPERAND (ics2, 0);
5245 if (TREE_CODE (ics2) == USER_CONV
5246 || TREE_CODE (ics2) == AMBIG_CONV
5247 || TREE_CODE (ics2) == IDENTITY_CONV)
5248 /* At this point, ICS1 cannot be a proper subsequence of
5249 ICS2. We can get a USER_CONV when we are comparing the
5250 second standard conversion sequence of two user conversion
5254 ics2 = TREE_OPERAND (ics2, 0);
5256 if (TREE_CODE (ics2) == TREE_CODE (ics1)
5257 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
5258 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
5259 TREE_TYPE (TREE_OPERAND (ics1, 0))))
5264 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5265 be any _TYPE nodes. */
5268 is_properly_derived_from (tree derived, tree base)
5270 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5271 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5274 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5275 considers every class derived from itself. */
5276 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5277 && DERIVED_FROM_P (base, derived));
5280 /* We build the ICS for an implicit object parameter as a pointer
5281 conversion sequence. However, such a sequence should be compared
5282 as if it were a reference conversion sequence. If ICS is the
5283 implicit conversion sequence for an implicit object parameter,
5284 modify it accordingly. */
5287 maybe_handle_implicit_object (tree *ics)
5289 if (ICS_THIS_FLAG (*ics))
5291 /* [over.match.funcs]
5293 For non-static member functions, the type of the
5294 implicit object parameter is "reference to cv X"
5295 where X is the class of which the function is a
5296 member and cv is the cv-qualification on the member
5297 function declaration. */
5299 tree reference_type;
5301 /* The `this' parameter is a pointer to a class type. Make the
5302 implicit conversion talk about a reference to that same class
5304 reference_type = TREE_TYPE (TREE_TYPE (*ics));
5305 reference_type = build_reference_type (reference_type);
5307 if (TREE_CODE (t) == QUAL_CONV)
5308 t = TREE_OPERAND (t, 0);
5309 if (TREE_CODE (t) == PTR_CONV)
5310 t = TREE_OPERAND (t, 0);
5311 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
5312 t = direct_reference_binding (reference_type, t);
5317 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5318 and return the type to which the reference refers. Otherwise,
5319 leave *ICS unchanged and return NULL_TREE. */
5322 maybe_handle_ref_bind (tree *ics)
5324 if (TREE_CODE (*ics) == REF_BIND)
5326 tree old_ics = *ics;
5327 tree type = TREE_TYPE (TREE_TYPE (old_ics));
5328 *ics = TREE_OPERAND (old_ics, 0);
5329 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
5330 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
5337 /* Compare two implicit conversion sequences according to the rules set out in
5338 [over.ics.rank]. Return values:
5340 1: ics1 is better than ics2
5341 -1: ics2 is better than ics1
5342 0: ics1 and ics2 are indistinguishable */
5345 compare_ics (tree ics1, tree ics2)
5351 tree deref_from_type1 = NULL_TREE;
5352 tree deref_from_type2 = NULL_TREE;
5353 tree deref_to_type1 = NULL_TREE;
5354 tree deref_to_type2 = NULL_TREE;
5357 /* REF_BINDING is nonzero if the result of the conversion sequence
5358 is a reference type. In that case TARGET_TYPE is the
5359 type referred to by the reference. */
5363 /* Handle implicit object parameters. */
5364 maybe_handle_implicit_object (&ics1);
5365 maybe_handle_implicit_object (&ics2);
5367 /* Handle reference parameters. */
5368 target_type1 = maybe_handle_ref_bind (&ics1);
5369 target_type2 = maybe_handle_ref_bind (&ics2);
5373 When comparing the basic forms of implicit conversion sequences (as
5374 defined in _over.best.ics_)
5376 --a standard conversion sequence (_over.ics.scs_) is a better
5377 conversion sequence than a user-defined conversion sequence
5378 or an ellipsis conversion sequence, and
5380 --a user-defined conversion sequence (_over.ics.user_) is a
5381 better conversion sequence than an ellipsis conversion sequence
5382 (_over.ics.ellipsis_). */
5383 rank1 = ICS_RANK (ics1);
5384 rank2 = ICS_RANK (ics2);
5388 else if (rank1 < rank2)
5391 if (rank1 == BAD_RANK)
5393 /* XXX Isn't this an extension? */
5394 /* Both ICS are bad. We try to make a decision based on what
5395 would have happened if they'd been good. */
5396 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5397 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5399 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5400 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5403 /* We couldn't make up our minds; try to figure it out below. */
5406 if (ICS_ELLIPSIS_FLAG (ics1))
5407 /* Both conversions are ellipsis conversions. */
5410 /* User-defined conversion sequence U1 is a better conversion sequence
5411 than another user-defined conversion sequence U2 if they contain the
5412 same user-defined conversion operator or constructor and if the sec-
5413 ond standard conversion sequence of U1 is better than the second
5414 standard conversion sequence of U2. */
5416 if (ICS_USER_FLAG (ics1))
5420 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5421 if (TREE_CODE (t1) == AMBIG_CONV)
5423 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5424 if (TREE_CODE (t2) == AMBIG_CONV)
5427 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5430 /* We can just fall through here, after setting up
5431 FROM_TYPE1 and FROM_TYPE2. */
5432 from_type1 = TREE_TYPE (t1);
5433 from_type2 = TREE_TYPE (t2);
5437 /* We're dealing with two standard conversion sequences.
5441 Standard conversion sequence S1 is a better conversion
5442 sequence than standard conversion sequence S2 if
5444 --S1 is a proper subsequence of S2 (comparing the conversion
5445 sequences in the canonical form defined by _over.ics.scs_,
5446 excluding any Lvalue Transformation; the identity
5447 conversion sequence is considered to be a subsequence of
5448 any non-identity conversion sequence */
5451 while (TREE_CODE (from_type1) != IDENTITY_CONV)
5452 from_type1 = TREE_OPERAND (from_type1, 0);
5453 from_type1 = TREE_TYPE (from_type1);
5456 while (TREE_CODE (from_type2) != IDENTITY_CONV)
5457 from_type2 = TREE_OPERAND (from_type2, 0);
5458 from_type2 = TREE_TYPE (from_type2);
5461 if (same_type_p (from_type1, from_type2))
5463 if (is_subseq (ics1, ics2))
5465 if (is_subseq (ics2, ics1))
5468 /* Otherwise, one sequence cannot be a subsequence of the other; they
5469 don't start with the same type. This can happen when comparing the
5470 second standard conversion sequence in two user-defined conversion
5477 --the rank of S1 is better than the rank of S2 (by the rules
5480 Standard conversion sequences are ordered by their ranks: an Exact
5481 Match is a better conversion than a Promotion, which is a better
5482 conversion than a Conversion.
5484 Two conversion sequences with the same rank are indistinguishable
5485 unless one of the following rules applies:
5487 --A conversion that is not a conversion of a pointer, or pointer
5488 to member, to bool is better than another conversion that is such
5491 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5492 so that we do not have to check it explicitly. */
5493 if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5495 else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1))
5498 to_type1 = TREE_TYPE (ics1);
5499 to_type2 = TREE_TYPE (ics2);
5501 if (TYPE_PTR_P (from_type1)
5502 && TYPE_PTR_P (from_type2)
5503 && TYPE_PTR_P (to_type1)
5504 && TYPE_PTR_P (to_type2))
5506 deref_from_type1 = TREE_TYPE (from_type1);
5507 deref_from_type2 = TREE_TYPE (from_type2);
5508 deref_to_type1 = TREE_TYPE (to_type1);
5509 deref_to_type2 = TREE_TYPE (to_type2);
5511 /* The rules for pointers to members A::* are just like the rules
5512 for pointers A*, except opposite: if B is derived from A then
5513 A::* converts to B::*, not vice versa. For that reason, we
5514 switch the from_ and to_ variables here. */
5515 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5516 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5517 || (TYPE_PTRMEMFUNC_P (from_type1)
5518 && TYPE_PTRMEMFUNC_P (from_type2)
5519 && TYPE_PTRMEMFUNC_P (to_type1)
5520 && TYPE_PTRMEMFUNC_P (to_type2)))
5522 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5523 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5524 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5525 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5528 if (deref_from_type1 != NULL_TREE
5529 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5530 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5532 /* This was one of the pointer or pointer-like conversions.
5536 --If class B is derived directly or indirectly from class A,
5537 conversion of B* to A* is better than conversion of B* to
5538 void*, and conversion of A* to void* is better than
5539 conversion of B* to void*. */
5540 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5541 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5543 if (is_properly_derived_from (deref_from_type1,
5546 else if (is_properly_derived_from (deref_from_type2,
5550 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5551 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5553 if (same_type_p (deref_from_type1, deref_from_type2))
5555 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5557 if (is_properly_derived_from (deref_from_type1,
5561 /* We know that DEREF_TO_TYPE1 is `void' here. */
5562 else if (is_properly_derived_from (deref_from_type1,
5567 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5568 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5572 --If class B is derived directly or indirectly from class A
5573 and class C is derived directly or indirectly from B,
5575 --conversion of C* to B* is better than conversion of C* to
5578 --conversion of B* to A* is better than conversion of C* to
5580 if (same_type_p (deref_from_type1, deref_from_type2))
5582 if (is_properly_derived_from (deref_to_type1,
5585 else if (is_properly_derived_from (deref_to_type2,
5589 else if (same_type_p (deref_to_type1, deref_to_type2))
5591 if (is_properly_derived_from (deref_from_type2,
5594 else if (is_properly_derived_from (deref_from_type1,
5600 else if (CLASS_TYPE_P (non_reference (from_type1))
5601 && same_type_p (from_type1, from_type2))
5603 tree from = non_reference (from_type1);
5607 --binding of an expression of type C to a reference of type
5608 B& is better than binding an expression of type C to a
5609 reference of type A&
5611 --conversion of C to B is better than conversion of C to A, */
5612 if (is_properly_derived_from (from, to_type1)
5613 && is_properly_derived_from (from, to_type2))
5615 if (is_properly_derived_from (to_type1, to_type2))
5617 else if (is_properly_derived_from (to_type2, to_type1))
5621 else if (CLASS_TYPE_P (non_reference (to_type1))
5622 && same_type_p (to_type1, to_type2))
5624 tree to = non_reference (to_type1);
5628 --binding of an expression of type B to a reference of type
5629 A& is better than binding an expression of type C to a
5630 reference of type A&,
5632 --onversion of B to A is better than conversion of C to A */
5633 if (is_properly_derived_from (from_type1, to)
5634 && is_properly_derived_from (from_type2, to))
5636 if (is_properly_derived_from (from_type2, from_type1))
5638 else if (is_properly_derived_from (from_type1, from_type2))
5645 --S1 and S2 differ only in their qualification conversion and yield
5646 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5647 qualification signature of type T1 is a proper subset of the cv-
5648 qualification signature of type T2 */
5649 if (TREE_CODE (ics1) == QUAL_CONV
5650 && TREE_CODE (ics2) == QUAL_CONV
5651 && same_type_p (from_type1, from_type2))
5652 return comp_cv_qual_signature (to_type1, to_type2);
5656 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5657 types to which the references refer are the same type except for
5658 top-level cv-qualifiers, and the type to which the reference
5659 initialized by S2 refers is more cv-qualified than the type to
5660 which the reference initialized by S1 refers */
5662 if (target_type1 && target_type2
5663 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5664 return comp_cv_qualification (target_type2, target_type1);
5666 /* Neither conversion sequence is better than the other. */
5670 /* The source type for this standard conversion sequence. */
5673 source_type (tree t)
5675 for (;; t = TREE_OPERAND (t, 0))
5677 if (TREE_CODE (t) == USER_CONV
5678 || TREE_CODE (t) == AMBIG_CONV
5679 || TREE_CODE (t) == IDENTITY_CONV)
5680 return TREE_TYPE (t);
5685 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5686 a pointer to LOSER and re-running joust to produce the warning if WINNER
5687 is actually used. */
5690 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5692 winner->warnings = tree_cons (NULL_TREE,
5693 build_zc_wrapper (loser),
5697 /* Compare two candidates for overloading as described in
5698 [over.match.best]. Return values:
5700 1: cand1 is better than cand2
5701 -1: cand2 is better than cand1
5702 0: cand1 and cand2 are indistinguishable */
5705 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5708 int i, off1 = 0, off2 = 0, len;
5710 /* Candidates that involve bad conversions are always worse than those
5712 if (cand1->viable > cand2->viable)
5714 if (cand1->viable < cand2->viable)
5717 /* If we have two pseudo-candidates for conversions to the same type,
5718 or two candidates for the same function, arbitrarily pick one. */
5719 if (cand1->fn == cand2->fn
5720 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5723 /* a viable function F1
5724 is defined to be a better function than another viable function F2 if
5725 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5726 ICSi(F2), and then */
5728 /* for some argument j, ICSj(F1) is a better conversion sequence than
5731 /* For comparing static and non-static member functions, we ignore
5732 the implicit object parameter of the non-static function. The
5733 standard says to pretend that the static function has an object
5734 parm, but that won't work with operator overloading. */
5735 len = TREE_VEC_LENGTH (cand1->convs);
5736 if (len != TREE_VEC_LENGTH (cand2->convs))
5738 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5739 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5741 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5742 && DECL_STATIC_FUNCTION_P (cand2->fn))
5751 for (i = 0; i < len; ++i)
5753 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5754 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5755 int comp = compare_ics (t1, t2);
5760 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5761 && TREE_CODE (t1) == STD_CONV
5762 && TREE_CODE (t2) == STD_CONV
5763 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5764 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5765 && (TYPE_PRECISION (TREE_TYPE (t1))
5766 == TYPE_PRECISION (TREE_TYPE (t2)))
5767 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5768 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5771 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5773 struct z_candidate *w, *l;
5775 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5776 w = cand1, l = cand2;
5778 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5779 w = cand2, l = cand1;
5783 warning ("passing `%T' chooses `%T' over `%T'",
5784 type, type1, type2);
5785 warning (" in call to `%D'", w->fn);
5791 if (winner && comp != winner)
5800 /* warn about confusing overload resolution for user-defined conversions,
5801 either between a constructor and a conversion op, or between two
5803 if (winner && warn_conversion && cand1->second_conv
5804 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5805 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5807 struct z_candidate *w, *l;
5808 bool give_warning = false;
5811 w = cand1, l = cand2;
5813 w = cand2, l = cand1;
5815 /* We don't want to complain about `X::operator T1 ()'
5816 beating `X::operator T2 () const', when T2 is a no less
5817 cv-qualified version of T1. */
5818 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5819 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5821 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5822 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5824 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5829 if (!comp_ptr_ttypes (t, f))
5830 give_warning = true;
5833 give_warning = true;
5839 tree source = source_type (TREE_VEC_ELT (w->convs, 0));
5840 if (! DECL_CONSTRUCTOR_P (w->fn))
5841 source = TREE_TYPE (source);
5842 warning ("choosing `%D' over `%D'", w->fn, l->fn);
5843 warning (" for conversion from `%T' to `%T'",
5844 source, TREE_TYPE (w->second_conv));
5845 warning (" because conversion sequence for the argument is better");
5855 F1 is a non-template function and F2 is a template function
5858 if (! cand1->template && cand2->template)
5860 else if (cand1->template && ! cand2->template)
5864 F1 and F2 are template functions and the function template for F1 is
5865 more specialized than the template for F2 according to the partial
5868 if (cand1->template && cand2->template)
5870 winner = more_specialized
5871 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
5873 /* Tell the deduction code how many real function arguments
5874 we saw, not counting the implicit 'this' argument. But,
5875 add_function_candidate() suppresses the "this" argument
5878 [temp.func.order]: The presence of unused ellipsis and default
5879 arguments has no effect on the partial ordering of function
5881 TREE_VEC_LENGTH (cand1->convs)
5882 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
5883 - DECL_CONSTRUCTOR_P (cand1->fn)));
5889 the context is an initialization by user-defined conversion (see
5890 _dcl.init_ and _over.match.user_) and the standard conversion
5891 sequence from the return type of F1 to the destination type (i.e.,
5892 the type of the entity being initialized) is a better conversion
5893 sequence than the standard conversion sequence from the return type
5894 of F2 to the destination type. */
5896 if (cand1->second_conv)
5898 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5903 /* Check whether we can discard a builtin candidate, either because we
5904 have two identical ones or matching builtin and non-builtin candidates.
5906 (Pedantically in the latter case the builtin which matched the user
5907 function should not be added to the overload set, but we spot it here.
5910 ... the builtin candidates include ...
5911 - do not have the same parameter type list as any non-template
5912 non-member candidate. */
5914 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
5915 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
5917 for (i = 0; i < len; ++i)
5918 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5919 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i))))
5921 if (i == TREE_VEC_LENGTH (cand1->convs))
5923 if (cand1->fn == cand2->fn)
5924 /* Two built-in candidates; arbitrarily pick one. */
5926 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5927 /* cand1 is built-in; prefer cand2. */
5930 /* cand2 is built-in; prefer cand1. */
5935 /* If the two functions are the same (this can happen with declarations
5936 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5937 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
5938 && equal_functions (cand1->fn, cand2->fn))
5943 /* Extension: If the worst conversion for one candidate is worse than the
5944 worst conversion for the other, take the first. */
5947 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
5948 struct z_candidate *w = 0, *l = 0;
5950 for (i = 0; i < len; ++i)
5952 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5953 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5954 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5955 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5958 winner = 1, w = cand1, l = cand2;
5960 winner = -1, w = cand2, l = cand1;
5966 ISO C++ says that these are ambiguous, even \
5967 though the worst conversion for the first is better than \
5968 the worst conversion for the second:");
5969 print_z_candidate (_("candidate 1:"), w);
5970 print_z_candidate (_("candidate 2:"), l);
5978 my_friendly_assert (!winner, 20010121);
5982 /* Given a list of candidates for overloading, find the best one, if any.
5983 This algorithm has a worst case of O(2n) (winner is last), and a best
5984 case of O(n/2) (totally ambiguous); much better than a sorting
5987 static struct z_candidate *
5988 tourney (struct z_candidate *candidates)
5990 struct z_candidate *champ = candidates, *challenger;
5992 int champ_compared_to_predecessor = 0;
5994 /* Walk through the list once, comparing each current champ to the next
5995 candidate, knocking out a candidate or two with each comparison. */
5997 for (challenger = champ->next; challenger; )
5999 fate = joust (champ, challenger, 0);
6001 challenger = challenger->next;
6006 champ = challenger->next;
6009 champ_compared_to_predecessor = 0;
6014 champ_compared_to_predecessor = 1;
6017 challenger = champ->next;
6021 /* Make sure the champ is better than all the candidates it hasn't yet
6022 been compared to. */
6024 for (challenger = candidates;
6026 && !(champ_compared_to_predecessor && challenger->next == champ);
6027 challenger = challenger->next)
6029 fate = joust (champ, challenger, 0);
6037 /* Returns nonzero if things of type FROM can be converted to TO. */
6040 can_convert (tree to, tree from)
6042 return can_convert_arg (to, from, NULL_TREE);
6045 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6048 can_convert_arg (tree to, tree from, tree arg)
6050 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6051 return (t && ! ICS_BAD_FLAG (t));
6054 /* Like can_convert_arg, but allows dubious conversions as well. */
6057 can_convert_arg_bad (tree to, tree from, tree arg)
6059 return implicit_conversion (to, from, arg, LOOKUP_NORMAL) != 0;
6062 /* Convert EXPR to TYPE. Return the converted expression.
6064 Note that we allow bad conversions here because by the time we get to
6065 this point we are committed to doing the conversion. If we end up
6066 doing a bad conversion, convert_like will complain. */
6069 perform_implicit_conversion (tree type, tree expr)
6073 if (error_operand_p (expr))
6074 return error_mark_node;
6075 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6079 error ("could not convert `%E' to `%T'", expr, type);
6080 return error_mark_node;
6083 return convert_like (conv, expr);
6086 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6087 permitted. If the conversion is valid, the converted expression is
6088 returned. Otherwise, NULL_TREE is returned, except in the case
6089 that TYPE is a class type; in that case, an error is issued. */
6092 perform_direct_initialization_if_possible (tree type, tree expr)
6096 if (type == error_mark_node || error_operand_p (expr))
6097 return error_mark_node;
6100 If the destination type is a (possibly cv-qualified) class type:
6102 -- If the initialization is direct-initialization ...,
6103 constructors are considered. ... If no constructor applies, or
6104 the overload resolution is ambiguous, the initialization is
6106 if (CLASS_TYPE_P (type))
6108 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6109 build_tree_list (NULL_TREE, expr),
6112 return build_cplus_new (type, expr);
6114 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6116 if (!conv || ICS_BAD_FLAG (conv))
6118 return convert_like_real (conv, expr, NULL_TREE, 0, 0,
6119 /*issue_conversion_warnings=*/false);
6122 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6123 is being bound to a temporary. Create and return a new VAR_DECL
6124 with the indicated TYPE; this variable will store the value to
6125 which the reference is bound. */
6128 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6132 /* Create the variable. */
6133 var = build_decl (VAR_DECL, NULL_TREE, type);
6134 DECL_ARTIFICIAL (var) = 1;
6135 TREE_USED (var) = 1;
6137 /* Register the variable. */
6138 if (TREE_STATIC (decl))
6140 /* Namespace-scope or local static; give it a mangled name. */
6143 TREE_STATIC (var) = 1;
6144 name = mangle_ref_init_variable (decl);
6145 DECL_NAME (var) = name;
6146 SET_DECL_ASSEMBLER_NAME (var, name);
6147 var = pushdecl_top_level (var);
6151 /* Create a new cleanup level if necessary. */
6152 maybe_push_cleanup_level (type);
6153 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6154 DECL_CONTEXT (var) = current_function_decl;
6160 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6161 initializing a variable of that TYPE. If DECL is non-NULL, it is
6162 the VAR_DECL being initialized with the EXPR. (In that case, the
6163 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6164 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6165 return, if *CLEANUP is no longer NULL, it will be a CLEANUP_STMT
6166 that should be inserted after the returned expression is used to
6169 Return the converted expression. */
6172 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6176 if (type == error_mark_node || error_operand_p (expr))
6177 return error_mark_node;
6179 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6180 if (!conv || ICS_BAD_FLAG (conv))
6182 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6183 && !real_lvalue_p (expr))
6184 error ("invalid initialization of non-const reference of "
6185 "type '%T' from a temporary of type '%T'",
6186 type, TREE_TYPE (expr));
6188 error ("invalid initialization of reference of type "
6189 "'%T' from expression of type '%T'", type,
6191 return error_mark_node;
6194 /* If DECL is non-NULL, then this special rule applies:
6198 The temporary to which the reference is bound or the temporary
6199 that is the complete object to which the reference is bound
6200 persists for the lifetime of the reference.
6202 The temporaries created during the evaluation of the expression
6203 initializing the reference, except the temporary to which the
6204 reference is bound, are destroyed at the end of the
6205 full-expression in which they are created.
6207 In that case, we store the converted expression into a new
6208 VAR_DECL in a new scope.
6210 However, we want to be careful not to create temporaries when
6211 they are not required. For example, given:
6214 struct D : public B {};
6218 there is no need to copy the return value from "f"; we can just
6219 extend its lifetime. Similarly, given:
6222 struct T { operator S(); };
6226 we can extend the lifetime of the return value of the conversion
6228 my_friendly_assert (TREE_CODE (conv) == REF_BIND, 20030302);
6232 tree base_conv_type;
6234 /* Skip over the REF_BIND. */
6235 conv = TREE_OPERAND (conv, 0);
6236 /* If the next conversion is a BASE_CONV, skip that too -- but
6237 remember that the conversion was required. */
6238 if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv))
6240 void (*diagnostic_fn) (const char *, ...);
6241 if (CHECK_COPY_CONSTRUCTOR_P (conv))
6242 /* Generate a temporary copy purely to generate the required
6244 build_temp (build_dummy_object (TREE_TYPE (expr)),
6246 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6248 base_conv_type = TREE_TYPE (conv);
6249 conv = TREE_OPERAND (conv, 0);
6252 base_conv_type = NULL_TREE;
6253 /* Perform the remainder of the conversion. */
6254 expr = convert_like (conv, expr);
6255 if (!real_lvalue_p (expr))
6260 /* Create the temporary variable. */
6261 type = TREE_TYPE (expr);
6262 var = make_temporary_var_for_ref_to_temp (decl, type);
6263 layout_decl (var, 0);
6264 /* Create the INIT_EXPR that will initialize the temporary
6266 init = build (INIT_EXPR, type, var, expr);
6267 if (at_function_scope_p ())
6269 add_decl_stmt (var);
6270 *cleanup = cxx_maybe_build_cleanup (var);
6272 /* We must be careful to destroy the temporary only
6273 after its initialization has taken place. If the
6274 initialization throws an exception, then the
6275 destructor should not be run. We cannot simply
6276 transform INIT into something like:
6278 (INIT, ({ CLEANUP_STMT; }))
6280 because emit_local_var always treats the
6281 initializer as a full-expression. Thus, the
6282 destructor would run too early; it would run at the
6283 end of initializing the reference variable, rather
6284 than at the end of the block enclosing the
6287 The solution is to pass back a CLEANUP_STMT which
6288 the caller is responsible for attaching to the
6290 *cleanup = build_stmt (CLEANUP_STMT, var, *cleanup);
6294 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6295 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6296 static_aggregates = tree_cons (NULL_TREE, var,
6299 /* Use its address to initialize the reference variable. */
6300 expr = build_address (var);
6301 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6304 /* Take the address of EXPR. */
6305 expr = build_unary_op (ADDR_EXPR, expr, 0);
6306 /* If a BASE_CONV was required, perform it now. */
6308 expr = (perform_implicit_conversion
6309 (build_pointer_type (base_conv_type), expr));
6310 return build_nop (type, expr);
6313 /* Perform the conversion. */
6314 return convert_like (conv, expr);
6317 #include "gt-cp-call.h"