1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
5 modified by Brendan Kehoe (brendan@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* High-level class interface. */
29 #include "coretypes.h"
38 #include "diagnostic.h"
43 static tree build_field_call (tree, tree, tree);
44 static struct z_candidate * tourney (struct z_candidate *);
45 static int equal_functions (tree, tree);
46 static int joust (struct z_candidate *, struct z_candidate *, bool);
47 static int compare_ics (tree, tree);
48 static tree build_over_call (struct z_candidate *, int);
49 static tree build_java_interface_fn_ref (tree, tree);
50 #define convert_like(CONV, EXPR) \
51 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
52 /*issue_conversion_warnings=*/true)
53 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
54 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
55 /*issue_conversion_warnings=*/true)
56 static tree convert_like_real (tree, tree, tree, int, int, bool);
57 static void op_error (enum tree_code, enum tree_code, tree, tree,
59 static tree build_object_call (tree, tree);
60 static tree resolve_args (tree);
61 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
62 static void print_z_candidate (const char *, struct z_candidate *);
63 static void print_z_candidates (struct z_candidate *);
64 static tree build_this (tree);
65 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
66 static bool any_strictly_viable (struct z_candidate *);
67 static struct z_candidate *add_template_candidate
68 (struct z_candidate **, tree, tree, tree, tree, tree,
69 tree, tree, int, unification_kind_t);
70 static struct z_candidate *add_template_candidate_real
71 (struct z_candidate **, tree, tree, tree, tree, tree,
72 tree, tree, int, tree, unification_kind_t);
73 static struct z_candidate *add_template_conv_candidate
74 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
75 static void add_builtin_candidates
76 (struct z_candidate **, enum tree_code, enum tree_code,
78 static void add_builtin_candidate
79 (struct z_candidate **, enum tree_code, enum tree_code,
80 tree, tree, tree, tree *, tree *, int);
81 static bool is_complete (tree);
82 static void build_builtin_candidate
83 (struct z_candidate **, tree, tree, tree, tree *, tree *,
85 static struct z_candidate *add_conv_candidate
86 (struct z_candidate **, tree, tree, tree, tree, tree);
87 static struct z_candidate *add_function_candidate
88 (struct z_candidate **, tree, tree, tree, tree, tree, int);
89 static tree implicit_conversion (tree, tree, tree, int);
90 static tree standard_conversion (tree, tree, tree);
91 static tree reference_binding (tree, tree, tree, int);
92 static tree build_conv (enum tree_code, tree, tree);
93 static bool is_subseq (tree, tree);
94 static tree maybe_handle_ref_bind (tree *);
95 static void maybe_handle_implicit_object (tree *);
96 static struct z_candidate *add_candidate
97 (struct z_candidate **, tree, tree, tree, tree, tree, int);
98 static tree source_type (tree);
99 static void add_warning (struct z_candidate *, struct z_candidate *);
100 static bool reference_related_p (tree, tree);
101 static bool reference_compatible_p (tree, tree);
102 static tree convert_class_to_reference (tree, tree, tree);
103 static tree direct_reference_binding (tree, tree);
104 static bool promoted_arithmetic_type_p (tree);
105 static tree conditional_conversion (tree, tree);
106 static char *name_as_c_string (tree, tree, bool *);
107 static tree call_builtin_trap (void);
108 static tree prep_operand (tree);
109 static void add_candidates (tree, tree, tree, bool, tree, tree,
110 int, struct z_candidate **);
111 static tree merge_conversion_sequences (tree, tree);
114 build_vfield_ref (tree datum, tree type)
116 if (datum == error_mark_node)
117 return error_mark_node;
119 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
120 datum = convert_from_reference (datum);
122 if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
123 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
124 datum = convert_to_base (datum, type, /*check_access=*/false);
126 return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
127 datum, TYPE_VFIELD (type));
130 /* Build a call to a member of an object. I.e., one that overloads
131 operator ()(), or is a pointer-to-function or pointer-to-method. */
134 build_field_call (tree instance_ptr, tree decl, tree parms)
138 if (decl == error_mark_node || decl == NULL_TREE)
141 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
143 /* If it's a field, try overloading operator (),
144 or calling if the field is a pointer-to-function. */
145 instance = build_indirect_ref (instance_ptr, NULL);
146 instance = build_class_member_access_expr (instance, decl,
147 /*access_path=*/NULL_TREE,
148 /*preserve_reference=*/false);
150 if (instance == error_mark_node)
151 return error_mark_node;
153 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
154 return build_new_op (CALL_EXPR, LOOKUP_NORMAL,
155 instance, parms, NULL_TREE);
156 else if (TREE_CODE (TREE_TYPE (instance)) == FUNCTION_TYPE
157 || (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE
158 && (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
160 return build_function_call (instance, parms);
166 /* Returns nonzero iff the destructor name specified in NAME
167 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
171 check_dtor_name (tree basetype, tree name)
173 name = TREE_OPERAND (name, 0);
175 /* Just accept something we've already complained about. */
176 if (name == error_mark_node)
179 if (TREE_CODE (name) == TYPE_DECL)
180 name = TREE_TYPE (name);
181 else if (TYPE_P (name))
183 else if (TREE_CODE (name) == IDENTIFIER_NODE)
185 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
186 || (TREE_CODE (basetype) == ENUMERAL_TYPE
187 && name == TYPE_IDENTIFIER (basetype)))
190 name = get_type_value (name);
194 template <class T> struct S { ~S(); };
198 NAME will be a class template. */
199 else if (DECL_CLASS_TEMPLATE_P (name))
204 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
209 /* We want the address of a function or method. We avoid creating a
210 pointer-to-member function. */
213 build_addr_func (tree function)
215 tree type = TREE_TYPE (function);
217 /* We have to do these by hand to avoid real pointer to member
219 if (TREE_CODE (type) == METHOD_TYPE)
221 if (TREE_CODE (function) == OFFSET_REF)
223 tree object = build_address (TREE_OPERAND (function, 0));
224 return get_member_function_from_ptrfunc (&object,
225 TREE_OPERAND (function, 1));
227 function = build_address (function);
230 function = decay_conversion (function);
235 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
236 POINTER_TYPE to those. Note, pointer to member function types
237 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
240 build_call (tree function, tree parms)
242 int is_constructor = 0;
249 function = build_addr_func (function);
251 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
253 sorry ("unable to call pointer to member function here");
254 return error_mark_node;
257 fntype = TREE_TYPE (TREE_TYPE (function));
258 result_type = TREE_TYPE (fntype);
260 if (TREE_CODE (function) == ADDR_EXPR
261 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
262 decl = TREE_OPERAND (function, 0);
266 /* We check both the decl and the type; a function may be known not to
267 throw without being declared throw(). */
268 nothrow = ((decl && TREE_NOTHROW (decl))
269 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
271 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
272 current_function_returns_abnormally = 1;
274 if (decl && TREE_DEPRECATED (decl))
275 warn_deprecated_use (decl);
276 require_complete_eh_spec_types (fntype, decl);
278 if (decl && DECL_CONSTRUCTOR_P (decl))
281 if (decl && ! TREE_USED (decl))
283 /* We invoke build_call directly for several library functions.
284 These may have been declared normally if we're building libgcc,
285 so we can't just check DECL_ARTIFICIAL. */
286 if (DECL_ARTIFICIAL (decl)
287 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
293 /* Don't pass empty class objects by value. This is useful
294 for tags in STL, which are used to control overload resolution.
295 We don't need to handle other cases of copying empty classes. */
296 if (! decl || ! DECL_BUILT_IN (decl))
297 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
298 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
299 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
301 tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
302 TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
303 TREE_VALUE (tmp), t);
306 function = build_nt (CALL_EXPR, function, parms, NULL_TREE);
307 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
308 TREE_TYPE (function) = result_type;
309 TREE_SIDE_EFFECTS (function) = 1;
310 TREE_NOTHROW (function) = nothrow;
315 /* Build something of the form ptr->method (args)
316 or object.method (args). This can also build
317 calls to constructors, and find friends.
319 Member functions always take their class variable
322 INSTANCE is a class instance.
324 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
326 PARMS help to figure out what that NAME really refers to.
328 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
329 down to the real instance type to use for access checking. We need this
330 information to get protected accesses correct.
332 FLAGS is the logical disjunction of zero or more LOOKUP_
333 flags. See cp-tree.h for more info.
335 If this is all OK, calls build_function_call with the resolved
338 This function must also handle being called to perform
339 initialization, promotion/coercion of arguments, and
340 instantiation of default parameters.
342 Note that NAME may refer to an instance variable name. If
343 `operator()()' is defined for the type of that field, then we return
346 #ifdef GATHER_STATISTICS
347 extern int n_build_method_call;
351 build_method_call (tree instance, tree name, tree parms,
352 tree basetype_path, int flags)
356 tree template_args = NULL_TREE;
357 bool has_template_args = false;
359 #ifdef GATHER_STATISTICS
360 n_build_method_call++;
363 if (error_operand_p (instance)
364 || name == error_mark_node
365 || parms == error_mark_node)
366 return error_mark_node;
368 my_friendly_assert (!processing_template_decl, 20030707);
370 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
371 instance = convert_from_reference (instance);
372 object_type = TREE_TYPE (instance);
374 if (TREE_CODE (name) == BIT_NOT_EXPR)
379 error ("destructors take no parameters");
381 if (! check_dtor_name (object_type, name))
383 ("destructor name `~%T' does not match type `%T' of expression",
384 TREE_OPERAND (name, 0), object_type);
386 if (! TYPE_HAS_DESTRUCTOR (complete_type (object_type)))
387 return convert_to_void (instance, /*implicit=*/NULL);
388 instance = default_conversion (instance);
389 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
390 return build_delete (build_pointer_type (object_type),
391 instance_ptr, sfk_complete_destructor,
392 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
395 if (!CLASS_TYPE_P (object_type))
397 if ((flags & LOOKUP_COMPLAIN)
398 && TREE_TYPE (instance) != error_mark_node)
399 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
400 name, instance, object_type);
401 return error_mark_node;
404 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
406 template_args = TREE_OPERAND (name, 1);
407 has_template_args = true;
408 name = TREE_OPERAND (name, 0);
410 if (TREE_CODE (name) == OVERLOAD)
411 name = DECL_NAME (get_first_fn (name));
412 else if (DECL_P (name))
413 name = DECL_NAME (name);
414 if (has_template_args)
415 fn = lookup_fnfields (object_type, name, /*protect=*/2);
417 fn = lookup_member (object_type, name, /*protect=*/2, /*want_type=*/false);
419 if (fn && TREE_CODE (fn) == TREE_LIST)
421 error ("request for member `%D' is ambiguous", name);
422 print_candidates (fn);
423 return error_mark_node;
426 /* If the name could not be found, issue an error. */
428 return unqualified_name_lookup_error (name);
430 if (BASELINK_P (fn) && has_template_args)
431 BASELINK_FUNCTIONS (fn)
432 = build_nt (TEMPLATE_ID_EXPR,
433 BASELINK_FUNCTIONS (fn),
435 if (BASELINK_P (fn) && basetype_path)
436 BASELINK_ACCESS_BINFO (fn) = basetype_path;
438 return build_new_method_call (instance, fn, parms,
439 /*conversion_path=*/NULL_TREE, flags);
442 /* New overloading code. */
444 struct z_candidate GTY(()) {
445 /* The FUNCTION_DECL that will be called if this candidate is
446 selected by overload resolution. */
448 /* The arguments to use when calling this function. */
450 /* The implicit conversion sequences for each of the arguments to
453 /* If FN is a user-defined conversion, the standard conversion
454 sequence from the type returned by FN to the desired destination
458 /* If FN is a member function, the binfo indicating the path used to
459 qualify the name of FN at the call site. This path is used to
460 determine whether or not FN is accessible if it is selected by
461 overload resolution. The DECL_CONTEXT of FN will always be a
462 (possibly improper) base of this binfo. */
464 /* If FN is a non-static member function, the binfo indicating the
465 subobject to which the `this' pointer should be converted if FN
466 is selected by overload resolution. The type pointed to the by
467 the `this' pointer must correspond to the most derived class
468 indicated by the CONVERSION_PATH. */
469 tree conversion_path;
472 struct z_candidate *next;
475 #define IDENTITY_RANK 0
481 #define ELLIPSIS_RANK 6
484 #define ICS_RANK(NODE) \
485 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
486 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
487 : ICS_USER_FLAG (NODE) ? USER_RANK \
488 : ICS_STD_RANK (NODE))
490 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
492 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
493 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
494 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
495 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
497 /* In a REF_BIND or a BASE_CONV, this indicates that a temporary
498 should be created to hold the result of the conversion. */
499 #define NEED_TEMPORARY_P(NODE) TREE_LANG_FLAG_4 (NODE)
501 #define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1))
502 #define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
505 null_ptr_cst_p (tree t)
509 A null pointer constant is an integral constant expression
510 (_expr.const_) rvalue of integer type that evaluates to zero. */
512 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
518 /* Returns nonzero if PARMLIST consists of only default parms and/or
522 sufficient_parms_p (tree parmlist)
524 for (; parmlist && parmlist != void_list_node;
525 parmlist = TREE_CHAIN (parmlist))
526 if (!TREE_PURPOSE (parmlist))
532 build_conv (enum tree_code code, tree type, tree from)
535 int rank = ICS_STD_RANK (from);
537 /* We can't use buildl1 here because CODE could be USER_CONV, which
538 takes two arguments. In that case, the caller is responsible for
539 filling in the second argument. */
540 t = make_node (code);
541 TREE_TYPE (t) = type;
542 TREE_OPERAND (t, 0) = from;
555 if (rank < EXACT_RANK)
561 ICS_STD_RANK (t) = rank;
562 ICS_USER_FLAG (t) = (code == USER_CONV || ICS_USER_FLAG (from));
563 ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);
568 strip_top_quals (tree t)
570 if (TREE_CODE (t) == ARRAY_TYPE)
572 return cp_build_qualified_type (t, 0);
575 /* Returns the standard conversion path (see [conv]) from type FROM to type
576 TO, if any. For proper handling of null pointer constants, you must
577 also pass the expression EXPR to convert from. */
580 standard_conversion (tree to, tree from, tree expr)
582 enum tree_code fcode, tcode;
584 bool fromref = false;
586 to = non_reference (to);
587 if (TREE_CODE (from) == REFERENCE_TYPE)
590 from = TREE_TYPE (from);
592 to = strip_top_quals (to);
593 from = strip_top_quals (from);
595 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
596 && expr && type_unknown_p (expr))
598 expr = instantiate_type (to, expr, tf_none);
599 if (expr == error_mark_node)
601 from = TREE_TYPE (expr);
604 fcode = TREE_CODE (from);
605 tcode = TREE_CODE (to);
607 conv = build1 (IDENTITY_CONV, from, expr);
609 if (fcode == FUNCTION_TYPE)
611 from = build_pointer_type (from);
612 fcode = TREE_CODE (from);
613 conv = build_conv (LVALUE_CONV, from, conv);
615 else if (fcode == ARRAY_TYPE)
617 from = build_pointer_type (TREE_TYPE (from));
618 fcode = TREE_CODE (from);
619 conv = build_conv (LVALUE_CONV, from, conv);
621 else if (fromref || (expr && lvalue_p (expr)))
622 conv = build_conv (RVALUE_CONV, from, conv);
624 /* Allow conversion between `__complex__' data types */
625 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
627 /* The standard conversion sequence to convert FROM to TO is
628 the standard conversion sequence to perform componentwise
630 tree part_conv = standard_conversion
631 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
635 conv = build_conv (TREE_CODE (part_conv), to, conv);
636 ICS_STD_RANK (conv) = ICS_STD_RANK (part_conv);
644 if (same_type_p (from, to))
647 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
648 && expr && null_ptr_cst_p (expr))
649 conv = build_conv (STD_CONV, to, conv);
650 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE
651 && TREE_CODE (TREE_TYPE (to)) == VECTOR_TYPE
652 && TREE_CODE (TREE_TYPE (from)) == VECTOR_TYPE
653 && ((*targetm.vector_opaque_p) (TREE_TYPE (to))
654 || (*targetm.vector_opaque_p) (TREE_TYPE (from))))
655 conv = build_conv (STD_CONV, to, conv);
656 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
657 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
659 /* For backwards brain damage compatibility, allow interconversion of
660 pointers and integers with a pedwarn. */
661 conv = build_conv (STD_CONV, to, conv);
662 ICS_BAD_FLAG (conv) = 1;
664 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
666 /* For backwards brain damage compatibility, allow interconversion of
667 enums and integers with a pedwarn. */
668 conv = build_conv (STD_CONV, to, conv);
669 ICS_BAD_FLAG (conv) = 1;
671 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
672 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
677 if (tcode == POINTER_TYPE
678 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
681 else if (VOID_TYPE_P (TREE_TYPE (to))
682 && !TYPE_PTRMEM_P (from)
683 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
685 from = build_pointer_type
686 (cp_build_qualified_type (void_type_node,
687 cp_type_quals (TREE_TYPE (from))));
688 conv = build_conv (PTR_CONV, from, conv);
690 else if (TYPE_PTRMEM_P (from))
692 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
693 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
695 if (DERIVED_FROM_P (fbase, tbase)
696 && (same_type_ignoring_top_level_qualifiers_p
697 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
698 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
700 from = build_ptrmem_type (tbase,
701 TYPE_PTRMEM_POINTED_TO_TYPE (from));
702 conv = build_conv (PMEM_CONV, from, conv);
705 else if (IS_AGGR_TYPE (TREE_TYPE (from))
706 && IS_AGGR_TYPE (TREE_TYPE (to)))
708 if (DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
711 cp_build_qualified_type (TREE_TYPE (to),
712 cp_type_quals (TREE_TYPE (from)));
713 from = build_pointer_type (from);
714 conv = build_conv (PTR_CONV, from, conv);
718 if (tcode == POINTER_TYPE)
720 to_pointee = TREE_TYPE (to);
721 from_pointee = TREE_TYPE (from);
725 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
726 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
729 if (same_type_p (from, to))
731 else if (comp_ptr_ttypes (to_pointee, from_pointee))
732 conv = build_conv (QUAL_CONV, to, conv);
733 else if (expr && string_conv_p (to, expr, 0))
734 /* converting from string constant to char *. */
735 conv = build_conv (QUAL_CONV, to, conv);
736 else if (ptr_reasonably_similar (to_pointee, from_pointee))
738 conv = build_conv (PTR_CONV, to, conv);
739 ICS_BAD_FLAG (conv) = 1;
746 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
748 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
749 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
750 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
751 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
753 if (!DERIVED_FROM_P (fbase, tbase)
754 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
755 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
756 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
757 || cp_type_quals (fbase) != cp_type_quals (tbase))
760 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
761 from = build_cplus_method_type (from, TREE_TYPE (fromfn),
762 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
763 from = build_ptrmemfunc_type (build_pointer_type (from));
764 conv = build_conv (PMEM_CONV, from, conv);
766 else if (tcode == BOOLEAN_TYPE)
770 An rvalue of arithmetic, enumeration, pointer, or pointer to
771 member type can be converted to an rvalue of type bool. */
772 if (ARITHMETIC_TYPE_P (from)
773 || fcode == ENUMERAL_TYPE
774 || fcode == POINTER_TYPE
775 || TYPE_PTR_TO_MEMBER_P (from))
777 conv = build_conv (STD_CONV, to, conv);
778 if (fcode == POINTER_TYPE
779 || TYPE_PTRMEM_P (from)
780 || (TYPE_PTRMEMFUNC_P (from)
781 && ICS_STD_RANK (conv) < PBOOL_RANK))
782 ICS_STD_RANK (conv) = PBOOL_RANK;
788 /* We don't check for ENUMERAL_TYPE here because there are no standard
789 conversions to enum type. */
790 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
791 || tcode == REAL_TYPE)
793 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
795 conv = build_conv (STD_CONV, to, conv);
797 /* Give this a better rank if it's a promotion. */
798 if (same_type_p (to, type_promotes_to (from))
799 && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK)
800 ICS_STD_RANK (conv) = PROMO_RANK;
802 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
803 && ((*targetm.vector_opaque_p) (from)
804 || (*targetm.vector_opaque_p) (to)))
805 return build_conv (STD_CONV, to, conv);
806 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
807 && is_properly_derived_from (from, to))
809 if (TREE_CODE (conv) == RVALUE_CONV)
810 conv = TREE_OPERAND (conv, 0);
811 conv = build_conv (BASE_CONV, to, conv);
812 /* The derived-to-base conversion indicates the initialization
813 of a parameter with base type from an object of a derived
814 type. A temporary object is created to hold the result of
816 NEED_TEMPORARY_P (conv) = 1;
824 /* Returns nonzero if T1 is reference-related to T2. */
827 reference_related_p (tree t1, tree t2)
829 t1 = TYPE_MAIN_VARIANT (t1);
830 t2 = TYPE_MAIN_VARIANT (t2);
834 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
835 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
837 return (same_type_p (t1, t2)
838 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
839 && DERIVED_FROM_P (t1, t2)));
842 /* Returns nonzero if T1 is reference-compatible with T2. */
845 reference_compatible_p (tree t1, tree t2)
849 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
850 reference-related to T2 and cv1 is the same cv-qualification as,
851 or greater cv-qualification than, cv2. */
852 return (reference_related_p (t1, t2)
853 && at_least_as_qualified_p (t1, t2));
856 /* Determine whether or not the EXPR (of class type S) can be
857 converted to T as in [over.match.ref]. */
860 convert_class_to_reference (tree t, tree s, tree expr)
866 struct z_candidate *candidates;
867 struct z_candidate *cand;
870 conversions = lookup_conversions (s);
876 Assuming that "cv1 T" is the underlying type of the reference
877 being initialized, and "cv S" is the type of the initializer
878 expression, with S a class type, the candidate functions are
881 --The conversion functions of S and its base classes are
882 considered. Those that are not hidden within S and yield type
883 "reference to cv2 T2", where "cv1 T" is reference-compatible
884 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
886 The argument list has one argument, which is the initializer
891 /* Conceptually, we should take the address of EXPR and put it in
892 the argument list. Unfortunately, however, that can result in
893 error messages, which we should not issue now because we are just
894 trying to find a conversion operator. Therefore, we use NULL,
895 cast to the appropriate type. */
896 arglist = build_int_2 (0, 0);
897 TREE_TYPE (arglist) = build_pointer_type (s);
898 arglist = build_tree_list (NULL_TREE, arglist);
900 reference_type = build_reference_type (t);
904 tree fns = TREE_VALUE (conversions);
906 for (; fns; fns = OVL_NEXT (fns))
908 tree f = OVL_CURRENT (fns);
909 tree t2 = TREE_TYPE (TREE_TYPE (f));
913 /* If this is a template function, try to get an exact
915 if (TREE_CODE (f) == TEMPLATE_DECL)
917 cand = add_template_candidate (&candidates,
923 TREE_PURPOSE (conversions),
929 /* Now, see if the conversion function really returns
930 an lvalue of the appropriate type. From the
931 point of view of unification, simply returning an
932 rvalue of the right type is good enough. */
934 t2 = TREE_TYPE (TREE_TYPE (f));
935 if (TREE_CODE (t2) != REFERENCE_TYPE
936 || !reference_compatible_p (t, TREE_TYPE (t2)))
938 candidates = candidates->next;
943 else if (TREE_CODE (t2) == REFERENCE_TYPE
944 && reference_compatible_p (t, TREE_TYPE (t2)))
945 cand = add_function_candidate (&candidates, f, s, arglist,
947 TREE_PURPOSE (conversions),
951 /* Build a standard conversion sequence indicating the
952 binding from the reference type returned by the
953 function to the desired REFERENCE_TYPE. */
955 = (direct_reference_binding
957 build1 (IDENTITY_CONV,
958 TREE_TYPE (TREE_TYPE (TREE_TYPE (cand->fn))),
961 conversions = TREE_CHAIN (conversions);
964 candidates = splice_viable (candidates, pedantic, &any_viable_p);
965 /* If none of the conversion functions worked out, let our caller
970 cand = tourney (candidates);
974 /* Now that we know that this is the function we're going to use fix
975 the dummy first argument. */
976 cand->args = tree_cons (NULL_TREE,
978 TREE_CHAIN (cand->args));
980 /* Build a user-defined conversion sequence representing the
982 conv = build_conv (USER_CONV,
983 TREE_TYPE (TREE_TYPE (cand->fn)),
984 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
985 TREE_OPERAND (conv, 1) = build_zc_wrapper (cand);
987 /* Merge it with the standard conversion sequence from the
988 conversion function's return type to the desired type. */
989 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
991 if (cand->viable == -1)
992 ICS_BAD_FLAG (conv) = 1;
994 return cand->second_conv;
997 /* A reference of the indicated TYPE is being bound directly to the
998 expression represented by the implicit conversion sequence CONV.
999 Return a conversion sequence for this binding. */
1002 direct_reference_binding (tree type, tree conv)
1006 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
1007 my_friendly_assert (TREE_CODE (TREE_TYPE (conv)) != REFERENCE_TYPE,
1010 t = TREE_TYPE (type);
1014 When a parameter of reference type binds directly
1015 (_dcl.init.ref_) to an argument expression, the implicit
1016 conversion sequence is the identity conversion, unless the
1017 argument expression has a type that is a derived class of the
1018 parameter type, in which case the implicit conversion sequence is
1019 a derived-to-base Conversion.
1021 If the parameter binds directly to the result of applying a
1022 conversion function to the argument expression, the implicit
1023 conversion sequence is a user-defined conversion sequence
1024 (_over.ics.user_), with the second standard conversion sequence
1025 either an identity conversion or, if the conversion function
1026 returns an entity of a type that is a derived class of the
1027 parameter type, a derived-to-base conversion. */
1028 if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv)))
1030 /* Represent the derived-to-base conversion. */
1031 conv = build_conv (BASE_CONV, t, conv);
1032 /* We will actually be binding to the base-class subobject in
1033 the derived class, so we mark this conversion appropriately.
1034 That way, convert_like knows not to generate a temporary. */
1035 NEED_TEMPORARY_P (conv) = 0;
1037 return build_conv (REF_BIND, type, conv);
1040 /* Returns the conversion path from type FROM to reference type TO for
1041 purposes of reference binding. For lvalue binding, either pass a
1042 reference type to FROM or an lvalue expression to EXPR. If the
1043 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1044 the conversion returned. */
1047 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1049 tree conv = NULL_TREE;
1050 tree to = TREE_TYPE (rto);
1054 cp_lvalue_kind lvalue_p = clk_none;
1056 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1058 expr = instantiate_type (to, expr, tf_none);
1059 if (expr == error_mark_node)
1061 from = TREE_TYPE (expr);
1064 if (TREE_CODE (from) == REFERENCE_TYPE)
1066 /* Anything with reference type is an lvalue. */
1067 lvalue_p = clk_ordinary;
1068 from = TREE_TYPE (from);
1071 lvalue_p = real_lvalue_p (expr);
1073 /* Figure out whether or not the types are reference-related and
1074 reference compatible. We have do do this after stripping
1075 references from FROM. */
1076 related_p = reference_related_p (to, from);
1077 compatible_p = reference_compatible_p (to, from);
1079 if (lvalue_p && compatible_p)
1083 If the initializer expression
1085 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1086 is reference-compatible with "cv2 T2,"
1088 the reference is bound directly to the initializer expression
1090 conv = build1 (IDENTITY_CONV, from, expr);
1091 conv = direct_reference_binding (rto, conv);
1092 if ((lvalue_p & clk_bitfield) != 0
1093 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1094 /* For the purposes of overload resolution, we ignore the fact
1095 this expression is a bitfield or packed field. (In particular,
1096 [over.ics.ref] says specifically that a function with a
1097 non-const reference parameter is viable even if the
1098 argument is a bitfield.)
1100 However, when we actually call the function we must create
1101 a temporary to which to bind the reference. If the
1102 reference is volatile, or isn't const, then we cannot make
1103 a temporary, so we just issue an error when the conversion
1105 NEED_TEMPORARY_P (conv) = 1;
1109 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1113 If the initializer expression
1115 -- has a class type (i.e., T2 is a class type) can be
1116 implicitly converted to an lvalue of type "cv3 T3," where
1117 "cv1 T1" is reference-compatible with "cv3 T3". (this
1118 conversion is selected by enumerating the applicable
1119 conversion functions (_over.match.ref_) and choosing the
1120 best one through overload resolution. (_over.match_).
1122 the reference is bound to the lvalue result of the conversion
1123 in the second case. */
1124 conv = convert_class_to_reference (to, from, expr);
1129 /* From this point on, we conceptually need temporaries, even if we
1130 elide them. Only the cases above are "direct bindings". */
1131 if (flags & LOOKUP_NO_TEMP_BIND)
1136 When a parameter of reference type is not bound directly to an
1137 argument expression, the conversion sequence is the one required
1138 to convert the argument expression to the underlying type of the
1139 reference according to _over.best.ics_. Conceptually, this
1140 conversion sequence corresponds to copy-initializing a temporary
1141 of the underlying type with the argument expression. Any
1142 difference in top-level cv-qualification is subsumed by the
1143 initialization itself and does not constitute a conversion. */
1147 Otherwise, the reference shall be to a non-volatile const type. */
1148 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1153 If the initializer expression is an rvalue, with T2 a class type,
1154 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1155 is bound in one of the following ways:
1157 -- The reference is bound to the object represented by the rvalue
1158 or to a sub-object within that object.
1162 We use the first alternative. The implicit conversion sequence
1163 is supposed to be same as we would obtain by generating a
1164 temporary. Fortunately, if the types are reference compatible,
1165 then this is either an identity conversion or the derived-to-base
1166 conversion, just as for direct binding. */
1167 if (CLASS_TYPE_P (from) && compatible_p)
1169 conv = build1 (IDENTITY_CONV, from, expr);
1170 return direct_reference_binding (rto, conv);
1175 Otherwise, a temporary of type "cv1 T1" is created and
1176 initialized from the initializer expression using the rules for a
1177 non-reference copy initialization. If T1 is reference-related to
1178 T2, cv1 must be the same cv-qualification as, or greater
1179 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1180 if (related_p && !at_least_as_qualified_p (to, from))
1183 conv = implicit_conversion (to, from, expr, flags);
1187 conv = build_conv (REF_BIND, rto, conv);
1188 /* This reference binding, unlike those above, requires the
1189 creation of a temporary. */
1190 NEED_TEMPORARY_P (conv) = 1;
1195 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1196 to type TO. The optional expression EXPR may affect the conversion.
1197 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1201 implicit_conversion (tree to, tree from, tree expr, int flags)
1205 if (from == error_mark_node || to == error_mark_node
1206 || expr == error_mark_node)
1209 if (TREE_CODE (to) == REFERENCE_TYPE)
1210 conv = reference_binding (to, from, expr, flags);
1212 conv = standard_conversion (to, from, expr);
1217 if (expr != NULL_TREE
1218 && (IS_AGGR_TYPE (from)
1219 || IS_AGGR_TYPE (to))
1220 && (flags & LOOKUP_NO_CONVERSION) == 0)
1222 struct z_candidate *cand;
1224 cand = build_user_type_conversion_1
1225 (to, expr, LOOKUP_ONLYCONVERTING);
1227 conv = cand->second_conv;
1229 /* We used to try to bind a reference to a temporary here, but that
1230 is now handled by the recursive call to this function at the end
1231 of reference_binding. */
1238 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1241 static struct z_candidate *
1242 add_candidate (struct z_candidate **candidates,
1243 tree fn, tree args, tree convs, tree access_path,
1244 tree conversion_path, int viable)
1246 struct z_candidate *cand = ggc_alloc_cleared (sizeof (struct z_candidate));
1250 cand->convs = convs;
1251 cand->access_path = access_path;
1252 cand->conversion_path = conversion_path;
1253 cand->viable = viable;
1254 cand->next = *candidates;
1260 /* Create an overload candidate for the function or method FN called with
1261 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1262 to implicit_conversion.
1264 CTYPE, if non-NULL, is the type we want to pretend this function
1265 comes from for purposes of overload resolution. */
1267 static struct z_candidate *
1268 add_function_candidate (struct z_candidate **candidates,
1269 tree fn, tree ctype, tree arglist,
1270 tree access_path, tree conversion_path,
1273 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1276 tree parmnode, argnode;
1280 /* Built-in functions that haven't been declared don't really
1282 if (DECL_ANTICIPATED (fn))
1285 /* The `this', `in_chrg' and VTT arguments to constructors are not
1286 considered in overload resolution. */
1287 if (DECL_CONSTRUCTOR_P (fn))
1289 parmlist = skip_artificial_parms_for (fn, parmlist);
1290 orig_arglist = arglist;
1291 arglist = skip_artificial_parms_for (fn, arglist);
1294 orig_arglist = arglist;
1296 len = list_length (arglist);
1297 convs = make_tree_vec (len);
1299 /* 13.3.2 - Viable functions [over.match.viable]
1300 First, to be a viable function, a candidate function shall have enough
1301 parameters to agree in number with the arguments in the list.
1303 We need to check this first; otherwise, checking the ICSes might cause
1304 us to produce an ill-formed template instantiation. */
1306 parmnode = parmlist;
1307 for (i = 0; i < len; ++i)
1309 if (parmnode == NULL_TREE || parmnode == void_list_node)
1311 parmnode = TREE_CHAIN (parmnode);
1314 if (i < len && parmnode)
1317 /* Make sure there are default args for the rest of the parms. */
1318 else if (!sufficient_parms_p (parmnode))
1324 /* Second, for F to be a viable function, there shall exist for each
1325 argument an implicit conversion sequence that converts that argument
1326 to the corresponding parameter of F. */
1328 parmnode = parmlist;
1331 for (i = 0; i < len; ++i)
1333 tree arg = TREE_VALUE (argnode);
1334 tree argtype = lvalue_type (arg);
1338 if (parmnode == void_list_node)
1341 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1342 && ! DECL_CONSTRUCTOR_P (fn));
1346 tree parmtype = TREE_VALUE (parmnode);
1348 /* The type of the implicit object parameter ('this') for
1349 overload resolution is not always the same as for the
1350 function itself; conversion functions are considered to
1351 be members of the class being converted, and functions
1352 introduced by a using-declaration are considered to be
1353 members of the class that uses them.
1355 Since build_over_call ignores the ICS for the `this'
1356 parameter, we can just change the parm type. */
1357 if (ctype && is_this)
1360 = build_qualified_type (ctype,
1361 TYPE_QUALS (TREE_TYPE (parmtype)));
1362 parmtype = build_pointer_type (parmtype);
1365 t = implicit_conversion (parmtype, argtype, arg, flags);
1369 t = build1 (IDENTITY_CONV, argtype, arg);
1370 ICS_ELLIPSIS_FLAG (t) = 1;
1374 ICS_THIS_FLAG (t) = 1;
1376 TREE_VEC_ELT (convs, i) = t;
1383 if (ICS_BAD_FLAG (t))
1387 parmnode = TREE_CHAIN (parmnode);
1388 argnode = TREE_CHAIN (argnode);
1392 return add_candidate (candidates, fn, orig_arglist, convs, access_path,
1393 conversion_path, viable);
1396 /* Create an overload candidate for the conversion function FN which will
1397 be invoked for expression OBJ, producing a pointer-to-function which
1398 will in turn be called with the argument list ARGLIST, and add it to
1399 CANDIDATES. FLAGS is passed on to implicit_conversion.
1401 Actually, we don't really care about FN; we care about the type it
1402 converts to. There may be multiple conversion functions that will
1403 convert to that type, and we rely on build_user_type_conversion_1 to
1404 choose the best one; so when we create our candidate, we record the type
1405 instead of the function. */
1407 static struct z_candidate *
1408 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1409 tree arglist, tree access_path, tree conversion_path)
1411 tree totype = TREE_TYPE (TREE_TYPE (fn));
1412 int i, len, viable, flags;
1413 tree parmlist, convs, parmnode, argnode;
1415 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1416 parmlist = TREE_TYPE (parmlist);
1417 parmlist = TYPE_ARG_TYPES (parmlist);
1419 len = list_length (arglist) + 1;
1420 convs = make_tree_vec (len);
1421 parmnode = parmlist;
1424 flags = LOOKUP_NORMAL;
1426 /* Don't bother looking up the same type twice. */
1427 if (*candidates && (*candidates)->fn == totype)
1430 for (i = 0; i < len; ++i)
1432 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1433 tree argtype = lvalue_type (arg);
1437 t = implicit_conversion (totype, argtype, arg, flags);
1438 else if (parmnode == void_list_node)
1441 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1444 t = build1 (IDENTITY_CONV, argtype, arg);
1445 ICS_ELLIPSIS_FLAG (t) = 1;
1448 TREE_VEC_ELT (convs, i) = t;
1452 if (ICS_BAD_FLAG (t))
1459 parmnode = TREE_CHAIN (parmnode);
1460 argnode = TREE_CHAIN (argnode);
1466 if (!sufficient_parms_p (parmnode))
1469 return add_candidate (candidates, totype, arglist, convs, access_path,
1470 conversion_path, viable);
1474 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1475 tree type1, tree type2, tree *args, tree *argtypes,
1485 convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
1487 for (i = 0; i < 2; ++i)
1492 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1496 /* We need something for printing the candidate. */
1497 t = build1 (IDENTITY_CONV, types[i], NULL_TREE);
1499 else if (ICS_BAD_FLAG (t))
1501 TREE_VEC_ELT (convs, i) = t;
1504 /* For COND_EXPR we rearranged the arguments; undo that now. */
1507 TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1);
1508 TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0);
1509 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1511 TREE_VEC_ELT (convs, 0) = t;
1516 add_candidate (candidates, fnname, /*args=*/NULL_TREE, convs,
1517 /*access_path=*/NULL_TREE,
1518 /*conversion_path=*/NULL_TREE,
1523 is_complete (tree t)
1525 return COMPLETE_TYPE_P (complete_type (t));
1528 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1531 promoted_arithmetic_type_p (tree type)
1535 In this section, the term promoted integral type is used to refer
1536 to those integral types which are preserved by integral promotion
1537 (including e.g. int and long but excluding e.g. char).
1538 Similarly, the term promoted arithmetic type refers to promoted
1539 integral types plus floating types. */
1540 return ((INTEGRAL_TYPE_P (type)
1541 && same_type_p (type_promotes_to (type), type))
1542 || TREE_CODE (type) == REAL_TYPE);
1545 /* Create any builtin operator overload candidates for the operator in
1546 question given the converted operand types TYPE1 and TYPE2. The other
1547 args are passed through from add_builtin_candidates to
1548 build_builtin_candidate.
1550 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1551 If CODE is requires candidates operands of the same type of the kind
1552 of which TYPE1 and TYPE2 are, we add both candidates
1553 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1556 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1557 enum tree_code code2, tree fnname, tree type1,
1558 tree type2, tree *args, tree *argtypes, int flags)
1562 case POSTINCREMENT_EXPR:
1563 case POSTDECREMENT_EXPR:
1564 args[1] = integer_zero_node;
1565 type2 = integer_type_node;
1574 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1575 and VQ is either volatile or empty, there exist candidate operator
1576 functions of the form
1577 VQ T& operator++(VQ T&);
1578 T operator++(VQ T&, int);
1579 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1580 type other than bool, and VQ is either volatile or empty, there exist
1581 candidate operator functions of the form
1582 VQ T& operator--(VQ T&);
1583 T operator--(VQ T&, int);
1584 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1585 complete object type, and VQ is either volatile or empty, there exist
1586 candidate operator functions of the form
1587 T*VQ& operator++(T*VQ&);
1588 T*VQ& operator--(T*VQ&);
1589 T* operator++(T*VQ&, int);
1590 T* operator--(T*VQ&, int); */
1592 case POSTDECREMENT_EXPR:
1593 case PREDECREMENT_EXPR:
1594 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1596 case POSTINCREMENT_EXPR:
1597 case PREINCREMENT_EXPR:
1598 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1600 type1 = build_reference_type (type1);
1605 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1606 exist candidate operator functions of the form
1610 8 For every function type T, there exist candidate operator functions of
1612 T& operator*(T*); */
1615 if (TREE_CODE (type1) == POINTER_TYPE
1616 && (TYPE_PTROB_P (type1)
1617 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1621 /* 9 For every type T, there exist candidate operator functions of the form
1624 10For every promoted arithmetic type T, there exist candidate operator
1625 functions of the form
1629 case CONVERT_EXPR: /* unary + */
1630 if (TREE_CODE (type1) == POINTER_TYPE)
1633 if (ARITHMETIC_TYPE_P (type1))
1637 /* 11For every promoted integral type T, there exist candidate operator
1638 functions of the form
1642 if (INTEGRAL_TYPE_P (type1))
1646 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1647 is the same type as C2 or is a derived class of C2, T is a complete
1648 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1649 there exist candidate operator functions of the form
1650 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1651 where CV12 is the union of CV1 and CV2. */
1654 if (TREE_CODE (type1) == POINTER_TYPE
1655 && TYPE_PTR_TO_MEMBER_P (type2))
1657 tree c1 = TREE_TYPE (type1);
1658 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1660 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1661 && (TYPE_PTRMEMFUNC_P (type2)
1662 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1667 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1668 didate operator functions of the form
1673 bool operator<(L, R);
1674 bool operator>(L, R);
1675 bool operator<=(L, R);
1676 bool operator>=(L, R);
1677 bool operator==(L, R);
1678 bool operator!=(L, R);
1679 where LR is the result of the usual arithmetic conversions between
1682 14For every pair of types T and I, where T is a cv-qualified or cv-
1683 unqualified complete object type and I is a promoted integral type,
1684 there exist candidate operator functions of the form
1685 T* operator+(T*, I);
1686 T& operator[](T*, I);
1687 T* operator-(T*, I);
1688 T* operator+(I, T*);
1689 T& operator[](I, T*);
1691 15For every T, where T is a pointer to complete object type, there exist
1692 candidate operator functions of the form112)
1693 ptrdiff_t operator-(T, T);
1695 16For every pointer or enumeration type T, there exist candidate operator
1696 functions of the form
1697 bool operator<(T, T);
1698 bool operator>(T, T);
1699 bool operator<=(T, T);
1700 bool operator>=(T, T);
1701 bool operator==(T, T);
1702 bool operator!=(T, T);
1704 17For every pointer to member type T, there exist candidate operator
1705 functions of the form
1706 bool operator==(T, T);
1707 bool operator!=(T, T); */
1710 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1712 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1714 type2 = ptrdiff_type_node;
1718 case TRUNC_DIV_EXPR:
1719 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1725 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1726 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1728 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1733 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1745 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1747 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1749 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1751 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1756 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1764 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1767 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1769 type1 = ptrdiff_type_node;
1772 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1774 type2 = ptrdiff_type_node;
1779 /* 18For every pair of promoted integral types L and R, there exist candi-
1780 date operator functions of the form
1787 where LR is the result of the usual arithmetic conversions between
1790 case TRUNC_MOD_EXPR:
1796 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1800 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1801 type, VQ is either volatile or empty, and R is a promoted arithmetic
1802 type, there exist candidate operator functions of the form
1803 VQ L& operator=(VQ L&, R);
1804 VQ L& operator*=(VQ L&, R);
1805 VQ L& operator/=(VQ L&, R);
1806 VQ L& operator+=(VQ L&, R);
1807 VQ L& operator-=(VQ L&, R);
1809 20For every pair T, VQ), where T is any type and VQ is either volatile
1810 or empty, there exist candidate operator functions of the form
1811 T*VQ& operator=(T*VQ&, T*);
1813 21For every pair T, VQ), where T is a pointer to member type and VQ is
1814 either volatile or empty, there exist candidate operator functions of
1816 VQ T& operator=(VQ T&, T);
1818 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1819 unqualified complete object type, VQ is either volatile or empty, and
1820 I is a promoted integral type, there exist candidate operator func-
1822 T*VQ& operator+=(T*VQ&, I);
1823 T*VQ& operator-=(T*VQ&, I);
1825 23For every triple L, VQ, R), where L is an integral or enumeration
1826 type, VQ is either volatile or empty, and R is a promoted integral
1827 type, there exist candidate operator functions of the form
1829 VQ L& operator%=(VQ L&, R);
1830 VQ L& operator<<=(VQ L&, R);
1831 VQ L& operator>>=(VQ L&, R);
1832 VQ L& operator&=(VQ L&, R);
1833 VQ L& operator^=(VQ L&, R);
1834 VQ L& operator|=(VQ L&, R); */
1841 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1843 type2 = ptrdiff_type_node;
1847 case TRUNC_DIV_EXPR:
1848 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1852 case TRUNC_MOD_EXPR:
1858 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1863 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1865 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1866 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1867 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1868 || ((TYPE_PTRMEMFUNC_P (type1)
1869 || TREE_CODE (type1) == POINTER_TYPE)
1870 && null_ptr_cst_p (args[1])))
1880 type1 = build_reference_type (type1);
1886 For every pair of promoted arithmetic types L and R, there
1887 exist candidate operator functions of the form
1889 LR operator?(bool, L, R);
1891 where LR is the result of the usual arithmetic conversions
1892 between types L and R.
1894 For every type T, where T is a pointer or pointer-to-member
1895 type, there exist candidate operator functions of the form T
1896 operator?(bool, T, T); */
1898 if (promoted_arithmetic_type_p (type1)
1899 && promoted_arithmetic_type_p (type2))
1903 /* Otherwise, the types should be pointers. */
1904 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1905 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1908 /* We don't check that the two types are the same; the logic
1909 below will actually create two candidates; one in which both
1910 parameter types are TYPE1, and one in which both parameter
1918 /* If we're dealing with two pointer types or two enumeral types,
1919 we need candidates for both of them. */
1920 if (type2 && !same_type_p (type1, type2)
1921 && TREE_CODE (type1) == TREE_CODE (type2)
1922 && (TREE_CODE (type1) == REFERENCE_TYPE
1923 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1924 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1925 || TYPE_PTRMEMFUNC_P (type1)
1926 || IS_AGGR_TYPE (type1)
1927 || TREE_CODE (type1) == ENUMERAL_TYPE))
1929 build_builtin_candidate
1930 (candidates, fnname, type1, type1, args, argtypes, flags);
1931 build_builtin_candidate
1932 (candidates, fnname, type2, type2, args, argtypes, flags);
1936 build_builtin_candidate
1937 (candidates, fnname, type1, type2, args, argtypes, flags);
1941 type_decays_to (tree type)
1943 if (TREE_CODE (type) == ARRAY_TYPE)
1944 return build_pointer_type (TREE_TYPE (type));
1945 if (TREE_CODE (type) == FUNCTION_TYPE)
1946 return build_pointer_type (type);
1950 /* There are three conditions of builtin candidates:
1952 1) bool-taking candidates. These are the same regardless of the input.
1953 2) pointer-pair taking candidates. These are generated for each type
1954 one of the input types converts to.
1955 3) arithmetic candidates. According to the standard, we should generate
1956 all of these, but I'm trying not to...
1958 Here we generate a superset of the possible candidates for this particular
1959 case. That is a subset of the full set the standard defines, plus some
1960 other cases which the standard disallows. add_builtin_candidate will
1961 filter out the invalid set. */
1964 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
1965 enum tree_code code2, tree fnname, tree *args,
1970 tree type, argtypes[3];
1971 /* TYPES[i] is the set of possible builtin-operator parameter types
1972 we will consider for the Ith argument. These are represented as
1973 a TREE_LIST; the TREE_VALUE of each node is the potential
1977 for (i = 0; i < 3; ++i)
1980 argtypes[i] = lvalue_type (args[i]);
1982 argtypes[i] = NULL_TREE;
1987 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1988 and VQ is either volatile or empty, there exist candidate operator
1989 functions of the form
1990 VQ T& operator++(VQ T&); */
1992 case POSTINCREMENT_EXPR:
1993 case PREINCREMENT_EXPR:
1994 case POSTDECREMENT_EXPR:
1995 case PREDECREMENT_EXPR:
2000 /* 24There also exist candidate operator functions of the form
2001 bool operator!(bool);
2002 bool operator&&(bool, bool);
2003 bool operator||(bool, bool); */
2005 case TRUTH_NOT_EXPR:
2006 build_builtin_candidate
2007 (candidates, fnname, boolean_type_node,
2008 NULL_TREE, args, argtypes, flags);
2011 case TRUTH_ORIF_EXPR:
2012 case TRUTH_ANDIF_EXPR:
2013 build_builtin_candidate
2014 (candidates, fnname, boolean_type_node,
2015 boolean_type_node, args, argtypes, flags);
2037 types[0] = types[1] = NULL_TREE;
2039 for (i = 0; i < 2; ++i)
2043 else if (IS_AGGR_TYPE (argtypes[i]))
2047 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2050 convs = lookup_conversions (argtypes[i]);
2052 if (code == COND_EXPR)
2054 if (real_lvalue_p (args[i]))
2055 types[i] = tree_cons
2056 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2058 types[i] = tree_cons
2059 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2065 for (; convs; convs = TREE_CHAIN (convs))
2067 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2070 && (TREE_CODE (type) != REFERENCE_TYPE
2071 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2074 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2075 types[i] = tree_cons (NULL_TREE, type, types[i]);
2077 type = non_reference (type);
2078 if (i != 0 || ! ref1)
2080 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2081 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2082 types[i] = tree_cons (NULL_TREE, type, types[i]);
2083 if (INTEGRAL_TYPE_P (type))
2084 type = type_promotes_to (type);
2087 if (! value_member (type, types[i]))
2088 types[i] = tree_cons (NULL_TREE, type, types[i]);
2093 if (code == COND_EXPR && real_lvalue_p (args[i]))
2094 types[i] = tree_cons
2095 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2096 type = non_reference (argtypes[i]);
2097 if (i != 0 || ! ref1)
2099 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2100 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2101 types[i] = tree_cons (NULL_TREE, type, types[i]);
2102 if (INTEGRAL_TYPE_P (type))
2103 type = type_promotes_to (type);
2105 types[i] = tree_cons (NULL_TREE, type, types[i]);
2109 /* Run through the possible parameter types of both arguments,
2110 creating candidates with those parameter types. */
2111 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2114 for (type = types[1]; type; type = TREE_CHAIN (type))
2115 add_builtin_candidate
2116 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2117 TREE_VALUE (type), args, argtypes, flags);
2119 add_builtin_candidate
2120 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2121 NULL_TREE, args, argtypes, flags);
2128 /* If TMPL can be successfully instantiated as indicated by
2129 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2131 TMPL is the template. EXPLICIT_TARGS are any explicit template
2132 arguments. ARGLIST is the arguments provided at the call-site.
2133 The RETURN_TYPE is the desired type for conversion operators. If
2134 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2135 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2136 add_conv_candidate. */
2138 static struct z_candidate*
2139 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2140 tree ctype, tree explicit_targs, tree arglist,
2141 tree return_type, tree access_path,
2142 tree conversion_path, int flags, tree obj,
2143 unification_kind_t strict)
2145 int ntparms = DECL_NTPARMS (tmpl);
2146 tree targs = make_tree_vec (ntparms);
2147 tree args_without_in_chrg = arglist;
2148 struct z_candidate *cand;
2152 /* We don't do deduction on the in-charge parameter, the VTT
2153 parameter or 'this'. */
2154 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2155 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2157 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2158 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2159 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
2160 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2162 i = fn_type_unification (tmpl, explicit_targs, targs,
2163 args_without_in_chrg,
2164 return_type, strict, -1);
2169 fn = instantiate_template (tmpl, targs, tf_none);
2170 if (fn == error_mark_node)
2175 A member function template is never instantiated to perform the
2176 copy of a class object to an object of its class type.
2178 It's a little unclear what this means; the standard explicitly
2179 does allow a template to be used to copy a class. For example,
2184 template <class T> A(const T&);
2187 void g () { A a (f ()); }
2189 the member template will be used to make the copy. The section
2190 quoted above appears in the paragraph that forbids constructors
2191 whose only parameter is (a possibly cv-qualified variant of) the
2192 class type, and a logical interpretation is that the intent was
2193 to forbid the instantiation of member templates which would then
2195 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2197 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2198 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2203 if (obj != NULL_TREE)
2204 /* Aha, this is a conversion function. */
2205 cand = add_conv_candidate (candidates, fn, obj, access_path,
2206 conversion_path, arglist);
2208 cand = add_function_candidate (candidates, fn, ctype,
2209 arglist, access_path,
2210 conversion_path, flags);
2211 if (DECL_TI_TEMPLATE (fn) != tmpl)
2212 /* This situation can occur if a member template of a template
2213 class is specialized. Then, instantiate_template might return
2214 an instantiation of the specialization, in which case the
2215 DECL_TI_TEMPLATE field will point at the original
2216 specialization. For example:
2218 template <class T> struct S { template <class U> void f(U);
2219 template <> void f(int) {}; };
2223 Here, TMPL will be template <class U> S<double>::f(U).
2224 And, instantiate template will give us the specialization
2225 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2226 for this will point at template <class T> template <> S<T>::f(int),
2227 so that we can find the definition. For the purposes of
2228 overload resolution, however, we want the original TMPL. */
2229 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2231 cand->template = DECL_TEMPLATE_INFO (fn);
2237 static struct z_candidate *
2238 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2239 tree explicit_targs, tree arglist, tree return_type,
2240 tree access_path, tree conversion_path, int flags,
2241 unification_kind_t strict)
2244 add_template_candidate_real (candidates, tmpl, ctype,
2245 explicit_targs, arglist, return_type,
2246 access_path, conversion_path,
2247 flags, NULL_TREE, strict);
2251 static struct z_candidate *
2252 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2253 tree obj, tree arglist, tree return_type,
2254 tree access_path, tree conversion_path)
2257 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2258 arglist, return_type, access_path,
2259 conversion_path, 0, obj, DEDUCE_CONV);
2262 /* The CANDS are the set of candidates that were considered for
2263 overload resolution. Return the set of viable candidates. If none
2264 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2265 is true if a candidate should be considered viable only if it is
2268 static struct z_candidate*
2269 splice_viable (struct z_candidate *cands,
2273 struct z_candidate *viable;
2274 struct z_candidate **last_viable;
2275 struct z_candidate **cand;
2278 last_viable = &viable;
2279 *any_viable_p = false;
2284 struct z_candidate *c = *cand;
2285 if (strict_p ? c->viable == 1 : c->viable)
2290 last_viable = &c->next;
2291 *any_viable_p = true;
2297 return viable ? viable : cands;
2301 any_strictly_viable (struct z_candidate *cands)
2303 for (; cands; cands = cands->next)
2304 if (cands->viable == 1)
2310 build_this (tree obj)
2312 /* Fix this to work on non-lvalues. */
2313 return build_unary_op (ADDR_EXPR, obj, 0);
2316 /* Returns true iff functions are equivalent. Equivalent functions are
2317 not '==' only if one is a function-local extern function or if
2318 both are extern "C". */
2321 equal_functions (tree fn1, tree fn2)
2323 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2324 || DECL_EXTERN_C_FUNCTION_P (fn1))
2325 return decls_match (fn1, fn2);
2329 /* Print information about one overload candidate CANDIDATE. MSGSTR
2330 is the text to print before the candidate itself.
2332 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2333 to have been run through gettext by the caller. This wart makes
2334 life simpler in print_z_candidates and for the translators. */
2337 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2339 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2341 if (TREE_VEC_LENGTH (candidate->convs) == 3)
2342 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2343 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2344 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)),
2345 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 2)));
2346 else if (TREE_VEC_LENGTH (candidate->convs) == 2)
2347 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2348 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2349 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)));
2351 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2352 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)));
2354 else if (TYPE_P (candidate->fn))
2355 inform ("%s %T <conversion>", msgstr, candidate->fn);
2356 else if (candidate->viable == -1)
2357 inform ("%H%s %+#D <near match>",
2358 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
2360 inform ("%H%s %+#D",
2361 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
2365 print_z_candidates (struct z_candidate *candidates)
2368 struct z_candidate *cand1;
2369 struct z_candidate **cand2;
2371 /* There may be duplicates in the set of candidates. We put off
2372 checking this condition as long as possible, since we have no way
2373 to eliminate duplicates from a set of functions in less than n^2
2374 time. Now we are about to emit an error message, so it is more
2375 permissible to go slowly. */
2376 for (cand1 = candidates; cand1; cand1 = cand1->next)
2378 tree fn = cand1->fn;
2379 /* Skip builtin candidates and conversion functions. */
2380 if (TREE_CODE (fn) != FUNCTION_DECL)
2382 cand2 = &cand1->next;
2385 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2386 && equal_functions (fn, (*cand2)->fn))
2387 *cand2 = (*cand2)->next;
2389 cand2 = &(*cand2)->next;
2396 str = _("candidates are:");
2397 print_z_candidate (str, candidates);
2398 if (candidates->next)
2400 /* Indent successive candidates by the width of the translation
2401 of the above string. */
2402 size_t len = gcc_gettext_width (str) + 1;
2403 char *spaces = alloca (len);
2404 memset (spaces, ' ', len-1);
2405 spaces[len - 1] = '\0';
2407 candidates = candidates->next;
2410 print_z_candidate (spaces, candidates);
2411 candidates = candidates->next;
2417 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2418 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2419 the result of the conversion function to convert it to the final
2420 desired type. Merge the the two sequences into a single sequence,
2421 and return the merged sequence. */
2424 merge_conversion_sequences (tree user_seq, tree std_seq)
2428 my_friendly_assert (TREE_CODE (user_seq) == USER_CONV,
2431 /* Find the end of the second conversion sequence. */
2433 while (TREE_CODE (*t) != IDENTITY_CONV)
2434 t = &TREE_OPERAND (*t, 0);
2436 /* Replace the identity conversion with the user conversion
2440 /* The entire sequence is a user-conversion sequence. */
2441 ICS_USER_FLAG (std_seq) = 1;
2446 /* Returns the best overload candidate to perform the requested
2447 conversion. This function is used for three the overloading situations
2448 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2449 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2450 per [dcl.init.ref], so we ignore temporary bindings. */
2452 static struct z_candidate *
2453 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2455 struct z_candidate *candidates, *cand;
2456 tree fromtype = TREE_TYPE (expr);
2457 tree ctors = NULL_TREE, convs = NULL_TREE;
2458 tree args = NULL_TREE;
2461 /* We represent conversion within a hierarchy using RVALUE_CONV and
2462 BASE_CONV, as specified by [over.best.ics]; these become plain
2463 constructor calls, as specified in [dcl.init]. */
2464 my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2465 || !DERIVED_FROM_P (totype, fromtype), 20011226);
2467 if (IS_AGGR_TYPE (totype))
2468 ctors = lookup_fnfields (TYPE_BINFO (totype),
2469 complete_ctor_identifier,
2472 if (IS_AGGR_TYPE (fromtype))
2473 convs = lookup_conversions (fromtype);
2476 flags |= LOOKUP_NO_CONVERSION;
2482 ctors = BASELINK_FUNCTIONS (ctors);
2484 t = build_int_2 (0, 0);
2485 TREE_TYPE (t) = build_pointer_type (totype);
2486 args = build_tree_list (NULL_TREE, expr);
2487 /* We should never try to call the abstract or base constructor
2489 my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2490 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),
2492 args = tree_cons (NULL_TREE, t, args);
2494 for (; ctors; ctors = OVL_NEXT (ctors))
2496 tree ctor = OVL_CURRENT (ctors);
2497 if (DECL_NONCONVERTING_P (ctor))
2500 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2501 cand = add_template_candidate (&candidates, ctor, totype,
2502 NULL_TREE, args, NULL_TREE,
2503 TYPE_BINFO (totype),
2504 TYPE_BINFO (totype),
2508 cand = add_function_candidate (&candidates, ctor, totype,
2509 args, TYPE_BINFO (totype),
2510 TYPE_BINFO (totype),
2514 cand->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE);
2518 args = build_tree_list (NULL_TREE, build_this (expr));
2520 for (; convs; convs = TREE_CHAIN (convs))
2523 tree conversion_path = TREE_PURPOSE (convs);
2524 int convflags = LOOKUP_NO_CONVERSION;
2526 /* If we are called to convert to a reference type, we are trying to
2527 find an lvalue binding, so don't even consider temporaries. If
2528 we don't find an lvalue binding, the caller will try again to
2529 look for a temporary binding. */
2530 if (TREE_CODE (totype) == REFERENCE_TYPE)
2531 convflags |= LOOKUP_NO_TEMP_BIND;
2533 for (fns = TREE_VALUE (convs); fns; fns = OVL_NEXT (fns))
2535 tree fn = OVL_CURRENT (fns);
2537 /* [over.match.funcs] For conversion functions, the function
2538 is considered to be a member of the class of the implicit
2539 object argument for the purpose of defining the type of
2540 the implicit object parameter.
2542 So we pass fromtype as CTYPE to add_*_candidate. */
2544 if (TREE_CODE (fn) == TEMPLATE_DECL)
2545 cand = add_template_candidate (&candidates, fn, fromtype,
2548 TYPE_BINFO (fromtype),
2553 cand = add_function_candidate (&candidates, fn, fromtype,
2555 TYPE_BINFO (fromtype),
2561 tree ics = implicit_conversion (totype,
2562 TREE_TYPE (TREE_TYPE (cand->fn)),
2565 cand->second_conv = ics;
2567 if (ics == NULL_TREE)
2569 else if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
2575 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2579 cand = tourney (candidates);
2582 if (flags & LOOKUP_COMPLAIN)
2584 error ("conversion from `%T' to `%T' is ambiguous",
2586 print_z_candidates (candidates);
2589 cand = candidates; /* any one will do */
2590 cand->second_conv = build1 (AMBIG_CONV, totype, expr);
2591 ICS_USER_FLAG (cand->second_conv) = 1;
2592 if (!any_strictly_viable (candidates))
2593 ICS_BAD_FLAG (cand->second_conv) = 1;
2594 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2595 ambiguous conversion is no worse than another user-defined
2601 /* Build the user conversion sequence. */
2604 (DECL_CONSTRUCTOR_P (cand->fn)
2605 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2606 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
2607 TREE_OPERAND (convs, 1) = build_zc_wrapper (cand);
2609 /* Combine it with the second conversion sequence. */
2610 cand->second_conv = merge_conversion_sequences (convs,
2613 if (cand->viable == -1)
2614 ICS_BAD_FLAG (cand->second_conv) = 1;
2620 build_user_type_conversion (tree totype, tree expr, int flags)
2622 struct z_candidate *cand
2623 = build_user_type_conversion_1 (totype, expr, flags);
2627 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
2628 return error_mark_node;
2629 return convert_from_reference (convert_like (cand->second_conv, expr));
2634 /* Do any initial processing on the arguments to a function call. */
2637 resolve_args (tree args)
2640 for (t = args; t; t = TREE_CHAIN (t))
2642 tree arg = TREE_VALUE (t);
2644 if (arg == error_mark_node)
2645 return error_mark_node;
2646 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2648 error ("invalid use of void expression");
2649 return error_mark_node;
2651 arg = convert_from_reference (arg);
2652 TREE_VALUE (t) = arg;
2657 /* Perform overload resolution on FN, which is called with the ARGS.
2659 Return the candidate function selected by overload resolution, or
2660 NULL if the event that overload resolution failed. In the case
2661 that overload resolution fails, *CANDIDATES will be the set of
2662 candidates considered, and ANY_VIABLE_P will be set to true or
2663 false to indicate whether or not any of the candidates were
2666 The ARGS should already have gone through RESOLVE_ARGS before this
2667 function is called. */
2669 static struct z_candidate *
2670 perform_overload_resolution (tree fn,
2672 struct z_candidate **candidates,
2675 struct z_candidate *cand;
2676 tree explicit_targs = NULL_TREE;
2677 int template_only = 0;
2680 *any_viable_p = true;
2682 /* Check FN and ARGS. */
2683 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
2684 || TREE_CODE (fn) == TEMPLATE_DECL
2685 || TREE_CODE (fn) == OVERLOAD
2686 || TREE_CODE (fn) == TEMPLATE_ID_EXPR,
2688 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
2691 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2693 explicit_targs = TREE_OPERAND (fn, 1);
2694 fn = TREE_OPERAND (fn, 0);
2698 /* Add the various candidate functions. */
2699 add_candidates (fn, args, explicit_targs, template_only,
2700 /*conversion_path=*/NULL_TREE,
2701 /*access_path=*/NULL_TREE,
2705 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2709 cand = tourney (*candidates);
2713 /* Return an expression for a call to FN (a namespace-scope function,
2714 or a static member function) with the ARGS. */
2717 build_new_function_call (tree fn, tree args)
2719 struct z_candidate *candidates, *cand;
2722 args = resolve_args (args);
2723 if (args == error_mark_node)
2724 return error_mark_node;
2726 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2730 if (!any_viable_p && candidates && ! candidates->next)
2731 return build_function_call (candidates->fn, args);
2732 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2733 fn = TREE_OPERAND (fn, 0);
2735 error ("no matching function for call to `%D(%A)'",
2736 DECL_NAME (OVL_CURRENT (fn)), args);
2738 error ("call of overloaded `%D(%A)' is ambiguous",
2739 DECL_NAME (OVL_CURRENT (fn)), args);
2741 print_z_candidates (candidates);
2742 return error_mark_node;
2745 return build_over_call (cand, LOOKUP_NORMAL);
2748 /* Build a call to a global operator new. FNNAME is the name of the
2749 operator (either "operator new" or "operator new[]") and ARGS are
2750 the arguments provided. *SIZE points to the total number of bytes
2751 required by the allocation, and is updated if that is changed here.
2752 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2753 function determines that no cookie should be used, after all,
2754 *COOKIE_SIZE is set to NULL_TREE. */
2757 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2760 struct z_candidate *candidates;
2761 struct z_candidate *cand;
2764 args = tree_cons (NULL_TREE, *size, args);
2765 args = resolve_args (args);
2766 if (args == error_mark_node)
2769 fns = lookup_function_nonclass (fnname, args);
2771 /* Figure out what function is being called. */
2772 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2774 /* If no suitable function could be found, issue an error message
2779 error ("no matching function for call to `%D(%A)'",
2780 DECL_NAME (OVL_CURRENT (fns)), args);
2782 error ("call of overloaded `%D(%A)' is ambiguous",
2783 DECL_NAME (OVL_CURRENT (fns)), args);
2785 print_z_candidates (candidates);
2786 return error_mark_node;
2789 /* If a cookie is required, add some extra space. Whether
2790 or not a cookie is required cannot be determined until
2791 after we know which function was called. */
2794 bool use_cookie = true;
2795 if (!abi_version_at_least (2))
2797 tree placement = TREE_CHAIN (args);
2798 /* In G++ 3.2, the check was implemented incorrectly; it
2799 looked at the placement expression, rather than the
2800 type of the function. */
2801 if (placement && !TREE_CHAIN (placement)
2802 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2810 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2811 /* Skip the size_t parameter. */
2812 arg_types = TREE_CHAIN (arg_types);
2813 /* Check the remaining parameters (if any). */
2815 && TREE_CHAIN (arg_types) == void_list_node
2816 && same_type_p (TREE_VALUE (arg_types),
2820 /* If we need a cookie, adjust the number of bytes allocated. */
2823 /* Update the total size. */
2824 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2825 /* Update the argument list to reflect the adjusted size. */
2826 TREE_VALUE (args) = *size;
2829 *cookie_size = NULL_TREE;
2832 /* Build the CALL_EXPR. */
2833 return build_over_call (cand, LOOKUP_NORMAL);
2837 build_object_call (tree obj, tree args)
2839 struct z_candidate *candidates = 0, *cand;
2840 tree fns, convs, mem_args = NULL_TREE;
2841 tree type = TREE_TYPE (obj);
2844 if (TYPE_PTRMEMFUNC_P (type))
2846 /* It's no good looking for an overloaded operator() on a
2847 pointer-to-member-function. */
2848 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2849 return error_mark_node;
2852 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2853 if (fns == error_mark_node)
2854 return error_mark_node;
2856 args = resolve_args (args);
2858 if (args == error_mark_node)
2859 return error_mark_node;
2863 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2864 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2866 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2868 tree fn = OVL_CURRENT (fns);
2869 if (TREE_CODE (fn) == TEMPLATE_DECL)
2870 add_template_candidate (&candidates, fn, base, NULL_TREE,
2871 mem_args, NULL_TREE,
2874 LOOKUP_NORMAL, DEDUCE_CALL);
2876 add_function_candidate
2877 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2878 TYPE_BINFO (type), LOOKUP_NORMAL);
2882 convs = lookup_conversions (type);
2884 for (; convs; convs = TREE_CHAIN (convs))
2886 tree fns = TREE_VALUE (convs);
2887 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2889 if ((TREE_CODE (totype) == POINTER_TYPE
2890 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2891 || (TREE_CODE (totype) == REFERENCE_TYPE
2892 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2893 || (TREE_CODE (totype) == REFERENCE_TYPE
2894 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2895 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
2896 for (; fns; fns = OVL_NEXT (fns))
2898 tree fn = OVL_CURRENT (fns);
2899 if (TREE_CODE (fn) == TEMPLATE_DECL)
2900 add_template_conv_candidate
2901 (&candidates, fn, obj, args, totype,
2902 /*access_path=*/NULL_TREE,
2903 /*conversion_path=*/NULL_TREE);
2905 add_conv_candidate (&candidates, fn, obj, args,
2906 /*conversion_path=*/NULL_TREE,
2907 /*access_path=*/NULL_TREE);
2911 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2914 error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
2915 print_z_candidates (candidates);
2916 return error_mark_node;
2919 cand = tourney (candidates);
2922 error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
2923 print_z_candidates (candidates);
2924 return error_mark_node;
2927 /* Since cand->fn will be a type, not a function, for a conversion
2928 function, we must be careful not to unconditionally look at
2930 if (TREE_CODE (cand->fn) == FUNCTION_DECL
2931 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
2932 return build_over_call (cand, LOOKUP_NORMAL);
2934 obj = convert_like_with_context
2935 (TREE_VEC_ELT (cand->convs, 0), obj, cand->fn, -1);
2938 return build_function_call (obj, args);
2942 op_error (enum tree_code code, enum tree_code code2,
2943 tree arg1, tree arg2, tree arg3, const char *problem)
2947 if (code == MODIFY_EXPR)
2948 opname = assignment_operator_name_info[code2].name;
2950 opname = operator_name_info[code].name;
2955 error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
2956 problem, arg1, arg2, arg3);
2959 case POSTINCREMENT_EXPR:
2960 case POSTDECREMENT_EXPR:
2961 error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname);
2965 error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2);
2970 error ("%s for '%s' in '%s %E'", problem, opname, opname, arg1);
2975 error ("%s for 'operator%s' in '%E %s %E'",
2976 problem, opname, arg1, opname, arg2);
2978 error ("%s for 'operator%s' in '%s%E'",
2979 problem, opname, opname, arg1);
2984 /* Return the implicit conversion sequence that could be used to
2985 convert E1 to E2 in [expr.cond]. */
2988 conditional_conversion (tree e1, tree e2)
2990 tree t1 = non_reference (TREE_TYPE (e1));
2991 tree t2 = non_reference (TREE_TYPE (e2));
2997 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
2998 implicitly converted (clause _conv_) to the type "reference to
2999 T2", subject to the constraint that in the conversion the
3000 reference must bind directly (_dcl.init.ref_) to E1. */
3001 if (real_lvalue_p (e2))
3003 conv = implicit_conversion (build_reference_type (t2),
3006 LOOKUP_NO_TEMP_BIND);
3013 If E1 and E2 have class type, and the underlying class types are
3014 the same or one is a base class of the other: E1 can be converted
3015 to match E2 if the class of T2 is the same type as, or a base
3016 class of, the class of T1, and the cv-qualification of T2 is the
3017 same cv-qualification as, or a greater cv-qualification than, the
3018 cv-qualification of T1. If the conversion is applied, E1 is
3019 changed to an rvalue of type T2 that still refers to the original
3020 source class object (or the appropriate subobject thereof).
3022 FIXME we can't express an rvalue that refers to the original object;
3023 we have to create a new one. */
3024 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3025 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3027 if (good_base && at_least_as_qualified_p (t2, t1))
3029 conv = build1 (IDENTITY_CONV, t1, e1);
3030 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3031 TYPE_MAIN_VARIANT (t2)))
3033 conv = build_conv (BASE_CONV, t2, conv);
3034 NEED_TEMPORARY_P (conv) = 1;
3037 conv = build_conv (RVALUE_CONV, t2, conv);
3046 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3047 converted to the type that expression E2 would have if E2 were
3048 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3049 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3052 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3053 arguments to the conditional expression. */
3056 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3061 tree result_type = NULL_TREE;
3062 bool lvalue_p = true;
3063 struct z_candidate *candidates = 0;
3064 struct z_candidate *cand;
3066 /* As a G++ extension, the second argument to the conditional can be
3067 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3068 c'.) If the second operand is omitted, make sure it is
3069 calculated only once. */
3073 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3075 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3076 if (real_lvalue_p (arg1))
3077 arg2 = arg1 = stabilize_reference (arg1);
3079 arg2 = arg1 = save_expr (arg1);
3084 The first expr ession is implicitly converted to bool (clause
3086 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3088 /* If something has already gone wrong, just pass that fact up the
3090 if (error_operand_p (arg1)
3091 || error_operand_p (arg2)
3092 || error_operand_p (arg3))
3093 return error_mark_node;
3097 If either the second or the third operand has type (possibly
3098 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3099 array-to-pointer (_conv.array_), and function-to-pointer
3100 (_conv.func_) standard conversions are performed on the second
3101 and third operands. */
3102 arg2_type = TREE_TYPE (arg2);
3103 arg3_type = TREE_TYPE (arg3);
3104 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3106 /* Do the conversions. We don't these for `void' type arguments
3107 since it can't have any effect and since decay_conversion
3108 does not handle that case gracefully. */
3109 if (!VOID_TYPE_P (arg2_type))
3110 arg2 = decay_conversion (arg2);
3111 if (!VOID_TYPE_P (arg3_type))
3112 arg3 = decay_conversion (arg3);
3113 arg2_type = TREE_TYPE (arg2);
3114 arg3_type = TREE_TYPE (arg3);
3118 One of the following shall hold:
3120 --The second or the third operand (but not both) is a
3121 throw-expression (_except.throw_); the result is of the
3122 type of the other and is an rvalue.
3124 --Both the second and the third operands have type void; the
3125 result is of type void and is an rvalue. */
3126 if ((TREE_CODE (arg2) == THROW_EXPR)
3127 ^ (TREE_CODE (arg3) == THROW_EXPR))
3128 result_type = ((TREE_CODE (arg2) == THROW_EXPR)
3129 ? arg3_type : arg2_type);
3130 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3131 result_type = void_type_node;
3134 error ("`%E' has type `void' and is not a throw-expression",
3135 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3136 return error_mark_node;
3140 goto valid_operands;
3144 Otherwise, if the second and third operand have different types,
3145 and either has (possibly cv-qualified) class type, an attempt is
3146 made to convert each of those operands to the type of the other. */
3147 else if (!same_type_p (arg2_type, arg3_type)
3148 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3150 tree conv2 = conditional_conversion (arg2, arg3);
3151 tree conv3 = conditional_conversion (arg3, arg2);
3155 If both can be converted, or one can be converted but the
3156 conversion is ambiguous, the program is ill-formed. If
3157 neither can be converted, the operands are left unchanged and
3158 further checking is performed as described below. If exactly
3159 one conversion is possible, that conversion is applied to the
3160 chosen operand and the converted operand is used in place of
3161 the original operand for the remainder of this section. */
3162 if ((conv2 && !ICS_BAD_FLAG (conv2)
3163 && conv3 && !ICS_BAD_FLAG (conv3))
3164 || (conv2 && TREE_CODE (conv2) == AMBIG_CONV)
3165 || (conv3 && TREE_CODE (conv3) == AMBIG_CONV))
3167 error ("operands to ?: have different types");
3168 return error_mark_node;
3170 else if (conv2 && !ICS_BAD_FLAG (conv2))
3172 arg2 = convert_like (conv2, arg2);
3173 arg2 = convert_from_reference (arg2);
3174 if (!same_type_p (TREE_TYPE (arg2), arg3_type))
3176 arg2_type = TREE_TYPE (arg2);
3178 else if (conv3 && !ICS_BAD_FLAG (conv3))
3180 arg3 = convert_like (conv3, arg3);
3181 arg3 = convert_from_reference (arg3);
3182 if (!same_type_p (TREE_TYPE (arg3), arg2_type))
3184 arg3_type = TREE_TYPE (arg3);
3190 If the second and third operands are lvalues and have the same
3191 type, the result is of that type and is an lvalue. */
3192 if (real_lvalue_p (arg2) && real_lvalue_p (arg3) &&
3193 same_type_p (arg2_type, arg3_type))
3195 result_type = arg2_type;
3196 goto valid_operands;
3201 Otherwise, the result is an rvalue. If the second and third
3202 operand do not have the same type, and either has (possibly
3203 cv-qualified) class type, overload resolution is used to
3204 determine the conversions (if any) to be applied to the operands
3205 (_over.match.oper_, _over.built_). */
3207 if (!same_type_p (arg2_type, arg3_type)
3208 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3214 /* Rearrange the arguments so that add_builtin_candidate only has
3215 to know about two args. In build_builtin_candidates, the
3216 arguments are unscrambled. */
3220 add_builtin_candidates (&candidates,
3223 ansi_opname (COND_EXPR),
3229 If the overload resolution fails, the program is
3231 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3234 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3235 print_z_candidates (candidates);
3236 return error_mark_node;
3238 cand = tourney (candidates);
3241 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3242 print_z_candidates (candidates);
3243 return error_mark_node;
3248 Otherwise, the conversions thus determined are applied, and
3249 the converted operands are used in place of the original
3250 operands for the remainder of this section. */
3251 conv = TREE_VEC_ELT (cand->convs, 0);
3252 arg1 = convert_like (conv, arg1);
3253 conv = TREE_VEC_ELT (cand->convs, 1);
3254 arg2 = convert_like (conv, arg2);
3255 conv = TREE_VEC_ELT (cand->convs, 2);
3256 arg3 = convert_like (conv, arg3);
3261 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3262 and function-to-pointer (_conv.func_) standard conversions are
3263 performed on the second and third operands.
3265 We need to force the lvalue-to-rvalue conversion here for class types,
3266 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3267 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3270 We use ocp_convert rather than build_user_type_conversion because the
3271 latter returns NULL_TREE on failure, while the former gives an error. */
3273 arg2 = force_rvalue (arg2);
3274 arg2_type = TREE_TYPE (arg2);
3276 arg3 = force_rvalue (arg3);
3277 arg3_type = TREE_TYPE (arg3);
3279 if (arg2 == error_mark_node || arg3 == error_mark_node)
3280 return error_mark_node;
3284 After those conversions, one of the following shall hold:
3286 --The second and third operands have the same type; the result is of
3288 if (same_type_p (arg2_type, arg3_type))
3289 result_type = arg2_type;
3292 --The second and third operands have arithmetic or enumeration
3293 type; the usual arithmetic conversions are performed to bring
3294 them to a common type, and the result is of that type. */
3295 else if ((ARITHMETIC_TYPE_P (arg2_type)
3296 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3297 && (ARITHMETIC_TYPE_P (arg3_type)
3298 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3300 /* In this case, there is always a common type. */
3301 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3304 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3305 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3306 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3307 arg2_type, arg3_type);
3308 else if (extra_warnings
3309 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3310 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3311 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3312 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3313 warning ("enumeral and non-enumeral type in conditional expression");
3315 arg2 = perform_implicit_conversion (result_type, arg2);
3316 arg3 = perform_implicit_conversion (result_type, arg3);
3320 --The second and third operands have pointer type, or one has
3321 pointer type and the other is a null pointer constant; pointer
3322 conversions (_conv.ptr_) and qualification conversions
3323 (_conv.qual_) are performed to bring them to their composite
3324 pointer type (_expr.rel_). The result is of the composite
3327 --The second and third operands have pointer to member type, or
3328 one has pointer to member type and the other is a null pointer
3329 constant; pointer to member conversions (_conv.mem_) and
3330 qualification conversions (_conv.qual_) are performed to bring
3331 them to a common type, whose cv-qualification shall match the
3332 cv-qualification of either the second or the third operand.
3333 The result is of the common type. */
3334 else if ((null_ptr_cst_p (arg2)
3335 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3336 || (null_ptr_cst_p (arg3)
3337 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3338 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3339 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3340 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3342 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3343 arg3, "conditional expression");
3344 if (result_type == error_mark_node)
3345 return error_mark_node;
3346 arg2 = perform_implicit_conversion (result_type, arg2);
3347 arg3 = perform_implicit_conversion (result_type, arg3);
3352 error ("operands to ?: have different types");
3353 return error_mark_node;
3357 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3358 /* We can't use result_type below, as fold might have returned a
3361 /* Expand both sides into the same slot, hopefully the target of the
3362 ?: expression. We used to check for TARGET_EXPRs here, but now we
3363 sometimes wrap them in NOP_EXPRs so the test would fail. */
3364 if (!lvalue_p && IS_AGGR_TYPE (TREE_TYPE (result)))
3365 result = get_target_expr (result);
3367 /* If this expression is an rvalue, but might be mistaken for an
3368 lvalue, we must add a NON_LVALUE_EXPR. */
3369 if (!lvalue_p && real_lvalue_p (result))
3370 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3375 /* OPERAND is an operand to an expression. Perform necessary steps
3376 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3380 prep_operand (tree operand)
3384 operand = convert_from_reference (operand);
3385 if (CLASS_TYPE_P (TREE_TYPE (operand))
3386 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3387 /* Make sure the template type is instantiated now. */
3388 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3394 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3395 OVERLOAD) to the CANDIDATES, returning an updated list of
3396 CANDIDATES. The ARGS are the arguments provided to the call,
3397 without any implicit object parameter. The EXPLICIT_TARGS are
3398 explicit template arguments provided. TEMPLATE_ONLY is true if
3399 only template fucntions should be considered. CONVERSION_PATH,
3400 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3403 add_candidates (tree fns, tree args,
3404 tree explicit_targs, bool template_only,
3405 tree conversion_path, tree access_path,
3407 struct z_candidate **candidates)
3410 tree non_static_args;
3412 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3413 /* Delay creating the implicit this parameter until it is needed. */
3414 non_static_args = NULL_TREE;
3421 fn = OVL_CURRENT (fns);
3422 /* Figure out which set of arguments to use. */
3423 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3425 /* If this function is a non-static member, prepend the implicit
3426 object parameter. */
3427 if (!non_static_args)
3428 non_static_args = tree_cons (NULL_TREE,
3429 build_this (TREE_VALUE (args)),
3431 fn_args = non_static_args;
3434 /* Otherwise, just use the list of arguments provided. */
3437 if (TREE_CODE (fn) == TEMPLATE_DECL)
3438 add_template_candidate (candidates,
3448 else if (!template_only)
3449 add_function_candidate (candidates,
3456 fns = OVL_NEXT (fns);
3461 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3)
3463 struct z_candidate *candidates = 0, *cand;
3464 tree arglist, fnname;
3466 enum tree_code code2 = NOP_EXPR;
3471 if (error_operand_p (arg1)
3472 || error_operand_p (arg2)
3473 || error_operand_p (arg3))
3474 return error_mark_node;
3476 if (code == MODIFY_EXPR)
3478 code2 = TREE_CODE (arg3);
3480 fnname = ansi_assopname (code2);
3483 fnname = ansi_opname (code);
3485 arg1 = prep_operand (arg1);
3491 case VEC_DELETE_EXPR:
3493 /* Use build_op_new_call and build_op_delete_call instead. */
3497 return build_object_call (arg1, arg2);
3503 arg2 = prep_operand (arg2);
3504 arg3 = prep_operand (arg3);
3506 if (code == COND_EXPR)
3508 if (arg2 == NULL_TREE
3509 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3510 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3511 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3512 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3515 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3516 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3519 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3520 arg2 = integer_zero_node;
3522 arglist = NULL_TREE;
3524 arglist = tree_cons (NULL_TREE, arg3, arglist);
3526 arglist = tree_cons (NULL_TREE, arg2, arglist);
3527 arglist = tree_cons (NULL_TREE, arg1, arglist);
3529 /* Add namespace-scope operators to the list of functions to
3531 add_candidates (lookup_function_nonclass (fnname, arglist),
3532 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3533 flags, &candidates);
3534 /* Add class-member operators to the candidate set. */
3535 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3539 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3540 if (fns == error_mark_node)
3543 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3545 BASELINK_BINFO (fns),
3546 TYPE_BINFO (TREE_TYPE (arg1)),
3547 flags, &candidates);
3550 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3551 to know about two args; a builtin candidate will always have a first
3552 parameter of type bool. We'll handle that in
3553 build_builtin_candidate. */
3554 if (code == COND_EXPR)
3564 args[2] = NULL_TREE;
3567 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3573 /* For these, the built-in candidates set is empty
3574 [over.match.oper]/3. We don't want non-strict matches
3575 because exact matches are always possible with built-in
3576 operators. The built-in candidate set for COMPONENT_REF
3577 would be empty too, but since there are no such built-in
3578 operators, we accept non-strict matches for them. */
3583 strict_p = pedantic;
3587 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3592 case POSTINCREMENT_EXPR:
3593 case POSTDECREMENT_EXPR:
3594 /* Look for an `operator++ (int)'. If they didn't have
3595 one, then we fall back to the old way of doing things. */
3596 if (flags & LOOKUP_COMPLAIN)
3597 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3599 operator_name_info[code].name);
3600 if (code == POSTINCREMENT_EXPR)
3601 code = PREINCREMENT_EXPR;
3603 code = PREDECREMENT_EXPR;
3604 return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
3606 /* The caller will deal with these. */
3615 if (flags & LOOKUP_COMPLAIN)
3617 op_error (code, code2, arg1, arg2, arg3, "no match");
3618 print_z_candidates (candidates);
3620 return error_mark_node;
3623 cand = tourney (candidates);
3626 if (flags & LOOKUP_COMPLAIN)
3628 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3629 print_z_candidates (candidates);
3631 return error_mark_node;
3634 if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3637 && fnname == ansi_assopname (NOP_EXPR)
3638 && DECL_ARTIFICIAL (cand->fn)
3640 && ! candidates->next->next)
3642 warning ("using synthesized `%#D' for copy assignment",
3644 cp_warning_at (" where cfront would use `%#D'",
3646 ? candidates->next->fn
3650 return build_over_call (cand, LOOKUP_NORMAL);
3653 /* Check for comparison of different enum types. */
3662 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3663 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3664 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3665 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3667 warning ("comparison between `%#T' and `%#T'",
3668 TREE_TYPE (arg1), TREE_TYPE (arg2));
3675 /* We need to strip any leading REF_BIND so that bitfields don't cause
3676 errors. This should not remove any important conversions, because
3677 builtins don't apply to class objects directly. */
3678 conv = TREE_VEC_ELT (cand->convs, 0);
3679 if (TREE_CODE (conv) == REF_BIND)
3680 conv = TREE_OPERAND (conv, 0);
3681 arg1 = convert_like (conv, arg1);
3684 conv = TREE_VEC_ELT (cand->convs, 1);
3685 if (TREE_CODE (conv) == REF_BIND)
3686 conv = TREE_OPERAND (conv, 0);
3687 arg2 = convert_like (conv, arg2);
3691 conv = TREE_VEC_ELT (cand->convs, 2);
3692 if (TREE_CODE (conv) == REF_BIND)
3693 conv = TREE_OPERAND (conv, 0);
3694 arg3 = convert_like (conv, arg3);
3701 return build_modify_expr (arg1, code2, arg2);
3704 return build_indirect_ref (arg1, "unary *");
3709 case TRUNC_DIV_EXPR:
3720 case TRUNC_MOD_EXPR:
3724 case TRUTH_ANDIF_EXPR:
3725 case TRUTH_ORIF_EXPR:
3726 return cp_build_binary_op (code, arg1, arg2);
3731 case TRUTH_NOT_EXPR:
3732 case PREINCREMENT_EXPR:
3733 case POSTINCREMENT_EXPR:
3734 case PREDECREMENT_EXPR:
3735 case POSTDECREMENT_EXPR:
3738 return build_unary_op (code, arg1, candidates != 0);
3741 return build_array_ref (arg1, arg2);
3744 return build_conditional_expr (arg1, arg2, arg3);
3747 return build_m_component_ref
3748 (build_indirect_ref (arg1, NULL), arg2);
3750 /* The caller will deal with these. */
3762 /* Build a call to operator delete. This has to be handled very specially,
3763 because the restrictions on what signatures match are different from all
3764 other call instances. For a normal delete, only a delete taking (void *)
3765 or (void *, size_t) is accepted. For a placement delete, only an exact
3766 match with the placement new is accepted.
3768 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3769 ADDR is the pointer to be deleted.
3770 SIZE is the size of the memory block to be deleted.
3771 FLAGS are the usual overloading flags.
3772 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3775 build_op_delete_call (enum tree_code code, tree addr, tree size,
3776 int flags, tree placement)
3778 tree fn = NULL_TREE;
3779 tree fns, fnname, argtypes, args, type;
3782 if (addr == error_mark_node)
3783 return error_mark_node;
3785 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3787 fnname = ansi_opname (code);
3789 if (IS_AGGR_TYPE (type) && ! (flags & LOOKUP_GLOBAL))
3792 If the result of the lookup is ambiguous or inaccessible, or if
3793 the lookup selects a placement deallocation function, the
3794 program is ill-formed.
3796 Therefore, we ask lookup_fnfields to complain ambout ambiguity. */
3798 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3799 if (fns == error_mark_node)
3800 return error_mark_node;
3805 if (fns == NULL_TREE)
3806 fns = lookup_name_nonclass (fnname);
3813 /* Find the allocation function that is being called. */
3814 call_expr = placement;
3815 /* Sometimes we have a COMPOUND_EXPR, rather than a simple
3817 while (TREE_CODE (call_expr) == COMPOUND_EXPR)
3818 call_expr = TREE_OPERAND (call_expr, 1);
3819 /* Extract the function. */
3820 alloc_fn = get_callee_fndecl (call_expr);
3821 my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
3822 /* Then the second parm type. */
3823 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3824 /* Also the second argument. */
3825 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3829 /* First try it without the size argument. */
3830 argtypes = void_list_node;
3834 /* Strip const and volatile from addr. */
3835 addr = cp_convert (ptr_type_node, addr);
3837 /* We make two tries at finding a matching `operator delete'. On
3838 the first pass, we look for a one-operator (or placement)
3839 operator delete. If we're not doing placement delete, then on
3840 the second pass we look for a two-argument delete. */
3841 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
3843 /* Go through the `operator delete' functions looking for one
3844 with a matching type. */
3845 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
3851 /* The first argument must be "void *". */
3852 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3853 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3856 /* On the first pass, check the rest of the arguments. */
3859 while (argtypes && t)
3861 if (!same_type_p (TREE_VALUE (argtypes),
3864 argtypes = TREE_CHAIN (argtypes);
3867 if (!argtypes && !t)
3870 /* On the second pass, the second argument must be
3873 && same_type_p (TREE_VALUE (t), sizetype)
3874 && TREE_CHAIN (t) == void_list_node)
3878 /* If we found a match, we're done. */
3883 /* If we have a matching function, call it. */
3886 /* Make sure we have the actual function, and not an
3888 fn = OVL_CURRENT (fn);
3890 /* If the FN is a member function, make sure that it is
3892 if (DECL_CLASS_SCOPE_P (fn))
3893 perform_or_defer_access_check (TYPE_BINFO (type), fn);
3896 args = tree_cons (NULL_TREE, addr, args);
3898 args = tree_cons (NULL_TREE, addr,
3899 build_tree_list (NULL_TREE, size));
3901 return build_function_call (fn, args);
3904 /* If we are doing placement delete we do nothing if we don't find a
3905 matching op delete. */
3909 error ("no suitable `operator %s' for `%T'",
3910 operator_name_info[(int)code].name, type);
3911 return error_mark_node;
3914 /* If the current scope isn't allowed to access DECL along
3915 BASETYPE_PATH, give an error. The most derived class in
3916 BASETYPE_PATH is the one used to qualify DECL. */
3919 enforce_access (tree basetype_path, tree decl)
3921 my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624);
3923 if (!accessible_p (basetype_path, decl))
3925 if (TREE_PRIVATE (decl))
3926 cp_error_at ("`%+#D' is private", decl);
3927 else if (TREE_PROTECTED (decl))
3928 cp_error_at ("`%+#D' is protected", decl);
3930 cp_error_at ("`%+#D' is inaccessible", decl);
3931 error ("within this context");
3938 /* Perform the conversions in CONVS on the expression EXPR. FN and
3939 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
3940 indicates the `this' argument of a method. INNER is nonzero when
3941 being called to continue a conversion chain. It is negative when a
3942 reference binding will be applied, positive otherwise. If
3943 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
3944 conversions will be emitted if appropriate. */
3947 convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner,
3948 bool issue_conversion_warnings)
3952 tree totype = TREE_TYPE (convs);
3954 if (ICS_BAD_FLAG (convs)
3955 && TREE_CODE (convs) != USER_CONV
3956 && TREE_CODE (convs) != AMBIG_CONV
3957 && TREE_CODE (convs) != REF_BIND)
3960 for (; t; t = TREE_OPERAND (t, 0))
3962 if (TREE_CODE (t) == USER_CONV || !ICS_BAD_FLAG (t))
3964 expr = convert_like_real (t, expr, fn, argnum, 1,
3965 /*issue_conversion_warnings=*/false);
3968 else if (TREE_CODE (t) == AMBIG_CONV)
3969 return convert_like_real (t, expr, fn, argnum, 1,
3970 /*issue_conversion_warnings=*/false);
3971 else if (TREE_CODE (t) == IDENTITY_CONV)
3974 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
3976 pedwarn (" initializing argument %P of `%D'", argnum, fn);
3977 return cp_convert (totype, expr);
3980 if (issue_conversion_warnings)
3981 expr = dubious_conversion_warnings
3982 (totype, expr, "argument", fn, argnum);
3983 switch (TREE_CODE (convs))
3987 struct z_candidate *cand = USER_CONV_CAND (convs);
3988 tree convfn = cand->fn;
3991 if (DECL_CONSTRUCTOR_P (convfn))
3993 tree t = build_int_2 (0, 0);
3994 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
3996 args = build_tree_list (NULL_TREE, expr);
3997 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
3998 || DECL_HAS_VTT_PARM_P (convfn))
3999 /* We should never try to call the abstract or base constructor
4002 args = tree_cons (NULL_TREE, t, args);
4005 args = build_this (expr);
4006 expr = build_over_call (cand, LOOKUP_NORMAL);
4008 /* If this is a constructor or a function returning an aggr type,
4009 we need to build up a TARGET_EXPR. */
4010 if (DECL_CONSTRUCTOR_P (convfn))
4011 expr = build_cplus_new (totype, expr);
4013 /* The result of the call is then used to direct-initialize the object
4014 that is the destination of the copy-initialization. [dcl.init]
4016 Note that this step is not reflected in the conversion sequence;
4017 it affects the semantics when we actually perform the
4018 conversion, but is not considered during overload resolution.
4020 If the target is a class, that means call a ctor. */
4021 if (IS_AGGR_TYPE (totype)
4022 && (inner >= 0 || !lvalue_p (expr)))
4024 savew = warningcount, savee = errorcount;
4025 expr = build_special_member_call
4026 (NULL_TREE, complete_ctor_identifier,
4027 build_tree_list (NULL_TREE, expr), TYPE_BINFO (totype),
4028 /* Core issue 84, now a DR, says that we don't allow UDCs
4029 for these args (which deliberately breaks copy-init of an
4030 auto_ptr<Base> from an auto_ptr<Derived>). */
4031 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION);
4033 /* Tell the user where this failing constructor call came from. */
4036 if (warningcount > savew)
4038 (" initializing argument %P of `%D' from result of `%D'",
4039 argnum, fn, convfn);
4040 else if (errorcount > savee)
4042 (" initializing argument %P of `%D' from result of `%D'",
4043 argnum, fn, convfn);
4047 if (warningcount > savew)
4048 warning (" initializing temporary from result of `%D'",
4050 else if (errorcount > savee)
4051 error (" initializing temporary from result of `%D'",
4054 expr = build_cplus_new (totype, expr);
4059 if (type_unknown_p (expr))
4060 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4061 /* Convert a non-array constant variable to its underlying value, unless we
4062 are about to bind it to a reference, in which case we need to
4063 leave it as an lvalue. */
4065 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4066 expr = decl_constant_value (expr);
4069 /* Call build_user_type_conversion again for the error. */
4070 return build_user_type_conversion
4071 (totype, TREE_OPERAND (convs, 0), LOOKUP_NORMAL);
4077 expr = convert_like_real (TREE_OPERAND (convs, 0), expr, fn, argnum,
4078 TREE_CODE (convs) == REF_BIND ? -1 : 1,
4079 /*issue_conversion_warnings=*/false);
4080 if (expr == error_mark_node)
4081 return error_mark_node;
4083 switch (TREE_CODE (convs))
4086 if (! IS_AGGR_TYPE (totype))
4088 /* else fall through */
4090 if (TREE_CODE (convs) == BASE_CONV && !NEED_TEMPORARY_P (convs))
4092 /* We are going to bind a reference directly to a base-class
4093 subobject of EXPR. */
4094 tree base_ptr = build_pointer_type (totype);
4096 /* Build an expression for `*((base*) &expr)'. */
4097 expr = build_unary_op (ADDR_EXPR, expr, 0);
4098 expr = perform_implicit_conversion (base_ptr, expr);
4099 expr = build_indirect_ref (expr, "implicit conversion");
4103 /* Copy-initialization where the cv-unqualified version of the source
4104 type is the same class as, or a derived class of, the class of the
4105 destination [is treated as direct-initialization]. [dcl.init] */
4106 savew = warningcount, savee = errorcount;
4107 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4108 build_tree_list (NULL_TREE, expr),
4109 TYPE_BINFO (totype),
4110 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING);
4113 if (warningcount > savew)
4114 warning (" initializing argument %P of `%D'", argnum, fn);
4115 else if (errorcount > savee)
4116 error (" initializing argument %P of `%D'", argnum, fn);
4118 return build_cplus_new (totype, expr);
4122 tree ref_type = totype;
4124 /* If necessary, create a temporary. */
4125 if (NEED_TEMPORARY_P (convs) || !non_cast_lvalue_p (expr))
4127 tree type = TREE_TYPE (TREE_OPERAND (convs, 0));
4129 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4131 /* If the reference is volatile or non-const, we
4132 cannot create a temporary. */
4133 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4135 if (lvalue & clk_bitfield)
4136 error ("cannot bind bitfield `%E' to `%T'",
4138 else if (lvalue & clk_packed)
4139 error ("cannot bind packed field `%E' to `%T'",
4142 error ("cannot bind rvalue `%E' to `%T'", expr, ref_type);
4143 return error_mark_node;
4145 expr = build_target_expr_with_type (expr, type);
4148 /* Take the address of the thing to which we will bind the
4150 expr = build_unary_op (ADDR_EXPR, expr, 1);
4151 if (expr == error_mark_node)
4152 return error_mark_node;
4154 /* Convert it to a pointer to the type referred to by the
4155 reference. This will adjust the pointer if a derived to
4156 base conversion is being performed. */
4157 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4159 /* Convert the pointer to the desired reference type. */
4160 return build_nop (ref_type, expr);
4164 return decay_conversion (expr);
4167 /* Warn about deprecated conversion if appropriate. */
4168 string_conv_p (totype, expr, 1);
4174 return ocp_convert (totype, expr, CONV_IMPLICIT,
4175 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4178 /* Build a call to __builtin_trap which can be used in an expression. */
4181 call_builtin_trap (void)
4183 tree fn = get_identifier ("__builtin_trap");
4184 if (IDENTIFIER_GLOBAL_VALUE (fn))
4185 fn = IDENTIFIER_GLOBAL_VALUE (fn);
4189 fn = build_call (fn, NULL_TREE);
4190 fn = build (COMPOUND_EXPR, integer_type_node, fn, integer_zero_node);
4194 /* ARG is being passed to a varargs function. Perform any conversions
4195 required. Return the converted value. */
4198 convert_arg_to_ellipsis (tree arg)
4202 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4203 standard conversions are performed. */
4204 arg = decay_conversion (arg);
4207 If the argument has integral or enumeration type that is subject
4208 to the integral promotions (_conv.prom_), or a floating point
4209 type that is subject to the floating point promotion
4210 (_conv.fpprom_), the value of the argument is converted to the
4211 promoted type before the call. */
4212 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4213 && (TYPE_PRECISION (TREE_TYPE (arg))
4214 < TYPE_PRECISION (double_type_node)))
4215 arg = convert_to_real (double_type_node, arg);
4216 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4217 arg = perform_integral_promotions (arg);
4219 arg = require_complete_type (arg);
4221 if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
4223 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4224 here and do a bitwise copy, but now cp_expr_size will abort if we
4226 warning ("cannot pass objects of non-POD type `%#T' through `...'; \
4227 call will abort at runtime",
4229 arg = call_builtin_trap ();
4235 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4238 build_x_va_arg (tree expr, tree type)
4240 if (processing_template_decl)
4241 return build_min (VA_ARG_EXPR, type, expr);
4243 type = complete_type_or_else (type, NULL_TREE);
4245 if (expr == error_mark_node || !type)
4246 return error_mark_node;
4248 if (! pod_type_p (type))
4250 /* Undefined behavior [expr.call] 5.2.2/7. */
4251 warning ("cannot receive objects of non-POD type `%#T' through `...'",
4255 return build_va_arg (expr, type);
4258 /* TYPE has been given to va_arg. Apply the default conversions which
4259 would have happened when passed via ellipsis. Return the promoted
4260 type, or the passed type if there is no change. */
4263 cxx_type_promotes_to (tree type)
4267 if (TREE_CODE (type) == ARRAY_TYPE)
4268 return build_pointer_type (TREE_TYPE (type));
4270 if (TREE_CODE (type) == FUNCTION_TYPE)
4271 return build_pointer_type (type);
4273 promote = type_promotes_to (type);
4274 if (same_type_p (type, promote))
4280 /* ARG is a default argument expression being passed to a parameter of
4281 the indicated TYPE, which is a parameter to FN. Do any required
4282 conversions. Return the converted value. */
4285 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4287 /* If the ARG is an unparsed default argument expression, the
4288 conversion cannot be performed. */
4289 if (TREE_CODE (arg) == DEFAULT_ARG)
4291 error ("the default argument for parameter %d of `%D' has "
4292 "not yet been parsed",
4294 return error_mark_node;
4297 if (fn && DECL_TEMPLATE_INFO (fn))
4298 arg = tsubst_default_argument (fn, type, arg);
4300 arg = break_out_target_exprs (arg);
4302 if (TREE_CODE (arg) == CONSTRUCTOR)
4304 arg = digest_init (type, arg, 0);
4305 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4306 "default argument", fn, parmnum);
4310 /* This could get clobbered by the following call. */
4311 if (TREE_HAS_CONSTRUCTOR (arg))
4312 arg = copy_node (arg);
4314 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4315 "default argument", fn, parmnum);
4316 arg = convert_for_arg_passing (type, arg);
4322 /* Returns the type which will really be used for passing an argument of
4326 type_passed_as (tree type)
4328 /* Pass classes with copy ctors by invisible reference. */
4329 if (TREE_ADDRESSABLE (type))
4330 type = build_reference_type (type);
4331 else if (PROMOTE_PROTOTYPES
4332 && INTEGRAL_TYPE_P (type)
4333 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4334 TYPE_SIZE (integer_type_node)))
4335 type = integer_type_node;
4340 /* Actually perform the appropriate conversion. */
4343 convert_for_arg_passing (tree type, tree val)
4345 if (val == error_mark_node)
4347 /* Pass classes with copy ctors by invisible reference. */
4348 else if (TREE_ADDRESSABLE (type))
4349 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4350 else if (PROMOTE_PROTOTYPES
4351 && INTEGRAL_TYPE_P (type)
4352 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4353 TYPE_SIZE (integer_type_node)))
4354 val = perform_integral_promotions (val);
4358 /* Subroutine of the various build_*_call functions. Overload resolution
4359 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4360 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4361 bitmask of various LOOKUP_* flags which apply to the call itself. */
4364 build_over_call (struct z_candidate *cand, int flags)
4367 tree args = cand->args;
4368 tree convs = cand->convs;
4369 tree converted_args = NULL_TREE;
4370 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4371 tree conv, arg, val;
4375 /* Give any warnings we noticed during overload resolution. */
4377 for (val = cand->warnings; val; val = TREE_CHAIN (val))
4378 joust (cand, WRAPPER_ZC (TREE_VALUE (val)), 1);
4380 if (DECL_FUNCTION_MEMBER_P (fn))
4381 perform_or_defer_access_check (cand->access_path, fn);
4383 if (args && TREE_CODE (args) != TREE_LIST)
4384 args = build_tree_list (NULL_TREE, args);
4387 /* The implicit parameters to a constructor are not considered by overload
4388 resolution, and must be of the proper type. */
4389 if (DECL_CONSTRUCTOR_P (fn))
4391 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4392 arg = TREE_CHAIN (arg);
4393 parm = TREE_CHAIN (parm);
4394 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4395 /* We should never try to call the abstract constructor. */
4397 if (DECL_HAS_VTT_PARM_P (fn))
4399 converted_args = tree_cons
4400 (NULL_TREE, TREE_VALUE (arg), converted_args);
4401 arg = TREE_CHAIN (arg);
4402 parm = TREE_CHAIN (parm);
4405 /* Bypass access control for 'this' parameter. */
4406 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4408 tree parmtype = TREE_VALUE (parm);
4409 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4413 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
4414 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4415 TREE_TYPE (argtype), fn);
4417 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4418 X is called for an object that is not of type X, or of a type
4419 derived from X, the behavior is undefined.
4421 So we can assume that anything passed as 'this' is non-null, and
4422 optimize accordingly. */
4423 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4424 /* Convert to the base in which the function was declared. */
4425 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4426 converted_arg = build_base_path (PLUS_EXPR,
4428 cand->conversion_path,
4430 /* Check that the base class is accessible. */
4431 if (!accessible_base_p (TREE_TYPE (argtype),
4432 BINFO_TYPE (cand->conversion_path)))
4433 error ("`%T' is not an accessible base of `%T'",
4434 BINFO_TYPE (cand->conversion_path),
4435 TREE_TYPE (argtype));
4436 /* If fn was found by a using declaration, the conversion path
4437 will be to the derived class, not the base declaring fn. We
4438 must convert from derived to base. */
4439 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4440 TREE_TYPE (parmtype), ba_ignore, NULL);
4441 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4444 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4445 parm = TREE_CHAIN (parm);
4446 arg = TREE_CHAIN (arg);
4452 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4454 tree type = TREE_VALUE (parm);
4456 conv = TREE_VEC_ELT (convs, i);
4457 val = convert_like_with_context
4458 (conv, TREE_VALUE (arg), fn, i - is_method);
4460 val = convert_for_arg_passing (type, val);
4461 converted_args = tree_cons (NULL_TREE, val, converted_args);
4464 /* Default arguments */
4465 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4467 = tree_cons (NULL_TREE,
4468 convert_default_arg (TREE_VALUE (parm),
4469 TREE_PURPOSE (parm),
4474 for (; arg; arg = TREE_CHAIN (arg))
4476 = tree_cons (NULL_TREE,
4477 convert_arg_to_ellipsis (TREE_VALUE (arg)),
4480 converted_args = nreverse (converted_args);
4483 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4486 /* Avoid actually calling copy constructors and copy assignment operators,
4489 if (! flag_elide_constructors)
4490 /* Do things the hard way. */;
4491 else if (TREE_VEC_LENGTH (convs) == 1
4492 && DECL_COPY_CONSTRUCTOR_P (fn))
4495 arg = skip_artificial_parms_for (fn, converted_args);
4496 arg = TREE_VALUE (arg);
4498 /* Pull out the real argument, disregarding const-correctness. */
4500 while (TREE_CODE (targ) == NOP_EXPR
4501 || TREE_CODE (targ) == NON_LVALUE_EXPR
4502 || TREE_CODE (targ) == CONVERT_EXPR)
4503 targ = TREE_OPERAND (targ, 0);
4504 if (TREE_CODE (targ) == ADDR_EXPR)
4506 targ = TREE_OPERAND (targ, 0);
4507 if (!same_type_ignoring_top_level_qualifiers_p
4508 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4517 arg = build_indirect_ref (arg, 0);
4519 /* [class.copy]: the copy constructor is implicitly defined even if
4520 the implementation elided its use. */
4521 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4524 /* If we're creating a temp and we already have one, don't create a
4525 new one. If we're not creating a temp but we get one, use
4526 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4527 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4528 temp or an INIT_EXPR otherwise. */
4529 if (integer_zerop (TREE_VALUE (args)))
4531 if (TREE_CODE (arg) == TARGET_EXPR)
4533 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4534 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4536 else if (TREE_CODE (arg) == TARGET_EXPR
4537 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4540 tree to = stabilize_reference
4541 (build_indirect_ref (TREE_VALUE (args), 0));
4543 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4544 address = build_unary_op (ADDR_EXPR, val, 0);
4545 /* Avoid a warning about this expression, if the address is
4547 TREE_USED (address) = 1;
4551 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4553 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4555 tree to = stabilize_reference
4556 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4558 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4559 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4565 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4567 tree t, *p = &TREE_VALUE (converted_args);
4568 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4571 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4573 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4574 if (TREE_SIDE_EFFECTS (*p))
4575 *p = save_expr (*p);
4576 t = build_pointer_type (TREE_TYPE (fn));
4577 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4578 fn = build_java_interface_fn_ref (fn, *p);
4580 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4583 else if (DECL_INLINE (fn))
4584 fn = inline_conversion (fn);
4586 fn = build_addr_func (fn);
4588 return build_cxx_call (fn, args, converted_args);
4591 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4592 gives the original form of the arguments. This function performs
4593 no overload resolution, conversion, or other high-level
4597 build_cxx_call(tree fn, tree args, tree converted_args)
4601 /* Recognize certain built-in functions so we can make tree-codes
4602 other than CALL_EXPR. We do this when it enables fold-const.c
4603 to do something useful. */
4604 if (TREE_CODE (fn) == ADDR_EXPR
4605 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4606 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4609 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4614 fn = build_call (fn, converted_args);
4616 /* If this call might throw an exception, note that fact. */
4617 fndecl = get_callee_fndecl (fn);
4618 if ((!fndecl || !TREE_NOTHROW (fndecl))
4619 && at_function_scope_p ()
4621 cp_function_chain->can_throw = 1;
4623 /* Some built-in function calls will be evaluated at compile-time in
4627 if (VOID_TYPE_P (TREE_TYPE (fn)))
4630 fn = require_complete_type (fn);
4631 if (fn == error_mark_node)
4632 return error_mark_node;
4634 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4635 fn = build_cplus_new (TREE_TYPE (fn), fn);
4636 return convert_from_reference (fn);
4639 static GTY(()) tree java_iface_lookup_fn;
4641 /* Make an expression which yields the address of the Java interface
4642 method FN. This is achieved by generating a call to libjava's
4643 _Jv_LookupInterfaceMethodIdx(). */
4646 build_java_interface_fn_ref (tree fn, tree instance)
4648 tree lookup_args, lookup_fn, method, idx;
4649 tree klass_ref, iface, iface_ref;
4652 if (!java_iface_lookup_fn)
4654 tree endlink = build_void_list_node ();
4655 tree t = tree_cons (NULL_TREE, ptr_type_node,
4656 tree_cons (NULL_TREE, ptr_type_node,
4657 tree_cons (NULL_TREE, java_int_type_node,
4659 java_iface_lookup_fn
4660 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4661 build_function_type (ptr_type_node, t),
4662 0, NOT_BUILT_IN, NULL, NULL_TREE);
4665 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4666 This is the first entry in the vtable. */
4667 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4670 /* Get the java.lang.Class pointer for the interface being called. */
4671 iface = DECL_CONTEXT (fn);
4672 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4673 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4674 || DECL_CONTEXT (iface_ref) != iface)
4676 error ("could not find class$ field in java interface type `%T'",
4678 return error_mark_node;
4680 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4682 /* Determine the itable index of FN. */
4684 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4686 if (!DECL_VIRTUAL_P (method))
4692 idx = build_int_2 (i, 0);
4694 lookup_args = tree_cons (NULL_TREE, klass_ref,
4695 tree_cons (NULL_TREE, iface_ref,
4696 build_tree_list (NULL_TREE, idx)));
4697 lookup_fn = build1 (ADDR_EXPR,
4698 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4699 java_iface_lookup_fn);
4700 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4703 /* Returns the value to use for the in-charge parameter when making a
4704 call to a function with the indicated NAME. */
4707 in_charge_arg_for_name (tree name)
4709 if (name == base_ctor_identifier
4710 || name == base_dtor_identifier)
4711 return integer_zero_node;
4712 else if (name == complete_ctor_identifier)
4713 return integer_one_node;
4714 else if (name == complete_dtor_identifier)
4715 return integer_two_node;
4716 else if (name == deleting_dtor_identifier)
4717 return integer_three_node;
4719 /* This function should only be called with one of the names listed
4725 /* Build a call to a constructor, destructor, or an assignment
4726 operator for INSTANCE, an expression with class type. NAME
4727 indicates the special member function to call; ARGS are the
4728 arguments. BINFO indicates the base of INSTANCE that is to be
4729 passed as the `this' parameter to the member function called.
4731 FLAGS are the LOOKUP_* flags to use when processing the call.
4733 If NAME indicates a complete object constructor, INSTANCE may be
4734 NULL_TREE. In this case, the caller will call build_cplus_new to
4735 store the newly constructed object into a VAR_DECL. */
4738 build_special_member_call (tree instance, tree name, tree args,
4739 tree binfo, int flags)
4742 /* The type of the subobject to be constructed or destroyed. */
4745 my_friendly_assert (name == complete_ctor_identifier
4746 || name == base_ctor_identifier
4747 || name == complete_dtor_identifier
4748 || name == base_dtor_identifier
4749 || name == deleting_dtor_identifier
4750 || name == ansi_assopname (NOP_EXPR),
4752 my_friendly_assert (binfo != NULL_TREE, 20020712);
4754 class_type = BINFO_TYPE (binfo);
4756 /* Handle the special case where INSTANCE is NULL_TREE. */
4757 if (name == complete_ctor_identifier && !instance)
4759 instance = build_int_2 (0, 0);
4760 TREE_TYPE (instance) = build_pointer_type (class_type);
4761 instance = build1 (INDIRECT_REF, class_type, instance);
4765 if (name == complete_dtor_identifier
4766 || name == base_dtor_identifier
4767 || name == deleting_dtor_identifier)
4768 my_friendly_assert (args == NULL_TREE, 20020712);
4770 /* We must perform the conversion here so that we do not
4771 subsequently check to see whether BINFO is an accessible
4772 base. (It is OK for a constructor to call a constructor in
4773 an inaccessible base as long as the constructor being called
4775 if (!same_type_ignoring_top_level_qualifiers_p
4776 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
4777 instance = convert_to_base_statically (instance, binfo);
4780 my_friendly_assert (instance != NULL_TREE, 20020712);
4782 /* Resolve the name. */
4783 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
4784 return error_mark_node;
4786 fns = lookup_fnfields (binfo, name, 1);
4788 /* When making a call to a constructor or destructor for a subobject
4789 that uses virtual base classes, pass down a pointer to a VTT for
4791 if ((name == base_ctor_identifier
4792 || name == base_dtor_identifier)
4793 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
4798 /* If the current function is a complete object constructor
4799 or destructor, then we fetch the VTT directly.
4800 Otherwise, we look it up using the VTT we were given. */
4801 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
4802 vtt = decay_conversion (vtt);
4803 vtt = build (COND_EXPR, TREE_TYPE (vtt),
4804 build (EQ_EXPR, boolean_type_node,
4805 current_in_charge_parm, integer_zero_node),
4808 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
4809 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
4810 BINFO_SUBVTT_INDEX (binfo));
4812 args = tree_cons (NULL_TREE, sub_vtt, args);
4815 return build_new_method_call (instance, fns, args,
4816 TYPE_BINFO (BINFO_TYPE (binfo)),
4820 /* Return the NAME, as a C string. The NAME indicates a function that
4821 is a member of TYPE. *FREE_P is set to true if the caller must
4822 free the memory returned.
4824 Rather than go through all of this, we should simply set the names
4825 of constructors and destructors appropriately, and dispense with
4826 ctor_identifier, dtor_identifier, etc. */
4829 name_as_c_string (tree name, tree type, bool *free_p)
4833 /* Assume that we will not allocate memory. */
4835 /* Constructors and destructors are special. */
4836 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4839 = (char *) IDENTIFIER_POINTER (constructor_name (type));
4840 /* For a destructor, add the '~'. */
4841 if (name == complete_dtor_identifier
4842 || name == base_dtor_identifier
4843 || name == deleting_dtor_identifier)
4845 pretty_name = concat ("~", pretty_name, NULL);
4846 /* Remember that we need to free the memory allocated. */
4851 pretty_name = (char *) IDENTIFIER_POINTER (name);
4856 /* Build a call to "INSTANCE.FN (ARGS)". */
4859 build_new_method_call (tree instance, tree fns, tree args,
4860 tree conversion_path, int flags)
4862 struct z_candidate *candidates = 0, *cand;
4863 tree explicit_targs = NULL_TREE;
4864 tree basetype = NULL_TREE;
4867 tree mem_args = NULL_TREE, instance_ptr;
4873 int template_only = 0;
4879 my_friendly_assert (instance != NULL_TREE, 20020729);
4881 if (error_operand_p (instance)
4882 || error_operand_p (fns)
4883 || args == error_mark_node)
4884 return error_mark_node;
4886 orig_instance = instance;
4890 if (processing_template_decl)
4892 instance = build_non_dependent_expr (instance);
4893 if (!BASELINK_P (fns)
4894 && TREE_CODE (fns) != PSEUDO_DTOR_EXPR
4895 && TREE_TYPE (fns) != unknown_type_node)
4896 fns = build_non_dependent_expr (fns);
4897 args = build_non_dependent_args (orig_args);
4900 /* Process the argument list. */
4902 args = resolve_args (args);
4903 if (args == error_mark_node)
4904 return error_mark_node;
4906 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
4907 instance = convert_from_reference (instance);
4908 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
4909 instance_ptr = build_this (instance);
4911 if (!BASELINK_P (fns))
4913 call = build_field_call (instance_ptr, fns, args);
4916 error ("call to non-function `%D'", fns);
4917 return error_mark_node;
4920 if (!conversion_path)
4921 conversion_path = BASELINK_BINFO (fns);
4922 access_binfo = BASELINK_ACCESS_BINFO (fns);
4923 optype = BASELINK_OPTYPE (fns);
4924 fns = BASELINK_FUNCTIONS (fns);
4926 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
4928 explicit_targs = TREE_OPERAND (fns, 1);
4929 fns = TREE_OPERAND (fns, 0);
4933 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
4934 || TREE_CODE (fns) == TEMPLATE_DECL
4935 || TREE_CODE (fns) == OVERLOAD,
4938 /* XXX this should be handled before we get here. */
4939 if (! IS_AGGR_TYPE (basetype))
4941 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
4942 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
4943 fns, instance, basetype);
4945 return error_mark_node;
4948 fn = get_first_fn (fns);
4949 name = DECL_NAME (fn);
4951 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4953 /* Callers should explicitly indicate whether they want to construct
4954 the complete object or just the part without virtual bases. */
4955 my_friendly_assert (name != ctor_identifier, 20000408);
4956 /* Similarly for destructors. */
4957 my_friendly_assert (name != dtor_identifier, 20000408);
4960 /* It's OK to call destructors on cv-qualified objects. Therefore,
4961 convert the INSTANCE_PTR to the unqualified type, if necessary. */
4962 if (DECL_DESTRUCTOR_P (fn))
4964 tree type = build_pointer_type (basetype);
4965 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
4966 instance_ptr = build_nop (type, instance_ptr);
4969 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
4970 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
4972 for (fn = fns; fn; fn = OVL_NEXT (fn))
4974 tree t = OVL_CURRENT (fn);
4977 /* We can end up here for copy-init of same or base class. */
4978 if ((flags & LOOKUP_ONLYCONVERTING)
4979 && DECL_NONCONVERTING_P (t))
4982 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
4983 this_arglist = mem_args;
4985 this_arglist = args;
4987 if (TREE_CODE (t) == TEMPLATE_DECL)
4988 /* A member template. */
4989 add_template_candidate (&candidates, t,
4992 this_arglist, optype,
4997 else if (! template_only)
4998 add_function_candidate (&candidates, t,
5006 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5009 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5010 if (flags & LOOKUP_SPECULATIVELY)
5012 if (!COMPLETE_TYPE_P (basetype))
5013 cxx_incomplete_type_error (instance_ptr, basetype);
5019 pretty_name = name_as_c_string (name, basetype, &free_p);
5020 error ("no matching function for call to `%T::%s(%A)%#V'",
5021 basetype, pretty_name, user_args,
5022 TREE_TYPE (TREE_TYPE (instance_ptr)));
5026 print_z_candidates (candidates);
5027 return error_mark_node;
5030 cand = tourney (candidates);
5036 pretty_name = name_as_c_string (name, basetype, &free_p);
5037 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
5039 print_z_candidates (candidates);
5042 return error_mark_node;
5045 if (DECL_PURE_VIRTUAL_P (cand->fn)
5046 && instance == current_class_ref
5047 && (DECL_CONSTRUCTOR_P (current_function_decl)
5048 || DECL_DESTRUCTOR_P (current_function_decl))
5049 && ! (flags & LOOKUP_NONVIRTUAL)
5050 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
5051 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5052 "abstract virtual `%#D' called from constructor"
5053 : "abstract virtual `%#D' called from destructor"),
5055 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5056 && is_dummy_object (instance_ptr))
5058 error ("cannot call member function `%D' without object", cand->fn);
5059 return error_mark_node;
5062 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5063 && resolves_to_fixed_type_p (instance, 0))
5064 flags |= LOOKUP_NONVIRTUAL;
5066 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE)
5067 call = build_over_call (cand, flags);
5070 call = build_over_call (cand, flags);
5071 /* In an expression of the form `a->f()' where `f' turns out to
5072 be a static member function, `a' is none-the-less evaluated. */
5073 if (!is_dummy_object (instance_ptr) && TREE_SIDE_EFFECTS (instance))
5074 call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call);
5077 if (processing_template_decl && call != error_mark_node)
5078 return build_min (CALL_EXPR,
5080 build_min_nt (COMPONENT_REF,
5087 /* Returns true iff standard conversion sequence ICS1 is a proper
5088 subsequence of ICS2. */
5091 is_subseq (tree ics1, tree ics2)
5093 /* We can assume that a conversion of the same code
5094 between the same types indicates a subsequence since we only get
5095 here if the types we are converting from are the same. */
5097 while (TREE_CODE (ics1) == RVALUE_CONV
5098 || TREE_CODE (ics1) == LVALUE_CONV)
5099 ics1 = TREE_OPERAND (ics1, 0);
5103 while (TREE_CODE (ics2) == RVALUE_CONV
5104 || TREE_CODE (ics2) == LVALUE_CONV)
5105 ics2 = TREE_OPERAND (ics2, 0);
5107 if (TREE_CODE (ics2) == USER_CONV
5108 || TREE_CODE (ics2) == AMBIG_CONV
5109 || TREE_CODE (ics2) == IDENTITY_CONV)
5110 /* At this point, ICS1 cannot be a proper subsequence of
5111 ICS2. We can get a USER_CONV when we are comparing the
5112 second standard conversion sequence of two user conversion
5116 ics2 = TREE_OPERAND (ics2, 0);
5118 if (TREE_CODE (ics2) == TREE_CODE (ics1)
5119 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
5120 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
5121 TREE_TYPE (TREE_OPERAND (ics1, 0))))
5126 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5127 be any _TYPE nodes. */
5130 is_properly_derived_from (tree derived, tree base)
5132 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5133 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5136 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5137 considers every class derived from itself. */
5138 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5139 && DERIVED_FROM_P (base, derived));
5142 /* We build the ICS for an implicit object parameter as a pointer
5143 conversion sequence. However, such a sequence should be compared
5144 as if it were a reference conversion sequence. If ICS is the
5145 implicit conversion sequence for an implicit object parameter,
5146 modify it accordingly. */
5149 maybe_handle_implicit_object (tree *ics)
5151 if (ICS_THIS_FLAG (*ics))
5153 /* [over.match.funcs]
5155 For non-static member functions, the type of the
5156 implicit object parameter is "reference to cv X"
5157 where X is the class of which the function is a
5158 member and cv is the cv-qualification on the member
5159 function declaration. */
5161 tree reference_type;
5163 /* The `this' parameter is a pointer to a class type. Make the
5164 implicit conversion talk about a reference to that same class
5166 reference_type = TREE_TYPE (TREE_TYPE (*ics));
5167 reference_type = build_reference_type (reference_type);
5169 if (TREE_CODE (t) == QUAL_CONV)
5170 t = TREE_OPERAND (t, 0);
5171 if (TREE_CODE (t) == PTR_CONV)
5172 t = TREE_OPERAND (t, 0);
5173 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
5174 t = direct_reference_binding (reference_type, t);
5179 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5180 and return the type to which the reference refers. Otherwise,
5181 leave *ICS unchanged and return NULL_TREE. */
5184 maybe_handle_ref_bind (tree *ics)
5186 if (TREE_CODE (*ics) == REF_BIND)
5188 tree old_ics = *ics;
5189 tree type = TREE_TYPE (TREE_TYPE (old_ics));
5190 *ics = TREE_OPERAND (old_ics, 0);
5191 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
5192 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
5199 /* Compare two implicit conversion sequences according to the rules set out in
5200 [over.ics.rank]. Return values:
5202 1: ics1 is better than ics2
5203 -1: ics2 is better than ics1
5204 0: ics1 and ics2 are indistinguishable */
5207 compare_ics (tree ics1, tree ics2)
5213 tree deref_from_type1 = NULL_TREE;
5214 tree deref_from_type2 = NULL_TREE;
5215 tree deref_to_type1 = NULL_TREE;
5216 tree deref_to_type2 = NULL_TREE;
5219 /* REF_BINDING is nonzero if the result of the conversion sequence
5220 is a reference type. In that case TARGET_TYPE is the
5221 type referred to by the reference. */
5225 /* Handle implicit object parameters. */
5226 maybe_handle_implicit_object (&ics1);
5227 maybe_handle_implicit_object (&ics2);
5229 /* Handle reference parameters. */
5230 target_type1 = maybe_handle_ref_bind (&ics1);
5231 target_type2 = maybe_handle_ref_bind (&ics2);
5235 When comparing the basic forms of implicit conversion sequences (as
5236 defined in _over.best.ics_)
5238 --a standard conversion sequence (_over.ics.scs_) is a better
5239 conversion sequence than a user-defined conversion sequence
5240 or an ellipsis conversion sequence, and
5242 --a user-defined conversion sequence (_over.ics.user_) is a
5243 better conversion sequence than an ellipsis conversion sequence
5244 (_over.ics.ellipsis_). */
5245 rank1 = ICS_RANK (ics1);
5246 rank2 = ICS_RANK (ics2);
5250 else if (rank1 < rank2)
5253 if (rank1 == BAD_RANK)
5255 /* XXX Isn't this an extension? */
5256 /* Both ICS are bad. We try to make a decision based on what
5257 would have happenned if they'd been good. */
5258 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5259 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5261 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5262 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5265 /* We couldn't make up our minds; try to figure it out below. */
5268 if (ICS_ELLIPSIS_FLAG (ics1))
5269 /* Both conversions are ellipsis conversions. */
5272 /* User-defined conversion sequence U1 is a better conversion sequence
5273 than another user-defined conversion sequence U2 if they contain the
5274 same user-defined conversion operator or constructor and if the sec-
5275 ond standard conversion sequence of U1 is better than the second
5276 standard conversion sequence of U2. */
5278 if (ICS_USER_FLAG (ics1))
5282 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5283 if (TREE_CODE (t1) == AMBIG_CONV)
5285 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5286 if (TREE_CODE (t2) == AMBIG_CONV)
5289 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5292 /* We can just fall through here, after setting up
5293 FROM_TYPE1 and FROM_TYPE2. */
5294 from_type1 = TREE_TYPE (t1);
5295 from_type2 = TREE_TYPE (t2);
5299 /* We're dealing with two standard conversion sequences.
5303 Standard conversion sequence S1 is a better conversion
5304 sequence than standard conversion sequence S2 if
5306 --S1 is a proper subsequence of S2 (comparing the conversion
5307 sequences in the canonical form defined by _over.ics.scs_,
5308 excluding any Lvalue Transformation; the identity
5309 conversion sequence is considered to be a subsequence of
5310 any non-identity conversion sequence */
5313 while (TREE_CODE (from_type1) != IDENTITY_CONV)
5314 from_type1 = TREE_OPERAND (from_type1, 0);
5315 from_type1 = TREE_TYPE (from_type1);
5318 while (TREE_CODE (from_type2) != IDENTITY_CONV)
5319 from_type2 = TREE_OPERAND (from_type2, 0);
5320 from_type2 = TREE_TYPE (from_type2);
5323 if (same_type_p (from_type1, from_type2))
5325 if (is_subseq (ics1, ics2))
5327 if (is_subseq (ics2, ics1))
5330 /* Otherwise, one sequence cannot be a subsequence of the other; they
5331 don't start with the same type. This can happen when comparing the
5332 second standard conversion sequence in two user-defined conversion
5339 --the rank of S1 is better than the rank of S2 (by the rules
5342 Standard conversion sequences are ordered by their ranks: an Exact
5343 Match is a better conversion than a Promotion, which is a better
5344 conversion than a Conversion.
5346 Two conversion sequences with the same rank are indistinguishable
5347 unless one of the following rules applies:
5349 --A conversion that is not a conversion of a pointer, or pointer
5350 to member, to bool is better than another conversion that is such
5353 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5354 so that we do not have to check it explicitly. */
5355 if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5357 else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1))
5360 to_type1 = TREE_TYPE (ics1);
5361 to_type2 = TREE_TYPE (ics2);
5363 if (TYPE_PTR_P (from_type1)
5364 && TYPE_PTR_P (from_type2)
5365 && TYPE_PTR_P (to_type1)
5366 && TYPE_PTR_P (to_type2))
5368 deref_from_type1 = TREE_TYPE (from_type1);
5369 deref_from_type2 = TREE_TYPE (from_type2);
5370 deref_to_type1 = TREE_TYPE (to_type1);
5371 deref_to_type2 = TREE_TYPE (to_type2);
5373 /* The rules for pointers to members A::* are just like the rules
5374 for pointers A*, except opposite: if B is derived from A then
5375 A::* converts to B::*, not vice versa. For that reason, we
5376 switch the from_ and to_ variables here. */
5377 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5378 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5379 || (TYPE_PTRMEMFUNC_P (from_type1)
5380 && TYPE_PTRMEMFUNC_P (from_type2)
5381 && TYPE_PTRMEMFUNC_P (to_type1)
5382 && TYPE_PTRMEMFUNC_P (to_type2)))
5384 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5385 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5386 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5387 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5390 if (deref_from_type1 != NULL_TREE
5391 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5392 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5394 /* This was one of the pointer or pointer-like conversions.
5398 --If class B is derived directly or indirectly from class A,
5399 conversion of B* to A* is better than conversion of B* to
5400 void*, and conversion of A* to void* is better than
5401 conversion of B* to void*. */
5402 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5403 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5405 if (is_properly_derived_from (deref_from_type1,
5408 else if (is_properly_derived_from (deref_from_type2,
5412 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5413 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5415 if (same_type_p (deref_from_type1, deref_from_type2))
5417 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5419 if (is_properly_derived_from (deref_from_type1,
5423 /* We know that DEREF_TO_TYPE1 is `void' here. */
5424 else if (is_properly_derived_from (deref_from_type1,
5429 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5430 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5434 --If class B is derived directly or indirectly from class A
5435 and class C is derived directly or indirectly from B,
5437 --conversion of C* to B* is better than conversion of C* to
5440 --conversion of B* to A* is better than conversion of C* to
5442 if (same_type_p (deref_from_type1, deref_from_type2))
5444 if (is_properly_derived_from (deref_to_type1,
5447 else if (is_properly_derived_from (deref_to_type2,
5451 else if (same_type_p (deref_to_type1, deref_to_type2))
5453 if (is_properly_derived_from (deref_from_type2,
5456 else if (is_properly_derived_from (deref_from_type1,
5462 else if (CLASS_TYPE_P (non_reference (from_type1))
5463 && same_type_p (from_type1, from_type2))
5465 tree from = non_reference (from_type1);
5469 --binding of an expression of type C to a reference of type
5470 B& is better than binding an expression of type C to a
5471 reference of type A&
5473 --conversion of C to B is better than conversion of C to A, */
5474 if (is_properly_derived_from (from, to_type1)
5475 && is_properly_derived_from (from, to_type2))
5477 if (is_properly_derived_from (to_type1, to_type2))
5479 else if (is_properly_derived_from (to_type2, to_type1))
5483 else if (CLASS_TYPE_P (non_reference (to_type1))
5484 && same_type_p (to_type1, to_type2))
5486 tree to = non_reference (to_type1);
5490 --binding of an expression of type B to a reference of type
5491 A& is better than binding an expression of type C to a
5492 reference of type A&,
5494 --onversion of B to A is better than conversion of C to A */
5495 if (is_properly_derived_from (from_type1, to)
5496 && is_properly_derived_from (from_type2, to))
5498 if (is_properly_derived_from (from_type2, from_type1))
5500 else if (is_properly_derived_from (from_type1, from_type2))
5507 --S1 and S2 differ only in their qualification conversion and yield
5508 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5509 qualification signature of type T1 is a proper subset of the cv-
5510 qualification signature of type T2 */
5511 if (TREE_CODE (ics1) == QUAL_CONV
5512 && TREE_CODE (ics2) == QUAL_CONV
5513 && same_type_p (from_type1, from_type2))
5514 return comp_cv_qual_signature (to_type1, to_type2);
5518 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5519 types to which the references refer are the same type except for
5520 top-level cv-qualifiers, and the type to which the reference
5521 initialized by S2 refers is more cv-qualified than the type to
5522 which the reference initialized by S1 refers */
5524 if (target_type1 && target_type2
5525 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5526 return comp_cv_qualification (target_type2, target_type1);
5528 /* Neither conversion sequence is better than the other. */
5532 /* The source type for this standard conversion sequence. */
5535 source_type (tree t)
5537 for (;; t = TREE_OPERAND (t, 0))
5539 if (TREE_CODE (t) == USER_CONV
5540 || TREE_CODE (t) == AMBIG_CONV
5541 || TREE_CODE (t) == IDENTITY_CONV)
5542 return TREE_TYPE (t);
5547 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5548 a pointer to LOSER and re-running joust to produce the warning if WINNER
5549 is actually used. */
5552 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5554 winner->warnings = tree_cons (NULL_TREE,
5555 build_zc_wrapper (loser),
5559 /* Compare two candidates for overloading as described in
5560 [over.match.best]. Return values:
5562 1: cand1 is better than cand2
5563 -1: cand2 is better than cand1
5564 0: cand1 and cand2 are indistinguishable */
5567 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5570 int i, off1 = 0, off2 = 0, len;
5572 /* Candidates that involve bad conversions are always worse than those
5574 if (cand1->viable > cand2->viable)
5576 if (cand1->viable < cand2->viable)
5579 /* If we have two pseudo-candidates for conversions to the same type,
5580 or two candidates for the same function, arbitrarily pick one. */
5581 if (cand1->fn == cand2->fn
5582 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5585 /* a viable function F1
5586 is defined to be a better function than another viable function F2 if
5587 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5588 ICSi(F2), and then */
5590 /* for some argument j, ICSj(F1) is a better conversion sequence than
5593 /* For comparing static and non-static member functions, we ignore
5594 the implicit object parameter of the non-static function. The
5595 standard says to pretend that the static function has an object
5596 parm, but that won't work with operator overloading. */
5597 len = TREE_VEC_LENGTH (cand1->convs);
5598 if (len != TREE_VEC_LENGTH (cand2->convs))
5600 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5601 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5603 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5604 && DECL_STATIC_FUNCTION_P (cand2->fn))
5613 for (i = 0; i < len; ++i)
5615 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5616 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5617 int comp = compare_ics (t1, t2);
5622 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5623 && TREE_CODE (t1) == STD_CONV
5624 && TREE_CODE (t2) == STD_CONV
5625 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5626 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5627 && (TYPE_PRECISION (TREE_TYPE (t1))
5628 == TYPE_PRECISION (TREE_TYPE (t2)))
5629 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5630 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5633 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5635 struct z_candidate *w, *l;
5637 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5638 w = cand1, l = cand2;
5640 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5641 w = cand2, l = cand1;
5645 warning ("passing `%T' chooses `%T' over `%T'",
5646 type, type1, type2);
5647 warning (" in call to `%D'", w->fn);
5653 if (winner && comp != winner)
5662 /* warn about confusing overload resolution for user-defined conversions,
5663 either between a constructor and a conversion op, or between two
5665 if (winner && warn_conversion && cand1->second_conv
5666 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5667 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5669 struct z_candidate *w, *l;
5670 bool give_warning = false;
5673 w = cand1, l = cand2;
5675 w = cand2, l = cand1;
5677 /* We don't want to complain about `X::operator T1 ()'
5678 beating `X::operator T2 () const', when T2 is a no less
5679 cv-qualified version of T1. */
5680 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5681 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5683 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5684 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5686 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5691 if (!comp_ptr_ttypes (t, f))
5692 give_warning = true;
5695 give_warning = true;
5701 tree source = source_type (TREE_VEC_ELT (w->convs, 0));
5702 if (! DECL_CONSTRUCTOR_P (w->fn))
5703 source = TREE_TYPE (source);
5704 warning ("choosing `%D' over `%D'", w->fn, l->fn);
5705 warning (" for conversion from `%T' to `%T'",
5706 source, TREE_TYPE (w->second_conv));
5707 warning (" because conversion sequence for the argument is better");
5717 F1 is a non-template function and F2 is a template function
5720 if (! cand1->template && cand2->template)
5722 else if (cand1->template && ! cand2->template)
5726 F1 and F2 are template functions and the function template for F1 is
5727 more specialized than the template for F2 according to the partial
5730 if (cand1->template && cand2->template)
5732 winner = more_specialized
5733 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
5735 /* Tell the deduction code how many real function arguments
5736 we saw, not counting the implicit 'this' argument. But,
5737 add_function_candidate() suppresses the "this" argument
5740 [temp.func.order]: The presence of unused ellipsis and default
5741 arguments has no effect on the partial ordering of function
5743 TREE_VEC_LENGTH (cand1->convs)
5744 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
5745 - DECL_CONSTRUCTOR_P (cand1->fn)));
5751 the context is an initialization by user-defined conversion (see
5752 _dcl.init_ and _over.match.user_) and the standard conversion
5753 sequence from the return type of F1 to the destination type (i.e.,
5754 the type of the entity being initialized) is a better conversion
5755 sequence than the standard conversion sequence from the return type
5756 of F2 to the destination type. */
5758 if (cand1->second_conv)
5760 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5765 /* Check whether we can discard a builtin candidate, either because we
5766 have two identical ones or matching builtin and non-builtin candidates.
5768 (Pedantically in the latter case the builtin which matched the user
5769 function should not be added to the overload set, but we spot it here.
5772 ... the builtin candidates include ...
5773 - do not have the same parameter type list as any non-template
5774 non-member candidate. */
5776 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
5777 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
5779 for (i = 0; i < len; ++i)
5780 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5781 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i))))
5783 if (i == TREE_VEC_LENGTH (cand1->convs))
5785 if (cand1->fn == cand2->fn)
5786 /* Two built-in candidates; arbitrarily pick one. */
5788 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5789 /* cand1 is built-in; prefer cand2. */
5792 /* cand2 is built-in; prefer cand1. */
5797 /* If the two functions are the same (this can happen with declarations
5798 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5799 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
5800 && equal_functions (cand1->fn, cand2->fn))
5805 /* Extension: If the worst conversion for one candidate is worse than the
5806 worst conversion for the other, take the first. */
5809 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
5810 struct z_candidate *w = 0, *l = 0;
5812 for (i = 0; i < len; ++i)
5814 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5815 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5816 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5817 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5820 winner = 1, w = cand1, l = cand2;
5822 winner = -1, w = cand2, l = cand1;
5828 ISO C++ says that these are ambiguous, even \
5829 though the worst conversion for the first is better than \
5830 the worst conversion for the second:");
5831 print_z_candidate (_("candidate 1:"), w);
5832 print_z_candidate (_("candidate 2:"), l);
5840 my_friendly_assert (!winner, 20010121);
5844 /* Given a list of candidates for overloading, find the best one, if any.
5845 This algorithm has a worst case of O(2n) (winner is last), and a best
5846 case of O(n/2) (totally ambiguous); much better than a sorting
5849 static struct z_candidate *
5850 tourney (struct z_candidate *candidates)
5852 struct z_candidate *champ = candidates, *challenger;
5854 int champ_compared_to_predecessor = 0;
5856 /* Walk through the list once, comparing each current champ to the next
5857 candidate, knocking out a candidate or two with each comparison. */
5859 for (challenger = champ->next; challenger; )
5861 fate = joust (champ, challenger, 0);
5863 challenger = challenger->next;
5868 champ = challenger->next;
5871 champ_compared_to_predecessor = 0;
5876 champ_compared_to_predecessor = 1;
5879 challenger = champ->next;
5883 /* Make sure the champ is better than all the candidates it hasn't yet
5884 been compared to. */
5886 for (challenger = candidates;
5888 && !(champ_compared_to_predecessor && challenger->next == champ);
5889 challenger = challenger->next)
5891 fate = joust (champ, challenger, 0);
5899 /* Returns nonzero if things of type FROM can be converted to TO. */
5902 can_convert (tree to, tree from)
5904 return can_convert_arg (to, from, NULL_TREE);
5907 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
5910 can_convert_arg (tree to, tree from, tree arg)
5912 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
5913 return (t && ! ICS_BAD_FLAG (t));
5916 /* Like can_convert_arg, but allows dubious conversions as well. */
5919 can_convert_arg_bad (tree to, tree from, tree arg)
5921 return implicit_conversion (to, from, arg, LOOKUP_NORMAL) != 0;
5924 /* Convert EXPR to TYPE. Return the converted expression.
5926 Note that we allow bad conversions here because by the time we get to
5927 this point we are committed to doing the conversion. If we end up
5928 doing a bad conversion, convert_like will complain. */
5931 perform_implicit_conversion (tree type, tree expr)
5935 if (error_operand_p (expr))
5936 return error_mark_node;
5937 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
5941 error ("could not convert `%E' to `%T'", expr, type);
5942 return error_mark_node;
5945 return convert_like (conv, expr);
5948 /* Convert EXPR to TYPE (as a direct-initialization) if that is
5949 permitted. If the conversion is valid, the converted expression is
5950 returned. Otherwise, NULL_TREE is returned. */
5953 perform_direct_initialization_if_possible (tree type, tree expr)
5957 if (type == error_mark_node || error_operand_p (expr))
5958 return error_mark_node;
5959 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
5961 if (!conv || ICS_BAD_FLAG (conv))
5963 return convert_like_real (conv, expr, NULL_TREE, 0, 0,
5964 /*issue_conversion_warnings=*/false);
5967 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
5968 is being bound to a temporary. Create and return a new VAR_DECL
5969 with the indicated TYPE; this variable will store the value to
5970 which the reference is bound. */
5973 make_temporary_var_for_ref_to_temp (tree decl, tree type)
5977 /* Create the variable. */
5978 var = build_decl (VAR_DECL, NULL_TREE, type);
5979 DECL_ARTIFICIAL (var) = 1;
5980 TREE_USED (var) = 1;
5982 /* Register the variable. */
5983 if (TREE_STATIC (decl))
5985 /* Namespace-scope or local static; give it a mangled name. */
5988 TREE_STATIC (var) = 1;
5989 name = mangle_ref_init_variable (decl);
5990 DECL_NAME (var) = name;
5991 SET_DECL_ASSEMBLER_NAME (var, name);
5992 var = pushdecl_top_level (var);
5996 /* Create a new cleanup level if necessary. */
5997 maybe_push_cleanup_level (type);
5998 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
5999 DECL_CONTEXT (var) = current_function_decl;
6005 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6006 initializing a variable of that TYPE. If DECL is non-NULL, it is
6007 the VAR_DECL being initialized with the EXPR. (In that case, the
6008 type of DECL will be TYPE.)
6010 Return the converted expression. */
6013 initialize_reference (tree type, tree expr, tree decl)
6017 if (type == error_mark_node || error_operand_p (expr))
6018 return error_mark_node;
6020 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6021 if (!conv || ICS_BAD_FLAG (conv))
6023 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6024 && !real_lvalue_p (expr))
6025 error ("invalid initialization of non-const reference of "
6026 "type '%T' from a temporary of type '%T'",
6027 type, TREE_TYPE (expr));
6029 error ("could not convert `%E' to `%T'", expr, type);
6030 return error_mark_node;
6033 /* If DECL is non-NULL, then this special rule applies:
6037 The temporary to which the reference is bound or the temporary
6038 that is the complete object to which the reference is bound
6039 persists for the lifetime of the reference.
6041 The temporaries created during the evaluation of the expression
6042 initializing the reference, except the temporary to which the
6043 reference is bound, are destroyed at the end of the
6044 full-expression in which they are created.
6046 In that case, we store the converted expression into a new
6047 VAR_DECL in a new scope.
6049 However, we want to be careful not to create temporaries when
6050 they are not required. For example, given:
6053 struct D : public B {};
6057 there is no need to copy the return value from "f"; we can just
6058 extend its lifetime. Similarly, given:
6061 struct T { operator S(); };
6065 we can extend the lifetime of the return value of the conversion
6067 my_friendly_assert (TREE_CODE (conv) == REF_BIND, 20030302);
6071 tree base_conv_type;
6073 /* Skip over the REF_BIND. */
6074 conv = TREE_OPERAND (conv, 0);
6075 /* If the next conversion is a BASE_CONV, skip that too -- but
6076 remember that the conversion was required. */
6077 if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv))
6079 base_conv_type = TREE_TYPE (conv);
6080 conv = TREE_OPERAND (conv, 0);
6083 base_conv_type = NULL_TREE;
6084 /* Perform the remainder of the conversion. */
6085 expr = convert_like (conv, expr);
6086 if (!real_non_cast_lvalue_p (expr))
6091 /* Create the temporary variable. */
6092 type = TREE_TYPE (expr);
6093 var = make_temporary_var_for_ref_to_temp (decl, type);
6094 layout_decl (var, 0);
6095 if (at_function_scope_p ())
6099 add_decl_stmt (var);
6100 cleanup = cxx_maybe_build_cleanup (var);
6102 finish_decl_cleanup (var, cleanup);
6106 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6107 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6108 static_aggregates = tree_cons (NULL_TREE, var,
6111 init = build (INIT_EXPR, type, var, expr);
6112 /* Use its address to initialize the reference variable. */
6113 expr = build_address (var);
6114 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6117 /* Take the address of EXPR. */
6118 expr = build_unary_op (ADDR_EXPR, expr, 0);
6119 /* If a BASE_CONV was required, perform it now. */
6121 expr = (perform_implicit_conversion
6122 (build_pointer_type (base_conv_type), expr));
6123 return build_nop (type, expr);
6126 /* Perform the conversion. */
6127 return convert_like (conv, expr);
6130 #include "gt-cp-call.h"