1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 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 GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* High-level class interface. */
37 #include "diagnostic.h"
39 extern int inhibit_warnings;
41 static tree build_new_method_call PARAMS ((tree, tree, tree, tree, int));
43 static tree build_field_call PARAMS ((tree, tree, tree, tree));
44 static struct z_candidate * tourney PARAMS ((struct z_candidate *));
45 static int equal_functions PARAMS ((tree, tree));
46 static int joust PARAMS ((struct z_candidate *, struct z_candidate *, int));
47 static int compare_ics PARAMS ((tree, tree));
48 static tree build_over_call PARAMS ((struct z_candidate *, tree, int));
49 static tree build_java_interface_fn_ref PARAMS ((tree, tree));
50 #define convert_like(CONV, EXPR) convert_like_real (CONV, EXPR, NULL_TREE, 0, 0)
51 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) convert_like_real (CONV, EXPR, FN, ARGNO, 0)
52 static tree convert_like_real PARAMS ((tree, tree, tree, int, int));
53 static void op_error PARAMS ((enum tree_code, enum tree_code, tree, tree,
55 static tree build_object_call PARAMS ((tree, tree));
56 static tree resolve_args PARAMS ((tree));
57 static struct z_candidate * build_user_type_conversion_1
58 PARAMS ((tree, tree, int));
59 static void print_z_candidates PARAMS ((struct z_candidate *));
60 static tree build_this PARAMS ((tree));
61 static struct z_candidate * splice_viable PARAMS ((struct z_candidate *));
62 static int any_viable PARAMS ((struct z_candidate *));
63 static struct z_candidate * add_template_candidate
64 PARAMS ((struct z_candidate *, tree, tree, tree, tree, tree, int,
66 static struct z_candidate * add_template_candidate_real
67 PARAMS ((struct z_candidate *, tree, tree, tree, tree, tree, int,
68 tree, unification_kind_t));
69 static struct z_candidate * add_template_conv_candidate
70 PARAMS ((struct z_candidate *, tree, tree, tree, tree));
71 static struct z_candidate * add_builtin_candidates
72 PARAMS ((struct z_candidate *, enum tree_code, enum tree_code,
74 static struct z_candidate * add_builtin_candidate
75 PARAMS ((struct z_candidate *, enum tree_code, enum tree_code,
76 tree, tree, tree, tree *, tree *, int));
77 static int is_complete PARAMS ((tree));
78 static struct z_candidate * build_builtin_candidate
79 PARAMS ((struct z_candidate *, tree, tree, tree, tree *, tree *,
81 static struct z_candidate * add_conv_candidate
82 PARAMS ((struct z_candidate *, tree, tree, tree));
83 static struct z_candidate * add_function_candidate
84 PARAMS ((struct z_candidate *, tree, tree, tree, int));
85 static tree implicit_conversion PARAMS ((tree, tree, tree, int));
86 static tree standard_conversion PARAMS ((tree, tree, tree));
87 static tree reference_binding PARAMS ((tree, tree, tree, int));
88 static tree non_reference PARAMS ((tree));
89 static tree build_conv PARAMS ((enum tree_code, tree, tree));
90 static int is_subseq PARAMS ((tree, tree));
91 static int maybe_handle_ref_bind PARAMS ((tree*, tree*));
92 static void maybe_handle_implicit_object PARAMS ((tree*));
93 static struct z_candidate * add_candidate PARAMS ((struct z_candidate *,
95 static tree source_type PARAMS ((tree));
96 static void add_warning PARAMS ((struct z_candidate *, struct z_candidate *));
97 static int reference_related_p PARAMS ((tree, tree));
98 static int reference_compatible_p PARAMS ((tree, tree));
99 static tree convert_class_to_reference PARAMS ((tree, tree, tree));
100 static tree direct_reference_binding PARAMS ((tree, tree));
101 static int promoted_arithmetic_type_p PARAMS ((tree));
102 static tree conditional_conversion PARAMS ((tree, tree));
105 build_vfield_ref (datum, type)
110 if (datum == error_mark_node)
111 return error_mark_node;
113 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
114 datum = convert_from_reference (datum);
116 if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type))
117 rval = build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
118 datum, TYPE_VFIELD (type));
120 rval = build_component_ref (datum, DECL_NAME (TYPE_VFIELD (type)), NULL_TREE, 0);
125 /* Build a call to a member of an object. I.e., one that overloads
126 operator ()(), or is a pointer-to-function or pointer-to-method. */
129 build_field_call (basetype_path, instance_ptr, name, parms)
130 tree basetype_path, instance_ptr, name, parms;
132 tree field, instance;
134 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
137 /* Speed up the common case. */
138 if (instance_ptr == current_class_ptr
139 && IDENTIFIER_CLASS_VALUE (name) == NULL_TREE)
142 field = lookup_field (basetype_path, name, 1, 0);
144 if (field == error_mark_node || field == NULL_TREE)
147 if (TREE_CODE (field) == FIELD_DECL || TREE_CODE (field) == VAR_DECL)
149 /* If it's a field, try overloading operator (),
150 or calling if the field is a pointer-to-function. */
151 instance = build_indirect_ref (instance_ptr, NULL);
152 instance = build_component_ref_1 (instance, field, 0);
154 if (instance == error_mark_node)
155 return error_mark_node;
157 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
158 return build_opfncall (CALL_EXPR, LOOKUP_NORMAL,
159 instance, parms, NULL_TREE);
160 else if (TREE_CODE (TREE_TYPE (instance)) == FUNCTION_TYPE
161 || (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE
162 && (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
164 return build_function_call (instance, parms);
170 /* Returns nonzero iff the destructor name specified in NAME
171 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
175 check_dtor_name (basetype, name)
178 name = TREE_OPERAND (name, 0);
180 /* Just accept something we've already complained about. */
181 if (name == error_mark_node)
184 if (TREE_CODE (name) == TYPE_DECL)
185 name = TREE_TYPE (name);
186 else if (TYPE_P (name))
188 else if (TREE_CODE (name) == IDENTIFIER_NODE)
190 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
191 || (TREE_CODE (basetype) == ENUMERAL_TYPE
192 && name == TYPE_IDENTIFIER (basetype)))
195 name = get_type_value (name);
199 template <class T> struct S { ~S(); };
203 NAME will be a class template. */
204 else if (DECL_CLASS_TEMPLATE_P (name))
207 my_friendly_abort (980605);
209 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
214 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
215 This is how virtual function calls are avoided. */
218 build_scoped_method_call (exp, basetype, name, parms)
219 tree exp, basetype, name, parms;
221 /* Because this syntactic form does not allow
222 a pointer to a base class to be `stolen',
223 we need not protect the derived->base conversion
226 @@ But we do have to check access privileges later. */
228 tree type = TREE_TYPE (exp);
230 if (type == error_mark_node
231 || basetype == error_mark_node)
232 return error_mark_node;
234 if (processing_template_decl)
236 if (TREE_CODE (name) == BIT_NOT_EXPR
237 && TREE_CODE (TREE_OPERAND (name, 0)) == IDENTIFIER_NODE)
239 tree type = get_aggr_from_typedef (TREE_OPERAND (name, 0), 0);
241 name = build_min_nt (BIT_NOT_EXPR, type);
243 name = build_min_nt (SCOPE_REF, basetype, name);
244 return build_min_nt (METHOD_CALL_EXPR, name, exp, parms, NULL_TREE);
247 if (TREE_CODE (type) == REFERENCE_TYPE)
248 type = TREE_TYPE (type);
250 if (TREE_CODE (basetype) == TREE_VEC)
253 basetype = BINFO_TYPE (binfo);
258 /* Check the destructor call syntax. */
259 if (TREE_CODE (name) == BIT_NOT_EXPR)
261 /* We can get here if someone writes their destructor call like
262 `obj.NS::~T()'; this isn't really a scoped method call, so hand
264 if (TREE_CODE (basetype) == NAMESPACE_DECL)
265 return build_method_call (exp, name, parms, NULL_TREE, LOOKUP_NORMAL);
267 if (! check_dtor_name (basetype, name))
268 cp_error ("qualified type `%T' does not match destructor name `~%T'",
269 basetype, TREE_OPERAND (name, 0));
271 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
272 that explicit ~int is caught in the parser; this deals with typedefs
273 and template parms. */
274 if (! IS_AGGR_TYPE (basetype))
276 if (TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (basetype))
277 cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
278 exp, basetype, type);
280 return cp_convert (void_type_node, exp);
284 if (TREE_CODE (basetype) == NAMESPACE_DECL)
286 cp_error ("`%D' is a namespace", basetype);
287 return error_mark_node;
289 if (! is_aggr_type (basetype, 1))
290 return error_mark_node;
292 if (! IS_AGGR_TYPE (type))
294 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
296 return error_mark_node;
301 binfo = get_binfo (basetype, type, 1);
302 if (binfo == error_mark_node)
303 return error_mark_node;
305 error_not_base_type (basetype, type);
310 if (TREE_CODE (exp) == INDIRECT_REF)
311 decl = build_indirect_ref
312 (convert_pointer_to_real
313 (binfo, build_unary_op (ADDR_EXPR, exp, 0)), NULL);
315 decl = build_scoped_ref (exp, basetype);
317 /* Call to a destructor. */
318 if (TREE_CODE (name) == BIT_NOT_EXPR)
320 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl)))
321 return cp_convert (void_type_node, exp);
323 return build_delete (TREE_TYPE (decl), decl,
324 sfk_complete_destructor,
325 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR,
329 /* Call to a method. */
330 return build_method_call (decl, name, parms, binfo,
331 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
333 return error_mark_node;
336 /* We want the address of a function or method. We avoid creating a
337 pointer-to-member function. */
340 build_addr_func (function)
343 tree type = TREE_TYPE (function);
345 /* We have to do these by hand to avoid real pointer to member
347 if (TREE_CODE (type) == METHOD_TYPE)
351 type = build_pointer_type (type);
353 if (mark_addressable (function) == 0)
354 return error_mark_node;
356 addr = build1 (ADDR_EXPR, type, function);
358 /* Address of a static or external variable or function counts
360 if (staticp (function))
361 TREE_CONSTANT (addr) = 1;
366 function = default_conversion (function);
371 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
372 POINTER_TYPE to those. Note, pointer to member function types
373 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
376 build_call (function, parms)
377 tree function, parms;
379 int is_constructor = 0;
385 function = build_addr_func (function);
387 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
389 sorry ("unable to call pointer to member function here");
390 return error_mark_node;
393 result_type = TREE_TYPE (TREE_TYPE (TREE_TYPE (function)));
395 if (TREE_CODE (function) == ADDR_EXPR
396 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
397 decl = TREE_OPERAND (function, 0);
401 /* We check both the decl and the type; a function may be known not to
402 throw without being declared throw(). */
403 nothrow = ((decl && TREE_NOTHROW (decl))
404 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
406 if (decl && DECL_CONSTRUCTOR_P (decl))
409 if (decl && ! TREE_USED (decl))
411 /* We invoke build_call directly for several library functions.
412 These may have been declared normally if we're building libgcc,
413 so we can't just check DECL_ARTIFICIAL. */
414 if (DECL_ARTIFICIAL (decl)
415 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
418 my_friendly_abort (990125);
421 /* Don't pass empty class objects by value. This is useful
422 for tags in STL, which are used to control overload resolution.
423 We don't need to handle other cases of copying empty classes. */
424 if (! decl || ! DECL_BUILT_IN (decl))
425 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
426 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
427 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
429 tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
430 TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
431 TREE_VALUE (tmp), t);
434 function = build_nt (CALL_EXPR, function, parms, NULL_TREE);
435 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
436 TREE_TYPE (function) = result_type;
437 TREE_SIDE_EFFECTS (function) = 1;
438 TREE_NOTHROW (function) = nothrow;
443 /* Build something of the form ptr->method (args)
444 or object.method (args). This can also build
445 calls to constructors, and find friends.
447 Member functions always take their class variable
450 INSTANCE is a class instance.
452 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
454 PARMS help to figure out what that NAME really refers to.
456 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
457 down to the real instance type to use for access checking. We need this
458 information to get protected accesses correct. This parameter is used
459 by build_member_call.
461 FLAGS is the logical disjunction of zero or more LOOKUP_
462 flags. See cp-tree.h for more info.
464 If this is all OK, calls build_function_call with the resolved
467 This function must also handle being called to perform
468 initialization, promotion/coercion of arguments, and
469 instantiation of default parameters.
471 Note that NAME may refer to an instance variable name. If
472 `operator()()' is defined for the type of that field, then we return
475 #ifdef GATHER_STATISTICS
476 extern int n_build_method_call;
480 build_method_call (instance, name, parms, basetype_path, flags)
481 tree instance, name, parms, basetype_path;
484 tree basetype, instance_ptr;
486 #ifdef GATHER_STATISTICS
487 n_build_method_call++;
490 if (instance == error_mark_node
491 || name == error_mark_node
492 || parms == error_mark_node
493 || (instance != NULL_TREE && TREE_TYPE (instance) == error_mark_node))
494 return error_mark_node;
496 if (processing_template_decl)
498 /* We need to process template parm names here so that tsubst catches
499 them properly. Other type names can wait. */
500 if (TREE_CODE (name) == BIT_NOT_EXPR)
502 tree type = NULL_TREE;
504 if (TREE_CODE (TREE_OPERAND (name, 0)) == IDENTIFIER_NODE)
505 type = get_aggr_from_typedef (TREE_OPERAND (name, 0), 0);
506 else if (TREE_CODE (TREE_OPERAND (name, 0)) == TYPE_DECL)
507 type = TREE_TYPE (TREE_OPERAND (name, 0));
509 if (type && TREE_CODE (type) == TEMPLATE_TYPE_PARM)
510 name = build_min_nt (BIT_NOT_EXPR, type);
513 return build_min_nt (METHOD_CALL_EXPR, name, instance, parms, NULL_TREE);
516 if (TREE_CODE (name) == BIT_NOT_EXPR)
519 error ("destructors take no parameters");
520 basetype = TREE_TYPE (instance);
521 if (TREE_CODE (basetype) == REFERENCE_TYPE)
522 basetype = TREE_TYPE (basetype);
524 if (! check_dtor_name (basetype, name))
526 ("destructor name `~%T' does not match type `%T' of expression",
527 TREE_OPERAND (name, 0), basetype);
529 if (! TYPE_HAS_DESTRUCTOR (complete_type (basetype)))
530 return cp_convert (void_type_node, instance);
531 instance = default_conversion (instance);
532 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
533 return build_delete (build_pointer_type (basetype),
534 instance_ptr, sfk_complete_destructor,
535 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
538 return build_new_method_call (instance, name, parms, basetype_path, flags);
541 /* New overloading code. */
551 struct z_candidate *next;
554 #define IDENTITY_RANK 0
560 #define ELLIPSIS_RANK 6
563 #define ICS_RANK(NODE) \
564 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
565 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
566 : ICS_USER_FLAG (NODE) ? USER_RANK \
567 : ICS_STD_RANK (NODE))
569 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
571 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
572 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
573 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
574 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
576 /* In a REF_BIND or a BASE_CONV, this indicates that a temporary
577 should be created to hold the result of the conversion. */
578 #define NEED_TEMPORARY_P(NODE) (TREE_LANG_FLAG_4 ((NODE)))
580 #define USER_CONV_CAND(NODE) \
581 ((struct z_candidate *)WRAPPER_PTR (TREE_OPERAND (NODE, 1)))
582 #define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
590 A null pointer constant is an integral constant expression
591 (_expr.const_) rvalue of integer type that evaluates to zero. */
593 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
599 /* Returns non-zero if PARMLIST consists of only default parms and/or
603 sufficient_parms_p (parmlist)
606 for (; parmlist && parmlist != void_list_node;
607 parmlist = TREE_CHAIN (parmlist))
608 if (!TREE_PURPOSE (parmlist))
614 build_conv (code, type, from)
619 int rank = ICS_STD_RANK (from);
621 /* We can't use buildl1 here because CODE could be USER_CONV, which
622 takes two arguments. In that case, the caller is responsible for
623 filling in the second argument. */
624 t = make_node (code);
625 TREE_TYPE (t) = type;
626 TREE_OPERAND (t, 0) = from;
639 if (rank < EXACT_RANK)
645 ICS_STD_RANK (t) = rank;
646 ICS_USER_FLAG (t) = ICS_USER_FLAG (from);
647 ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);
655 if (TREE_CODE (t) == REFERENCE_TYPE)
664 if (TREE_CODE (t) == ARRAY_TYPE)
666 return TYPE_MAIN_VARIANT (t);
669 /* Returns the standard conversion path (see [conv]) from type FROM to type
670 TO, if any. For proper handling of null pointer constants, you must
671 also pass the expression EXPR to convert from. */
674 standard_conversion (to, from, expr)
677 enum tree_code fcode, tcode;
681 if (TREE_CODE (to) == REFERENCE_TYPE)
683 if (TREE_CODE (from) == REFERENCE_TYPE)
686 from = TREE_TYPE (from);
688 to = strip_top_quals (to);
689 from = strip_top_quals (from);
691 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
692 && expr && type_unknown_p (expr))
694 expr = instantiate_type (to, expr, itf_none);
695 if (expr == error_mark_node)
697 from = TREE_TYPE (expr);
700 fcode = TREE_CODE (from);
701 tcode = TREE_CODE (to);
703 conv = build1 (IDENTITY_CONV, from, expr);
705 if (fcode == FUNCTION_TYPE)
707 from = build_pointer_type (from);
708 fcode = TREE_CODE (from);
709 conv = build_conv (LVALUE_CONV, from, conv);
711 else if (fcode == ARRAY_TYPE)
713 from = build_pointer_type (TREE_TYPE (from));
714 fcode = TREE_CODE (from);
715 conv = build_conv (LVALUE_CONV, from, conv);
717 else if (fromref || (expr && lvalue_p (expr)))
718 conv = build_conv (RVALUE_CONV, from, conv);
720 /* Allow conversion between `__complex__' data types */
721 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
723 /* The standard conversion sequence to convert FROM to TO is
724 the standard conversion sequence to perform componentwise
726 tree part_conv = standard_conversion
727 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
731 conv = build_conv (TREE_CODE (part_conv), to, conv);
732 ICS_STD_RANK (conv) = ICS_STD_RANK (part_conv);
740 if (same_type_p (from, to))
743 if ((tcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (to))
744 && expr && null_ptr_cst_p (expr))
746 conv = build_conv (STD_CONV, to, conv);
748 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE)
750 enum tree_code ufcode = TREE_CODE (TREE_TYPE (from));
751 enum tree_code utcode = TREE_CODE (TREE_TYPE (to));
753 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
756 else if (utcode == VOID_TYPE && ufcode != OFFSET_TYPE
757 && ufcode != FUNCTION_TYPE)
759 from = build_pointer_type
760 (cp_build_qualified_type (void_type_node,
761 CP_TYPE_QUALS (TREE_TYPE (from))));
762 conv = build_conv (PTR_CONV, from, conv);
764 else if (ufcode == OFFSET_TYPE && utcode == OFFSET_TYPE)
766 tree fbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (from));
767 tree tbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (to));
768 tree binfo = get_binfo (fbase, tbase, 1);
770 if (binfo && !binfo_from_vbase (binfo)
771 && (same_type_ignoring_top_level_qualifiers_p
772 (TREE_TYPE (TREE_TYPE (from)),
773 TREE_TYPE (TREE_TYPE (to)))))
775 from = build_offset_type (tbase, TREE_TYPE (TREE_TYPE (from)));
776 from = build_pointer_type (from);
777 conv = build_conv (PMEM_CONV, from, conv);
780 else if (IS_AGGR_TYPE (TREE_TYPE (from))
781 && IS_AGGR_TYPE (TREE_TYPE (to)))
783 if (DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
786 cp_build_qualified_type (TREE_TYPE (to),
787 CP_TYPE_QUALS (TREE_TYPE (from)));
788 from = build_pointer_type (from);
789 conv = build_conv (PTR_CONV, from, conv);
793 if (same_type_p (from, to))
795 else if (comp_ptr_ttypes (TREE_TYPE (to), TREE_TYPE (from)))
796 conv = build_conv (QUAL_CONV, to, conv);
797 else if (expr && string_conv_p (to, expr, 0))
798 /* converting from string constant to char *. */
799 conv = build_conv (QUAL_CONV, to, conv);
800 else if (ptr_reasonably_similar (TREE_TYPE (to), TREE_TYPE (from)))
802 conv = build_conv (PTR_CONV, to, conv);
803 ICS_BAD_FLAG (conv) = 1;
810 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
812 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
813 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
814 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
815 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
816 tree binfo = get_binfo (fbase, tbase, 1);
818 if (!binfo || binfo_from_vbase (binfo)
819 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
820 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
821 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
822 || CP_TYPE_QUALS (fbase) != CP_TYPE_QUALS (tbase))
825 from = cp_build_qualified_type (tbase, CP_TYPE_QUALS (fbase));
826 from = build_cplus_method_type (from, TREE_TYPE (fromfn),
827 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
828 from = build_ptrmemfunc_type (build_pointer_type (from));
829 conv = build_conv (PMEM_CONV, from, conv);
831 else if (tcode == BOOLEAN_TYPE)
833 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE
834 || fcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (from)))
837 conv = build_conv (STD_CONV, to, conv);
838 if (fcode == POINTER_TYPE
839 || (TYPE_PTRMEMFUNC_P (from) && ICS_STD_RANK (conv) < PBOOL_RANK))
840 ICS_STD_RANK (conv) = PBOOL_RANK;
842 /* We don't check for ENUMERAL_TYPE here because there are no standard
843 conversions to enum type. */
844 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
845 || tcode == REAL_TYPE)
847 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
849 conv = build_conv (STD_CONV, to, conv);
851 /* Give this a better rank if it's a promotion. */
852 if (to == type_promotes_to (from)
853 && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK)
854 ICS_STD_RANK (conv) = PROMO_RANK;
856 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
857 && is_properly_derived_from (from, to))
859 if (TREE_CODE (conv) == RVALUE_CONV)
860 conv = TREE_OPERAND (conv, 0);
861 conv = build_conv (BASE_CONV, to, conv);
862 /* The derived-to-base conversion indicates the initialization
863 of a parameter with base type from an object of a derived
864 type. A temporary object is created to hold the result of
866 NEED_TEMPORARY_P (conv) = 1;
874 /* Returns non-zero if T1 is reference-related to T2. */
877 reference_related_p (t1, t2)
881 t1 = TYPE_MAIN_VARIANT (t1);
882 t2 = TYPE_MAIN_VARIANT (t2);
886 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
887 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
889 return (same_type_p (t1, t2)
890 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
891 && DERIVED_FROM_P (t1, t2)));
894 /* Returns non-zero if T1 is reference-compatible with T2. */
897 reference_compatible_p (t1, t2)
903 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
904 reference-related to T2 and cv1 is the same cv-qualification as,
905 or greater cv-qualification than, cv2. */
906 return (reference_related_p (t1, t2)
907 && at_least_as_qualified_p (t1, t2));
910 /* Determine whether or not the EXPR (of class type S) can be
911 converted to T as in [over.match.ref]. */
914 convert_class_to_reference (t, s, expr)
922 struct z_candidate *candidates;
923 struct z_candidate *cand;
927 Assuming that "cv1 T" is the underlying type of the reference
928 being initialized, and "cv S" is the type of the initializer
929 expression, with S a class type, the candidate functions are
932 --The conversion functions of S and its base classes are
933 considered. Those that are not hidden within S and yield type
934 "reference to cv2 T2", where "cv1 T" is reference-compatible
935 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
937 The argument list has one argument, which is the initializer
942 /* Conceptually, we should take the address of EXPR and put it in
943 the argument list. Unfortunately, however, that can result in
944 error messages, which we should not issue now because we are just
945 trying to find a conversion operator. Therefore, we use NULL,
946 cast to the appropriate type. */
947 arglist = build_int_2 (0, 0);
948 TREE_TYPE (arglist) = build_pointer_type (s);
949 arglist = build_tree_list (NULL_TREE, arglist);
951 for (conversions = lookup_conversions (s);
953 conversions = TREE_CHAIN (conversions))
955 tree fns = TREE_VALUE (conversions);
957 for (; fns; fns = OVL_NEXT (fns))
959 tree f = OVL_CURRENT (fns);
960 tree t2 = TREE_TYPE (TREE_TYPE (f));
961 struct z_candidate *old_candidates = candidates;
963 /* If this is a template function, try to get an exact
965 if (TREE_CODE (f) == TEMPLATE_DECL)
968 = add_template_candidate (candidates,
972 build_reference_type (t),
976 if (candidates != old_candidates)
978 /* Now, see if the conversion function really returns
979 an lvalue of the appropriate type. From the
980 point of view of unification, simply returning an
981 rvalue of the right type is good enough. */
983 t2 = TREE_TYPE (TREE_TYPE (f));
984 if (TREE_CODE (t2) != REFERENCE_TYPE
985 || !reference_compatible_p (t, TREE_TYPE (t2)))
986 candidates = candidates->next;
989 else if (TREE_CODE (t2) == REFERENCE_TYPE
990 && reference_compatible_p (t, TREE_TYPE (t2)))
992 = add_function_candidate (candidates, f, s, arglist,
995 if (candidates != old_candidates)
996 candidates->basetype_path = TYPE_BINFO (s);
1000 /* If none of the conversion functions worked out, let our caller
1002 if (!any_viable (candidates))
1005 candidates = splice_viable (candidates);
1006 cand = tourney (candidates);
1010 conv = build1 (IDENTITY_CONV, s, expr);
1011 conv = build_conv (USER_CONV,
1012 non_reference (TREE_TYPE (TREE_TYPE (cand->fn))),
1014 TREE_OPERAND (conv, 1) = build_ptr_wrapper (cand);
1015 ICS_USER_FLAG (conv) = 1;
1016 if (cand->viable == -1)
1017 ICS_BAD_FLAG (conv) = 1;
1018 cand->second_conv = conv;
1023 /* A reference of the indicated TYPE is being bound directly to the
1024 expression represented by the implicit conversion sequence CONV.
1025 Return a conversion sequence for this binding. */
1028 direct_reference_binding (type, conv)
1032 tree t = TREE_TYPE (type);
1036 When a parameter of reference type binds directly
1037 (_dcl.init.ref_) to an argument expression, the implicit
1038 conversion sequence is the identity conversion, unless the
1039 argument expression has a type that is a derived class of the
1040 parameter type, in which case the implicit conversion sequence is
1041 a derived-to-base Conversion.
1043 If the parameter binds directly to the result of applying a
1044 conversion function to the argument expression, the implicit
1045 conversion sequence is a user-defined conversion sequence
1046 (_over.ics.user_), with the second standard conversion sequence
1047 either an identity conversion or, if the conversion function
1048 returns an entity of a type that is a derived class of the
1049 parameter type, a derived-to-base conversion. */
1050 if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv)))
1052 /* Represent the derived-to-base conversion. */
1053 conv = build_conv (BASE_CONV, t, conv);
1054 /* We will actually be binding to the base-class subobject in
1055 the derived class, so we mark this conversion appropriately.
1056 That way, convert_like knows not to generate a temporary. */
1057 NEED_TEMPORARY_P (conv) = 0;
1059 return build_conv (REF_BIND, type, conv);
1062 /* Returns the conversion path from type FROM to reference type TO for
1063 purposes of reference binding. For lvalue binding, either pass a
1064 reference type to FROM or an lvalue expression to EXPR. If the
1065 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1066 the conversion returned. */
1069 reference_binding (rto, rfrom, expr, flags)
1070 tree rto, rfrom, expr;
1073 tree conv = NULL_TREE;
1074 tree to = TREE_TYPE (rto);
1078 cp_lvalue_kind lvalue_p = clk_none;
1080 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1082 expr = instantiate_type (to, expr, itf_none);
1083 if (expr == error_mark_node)
1085 from = TREE_TYPE (expr);
1088 if (TREE_CODE (from) == REFERENCE_TYPE)
1090 /* Anything with reference type is an lvalue. */
1091 lvalue_p = clk_ordinary;
1092 from = TREE_TYPE (from);
1095 lvalue_p = real_lvalue_p (expr);
1097 /* Figure out whether or not the types are reference-related and
1098 reference compatible. We have do do this after stripping
1099 references from FROM. */
1100 related_p = reference_related_p (to, from);
1101 compatible_p = reference_compatible_p (to, from);
1103 if (lvalue_p && compatible_p)
1107 If the intializer expression
1109 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1110 is reference-compatible with "cv2 T2,"
1112 the reference is bound directly to the initializer exprssion
1114 conv = build1 (IDENTITY_CONV, from, expr);
1115 conv = direct_reference_binding (rto, conv);
1116 if ((lvalue_p & clk_bitfield) != 0
1117 && CP_TYPE_CONST_NON_VOLATILE_P (to))
1118 /* For the purposes of overload resolution, we ignore the fact
1119 this expression is a bitfield. (In particular,
1120 [over.ics.ref] says specifically that a function with a
1121 non-const reference parameter is viable even if the
1122 argument is a bitfield.)
1124 However, when we actually call the function we must create
1125 a temporary to which to bind the reference. If the
1126 reference is volatile, or isn't const, then we cannot make
1127 a temporary, so we just issue an error when the conversion
1129 NEED_TEMPORARY_P (conv) = 1;
1132 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1136 If the initializer exprsesion
1138 -- has a class type (i.e., T2 is a class type) can be
1139 implicitly converted to an lvalue of type "cv3 T3," where
1140 "cv1 T1" is reference-compatible with "cv3 T3". (this
1141 conversion is selected by enumerating the applicable
1142 conversion functions (_over.match.ref_) and choosing the
1143 best one through overload resolution. (_over.match_).
1145 the reference is bound to the lvalue result of the conversion
1146 in the second case. */
1147 conv = convert_class_to_reference (to, from, expr);
1149 return direct_reference_binding (rto, conv);
1152 /* From this point on, we conceptually need temporaries, even if we
1153 elide them. Only the cases above are "direct bindings". */
1154 if (flags & LOOKUP_NO_TEMP_BIND)
1159 When a parameter of reference type is not bound directly to an
1160 argument expression, the conversion sequence is the one required
1161 to convert the argument expression to the underlying type of the
1162 reference according to _over.best.ics_. Conceptually, this
1163 conversion sequence corresponds to copy-initializing a temporary
1164 of the underlying type with the argument expression. Any
1165 difference in top-level cv-qualification is subsumed by the
1166 initialization itself and does not constitute a conversion. */
1170 Otherwise, the reference shall be to a non-volatile const type. */
1171 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1176 If the initializer expression is an rvalue, with T2 a class type,
1177 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1178 is bound in one of the following ways:
1180 -- The reference is bound to the object represented by the rvalue
1181 or to a sub-object within that object.
1183 In this case, the implicit conversion sequence is supposed to be
1184 same as we would obtain by generating a temporary. Fortunately,
1185 if the types are reference compatible, then this is either an
1186 identity conversion or the derived-to-base conversion, just as
1187 for direct binding. */
1188 if (CLASS_TYPE_P (from) && compatible_p)
1190 conv = build1 (IDENTITY_CONV, from, expr);
1191 return direct_reference_binding (rto, conv);
1196 Otherwise, a temporary of type "cv1 T1" is created and
1197 initialized from the initializer expression using the rules for a
1198 non-reference copy initialization. If T1 is reference-related to
1199 T2, cv1 must be the same cv-qualification as, or greater
1200 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1201 if (related_p && !at_least_as_qualified_p (to, from))
1204 conv = implicit_conversion (to, from, expr, flags);
1208 conv = build_conv (REF_BIND, rto, conv);
1209 /* This reference binding, unlike those above, requires the
1210 creation of a temporary. */
1211 NEED_TEMPORARY_P (conv) = 1;
1216 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1217 to type TO. The optional expression EXPR may affect the conversion.
1218 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1222 implicit_conversion (to, from, expr, flags)
1223 tree to, from, expr;
1227 struct z_candidate *cand;
1229 /* Resolve expressions like `A::p' that we thought might become
1230 pointers-to-members. */
1231 if (expr && TREE_CODE (expr) == OFFSET_REF)
1233 expr = resolve_offset_ref (expr);
1234 from = TREE_TYPE (expr);
1237 if (from == error_mark_node || to == error_mark_node
1238 || expr == error_mark_node)
1241 /* Make sure both the FROM and TO types are complete so that
1242 user-defined conversions are available. */
1243 complete_type (from);
1246 if (TREE_CODE (to) == REFERENCE_TYPE)
1247 conv = reference_binding (to, from, expr, flags);
1249 conv = standard_conversion (to, from, expr);
1253 else if (expr != NULL_TREE
1254 && (IS_AGGR_TYPE (from)
1255 || IS_AGGR_TYPE (to))
1256 && (flags & LOOKUP_NO_CONVERSION) == 0)
1258 cand = build_user_type_conversion_1
1259 (to, expr, LOOKUP_ONLYCONVERTING);
1261 conv = cand->second_conv;
1263 /* We used to try to bind a reference to a temporary here, but that
1264 is now handled by the recursive call to this function at the end
1265 of reference_binding. */
1271 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1274 static struct z_candidate *
1275 add_candidate (candidates, fn, convs, viable)
1276 struct z_candidate *candidates;
1280 struct z_candidate *cand
1281 = (struct z_candidate *) ggc_alloc_cleared (sizeof (struct z_candidate));
1284 cand->convs = convs;
1285 cand->viable = viable;
1286 cand->next = candidates;
1291 /* Create an overload candidate for the function or method FN called with
1292 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1293 to implicit_conversion.
1295 CTYPE, if non-NULL, is the type we want to pretend this function
1296 comes from for purposes of overload resolution. */
1298 static struct z_candidate *
1299 add_function_candidate (candidates, fn, ctype, arglist, flags)
1300 struct z_candidate *candidates;
1301 tree fn, ctype, arglist;
1304 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1307 tree parmnode, argnode;
1310 /* The `this', `in_chrg' and VTT arguments to constructors are not
1311 considered in overload resolution. */
1312 if (DECL_CONSTRUCTOR_P (fn))
1314 parmlist = skip_artificial_parms_for (fn, parmlist);
1315 arglist = skip_artificial_parms_for (fn, arglist);
1318 len = list_length (arglist);
1319 convs = make_tree_vec (len);
1321 /* 13.3.2 - Viable functions [over.match.viable]
1322 First, to be a viable function, a candidate function shall have enough
1323 parameters to agree in number with the arguments in the list.
1325 We need to check this first; otherwise, checking the ICSes might cause
1326 us to produce an ill-formed template instantiation. */
1328 parmnode = parmlist;
1329 for (i = 0; i < len; ++i)
1331 if (parmnode == NULL_TREE || parmnode == void_list_node)
1333 parmnode = TREE_CHAIN (parmnode);
1336 if (i < len && parmnode)
1339 /* Make sure there are default args for the rest of the parms. */
1340 else if (!sufficient_parms_p (parmnode))
1346 /* Second, for F to be a viable function, there shall exist for each
1347 argument an implicit conversion sequence that converts that argument
1348 to the corresponding parameter of F. */
1350 parmnode = parmlist;
1353 for (i = 0; i < len; ++i)
1355 tree arg = TREE_VALUE (argnode);
1356 tree argtype = lvalue_type (arg);
1360 if (parmnode == void_list_node)
1363 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1364 && ! DECL_CONSTRUCTOR_P (fn));
1368 tree parmtype = TREE_VALUE (parmnode);
1370 /* The type of the implicit object parameter ('this') for
1371 overload resolution is not always the same as for the
1372 function itself; conversion functions are considered to
1373 be members of the class being converted, and functions
1374 introduced by a using-declaration are considered to be
1375 members of the class that uses them.
1377 Since build_over_call ignores the ICS for the `this'
1378 parameter, we can just change the parm type. */
1379 if (ctype && is_this)
1382 = build_qualified_type (ctype,
1383 TYPE_QUALS (TREE_TYPE (parmtype)));
1384 parmtype = build_pointer_type (parmtype);
1387 t = implicit_conversion (parmtype, argtype, arg, flags);
1391 t = build1 (IDENTITY_CONV, argtype, arg);
1392 ICS_ELLIPSIS_FLAG (t) = 1;
1396 ICS_THIS_FLAG (t) = 1;
1398 TREE_VEC_ELT (convs, i) = t;
1405 if (ICS_BAD_FLAG (t))
1409 parmnode = TREE_CHAIN (parmnode);
1410 argnode = TREE_CHAIN (argnode);
1414 return add_candidate (candidates, fn, convs, viable);
1417 /* Create an overload candidate for the conversion function FN which will
1418 be invoked for expression OBJ, producing a pointer-to-function which
1419 will in turn be called with the argument list ARGLIST, and add it to
1420 CANDIDATES. FLAGS is passed on to implicit_conversion.
1422 Actually, we don't really care about FN; we care about the type it
1423 converts to. There may be multiple conversion functions that will
1424 convert to that type, and we rely on build_user_type_conversion_1 to
1425 choose the best one; so when we create our candidate, we record the type
1426 instead of the function. */
1428 static struct z_candidate *
1429 add_conv_candidate (candidates, fn, obj, arglist)
1430 struct z_candidate *candidates;
1431 tree fn, obj, arglist;
1433 tree totype = TREE_TYPE (TREE_TYPE (fn));
1434 int i, len, viable, flags;
1435 tree parmlist, convs, parmnode, argnode;
1437 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1438 parmlist = TREE_TYPE (parmlist);
1439 parmlist = TYPE_ARG_TYPES (parmlist);
1441 len = list_length (arglist) + 1;
1442 convs = make_tree_vec (len);
1443 parmnode = parmlist;
1446 flags = LOOKUP_NORMAL;
1448 /* Don't bother looking up the same type twice. */
1449 if (candidates && candidates->fn == totype)
1452 for (i = 0; i < len; ++i)
1454 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1455 tree argtype = lvalue_type (arg);
1459 t = implicit_conversion (totype, argtype, arg, flags);
1460 else if (parmnode == void_list_node)
1463 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1466 t = build1 (IDENTITY_CONV, argtype, arg);
1467 ICS_ELLIPSIS_FLAG (t) = 1;
1470 TREE_VEC_ELT (convs, i) = t;
1474 if (ICS_BAD_FLAG (t))
1481 parmnode = TREE_CHAIN (parmnode);
1482 argnode = TREE_CHAIN (argnode);
1488 if (!sufficient_parms_p (parmnode))
1491 return add_candidate (candidates, totype, convs, viable);
1494 static struct z_candidate *
1495 build_builtin_candidate (candidates, fnname, type1, type2,
1496 args, argtypes, flags)
1497 struct z_candidate *candidates;
1498 tree fnname, type1, type2, *args, *argtypes;
1509 convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
1511 for (i = 0; i < 2; ++i)
1516 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1520 /* We need something for printing the candidate. */
1521 t = build1 (IDENTITY_CONV, types[i], NULL_TREE);
1523 else if (ICS_BAD_FLAG (t))
1525 TREE_VEC_ELT (convs, i) = t;
1528 /* For COND_EXPR we rearranged the arguments; undo that now. */
1531 TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1);
1532 TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0);
1533 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1535 TREE_VEC_ELT (convs, 0) = t;
1540 return add_candidate (candidates, fnname, convs, viable);
1547 return COMPLETE_TYPE_P (complete_type (t));
1550 /* Returns non-zero if TYPE is a promoted arithmetic type. */
1553 promoted_arithmetic_type_p (type)
1558 In this section, the term promoted integral type is used to refer
1559 to those integral types which are preserved by integral promotion
1560 (including e.g. int and long but excluding e.g. char).
1561 Similarly, the term promoted arithmetic type refers to promoted
1562 integral types plus floating types. */
1563 return ((INTEGRAL_TYPE_P (type)
1564 && same_type_p (type_promotes_to (type), type))
1565 || TREE_CODE (type) == REAL_TYPE);
1568 /* Create any builtin operator overload candidates for the operator in
1569 question given the converted operand types TYPE1 and TYPE2. The other
1570 args are passed through from add_builtin_candidates to
1571 build_builtin_candidate.
1573 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1574 If CODE is requires candidates operands of the same type of the kind
1575 of which TYPE1 and TYPE2 are, we add both candidates
1576 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1578 static struct z_candidate *
1579 add_builtin_candidate (candidates, code, code2, fnname, type1, type2,
1580 args, argtypes, flags)
1581 struct z_candidate *candidates;
1582 enum tree_code code, code2;
1583 tree fnname, type1, type2, *args, *argtypes;
1588 case POSTINCREMENT_EXPR:
1589 case POSTDECREMENT_EXPR:
1590 args[1] = integer_zero_node;
1591 type2 = integer_type_node;
1600 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1601 and VQ is either volatile or empty, there exist candidate operator
1602 functions of the form
1603 VQ T& operator++(VQ T&);
1604 T operator++(VQ T&, int);
1605 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1606 type other than bool, and VQ is either volatile or empty, there exist
1607 candidate operator functions of the form
1608 VQ T& operator--(VQ T&);
1609 T operator--(VQ T&, int);
1610 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1611 complete object type, and VQ is either volatile or empty, there exist
1612 candidate operator functions of the form
1613 T*VQ& operator++(T*VQ&);
1614 T*VQ& operator--(T*VQ&);
1615 T* operator++(T*VQ&, int);
1616 T* operator--(T*VQ&, int); */
1618 case POSTDECREMENT_EXPR:
1619 case PREDECREMENT_EXPR:
1620 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1622 case POSTINCREMENT_EXPR:
1623 case PREINCREMENT_EXPR:
1624 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1626 type1 = build_reference_type (type1);
1631 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1632 exist candidate operator functions of the form
1636 8 For every function type T, there exist candidate operator functions of
1638 T& operator*(T*); */
1641 if (TREE_CODE (type1) == POINTER_TYPE
1642 && (TYPE_PTROB_P (type1)
1643 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1647 /* 9 For every type T, there exist candidate operator functions of the form
1650 10For every promoted arithmetic type T, there exist candidate operator
1651 functions of the form
1655 case CONVERT_EXPR: /* unary + */
1656 if (TREE_CODE (type1) == POINTER_TYPE
1657 && TREE_CODE (TREE_TYPE (type1)) != OFFSET_TYPE)
1660 if (ARITHMETIC_TYPE_P (type1))
1664 /* 11For every promoted integral type T, there exist candidate operator
1665 functions of the form
1669 if (INTEGRAL_TYPE_P (type1))
1673 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1674 is the same type as C2 or is a derived class of C2, T is a complete
1675 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1676 there exist candidate operator functions of the form
1677 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1678 where CV12 is the union of CV1 and CV2. */
1681 if (TREE_CODE (type1) == POINTER_TYPE
1682 && (TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2)))
1684 tree c1 = TREE_TYPE (type1);
1685 tree c2 = (TYPE_PTRMEMFUNC_P (type2)
1686 ? TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2)))
1687 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2)));
1689 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1690 && (TYPE_PTRMEMFUNC_P (type2)
1691 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1696 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1697 didate operator functions of the form
1702 bool operator<(L, R);
1703 bool operator>(L, R);
1704 bool operator<=(L, R);
1705 bool operator>=(L, R);
1706 bool operator==(L, R);
1707 bool operator!=(L, R);
1708 where LR is the result of the usual arithmetic conversions between
1711 14For every pair of types T and I, where T is a cv-qualified or cv-
1712 unqualified complete object type and I is a promoted integral type,
1713 there exist candidate operator functions of the form
1714 T* operator+(T*, I);
1715 T& operator[](T*, I);
1716 T* operator-(T*, I);
1717 T* operator+(I, T*);
1718 T& operator[](I, T*);
1720 15For every T, where T is a pointer to complete object type, there exist
1721 candidate operator functions of the form112)
1722 ptrdiff_t operator-(T, T);
1724 16For every pointer or enumeration type T, there exist candidate operator
1725 functions of the form
1726 bool operator<(T, T);
1727 bool operator>(T, T);
1728 bool operator<=(T, T);
1729 bool operator>=(T, T);
1730 bool operator==(T, T);
1731 bool operator!=(T, T);
1733 17For every pointer to member type T, there exist candidate operator
1734 functions of the form
1735 bool operator==(T, T);
1736 bool operator!=(T, T); */
1739 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1741 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1743 type2 = ptrdiff_type_node;
1747 case TRUNC_DIV_EXPR:
1748 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1754 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1755 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1757 if ((TYPE_PTRMEMFUNC_P (type1) || TYPE_PTRMEM_P (type1))
1758 && null_ptr_cst_p (args[1]))
1763 if ((TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2))
1764 && null_ptr_cst_p (args[0]))
1776 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1778 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1780 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1782 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1787 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1795 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1798 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1800 type1 = ptrdiff_type_node;
1803 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1805 type2 = ptrdiff_type_node;
1810 /* 18For every pair of promoted integral types L and R, there exist candi-
1811 date operator functions of the form
1818 where LR is the result of the usual arithmetic conversions between
1821 case TRUNC_MOD_EXPR:
1827 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1831 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1832 type, VQ is either volatile or empty, and R is a promoted arithmetic
1833 type, there exist candidate operator functions of the form
1834 VQ L& operator=(VQ L&, R);
1835 VQ L& operator*=(VQ L&, R);
1836 VQ L& operator/=(VQ L&, R);
1837 VQ L& operator+=(VQ L&, R);
1838 VQ L& operator-=(VQ L&, R);
1840 20For every pair T, VQ), where T is any type and VQ is either volatile
1841 or empty, there exist candidate operator functions of the form
1842 T*VQ& operator=(T*VQ&, T*);
1844 21For every pair T, VQ), where T is a pointer to member type and VQ is
1845 either volatile or empty, there exist candidate operator functions of
1847 VQ T& operator=(VQ T&, T);
1849 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1850 unqualified complete object type, VQ is either volatile or empty, and
1851 I is a promoted integral type, there exist candidate operator func-
1853 T*VQ& operator+=(T*VQ&, I);
1854 T*VQ& operator-=(T*VQ&, I);
1856 23For every triple L, VQ, R), where L is an integral or enumeration
1857 type, VQ is either volatile or empty, and R is a promoted integral
1858 type, there exist candidate operator functions of the form
1860 VQ L& operator%=(VQ L&, R);
1861 VQ L& operator<<=(VQ L&, R);
1862 VQ L& operator>>=(VQ L&, R);
1863 VQ L& operator&=(VQ L&, R);
1864 VQ L& operator^=(VQ L&, R);
1865 VQ L& operator|=(VQ L&, R); */
1872 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1874 type2 = ptrdiff_type_node;
1878 case TRUNC_DIV_EXPR:
1879 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1883 case TRUNC_MOD_EXPR:
1889 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1894 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1896 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1897 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1898 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1899 || ((TYPE_PTRMEMFUNC_P (type1)
1900 || TREE_CODE (type1) == POINTER_TYPE)
1901 && null_ptr_cst_p (args[1])))
1909 my_friendly_abort (367);
1911 type1 = build_reference_type (type1);
1917 For every pair of promoted arithmetic types L and R, there
1918 exist candidate operator functions of the form
1920 LR operator?(bool, L, R);
1922 where LR is the result of the usual arithmetic conversions
1923 between types L and R.
1925 For every type T, where T is a pointer or pointer-to-member
1926 type, there exist candidate operator functions of the form T
1927 operator?(bool, T, T); */
1929 if (promoted_arithmetic_type_p (type1)
1930 && promoted_arithmetic_type_p (type2))
1934 /* Otherwise, the types should be pointers. */
1935 if (!(TREE_CODE (type1) == POINTER_TYPE
1936 || TYPE_PTRMEM_P (type1)
1937 || TYPE_PTRMEMFUNC_P (type1))
1938 || !(TREE_CODE (type2) == POINTER_TYPE
1939 || TYPE_PTRMEM_P (type2)
1940 || TYPE_PTRMEMFUNC_P (type2)))
1943 /* We don't check that the two types are the same; the logic
1944 below will actually create two candidates; one in which both
1945 parameter types are TYPE1, and one in which both parameter
1949 /* These arguments do not make for a legal overloaded operator. */
1953 my_friendly_abort (367);
1956 /* If we're dealing with two pointer types or two enumeral types,
1957 we need candidates for both of them. */
1958 if (type2 && !same_type_p (type1, type2)
1959 && TREE_CODE (type1) == TREE_CODE (type2)
1960 && (TREE_CODE (type1) == REFERENCE_TYPE
1961 || (TREE_CODE (type1) == POINTER_TYPE
1962 && TYPE_PTRMEM_P (type1) == TYPE_PTRMEM_P (type2))
1963 || TYPE_PTRMEMFUNC_P (type1)
1964 || IS_AGGR_TYPE (type1)
1965 || TREE_CODE (type1) == ENUMERAL_TYPE))
1967 candidates = build_builtin_candidate
1968 (candidates, fnname, type1, type1, args, argtypes, flags);
1969 return build_builtin_candidate
1970 (candidates, fnname, type2, type2, args, argtypes, flags);
1973 return build_builtin_candidate
1974 (candidates, fnname, type1, type2, args, argtypes, flags);
1978 type_decays_to (type)
1981 if (TREE_CODE (type) == ARRAY_TYPE)
1982 return build_pointer_type (TREE_TYPE (type));
1983 if (TREE_CODE (type) == FUNCTION_TYPE)
1984 return build_pointer_type (type);
1988 /* There are three conditions of builtin candidates:
1990 1) bool-taking candidates. These are the same regardless of the input.
1991 2) pointer-pair taking candidates. These are generated for each type
1992 one of the input types converts to.
1993 3) arithmetic candidates. According to the standard, we should generate
1994 all of these, but I'm trying not to...
1996 Here we generate a superset of the possible candidates for this particular
1997 case. That is a subset of the full set the standard defines, plus some
1998 other cases which the standard disallows. add_builtin_candidate will
1999 filter out the illegal set. */
2001 static struct z_candidate *
2002 add_builtin_candidates (candidates, code, code2, fnname, args, flags)
2003 struct z_candidate *candidates;
2004 enum tree_code code, code2;
2010 tree type, argtypes[3];
2011 /* TYPES[i] is the set of possible builtin-operator parameter types
2012 we will consider for the Ith argument. These are represented as
2013 a TREE_LIST; the TREE_VALUE of each node is the potential
2017 for (i = 0; i < 3; ++i)
2020 argtypes[i] = lvalue_type (args[i]);
2022 argtypes[i] = NULL_TREE;
2027 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2028 and VQ is either volatile or empty, there exist candidate operator
2029 functions of the form
2030 VQ T& operator++(VQ T&); */
2032 case POSTINCREMENT_EXPR:
2033 case PREINCREMENT_EXPR:
2034 case POSTDECREMENT_EXPR:
2035 case PREDECREMENT_EXPR:
2040 /* 24There also exist candidate operator functions of the form
2041 bool operator!(bool);
2042 bool operator&&(bool, bool);
2043 bool operator||(bool, bool); */
2045 case TRUTH_NOT_EXPR:
2046 return build_builtin_candidate
2047 (candidates, fnname, boolean_type_node,
2048 NULL_TREE, args, argtypes, flags);
2050 case TRUTH_ORIF_EXPR:
2051 case TRUTH_ANDIF_EXPR:
2052 return build_builtin_candidate
2053 (candidates, fnname, boolean_type_node,
2054 boolean_type_node, args, argtypes, flags);
2075 types[0] = types[1] = NULL_TREE;
2077 for (i = 0; i < 2; ++i)
2081 else if (IS_AGGR_TYPE (argtypes[i]))
2085 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2088 convs = lookup_conversions (argtypes[i]);
2090 if (code == COND_EXPR)
2092 if (real_lvalue_p (args[i]))
2093 types[i] = tree_cons
2094 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2096 types[i] = tree_cons
2097 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2103 for (; convs; convs = TREE_CHAIN (convs))
2105 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2108 && (TREE_CODE (type) != REFERENCE_TYPE
2109 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2112 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2113 types[i] = tree_cons (NULL_TREE, type, types[i]);
2115 type = non_reference (type);
2116 if (i != 0 || ! ref1)
2118 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2119 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2120 types[i] = tree_cons (NULL_TREE, type, types[i]);
2121 if (INTEGRAL_TYPE_P (type))
2122 type = type_promotes_to (type);
2125 if (! value_member (type, types[i]))
2126 types[i] = tree_cons (NULL_TREE, type, types[i]);
2131 if (code == COND_EXPR && real_lvalue_p (args[i]))
2132 types[i] = tree_cons
2133 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2134 type = non_reference (argtypes[i]);
2135 if (i != 0 || ! ref1)
2137 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2138 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2139 types[i] = tree_cons (NULL_TREE, type, types[i]);
2140 if (INTEGRAL_TYPE_P (type))
2141 type = type_promotes_to (type);
2143 types[i] = tree_cons (NULL_TREE, type, types[i]);
2147 /* Run through the possible parameter types of both arguments,
2148 creating candidates with those parameter types. */
2149 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2152 for (type = types[1]; type; type = TREE_CHAIN (type))
2153 candidates = add_builtin_candidate
2154 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2155 TREE_VALUE (type), args, argtypes, flags);
2157 candidates = add_builtin_candidate
2158 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2159 NULL_TREE, args, argtypes, flags);
2166 /* If TMPL can be successfully instantiated as indicated by
2167 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2169 TMPL is the template. EXPLICIT_TARGS are any explicit template
2170 arguments. ARGLIST is the arguments provided at the call-site.
2171 The RETURN_TYPE is the desired type for conversion operators. If
2172 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2173 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2174 add_conv_candidate. */
2176 static struct z_candidate*
2177 add_template_candidate_real (candidates, tmpl, ctype, explicit_targs,
2178 arglist, return_type, flags,
2180 struct z_candidate *candidates;
2181 tree tmpl, ctype, explicit_targs, arglist, return_type;
2184 unification_kind_t strict;
2186 int ntparms = DECL_NTPARMS (tmpl);
2187 tree targs = make_tree_vec (ntparms);
2188 tree args_without_in_chrg = arglist;
2189 struct z_candidate *cand;
2193 /* We don't do deduction on the in-charge parameter, the VTT
2194 parameter or 'this'. */
2195 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2196 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2198 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2199 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2200 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
2201 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2203 i = fn_type_unification (tmpl, explicit_targs, targs,
2204 args_without_in_chrg,
2205 return_type, strict, -1);
2210 fn = instantiate_template (tmpl, targs);
2211 if (fn == error_mark_node)
2214 if (obj != NULL_TREE)
2215 /* Aha, this is a conversion function. */
2216 cand = add_conv_candidate (candidates, fn, obj, arglist);
2218 cand = add_function_candidate (candidates, fn, ctype,
2220 if (DECL_TI_TEMPLATE (fn) != tmpl)
2221 /* This situation can occur if a member template of a template
2222 class is specialized. Then, instantiate_template might return
2223 an instantiation of the specialization, in which case the
2224 DECL_TI_TEMPLATE field will point at the original
2225 specialization. For example:
2227 template <class T> struct S { template <class U> void f(U);
2228 template <> void f(int) {}; };
2232 Here, TMPL will be template <class U> S<double>::f(U).
2233 And, instantiate template will give us the specialization
2234 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2235 for this will point at template <class T> template <> S<T>::f(int),
2236 so that we can find the definition. For the purposes of
2237 overload resolution, however, we want the original TMPL. */
2238 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2240 cand->template = DECL_TEMPLATE_INFO (fn);
2246 static struct z_candidate *
2247 add_template_candidate (candidates, tmpl, ctype, explicit_targs,
2248 arglist, return_type, flags, strict)
2249 struct z_candidate *candidates;
2250 tree tmpl, ctype, explicit_targs, arglist, return_type;
2252 unification_kind_t strict;
2255 add_template_candidate_real (candidates, tmpl, ctype,
2256 explicit_targs, arglist, return_type, flags,
2261 static struct z_candidate *
2262 add_template_conv_candidate (candidates, tmpl, obj, arglist, return_type)
2263 struct z_candidate *candidates;
2264 tree tmpl, obj, arglist, return_type;
2267 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2268 arglist, return_type, 0, obj, DEDUCE_CONV);
2274 struct z_candidate *cands;
2276 for (; cands; cands = cands->next)
2277 if (pedantic ? cands->viable == 1 : cands->viable)
2282 static struct z_candidate *
2283 splice_viable (cands)
2284 struct z_candidate *cands;
2286 struct z_candidate **p = &cands;
2290 if (pedantic ? (*p)->viable == 1 : (*p)->viable)
2303 /* Fix this to work on non-lvalues. */
2304 return build_unary_op (ADDR_EXPR, obj, 0);
2308 print_z_candidates (candidates)
2309 struct z_candidate *candidates;
2311 const char *str = "candidates are:";
2312 for (; candidates; candidates = candidates->next)
2314 if (TREE_CODE (candidates->fn) == IDENTIFIER_NODE)
2316 if (TREE_VEC_LENGTH (candidates->convs) == 3)
2317 cp_error ("%s %D(%T, %T, %T) <builtin>", str, candidates->fn,
2318 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
2319 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)),
2320 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 2)));
2321 else if (TREE_VEC_LENGTH (candidates->convs) == 2)
2322 cp_error ("%s %D(%T, %T) <builtin>", str, candidates->fn,
2323 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
2324 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)));
2326 cp_error ("%s %D(%T) <builtin>", str, candidates->fn,
2327 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)));
2329 else if (TYPE_P (candidates->fn))
2330 cp_error ("%s %T <conversion>", str, candidates->fn);
2332 cp_error_at ("%s %+#D%s", str, candidates->fn,
2333 candidates->viable == -1 ? " <near match>" : "");
2338 /* Returns the best overload candidate to perform the requested
2339 conversion. This function is used for three the overloading situations
2340 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2341 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2342 per [dcl.init.ref], so we ignore temporary bindings. */
2344 static struct z_candidate *
2345 build_user_type_conversion_1 (totype, expr, flags)
2349 struct z_candidate *candidates, *cand;
2350 tree fromtype = TREE_TYPE (expr);
2351 tree ctors = NULL_TREE, convs = NULL_TREE, *p;
2352 tree args = NULL_TREE;
2353 tree templates = NULL_TREE;
2355 /* We represent conversion within a hierarchy using RVALUE_CONV and
2356 BASE_CONV, as specified by [over.best.ics]; these become plain
2357 constructor calls, as specified in [dcl.init]. */
2358 if (IS_AGGR_TYPE (fromtype) && IS_AGGR_TYPE (totype)
2359 && DERIVED_FROM_P (totype, fromtype))
2362 if (IS_AGGR_TYPE (totype))
2363 ctors = lookup_fnfields (TYPE_BINFO (totype),
2364 complete_ctor_identifier,
2367 if (IS_AGGR_TYPE (fromtype))
2368 convs = lookup_conversions (fromtype);
2371 flags |= LOOKUP_NO_CONVERSION;
2377 ctors = TREE_VALUE (ctors);
2379 t = build_int_2 (0, 0);
2380 TREE_TYPE (t) = build_pointer_type (totype);
2381 args = build_tree_list (NULL_TREE, expr);
2382 if (DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2383 || DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)))
2384 /* We should never try to call the abstract or base constructor
2387 args = tree_cons (NULL_TREE, t, args);
2389 for (; ctors; ctors = OVL_NEXT (ctors))
2391 tree ctor = OVL_CURRENT (ctors);
2392 if (DECL_NONCONVERTING_P (ctor))
2395 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2397 templates = tree_cons (NULL_TREE, ctor, templates);
2399 add_template_candidate (candidates, ctor, totype,
2400 NULL_TREE, args, NULL_TREE, flags,
2404 candidates = add_function_candidate (candidates, ctor, totype,
2409 candidates->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE);
2410 candidates->basetype_path = TYPE_BINFO (totype);
2415 args = build_tree_list (NULL_TREE, build_this (expr));
2417 for (; convs; convs = TREE_CHAIN (convs))
2419 tree fns = TREE_VALUE (convs);
2420 int convflags = LOOKUP_NO_CONVERSION;
2423 /* If we are called to convert to a reference type, we are trying to
2424 find an lvalue binding, so don't even consider temporaries. If
2425 we don't find an lvalue binding, the caller will try again to
2426 look for a temporary binding. */
2427 if (TREE_CODE (totype) == REFERENCE_TYPE)
2428 convflags |= LOOKUP_NO_TEMP_BIND;
2430 if (TREE_CODE (OVL_CURRENT (fns)) != TEMPLATE_DECL)
2431 ics = implicit_conversion
2432 (totype, TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns))), 0, convflags);
2434 /* We can't compute this yet. */
2435 ics = error_mark_node;
2437 if (TREE_CODE (totype) == REFERENCE_TYPE && ics && ICS_BAD_FLAG (ics))
2438 /* ignore the near match. */;
2440 for (; fns; fns = OVL_NEXT (fns))
2442 tree fn = OVL_CURRENT (fns);
2443 struct z_candidate *old_candidates = candidates;
2445 /* [over.match.funcs] For conversion functions, the function is
2446 considered to be a member of the class of the implicit object
2447 argument for the purpose of defining the type of the implicit
2450 So we pass fromtype as CTYPE to add_*_candidate. */
2452 if (TREE_CODE (fn) == TEMPLATE_DECL)
2454 templates = tree_cons (NULL_TREE, fn, templates);
2456 add_template_candidate (candidates, fn, fromtype, NULL_TREE,
2457 args, totype, flags,
2461 candidates = add_function_candidate (candidates, fn, fromtype,
2464 if (candidates != old_candidates)
2466 if (TREE_CODE (fn) == TEMPLATE_DECL)
2467 ics = implicit_conversion
2468 (totype, TREE_TYPE (TREE_TYPE (candidates->fn)),
2471 candidates->second_conv = ics;
2472 candidates->basetype_path = TYPE_BINFO (fromtype);
2474 if (ics == NULL_TREE)
2475 candidates->viable = 0;
2476 else if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
2477 candidates->viable = -1;
2482 if (! any_viable (candidates))
2485 if (flags & LOOKUP_COMPLAIN)
2487 if (candidates && ! candidates->next)
2488 /* say why this one won't work or try to be loose */;
2490 cp_error ("no viable candidates");
2497 candidates = splice_viable (candidates);
2498 cand = tourney (candidates);
2502 if (flags & LOOKUP_COMPLAIN)
2504 cp_error ("conversion from `%T' to `%T' is ambiguous",
2506 print_z_candidates (candidates);
2509 cand = candidates; /* any one will do */
2510 cand->second_conv = build1 (AMBIG_CONV, totype, expr);
2511 ICS_USER_FLAG (cand->second_conv) = 1;
2512 ICS_BAD_FLAG (cand->second_conv) = 1;
2517 for (p = &(cand->second_conv); TREE_CODE (*p) != IDENTITY_CONV; )
2518 p = &(TREE_OPERAND (*p, 0));
2522 (DECL_CONSTRUCTOR_P (cand->fn)
2523 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2524 expr, build_ptr_wrapper (cand));
2526 ICS_USER_FLAG (cand->second_conv) = ICS_USER_FLAG (*p) = 1;
2527 if (cand->viable == -1)
2528 ICS_BAD_FLAG (cand->second_conv) = ICS_BAD_FLAG (*p) = 1;
2534 build_user_type_conversion (totype, expr, flags)
2538 struct z_candidate *cand
2539 = build_user_type_conversion_1 (totype, expr, flags);
2543 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
2544 return error_mark_node;
2545 return convert_from_reference (convert_like (cand->second_conv, expr));
2550 /* Do any initial processing on the arguments to a function call. */
2557 for (t = args; t; t = TREE_CHAIN (t))
2559 tree arg = TREE_VALUE (t);
2561 if (arg == error_mark_node)
2562 return error_mark_node;
2563 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2565 error ("invalid use of void expression");
2566 return error_mark_node;
2568 else if (TREE_CODE (arg) == OFFSET_REF)
2569 arg = resolve_offset_ref (arg);
2570 arg = convert_from_reference (arg);
2571 TREE_VALUE (t) = arg;
2577 build_new_function_call (fn, args)
2580 struct z_candidate *candidates = 0, *cand;
2581 tree explicit_targs = NULL_TREE;
2582 int template_only = 0;
2584 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2586 explicit_targs = TREE_OPERAND (fn, 1);
2587 fn = TREE_OPERAND (fn, 0);
2591 if (really_overloaded_fn (fn))
2594 tree templates = NULL_TREE;
2596 args = resolve_args (args);
2598 if (args == error_mark_node)
2599 return error_mark_node;
2601 for (t1 = fn; t1; t1 = OVL_CHAIN (t1))
2603 tree t = OVL_FUNCTION (t1);
2605 if (TREE_CODE (t) == TEMPLATE_DECL)
2607 templates = tree_cons (NULL_TREE, t, templates);
2608 candidates = add_template_candidate
2609 (candidates, t, NULL_TREE, explicit_targs, args, NULL_TREE,
2610 LOOKUP_NORMAL, DEDUCE_CALL);
2612 else if (! template_only)
2613 candidates = add_function_candidate
2614 (candidates, t, NULL_TREE, args, LOOKUP_NORMAL);
2617 if (! any_viable (candidates))
2619 if (candidates && ! candidates->next)
2620 return build_function_call (candidates->fn, args);
2621 cp_error ("no matching function for call to `%D(%A)'",
2622 DECL_NAME (OVL_FUNCTION (fn)), args);
2624 print_z_candidates (candidates);
2625 return error_mark_node;
2627 candidates = splice_viable (candidates);
2628 cand = tourney (candidates);
2632 cp_error ("call of overloaded `%D(%A)' is ambiguous",
2633 DECL_NAME (OVL_FUNCTION (fn)), args);
2634 print_z_candidates (candidates);
2635 return error_mark_node;
2638 return build_over_call (cand, args, LOOKUP_NORMAL);
2641 /* This is not really overloaded. */
2642 fn = OVL_CURRENT (fn);
2644 return build_function_call (fn, args);
2648 build_object_call (obj, args)
2651 struct z_candidate *candidates = 0, *cand;
2652 tree fns, convs, mem_args = NULL_TREE;
2653 tree type = TREE_TYPE (obj);
2655 if (TYPE_PTRMEMFUNC_P (type))
2657 /* It's no good looking for an overloaded operator() on a
2658 pointer-to-member-function. */
2659 cp_error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2660 return error_mark_node;
2663 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2664 if (fns == error_mark_node)
2665 return error_mark_node;
2667 args = resolve_args (args);
2669 if (args == error_mark_node)
2670 return error_mark_node;
2674 tree base = BINFO_TYPE (TREE_PURPOSE (fns));
2675 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2677 for (fns = TREE_VALUE (fns); fns; fns = OVL_NEXT (fns))
2679 tree fn = OVL_CURRENT (fns);
2680 if (TREE_CODE (fn) == TEMPLATE_DECL)
2683 = add_template_candidate (candidates, fn, base, NULL_TREE,
2684 mem_args, NULL_TREE,
2685 LOOKUP_NORMAL, DEDUCE_CALL);
2688 candidates = add_function_candidate
2689 (candidates, fn, base, mem_args, LOOKUP_NORMAL);
2692 candidates->basetype_path = TYPE_BINFO (type);
2696 convs = lookup_conversions (type);
2698 for (; convs; convs = TREE_CHAIN (convs))
2700 tree fns = TREE_VALUE (convs);
2701 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2703 if ((TREE_CODE (totype) == POINTER_TYPE
2704 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2705 || (TREE_CODE (totype) == REFERENCE_TYPE
2706 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2707 || (TREE_CODE (totype) == REFERENCE_TYPE
2708 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2709 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
2710 for (; fns; fns = OVL_NEXT (fns))
2712 tree fn = OVL_CURRENT (fns);
2713 if (TREE_CODE (fn) == TEMPLATE_DECL)
2715 candidates = add_template_conv_candidate (candidates,
2722 candidates = add_conv_candidate (candidates, fn, obj, args);
2726 if (! any_viable (candidates))
2728 cp_error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
2729 print_z_candidates (candidates);
2730 return error_mark_node;
2733 candidates = splice_viable (candidates);
2734 cand = tourney (candidates);
2738 cp_error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
2739 print_z_candidates (candidates);
2740 return error_mark_node;
2743 /* Since cand->fn will be a type, not a function, for a conversion
2744 function, we must be careful not to unconditionally look at
2746 if (TREE_CODE (cand->fn) == FUNCTION_DECL
2747 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
2748 return build_over_call (cand, mem_args, LOOKUP_NORMAL);
2750 obj = convert_like_with_context
2751 (TREE_VEC_ELT (cand->convs, 0), obj, cand->fn, -1);
2754 return build_function_call (obj, args);
2758 op_error (code, code2, arg1, arg2, arg3, problem)
2759 enum tree_code code, code2;
2760 tree arg1, arg2, arg3;
2761 const char *problem;
2765 if (code == MODIFY_EXPR)
2766 opname = assignment_operator_name_info[code2].name;
2768 opname = operator_name_info[code].name;
2773 cp_error ("%s for `%T ? %T : %T' operator", problem,
2774 error_type (arg1), error_type (arg2), error_type (arg3));
2776 case POSTINCREMENT_EXPR:
2777 case POSTDECREMENT_EXPR:
2778 cp_error ("%s for `%T %s' operator", problem, error_type (arg1), opname);
2781 cp_error ("%s for `%T [%T]' operator", problem,
2782 error_type (arg1), error_type (arg2));
2786 cp_error ("%s for `%T %s %T' operator", problem,
2787 error_type (arg1), opname, error_type (arg2));
2789 cp_error ("%s for `%s %T' operator", problem, opname, error_type (arg1));
2793 /* Return the implicit conversion sequence that could be used to
2794 convert E1 to E2 in [expr.cond]. */
2797 conditional_conversion (e1, e2)
2801 tree t1 = non_reference (TREE_TYPE (e1));
2802 tree t2 = non_reference (TREE_TYPE (e2));
2807 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
2808 implicitly converted (clause _conv_) to the type "reference to
2809 T2", subject to the constraint that in the conversion the
2810 reference must bind directly (_dcl.init.ref_) to E1. */
2811 if (real_lvalue_p (e2))
2813 conv = implicit_conversion (build_reference_type (t2),
2816 LOOKUP_NO_TEMP_BIND);
2823 If E1 and E2 have class type, and the underlying class types are
2824 the same or one is a base class of the other: E1 can be converted
2825 to match E2 if the class of T2 is the same type as, or a base
2826 class of, the class of T1, and the cv-qualification of T2 is the
2827 same cv-qualification as, or a greater cv-qualification than, the
2828 cv-qualification of T1. If the conversion is applied, E1 is
2829 changed to an rvalue of type T2 that still refers to the original
2830 source class object (or the appropriate subobject thereof). */
2831 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
2832 && same_or_base_type_p (TYPE_MAIN_VARIANT (t2),
2833 TYPE_MAIN_VARIANT (t1)))
2835 if (at_least_as_qualified_p (t2, t1))
2837 conv = build1 (IDENTITY_CONV, t1, e1);
2838 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
2839 TYPE_MAIN_VARIANT (t2)))
2840 conv = build_conv (BASE_CONV, t2, conv);
2849 E1 can be converted to match E2 if E1 can be implicitly converted
2850 to the type that expression E2 would have if E2 were converted to
2851 an rvalue (or the type it has, if E2 is an rvalue). */
2852 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
2855 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
2856 arguments to the conditional expression. By the time this function
2857 is called, any suitable candidate functions are included in
2861 build_conditional_expr (arg1, arg2, arg3)
2869 tree result_type = NULL_TREE;
2871 struct z_candidate *candidates = 0;
2872 struct z_candidate *cand;
2874 /* As a G++ extension, the second argument to the conditional can be
2875 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
2876 c'.) If the second operand is omitted, make sure it is
2877 calculated only once. */
2881 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
2882 arg1 = arg2 = save_expr (arg1);
2887 The first expr ession is implicitly converted to bool (clause
2889 arg1 = cp_convert (boolean_type_node, arg1);
2891 /* If something has already gone wrong, just pass that fact up the
2893 if (arg1 == error_mark_node
2894 || arg2 == error_mark_node
2895 || arg3 == error_mark_node
2896 || TREE_TYPE (arg1) == error_mark_node
2897 || TREE_TYPE (arg2) == error_mark_node
2898 || TREE_TYPE (arg3) == error_mark_node)
2899 return error_mark_node;
2903 If either the second or the third operand has type (possibly
2904 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
2905 array-to-pointer (_conv.array_), and function-to-pointer
2906 (_conv.func_) standard conversions are performed on the second
2907 and third operands. */
2908 arg2_type = TREE_TYPE (arg2);
2909 arg3_type = TREE_TYPE (arg3);
2910 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
2912 /* Do the conversions. We don't these for `void' type arguments
2913 since it can't have any effect and since decay_conversion
2914 does not handle that case gracefully. */
2915 if (!VOID_TYPE_P (arg2_type))
2916 arg2 = decay_conversion (arg2);
2917 if (!VOID_TYPE_P (arg3_type))
2918 arg3 = decay_conversion (arg3);
2919 arg2_type = TREE_TYPE (arg2);
2920 arg3_type = TREE_TYPE (arg3);
2924 One of the following shall hold:
2926 --The second or the third operand (but not both) is a
2927 throw-expression (_except.throw_); the result is of the
2928 type of the other and is an rvalue.
2930 --Both the second and the third operands have type void; the
2931 result is of type void and is an rvalue. */
2932 if ((TREE_CODE (arg2) == THROW_EXPR)
2933 ^ (TREE_CODE (arg3) == THROW_EXPR))
2934 result_type = ((TREE_CODE (arg2) == THROW_EXPR)
2935 ? arg3_type : arg2_type);
2936 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
2937 result_type = void_type_node;
2940 cp_error ("`%E' has type `void' and is not a throw-expression",
2941 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
2942 return error_mark_node;
2946 goto valid_operands;
2950 Otherwise, if the second and third operand have different types,
2951 and either has (possibly cv-qualified) class type, an attempt is
2952 made to convert each of those operands to the type of the other. */
2953 else if (!same_type_p (arg2_type, arg3_type)
2954 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
2956 tree conv2 = conditional_conversion (arg2, arg3);
2957 tree conv3 = conditional_conversion (arg3, arg2);
2961 If both can be converted, or one can be converted but the
2962 conversion is ambiguous, the program is ill-formed. If
2963 neither can be converted, the operands are left unchanged and
2964 further checking is performed as described below. If exactly
2965 one conversion is possible, that conversion is applied to the
2966 chosen operand and the converted operand is used in place of
2967 the original operand for the remainder of this section. */
2968 if ((conv2 && !ICS_BAD_FLAG (conv2)
2969 && conv3 && !ICS_BAD_FLAG (conv3))
2970 || (conv2 && TREE_CODE (conv2) == AMBIG_CONV)
2971 || (conv3 && TREE_CODE (conv3) == AMBIG_CONV))
2973 cp_error ("operands to ?: have different types");
2974 return error_mark_node;
2976 else if (conv2 && !ICS_BAD_FLAG (conv2))
2978 arg2 = convert_like (conv2, arg2);
2979 arg2 = convert_from_reference (arg2);
2980 /* That may not quite have done the trick. If the two types
2981 are cv-qualified variants of one another, we will have
2982 just used an IDENTITY_CONV. (There's no conversion from
2983 an lvalue of one class type to an lvalue of another type,
2984 even a cv-qualified variant, and we don't want to lose
2985 lvalue-ness here.) So, we manually add a NOP_EXPR here
2987 if (!same_type_p (TREE_TYPE (arg2), arg3_type))
2988 arg2 = build1 (NOP_EXPR, arg3_type, arg2);
2989 arg2_type = TREE_TYPE (arg2);
2991 else if (conv3 && !ICS_BAD_FLAG (conv3))
2993 arg3 = convert_like (conv3, arg3);
2994 arg3 = convert_from_reference (arg3);
2995 if (!same_type_p (TREE_TYPE (arg3), arg2_type))
2996 arg3 = build1 (NOP_EXPR, arg2_type, arg3);
2997 arg3_type = TREE_TYPE (arg3);
3003 If the second and third operands are lvalues and have the same
3004 type, the result is of that type and is an lvalue. */
3005 if (real_lvalue_p (arg2) && real_lvalue_p (arg3) &&
3006 same_type_p (arg2_type, arg3_type))
3008 result_type = arg2_type;
3009 goto valid_operands;
3014 Otherwise, the result is an rvalue. If the second and third
3015 operand do not have the same type, and either has (possibly
3016 cv-qualified) class type, overload resolution is used to
3017 determine the conversions (if any) to be applied to the operands
3018 (_over.match.oper_, _over.built_). */
3020 if (!same_type_p (arg2_type, arg3_type)
3021 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3026 /* Rearrange the arguments so that add_builtin_candidate only has
3027 to know about two args. In build_builtin_candidates, the
3028 arguments are unscrambled. */
3032 candidates = add_builtin_candidates (candidates,
3035 ansi_opname (COND_EXPR),
3041 If the overload resolution fails, the program is
3043 if (!any_viable (candidates))
3045 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3046 print_z_candidates (candidates);
3047 return error_mark_node;
3049 candidates = splice_viable (candidates);
3050 cand = tourney (candidates);
3053 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3054 print_z_candidates (candidates);
3055 return error_mark_node;
3060 Otherwise, the conversions thus determined are applied, and
3061 the converted operands are used in place of the original
3062 operands for the remainder of this section. */
3063 conv = TREE_VEC_ELT (cand->convs, 0);
3064 arg1 = convert_like (conv, arg1);
3065 conv = TREE_VEC_ELT (cand->convs, 1);
3066 arg2 = convert_like (conv, arg2);
3067 conv = TREE_VEC_ELT (cand->convs, 2);
3068 arg3 = convert_like (conv, arg3);
3073 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3074 and function-to-pointer (_conv.func_) standard conversions are
3075 performed on the second and third operands.
3077 We need to force the lvalue-to-rvalue conversion here for class types,
3078 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3079 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3082 We use ocp_convert rather than build_user_type_conversion because the
3083 latter returns NULL_TREE on failure, while the former gives an error. */
3085 if (IS_AGGR_TYPE (TREE_TYPE (arg2)) && real_lvalue_p (arg2))
3086 arg2 = ocp_convert (TREE_TYPE (arg2), arg2,
3087 CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL);
3089 arg2 = decay_conversion (arg2);
3090 arg2_type = TREE_TYPE (arg2);
3092 if (IS_AGGR_TYPE (TREE_TYPE (arg3)) && real_lvalue_p (arg3))
3093 arg3 = ocp_convert (TREE_TYPE (arg3), arg3,
3094 CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL);
3096 arg3 = decay_conversion (arg3);
3097 arg3_type = TREE_TYPE (arg3);
3099 if (arg2 == error_mark_node || arg3 == error_mark_node)
3100 return error_mark_node;
3104 After those conversions, one of the following shall hold:
3106 --The second and third operands have the same type; the result is of
3108 if (same_type_p (arg2_type, arg3_type))
3109 result_type = arg2_type;
3112 --The second and third operands have arithmetic or enumeration
3113 type; the usual arithmetic conversions are performed to bring
3114 them to a common type, and the result is of that type. */
3115 else if ((ARITHMETIC_TYPE_P (arg2_type)
3116 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3117 && (ARITHMETIC_TYPE_P (arg3_type)
3118 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3120 /* In this case, there is always a common type. */
3121 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3124 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3125 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3126 cp_warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3127 arg2_type, arg3_type);
3128 else if (extra_warnings
3129 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3130 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3131 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3132 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3133 cp_warning ("enumeral and non-enumeral type in conditional expression");
3135 arg2 = perform_implicit_conversion (result_type, arg2);
3136 arg3 = perform_implicit_conversion (result_type, arg3);
3140 --The second and third operands have pointer type, or one has
3141 pointer type and the other is a null pointer constant; pointer
3142 conversions (_conv.ptr_) and qualification conversions
3143 (_conv.qual_) are performed to bring them to their composite
3144 pointer type (_expr.rel_). The result is of the composite
3147 --The second and third operands have pointer to member type, or
3148 one has pointer to member type and the other is a null pointer
3149 constant; pointer to member conversions (_conv.mem_) and
3150 qualification conversions (_conv.qual_) are performed to bring
3151 them to a common type, whose cv-qualification shall match the
3152 cv-qualification of either the second or the third operand.
3153 The result is of the common type. */
3154 else if ((null_ptr_cst_p (arg2)
3155 && (TYPE_PTR_P (arg3_type) || TYPE_PTRMEM_P (arg3_type)
3156 || TYPE_PTRMEMFUNC_P (arg3_type)))
3157 || (null_ptr_cst_p (arg3)
3158 && (TYPE_PTR_P (arg2_type) || TYPE_PTRMEM_P (arg2_type)
3159 || TYPE_PTRMEMFUNC_P (arg2_type)))
3160 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3161 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3162 || (TYPE_PTRMEMFUNC_P (arg2_type)
3163 && TYPE_PTRMEMFUNC_P (arg3_type)))
3165 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3166 arg3, "conditional expression");
3167 arg2 = perform_implicit_conversion (result_type, arg2);
3168 arg3 = perform_implicit_conversion (result_type, arg3);
3173 cp_error ("operands to ?: have different types");
3174 return error_mark_node;
3178 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3179 /* Expand both sides into the same slot, hopefully the target of the
3180 ?: expression. We used to check for TARGET_EXPRs here, but now we
3181 sometimes wrap them in NOP_EXPRs so the test would fail. */
3182 if (!lvalue_p && IS_AGGR_TYPE (result_type))
3183 result = build_target_expr_with_type (result, result_type);
3185 /* If this expression is an rvalue, but might be mistaken for an
3186 lvalue, we must add a NON_LVALUE_EXPR. */
3187 if (!lvalue_p && real_lvalue_p (result))
3188 result = build1 (NON_LVALUE_EXPR, result_type, result);
3194 build_new_op (code, flags, arg1, arg2, arg3)
3195 enum tree_code code;
3197 tree arg1, arg2, arg3;
3199 struct z_candidate *candidates = 0, *cand;
3200 tree fns, mem_arglist = NULL_TREE, arglist, fnname;
3201 enum tree_code code2 = NOP_EXPR;
3202 tree templates = NULL_TREE;
3205 if (arg1 == error_mark_node
3206 || arg2 == error_mark_node
3207 || arg3 == error_mark_node)
3208 return error_mark_node;
3210 /* This can happen if a template takes all non-type parameters, e.g.
3211 undeclared_template<1, 5, 72>a; */
3212 if (code == LT_EXPR && TREE_CODE (arg1) == TEMPLATE_DECL)
3214 cp_error ("`%D' must be declared before use", arg1);
3215 return error_mark_node;
3218 if (code == MODIFY_EXPR)
3220 code2 = TREE_CODE (arg3);
3222 fnname = ansi_assopname (code2);
3225 fnname = ansi_opname (code);
3227 if (TREE_CODE (arg1) == OFFSET_REF)
3228 arg1 = resolve_offset_ref (arg1);
3229 arg1 = convert_from_reference (arg1);
3235 case VEC_DELETE_EXPR:
3237 /* Use build_op_new_call and build_op_delete_call instead. */
3238 my_friendly_abort (981018);
3241 return build_object_call (arg1, arg2);
3249 if (TREE_CODE (arg2) == OFFSET_REF)
3250 arg2 = resolve_offset_ref (arg2);
3251 arg2 = convert_from_reference (arg2);
3255 if (TREE_CODE (arg3) == OFFSET_REF)
3256 arg3 = resolve_offset_ref (arg3);
3257 arg3 = convert_from_reference (arg3);
3260 if (code == COND_EXPR)
3262 if (arg2 == NULL_TREE
3263 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3264 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3265 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3266 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3269 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3270 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3273 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3274 arg2 = integer_zero_node;
3277 arglist = tree_cons (NULL_TREE, arg1, tree_cons
3278 (NULL_TREE, arg2, build_tree_list (NULL_TREE, arg3)));
3280 arglist = tree_cons (NULL_TREE, arg1, build_tree_list (NULL_TREE, arg2));
3282 arglist = build_tree_list (NULL_TREE, arg1);
3284 fns = lookup_function_nonclass (fnname, arglist);
3286 if (fns && TREE_CODE (fns) == TREE_LIST)
3287 fns = TREE_VALUE (fns);
3288 for (; fns; fns = OVL_NEXT (fns))
3290 tree fn = OVL_CURRENT (fns);
3291 if (TREE_CODE (fn) == TEMPLATE_DECL)
3293 templates = tree_cons (NULL_TREE, fn, templates);
3295 = add_template_candidate (candidates, fn, NULL_TREE, NULL_TREE,
3296 arglist, TREE_TYPE (fnname),
3297 flags, DEDUCE_CALL);
3300 candidates = add_function_candidate (candidates, fn, NULL_TREE,
3304 if (IS_AGGR_TYPE (TREE_TYPE (arg1)))
3306 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3307 if (fns == error_mark_node)
3315 tree basetype = BINFO_TYPE (TREE_PURPOSE (fns));
3316 mem_arglist = tree_cons (NULL_TREE, build_this (arg1), TREE_CHAIN (arglist));
3317 for (fns = TREE_VALUE (fns); fns; fns = OVL_NEXT (fns))
3319 tree fn = OVL_CURRENT (fns);
3322 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
3323 this_arglist = mem_arglist;
3325 this_arglist = arglist;
3327 if (TREE_CODE (fn) == TEMPLATE_DECL)
3329 /* A member template. */
3330 templates = tree_cons (NULL_TREE, fn, templates);
3332 = add_template_candidate (candidates, fn, basetype, NULL_TREE,
3333 this_arglist, TREE_TYPE (fnname),
3334 flags, DEDUCE_CALL);
3337 candidates = add_function_candidate
3338 (candidates, fn, basetype, this_arglist, flags);
3341 candidates->basetype_path = TYPE_BINFO (TREE_TYPE (arg1));
3348 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3349 to know about two args; a builtin candidate will always have a first
3350 parameter of type bool. We'll handle that in
3351 build_builtin_candidate. */
3352 if (code == COND_EXPR)
3362 args[2] = NULL_TREE;
3365 candidates = add_builtin_candidates
3366 (candidates, code, code2, fnname, args, flags);
3369 if (! any_viable (candidates))
3373 case POSTINCREMENT_EXPR:
3374 case POSTDECREMENT_EXPR:
3375 /* Look for an `operator++ (int)'. If they didn't have
3376 one, then we fall back to the old way of doing things. */
3377 if (flags & LOOKUP_COMPLAIN)
3378 cp_pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3380 operator_name_info[code].name);
3381 if (code == POSTINCREMENT_EXPR)
3382 code = PREINCREMENT_EXPR;
3384 code = PREDECREMENT_EXPR;
3385 return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
3387 /* The caller will deal with these. */
3396 if (flags & LOOKUP_COMPLAIN)
3398 op_error (code, code2, arg1, arg2, arg3, "no match");
3399 print_z_candidates (candidates);
3401 return error_mark_node;
3403 candidates = splice_viable (candidates);
3404 cand = tourney (candidates);
3408 if (flags & LOOKUP_COMPLAIN)
3410 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3411 print_z_candidates (candidates);
3413 return error_mark_node;
3416 if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3418 extern int warn_synth;
3420 && fnname == ansi_assopname (NOP_EXPR)
3421 && DECL_ARTIFICIAL (cand->fn)
3423 && ! candidates->next->next)
3425 cp_warning ("using synthesized `%#D' for copy assignment",
3427 cp_warning_at (" where cfront would use `%#D'",
3429 ? candidates->next->fn
3433 return build_over_call
3435 TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
3436 ? mem_arglist : arglist,
3440 /* Check for comparison of different enum types. */
3449 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3450 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3451 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3452 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3454 cp_warning ("comparison between `%#T' and `%#T'",
3455 TREE_TYPE (arg1), TREE_TYPE (arg2));
3462 /* We need to strip any leading REF_BIND so that bitfields don't cause
3463 errors. This should not remove any important conversions, because
3464 builtins don't apply to class objects directly. */
3465 conv = TREE_VEC_ELT (cand->convs, 0);
3466 if (TREE_CODE (conv) == REF_BIND)
3467 conv = TREE_OPERAND (conv, 0);
3468 arg1 = convert_like (conv, arg1);
3471 conv = TREE_VEC_ELT (cand->convs, 1);
3472 if (TREE_CODE (conv) == REF_BIND)
3473 conv = TREE_OPERAND (conv, 0);
3474 arg2 = convert_like (conv, arg2);
3478 conv = TREE_VEC_ELT (cand->convs, 2);
3479 if (TREE_CODE (conv) == REF_BIND)
3480 conv = TREE_OPERAND (conv, 0);
3481 arg3 = convert_like (conv, arg3);
3488 return build_modify_expr (arg1, code2, arg2);
3491 return build_indirect_ref (arg1, "unary *");
3496 case TRUNC_DIV_EXPR:
3507 case TRUNC_MOD_EXPR:
3511 case TRUTH_ANDIF_EXPR:
3512 case TRUTH_ORIF_EXPR:
3513 return cp_build_binary_op (code, arg1, arg2);
3518 case TRUTH_NOT_EXPR:
3519 case PREINCREMENT_EXPR:
3520 case POSTINCREMENT_EXPR:
3521 case PREDECREMENT_EXPR:
3522 case POSTDECREMENT_EXPR:
3525 return build_unary_op (code, arg1, candidates != 0);
3528 return build_array_ref (arg1, arg2);
3531 return build_conditional_expr (arg1, arg2, arg3);
3534 return build_m_component_ref
3535 (build_indirect_ref (arg1, NULL), arg2);
3537 /* The caller will deal with these. */
3544 my_friendly_abort (367);
3549 /* Build a call to operator delete. This has to be handled very specially,
3550 because the restrictions on what signatures match are different from all
3551 other call instances. For a normal delete, only a delete taking (void *)
3552 or (void *, size_t) is accepted. For a placement delete, only an exact
3553 match with the placement new is accepted.
3555 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3556 ADDR is the pointer to be deleted. For placement delete, it is also
3557 used to determine what the corresponding new looked like.
3558 SIZE is the size of the memory block to be deleted.
3559 FLAGS are the usual overloading flags.
3560 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3563 build_op_delete_call (code, addr, size, flags, placement)
3564 enum tree_code code;
3565 tree addr, size, placement;
3568 tree fn = NULL_TREE;
3569 tree fns, fnname, fntype, argtypes, args, type;
3572 if (addr == error_mark_node)
3573 return error_mark_node;
3575 type = TREE_TYPE (TREE_TYPE (addr));
3576 while (TREE_CODE (type) == ARRAY_TYPE)
3577 type = TREE_TYPE (type);
3579 fnname = ansi_opname (code);
3581 if (IS_AGGR_TYPE (type) && ! (flags & LOOKUP_GLOBAL))
3584 If the result of the lookup is ambiguous or inaccessible, or if
3585 the lookup selects a placement deallocation function, the
3586 program is ill-formed.
3588 Therefore, we ask lookup_fnfields to complain ambout ambiguity. */
3590 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3591 if (fns == error_mark_node)
3592 return error_mark_node;
3597 if (fns == NULL_TREE)
3598 fns = lookup_name_nonclass (fnname);
3602 /* placement is a CALL_EXPR around an ADDR_EXPR around a function. */
3604 /* Extract the function. */
3605 argtypes = TREE_OPERAND (TREE_OPERAND (placement, 0), 0);
3606 /* Then the second parm type. */
3607 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (argtypes)));
3609 /* Also the second argument. */
3610 args = TREE_CHAIN (TREE_OPERAND (placement, 1));
3614 /* First try it without the size argument. */
3615 argtypes = void_list_node;
3619 /* Strip const and volatile from addr. */
3620 addr = cp_convert (ptr_type_node, addr);
3622 /* We make two tries at finding a matching `operator delete'. On
3623 the first pass, we look for an one-operator (or placement)
3624 operator delete. If we're not doing placement delete, then on
3625 the second pass we look for a two-argument delete. */
3626 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
3629 argtypes = tree_cons (NULL_TREE, ptr_type_node, argtypes);
3631 /* Normal delete; now try to find a match including the size
3633 argtypes = tree_cons (NULL_TREE, ptr_type_node,
3634 tree_cons (NULL_TREE, sizetype,
3636 fntype = build_function_type (void_type_node, argtypes);
3638 /* Go through the `operator delete' functions looking for one
3639 with a matching type. */
3640 for (fn = BASELINK_P (fns) ? TREE_VALUE (fns) : fns;
3646 /* Exception specifications on the `delete' operator do not
3648 t = build_exception_variant (TREE_TYPE (OVL_CURRENT (fn)),
3650 /* We also don't compare attributes. We're really just
3651 trying to check the types of the first two parameters. */
3652 if (comptypes (t, fntype, COMPARE_NO_ATTRIBUTES))
3656 /* If we found a match, we're done. */
3661 /* If we have a matching function, call it. */
3664 /* Make sure we have the actual function, and not an
3666 fn = OVL_CURRENT (fn);
3668 /* If the FN is a member function, make sure that it is
3670 if (DECL_CLASS_SCOPE_P (fn))
3671 enforce_access (type, fn);
3674 args = tree_cons (NULL_TREE, addr, args);
3676 args = tree_cons (NULL_TREE, addr,
3677 build_tree_list (NULL_TREE, size));
3679 return build_function_call (fn, args);
3682 /* If we are doing placement delete we do nothing if we don't find a
3683 matching op delete. */
3687 cp_error ("no suitable `operator delete' for `%T'", type);
3688 return error_mark_node;
3691 /* If the current scope isn't allowed to access DECL along
3692 BASETYPE_PATH, give an error. The most derived class in
3693 BASETYPE_PATH is the one used to qualify DECL. */
3696 enforce_access (basetype_path, decl)
3702 accessible = accessible_p (basetype_path, decl);
3705 if (TREE_PRIVATE (decl))
3706 cp_error_at ("`%+#D' is private", decl);
3707 else if (TREE_PROTECTED (decl))
3708 cp_error_at ("`%+#D' is protected", decl);
3710 cp_error_at ("`%+#D' is inaccessible", decl);
3711 cp_error ("within this context");
3718 /* Perform the conversions in CONVS on the expression EXPR.
3719 FN and ARGNUM are used for diagnostics. ARGNUM is zero based, -1
3720 indicates the `this' argument of a method. INNER is non-zero when
3721 being called to continue a conversion chain. It is negative when a
3722 reference binding will be applied, positive otherwise. */
3725 convert_like_real (convs, expr, fn, argnum, inner)
3733 tree totype = TREE_TYPE (convs);
3735 if (ICS_BAD_FLAG (convs)
3736 && TREE_CODE (convs) != USER_CONV
3737 && TREE_CODE (convs) != AMBIG_CONV
3738 && TREE_CODE (convs) != REF_BIND)
3741 for (; t; t = TREE_OPERAND (t, 0))
3743 if (TREE_CODE (t) == USER_CONV)
3745 expr = convert_like_real (t, expr, fn, argnum, 1);
3748 else if (TREE_CODE (t) == AMBIG_CONV)
3749 return convert_like_real (t, expr, fn, argnum, 1);
3750 else if (TREE_CODE (t) == IDENTITY_CONV)
3753 return convert_for_initialization
3754 (NULL_TREE, totype, expr, LOOKUP_NORMAL,
3755 "conversion", fn, argnum);
3759 expr = dubious_conversion_warnings
3760 (totype, expr, "argument", fn, argnum);
3761 switch (TREE_CODE (convs))
3765 struct z_candidate *cand
3766 = WRAPPER_PTR (TREE_OPERAND (convs, 1));
3767 tree convfn = cand->fn;
3770 if (DECL_CONSTRUCTOR_P (convfn))
3772 tree t = build_int_2 (0, 0);
3773 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
3775 args = build_tree_list (NULL_TREE, expr);
3776 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
3777 || DECL_HAS_VTT_PARM_P (convfn))
3778 /* We should never try to call the abstract or base constructor
3781 args = tree_cons (NULL_TREE, t, args);
3784 args = build_this (expr);
3785 expr = build_over_call (cand, args, LOOKUP_NORMAL);
3787 /* If this is a constructor or a function returning an aggr type,
3788 we need to build up a TARGET_EXPR. */
3789 if (DECL_CONSTRUCTOR_P (convfn))
3790 expr = build_cplus_new (totype, expr);
3792 /* The result of the call is then used to direct-initialize the object
3793 that is the destination of the copy-initialization. [dcl.init]
3795 Note that this step is not reflected in the conversion sequence;
3796 it affects the semantics when we actually perform the
3797 conversion, but is not considered during overload resolution.
3799 If the target is a class, that means call a ctor. */
3800 if (IS_AGGR_TYPE (totype)
3801 && (inner >= 0 || !real_lvalue_p (expr)))
3803 savew = warningcount, savee = errorcount;
3804 expr = build_new_method_call
3805 (NULL_TREE, complete_ctor_identifier,
3806 build_tree_list (NULL_TREE, expr), TYPE_BINFO (totype),
3807 /* Core issue 84, now a DR, says that we don't allow UDCs
3808 for these args (which deliberately breaks copy-init of an
3809 auto_ptr<Base> from an auto_ptr<Derived>). */
3810 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION);
3812 /* Tell the user where this failing constructor call came from. */
3815 if (warningcount > savew)
3817 (" initializing argument %P of `%D' from result of `%D'",
3818 argnum, fn, convfn);
3819 else if (errorcount > savee)
3821 (" initializing argument %P of `%D' from result of `%D'",
3822 argnum, fn, convfn);
3826 if (warningcount > savew)
3827 cp_warning (" initializing temporary from result of `%D'",
3829 else if (errorcount > savee)
3830 cp_error (" initializing temporary from result of `%D'",
3833 expr = build_cplus_new (totype, expr);
3838 if (type_unknown_p (expr))
3839 expr = instantiate_type (totype, expr, itf_complain);
3842 /* Call build_user_type_conversion again for the error. */
3843 return build_user_type_conversion
3844 (totype, TREE_OPERAND (convs, 0), LOOKUP_NORMAL);
3850 expr = convert_like_real (TREE_OPERAND (convs, 0), expr, fn, argnum,
3851 TREE_CODE (convs) == REF_BIND ? -1 : 1);
3852 if (expr == error_mark_node)
3853 return error_mark_node;
3855 /* Convert a non-array constant variable to its underlying value, unless we
3856 are about to bind it to a reference, in which case we need to
3857 leave it as an lvalue. */
3858 if (TREE_CODE (convs) != REF_BIND
3859 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
3860 expr = decl_constant_value (expr);
3862 switch (TREE_CODE (convs))
3865 if (! IS_AGGR_TYPE (totype))
3867 /* else fall through */
3869 if (TREE_CODE (convs) == BASE_CONV && !NEED_TEMPORARY_P (convs))
3871 /* We are going to bind a reference directly to a base-class
3872 subobject of EXPR. */
3873 tree base_ptr = build_pointer_type (totype);
3875 /* Build an expression for `*((base*) &expr)'. */
3876 expr = build_unary_op (ADDR_EXPR, expr, 0);
3877 expr = perform_implicit_conversion (base_ptr, expr);
3878 expr = build_indirect_ref (expr, "implicit conversion");
3882 /* Copy-initialization where the cv-unqualified version of the source
3883 type is the same class as, or a derived class of, the class of the
3884 destination [is treated as direct-initialization]. [dcl.init] */
3885 savew = warningcount, savee = errorcount;
3886 expr = build_new_method_call (NULL_TREE, complete_ctor_identifier,
3887 build_tree_list (NULL_TREE, expr),
3888 TYPE_BINFO (totype),
3889 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING);
3892 if (warningcount > savew)
3893 cp_warning (" initializing argument %P of `%D'", argnum, fn);
3894 else if (errorcount > savee)
3895 cp_error (" initializing argument %P of `%D'", argnum, fn);
3897 return build_cplus_new (totype, expr);
3901 tree ref_type = totype;
3903 /* If necessary, create a temporary. */
3904 if (NEED_TEMPORARY_P (convs) || !lvalue_p (expr))
3906 tree type = TREE_TYPE (TREE_OPERAND (convs, 0));
3907 expr = build_target_expr_with_type (expr, type);
3910 /* Take the address of the thing to which we will bind the
3912 expr = build_unary_op (ADDR_EXPR, expr, 1);
3913 if (expr == error_mark_node)
3914 return error_mark_node;
3916 /* Convert it to a pointer to the type referred to by the
3917 reference. This will adjust the pointer if a derived to
3918 base conversion is being performed. */
3919 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
3921 /* Convert the pointer to the desired reference type. */
3922 expr = build1 (NOP_EXPR, ref_type, expr);
3928 return decay_conversion (expr);
3931 /* Warn about deprecated conversion if appropriate. */
3932 string_conv_p (totype, expr, 1);
3938 return ocp_convert (totype, expr, CONV_IMPLICIT,
3939 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
3942 /* ARG is being passed to a varargs function. Perform any conversions
3943 required. Array/function to pointer decay must have already happened.
3944 Return the converted value. */
3947 convert_arg_to_ellipsis (arg)
3950 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
3951 && (TYPE_PRECISION (TREE_TYPE (arg))
3952 < TYPE_PRECISION (double_type_node)))
3953 /* Convert `float' to `double'. */
3954 arg = cp_convert (double_type_node, arg);
3956 /* Convert `short' and `char' to full-size `int'. */
3957 arg = default_conversion (arg);
3959 arg = require_complete_type (arg);
3961 if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
3963 /* Undefined behaviour [expr.call] 5.2.2/7. */
3964 cp_warning ("cannot pass objects of non-POD type `%#T' through `...'",
3971 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
3974 build_x_va_arg (expr, type)
3978 if (processing_template_decl)
3979 return build_min (VA_ARG_EXPR, type, expr);
3981 type = complete_type_or_else (type, NULL_TREE);
3983 if (expr == error_mark_node || !type)
3984 return error_mark_node;
3986 if (! pod_type_p (type))
3988 /* Undefined behaviour [expr.call] 5.2.2/7. */
3989 cp_warning ("cannot receive objects of non-POD type `%#T' through `...'",
3993 return build_va_arg (expr, type);
3996 /* TYPE has been given to va_arg. Apply the default conversions which would
3997 have happened when passed via ellipsis. Return the promoted type, or
3998 NULL_TREE, if there is no change. */
4001 convert_type_from_ellipsis (type)
4006 if (TREE_CODE (type) == ARRAY_TYPE)
4007 promote = build_pointer_type (TREE_TYPE (type));
4008 else if (TREE_CODE (type) == FUNCTION_TYPE)
4009 promote = build_pointer_type (type);
4011 promote = type_promotes_to (type);
4013 return same_type_p (type, promote) ? NULL_TREE : promote;
4016 /* ARG is a default argument expression being passed to a parameter of
4017 the indicated TYPE, which is a parameter to FN. Do any required
4018 conversions. Return the converted value. */
4021 convert_default_arg (type, arg, fn, parmnum)
4027 if (TREE_CODE (arg) == DEFAULT_ARG)
4029 /* When processing the default args for a class, we can find that
4030 there is an ordering constraint, and we call a function who's
4031 default args have not yet been converted. For instance,
4034 void Foo (A const & = A ());
4036 We must process A::A before A::Foo's default arg can be converted.
4037 Remember the dependent function, so do_pending_defargs can retry,
4039 unprocessed_defarg_fn (fn);
4041 /* Don't return error_mark node, as we won't be able to distinguish
4042 genuine errors from this case, and that would lead to repeated
4043 diagnostics. Just make something of the right type. */
4044 return build1 (NOP_EXPR, type, integer_zero_node);
4047 if (fn && DECL_TEMPLATE_INFO (fn))
4048 arg = tsubst_default_argument (fn, type, arg);
4050 arg = break_out_target_exprs (arg);
4052 if (TREE_CODE (arg) == CONSTRUCTOR)
4054 arg = digest_init (type, arg, 0);
4055 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4056 "default argument", fn, parmnum);
4060 /* This could get clobbered by the following call. */
4061 if (TREE_HAS_CONSTRUCTOR (arg))
4062 arg = copy_node (arg);
4064 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4065 "default argument", fn, parmnum);
4066 if (PROMOTE_PROTOTYPES
4067 && INTEGRAL_TYPE_P (type)
4068 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
4069 arg = default_conversion (arg);
4075 /* Subroutine of the various build_*_call functions. Overload resolution
4076 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4077 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4078 bitmask of various LOOKUP_* flags which apply to the call itself. */
4081 build_over_call (cand, args, flags)
4082 struct z_candidate *cand;
4087 tree convs = cand->convs;
4088 tree converted_args = NULL_TREE;
4089 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4090 tree conv, arg, val;
4094 /* Give any warnings we noticed during overload resolution. */
4096 for (val = cand->warnings; val; val = TREE_CHAIN (val))
4097 joust (cand, WRAPPER_PTR (TREE_VALUE (val)), 1);
4099 if (DECL_FUNCTION_MEMBER_P (fn))
4100 enforce_access (cand->basetype_path, fn);
4102 if (args && TREE_CODE (args) != TREE_LIST)
4103 args = build_tree_list (NULL_TREE, args);
4106 /* The implicit parameters to a constructor are not considered by overload
4107 resolution, and must be of the proper type. */
4108 if (DECL_CONSTRUCTOR_P (fn))
4110 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4111 arg = TREE_CHAIN (arg);
4112 parm = TREE_CHAIN (parm);
4113 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4114 /* We should never try to call the abstract constructor. */
4116 if (DECL_HAS_VTT_PARM_P (fn))
4118 converted_args = tree_cons
4119 (NULL_TREE, TREE_VALUE (arg), converted_args);
4120 arg = TREE_CHAIN (arg);
4121 parm = TREE_CHAIN (parm);
4124 /* Bypass access control for 'this' parameter. */
4125 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4127 tree parmtype = TREE_VALUE (parm);
4128 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4130 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
4131 cp_pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4132 TREE_TYPE (argtype), fn);
4134 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4135 X is called for an object that is not of type X, or of a type
4136 derived from X, the behavior is undefined.
4138 So we can assume that anything passed as 'this' is non-null, and
4139 optimize accordingly. */
4140 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4141 t = convert_pointer_to_real (TREE_TYPE (parmtype), TREE_VALUE (arg));
4142 converted_args = tree_cons (NULL_TREE, t, converted_args);
4143 parm = TREE_CHAIN (parm);
4144 arg = TREE_CHAIN (arg);
4150 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4152 tree type = TREE_VALUE (parm);
4154 conv = TREE_VEC_ELT (convs, i);
4155 if (ICS_BAD_FLAG (conv))
4158 val = TREE_VALUE (arg);
4160 for (; t; t = TREE_OPERAND (t, 0))
4162 if (TREE_CODE (t) == USER_CONV
4163 || TREE_CODE (t) == AMBIG_CONV)
4165 val = convert_like_with_context (t, val, fn, i - is_method);
4168 else if (TREE_CODE (t) == IDENTITY_CONV)
4171 val = convert_for_initialization
4172 (NULL_TREE, type, val, LOOKUP_NORMAL,
4173 "argument", fn, i - is_method);
4177 val = TREE_VALUE (arg);
4178 val = convert_like_with_context
4179 (conv, TREE_VALUE (arg), fn, i - is_method);
4182 if (PROMOTE_PROTOTYPES
4183 && INTEGRAL_TYPE_P (type)
4184 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
4185 val = default_conversion (val);
4186 converted_args = tree_cons (NULL_TREE, val, converted_args);
4189 /* Default arguments */
4190 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4192 = tree_cons (NULL_TREE,
4193 convert_default_arg (TREE_VALUE (parm),
4194 TREE_PURPOSE (parm),
4199 for (; arg; arg = TREE_CHAIN (arg))
4201 = tree_cons (NULL_TREE,
4202 convert_arg_to_ellipsis (TREE_VALUE (arg)),
4205 converted_args = nreverse (converted_args);
4208 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4211 /* Avoid actually calling copy constructors and copy assignment operators,
4214 if (! flag_elide_constructors)
4215 /* Do things the hard way. */;
4216 else if (TREE_VEC_LENGTH (convs) == 1
4217 && DECL_COPY_CONSTRUCTOR_P (fn))
4220 arg = skip_artificial_parms_for (fn, converted_args);
4221 arg = TREE_VALUE (arg);
4223 /* Pull out the real argument, disregarding const-correctness. */
4225 while (TREE_CODE (targ) == NOP_EXPR
4226 || TREE_CODE (targ) == NON_LVALUE_EXPR
4227 || TREE_CODE (targ) == CONVERT_EXPR)
4228 targ = TREE_OPERAND (targ, 0);
4229 if (TREE_CODE (targ) == ADDR_EXPR)
4231 targ = TREE_OPERAND (targ, 0);
4232 if (!same_type_ignoring_top_level_qualifiers_p
4233 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4242 arg = build_indirect_ref (arg, 0);
4244 /* [class.copy]: the copy constructor is implicitly defined even if
4245 the implementation elided its use. */
4246 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4249 /* If we're creating a temp and we already have one, don't create a
4250 new one. If we're not creating a temp but we get one, use
4251 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4252 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4253 temp or an INIT_EXPR otherwise. */
4254 if (integer_zerop (TREE_VALUE (args)))
4256 if (! real_lvalue_p (arg))
4258 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4259 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4261 else if ((!real_lvalue_p (arg)
4262 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4263 /* Empty classes have padding which can be hidden
4264 inside an (empty) base of the class. This must not
4265 be touched as it might overlay things. When the
4266 gcc core learns about empty classes, we can treat it
4267 like other classes. */
4268 && !is_empty_class (DECL_CONTEXT (fn)))
4271 tree to = stabilize_reference
4272 (build_indirect_ref (TREE_VALUE (args), 0));
4274 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4275 address = build_unary_op (ADDR_EXPR, val, 0);
4276 /* Avoid a warning about this expression, if the address is
4278 TREE_USED (address) = 1;
4282 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4284 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4286 tree to = stabilize_reference
4287 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4289 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4290 if (is_empty_class (TREE_TYPE (to)))
4292 TREE_USED (arg) = 1;
4294 val = build (COMPOUND_EXPR, DECL_CONTEXT (fn), arg, to);
4295 /* Even though the assignment may not actually result in any
4296 code being generated, we do not want to warn about the
4297 assignment having no effect. That would be confusing to
4298 users who may be performing the assignment as part of a
4299 generic algorithm, for example.
4301 Ideally, the notions of having side-effects and of being
4302 useless would be orthogonal. */
4303 TREE_SIDE_EFFECTS (val) = 1;
4306 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4312 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4314 tree t, *p = &TREE_VALUE (converted_args);
4315 tree binfo = get_binfo
4316 (DECL_VIRTUAL_CONTEXT (fn), TREE_TYPE (TREE_TYPE (*p)), 0);
4317 *p = convert_pointer_to_real (binfo, *p);
4318 if (TREE_SIDE_EFFECTS (*p))
4319 *p = save_expr (*p);
4320 t = build_pointer_type (TREE_TYPE (fn));
4321 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4322 fn = build_java_interface_fn_ref (fn, *p);
4324 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4327 else if (DECL_INLINE (fn))
4328 fn = inline_conversion (fn);
4330 fn = build_addr_func (fn);
4332 /* Recognize certain built-in functions so we can make tree-codes
4333 other than CALL_EXPR. We do this when it enables fold-const.c
4334 to do something useful. */
4336 if (TREE_CODE (fn) == ADDR_EXPR
4337 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4338 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4341 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4346 /* Some built-in function calls will be evaluated at
4347 compile-time in fold (). */
4348 fn = fold (build_call (fn, converted_args));
4349 if (VOID_TYPE_P (TREE_TYPE (fn)))
4351 fn = require_complete_type (fn);
4352 if (fn == error_mark_node)
4353 return error_mark_node;
4354 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4355 fn = build_cplus_new (TREE_TYPE (fn), fn);
4356 return convert_from_reference (fn);
4359 static tree java_iface_lookup_fn;
4361 /* Make an expression which yields the address of the Java interface
4362 method FN. This is achieved by generating a call to libjava's
4363 _Jv_LookupInterfaceMethodIdx(). */
4366 build_java_interface_fn_ref (fn, instance)
4369 tree lookup_args, lookup_fn, method, idx;
4370 tree klass_ref, iface, iface_ref;
4373 if (!java_iface_lookup_fn)
4375 tree endlink = build_void_list_node ();
4376 tree t = tree_cons (NULL_TREE, ptr_type_node,
4377 tree_cons (NULL_TREE, ptr_type_node,
4378 tree_cons (NULL_TREE, java_int_type_node,
4380 java_iface_lookup_fn
4381 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4382 build_function_type (ptr_type_node, t),
4383 0, NOT_BUILT_IN, NULL);
4384 ggc_add_tree_root (&java_iface_lookup_fn, 1);
4387 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4388 This is the first entry in the vtable. */
4389 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4392 /* Get the java.lang.Class pointer for the interface being called. */
4393 iface = DECL_CONTEXT (fn);
4394 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, 0);
4395 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4396 || DECL_CONTEXT (iface_ref) != iface)
4398 cp_error ("Could not find class$ field in java interface type `%T'",
4400 return error_mark_node;
4402 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4404 /* Determine the itable index of FN. */
4406 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4408 if (!DECL_VIRTUAL_P (method))
4414 idx = build_int_2 (i, 0);
4416 lookup_args = tree_cons (NULL_TREE, klass_ref,
4417 tree_cons (NULL_TREE, iface_ref,
4418 build_tree_list (NULL_TREE, idx)));
4419 lookup_fn = build1 (ADDR_EXPR,
4420 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4421 java_iface_lookup_fn);
4422 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4425 /* Returns the value to use for the in-charge parameter when making a
4426 call to a function with the indicated NAME. */
4429 in_charge_arg_for_name (name)
4432 if (name == base_ctor_identifier
4433 || name == base_dtor_identifier)
4434 return integer_zero_node;
4435 else if (name == complete_ctor_identifier)
4436 return integer_one_node;
4437 else if (name == complete_dtor_identifier)
4438 return integer_two_node;
4439 else if (name == deleting_dtor_identifier)
4440 return integer_three_node;
4442 /* This function should only be called with one of the names listed
4444 my_friendly_abort (20000411);
4449 build_new_method_call (instance, name, args, basetype_path, flags)
4450 tree instance, name, args, basetype_path;
4453 struct z_candidate *candidates = 0, *cand;
4454 tree explicit_targs = NULL_TREE;
4455 tree basetype, mem_args = NULL_TREE, fns, instance_ptr;
4458 tree templates = NULL_TREE;
4460 int template_only = 0;
4462 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
4464 explicit_targs = TREE_OPERAND (name, 1);
4465 name = TREE_OPERAND (name, 0);
4467 name = DECL_NAME (name);
4470 if (TREE_CODE (name) == COMPONENT_REF)
4471 name = TREE_OPERAND (name, 1);
4472 if (TREE_CODE (name) == OVERLOAD)
4473 name = DECL_NAME (OVL_CURRENT (name));
4480 args = resolve_args (args);
4482 if (args == error_mark_node)
4483 return error_mark_node;
4485 if (instance == NULL_TREE)
4486 basetype = BINFO_TYPE (basetype_path);
4489 if (TREE_CODE (instance) == OFFSET_REF)
4490 instance = resolve_offset_ref (instance);
4491 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
4492 instance = convert_from_reference (instance);
4493 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
4495 /* XXX this should be handled before we get here. */
4496 if (! IS_AGGR_TYPE (basetype))
4498 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
4499 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
4500 name, instance, basetype);
4502 return error_mark_node;
4506 if (basetype_path == NULL_TREE)
4507 basetype_path = TYPE_BINFO (basetype);
4511 instance_ptr = build_this (instance);
4513 if (! template_only)
4515 /* XXX this should be handled before we get here. */
4516 fns = build_field_call (basetype_path, instance_ptr, name, args);
4523 instance_ptr = build_int_2 (0, 0);
4524 TREE_TYPE (instance_ptr) = build_pointer_type (basetype);
4527 /* Callers should explicitly indicate whether they want to construct
4528 the complete object or just the part without virtual bases. */
4529 my_friendly_assert (name != ctor_identifier, 20000408);
4530 /* Similarly for destructors. */
4531 my_friendly_assert (name != dtor_identifier, 20000408);
4533 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4537 constructor_p = (name == complete_ctor_identifier
4538 || name == base_ctor_identifier);
4539 pretty_name = (constructor_p
4540 ? constructor_name (basetype) : dtor_identifier);
4542 /* If we're a call to a constructor or destructor for a
4543 subobject that uses virtual base classes, then we need to
4544 pass down a pointer to a VTT for the subobject. */
4545 if ((name == base_ctor_identifier
4546 || name == base_dtor_identifier)
4547 && TYPE_USES_VIRTUAL_BASECLASSES (basetype))
4551 tree basebinfo = basetype_path;
4553 /* If the current function is a complete object constructor
4554 or destructor, then we fetch the VTT directly.
4555 Otherwise, we look it up using the VTT we were given. */
4556 vtt = IDENTIFIER_GLOBAL_VALUE (get_vtt_name (current_class_type));
4557 vtt = decay_conversion (vtt);
4558 vtt = build (COND_EXPR, TREE_TYPE (vtt),
4559 build (EQ_EXPR, boolean_type_node,
4560 current_in_charge_parm, integer_zero_node),
4563 if (TREE_VIA_VIRTUAL (basebinfo))
4564 basebinfo = binfo_for_vbase (basetype, current_class_type);
4565 my_friendly_assert (BINFO_SUBVTT_INDEX (basebinfo), 20010110);
4566 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
4567 BINFO_SUBVTT_INDEX (basebinfo));
4569 args = tree_cons (NULL_TREE, sub_vtt, args);
4575 fns = lookup_fnfields (basetype_path, name, 1);
4577 if (fns == error_mark_node)
4578 return error_mark_node;
4581 tree base = BINFO_TYPE (TREE_PURPOSE (fns));
4582 tree fn = TREE_VALUE (fns);
4583 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
4584 for (; fn; fn = OVL_NEXT (fn))
4586 tree t = OVL_CURRENT (fn);
4589 /* We can end up here for copy-init of same or base class. */
4590 if ((flags & LOOKUP_ONLYCONVERTING)
4591 && DECL_NONCONVERTING_P (t))
4594 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
4595 this_arglist = mem_args;
4597 this_arglist = args;
4599 if (TREE_CODE (t) == TEMPLATE_DECL)
4601 /* A member template. */
4602 templates = tree_cons (NULL_TREE, t, templates);
4604 add_template_candidate (candidates, t, base, explicit_targs,
4606 TREE_TYPE (name), flags, DEDUCE_CALL);
4608 else if (! template_only)
4609 candidates = add_function_candidate (candidates, t, base,
4610 this_arglist, flags);
4613 candidates->basetype_path = basetype_path;
4617 if (! any_viable (candidates))
4619 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
4620 if (flags & LOOKUP_SPECULATIVELY)
4622 if (!COMPLETE_TYPE_P (basetype))
4623 incomplete_type_error (instance_ptr, basetype);
4625 cp_error ("no matching function for call to `%T::%D(%A)%V'",
4626 basetype, pretty_name, user_args,
4627 TREE_TYPE (TREE_TYPE (instance_ptr)));
4628 print_z_candidates (candidates);
4629 return error_mark_node;
4631 candidates = splice_viable (candidates);
4632 cand = tourney (candidates);
4636 cp_error ("call of overloaded `%D(%A)' is ambiguous", pretty_name,
4638 print_z_candidates (candidates);
4639 return error_mark_node;
4642 if (DECL_PURE_VIRTUAL_P (cand->fn)
4643 && instance == current_class_ref
4644 && (DECL_CONSTRUCTOR_P (current_function_decl)
4645 || DECL_DESTRUCTOR_P (current_function_decl))
4646 && ! (flags & LOOKUP_NONVIRTUAL)
4647 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
4648 cp_error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
4649 "abstract virtual `%#D' called from constructor"
4650 : "abstract virtual `%#D' called from destructor"),
4652 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
4653 && is_dummy_object (instance_ptr))
4655 cp_error ("cannot call member function `%D' without object", cand->fn);
4656 return error_mark_node;
4659 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
4660 && ((instance == current_class_ref && (dtor_label || ctor_label))
4661 || resolves_to_fixed_type_p (instance, 0)))
4662 flags |= LOOKUP_NONVIRTUAL;
4664 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE)
4665 call = build_over_call (cand, mem_args, flags);
4668 call = build_over_call (cand, args, flags);
4669 /* Do evaluate the object parameter in a call to a static member
4671 if (TREE_SIDE_EFFECTS (instance))
4672 call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call);
4678 /* Returns non-zero iff standard conversion sequence ICS1 is a proper
4679 subsequence of ICS2. */
4682 is_subseq (ics1, ics2)
4685 /* We can assume that a conversion of the same code
4686 between the same types indicates a subsequence since we only get
4687 here if the types we are converting from are the same. */
4689 while (TREE_CODE (ics1) == RVALUE_CONV
4690 || TREE_CODE (ics1) == LVALUE_CONV)
4691 ics1 = TREE_OPERAND (ics1, 0);
4695 while (TREE_CODE (ics2) == RVALUE_CONV
4696 || TREE_CODE (ics2) == LVALUE_CONV)
4697 ics2 = TREE_OPERAND (ics2, 0);
4699 if (TREE_CODE (ics2) == USER_CONV
4700 || TREE_CODE (ics2) == AMBIG_CONV
4701 || TREE_CODE (ics2) == IDENTITY_CONV)
4702 /* At this point, ICS1 cannot be a proper subsequence of
4703 ICS2. We can get a USER_CONV when we are comparing the
4704 second standard conversion sequence of two user conversion
4708 ics2 = TREE_OPERAND (ics2, 0);
4710 if (TREE_CODE (ics2) == TREE_CODE (ics1)
4711 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
4712 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
4713 TREE_TYPE (TREE_OPERAND (ics1, 0))))
4718 /* Returns non-zero iff DERIVED is derived from BASE. The inputs may
4719 be any _TYPE nodes. */
4722 is_properly_derived_from (derived, base)
4726 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
4727 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
4730 /* We only allow proper derivation here. The DERIVED_FROM_P macro
4731 considers every class derived from itself. */
4732 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
4733 && DERIVED_FROM_P (base, derived));
4736 /* We build the ICS for an implicit object parameter as a pointer
4737 conversion sequence. However, such a sequence should be compared
4738 as if it were a reference conversion sequence. If ICS is the
4739 implicit conversion sequence for an implicit object parameter,
4740 modify it accordingly. */
4743 maybe_handle_implicit_object (ics)
4746 if (ICS_THIS_FLAG (*ics))
4748 /* [over.match.funcs]
4750 For non-static member functions, the type of the
4751 implicit object parameter is "reference to cv X"
4752 where X is the class of which the function is a
4753 member and cv is the cv-qualification on the member
4754 function declaration. */
4756 tree reference_type;
4758 /* The `this' parameter is a pointer to a class type. Make the
4759 implict conversion talk about a reference to that same class
4761 reference_type = TREE_TYPE (TREE_TYPE (*ics));
4762 reference_type = build_reference_type (reference_type);
4764 if (TREE_CODE (t) == QUAL_CONV)
4765 t = TREE_OPERAND (t, 0);
4766 if (TREE_CODE (t) == PTR_CONV)
4767 t = TREE_OPERAND (t, 0);
4768 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
4769 t = direct_reference_binding (reference_type, t);
4774 /* If ICS is a REF_BIND, modify it appropriately, set TARGET_TYPE
4775 to the type the reference originally referred to, and return 1.
4776 Otherwise, return 0. */
4779 maybe_handle_ref_bind (ics, target_type)
4783 if (TREE_CODE (*ics) == REF_BIND)
4785 tree old_ics = *ics;
4786 *target_type = TREE_TYPE (TREE_TYPE (*ics));
4787 *ics = TREE_OPERAND (*ics, 0);
4788 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
4789 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
4796 /* Compare two implicit conversion sequences according to the rules set out in
4797 [over.ics.rank]. Return values:
4799 1: ics1 is better than ics2
4800 -1: ics2 is better than ics1
4801 0: ics1 and ics2 are indistinguishable */
4804 compare_ics (ics1, ics2)
4811 tree deref_from_type1 = NULL_TREE;
4812 tree deref_from_type2 = NULL_TREE;
4813 tree deref_to_type1 = NULL_TREE;
4814 tree deref_to_type2 = NULL_TREE;
4817 /* REF_BINDING is non-zero if the result of the conversion sequence
4818 is a reference type. In that case TARGET_TYPE is the
4819 type referred to by the reference. */
4825 /* Handle implicit object parameters. */
4826 maybe_handle_implicit_object (&ics1);
4827 maybe_handle_implicit_object (&ics2);
4829 /* Handle reference parameters. */
4830 ref_binding1 = maybe_handle_ref_bind (&ics1, &target_type1);
4831 ref_binding2 = maybe_handle_ref_bind (&ics2, &target_type2);
4835 When comparing the basic forms of implicit conversion sequences (as
4836 defined in _over.best.ics_)
4838 --a standard conversion sequence (_over.ics.scs_) is a better
4839 conversion sequence than a user-defined conversion sequence
4840 or an ellipsis conversion sequence, and
4842 --a user-defined conversion sequence (_over.ics.user_) is a
4843 better conversion sequence than an ellipsis conversion sequence
4844 (_over.ics.ellipsis_). */
4845 rank1 = ICS_RANK (ics1);
4846 rank2 = ICS_RANK (ics2);
4850 else if (rank1 < rank2)
4853 if (rank1 == BAD_RANK)
4855 /* XXX Isn't this an extension? */
4856 /* Both ICS are bad. We try to make a decision based on what
4857 would have happenned if they'd been good. */
4858 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
4859 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
4861 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
4862 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
4865 /* We couldn't make up our minds; try to figure it out below. */
4868 if (ICS_ELLIPSIS_FLAG (ics1))
4869 /* Both conversions are ellipsis conversions. */
4872 /* User-defined conversion sequence U1 is a better conversion sequence
4873 than another user-defined conversion sequence U2 if they contain the
4874 same user-defined conversion operator or constructor and if the sec-
4875 ond standard conversion sequence of U1 is better than the second
4876 standard conversion sequence of U2. */
4878 if (ICS_USER_FLAG (ics1))
4882 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
4883 if (TREE_CODE (t1) == AMBIG_CONV)
4885 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
4886 if (TREE_CODE (t2) == AMBIG_CONV)
4889 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
4892 /* We can just fall through here, after setting up
4893 FROM_TYPE1 and FROM_TYPE2. */
4894 from_type1 = TREE_TYPE (t1);
4895 from_type2 = TREE_TYPE (t2);
4899 /* We're dealing with two standard conversion sequences.
4903 Standard conversion sequence S1 is a better conversion
4904 sequence than standard conversion sequence S2 if
4906 --S1 is a proper subsequence of S2 (comparing the conversion
4907 sequences in the canonical form defined by _over.ics.scs_,
4908 excluding any Lvalue Transformation; the identity
4909 conversion sequence is considered to be a subsequence of
4910 any non-identity conversion sequence */
4913 while (TREE_CODE (from_type1) != IDENTITY_CONV)
4914 from_type1 = TREE_OPERAND (from_type1, 0);
4915 from_type1 = TREE_TYPE (from_type1);
4918 while (TREE_CODE (from_type2) != IDENTITY_CONV)
4919 from_type2 = TREE_OPERAND (from_type2, 0);
4920 from_type2 = TREE_TYPE (from_type2);
4923 if (same_type_p (from_type1, from_type2))
4925 if (is_subseq (ics1, ics2))
4927 if (is_subseq (ics2, ics1))
4930 /* Otherwise, one sequence cannot be a subsequence of the other; they
4931 don't start with the same type. This can happen when comparing the
4932 second standard conversion sequence in two user-defined conversion
4939 --the rank of S1 is better than the rank of S2 (by the rules
4942 Standard conversion sequences are ordered by their ranks: an Exact
4943 Match is a better conversion than a Promotion, which is a better
4944 conversion than a Conversion.
4946 Two conversion sequences with the same rank are indistinguishable
4947 unless one of the following rules applies:
4949 --A conversion that is not a conversion of a pointer, or pointer
4950 to member, to bool is better than another conversion that is such
4953 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
4954 so that we do not have to check it explicitly. */
4955 if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
4957 else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1))
4960 to_type1 = TREE_TYPE (ics1);
4961 to_type2 = TREE_TYPE (ics2);
4963 if (TYPE_PTR_P (from_type1)
4964 && TYPE_PTR_P (from_type2)
4965 && TYPE_PTR_P (to_type1)
4966 && TYPE_PTR_P (to_type2))
4968 deref_from_type1 = TREE_TYPE (from_type1);
4969 deref_from_type2 = TREE_TYPE (from_type2);
4970 deref_to_type1 = TREE_TYPE (to_type1);
4971 deref_to_type2 = TREE_TYPE (to_type2);
4973 /* The rules for pointers to members A::* are just like the rules
4974 for pointers A*, except opposite: if B is derived from A then
4975 A::* converts to B::*, not vice versa. For that reason, we
4976 switch the from_ and to_ variables here. */
4977 else if (TYPE_PTRMEM_P (from_type1)
4978 && TYPE_PTRMEM_P (from_type2)
4979 && TYPE_PTRMEM_P (to_type1)
4980 && TYPE_PTRMEM_P (to_type2))
4982 deref_to_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type1));
4983 deref_to_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type2));
4984 deref_from_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type1));
4985 deref_from_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type2));
4987 else if (TYPE_PTRMEMFUNC_P (from_type1)
4988 && TYPE_PTRMEMFUNC_P (from_type2)
4989 && TYPE_PTRMEMFUNC_P (to_type1)
4990 && TYPE_PTRMEMFUNC_P (to_type2))
4992 deref_to_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type1);
4993 deref_to_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type2);
4994 deref_from_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type1);
4995 deref_from_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type2);
4998 if (deref_from_type1 != NULL_TREE
4999 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5000 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5002 /* This was one of the pointer or pointer-like conversions.
5006 --If class B is derived directly or indirectly from class A,
5007 conversion of B* to A* is better than conversion of B* to
5008 void*, and conversion of A* to void* is better than
5009 conversion of B* to void*. */
5010 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5011 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5013 if (is_properly_derived_from (deref_from_type1,
5016 else if (is_properly_derived_from (deref_from_type2,
5020 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5021 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5023 if (same_type_p (deref_from_type1, deref_from_type2))
5025 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5027 if (is_properly_derived_from (deref_from_type1,
5031 /* We know that DEREF_TO_TYPE1 is `void' here. */
5032 else if (is_properly_derived_from (deref_from_type1,
5037 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5038 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5042 --If class B is derived directly or indirectly from class A
5043 and class C is derived directly or indirectly from B,
5045 --conversion of C* to B* is better than conversion of C* to
5048 --conversion of B* to A* is better than conversion of C* to
5050 if (same_type_p (deref_from_type1, deref_from_type2))
5052 if (is_properly_derived_from (deref_to_type1,
5055 else if (is_properly_derived_from (deref_to_type2,
5059 else if (same_type_p (deref_to_type1, deref_to_type2))
5061 if (is_properly_derived_from (deref_from_type2,
5064 else if (is_properly_derived_from (deref_from_type1,
5070 else if (IS_AGGR_TYPE_CODE (TREE_CODE (from_type1))
5071 && same_type_p (from_type1, from_type2))
5075 --binding of an expression of type C to a reference of type
5076 B& is better than binding an expression of type C to a
5077 reference of type A&
5079 --conversion of C to B is better than conversion of C to A, */
5080 if (is_properly_derived_from (from_type1, to_type1)
5081 && is_properly_derived_from (from_type1, to_type2))
5083 if (is_properly_derived_from (to_type1, to_type2))
5085 else if (is_properly_derived_from (to_type2, to_type1))
5089 else if (IS_AGGR_TYPE_CODE (TREE_CODE (to_type1))
5090 && same_type_p (to_type1, to_type2))
5094 --binding of an expression of type B to a reference of type
5095 A& is better than binding an expression of type C to a
5096 reference of type A&,
5098 --onversion of B to A is better than conversion of C to A */
5099 if (is_properly_derived_from (from_type1, to_type1)
5100 && is_properly_derived_from (from_type2, to_type1))
5102 if (is_properly_derived_from (from_type2, from_type1))
5104 else if (is_properly_derived_from (from_type1, from_type2))
5111 --S1 and S2 differ only in their qualification conversion and yield
5112 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5113 qualification signature of type T1 is a proper subset of the cv-
5114 qualification signature of type T2 */
5115 if (TREE_CODE (ics1) == QUAL_CONV
5116 && TREE_CODE (ics2) == QUAL_CONV
5117 && same_type_p (from_type1, from_type2))
5118 return comp_cv_qual_signature (to_type1, to_type2);
5122 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5123 types to which the references refer are the same type except for
5124 top-level cv-qualifiers, and the type to which the reference
5125 initialized by S2 refers is more cv-qualified than the type to
5126 which the reference initialized by S1 refers */
5128 if (ref_binding1 && ref_binding2
5129 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5130 return comp_cv_qualification (target_type2, target_type1);
5132 /* Neither conversion sequence is better than the other. */
5136 /* The source type for this standard conversion sequence. */
5142 for (;; t = TREE_OPERAND (t, 0))
5144 if (TREE_CODE (t) == USER_CONV
5145 || TREE_CODE (t) == AMBIG_CONV
5146 || TREE_CODE (t) == IDENTITY_CONV)
5147 return TREE_TYPE (t);
5149 my_friendly_abort (1823);
5152 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5153 a pointer to LOSER and re-running joust to produce the warning if WINNER
5154 is actually used. */
5157 add_warning (winner, loser)
5158 struct z_candidate *winner, *loser;
5160 winner->warnings = tree_cons (NULL_TREE,
5161 build_ptr_wrapper (loser),
5165 /* Returns true iff functions are equivalent. Equivalent functions are
5166 not '==' only if one is a function-local extern function or if
5167 both are extern "C". */
5170 equal_functions (fn1, fn2)
5174 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
5175 || DECL_EXTERN_C_FUNCTION_P (fn1))
5176 return decls_match (fn1, fn2);
5180 /* Compare two candidates for overloading as described in
5181 [over.match.best]. Return values:
5183 1: cand1 is better than cand2
5184 -1: cand2 is better than cand1
5185 0: cand1 and cand2 are indistinguishable */
5188 joust (cand1, cand2, warn)
5189 struct z_candidate *cand1, *cand2;
5193 int i, off1 = 0, off2 = 0, len;
5195 /* Candidates that involve bad conversions are always worse than those
5197 if (cand1->viable > cand2->viable)
5199 if (cand1->viable < cand2->viable)
5202 /* If we have two pseudo-candidates for conversions to the same type,
5203 or two candidates for the same function, arbitrarily pick one. */
5204 if (cand1->fn == cand2->fn
5205 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5208 /* a viable function F1
5209 is defined to be a better function than another viable function F2 if
5210 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5211 ICSi(F2), and then */
5213 /* for some argument j, ICSj(F1) is a better conversion sequence than
5216 /* For comparing static and non-static member functions, we ignore
5217 the implicit object parameter of the non-static function. The
5218 standard says to pretend that the static function has an object
5219 parm, but that won't work with operator overloading. */
5220 len = TREE_VEC_LENGTH (cand1->convs);
5221 if (len != TREE_VEC_LENGTH (cand2->convs))
5223 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5224 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5226 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5227 && DECL_STATIC_FUNCTION_P (cand2->fn))
5233 my_friendly_abort (42);
5236 for (i = 0; i < len; ++i)
5238 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5239 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5240 int comp = compare_ics (t1, t2);
5245 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5246 && TREE_CODE (t1) == STD_CONV
5247 && TREE_CODE (t2) == STD_CONV
5248 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5249 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5250 && (TYPE_PRECISION (TREE_TYPE (t1))
5251 == TYPE_PRECISION (TREE_TYPE (t2)))
5252 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5253 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5256 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5258 struct z_candidate *w, *l;
5260 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5261 w = cand1, l = cand2;
5263 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5264 w = cand2, l = cand1;
5268 cp_warning ("passing `%T' chooses `%T' over `%T'",
5269 type, type1, type2);
5270 cp_warning (" in call to `%D'", w->fn);
5276 if (winner && comp != winner)
5285 /* warn about confusing overload resolution for user-defined conversions,
5286 either between a constructor and a conversion op, or between two
5288 if (winner && cand1->second_conv
5289 && ((DECL_CONSTRUCTOR_P (cand1->fn)
5290 != DECL_CONSTRUCTOR_P (cand2->fn))
5291 /* Don't warn if the two conv ops convert to the same type... */
5292 || (! DECL_CONSTRUCTOR_P (cand1->fn)
5293 && ! same_type_p (TREE_TYPE (TREE_TYPE (cand1->fn)),
5294 TREE_TYPE (TREE_TYPE (cand2->fn))))))
5296 int comp = compare_ics (cand1->second_conv, cand2->second_conv);
5299 struct z_candidate *w, *l;
5302 w = cand1, l = cand2;
5304 w = cand2, l = cand1;
5305 if (DECL_CONTEXT (cand1->fn) == DECL_CONTEXT (cand2->fn)
5306 && ! DECL_CONSTRUCTOR_P (cand1->fn)
5307 && ! DECL_CONSTRUCTOR_P (cand2->fn)
5308 && (convn = standard_conversion
5309 (TREE_TYPE (TREE_TYPE (l->fn)),
5310 TREE_TYPE (TREE_TYPE (w->fn)), NULL_TREE))
5311 && TREE_CODE (convn) == QUAL_CONV)
5312 /* Don't complain about `operator char *()' beating
5313 `operator const char *() const'. */;
5316 tree source = source_type (TREE_VEC_ELT (w->convs, 0));
5317 if (! DECL_CONSTRUCTOR_P (w->fn))
5318 source = TREE_TYPE (source);
5319 cp_warning ("choosing `%D' over `%D'", w->fn, l->fn);
5320 cp_warning (" for conversion from `%T' to `%T'",
5321 source, TREE_TYPE (w->second_conv));
5322 cp_warning (" because conversion sequence for the argument is better");
5333 F1 is a non-template function and F2 is a template function
5336 if (! cand1->template && cand2->template)
5338 else if (cand1->template && ! cand2->template)
5342 F1 and F2 are template functions and the function template for F1 is
5343 more specialized than the template for F2 according to the partial
5346 if (cand1->template && cand2->template)
5348 winner = more_specialized
5349 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
5351 /* Tell the deduction code how many real function arguments
5352 we saw, not counting the implicit 'this' argument. But,
5353 add_function_candidate() suppresses the "this" argument
5356 [temp.func.order]: The presence of unused ellipsis and default
5357 arguments has no effect on the partial ordering of function
5359 TREE_VEC_LENGTH (cand1->convs)
5360 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
5361 - DECL_CONSTRUCTOR_P (cand1->fn)));
5368 the context is an initialization by user-defined conversion (see
5369 _dcl.init_ and _over.match.user_) and the standard conversion
5370 sequence from the return type of F1 to the destination type (i.e.,
5371 the type of the entity being initialized) is a better conversion
5372 sequence than the standard conversion sequence from the return type
5373 of F2 to the destination type. */
5375 if (cand1->second_conv)
5377 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5382 /* Check whether we can discard a builtin candidate, either because we
5383 have two identical ones or matching builtin and non-builtin candidates.
5385 (Pedantically in the latter case the builtin which matched the user
5386 function should not be added to the overload set, but we spot it here.
5389 ... the builtin candidates include ...
5390 - do not have the same parameter type list as any non-template
5391 non-member candidate. */
5393 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
5394 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
5396 for (i = 0; i < len; ++i)
5397 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5398 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i))))
5400 if (i == TREE_VEC_LENGTH (cand1->convs))
5402 if (cand1->fn == cand2->fn)
5403 /* Two built-in candidates; arbitrarily pick one. */
5405 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5406 /* cand1 is built-in; prefer cand2. */
5409 /* cand2 is built-in; prefer cand1. */
5413 /* Kludge around broken overloading rules whereby
5414 Integer a, b; test ? a : b; is ambiguous, since there's a builtin
5415 that takes references and another that takes values. */
5416 if (cand1->fn == cand2->fn
5417 && cand1->fn == ansi_opname (COND_EXPR))
5419 tree c1 = TREE_VEC_ELT (cand1->convs, 1);
5420 tree c2 = TREE_VEC_ELT (cand2->convs, 1);
5421 tree t1 = strip_top_quals (non_reference (TREE_TYPE (c1)));
5422 tree t2 = strip_top_quals (non_reference (TREE_TYPE (c2)));
5424 if (same_type_p (t1, t2))
5426 if (TREE_CODE (c1) == REF_BIND && TREE_CODE (c2) != REF_BIND)
5428 if (TREE_CODE (c1) != REF_BIND && TREE_CODE (c2) == REF_BIND)
5434 /* If the two functions are the same (this can happen with declarations
5435 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5436 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
5437 && equal_functions (cand1->fn, cand2->fn))
5442 /* Extension: If the worst conversion for one candidate is worse than the
5443 worst conversion for the other, take the first. */
5446 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
5447 struct z_candidate *w = 0, *l = 0;
5449 for (i = 0; i < len; ++i)
5451 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5452 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5453 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5454 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5457 winner = 1, w = cand1, l = cand2;
5459 winner = -1, w = cand2, l = cand1;
5464 cp_pedwarn ("choosing `%D' over `%D'", w->fn, l->fn);
5466 " because worst conversion for the former is better than worst conversion for the latter");
5474 my_friendly_assert (!winner, 20010121);
5478 /* Given a list of candidates for overloading, find the best one, if any.
5479 This algorithm has a worst case of O(2n) (winner is last), and a best
5480 case of O(n/2) (totally ambiguous); much better than a sorting
5483 static struct z_candidate *
5484 tourney (candidates)
5485 struct z_candidate *candidates;
5487 struct z_candidate *champ = candidates, *challenger;
5489 int champ_compared_to_predecessor = 0;
5491 /* Walk through the list once, comparing each current champ to the next
5492 candidate, knocking out a candidate or two with each comparison. */
5494 for (challenger = champ->next; challenger; )
5496 fate = joust (champ, challenger, 0);
5498 challenger = challenger->next;
5503 champ = challenger->next;
5506 champ_compared_to_predecessor = 0;
5511 champ_compared_to_predecessor = 1;
5514 challenger = champ->next;
5518 /* Make sure the champ is better than all the candidates it hasn't yet
5519 been compared to. */
5521 for (challenger = candidates;
5523 && !(champ_compared_to_predecessor && challenger->next == champ);
5524 challenger = challenger->next)
5526 fate = joust (champ, challenger, 0);
5534 /* Returns non-zero if things of type FROM can be converted to TO. */
5537 can_convert (to, from)
5540 return can_convert_arg (to, from, NULL_TREE);
5543 /* Returns non-zero if ARG (of type FROM) can be converted to TO. */
5546 can_convert_arg (to, from, arg)
5549 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
5550 return (t && ! ICS_BAD_FLAG (t));
5553 /* Convert EXPR to TYPE. Return the converted expression. */
5556 perform_implicit_conversion (type, expr)
5562 if (expr == error_mark_node)
5563 return error_mark_node;
5564 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
5566 if (!conv || ICS_BAD_FLAG (conv))
5568 cp_error ("could not convert `%E' to `%T'", expr, type);
5569 return error_mark_node;
5572 return convert_like (conv, expr);
5575 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
5576 initializing a variable of that TYPE. Return the converted
5580 initialize_reference (type, expr)
5586 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
5587 if (!conv || ICS_BAD_FLAG (conv))
5589 cp_error ("could not convert `%E' to `%T'", expr, type);
5590 return error_mark_node;
5593 return convert_like (conv, expr);