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"
41 static tree build_field_call (tree, tree, tree);
42 static struct z_candidate * tourney (struct z_candidate *);
43 static int equal_functions (tree, tree);
44 static int joust (struct z_candidate *, struct z_candidate *, bool);
45 static int compare_ics (tree, tree);
46 static tree build_over_call (struct z_candidate *, int);
47 static tree build_java_interface_fn_ref (tree, tree);
48 #define convert_like(CONV, EXPR) \
49 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0)
50 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
51 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0)
52 static tree convert_like_real (tree, tree, tree, int, int);
53 static void op_error (enum tree_code, enum tree_code, tree, tree,
55 static tree build_object_call (tree, tree);
56 static tree resolve_args (tree);
57 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
58 static void print_z_candidate (const char *, struct z_candidate *);
59 static void print_z_candidates (struct z_candidate *);
60 static tree build_this (tree);
61 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
62 static bool any_strictly_viable (struct z_candidate *);
63 static struct z_candidate *add_template_candidate
64 (struct z_candidate **, tree, tree, tree, tree, tree,
65 tree, tree, int, unification_kind_t);
66 static struct z_candidate *add_template_candidate_real
67 (struct z_candidate **, tree, tree, tree, tree, tree,
68 tree, tree, int, tree, unification_kind_t);
69 static struct z_candidate *add_template_conv_candidate
70 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
71 static void add_builtin_candidates
72 (struct z_candidate **, enum tree_code, enum tree_code,
74 static void add_builtin_candidate
75 (struct z_candidate **, enum tree_code, enum tree_code,
76 tree, tree, tree, tree *, tree *, int);
77 static bool is_complete (tree);
78 static void build_builtin_candidate
79 (struct z_candidate **, tree, tree, tree, tree *, tree *,
81 static struct z_candidate *add_conv_candidate
82 (struct z_candidate **, tree, tree, tree, tree, tree);
83 static struct z_candidate *add_function_candidate
84 (struct z_candidate **, tree, tree, tree, tree, tree, int);
85 static tree implicit_conversion (tree, tree, tree, int);
86 static tree standard_conversion (tree, tree, tree);
87 static tree reference_binding (tree, tree, tree, int);
88 static tree non_reference (tree);
89 static tree build_conv (enum tree_code, tree, tree);
90 static bool is_subseq (tree, tree);
91 static tree maybe_handle_ref_bind (tree *);
92 static void maybe_handle_implicit_object (tree *);
93 static struct z_candidate *add_candidate
94 (struct z_candidate **, tree, tree, tree, tree, tree, int);
95 static tree source_type (tree);
96 static void add_warning (struct z_candidate *, struct z_candidate *);
97 static bool reference_related_p (tree, tree);
98 static bool reference_compatible_p (tree, tree);
99 static tree convert_class_to_reference (tree, tree, tree);
100 static tree direct_reference_binding (tree, tree);
101 static bool promoted_arithmetic_type_p (tree);
102 static tree conditional_conversion (tree, tree);
103 static char *name_as_c_string (tree, tree, bool *);
104 static tree call_builtin_trap (void);
105 static tree prep_operand (tree);
106 static void add_candidates (tree, tree, tree, bool, tree, tree,
107 int, struct z_candidate **);
108 static tree merge_conversion_sequences (tree, tree);
111 build_vfield_ref (tree datum, tree type)
113 if (datum == error_mark_node)
114 return error_mark_node;
116 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
117 datum = convert_from_reference (datum);
119 if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
120 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
121 datum = convert_to_base (datum, type, /*check_access=*/false);
123 return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
124 datum, TYPE_VFIELD (type));
127 /* Build a call to a member of an object. I.e., one that overloads
128 operator ()(), or is a pointer-to-function or pointer-to-method. */
131 build_field_call (tree instance_ptr, tree decl, tree parms)
135 if (decl == error_mark_node || decl == NULL_TREE)
138 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
140 /* If it's a field, try overloading operator (),
141 or calling if the field is a pointer-to-function. */
142 instance = build_indirect_ref (instance_ptr, NULL);
143 instance = build_class_member_access_expr (instance, decl,
144 /*access_path=*/NULL_TREE,
145 /*preserve_reference=*/false);
147 if (instance == error_mark_node)
148 return error_mark_node;
150 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
151 return build_new_op (CALL_EXPR, LOOKUP_NORMAL,
152 instance, parms, NULL_TREE);
153 else if (TREE_CODE (TREE_TYPE (instance)) == FUNCTION_TYPE
154 || (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE
155 && (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
157 return build_function_call (instance, parms);
163 /* Returns nonzero iff the destructor name specified in NAME
164 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
168 check_dtor_name (tree basetype, tree name)
170 name = TREE_OPERAND (name, 0);
172 /* Just accept something we've already complained about. */
173 if (name == error_mark_node)
176 if (TREE_CODE (name) == TYPE_DECL)
177 name = TREE_TYPE (name);
178 else if (TYPE_P (name))
180 else if (TREE_CODE (name) == IDENTIFIER_NODE)
182 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
183 || (TREE_CODE (basetype) == ENUMERAL_TYPE
184 && name == TYPE_IDENTIFIER (basetype)))
187 name = get_type_value (name);
191 template <class T> struct S { ~S(); };
195 NAME will be a class template. */
196 else if (DECL_CLASS_TEMPLATE_P (name))
201 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
206 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
207 This is how virtual function calls are avoided. */
210 build_scoped_method_call (tree exp, tree basetype, tree name, tree parms)
212 /* Because this syntactic form does not allow
213 a pointer to a base class to be `stolen',
214 we need not protect the derived->base conversion
217 @@ But we do have to check access privileges later. */
219 tree type = TREE_TYPE (exp);
221 if (type == error_mark_node
222 || basetype == error_mark_node)
223 return error_mark_node;
225 if (processing_template_decl)
227 name = build_min_nt (SCOPE_REF, basetype, name);
228 return build_min_nt (METHOD_CALL_EXPR, name, exp, parms, NULL_TREE);
231 if (TREE_CODE (type) == REFERENCE_TYPE)
232 type = TREE_TYPE (type);
234 if (TREE_CODE (basetype) == TREE_VEC)
237 basetype = BINFO_TYPE (binfo);
242 /* Check the destructor call syntax. */
243 if (TREE_CODE (name) == BIT_NOT_EXPR)
245 /* We can get here if someone writes their destructor call like
246 `obj.NS::~T()'; this isn't really a scoped method call, so hand
248 if (TREE_CODE (basetype) == NAMESPACE_DECL)
249 return build_method_call (exp, name, parms, NULL_TREE, LOOKUP_NORMAL);
251 if (! check_dtor_name (basetype, name))
252 error ("qualified type `%T' does not match destructor name `~%T'",
253 basetype, TREE_OPERAND (name, 0));
255 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
256 that explicit ~int is caught in the parser; this deals with typedefs
257 and template parms. */
258 if (! IS_AGGR_TYPE (basetype))
260 if (TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (basetype))
261 error ("type of `%E' does not match destructor type `%T' (type was `%T')",
262 exp, basetype, type);
264 return cp_convert (void_type_node, exp);
268 if (TREE_CODE (basetype) == NAMESPACE_DECL)
270 error ("`%D' is a namespace", basetype);
271 return error_mark_node;
273 if (! is_aggr_type (basetype, 1))
274 return error_mark_node;
276 if (! IS_AGGR_TYPE (type))
278 error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
280 return error_mark_node;
283 decl = build_scoped_ref (exp, basetype, &binfo);
287 /* Call to a destructor. */
288 if (TREE_CODE (name) == BIT_NOT_EXPR)
290 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl)))
291 return cp_convert (void_type_node, exp);
293 return build_delete (TREE_TYPE (decl), decl,
294 sfk_complete_destructor,
295 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR,
299 /* Call to a method. */
300 return build_method_call (decl, name, parms, binfo,
301 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
303 return error_mark_node;
306 /* We want the address of a function or method. We avoid creating a
307 pointer-to-member function. */
310 build_addr_func (tree function)
312 tree type = TREE_TYPE (function);
314 /* We have to do these by hand to avoid real pointer to member
316 if (TREE_CODE (type) == METHOD_TYPE)
320 type = build_pointer_type (type);
322 if (!cxx_mark_addressable (function))
323 return error_mark_node;
325 addr = build1 (ADDR_EXPR, type, function);
327 /* Address of a static or external variable or function counts
329 if (staticp (function))
330 TREE_CONSTANT (addr) = 1;
335 function = default_conversion (function);
340 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
341 POINTER_TYPE to those. Note, pointer to member function types
342 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
345 build_call (tree function, tree parms)
347 int is_constructor = 0;
354 function = build_addr_func (function);
356 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
358 sorry ("unable to call pointer to member function here");
359 return error_mark_node;
362 fntype = TREE_TYPE (TREE_TYPE (function));
363 result_type = TREE_TYPE (fntype);
365 if (TREE_CODE (function) == ADDR_EXPR
366 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
367 decl = TREE_OPERAND (function, 0);
371 /* We check both the decl and the type; a function may be known not to
372 throw without being declared throw(). */
373 nothrow = ((decl && TREE_NOTHROW (decl))
374 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
376 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
377 current_function_returns_abnormally = 1;
379 if (decl && TREE_DEPRECATED (decl))
380 warn_deprecated_use (decl);
381 require_complete_eh_spec_types (fntype, decl);
383 if (decl && DECL_CONSTRUCTOR_P (decl))
386 if (decl && ! TREE_USED (decl))
388 /* We invoke build_call directly for several library functions.
389 These may have been declared normally if we're building libgcc,
390 so we can't just check DECL_ARTIFICIAL. */
391 if (DECL_ARTIFICIAL (decl)
392 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
398 /* Don't pass empty class objects by value. This is useful
399 for tags in STL, which are used to control overload resolution.
400 We don't need to handle other cases of copying empty classes. */
401 if (! decl || ! DECL_BUILT_IN (decl))
402 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
403 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
404 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
406 tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
407 TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
408 TREE_VALUE (tmp), t);
411 function = build_nt (CALL_EXPR, function, parms, NULL_TREE);
412 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
413 TREE_TYPE (function) = result_type;
414 TREE_SIDE_EFFECTS (function) = 1;
415 TREE_NOTHROW (function) = nothrow;
420 /* Build something of the form ptr->method (args)
421 or object.method (args). This can also build
422 calls to constructors, and find friends.
424 Member functions always take their class variable
427 INSTANCE is a class instance.
429 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
431 PARMS help to figure out what that NAME really refers to.
433 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
434 down to the real instance type to use for access checking. We need this
435 information to get protected accesses correct. This parameter is used
436 by build_member_call.
438 FLAGS is the logical disjunction of zero or more LOOKUP_
439 flags. See cp-tree.h for more info.
441 If this is all OK, calls build_function_call with the resolved
444 This function must also handle being called to perform
445 initialization, promotion/coercion of arguments, and
446 instantiation of default parameters.
448 Note that NAME may refer to an instance variable name. If
449 `operator()()' is defined for the type of that field, then we return
452 #ifdef GATHER_STATISTICS
453 extern int n_build_method_call;
457 build_method_call (tree instance, tree name, tree parms,
458 tree basetype_path, int flags)
462 tree template_args = NULL_TREE;
463 bool has_template_args = false;
465 #ifdef GATHER_STATISTICS
466 n_build_method_call++;
469 if (instance == error_mark_node
470 || name == error_mark_node
471 || parms == error_mark_node
472 || (instance && TREE_TYPE (instance) == error_mark_node))
473 return error_mark_node;
475 if (processing_template_decl)
476 return build_min_nt (METHOD_CALL_EXPR, name, instance, parms, NULL_TREE);
478 if (TREE_CODE (instance) == OFFSET_REF)
479 instance = resolve_offset_ref (instance);
480 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
481 instance = convert_from_reference (instance);
482 object_type = TREE_TYPE (instance);
484 if (TREE_CODE (name) == BIT_NOT_EXPR)
489 error ("destructors take no parameters");
491 if (! check_dtor_name (object_type, name))
493 ("destructor name `~%T' does not match type `%T' of expression",
494 TREE_OPERAND (name, 0), object_type);
496 if (! TYPE_HAS_DESTRUCTOR (complete_type (object_type)))
497 return cp_convert (void_type_node, instance);
498 instance = default_conversion (instance);
499 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
500 return build_delete (build_pointer_type (object_type),
501 instance_ptr, sfk_complete_destructor,
502 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
505 if (!CLASS_TYPE_P (object_type))
507 if ((flags & LOOKUP_COMPLAIN)
508 && TREE_TYPE (instance) != error_mark_node)
509 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
510 name, instance, object_type);
511 return error_mark_node;
514 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
516 template_args = TREE_OPERAND (name, 1);
517 has_template_args = true;
518 name = TREE_OPERAND (name, 0);
520 if (TREE_CODE (name) == OVERLOAD)
521 name = DECL_NAME (get_first_fn (name));
522 else if (DECL_P (name))
523 name = DECL_NAME (name);
524 if (has_template_args)
525 fn = lookup_fnfields (object_type, name, /*protect=*/2);
527 fn = lookup_member (object_type, name, /*protect=*/2, /*want_type=*/false);
529 if (fn && TREE_CODE (fn) == TREE_LIST && !BASELINK_P (fn))
531 error ("request for member `%D' is ambiguous", name);
532 print_candidates (fn);
533 return error_mark_node;
536 /* If the name could not be found, issue an error. */
539 unqualified_name_lookup_error (name);
540 return error_mark_node;
543 if (BASELINK_P (fn) && has_template_args)
544 BASELINK_FUNCTIONS (fn)
545 = build_nt (TEMPLATE_ID_EXPR,
546 BASELINK_FUNCTIONS (fn),
548 if (BASELINK_P (fn) && basetype_path)
549 BASELINK_ACCESS_BINFO (fn) = basetype_path;
551 return build_new_method_call (instance, fn, parms,
552 /*conversion_path=*/NULL_TREE, flags);
555 /* New overloading code. */
557 struct z_candidate GTY(()) {
558 /* The FUNCTION_DECL that will be called if this candidate is
559 selected by overload resolution. */
561 /* The arguments to use when calling this function. */
563 /* The implicit conversion sequences for each of the arguments to
566 /* If FN is a user-defined conversion, the standard conversion
567 sequence from the type returned by FN to the desired destination
571 /* If FN is a member function, the binfo indicating the path used to
572 qualify the name of FN at the call site. This path is used to
573 determine whether or not FN is accessible if it is selected by
574 overload resolution. The DECL_CONTEXT of FN will always be a
575 (possibly improper) base of this binfo. */
577 /* If FN is a non-static member function, the binfo indicating the
578 subobject to which the `this' pointer should be converted if FN
579 is selected by overload resolution. The type pointed to the by
580 the `this' pointer must correspond to the most derived class
581 indicated by the CONVERSION_PATH. */
582 tree conversion_path;
585 struct z_candidate *next;
588 #define IDENTITY_RANK 0
594 #define ELLIPSIS_RANK 6
597 #define ICS_RANK(NODE) \
598 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
599 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
600 : ICS_USER_FLAG (NODE) ? USER_RANK \
601 : ICS_STD_RANK (NODE))
603 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
605 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
606 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
607 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
608 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
610 /* In a REF_BIND or a BASE_CONV, this indicates that a temporary
611 should be created to hold the result of the conversion. */
612 #define NEED_TEMPORARY_P(NODE) TREE_LANG_FLAG_4 (NODE)
614 #define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1))
615 #define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
618 null_ptr_cst_p (tree t)
622 A null pointer constant is an integral constant expression
623 (_expr.const_) rvalue of integer type that evaluates to zero. */
625 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
631 /* Returns nonzero if PARMLIST consists of only default parms and/or
635 sufficient_parms_p (tree parmlist)
637 for (; parmlist && parmlist != void_list_node;
638 parmlist = TREE_CHAIN (parmlist))
639 if (!TREE_PURPOSE (parmlist))
645 build_conv (enum tree_code code, tree type, tree from)
648 int rank = ICS_STD_RANK (from);
650 /* We can't use buildl1 here because CODE could be USER_CONV, which
651 takes two arguments. In that case, the caller is responsible for
652 filling in the second argument. */
653 t = make_node (code);
654 TREE_TYPE (t) = type;
655 TREE_OPERAND (t, 0) = from;
668 if (rank < EXACT_RANK)
674 ICS_STD_RANK (t) = rank;
675 ICS_USER_FLAG (t) = (code == USER_CONV || ICS_USER_FLAG (from));
676 ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);
680 /* If T is a REFERENCE_TYPE return the type to which T refers.
681 Otherwise, return T itself. */
684 non_reference (tree t)
686 if (TREE_CODE (t) == REFERENCE_TYPE)
692 strip_top_quals (tree t)
694 if (TREE_CODE (t) == ARRAY_TYPE)
696 return TYPE_MAIN_VARIANT (t);
699 /* Returns the standard conversion path (see [conv]) from type FROM to type
700 TO, if any. For proper handling of null pointer constants, you must
701 also pass the expression EXPR to convert from. */
704 standard_conversion (tree to, tree from, tree expr)
706 enum tree_code fcode, tcode;
708 bool fromref = false;
710 if (TREE_CODE (to) == REFERENCE_TYPE)
712 if (TREE_CODE (from) == REFERENCE_TYPE)
715 from = TREE_TYPE (from);
717 to = strip_top_quals (to);
718 from = strip_top_quals (from);
720 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
721 && expr && type_unknown_p (expr))
723 expr = instantiate_type (to, expr, tf_none);
724 if (expr == error_mark_node)
726 from = TREE_TYPE (expr);
729 fcode = TREE_CODE (from);
730 tcode = TREE_CODE (to);
732 conv = build1 (IDENTITY_CONV, from, expr);
734 if (fcode == FUNCTION_TYPE)
736 from = build_pointer_type (from);
737 fcode = TREE_CODE (from);
738 conv = build_conv (LVALUE_CONV, from, conv);
740 else if (fcode == ARRAY_TYPE)
742 from = build_pointer_type (TREE_TYPE (from));
743 fcode = TREE_CODE (from);
744 conv = build_conv (LVALUE_CONV, from, conv);
746 else if (fromref || (expr && lvalue_p (expr)))
747 conv = build_conv (RVALUE_CONV, from, conv);
749 /* Allow conversion between `__complex__' data types */
750 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
752 /* The standard conversion sequence to convert FROM to TO is
753 the standard conversion sequence to perform componentwise
755 tree part_conv = standard_conversion
756 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
760 conv = build_conv (TREE_CODE (part_conv), to, conv);
761 ICS_STD_RANK (conv) = ICS_STD_RANK (part_conv);
769 if (same_type_p (from, to))
772 if ((tcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (to))
773 && expr && null_ptr_cst_p (expr))
775 conv = build_conv (STD_CONV, to, conv);
777 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
778 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
780 /* For backwards brain damage compatibility, allow interconversion of
781 pointers and integers with a pedwarn. */
782 conv = build_conv (STD_CONV, to, conv);
783 ICS_BAD_FLAG (conv) = 1;
785 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE
786 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
788 /* For backwards brain damage compatibility, allow interconversion of
789 enums and integers with a pedwarn. */
790 conv = build_conv (STD_CONV, to, conv);
791 ICS_BAD_FLAG (conv) = 1;
793 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE)
795 enum tree_code ufcode = TREE_CODE (TREE_TYPE (from));
796 enum tree_code utcode = TREE_CODE (TREE_TYPE (to));
798 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
801 else if (utcode == VOID_TYPE && ufcode != OFFSET_TYPE
802 && ufcode != FUNCTION_TYPE)
804 from = build_pointer_type
805 (cp_build_qualified_type (void_type_node,
806 cp_type_quals (TREE_TYPE (from))));
807 conv = build_conv (PTR_CONV, from, conv);
809 else if (ufcode == OFFSET_TYPE && utcode == OFFSET_TYPE)
811 tree fbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (from));
812 tree tbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (to));
814 if (DERIVED_FROM_P (fbase, tbase)
815 && (same_type_ignoring_top_level_qualifiers_p
816 (TREE_TYPE (TREE_TYPE (from)),
817 TREE_TYPE (TREE_TYPE (to)))))
819 from = build_ptrmem_type (tbase, TREE_TYPE (TREE_TYPE (from)));
820 conv = build_conv (PMEM_CONV, from, conv);
823 else if (IS_AGGR_TYPE (TREE_TYPE (from))
824 && IS_AGGR_TYPE (TREE_TYPE (to)))
826 if (DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
829 cp_build_qualified_type (TREE_TYPE (to),
830 cp_type_quals (TREE_TYPE (from)));
831 from = build_pointer_type (from);
832 conv = build_conv (PTR_CONV, from, conv);
836 if (same_type_p (from, to))
838 else if (comp_ptr_ttypes (TREE_TYPE (to), TREE_TYPE (from)))
839 conv = build_conv (QUAL_CONV, to, conv);
840 else if (expr && string_conv_p (to, expr, 0))
841 /* converting from string constant to char *. */
842 conv = build_conv (QUAL_CONV, to, conv);
843 else if (ptr_reasonably_similar (TREE_TYPE (to), TREE_TYPE (from)))
845 conv = build_conv (PTR_CONV, to, conv);
846 ICS_BAD_FLAG (conv) = 1;
853 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
855 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
856 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
857 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
858 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
860 if (!DERIVED_FROM_P (fbase, tbase)
861 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
862 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
863 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
864 || cp_type_quals (fbase) != cp_type_quals (tbase))
867 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
868 from = build_cplus_method_type (from, TREE_TYPE (fromfn),
869 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
870 from = build_ptrmemfunc_type (build_pointer_type (from));
871 conv = build_conv (PMEM_CONV, from, conv);
873 else if (tcode == BOOLEAN_TYPE)
875 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE
876 || fcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (from)))
879 conv = build_conv (STD_CONV, to, conv);
880 if (fcode == POINTER_TYPE
881 || (TYPE_PTRMEMFUNC_P (from) && ICS_STD_RANK (conv) < PBOOL_RANK))
882 ICS_STD_RANK (conv) = PBOOL_RANK;
884 /* We don't check for ENUMERAL_TYPE here because there are no standard
885 conversions to enum type. */
886 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
887 || tcode == REAL_TYPE)
889 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
891 conv = build_conv (STD_CONV, to, conv);
893 /* Give this a better rank if it's a promotion. */
894 if (to == type_promotes_to (from)
895 && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK)
896 ICS_STD_RANK (conv) = PROMO_RANK;
898 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
899 && is_properly_derived_from (from, to))
901 if (TREE_CODE (conv) == RVALUE_CONV)
902 conv = TREE_OPERAND (conv, 0);
903 conv = build_conv (BASE_CONV, to, conv);
904 /* The derived-to-base conversion indicates the initialization
905 of a parameter with base type from an object of a derived
906 type. A temporary object is created to hold the result of
908 NEED_TEMPORARY_P (conv) = 1;
916 /* Returns nonzero if T1 is reference-related to T2. */
919 reference_related_p (tree t1, tree t2)
921 t1 = TYPE_MAIN_VARIANT (t1);
922 t2 = TYPE_MAIN_VARIANT (t2);
926 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
927 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
929 return (same_type_p (t1, t2)
930 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
931 && DERIVED_FROM_P (t1, t2)));
934 /* Returns nonzero if T1 is reference-compatible with T2. */
937 reference_compatible_p (tree t1, tree t2)
941 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
942 reference-related to T2 and cv1 is the same cv-qualification as,
943 or greater cv-qualification than, cv2. */
944 return (reference_related_p (t1, t2)
945 && at_least_as_qualified_p (t1, t2));
948 /* Determine whether or not the EXPR (of class type S) can be
949 converted to T as in [over.match.ref]. */
952 convert_class_to_reference (tree t, tree s, tree expr)
958 struct z_candidate *candidates;
959 struct z_candidate *cand;
962 conversions = lookup_conversions (s);
968 Assuming that "cv1 T" is the underlying type of the reference
969 being initialized, and "cv S" is the type of the initializer
970 expression, with S a class type, the candidate functions are
973 --The conversion functions of S and its base classes are
974 considered. Those that are not hidden within S and yield type
975 "reference to cv2 T2", where "cv1 T" is reference-compatible
976 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
978 The argument list has one argument, which is the initializer
983 /* Conceptually, we should take the address of EXPR and put it in
984 the argument list. Unfortunately, however, that can result in
985 error messages, which we should not issue now because we are just
986 trying to find a conversion operator. Therefore, we use NULL,
987 cast to the appropriate type. */
988 arglist = build_int_2 (0, 0);
989 TREE_TYPE (arglist) = build_pointer_type (s);
990 arglist = build_tree_list (NULL_TREE, arglist);
992 reference_type = build_reference_type (t);
996 tree fns = TREE_VALUE (conversions);
998 for (; fns; fns = OVL_NEXT (fns))
1000 tree f = OVL_CURRENT (fns);
1001 tree t2 = TREE_TYPE (TREE_TYPE (f));
1005 /* If this is a template function, try to get an exact
1007 if (TREE_CODE (f) == TEMPLATE_DECL)
1009 cand = add_template_candidate (&candidates,
1015 TREE_PURPOSE (conversions),
1021 /* Now, see if the conversion function really returns
1022 an lvalue of the appropriate type. From the
1023 point of view of unification, simply returning an
1024 rvalue of the right type is good enough. */
1026 t2 = TREE_TYPE (TREE_TYPE (f));
1027 if (TREE_CODE (t2) != REFERENCE_TYPE
1028 || !reference_compatible_p (t, TREE_TYPE (t2)))
1030 candidates = candidates->next;
1035 else if (TREE_CODE (t2) == REFERENCE_TYPE
1036 && reference_compatible_p (t, TREE_TYPE (t2)))
1037 cand = add_function_candidate (&candidates, f, s, arglist,
1039 TREE_PURPOSE (conversions),
1043 /* Build a standard conversion sequence indicating the
1044 binding from the reference type returned by the
1045 function to the desired REFERENCE_TYPE. */
1047 = (direct_reference_binding
1049 build1 (IDENTITY_CONV,
1050 TREE_TYPE (TREE_TYPE (TREE_TYPE (cand->fn))),
1053 conversions = TREE_CHAIN (conversions);
1056 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1057 /* If none of the conversion functions worked out, let our caller
1062 cand = tourney (candidates);
1066 /* Now that we know that this is the function we're going to use fix
1067 the dummy first argument. */
1068 cand->args = tree_cons (NULL_TREE,
1070 TREE_CHAIN (cand->args));
1072 /* Build a user-defined conversion sequence representing the
1074 conv = build_conv (USER_CONV,
1075 TREE_TYPE (TREE_TYPE (cand->fn)),
1076 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
1077 TREE_OPERAND (conv, 1) = build_zc_wrapper (cand);
1079 /* Merge it with the standard conversion sequence from the
1080 conversion function's return type to the desired type. */
1081 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1083 if (cand->viable == -1)
1084 ICS_BAD_FLAG (conv) = 1;
1086 return cand->second_conv;
1089 /* A reference of the indicated TYPE is being bound directly to the
1090 expression represented by the implicit conversion sequence CONV.
1091 Return a conversion sequence for this binding. */
1094 direct_reference_binding (tree type, tree conv)
1098 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
1099 my_friendly_assert (TREE_CODE (TREE_TYPE (conv)) != REFERENCE_TYPE,
1102 t = TREE_TYPE (type);
1106 When a parameter of reference type binds directly
1107 (_dcl.init.ref_) to an argument expression, the implicit
1108 conversion sequence is the identity conversion, unless the
1109 argument expression has a type that is a derived class of the
1110 parameter type, in which case the implicit conversion sequence is
1111 a derived-to-base Conversion.
1113 If the parameter binds directly to the result of applying a
1114 conversion function to the argument expression, the implicit
1115 conversion sequence is a user-defined conversion sequence
1116 (_over.ics.user_), with the second standard conversion sequence
1117 either an identity conversion or, if the conversion function
1118 returns an entity of a type that is a derived class of the
1119 parameter type, a derived-to-base conversion. */
1120 if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv)))
1122 /* Represent the derived-to-base conversion. */
1123 conv = build_conv (BASE_CONV, t, conv);
1124 /* We will actually be binding to the base-class subobject in
1125 the derived class, so we mark this conversion appropriately.
1126 That way, convert_like knows not to generate a temporary. */
1127 NEED_TEMPORARY_P (conv) = 0;
1129 return build_conv (REF_BIND, type, conv);
1132 /* Returns the conversion path from type FROM to reference type TO for
1133 purposes of reference binding. For lvalue binding, either pass a
1134 reference type to FROM or an lvalue expression to EXPR. If the
1135 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1136 the conversion returned. */
1139 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1141 tree conv = NULL_TREE;
1142 tree to = TREE_TYPE (rto);
1146 cp_lvalue_kind lvalue_p = clk_none;
1148 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1150 expr = instantiate_type (to, expr, tf_none);
1151 if (expr == error_mark_node)
1153 from = TREE_TYPE (expr);
1156 if (TREE_CODE (from) == REFERENCE_TYPE)
1158 /* Anything with reference type is an lvalue. */
1159 lvalue_p = clk_ordinary;
1160 from = TREE_TYPE (from);
1163 lvalue_p = real_lvalue_p (expr);
1165 /* Figure out whether or not the types are reference-related and
1166 reference compatible. We have do do this after stripping
1167 references from FROM. */
1168 related_p = reference_related_p (to, from);
1169 compatible_p = reference_compatible_p (to, from);
1171 if (lvalue_p && compatible_p)
1175 If the initializer expression
1177 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1178 is reference-compatible with "cv2 T2,"
1180 the reference is bound directly to the initializer exprssion
1182 conv = build1 (IDENTITY_CONV, from, expr);
1183 conv = direct_reference_binding (rto, conv);
1184 if ((lvalue_p & clk_bitfield) != 0
1185 && CP_TYPE_CONST_NON_VOLATILE_P (to))
1186 /* For the purposes of overload resolution, we ignore the fact
1187 this expression is a bitfield. (In particular,
1188 [over.ics.ref] says specifically that a function with a
1189 non-const reference parameter is viable even if the
1190 argument is a bitfield.)
1192 However, when we actually call the function we must create
1193 a temporary to which to bind the reference. If the
1194 reference is volatile, or isn't const, then we cannot make
1195 a temporary, so we just issue an error when the conversion
1197 NEED_TEMPORARY_P (conv) = 1;
1200 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1204 If the initializer exprsesion
1206 -- has a class type (i.e., T2 is a class type) can be
1207 implicitly converted to an lvalue of type "cv3 T3," where
1208 "cv1 T1" is reference-compatible with "cv3 T3". (this
1209 conversion is selected by enumerating the applicable
1210 conversion functions (_over.match.ref_) and choosing the
1211 best one through overload resolution. (_over.match_).
1213 the reference is bound to the lvalue result of the conversion
1214 in the second case. */
1215 conv = convert_class_to_reference (to, from, expr);
1220 /* From this point on, we conceptually need temporaries, even if we
1221 elide them. Only the cases above are "direct bindings". */
1222 if (flags & LOOKUP_NO_TEMP_BIND)
1227 When a parameter of reference type is not bound directly to an
1228 argument expression, the conversion sequence is the one required
1229 to convert the argument expression to the underlying type of the
1230 reference according to _over.best.ics_. Conceptually, this
1231 conversion sequence corresponds to copy-initializing a temporary
1232 of the underlying type with the argument expression. Any
1233 difference in top-level cv-qualification is subsumed by the
1234 initialization itself and does not constitute a conversion. */
1238 Otherwise, the reference shall be to a non-volatile const type. */
1239 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1244 If the initializer expression is an rvalue, with T2 a class type,
1245 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1246 is bound in one of the following ways:
1248 -- The reference is bound to the object represented by the rvalue
1249 or to a sub-object within that object.
1253 We use the first alternative. The implicit conversion sequence
1254 is supposed to be same as we would obtain by generating a
1255 temporary. Fortunately, if the types are reference compatible,
1256 then this is either an identity conversion or the derived-to-base
1257 conversion, just as for direct binding. */
1258 if (CLASS_TYPE_P (from) && compatible_p)
1260 conv = build1 (IDENTITY_CONV, from, expr);
1261 return direct_reference_binding (rto, conv);
1266 Otherwise, a temporary of type "cv1 T1" is created and
1267 initialized from the initializer expression using the rules for a
1268 non-reference copy initialization. If T1 is reference-related to
1269 T2, cv1 must be the same cv-qualification as, or greater
1270 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1271 if (related_p && !at_least_as_qualified_p (to, from))
1274 conv = implicit_conversion (to, from, expr, flags);
1278 conv = build_conv (REF_BIND, rto, conv);
1279 /* This reference binding, unlike those above, requires the
1280 creation of a temporary. */
1281 NEED_TEMPORARY_P (conv) = 1;
1286 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1287 to type TO. The optional expression EXPR may affect the conversion.
1288 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1292 implicit_conversion (tree to, tree from, tree expr, int flags)
1296 /* Resolve expressions like `A::p' that we thought might become
1297 pointers-to-members. */
1298 if (expr && TREE_CODE (expr) == OFFSET_REF)
1300 expr = resolve_offset_ref (expr);
1301 from = TREE_TYPE (expr);
1304 if (from == error_mark_node || to == error_mark_node
1305 || expr == error_mark_node)
1308 if (TREE_CODE (to) == REFERENCE_TYPE)
1309 conv = reference_binding (to, from, expr, flags);
1311 conv = standard_conversion (to, from, expr);
1316 if (expr != NULL_TREE
1317 && (IS_AGGR_TYPE (from)
1318 || IS_AGGR_TYPE (to))
1319 && (flags & LOOKUP_NO_CONVERSION) == 0)
1321 struct z_candidate *cand;
1323 cand = build_user_type_conversion_1
1324 (to, expr, LOOKUP_ONLYCONVERTING);
1326 conv = cand->second_conv;
1328 /* We used to try to bind a reference to a temporary here, but that
1329 is now handled by the recursive call to this function at the end
1330 of reference_binding. */
1337 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1340 static struct z_candidate *
1341 add_candidate (struct z_candidate **candidates,
1342 tree fn, tree args, tree convs, tree access_path,
1343 tree conversion_path, int viable)
1345 struct z_candidate *cand
1346 = (struct z_candidate *) ggc_alloc_cleared (sizeof (struct z_candidate));
1350 cand->convs = convs;
1351 cand->access_path = access_path;
1352 cand->conversion_path = conversion_path;
1353 cand->viable = viable;
1354 cand->next = *candidates;
1360 /* Create an overload candidate for the function or method FN called with
1361 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1362 to implicit_conversion.
1364 CTYPE, if non-NULL, is the type we want to pretend this function
1365 comes from for purposes of overload resolution. */
1367 static struct z_candidate *
1368 add_function_candidate (struct z_candidate **candidates,
1369 tree fn, tree ctype, tree arglist,
1370 tree access_path, tree conversion_path,
1373 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1376 tree parmnode, argnode;
1380 /* Built-in functions that haven't been declared don't really
1382 if (DECL_ANTICIPATED (fn))
1385 /* The `this', `in_chrg' and VTT arguments to constructors are not
1386 considered in overload resolution. */
1387 if (DECL_CONSTRUCTOR_P (fn))
1389 parmlist = skip_artificial_parms_for (fn, parmlist);
1390 orig_arglist = arglist;
1391 arglist = skip_artificial_parms_for (fn, arglist);
1394 orig_arglist = arglist;
1396 len = list_length (arglist);
1397 convs = make_tree_vec (len);
1399 /* 13.3.2 - Viable functions [over.match.viable]
1400 First, to be a viable function, a candidate function shall have enough
1401 parameters to agree in number with the arguments in the list.
1403 We need to check this first; otherwise, checking the ICSes might cause
1404 us to produce an ill-formed template instantiation. */
1406 parmnode = parmlist;
1407 for (i = 0; i < len; ++i)
1409 if (parmnode == NULL_TREE || parmnode == void_list_node)
1411 parmnode = TREE_CHAIN (parmnode);
1414 if (i < len && parmnode)
1417 /* Make sure there are default args for the rest of the parms. */
1418 else if (!sufficient_parms_p (parmnode))
1424 /* Second, for F to be a viable function, there shall exist for each
1425 argument an implicit conversion sequence that converts that argument
1426 to the corresponding parameter of F. */
1428 parmnode = parmlist;
1431 for (i = 0; i < len; ++i)
1433 tree arg = TREE_VALUE (argnode);
1434 tree argtype = lvalue_type (arg);
1438 if (parmnode == void_list_node)
1441 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1442 && ! DECL_CONSTRUCTOR_P (fn));
1446 tree parmtype = TREE_VALUE (parmnode);
1448 /* The type of the implicit object parameter ('this') for
1449 overload resolution is not always the same as for the
1450 function itself; conversion functions are considered to
1451 be members of the class being converted, and functions
1452 introduced by a using-declaration are considered to be
1453 members of the class that uses them.
1455 Since build_over_call ignores the ICS for the `this'
1456 parameter, we can just change the parm type. */
1457 if (ctype && is_this)
1460 = build_qualified_type (ctype,
1461 TYPE_QUALS (TREE_TYPE (parmtype)));
1462 parmtype = build_pointer_type (parmtype);
1465 t = implicit_conversion (parmtype, argtype, arg, flags);
1469 t = build1 (IDENTITY_CONV, argtype, arg);
1470 ICS_ELLIPSIS_FLAG (t) = 1;
1474 ICS_THIS_FLAG (t) = 1;
1476 TREE_VEC_ELT (convs, i) = t;
1483 if (ICS_BAD_FLAG (t))
1487 parmnode = TREE_CHAIN (parmnode);
1488 argnode = TREE_CHAIN (argnode);
1492 return add_candidate (candidates, fn, orig_arglist, convs, access_path,
1493 conversion_path, viable);
1496 /* Create an overload candidate for the conversion function FN which will
1497 be invoked for expression OBJ, producing a pointer-to-function which
1498 will in turn be called with the argument list ARGLIST, and add it to
1499 CANDIDATES. FLAGS is passed on to implicit_conversion.
1501 Actually, we don't really care about FN; we care about the type it
1502 converts to. There may be multiple conversion functions that will
1503 convert to that type, and we rely on build_user_type_conversion_1 to
1504 choose the best one; so when we create our candidate, we record the type
1505 instead of the function. */
1507 static struct z_candidate *
1508 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1509 tree arglist, tree access_path, tree conversion_path)
1511 tree totype = TREE_TYPE (TREE_TYPE (fn));
1512 int i, len, viable, flags;
1513 tree parmlist, convs, parmnode, argnode;
1515 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1516 parmlist = TREE_TYPE (parmlist);
1517 parmlist = TYPE_ARG_TYPES (parmlist);
1519 len = list_length (arglist) + 1;
1520 convs = make_tree_vec (len);
1521 parmnode = parmlist;
1524 flags = LOOKUP_NORMAL;
1526 /* Don't bother looking up the same type twice. */
1527 if (*candidates && (*candidates)->fn == totype)
1530 for (i = 0; i < len; ++i)
1532 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1533 tree argtype = lvalue_type (arg);
1537 t = implicit_conversion (totype, argtype, arg, flags);
1538 else if (parmnode == void_list_node)
1541 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1544 t = build1 (IDENTITY_CONV, argtype, arg);
1545 ICS_ELLIPSIS_FLAG (t) = 1;
1548 TREE_VEC_ELT (convs, i) = t;
1552 if (ICS_BAD_FLAG (t))
1559 parmnode = TREE_CHAIN (parmnode);
1560 argnode = TREE_CHAIN (argnode);
1566 if (!sufficient_parms_p (parmnode))
1569 return add_candidate (candidates, totype, arglist, convs, access_path,
1570 conversion_path, viable);
1574 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1575 tree type1, tree type2, tree *args, tree *argtypes,
1585 convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
1587 for (i = 0; i < 2; ++i)
1592 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1596 /* We need something for printing the candidate. */
1597 t = build1 (IDENTITY_CONV, types[i], NULL_TREE);
1599 else if (ICS_BAD_FLAG (t))
1601 TREE_VEC_ELT (convs, i) = t;
1604 /* For COND_EXPR we rearranged the arguments; undo that now. */
1607 TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1);
1608 TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0);
1609 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1611 TREE_VEC_ELT (convs, 0) = t;
1616 add_candidate (candidates, fnname, /*args=*/NULL_TREE, convs,
1617 /*access_path=*/NULL_TREE,
1618 /*conversion_path=*/NULL_TREE,
1623 is_complete (tree t)
1625 return COMPLETE_TYPE_P (complete_type (t));
1628 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1631 promoted_arithmetic_type_p (tree type)
1635 In this section, the term promoted integral type is used to refer
1636 to those integral types which are preserved by integral promotion
1637 (including e.g. int and long but excluding e.g. char).
1638 Similarly, the term promoted arithmetic type refers to promoted
1639 integral types plus floating types. */
1640 return ((INTEGRAL_TYPE_P (type)
1641 && same_type_p (type_promotes_to (type), type))
1642 || TREE_CODE (type) == REAL_TYPE);
1645 /* Create any builtin operator overload candidates for the operator in
1646 question given the converted operand types TYPE1 and TYPE2. The other
1647 args are passed through from add_builtin_candidates to
1648 build_builtin_candidate.
1650 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1651 If CODE is requires candidates operands of the same type of the kind
1652 of which TYPE1 and TYPE2 are, we add both candidates
1653 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1656 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1657 enum tree_code code2, tree fnname, tree type1,
1658 tree type2, tree *args, tree *argtypes, int flags)
1662 case POSTINCREMENT_EXPR:
1663 case POSTDECREMENT_EXPR:
1664 args[1] = integer_zero_node;
1665 type2 = integer_type_node;
1674 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1675 and VQ is either volatile or empty, there exist candidate operator
1676 functions of the form
1677 VQ T& operator++(VQ T&);
1678 T operator++(VQ T&, int);
1679 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1680 type other than bool, and VQ is either volatile or empty, there exist
1681 candidate operator functions of the form
1682 VQ T& operator--(VQ T&);
1683 T operator--(VQ T&, int);
1684 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1685 complete object type, and VQ is either volatile or empty, there exist
1686 candidate operator functions of the form
1687 T*VQ& operator++(T*VQ&);
1688 T*VQ& operator--(T*VQ&);
1689 T* operator++(T*VQ&, int);
1690 T* operator--(T*VQ&, int); */
1692 case POSTDECREMENT_EXPR:
1693 case PREDECREMENT_EXPR:
1694 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1696 case POSTINCREMENT_EXPR:
1697 case PREINCREMENT_EXPR:
1698 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1700 type1 = build_reference_type (type1);
1705 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1706 exist candidate operator functions of the form
1710 8 For every function type T, there exist candidate operator functions of
1712 T& operator*(T*); */
1715 if (TREE_CODE (type1) == POINTER_TYPE
1716 && (TYPE_PTROB_P (type1)
1717 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1721 /* 9 For every type T, there exist candidate operator functions of the form
1724 10For every promoted arithmetic type T, there exist candidate operator
1725 functions of the form
1729 case CONVERT_EXPR: /* unary + */
1730 if (TREE_CODE (type1) == POINTER_TYPE
1731 && TREE_CODE (TREE_TYPE (type1)) != OFFSET_TYPE)
1734 if (ARITHMETIC_TYPE_P (type1))
1738 /* 11For every promoted integral type T, there exist candidate operator
1739 functions of the form
1743 if (INTEGRAL_TYPE_P (type1))
1747 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1748 is the same type as C2 or is a derived class of C2, T is a complete
1749 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1750 there exist candidate operator functions of the form
1751 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1752 where CV12 is the union of CV1 and CV2. */
1755 if (TREE_CODE (type1) == POINTER_TYPE
1756 && (TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2)))
1758 tree c1 = TREE_TYPE (type1);
1759 tree c2 = (TYPE_PTRMEMFUNC_P (type2)
1760 ? TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2)))
1761 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2)));
1763 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1764 && (TYPE_PTRMEMFUNC_P (type2)
1765 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1770 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1771 didate operator functions of the form
1776 bool operator<(L, R);
1777 bool operator>(L, R);
1778 bool operator<=(L, R);
1779 bool operator>=(L, R);
1780 bool operator==(L, R);
1781 bool operator!=(L, R);
1782 where LR is the result of the usual arithmetic conversions between
1785 14For every pair of types T and I, where T is a cv-qualified or cv-
1786 unqualified complete object type and I is a promoted integral type,
1787 there exist candidate operator functions of the form
1788 T* operator+(T*, I);
1789 T& operator[](T*, I);
1790 T* operator-(T*, I);
1791 T* operator+(I, T*);
1792 T& operator[](I, T*);
1794 15For every T, where T is a pointer to complete object type, there exist
1795 candidate operator functions of the form112)
1796 ptrdiff_t operator-(T, T);
1798 16For every pointer or enumeration type T, there exist candidate operator
1799 functions of the form
1800 bool operator<(T, T);
1801 bool operator>(T, T);
1802 bool operator<=(T, T);
1803 bool operator>=(T, T);
1804 bool operator==(T, T);
1805 bool operator!=(T, T);
1807 17For every pointer to member type T, there exist candidate operator
1808 functions of the form
1809 bool operator==(T, T);
1810 bool operator!=(T, T); */
1813 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1815 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1817 type2 = ptrdiff_type_node;
1821 case TRUNC_DIV_EXPR:
1822 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1828 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1829 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1831 if ((TYPE_PTRMEMFUNC_P (type1) || TYPE_PTRMEM_P (type1))
1832 && null_ptr_cst_p (args[1]))
1837 if ((TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2))
1838 && null_ptr_cst_p (args[0]))
1850 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1852 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1854 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1856 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1861 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1869 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1872 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1874 type1 = ptrdiff_type_node;
1877 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1879 type2 = ptrdiff_type_node;
1884 /* 18For every pair of promoted integral types L and R, there exist candi-
1885 date operator functions of the form
1892 where LR is the result of the usual arithmetic conversions between
1895 case TRUNC_MOD_EXPR:
1901 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1905 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1906 type, VQ is either volatile or empty, and R is a promoted arithmetic
1907 type, there exist candidate operator functions of the form
1908 VQ L& operator=(VQ L&, R);
1909 VQ L& operator*=(VQ L&, R);
1910 VQ L& operator/=(VQ L&, R);
1911 VQ L& operator+=(VQ L&, R);
1912 VQ L& operator-=(VQ L&, R);
1914 20For every pair T, VQ), where T is any type and VQ is either volatile
1915 or empty, there exist candidate operator functions of the form
1916 T*VQ& operator=(T*VQ&, T*);
1918 21For every pair T, VQ), where T is a pointer to member type and VQ is
1919 either volatile or empty, there exist candidate operator functions of
1921 VQ T& operator=(VQ T&, T);
1923 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1924 unqualified complete object type, VQ is either volatile or empty, and
1925 I is a promoted integral type, there exist candidate operator func-
1927 T*VQ& operator+=(T*VQ&, I);
1928 T*VQ& operator-=(T*VQ&, I);
1930 23For every triple L, VQ, R), where L is an integral or enumeration
1931 type, VQ is either volatile or empty, and R is a promoted integral
1932 type, there exist candidate operator functions of the form
1934 VQ L& operator%=(VQ L&, R);
1935 VQ L& operator<<=(VQ L&, R);
1936 VQ L& operator>>=(VQ L&, R);
1937 VQ L& operator&=(VQ L&, R);
1938 VQ L& operator^=(VQ L&, R);
1939 VQ L& operator|=(VQ L&, R); */
1946 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1948 type2 = ptrdiff_type_node;
1952 case TRUNC_DIV_EXPR:
1953 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1957 case TRUNC_MOD_EXPR:
1963 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1968 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1970 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1971 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1972 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1973 || ((TYPE_PTRMEMFUNC_P (type1)
1974 || TREE_CODE (type1) == POINTER_TYPE)
1975 && null_ptr_cst_p (args[1])))
1985 type1 = build_reference_type (type1);
1991 For every pair of promoted arithmetic types L and R, there
1992 exist candidate operator functions of the form
1994 LR operator?(bool, L, R);
1996 where LR is the result of the usual arithmetic conversions
1997 between types L and R.
1999 For every type T, where T is a pointer or pointer-to-member
2000 type, there exist candidate operator functions of the form T
2001 operator?(bool, T, T); */
2003 if (promoted_arithmetic_type_p (type1)
2004 && promoted_arithmetic_type_p (type2))
2008 /* Otherwise, the types should be pointers. */
2009 if (!(TREE_CODE (type1) == POINTER_TYPE
2010 || TYPE_PTRMEM_P (type1)
2011 || TYPE_PTRMEMFUNC_P (type1))
2012 || !(TREE_CODE (type2) == POINTER_TYPE
2013 || TYPE_PTRMEM_P (type2)
2014 || TYPE_PTRMEMFUNC_P (type2)))
2017 /* We don't check that the two types are the same; the logic
2018 below will actually create two candidates; one in which both
2019 parameter types are TYPE1, and one in which both parameter
2027 /* If we're dealing with two pointer types or two enumeral types,
2028 we need candidates for both of them. */
2029 if (type2 && !same_type_p (type1, type2)
2030 && TREE_CODE (type1) == TREE_CODE (type2)
2031 && (TREE_CODE (type1) == REFERENCE_TYPE
2032 || (TREE_CODE (type1) == POINTER_TYPE
2033 && TYPE_PTRMEM_P (type1) == TYPE_PTRMEM_P (type2))
2034 || TYPE_PTRMEMFUNC_P (type1)
2035 || IS_AGGR_TYPE (type1)
2036 || TREE_CODE (type1) == ENUMERAL_TYPE))
2038 build_builtin_candidate
2039 (candidates, fnname, type1, type1, args, argtypes, flags);
2040 build_builtin_candidate
2041 (candidates, fnname, type2, type2, args, argtypes, flags);
2045 build_builtin_candidate
2046 (candidates, fnname, type1, type2, args, argtypes, flags);
2050 type_decays_to (tree type)
2052 if (TREE_CODE (type) == ARRAY_TYPE)
2053 return build_pointer_type (TREE_TYPE (type));
2054 if (TREE_CODE (type) == FUNCTION_TYPE)
2055 return build_pointer_type (type);
2059 /* There are three conditions of builtin candidates:
2061 1) bool-taking candidates. These are the same regardless of the input.
2062 2) pointer-pair taking candidates. These are generated for each type
2063 one of the input types converts to.
2064 3) arithmetic candidates. According to the standard, we should generate
2065 all of these, but I'm trying not to...
2067 Here we generate a superset of the possible candidates for this particular
2068 case. That is a subset of the full set the standard defines, plus some
2069 other cases which the standard disallows. add_builtin_candidate will
2070 filter out the invalid set. */
2073 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2074 enum tree_code code2, tree fnname, tree *args,
2079 tree type, argtypes[3];
2080 /* TYPES[i] is the set of possible builtin-operator parameter types
2081 we will consider for the Ith argument. These are represented as
2082 a TREE_LIST; the TREE_VALUE of each node is the potential
2086 for (i = 0; i < 3; ++i)
2089 argtypes[i] = lvalue_type (args[i]);
2091 argtypes[i] = NULL_TREE;
2096 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2097 and VQ is either volatile or empty, there exist candidate operator
2098 functions of the form
2099 VQ T& operator++(VQ T&); */
2101 case POSTINCREMENT_EXPR:
2102 case PREINCREMENT_EXPR:
2103 case POSTDECREMENT_EXPR:
2104 case PREDECREMENT_EXPR:
2109 /* 24There also exist candidate operator functions of the form
2110 bool operator!(bool);
2111 bool operator&&(bool, bool);
2112 bool operator||(bool, bool); */
2114 case TRUTH_NOT_EXPR:
2115 build_builtin_candidate
2116 (candidates, fnname, boolean_type_node,
2117 NULL_TREE, args, argtypes, flags);
2120 case TRUTH_ORIF_EXPR:
2121 case TRUTH_ANDIF_EXPR:
2122 build_builtin_candidate
2123 (candidates, fnname, boolean_type_node,
2124 boolean_type_node, args, argtypes, flags);
2146 types[0] = types[1] = NULL_TREE;
2148 for (i = 0; i < 2; ++i)
2152 else if (IS_AGGR_TYPE (argtypes[i]))
2156 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2159 convs = lookup_conversions (argtypes[i]);
2161 if (code == COND_EXPR)
2163 if (real_lvalue_p (args[i]))
2164 types[i] = tree_cons
2165 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2167 types[i] = tree_cons
2168 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2174 for (; convs; convs = TREE_CHAIN (convs))
2176 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2179 && (TREE_CODE (type) != REFERENCE_TYPE
2180 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2183 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2184 types[i] = tree_cons (NULL_TREE, type, types[i]);
2186 type = non_reference (type);
2187 if (i != 0 || ! ref1)
2189 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2190 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2191 types[i] = tree_cons (NULL_TREE, type, types[i]);
2192 if (INTEGRAL_TYPE_P (type))
2193 type = type_promotes_to (type);
2196 if (! value_member (type, types[i]))
2197 types[i] = tree_cons (NULL_TREE, type, types[i]);
2202 if (code == COND_EXPR && real_lvalue_p (args[i]))
2203 types[i] = tree_cons
2204 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2205 type = non_reference (argtypes[i]);
2206 if (i != 0 || ! ref1)
2208 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2209 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2210 types[i] = tree_cons (NULL_TREE, type, types[i]);
2211 if (INTEGRAL_TYPE_P (type))
2212 type = type_promotes_to (type);
2214 types[i] = tree_cons (NULL_TREE, type, types[i]);
2218 /* Run through the possible parameter types of both arguments,
2219 creating candidates with those parameter types. */
2220 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2223 for (type = types[1]; type; type = TREE_CHAIN (type))
2224 add_builtin_candidate
2225 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2226 TREE_VALUE (type), args, argtypes, flags);
2228 add_builtin_candidate
2229 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2230 NULL_TREE, args, argtypes, flags);
2237 /* If TMPL can be successfully instantiated as indicated by
2238 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2240 TMPL is the template. EXPLICIT_TARGS are any explicit template
2241 arguments. ARGLIST is the arguments provided at the call-site.
2242 The RETURN_TYPE is the desired type for conversion operators. If
2243 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2244 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2245 add_conv_candidate. */
2247 static struct z_candidate*
2248 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2249 tree ctype, tree explicit_targs, tree arglist,
2250 tree return_type, tree access_path,
2251 tree conversion_path, int flags, tree obj,
2252 unification_kind_t strict)
2254 int ntparms = DECL_NTPARMS (tmpl);
2255 tree targs = make_tree_vec (ntparms);
2256 tree args_without_in_chrg = arglist;
2257 struct z_candidate *cand;
2261 /* We don't do deduction on the in-charge parameter, the VTT
2262 parameter or 'this'. */
2263 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2264 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2266 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2267 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2268 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
2269 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2271 i = fn_type_unification (tmpl, explicit_targs, targs,
2272 args_without_in_chrg,
2273 return_type, strict, -1);
2278 fn = instantiate_template (tmpl, targs, tf_none);
2279 if (fn == error_mark_node)
2284 A member function template is never instantiated to perform the
2285 copy of a class object to an object of its class type.
2287 It's a little unclear what this means; the standard explicitly
2288 does allow a template to be used to copy a class. For example,
2293 template <class T> A(const T&);
2296 void g () { A a (f ()); }
2298 the member template will be used to make the copy. The section
2299 quoted above appears in the paragraph that forbids constructors
2300 whose only parameter is (a possibly cv-qualified variant of) the
2301 class type, and a logical interpretation is that the intent was
2302 to forbid the instantiation of member templates which would then
2304 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2306 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2307 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2312 if (obj != NULL_TREE)
2313 /* Aha, this is a conversion function. */
2314 cand = add_conv_candidate (candidates, fn, obj, access_path,
2315 conversion_path, arglist);
2317 cand = add_function_candidate (candidates, fn, ctype,
2318 arglist, access_path,
2319 conversion_path, flags);
2320 if (DECL_TI_TEMPLATE (fn) != tmpl)
2321 /* This situation can occur if a member template of a template
2322 class is specialized. Then, instantiate_template might return
2323 an instantiation of the specialization, in which case the
2324 DECL_TI_TEMPLATE field will point at the original
2325 specialization. For example:
2327 template <class T> struct S { template <class U> void f(U);
2328 template <> void f(int) {}; };
2332 Here, TMPL will be template <class U> S<double>::f(U).
2333 And, instantiate template will give us the specialization
2334 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2335 for this will point at template <class T> template <> S<T>::f(int),
2336 so that we can find the definition. For the purposes of
2337 overload resolution, however, we want the original TMPL. */
2338 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2340 cand->template = DECL_TEMPLATE_INFO (fn);
2346 static struct z_candidate *
2347 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2348 tree explicit_targs, tree arglist, tree return_type,
2349 tree access_path, tree conversion_path, int flags,
2350 unification_kind_t strict)
2353 add_template_candidate_real (candidates, tmpl, ctype,
2354 explicit_targs, arglist, return_type,
2355 access_path, conversion_path,
2356 flags, NULL_TREE, strict);
2360 static struct z_candidate *
2361 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2362 tree obj, tree arglist, tree return_type,
2363 tree access_path, tree conversion_path)
2366 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2367 arglist, return_type, access_path,
2368 conversion_path, 0, obj, DEDUCE_CONV);
2371 /* The CANDS are the set of candidates that were considered for
2372 overload resolution. Return the set of viable candidates. If none
2373 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2374 is true if a candidate should be considered viable only if it is
2377 static struct z_candidate*
2378 splice_viable (struct z_candidate *cands,
2382 struct z_candidate *viable;
2383 struct z_candidate **last_viable;
2384 struct z_candidate **cand;
2387 last_viable = &viable;
2388 *any_viable_p = false;
2393 struct z_candidate *c = *cand;
2394 if (strict_p ? c->viable == 1 : c->viable)
2399 last_viable = &c->next;
2400 *any_viable_p = true;
2406 return viable ? viable : cands;
2410 any_strictly_viable (struct z_candidate *cands)
2412 for (; cands; cands = cands->next)
2413 if (cands->viable == 1)
2419 build_this (tree obj)
2421 /* Fix this to work on non-lvalues. */
2422 return build_unary_op (ADDR_EXPR, obj, 0);
2425 /* Returns true iff functions are equivalent. Equivalent functions are
2426 not '==' only if one is a function-local extern function or if
2427 both are extern "C". */
2430 equal_functions (tree fn1, tree fn2)
2432 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2433 || DECL_EXTERN_C_FUNCTION_P (fn1))
2434 return decls_match (fn1, fn2);
2438 /* Print information about one overload candidate CANDIDATE. MSGSTR
2439 is the text to print before the candidate itself.
2441 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2442 to have been run through gettext by the caller. This wart makes
2443 life simpler in print_z_candidates and for the translators. */
2446 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2448 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2450 if (TREE_VEC_LENGTH (candidate->convs) == 3)
2451 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2452 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2453 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)),
2454 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 2)));
2455 else if (TREE_VEC_LENGTH (candidate->convs) == 2)
2456 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2457 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2458 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)));
2460 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2461 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)));
2463 else if (TYPE_P (candidate->fn))
2464 inform ("%s %T <conversion>", msgstr, candidate->fn);
2465 else if (candidate->viable == -1)
2466 inform ("%H%s %+#D <near match>",
2467 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
2469 inform ("%H%s %+#D",
2470 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
2474 print_z_candidates (struct z_candidate *candidates)
2477 struct z_candidate *cand1;
2478 struct z_candidate **cand2;
2480 /* There may be duplicates in the set of candidates. We put off
2481 checking this condition as long as possible, since we have no way
2482 to eliminate duplicates from a set of functions in less than n^2
2483 time. Now we are about to emit an error message, so it is more
2484 permissible to go slowly. */
2485 for (cand1 = candidates; cand1; cand1 = cand1->next)
2487 tree fn = cand1->fn;
2488 /* Skip builtin candidates and conversion functions. */
2489 if (TREE_CODE (fn) != FUNCTION_DECL)
2491 cand2 = &cand1->next;
2494 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2495 && equal_functions (fn, (*cand2)->fn))
2496 *cand2 = (*cand2)->next;
2498 cand2 = &(*cand2)->next;
2505 str = _("candidates are:");
2506 print_z_candidate (str, candidates);
2507 if (candidates->next)
2509 /* Indent successive candidates by the width of the translation
2510 of the above string. */
2511 size_t len = gcc_gettext_width (str) + 1;
2512 char *spaces = alloca (len);
2513 memset (spaces, ' ', len-1);
2514 spaces[len - 1] = '\0';
2516 candidates = candidates->next;
2519 print_z_candidate (spaces, candidates);
2520 candidates = candidates->next;
2526 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2527 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2528 the result of the conversion function to convert it to the final
2529 desired type. Merge the the two sequences into a single sequence,
2530 and return the merged sequence. */
2533 merge_conversion_sequences (tree user_seq, tree std_seq)
2537 my_friendly_assert (TREE_CODE (user_seq) == USER_CONV,
2540 /* Find the end of the second conversion sequence. */
2542 while (TREE_CODE (*t) != IDENTITY_CONV)
2543 t = &TREE_OPERAND (*t, 0);
2545 /* Replace the identity conversion with the user conversion
2549 /* The entire sequence is a user-conversion sequence. */
2550 ICS_USER_FLAG (std_seq) = 1;
2555 /* Returns the best overload candidate to perform the requested
2556 conversion. This function is used for three the overloading situations
2557 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2558 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2559 per [dcl.init.ref], so we ignore temporary bindings. */
2561 static struct z_candidate *
2562 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2564 struct z_candidate *candidates, *cand;
2565 tree fromtype = TREE_TYPE (expr);
2566 tree ctors = NULL_TREE, convs = NULL_TREE;
2567 tree args = NULL_TREE;
2570 /* We represent conversion within a hierarchy using RVALUE_CONV and
2571 BASE_CONV, as specified by [over.best.ics]; these become plain
2572 constructor calls, as specified in [dcl.init]. */
2573 my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2574 || !DERIVED_FROM_P (totype, fromtype), 20011226);
2576 if (IS_AGGR_TYPE (totype))
2577 ctors = lookup_fnfields (TYPE_BINFO (totype),
2578 complete_ctor_identifier,
2581 if (IS_AGGR_TYPE (fromtype))
2582 convs = lookup_conversions (fromtype);
2585 flags |= LOOKUP_NO_CONVERSION;
2591 ctors = BASELINK_FUNCTIONS (ctors);
2593 t = build_int_2 (0, 0);
2594 TREE_TYPE (t) = build_pointer_type (totype);
2595 args = build_tree_list (NULL_TREE, expr);
2596 /* We should never try to call the abstract or base constructor
2598 my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2599 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),
2601 args = tree_cons (NULL_TREE, t, args);
2603 for (; ctors; ctors = OVL_NEXT (ctors))
2605 tree ctor = OVL_CURRENT (ctors);
2606 if (DECL_NONCONVERTING_P (ctor))
2609 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2610 cand = add_template_candidate (&candidates, ctor, totype,
2611 NULL_TREE, args, NULL_TREE,
2612 TYPE_BINFO (totype),
2613 TYPE_BINFO (totype),
2617 cand = add_function_candidate (&candidates, ctor, totype,
2618 args, TYPE_BINFO (totype),
2619 TYPE_BINFO (totype),
2623 cand->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE);
2627 args = build_tree_list (NULL_TREE, build_this (expr));
2629 for (; convs; convs = TREE_CHAIN (convs))
2632 tree conversion_path = TREE_PURPOSE (convs);
2633 int convflags = LOOKUP_NO_CONVERSION;
2635 /* If we are called to convert to a reference type, we are trying to
2636 find an lvalue binding, so don't even consider temporaries. If
2637 we don't find an lvalue binding, the caller will try again to
2638 look for a temporary binding. */
2639 if (TREE_CODE (totype) == REFERENCE_TYPE)
2640 convflags |= LOOKUP_NO_TEMP_BIND;
2642 for (fns = TREE_VALUE (convs); fns; fns = OVL_NEXT (fns))
2644 tree fn = OVL_CURRENT (fns);
2646 /* [over.match.funcs] For conversion functions, the function
2647 is considered to be a member of the class of the implicit
2648 object argument for the purpose of defining the type of
2649 the implicit object parameter.
2651 So we pass fromtype as CTYPE to add_*_candidate. */
2653 if (TREE_CODE (fn) == TEMPLATE_DECL)
2654 cand = add_template_candidate (&candidates, fn, fromtype,
2657 TYPE_BINFO (fromtype),
2662 cand = add_function_candidate (&candidates, fn, fromtype,
2664 TYPE_BINFO (fromtype),
2670 tree ics = implicit_conversion (totype,
2671 TREE_TYPE (TREE_TYPE (cand->fn)),
2674 cand->second_conv = ics;
2676 if (ics == NULL_TREE)
2678 else if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
2684 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2688 cand = tourney (candidates);
2691 if (flags & LOOKUP_COMPLAIN)
2693 error ("conversion from `%T' to `%T' is ambiguous",
2695 print_z_candidates (candidates);
2698 cand = candidates; /* any one will do */
2699 cand->second_conv = build1 (AMBIG_CONV, totype, expr);
2700 ICS_USER_FLAG (cand->second_conv) = 1;
2701 if (!any_strictly_viable (candidates))
2702 ICS_BAD_FLAG (cand->second_conv) = 1;
2703 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2704 ambiguous conversion is no worse than another user-defined
2710 /* Build the user conversion sequence. */
2713 (DECL_CONSTRUCTOR_P (cand->fn)
2714 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2715 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
2716 TREE_OPERAND (convs, 1) = build_zc_wrapper (cand);
2718 /* Combine it with the second conversion sequence. */
2719 cand->second_conv = merge_conversion_sequences (convs,
2722 if (cand->viable == -1)
2723 ICS_BAD_FLAG (cand->second_conv) = 1;
2729 build_user_type_conversion (tree totype, tree expr, int flags)
2731 struct z_candidate *cand
2732 = build_user_type_conversion_1 (totype, expr, flags);
2736 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
2737 return error_mark_node;
2738 return convert_from_reference (convert_like (cand->second_conv, expr));
2743 /* Find the possibly overloaded set of functions corresponding to a
2744 call of the form SCOPE::NAME (...). NAME might be a
2745 TEMPLATE_ID_EXPR, OVERLOAD, _DECL, IDENTIFIER_NODE or LOOKUP_EXPR. */
2748 resolve_scoped_fn_name (tree scope, tree name)
2751 tree template_args = NULL_TREE;
2752 bool is_template_id = TREE_CODE (name) == TEMPLATE_ID_EXPR;
2756 template_args = TREE_OPERAND (name, 1);
2757 name = TREE_OPERAND (name, 0);
2759 if (TREE_CODE (name) == OVERLOAD)
2760 name = DECL_NAME (get_first_fn (name));
2761 else if (TREE_CODE (name) == LOOKUP_EXPR)
2762 name = TREE_OPERAND (name, 0);
2764 if (TREE_CODE (scope) == NAMESPACE_DECL)
2765 fn = lookup_namespace_name (scope, name);
2768 if (!TYPE_BEING_DEFINED (scope)
2769 && !COMPLETE_TYPE_P (complete_type (scope)))
2771 error ("incomplete type '%T' cannot be used to name a scope",
2773 return error_mark_node;
2776 if (BASELINK_P (name))
2779 fn = lookup_member (scope, name, /*protect=*/1, /*want_type=*/false);
2780 if (fn && current_class_type)
2781 fn = (adjust_result_of_qualified_name_lookup
2782 (fn, scope, current_class_type));
2784 /* It might be the name of a function pointer member. */
2785 if (fn && TREE_CODE (fn) == FIELD_DECL)
2786 fn = resolve_offset_ref (build_offset_ref (scope, fn));
2791 error ("'%D' has no member named '%E'", scope, name);
2792 return error_mark_node;
2798 if (BASELINK_P (fn))
2799 fns = BASELINK_FUNCTIONS (fns);
2800 fns = build_nt (TEMPLATE_ID_EXPR, fns, template_args);
2801 if (BASELINK_P (fn))
2802 BASELINK_FUNCTIONS (fn) = fns;
2810 /* Do any initial processing on the arguments to a function call. */
2813 resolve_args (tree args)
2816 for (t = args; t; t = TREE_CHAIN (t))
2818 tree arg = TREE_VALUE (t);
2820 if (arg == error_mark_node)
2821 return error_mark_node;
2822 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2824 error ("invalid use of void expression");
2825 return error_mark_node;
2827 else if (TREE_CODE (arg) == OFFSET_REF)
2828 arg = resolve_offset_ref (arg);
2829 arg = convert_from_reference (arg);
2830 TREE_VALUE (t) = arg;
2835 /* Perform overload resolution on FN, which is called with the ARGS.
2837 Return the candidate function selected by overload resolution, or
2838 NULL if the event that overload resolution failed. In the case
2839 that overload resolution fails, *CANDIDATES will be the set of
2840 candidates considered, and ANY_VIABLE_P will be set to true or
2841 false to indicate whether or not any of the candidates were
2844 The ARGS should already have gone through RESOLVE_ARGS before this
2845 function is called. */
2847 static struct z_candidate *
2848 perform_overload_resolution (tree fn,
2850 struct z_candidate **candidates,
2853 struct z_candidate *cand;
2854 tree explicit_targs = NULL_TREE;
2855 int template_only = 0;
2858 *any_viable_p = true;
2860 /* Check FN and ARGS. */
2861 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
2862 || TREE_CODE (fn) == TEMPLATE_DECL
2863 || TREE_CODE (fn) == OVERLOAD
2864 || TREE_CODE (fn) == TEMPLATE_ID_EXPR,
2866 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
2869 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2871 explicit_targs = TREE_OPERAND (fn, 1);
2872 fn = TREE_OPERAND (fn, 0);
2876 /* Add the various candidate functions. */
2877 add_candidates (fn, args, explicit_targs, template_only,
2878 /*conversion_path=*/NULL_TREE,
2879 /*access_path=*/NULL_TREE,
2883 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2887 cand = tourney (*candidates);
2891 /* Return an expression for a call to FN (a namespace-scope function,
2892 or a static member function) with the ARGS. */
2895 build_new_function_call (tree fn, tree args)
2897 struct z_candidate *candidates, *cand;
2900 args = resolve_args (args);
2901 if (args == error_mark_node)
2902 return error_mark_node;
2904 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2908 if (!any_viable_p && candidates && ! candidates->next)
2909 return build_function_call (candidates->fn, args);
2910 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2911 fn = TREE_OPERAND (fn, 0);
2913 error ("no matching function for call to `%D(%A)'",
2914 DECL_NAME (OVL_CURRENT (fn)), args);
2916 error ("call of overloaded `%D(%A)' is ambiguous",
2917 DECL_NAME (OVL_CURRENT (fn)), args);
2919 print_z_candidates (candidates);
2920 return error_mark_node;
2923 return build_over_call (cand, LOOKUP_NORMAL);
2926 /* Build a call to a global operator new. FNNAME is the name of the
2927 operator (either "operator new" or "operator new[]") and ARGS are
2928 the arguments provided. *SIZE points to the total number of bytes
2929 required by the allocation, and is updated if that is changed here.
2930 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2931 function determins that no cookie should be used, after all,
2932 *COOKIE_SIZE is set to NULL_TREE. */
2935 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2938 struct z_candidate *candidates;
2939 struct z_candidate *cand;
2942 args = tree_cons (NULL_TREE, *size, args);
2943 args = resolve_args (args);
2944 if (args == error_mark_node)
2947 fns = lookup_function_nonclass (fnname, args);
2949 /* Figure out what function is being called. */
2950 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2952 /* If no suitable function could be found, issue an error message
2957 error ("no matching function for call to `%D(%A)'",
2958 DECL_NAME (OVL_CURRENT (fns)), args);
2960 error ("call of overloaded `%D(%A)' is ambiguous",
2961 DECL_NAME (OVL_CURRENT (fns)), args);
2963 print_z_candidates (candidates);
2964 return error_mark_node;
2967 /* If a cookie is required, add some extra space. Whether
2968 or not a cookie is required cannot be determined until
2969 after we know which function was called. */
2972 bool use_cookie = true;
2973 if (!abi_version_at_least (2))
2975 tree placement = TREE_CHAIN (args);
2976 /* In G++ 3.2, the check was implemented incorrectly; it
2977 looked at the placement expression, rather than the
2978 type of the function. */
2979 if (placement && !TREE_CHAIN (placement)
2980 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2988 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2989 /* Skip the size_t parameter. */
2990 arg_types = TREE_CHAIN (arg_types);
2991 /* Check the remaining parameters (if any). */
2993 && TREE_CHAIN (arg_types) == void_list_node
2994 && same_type_p (TREE_VALUE (arg_types),
2998 /* If we need a cookie, adjust the number of bytes allocated. */
3001 /* Update the total size. */
3002 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3003 /* Update the argument list to reflect the adjusted size. */
3004 TREE_VALUE (args) = *size;
3007 *cookie_size = NULL_TREE;
3010 /* Build the CALL_EXPR. */
3011 return build_over_call (cand, LOOKUP_NORMAL);
3015 build_object_call (tree obj, tree args)
3017 struct z_candidate *candidates = 0, *cand;
3018 tree fns, convs, mem_args = NULL_TREE;
3019 tree type = TREE_TYPE (obj);
3022 if (TYPE_PTRMEMFUNC_P (type))
3024 /* It's no good looking for an overloaded operator() on a
3025 pointer-to-member-function. */
3026 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3027 return error_mark_node;
3030 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3031 if (fns == error_mark_node)
3032 return error_mark_node;
3034 args = resolve_args (args);
3036 if (args == error_mark_node)
3037 return error_mark_node;
3041 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
3042 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
3044 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
3046 tree fn = OVL_CURRENT (fns);
3047 if (TREE_CODE (fn) == TEMPLATE_DECL)
3048 add_template_candidate (&candidates, fn, base, NULL_TREE,
3049 mem_args, NULL_TREE,
3052 LOOKUP_NORMAL, DEDUCE_CALL);
3054 add_function_candidate
3055 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3056 TYPE_BINFO (type), LOOKUP_NORMAL);
3060 convs = lookup_conversions (type);
3062 for (; convs; convs = TREE_CHAIN (convs))
3064 tree fns = TREE_VALUE (convs);
3065 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3067 if ((TREE_CODE (totype) == POINTER_TYPE
3068 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3069 || (TREE_CODE (totype) == REFERENCE_TYPE
3070 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3071 || (TREE_CODE (totype) == REFERENCE_TYPE
3072 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3073 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3074 for (; fns; fns = OVL_NEXT (fns))
3076 tree fn = OVL_CURRENT (fns);
3077 if (TREE_CODE (fn) == TEMPLATE_DECL)
3078 add_template_conv_candidate
3079 (&candidates, fn, obj, args, totype,
3080 /*access_path=*/NULL_TREE,
3081 /*conversion_path=*/NULL_TREE);
3083 add_conv_candidate (&candidates, fn, obj, args,
3084 /*conversion_path=*/NULL_TREE,
3085 /*access_path=*/NULL_TREE);
3089 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3092 error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
3093 print_z_candidates (candidates);
3094 return error_mark_node;
3097 cand = tourney (candidates);
3100 error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
3101 print_z_candidates (candidates);
3102 return error_mark_node;
3105 /* Since cand->fn will be a type, not a function, for a conversion
3106 function, we must be careful not to unconditionally look at
3108 if (TREE_CODE (cand->fn) == FUNCTION_DECL
3109 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3110 return build_over_call (cand, LOOKUP_NORMAL);
3112 obj = convert_like_with_context
3113 (TREE_VEC_ELT (cand->convs, 0), obj, cand->fn, -1);
3116 return build_function_call (obj, args);
3120 op_error (enum tree_code code, enum tree_code code2,
3121 tree arg1, tree arg2, tree arg3, const char *problem)
3125 if (code == MODIFY_EXPR)
3126 opname = assignment_operator_name_info[code2].name;
3128 opname = operator_name_info[code].name;
3133 error ("%s for `%T ? %T : %T' operator", problem,
3134 error_type (arg1), error_type (arg2), error_type (arg3));
3136 case POSTINCREMENT_EXPR:
3137 case POSTDECREMENT_EXPR:
3138 error ("%s for `%T %s' operator", problem, error_type (arg1), opname);
3141 error ("%s for `%T [%T]' operator", problem,
3142 error_type (arg1), error_type (arg2));
3146 error ("%s for `%T %s %T' operator", problem,
3147 error_type (arg1), opname, error_type (arg2));
3149 error ("%s for `%s %T' operator", problem, opname, error_type (arg1));
3153 /* Return the implicit conversion sequence that could be used to
3154 convert E1 to E2 in [expr.cond]. */
3157 conditional_conversion (tree e1, tree e2)
3159 tree t1 = non_reference (TREE_TYPE (e1));
3160 tree t2 = non_reference (TREE_TYPE (e2));
3166 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3167 implicitly converted (clause _conv_) to the type "reference to
3168 T2", subject to the constraint that in the conversion the
3169 reference must bind directly (_dcl.init.ref_) to E1. */
3170 if (real_lvalue_p (e2))
3172 conv = implicit_conversion (build_reference_type (t2),
3175 LOOKUP_NO_TEMP_BIND);
3182 If E1 and E2 have class type, and the underlying class types are
3183 the same or one is a base class of the other: E1 can be converted
3184 to match E2 if the class of T2 is the same type as, or a base
3185 class of, the class of T1, and the cv-qualification of T2 is the
3186 same cv-qualification as, or a greater cv-qualification than, the
3187 cv-qualification of T1. If the conversion is applied, E1 is
3188 changed to an rvalue of type T2 that still refers to the original
3189 source class object (or the appropriate subobject thereof).
3191 FIXME we can't express an rvalue that refers to the original object;
3192 we have to create a new one. */
3193 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3194 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3196 if (good_base && at_least_as_qualified_p (t2, t1))
3198 conv = build1 (IDENTITY_CONV, t1, e1);
3199 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3200 TYPE_MAIN_VARIANT (t2)))
3202 conv = build_conv (BASE_CONV, t2, conv);
3203 NEED_TEMPORARY_P (conv) = 1;
3206 conv = build_conv (RVALUE_CONV, t2, conv);
3215 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3216 converted to the type that expression E2 would have if E2 were
3217 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3218 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3221 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3222 arguments to the conditional expression. */
3225 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3230 tree result_type = NULL_TREE;
3231 bool lvalue_p = true;
3232 struct z_candidate *candidates = 0;
3233 struct z_candidate *cand;
3235 /* As a G++ extension, the second argument to the conditional can be
3236 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3237 c'.) If the second operand is omitted, make sure it is
3238 calculated only once. */
3242 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3244 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3245 if (real_lvalue_p (arg1))
3246 arg2 = arg1 = stabilize_reference (arg1);
3248 arg2 = arg1 = save_expr (arg1);
3253 The first expr ession is implicitly converted to bool (clause
3255 arg1 = cp_convert (boolean_type_node, arg1);
3257 /* If something has already gone wrong, just pass that fact up the
3259 if (arg1 == error_mark_node
3260 || arg2 == error_mark_node
3261 || arg3 == error_mark_node
3262 || TREE_TYPE (arg1) == error_mark_node
3263 || TREE_TYPE (arg2) == error_mark_node
3264 || TREE_TYPE (arg3) == error_mark_node)
3265 return error_mark_node;
3269 If either the second or the third operand has type (possibly
3270 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3271 array-to-pointer (_conv.array_), and function-to-pointer
3272 (_conv.func_) standard conversions are performed on the second
3273 and third operands. */
3274 arg2_type = TREE_TYPE (arg2);
3275 arg3_type = TREE_TYPE (arg3);
3276 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3278 /* Do the conversions. We don't these for `void' type arguments
3279 since it can't have any effect and since decay_conversion
3280 does not handle that case gracefully. */
3281 if (!VOID_TYPE_P (arg2_type))
3282 arg2 = decay_conversion (arg2);
3283 if (!VOID_TYPE_P (arg3_type))
3284 arg3 = decay_conversion (arg3);
3285 arg2_type = TREE_TYPE (arg2);
3286 arg3_type = TREE_TYPE (arg3);
3290 One of the following shall hold:
3292 --The second or the third operand (but not both) is a
3293 throw-expression (_except.throw_); the result is of the
3294 type of the other and is an rvalue.
3296 --Both the second and the third operands have type void; the
3297 result is of type void and is an rvalue. */
3298 if ((TREE_CODE (arg2) == THROW_EXPR)
3299 ^ (TREE_CODE (arg3) == THROW_EXPR))
3300 result_type = ((TREE_CODE (arg2) == THROW_EXPR)
3301 ? arg3_type : arg2_type);
3302 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3303 result_type = void_type_node;
3306 error ("`%E' has type `void' and is not a throw-expression",
3307 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3308 return error_mark_node;
3312 goto valid_operands;
3316 Otherwise, if the second and third operand have different types,
3317 and either has (possibly cv-qualified) class type, an attempt is
3318 made to convert each of those operands to the type of the other. */
3319 else if (!same_type_p (arg2_type, arg3_type)
3320 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3322 tree conv2 = conditional_conversion (arg2, arg3);
3323 tree conv3 = conditional_conversion (arg3, arg2);
3327 If both can be converted, or one can be converted but the
3328 conversion is ambiguous, the program is ill-formed. If
3329 neither can be converted, the operands are left unchanged and
3330 further checking is performed as described below. If exactly
3331 one conversion is possible, that conversion is applied to the
3332 chosen operand and the converted operand is used in place of
3333 the original operand for the remainder of this section. */
3334 if ((conv2 && !ICS_BAD_FLAG (conv2)
3335 && conv3 && !ICS_BAD_FLAG (conv3))
3336 || (conv2 && TREE_CODE (conv2) == AMBIG_CONV)
3337 || (conv3 && TREE_CODE (conv3) == AMBIG_CONV))
3339 error ("operands to ?: have different types");
3340 return error_mark_node;
3342 else if (conv2 && !ICS_BAD_FLAG (conv2))
3344 arg2 = convert_like (conv2, arg2);
3345 arg2 = convert_from_reference (arg2);
3346 if (!same_type_p (TREE_TYPE (arg2), arg3_type))
3348 arg2_type = TREE_TYPE (arg2);
3350 else if (conv3 && !ICS_BAD_FLAG (conv3))
3352 arg3 = convert_like (conv3, arg3);
3353 arg3 = convert_from_reference (arg3);
3354 if (!same_type_p (TREE_TYPE (arg3), arg2_type))
3356 arg3_type = TREE_TYPE (arg3);
3362 If the second and third operands are lvalues and have the same
3363 type, the result is of that type and is an lvalue. */
3364 if (real_lvalue_p (arg2) && real_lvalue_p (arg3) &&
3365 same_type_p (arg2_type, arg3_type))
3367 result_type = arg2_type;
3368 goto valid_operands;
3373 Otherwise, the result is an rvalue. If the second and third
3374 operand do not have the same type, and either has (possibly
3375 cv-qualified) class type, overload resolution is used to
3376 determine the conversions (if any) to be applied to the operands
3377 (_over.match.oper_, _over.built_). */
3379 if (!same_type_p (arg2_type, arg3_type)
3380 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3386 /* Rearrange the arguments so that add_builtin_candidate only has
3387 to know about two args. In build_builtin_candidates, the
3388 arguments are unscrambled. */
3392 add_builtin_candidates (&candidates,
3395 ansi_opname (COND_EXPR),
3401 If the overload resolution fails, the program is
3403 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3406 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3407 print_z_candidates (candidates);
3408 return error_mark_node;
3410 cand = tourney (candidates);
3413 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3414 print_z_candidates (candidates);
3415 return error_mark_node;
3420 Otherwise, the conversions thus determined are applied, and
3421 the converted operands are used in place of the original
3422 operands for the remainder of this section. */
3423 conv = TREE_VEC_ELT (cand->convs, 0);
3424 arg1 = convert_like (conv, arg1);
3425 conv = TREE_VEC_ELT (cand->convs, 1);
3426 arg2 = convert_like (conv, arg2);
3427 conv = TREE_VEC_ELT (cand->convs, 2);
3428 arg3 = convert_like (conv, arg3);
3433 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3434 and function-to-pointer (_conv.func_) standard conversions are
3435 performed on the second and third operands.
3437 We need to force the lvalue-to-rvalue conversion here for class types,
3438 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3439 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3442 We use ocp_convert rather than build_user_type_conversion because the
3443 latter returns NULL_TREE on failure, while the former gives an error. */
3445 arg2 = force_rvalue (arg2);
3446 arg2_type = TREE_TYPE (arg2);
3448 arg3 = force_rvalue (arg3);
3449 arg3_type = TREE_TYPE (arg3);
3451 if (arg2 == error_mark_node || arg3 == error_mark_node)
3452 return error_mark_node;
3456 After those conversions, one of the following shall hold:
3458 --The second and third operands have the same type; the result is of
3460 if (same_type_p (arg2_type, arg3_type))
3461 result_type = arg2_type;
3464 --The second and third operands have arithmetic or enumeration
3465 type; the usual arithmetic conversions are performed to bring
3466 them to a common type, and the result is of that type. */
3467 else if ((ARITHMETIC_TYPE_P (arg2_type)
3468 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3469 && (ARITHMETIC_TYPE_P (arg3_type)
3470 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3472 /* In this case, there is always a common type. */
3473 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3476 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3477 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3478 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3479 arg2_type, arg3_type);
3480 else if (extra_warnings
3481 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3482 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3483 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3484 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3485 warning ("enumeral and non-enumeral type in conditional expression");
3487 arg2 = perform_implicit_conversion (result_type, arg2);
3488 arg3 = perform_implicit_conversion (result_type, arg3);
3492 --The second and third operands have pointer type, or one has
3493 pointer type and the other is a null pointer constant; pointer
3494 conversions (_conv.ptr_) and qualification conversions
3495 (_conv.qual_) are performed to bring them to their composite
3496 pointer type (_expr.rel_). The result is of the composite
3499 --The second and third operands have pointer to member type, or
3500 one has pointer to member type and the other is a null pointer
3501 constant; pointer to member conversions (_conv.mem_) and
3502 qualification conversions (_conv.qual_) are performed to bring
3503 them to a common type, whose cv-qualification shall match the
3504 cv-qualification of either the second or the third operand.
3505 The result is of the common type. */
3506 else if ((null_ptr_cst_p (arg2)
3507 && (TYPE_PTR_P (arg3_type) || TYPE_PTRMEM_P (arg3_type)
3508 || TYPE_PTRMEMFUNC_P (arg3_type)))
3509 || (null_ptr_cst_p (arg3)
3510 && (TYPE_PTR_P (arg2_type) || TYPE_PTRMEM_P (arg2_type)
3511 || TYPE_PTRMEMFUNC_P (arg2_type)))
3512 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3513 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3514 || (TYPE_PTRMEMFUNC_P (arg2_type)
3515 && TYPE_PTRMEMFUNC_P (arg3_type)))
3517 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3518 arg3, "conditional expression");
3519 arg2 = perform_implicit_conversion (result_type, arg2);
3520 arg3 = perform_implicit_conversion (result_type, arg3);
3525 error ("operands to ?: have different types");
3526 return error_mark_node;
3530 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3531 /* We can't use result_type below, as fold might have returned a
3534 /* Expand both sides into the same slot, hopefully the target of the
3535 ?: expression. We used to check for TARGET_EXPRs here, but now we
3536 sometimes wrap them in NOP_EXPRs so the test would fail. */
3537 if (!lvalue_p && IS_AGGR_TYPE (TREE_TYPE (result)))
3538 result = get_target_expr (result);
3540 /* If this expression is an rvalue, but might be mistaken for an
3541 lvalue, we must add a NON_LVALUE_EXPR. */
3542 if (!lvalue_p && real_lvalue_p (result))
3543 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3548 /* OPERAND is an operand to an expression. Perform necessary steps
3549 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3553 prep_operand (tree operand)
3557 if (TREE_CODE (operand) == OFFSET_REF)
3558 operand = resolve_offset_ref (operand);
3559 operand = convert_from_reference (operand);
3560 if (CLASS_TYPE_P (TREE_TYPE (operand))
3561 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3562 /* Make sure the template type is instantiated now. */
3563 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3569 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3570 OVERLOAD) to the CANDIDATES, returning an updated list of
3571 CANDIDATES. The ARGS are the arguments provided to the call,
3572 without any implicit object parameter. The EXPLICIT_TARGS are
3573 explicit template arguments provided. TEMPLATE_ONLY is true if
3574 only template fucntions should be considered. CONVERSION_PATH,
3575 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3578 add_candidates (tree fns, tree args,
3579 tree explicit_targs, bool template_only,
3580 tree conversion_path, tree access_path,
3582 struct z_candidate **candidates)
3585 tree non_static_args;
3587 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3588 /* Delay creating the implicit this parameter until it is needed. */
3589 non_static_args = NULL_TREE;
3596 fn = OVL_CURRENT (fns);
3597 /* Figure out which set of arguments to use. */
3598 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3600 /* If this function is a non-static member, prepend the implicit
3601 object parameter. */
3602 if (!non_static_args)
3603 non_static_args = tree_cons (NULL_TREE,
3604 build_this (TREE_VALUE (args)),
3606 fn_args = non_static_args;
3609 /* Otherwise, just use the list of arguments provided. */
3612 if (TREE_CODE (fn) == TEMPLATE_DECL)
3613 add_template_candidate (candidates,
3623 else if (!template_only)
3624 add_function_candidate (candidates,
3631 fns = OVL_NEXT (fns);
3636 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3)
3638 struct z_candidate *candidates = 0, *cand;
3639 tree arglist, fnname;
3641 enum tree_code code2 = NOP_EXPR;
3646 if (error_operand_p (arg1)
3647 || error_operand_p (arg2)
3648 || error_operand_p (arg3))
3649 return error_mark_node;
3651 if (code == MODIFY_EXPR)
3653 code2 = TREE_CODE (arg3);
3655 fnname = ansi_assopname (code2);
3658 fnname = ansi_opname (code);
3660 arg1 = prep_operand (arg1);
3666 case VEC_DELETE_EXPR:
3668 /* Use build_op_new_call and build_op_delete_call instead. */
3672 return build_object_call (arg1, arg2);
3678 arg2 = prep_operand (arg2);
3679 arg3 = prep_operand (arg3);
3681 if (code == COND_EXPR)
3683 if (arg2 == NULL_TREE
3684 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3685 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3686 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3687 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3690 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3691 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3694 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3695 arg2 = integer_zero_node;
3697 arglist = NULL_TREE;
3699 arglist = tree_cons (NULL_TREE, arg3, arglist);
3701 arglist = tree_cons (NULL_TREE, arg2, arglist);
3702 arglist = tree_cons (NULL_TREE, arg1, arglist);
3704 /* Add namespace-scope operators to the list of functions to
3706 add_candidates (lookup_function_nonclass (fnname, arglist),
3707 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3708 flags, &candidates);
3709 /* Add class-member operators to the candidate set. */
3710 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3714 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3715 if (fns == error_mark_node)
3718 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3720 BASELINK_BINFO (fns),
3721 TYPE_BINFO (TREE_TYPE (arg1)),
3722 flags, &candidates);
3725 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3726 to know about two args; a builtin candidate will always have a first
3727 parameter of type bool. We'll handle that in
3728 build_builtin_candidate. */
3729 if (code == COND_EXPR)
3739 args[2] = NULL_TREE;
3742 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3748 /* For these, the built-in candidates set is empty
3749 [over.match.oper]/3. We don't want non-strict matches
3750 because exact matches are always possible with built-in
3751 operators. The built-in candidate set for COMPONENT_REF
3752 would be empty too, but since there are no such built-in
3753 operators, we accept non-strict matches for them. */
3758 strict_p = pedantic;
3762 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3767 case POSTINCREMENT_EXPR:
3768 case POSTDECREMENT_EXPR:
3769 /* Look for an `operator++ (int)'. If they didn't have
3770 one, then we fall back to the old way of doing things. */
3771 if (flags & LOOKUP_COMPLAIN)
3772 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3774 operator_name_info[code].name);
3775 if (code == POSTINCREMENT_EXPR)
3776 code = PREINCREMENT_EXPR;
3778 code = PREDECREMENT_EXPR;
3779 return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
3781 /* The caller will deal with these. */
3790 if (flags & LOOKUP_COMPLAIN)
3792 op_error (code, code2, arg1, arg2, arg3, "no match");
3793 print_z_candidates (candidates);
3795 return error_mark_node;
3798 cand = tourney (candidates);
3801 if (flags & LOOKUP_COMPLAIN)
3803 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3804 print_z_candidates (candidates);
3806 return error_mark_node;
3809 if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3812 && fnname == ansi_assopname (NOP_EXPR)
3813 && DECL_ARTIFICIAL (cand->fn)
3815 && ! candidates->next->next)
3817 warning ("using synthesized `%#D' for copy assignment",
3819 cp_warning_at (" where cfront would use `%#D'",
3821 ? candidates->next->fn
3825 return build_over_call (cand, LOOKUP_NORMAL);
3828 /* Check for comparison of different enum types. */
3837 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3838 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3839 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3840 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3842 warning ("comparison between `%#T' and `%#T'",
3843 TREE_TYPE (arg1), TREE_TYPE (arg2));
3850 /* We need to strip any leading REF_BIND so that bitfields don't cause
3851 errors. This should not remove any important conversions, because
3852 builtins don't apply to class objects directly. */
3853 conv = TREE_VEC_ELT (cand->convs, 0);
3854 if (TREE_CODE (conv) == REF_BIND)
3855 conv = TREE_OPERAND (conv, 0);
3856 arg1 = convert_like (conv, arg1);
3859 conv = TREE_VEC_ELT (cand->convs, 1);
3860 if (TREE_CODE (conv) == REF_BIND)
3861 conv = TREE_OPERAND (conv, 0);
3862 arg2 = convert_like (conv, arg2);
3866 conv = TREE_VEC_ELT (cand->convs, 2);
3867 if (TREE_CODE (conv) == REF_BIND)
3868 conv = TREE_OPERAND (conv, 0);
3869 arg3 = convert_like (conv, arg3);
3876 return build_modify_expr (arg1, code2, arg2);
3879 return build_indirect_ref (arg1, "unary *");
3884 case TRUNC_DIV_EXPR:
3895 case TRUNC_MOD_EXPR:
3899 case TRUTH_ANDIF_EXPR:
3900 case TRUTH_ORIF_EXPR:
3901 return cp_build_binary_op (code, arg1, arg2);
3906 case TRUTH_NOT_EXPR:
3907 case PREINCREMENT_EXPR:
3908 case POSTINCREMENT_EXPR:
3909 case PREDECREMENT_EXPR:
3910 case POSTDECREMENT_EXPR:
3913 return build_unary_op (code, arg1, candidates != 0);
3916 return build_array_ref (arg1, arg2);
3919 return build_conditional_expr (arg1, arg2, arg3);
3922 return build_m_component_ref
3923 (build_indirect_ref (arg1, NULL), arg2);
3925 /* The caller will deal with these. */
3937 /* Build a call to operator delete. This has to be handled very specially,
3938 because the restrictions on what signatures match are different from all
3939 other call instances. For a normal delete, only a delete taking (void *)
3940 or (void *, size_t) is accepted. For a placement delete, only an exact
3941 match with the placement new is accepted.
3943 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3944 ADDR is the pointer to be deleted.
3945 SIZE is the size of the memory block to be deleted.
3946 FLAGS are the usual overloading flags.
3947 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3950 build_op_delete_call (enum tree_code code, tree addr, tree size,
3951 int flags, tree placement)
3953 tree fn = NULL_TREE;
3954 tree fns, fnname, argtypes, args, type;
3957 if (addr == error_mark_node)
3958 return error_mark_node;
3960 type = TREE_TYPE (TREE_TYPE (addr));
3961 while (TREE_CODE (type) == ARRAY_TYPE)
3962 type = TREE_TYPE (type);
3964 fnname = ansi_opname (code);
3966 if (IS_AGGR_TYPE (type) && ! (flags & LOOKUP_GLOBAL))
3969 If the result of the lookup is ambiguous or inaccessible, or if
3970 the lookup selects a placement deallocation function, the
3971 program is ill-formed.
3973 Therefore, we ask lookup_fnfields to complain ambout ambiguity. */
3975 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3976 if (fns == error_mark_node)
3977 return error_mark_node;
3982 if (fns == NULL_TREE)
3983 fns = lookup_name_nonclass (fnname);
3990 /* Find the allocation function that is being called. */
3991 call_expr = placement;
3992 /* Sometimes we have a COMPOUND_EXPR, rather than a simple
3994 while (TREE_CODE (call_expr) == COMPOUND_EXPR)
3995 call_expr = TREE_OPERAND (call_expr, 1);
3996 /* Extract the function. */
3997 alloc_fn = get_callee_fndecl (call_expr);
3998 my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
3999 /* Then the second parm type. */
4000 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4001 /* Also the second argument. */
4002 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
4006 /* First try it without the size argument. */
4007 argtypes = void_list_node;
4011 /* Strip const and volatile from addr. */
4012 addr = cp_convert (ptr_type_node, addr);
4014 /* We make two tries at finding a matching `operator delete'. On
4015 the first pass, we look for an one-operator (or placement)
4016 operator delete. If we're not doing placement delete, then on
4017 the second pass we look for a two-argument delete. */
4018 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4020 /* Go through the `operator delete' functions looking for one
4021 with a matching type. */
4022 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4028 /* The first argument must be "void *". */
4029 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4030 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4033 /* On the first pass, check the rest of the arguments. */
4036 while (argtypes && t)
4038 if (!same_type_p (TREE_VALUE (argtypes),
4041 argtypes = TREE_CHAIN (argtypes);
4044 if (!argtypes && !t)
4047 /* On the second pass, the second argument must be
4050 && same_type_p (TREE_VALUE (t), sizetype)
4051 && TREE_CHAIN (t) == void_list_node)
4055 /* If we found a match, we're done. */
4060 /* If we have a matching function, call it. */
4063 /* Make sure we have the actual function, and not an
4065 fn = OVL_CURRENT (fn);
4067 /* If the FN is a member function, make sure that it is
4069 if (DECL_CLASS_SCOPE_P (fn))
4070 perform_or_defer_access_check (type, fn);
4073 args = tree_cons (NULL_TREE, addr, args);
4075 args = tree_cons (NULL_TREE, addr,
4076 build_tree_list (NULL_TREE, size));
4078 return build_function_call (fn, args);
4081 /* If we are doing placement delete we do nothing if we don't find a
4082 matching op delete. */
4086 error ("no suitable `operator delete' for `%T'", type);
4087 return error_mark_node;
4090 /* If the current scope isn't allowed to access DECL along
4091 BASETYPE_PATH, give an error. The most derived class in
4092 BASETYPE_PATH is the one used to qualify DECL. */
4095 enforce_access (tree basetype_path, tree decl)
4097 if (!accessible_p (basetype_path, decl))
4099 if (TREE_PRIVATE (decl))
4100 cp_error_at ("`%+#D' is private", decl);
4101 else if (TREE_PROTECTED (decl))
4102 cp_error_at ("`%+#D' is protected", decl);
4104 cp_error_at ("`%+#D' is inaccessible", decl);
4105 error ("within this context");
4112 /* Perform the conversions in CONVS on the expression EXPR.
4113 FN and ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4114 indicates the `this' argument of a method. INNER is nonzero when
4115 being called to continue a conversion chain. It is negative when a
4116 reference binding will be applied, positive otherwise. */
4119 convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner)
4123 tree totype = TREE_TYPE (convs);
4125 if (ICS_BAD_FLAG (convs)
4126 && TREE_CODE (convs) != USER_CONV
4127 && TREE_CODE (convs) != AMBIG_CONV
4128 && TREE_CODE (convs) != REF_BIND)
4131 for (; t; t = TREE_OPERAND (t, 0))
4133 if (TREE_CODE (t) == USER_CONV || !ICS_BAD_FLAG (t))
4135 expr = convert_like_real (t, expr, fn, argnum, 1);
4138 else if (TREE_CODE (t) == AMBIG_CONV)
4139 return convert_like_real (t, expr, fn, argnum, 1);
4140 else if (TREE_CODE (t) == IDENTITY_CONV)
4143 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
4145 pedwarn (" initializing argument %P of `%D'", argnum, fn);
4146 return cp_convert (totype, expr);
4150 expr = dubious_conversion_warnings
4151 (totype, expr, "argument", fn, argnum);
4152 switch (TREE_CODE (convs))
4156 struct z_candidate *cand = USER_CONV_CAND (convs);
4157 tree convfn = cand->fn;
4160 if (DECL_CONSTRUCTOR_P (convfn))
4162 tree t = build_int_2 (0, 0);
4163 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
4165 args = build_tree_list (NULL_TREE, expr);
4166 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
4167 || DECL_HAS_VTT_PARM_P (convfn))
4168 /* We should never try to call the abstract or base constructor
4171 args = tree_cons (NULL_TREE, t, args);
4174 args = build_this (expr);
4175 expr = build_over_call (cand, LOOKUP_NORMAL);
4177 /* If this is a constructor or a function returning an aggr type,
4178 we need to build up a TARGET_EXPR. */
4179 if (DECL_CONSTRUCTOR_P (convfn))
4180 expr = build_cplus_new (totype, expr);
4182 /* The result of the call is then used to direct-initialize the object
4183 that is the destination of the copy-initialization. [dcl.init]
4185 Note that this step is not reflected in the conversion sequence;
4186 it affects the semantics when we actually perform the
4187 conversion, but is not considered during overload resolution.
4189 If the target is a class, that means call a ctor. */
4190 if (IS_AGGR_TYPE (totype)
4191 && (inner >= 0 || !lvalue_p (expr)))
4193 savew = warningcount, savee = errorcount;
4194 expr = build_special_member_call
4195 (NULL_TREE, complete_ctor_identifier,
4196 build_tree_list (NULL_TREE, expr), TYPE_BINFO (totype),
4197 /* Core issue 84, now a DR, says that we don't allow UDCs
4198 for these args (which deliberately breaks copy-init of an
4199 auto_ptr<Base> from an auto_ptr<Derived>). */
4200 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION);
4202 /* Tell the user where this failing constructor call came from. */
4205 if (warningcount > savew)
4207 (" initializing argument %P of `%D' from result of `%D'",
4208 argnum, fn, convfn);
4209 else if (errorcount > savee)
4211 (" initializing argument %P of `%D' from result of `%D'",
4212 argnum, fn, convfn);
4216 if (warningcount > savew)
4217 warning (" initializing temporary from result of `%D'",
4219 else if (errorcount > savee)
4220 error (" initializing temporary from result of `%D'",
4223 expr = build_cplus_new (totype, expr);
4228 if (type_unknown_p (expr))
4229 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4230 /* Convert a non-array constant variable to its underlying value, unless we
4231 are about to bind it to a reference, in which case we need to
4232 leave it as an lvalue. */
4234 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4235 expr = decl_constant_value (expr);
4238 /* Call build_user_type_conversion again for the error. */
4239 return build_user_type_conversion
4240 (totype, TREE_OPERAND (convs, 0), LOOKUP_NORMAL);
4246 expr = convert_like_real (TREE_OPERAND (convs, 0), expr, fn, argnum,
4247 TREE_CODE (convs) == REF_BIND ? -1 : 1);
4248 if (expr == error_mark_node)
4249 return error_mark_node;
4251 switch (TREE_CODE (convs))
4254 if (! IS_AGGR_TYPE (totype))
4256 /* else fall through */
4258 if (TREE_CODE (convs) == BASE_CONV && !NEED_TEMPORARY_P (convs))
4260 /* We are going to bind a reference directly to a base-class
4261 subobject of EXPR. */
4262 tree base_ptr = build_pointer_type (totype);
4264 /* Build an expression for `*((base*) &expr)'. */
4265 expr = build_unary_op (ADDR_EXPR, expr, 0);
4266 expr = perform_implicit_conversion (base_ptr, expr);
4267 expr = build_indirect_ref (expr, "implicit conversion");
4271 /* Copy-initialization where the cv-unqualified version of the source
4272 type is the same class as, or a derived class of, the class of the
4273 destination [is treated as direct-initialization]. [dcl.init] */
4274 savew = warningcount, savee = errorcount;
4275 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4276 build_tree_list (NULL_TREE, expr),
4277 TYPE_BINFO (totype),
4278 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING);
4281 if (warningcount > savew)
4282 warning (" initializing argument %P of `%D'", argnum, fn);
4283 else if (errorcount > savee)
4284 error (" initializing argument %P of `%D'", argnum, fn);
4286 return build_cplus_new (totype, expr);
4290 tree ref_type = totype;
4292 /* If necessary, create a temporary. */
4293 if (NEED_TEMPORARY_P (convs) || !non_cast_lvalue_p (expr))
4295 tree type = TREE_TYPE (TREE_OPERAND (convs, 0));
4296 expr = build_target_expr_with_type (expr, type);
4299 /* Take the address of the thing to which we will bind the
4301 expr = build_unary_op (ADDR_EXPR, expr, 1);
4302 if (expr == error_mark_node)
4303 return error_mark_node;
4305 /* Convert it to a pointer to the type referred to by the
4306 reference. This will adjust the pointer if a derived to
4307 base conversion is being performed. */
4308 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4310 /* Convert the pointer to the desired reference type. */
4311 return build_nop (ref_type, expr);
4315 return decay_conversion (expr);
4318 /* Warn about deprecated conversion if appropriate. */
4319 string_conv_p (totype, expr, 1);
4325 return ocp_convert (totype, expr, CONV_IMPLICIT,
4326 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4329 /* Build a call to __builtin_trap which can be used in an expression. */
4332 call_builtin_trap (void)
4334 tree fn = get_identifier ("__builtin_trap");
4335 if (IDENTIFIER_GLOBAL_VALUE (fn))
4336 fn = IDENTIFIER_GLOBAL_VALUE (fn);
4340 fn = build_call (fn, NULL_TREE);
4341 fn = build (COMPOUND_EXPR, integer_type_node, fn, integer_zero_node);
4345 /* ARG is being passed to a varargs function. Perform any conversions
4346 required. Array/function to pointer decay must have already happened.
4347 Return the converted value. */
4350 convert_arg_to_ellipsis (tree arg)
4352 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4353 && (TYPE_PRECISION (TREE_TYPE (arg))
4354 < TYPE_PRECISION (double_type_node)))
4355 /* Convert `float' to `double'. */
4356 arg = cp_convert (double_type_node, arg);
4358 /* Convert `short' and `char' to full-size `int'. */
4359 arg = default_conversion (arg);
4361 arg = require_complete_type (arg);
4363 if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
4365 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4366 here and do a bitwise copy, but now cp_expr_size will abort if we
4368 warning ("cannot pass objects of non-POD type `%#T' through `...'; \
4369 call will abort at runtime",
4371 arg = call_builtin_trap ();
4377 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4380 build_x_va_arg (tree expr, tree type)
4382 if (processing_template_decl)
4383 return build_min (VA_ARG_EXPR, type, expr);
4385 type = complete_type_or_else (type, NULL_TREE);
4387 if (expr == error_mark_node || !type)
4388 return error_mark_node;
4390 if (! pod_type_p (type))
4392 /* Undefined behavior [expr.call] 5.2.2/7. */
4393 warning ("cannot receive objects of non-POD type `%#T' through `...'",
4397 return build_va_arg (expr, type);
4400 /* TYPE has been given to va_arg. Apply the default conversions which
4401 would have happened when passed via ellipsis. Return the promoted
4402 type, or the passed type if there is no change. */
4405 cxx_type_promotes_to (tree type)
4409 if (TREE_CODE (type) == ARRAY_TYPE)
4410 return build_pointer_type (TREE_TYPE (type));
4412 if (TREE_CODE (type) == FUNCTION_TYPE)
4413 return build_pointer_type (type);
4415 promote = type_promotes_to (type);
4416 if (same_type_p (type, promote))
4422 /* ARG is a default argument expression being passed to a parameter of
4423 the indicated TYPE, which is a parameter to FN. Do any required
4424 conversions. Return the converted value. */
4427 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4429 /* If the ARG is an unparsed default argument expression, the
4430 conversion cannot be performed. */
4431 if (TREE_CODE (arg) == DEFAULT_ARG)
4433 error ("the default argument for parameter %d of `%D' has "
4434 "not yet been parsed",
4436 return error_mark_node;
4439 if (fn && DECL_TEMPLATE_INFO (fn))
4440 arg = tsubst_default_argument (fn, type, arg);
4442 arg = break_out_target_exprs (arg);
4444 if (TREE_CODE (arg) == CONSTRUCTOR)
4446 arg = digest_init (type, arg, 0);
4447 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4448 "default argument", fn, parmnum);
4452 /* This could get clobbered by the following call. */
4453 if (TREE_HAS_CONSTRUCTOR (arg))
4454 arg = copy_node (arg);
4456 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4457 "default argument", fn, parmnum);
4458 arg = convert_for_arg_passing (type, arg);
4464 /* Returns the type which will really be used for passing an argument of
4468 type_passed_as (tree type)
4470 /* Pass classes with copy ctors by invisible reference. */
4471 if (TREE_ADDRESSABLE (type))
4472 type = build_reference_type (type);
4473 else if (PROMOTE_PROTOTYPES
4474 && INTEGRAL_TYPE_P (type)
4475 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4476 type = integer_type_node;
4481 /* Actually perform the appropriate conversion. */
4484 convert_for_arg_passing (tree type, tree val)
4486 if (val == error_mark_node)
4488 /* Pass classes with copy ctors by invisible reference. */
4489 else if (TREE_ADDRESSABLE (type))
4490 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4491 else if (PROMOTE_PROTOTYPES
4492 && INTEGRAL_TYPE_P (type)
4493 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4494 val = default_conversion (val);
4498 /* Subroutine of the various build_*_call functions. Overload resolution
4499 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4500 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4501 bitmask of various LOOKUP_* flags which apply to the call itself. */
4504 build_over_call (struct z_candidate *cand, int flags)
4507 tree args = cand->args;
4508 tree convs = cand->convs;
4509 tree converted_args = NULL_TREE;
4510 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4511 tree conv, arg, val;
4515 /* Give any warnings we noticed during overload resolution. */
4517 for (val = cand->warnings; val; val = TREE_CHAIN (val))
4518 joust (cand, WRAPPER_ZC (TREE_VALUE (val)), 1);
4520 if (DECL_FUNCTION_MEMBER_P (fn))
4521 perform_or_defer_access_check (cand->access_path, fn);
4523 if (args && TREE_CODE (args) != TREE_LIST)
4524 args = build_tree_list (NULL_TREE, args);
4527 /* The implicit parameters to a constructor are not considered by overload
4528 resolution, and must be of the proper type. */
4529 if (DECL_CONSTRUCTOR_P (fn))
4531 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4532 arg = TREE_CHAIN (arg);
4533 parm = TREE_CHAIN (parm);
4534 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4535 /* We should never try to call the abstract constructor. */
4537 if (DECL_HAS_VTT_PARM_P (fn))
4539 converted_args = tree_cons
4540 (NULL_TREE, TREE_VALUE (arg), converted_args);
4541 arg = TREE_CHAIN (arg);
4542 parm = TREE_CHAIN (parm);
4545 /* Bypass access control for 'this' parameter. */
4546 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4548 tree parmtype = TREE_VALUE (parm);
4549 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4553 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
4554 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4555 TREE_TYPE (argtype), fn);
4557 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4558 X is called for an object that is not of type X, or of a type
4559 derived from X, the behavior is undefined.
4561 So we can assume that anything passed as 'this' is non-null, and
4562 optimize accordingly. */
4563 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4564 /* Convert to the base in which the function was declared. */
4565 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4566 converted_arg = build_base_path (PLUS_EXPR,
4568 cand->conversion_path,
4570 /* If fn was found by a using declaration, the conversion path
4571 will be to the derived class, not the base declaring fn. We
4572 must convert from derived to base. */
4573 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4574 TREE_TYPE (parmtype), ba_ignore, NULL);
4576 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4579 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4580 parm = TREE_CHAIN (parm);
4581 arg = TREE_CHAIN (arg);
4587 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4589 tree type = TREE_VALUE (parm);
4591 conv = TREE_VEC_ELT (convs, i);
4592 val = convert_like_with_context
4593 (conv, TREE_VALUE (arg), fn, i - is_method);
4595 val = convert_for_arg_passing (type, val);
4596 converted_args = tree_cons (NULL_TREE, val, converted_args);
4599 /* Default arguments */
4600 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4602 = tree_cons (NULL_TREE,
4603 convert_default_arg (TREE_VALUE (parm),
4604 TREE_PURPOSE (parm),
4609 for (; arg; arg = TREE_CHAIN (arg))
4611 = tree_cons (NULL_TREE,
4612 convert_arg_to_ellipsis (TREE_VALUE (arg)),
4615 converted_args = nreverse (converted_args);
4618 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4621 /* Avoid actually calling copy constructors and copy assignment operators,
4624 if (! flag_elide_constructors)
4625 /* Do things the hard way. */;
4626 else if (TREE_VEC_LENGTH (convs) == 1
4627 && DECL_COPY_CONSTRUCTOR_P (fn))
4630 arg = skip_artificial_parms_for (fn, converted_args);
4631 arg = TREE_VALUE (arg);
4633 /* Pull out the real argument, disregarding const-correctness. */
4635 while (TREE_CODE (targ) == NOP_EXPR
4636 || TREE_CODE (targ) == NON_LVALUE_EXPR
4637 || TREE_CODE (targ) == CONVERT_EXPR)
4638 targ = TREE_OPERAND (targ, 0);
4639 if (TREE_CODE (targ) == ADDR_EXPR)
4641 targ = TREE_OPERAND (targ, 0);
4642 if (!same_type_ignoring_top_level_qualifiers_p
4643 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4652 arg = build_indirect_ref (arg, 0);
4654 /* [class.copy]: the copy constructor is implicitly defined even if
4655 the implementation elided its use. */
4656 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4659 /* If we're creating a temp and we already have one, don't create a
4660 new one. If we're not creating a temp but we get one, use
4661 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4662 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4663 temp or an INIT_EXPR otherwise. */
4664 if (integer_zerop (TREE_VALUE (args)))
4666 if (TREE_CODE (arg) == TARGET_EXPR)
4668 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4669 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4671 else if (TREE_CODE (arg) == TARGET_EXPR
4672 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4675 tree to = stabilize_reference
4676 (build_indirect_ref (TREE_VALUE (args), 0));
4678 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4679 address = build_unary_op (ADDR_EXPR, val, 0);
4680 /* Avoid a warning about this expression, if the address is
4682 TREE_USED (address) = 1;
4686 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4688 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4690 tree to = stabilize_reference
4691 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4693 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4694 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4700 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4702 tree t, *p = &TREE_VALUE (converted_args);
4703 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4706 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4708 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4709 if (TREE_SIDE_EFFECTS (*p))
4710 *p = save_expr (*p);
4711 t = build_pointer_type (TREE_TYPE (fn));
4712 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4713 fn = build_java_interface_fn_ref (fn, *p);
4715 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4718 else if (DECL_INLINE (fn))
4719 fn = inline_conversion (fn);
4721 fn = build_addr_func (fn);
4723 return build_cxx_call (fn, args, converted_args);
4726 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4727 gives the original form of the arguments. This function performs
4728 no overload resolution, conversion, or other high-level
4732 build_cxx_call(tree fn, tree args, tree converted_args)
4736 /* Recognize certain built-in functions so we can make tree-codes
4737 other than CALL_EXPR. We do this when it enables fold-const.c
4738 to do something useful. */
4739 if (TREE_CODE (fn) == ADDR_EXPR
4740 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4741 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4744 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4749 fn = build_call (fn, converted_args);
4751 /* If this call might throw an exception, note that fact. */
4752 fndecl = get_callee_fndecl (fn);
4753 if ((!fndecl || !TREE_NOTHROW (fndecl))
4754 && at_function_scope_p ()
4756 cp_function_chain->can_throw = 1;
4758 /* Some built-in function calls will be evaluated at compile-time in
4762 if (VOID_TYPE_P (TREE_TYPE (fn)))
4765 fn = require_complete_type (fn);
4766 if (fn == error_mark_node)
4767 return error_mark_node;
4769 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4770 fn = build_cplus_new (TREE_TYPE (fn), fn);
4771 return convert_from_reference (fn);
4774 static GTY(()) tree java_iface_lookup_fn;
4776 /* Make an expression which yields the address of the Java interface
4777 method FN. This is achieved by generating a call to libjava's
4778 _Jv_LookupInterfaceMethodIdx(). */
4781 build_java_interface_fn_ref (tree fn, tree instance)
4783 tree lookup_args, lookup_fn, method, idx;
4784 tree klass_ref, iface, iface_ref;
4787 if (!java_iface_lookup_fn)
4789 tree endlink = build_void_list_node ();
4790 tree t = tree_cons (NULL_TREE, ptr_type_node,
4791 tree_cons (NULL_TREE, ptr_type_node,
4792 tree_cons (NULL_TREE, java_int_type_node,
4794 java_iface_lookup_fn
4795 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4796 build_function_type (ptr_type_node, t),
4797 0, NOT_BUILT_IN, NULL, NULL_TREE);
4800 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4801 This is the first entry in the vtable. */
4802 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4805 /* Get the java.lang.Class pointer for the interface being called. */
4806 iface = DECL_CONTEXT (fn);
4807 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4808 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4809 || DECL_CONTEXT (iface_ref) != iface)
4811 error ("could not find class$ field in java interface type `%T'",
4813 return error_mark_node;
4815 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4817 /* Determine the itable index of FN. */
4819 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4821 if (!DECL_VIRTUAL_P (method))
4827 idx = build_int_2 (i, 0);
4829 lookup_args = tree_cons (NULL_TREE, klass_ref,
4830 tree_cons (NULL_TREE, iface_ref,
4831 build_tree_list (NULL_TREE, idx)));
4832 lookup_fn = build1 (ADDR_EXPR,
4833 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4834 java_iface_lookup_fn);
4835 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4838 /* Returns the value to use for the in-charge parameter when making a
4839 call to a function with the indicated NAME. */
4842 in_charge_arg_for_name (tree name)
4844 if (name == base_ctor_identifier
4845 || name == base_dtor_identifier)
4846 return integer_zero_node;
4847 else if (name == complete_ctor_identifier)
4848 return integer_one_node;
4849 else if (name == complete_dtor_identifier)
4850 return integer_two_node;
4851 else if (name == deleting_dtor_identifier)
4852 return integer_three_node;
4854 /* This function should only be called with one of the names listed
4860 /* Build a call to a constructor, destructor, or an assignment
4861 operator for INSTANCE, an expression with class type. NAME
4862 indicates the special member function to call; ARGS are the
4863 arguments. BINFO indicates the base of INSTANCE that is to be
4864 passed as the `this' parameter to the member function called.
4866 FLAGS are the LOOKUP_* flags to use when processing the call.
4868 If NAME indicates a complete object constructor, INSTANCE may be
4869 NULL_TREE. In this case, the caller will call build_cplus_new to
4870 store the newly constructed object into a VAR_DECL. */
4873 build_special_member_call (tree instance, tree name, tree args,
4874 tree binfo, int flags)
4877 /* The type of the subobject to be constructed or destroyed. */
4880 my_friendly_assert (name == complete_ctor_identifier
4881 || name == base_ctor_identifier
4882 || name == complete_dtor_identifier
4883 || name == base_dtor_identifier
4884 || name == deleting_dtor_identifier
4885 || name == ansi_assopname (NOP_EXPR),
4887 my_friendly_assert (binfo != NULL_TREE, 20020712);
4889 class_type = BINFO_TYPE (binfo);
4891 /* Handle the special case where INSTANCE is NULL_TREE. */
4892 if (name == complete_ctor_identifier && !instance)
4894 instance = build_int_2 (0, 0);
4895 TREE_TYPE (instance) = build_pointer_type (class_type);
4896 instance = build1 (INDIRECT_REF, class_type, instance);
4898 else if (name == complete_dtor_identifier
4899 || name == base_dtor_identifier
4900 || name == deleting_dtor_identifier)
4901 my_friendly_assert (args == NULL_TREE, 20020712);
4903 my_friendly_assert (instance != NULL_TREE, 20020712);
4905 /* Resolve the name. */
4906 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
4907 return error_mark_node;
4909 fns = lookup_fnfields (binfo, name, 1);
4911 /* When making a call to a constructor or destructor for a subobject
4912 that uses virtual base classes, pass down a pointer to a VTT for
4914 if ((name == base_ctor_identifier
4915 || name == base_dtor_identifier)
4916 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
4921 /* If the current function is a complete object constructor
4922 or destructor, then we fetch the VTT directly.
4923 Otherwise, we look it up using the VTT we were given. */
4924 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
4925 vtt = decay_conversion (vtt);
4926 vtt = build (COND_EXPR, TREE_TYPE (vtt),
4927 build (EQ_EXPR, boolean_type_node,
4928 current_in_charge_parm, integer_zero_node),
4931 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
4932 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
4933 BINFO_SUBVTT_INDEX (binfo));
4935 args = tree_cons (NULL_TREE, sub_vtt, args);
4938 return build_new_method_call (instance, fns, args, binfo, flags);
4941 /* Return the NAME, as a C string. The NAME indicates a function that
4942 is a member of TYPE. *FREE_P is set to true if the caller must
4943 free the memory returned.
4945 Rather than go through all of this, we should simply set the names
4946 of constructors and destructors appropriately, and dispense with
4947 ctor_identifier, dtor_identifier, etc. */
4950 name_as_c_string (tree name, tree type, bool *free_p)
4954 /* Assume that we will not allocate memory. */
4956 /* Constructors and destructors are special. */
4957 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4960 = (char *) IDENTIFIER_POINTER (constructor_name (type));
4961 /* For a destructor, add the '~'. */
4962 if (name == complete_dtor_identifier
4963 || name == base_dtor_identifier
4964 || name == deleting_dtor_identifier)
4966 pretty_name = concat ("~", pretty_name, NULL);
4967 /* Remember that we need to free the memory allocated. */
4972 pretty_name = (char *) IDENTIFIER_POINTER (name);
4977 /* Build a call to "INSTANCE.FN (ARGS)". */
4980 build_new_method_call (tree instance, tree fns, tree args,
4981 tree conversion_path, int flags)
4983 struct z_candidate *candidates = 0, *cand;
4984 tree explicit_targs = NULL_TREE;
4985 tree basetype = NULL_TREE;
4988 tree mem_args = NULL_TREE, instance_ptr;
4994 int template_only = 0;
4997 my_friendly_assert (instance != NULL_TREE, 20020729);
4999 if (error_operand_p (instance)
5000 || error_operand_p (fns)
5001 || args == error_mark_node)
5002 return error_mark_node;
5004 /* Process the argument list. */
5006 args = resolve_args (args);
5007 if (args == error_mark_node)
5008 return error_mark_node;
5010 if (TREE_CODE (instance) == OFFSET_REF)
5011 instance = resolve_offset_ref (instance);
5012 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5013 instance = convert_from_reference (instance);
5014 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5015 instance_ptr = build_this (instance);
5017 if (!BASELINK_P (fns))
5019 call = build_field_call (instance_ptr, fns, args);
5022 error ("call to non-function `%D'", fns);
5023 return error_mark_node;
5026 if (!conversion_path)
5027 conversion_path = BASELINK_BINFO (fns);
5028 access_binfo = BASELINK_ACCESS_BINFO (fns);
5029 optype = BASELINK_OPTYPE (fns);
5030 fns = BASELINK_FUNCTIONS (fns);
5032 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5034 explicit_targs = TREE_OPERAND (fns, 1);
5035 fns = TREE_OPERAND (fns, 0);
5039 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
5040 || TREE_CODE (fns) == TEMPLATE_DECL
5041 || TREE_CODE (fns) == OVERLOAD,
5044 /* XXX this should be handled before we get here. */
5045 if (! IS_AGGR_TYPE (basetype))
5047 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5048 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5049 fns, instance, basetype);
5051 return error_mark_node;
5054 fn = get_first_fn (fns);
5055 name = DECL_NAME (fn);
5057 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5059 /* Callers should explicitly indicate whether they want to construct
5060 the complete object or just the part without virtual bases. */
5061 my_friendly_assert (name != ctor_identifier, 20000408);
5062 /* Similarly for destructors. */
5063 my_friendly_assert (name != dtor_identifier, 20000408);
5066 /* It's OK to call destructors on cv-qualified objects. Therefore,
5067 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5068 if (DECL_DESTRUCTOR_P (fn))
5070 tree type = build_pointer_type (basetype);
5071 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5072 instance_ptr = build_nop (type, instance_ptr);
5075 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5076 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5078 for (fn = fns; fn; fn = OVL_NEXT (fn))
5080 tree t = OVL_CURRENT (fn);
5083 /* We can end up here for copy-init of same or base class. */
5084 if ((flags & LOOKUP_ONLYCONVERTING)
5085 && DECL_NONCONVERTING_P (t))
5088 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5089 this_arglist = mem_args;
5091 this_arglist = args;
5093 if (TREE_CODE (t) == TEMPLATE_DECL)
5094 /* A member template. */
5095 add_template_candidate (&candidates, t,
5098 this_arglist, optype,
5103 else if (! template_only)
5104 add_function_candidate (&candidates, t,
5112 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5115 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5116 if (flags & LOOKUP_SPECULATIVELY)
5118 if (!COMPLETE_TYPE_P (basetype))
5119 cxx_incomplete_type_error (instance_ptr, basetype);
5125 pretty_name = name_as_c_string (name, basetype, &free_p);
5126 error ("no matching function for call to `%T::%s(%A)%#V'",
5127 basetype, pretty_name, user_args,
5128 TREE_TYPE (TREE_TYPE (instance_ptr)));
5132 print_z_candidates (candidates);
5133 return error_mark_node;
5136 cand = tourney (candidates);
5142 pretty_name = name_as_c_string (name, basetype, &free_p);
5143 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
5145 print_z_candidates (candidates);
5148 return error_mark_node;
5151 if (DECL_PURE_VIRTUAL_P (cand->fn)
5152 && instance == current_class_ref
5153 && (DECL_CONSTRUCTOR_P (current_function_decl)
5154 || DECL_DESTRUCTOR_P (current_function_decl))
5155 && ! (flags & LOOKUP_NONVIRTUAL)
5156 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
5157 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5158 "abstract virtual `%#D' called from constructor"
5159 : "abstract virtual `%#D' called from destructor"),
5161 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5162 && is_dummy_object (instance_ptr))
5164 error ("cannot call member function `%D' without object", cand->fn);
5165 return error_mark_node;
5168 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5169 && resolves_to_fixed_type_p (instance, 0))
5170 flags |= LOOKUP_NONVIRTUAL;
5172 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE)
5173 call = build_over_call (cand, flags);
5176 call = build_over_call (cand, flags);
5177 /* In an expression of the form `a->f()' where `f' turns out to
5178 be a static member function, `a' is none-the-less evaluated. */
5179 if (!is_dummy_object (instance_ptr) && TREE_SIDE_EFFECTS (instance))
5180 call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call);
5186 /* Returns true iff standard conversion sequence ICS1 is a proper
5187 subsequence of ICS2. */
5190 is_subseq (tree ics1, tree ics2)
5192 /* We can assume that a conversion of the same code
5193 between the same types indicates a subsequence since we only get
5194 here if the types we are converting from are the same. */
5196 while (TREE_CODE (ics1) == RVALUE_CONV
5197 || TREE_CODE (ics1) == LVALUE_CONV)
5198 ics1 = TREE_OPERAND (ics1, 0);
5202 while (TREE_CODE (ics2) == RVALUE_CONV
5203 || TREE_CODE (ics2) == LVALUE_CONV)
5204 ics2 = TREE_OPERAND (ics2, 0);
5206 if (TREE_CODE (ics2) == USER_CONV
5207 || TREE_CODE (ics2) == AMBIG_CONV
5208 || TREE_CODE (ics2) == IDENTITY_CONV)
5209 /* At this point, ICS1 cannot be a proper subsequence of
5210 ICS2. We can get a USER_CONV when we are comparing the
5211 second standard conversion sequence of two user conversion
5215 ics2 = TREE_OPERAND (ics2, 0);
5217 if (TREE_CODE (ics2) == TREE_CODE (ics1)
5218 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
5219 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
5220 TREE_TYPE (TREE_OPERAND (ics1, 0))))
5225 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5226 be any _TYPE nodes. */
5229 is_properly_derived_from (tree derived, tree base)
5231 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5232 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5235 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5236 considers every class derived from itself. */
5237 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5238 && DERIVED_FROM_P (base, derived));
5241 /* We build the ICS for an implicit object parameter as a pointer
5242 conversion sequence. However, such a sequence should be compared
5243 as if it were a reference conversion sequence. If ICS is the
5244 implicit conversion sequence for an implicit object parameter,
5245 modify it accordingly. */
5248 maybe_handle_implicit_object (tree *ics)
5250 if (ICS_THIS_FLAG (*ics))
5252 /* [over.match.funcs]
5254 For non-static member functions, the type of the
5255 implicit object parameter is "reference to cv X"
5256 where X is the class of which the function is a
5257 member and cv is the cv-qualification on the member
5258 function declaration. */
5260 tree reference_type;
5262 /* The `this' parameter is a pointer to a class type. Make the
5263 implict conversion talk about a reference to that same class
5265 reference_type = TREE_TYPE (TREE_TYPE (*ics));
5266 reference_type = build_reference_type (reference_type);
5268 if (TREE_CODE (t) == QUAL_CONV)
5269 t = TREE_OPERAND (t, 0);
5270 if (TREE_CODE (t) == PTR_CONV)
5271 t = TREE_OPERAND (t, 0);
5272 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
5273 t = direct_reference_binding (reference_type, t);
5278 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5279 and return the type to which the reference refers. Otherwise,
5280 leave *ICS unchanged and return NULL_TREE. */
5283 maybe_handle_ref_bind (tree *ics)
5285 if (TREE_CODE (*ics) == REF_BIND)
5287 tree old_ics = *ics;
5288 tree type = TREE_TYPE (TREE_TYPE (old_ics));
5289 *ics = TREE_OPERAND (old_ics, 0);
5290 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
5291 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
5298 /* Compare two implicit conversion sequences according to the rules set out in
5299 [over.ics.rank]. Return values:
5301 1: ics1 is better than ics2
5302 -1: ics2 is better than ics1
5303 0: ics1 and ics2 are indistinguishable */
5306 compare_ics (tree ics1, tree ics2)
5312 tree deref_from_type1 = NULL_TREE;
5313 tree deref_from_type2 = NULL_TREE;
5314 tree deref_to_type1 = NULL_TREE;
5315 tree deref_to_type2 = NULL_TREE;
5318 /* REF_BINDING is nonzero if the result of the conversion sequence
5319 is a reference type. In that case TARGET_TYPE is the
5320 type referred to by the reference. */
5324 /* Handle implicit object parameters. */
5325 maybe_handle_implicit_object (&ics1);
5326 maybe_handle_implicit_object (&ics2);
5328 /* Handle reference parameters. */
5329 target_type1 = maybe_handle_ref_bind (&ics1);
5330 target_type2 = maybe_handle_ref_bind (&ics2);
5334 When comparing the basic forms of implicit conversion sequences (as
5335 defined in _over.best.ics_)
5337 --a standard conversion sequence (_over.ics.scs_) is a better
5338 conversion sequence than a user-defined conversion sequence
5339 or an ellipsis conversion sequence, and
5341 --a user-defined conversion sequence (_over.ics.user_) is a
5342 better conversion sequence than an ellipsis conversion sequence
5343 (_over.ics.ellipsis_). */
5344 rank1 = ICS_RANK (ics1);
5345 rank2 = ICS_RANK (ics2);
5349 else if (rank1 < rank2)
5352 if (rank1 == BAD_RANK)
5354 /* XXX Isn't this an extension? */
5355 /* Both ICS are bad. We try to make a decision based on what
5356 would have happenned if they'd been good. */
5357 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5358 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5360 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5361 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5364 /* We couldn't make up our minds; try to figure it out below. */
5367 if (ICS_ELLIPSIS_FLAG (ics1))
5368 /* Both conversions are ellipsis conversions. */
5371 /* User-defined conversion sequence U1 is a better conversion sequence
5372 than another user-defined conversion sequence U2 if they contain the
5373 same user-defined conversion operator or constructor and if the sec-
5374 ond standard conversion sequence of U1 is better than the second
5375 standard conversion sequence of U2. */
5377 if (ICS_USER_FLAG (ics1))
5381 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5382 if (TREE_CODE (t1) == AMBIG_CONV)
5384 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5385 if (TREE_CODE (t2) == AMBIG_CONV)
5388 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5391 /* We can just fall through here, after setting up
5392 FROM_TYPE1 and FROM_TYPE2. */
5393 from_type1 = TREE_TYPE (t1);
5394 from_type2 = TREE_TYPE (t2);
5398 /* We're dealing with two standard conversion sequences.
5402 Standard conversion sequence S1 is a better conversion
5403 sequence than standard conversion sequence S2 if
5405 --S1 is a proper subsequence of S2 (comparing the conversion
5406 sequences in the canonical form defined by _over.ics.scs_,
5407 excluding any Lvalue Transformation; the identity
5408 conversion sequence is considered to be a subsequence of
5409 any non-identity conversion sequence */
5412 while (TREE_CODE (from_type1) != IDENTITY_CONV)
5413 from_type1 = TREE_OPERAND (from_type1, 0);
5414 from_type1 = TREE_TYPE (from_type1);
5417 while (TREE_CODE (from_type2) != IDENTITY_CONV)
5418 from_type2 = TREE_OPERAND (from_type2, 0);
5419 from_type2 = TREE_TYPE (from_type2);
5422 if (same_type_p (from_type1, from_type2))
5424 if (is_subseq (ics1, ics2))
5426 if (is_subseq (ics2, ics1))
5429 /* Otherwise, one sequence cannot be a subsequence of the other; they
5430 don't start with the same type. This can happen when comparing the
5431 second standard conversion sequence in two user-defined conversion
5438 --the rank of S1 is better than the rank of S2 (by the rules
5441 Standard conversion sequences are ordered by their ranks: an Exact
5442 Match is a better conversion than a Promotion, which is a better
5443 conversion than a Conversion.
5445 Two conversion sequences with the same rank are indistinguishable
5446 unless one of the following rules applies:
5448 --A conversion that is not a conversion of a pointer, or pointer
5449 to member, to bool is better than another conversion that is such
5452 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5453 so that we do not have to check it explicitly. */
5454 if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5456 else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1))
5459 to_type1 = TREE_TYPE (ics1);
5460 to_type2 = TREE_TYPE (ics2);
5462 if (TYPE_PTR_P (from_type1)
5463 && TYPE_PTR_P (from_type2)
5464 && TYPE_PTR_P (to_type1)
5465 && TYPE_PTR_P (to_type2))
5467 deref_from_type1 = TREE_TYPE (from_type1);
5468 deref_from_type2 = TREE_TYPE (from_type2);
5469 deref_to_type1 = TREE_TYPE (to_type1);
5470 deref_to_type2 = TREE_TYPE (to_type2);
5472 /* The rules for pointers to members A::* are just like the rules
5473 for pointers A*, except opposite: if B is derived from A then
5474 A::* converts to B::*, not vice versa. For that reason, we
5475 switch the from_ and to_ variables here. */
5476 else if (TYPE_PTRMEM_P (from_type1)
5477 && TYPE_PTRMEM_P (from_type2)
5478 && TYPE_PTRMEM_P (to_type1)
5479 && TYPE_PTRMEM_P (to_type2))
5481 deref_to_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type1));
5482 deref_to_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type2));
5483 deref_from_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type1));
5484 deref_from_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type2));
5486 else if (TYPE_PTRMEMFUNC_P (from_type1)
5487 && TYPE_PTRMEMFUNC_P (from_type2)
5488 && TYPE_PTRMEMFUNC_P (to_type1)
5489 && TYPE_PTRMEMFUNC_P (to_type2))
5491 deref_to_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type1);
5492 deref_to_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type2);
5493 deref_from_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type1);
5494 deref_from_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type2);
5497 if (deref_from_type1 != NULL_TREE
5498 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5499 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5501 /* This was one of the pointer or pointer-like conversions.
5505 --If class B is derived directly or indirectly from class A,
5506 conversion of B* to A* is better than conversion of B* to
5507 void*, and conversion of A* to void* is better than
5508 conversion of B* to void*. */
5509 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5510 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5512 if (is_properly_derived_from (deref_from_type1,
5515 else if (is_properly_derived_from (deref_from_type2,
5519 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5520 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5522 if (same_type_p (deref_from_type1, deref_from_type2))
5524 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5526 if (is_properly_derived_from (deref_from_type1,
5530 /* We know that DEREF_TO_TYPE1 is `void' here. */
5531 else if (is_properly_derived_from (deref_from_type1,
5536 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5537 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5541 --If class B is derived directly or indirectly from class A
5542 and class C is derived directly or indirectly from B,
5544 --conversion of C* to B* is better than conversion of C* to
5547 --conversion of B* to A* is better than conversion of C* to
5549 if (same_type_p (deref_from_type1, deref_from_type2))
5551 if (is_properly_derived_from (deref_to_type1,
5554 else if (is_properly_derived_from (deref_to_type2,
5558 else if (same_type_p (deref_to_type1, deref_to_type2))
5560 if (is_properly_derived_from (deref_from_type2,
5563 else if (is_properly_derived_from (deref_from_type1,
5569 else if (CLASS_TYPE_P (non_reference (from_type1))
5570 && same_type_p (from_type1, from_type2))
5572 tree from = non_reference (from_type1);
5576 --binding of an expression of type C to a reference of type
5577 B& is better than binding an expression of type C to a
5578 reference of type A&
5580 --conversion of C to B is better than conversion of C to A, */
5581 if (is_properly_derived_from (from, to_type1)
5582 && is_properly_derived_from (from, to_type2))
5584 if (is_properly_derived_from (to_type1, to_type2))
5586 else if (is_properly_derived_from (to_type2, to_type1))
5590 else if (CLASS_TYPE_P (non_reference (to_type1))
5591 && same_type_p (to_type1, to_type2))
5593 tree to = non_reference (to_type1);
5597 --binding of an expression of type B to a reference of type
5598 A& is better than binding an expression of type C to a
5599 reference of type A&,
5601 --onversion of B to A is better than conversion of C to A */
5602 if (is_properly_derived_from (from_type1, to)
5603 && is_properly_derived_from (from_type2, to))
5605 if (is_properly_derived_from (from_type2, from_type1))
5607 else if (is_properly_derived_from (from_type1, from_type2))
5614 --S1 and S2 differ only in their qualification conversion and yield
5615 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5616 qualification signature of type T1 is a proper subset of the cv-
5617 qualification signature of type T2 */
5618 if (TREE_CODE (ics1) == QUAL_CONV
5619 && TREE_CODE (ics2) == QUAL_CONV
5620 && same_type_p (from_type1, from_type2))
5621 return comp_cv_qual_signature (to_type1, to_type2);
5625 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5626 types to which the references refer are the same type except for
5627 top-level cv-qualifiers, and the type to which the reference
5628 initialized by S2 refers is more cv-qualified than the type to
5629 which the reference initialized by S1 refers */
5631 if (target_type1 && target_type2
5632 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5633 return comp_cv_qualification (target_type2, target_type1);
5635 /* Neither conversion sequence is better than the other. */
5639 /* The source type for this standard conversion sequence. */
5642 source_type (tree t)
5644 for (;; t = TREE_OPERAND (t, 0))
5646 if (TREE_CODE (t) == USER_CONV
5647 || TREE_CODE (t) == AMBIG_CONV
5648 || TREE_CODE (t) == IDENTITY_CONV)
5649 return TREE_TYPE (t);
5654 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5655 a pointer to LOSER and re-running joust to produce the warning if WINNER
5656 is actually used. */
5659 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5661 winner->warnings = tree_cons (NULL_TREE,
5662 build_zc_wrapper (loser),
5666 /* Compare two candidates for overloading as described in
5667 [over.match.best]. Return values:
5669 1: cand1 is better than cand2
5670 -1: cand2 is better than cand1
5671 0: cand1 and cand2 are indistinguishable */
5674 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5677 int i, off1 = 0, off2 = 0, len;
5679 /* Candidates that involve bad conversions are always worse than those
5681 if (cand1->viable > cand2->viable)
5683 if (cand1->viable < cand2->viable)
5686 /* If we have two pseudo-candidates for conversions to the same type,
5687 or two candidates for the same function, arbitrarily pick one. */
5688 if (cand1->fn == cand2->fn
5689 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5692 /* a viable function F1
5693 is defined to be a better function than another viable function F2 if
5694 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5695 ICSi(F2), and then */
5697 /* for some argument j, ICSj(F1) is a better conversion sequence than
5700 /* For comparing static and non-static member functions, we ignore
5701 the implicit object parameter of the non-static function. The
5702 standard says to pretend that the static function has an object
5703 parm, but that won't work with operator overloading. */
5704 len = TREE_VEC_LENGTH (cand1->convs);
5705 if (len != TREE_VEC_LENGTH (cand2->convs))
5707 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5708 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5710 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5711 && DECL_STATIC_FUNCTION_P (cand2->fn))
5720 for (i = 0; i < len; ++i)
5722 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5723 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5724 int comp = compare_ics (t1, t2);
5729 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5730 && TREE_CODE (t1) == STD_CONV
5731 && TREE_CODE (t2) == STD_CONV
5732 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5733 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5734 && (TYPE_PRECISION (TREE_TYPE (t1))
5735 == TYPE_PRECISION (TREE_TYPE (t2)))
5736 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5737 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5740 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5742 struct z_candidate *w, *l;
5744 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5745 w = cand1, l = cand2;
5747 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5748 w = cand2, l = cand1;
5752 warning ("passing `%T' chooses `%T' over `%T'",
5753 type, type1, type2);
5754 warning (" in call to `%D'", w->fn);
5760 if (winner && comp != winner)
5769 /* warn about confusing overload resolution for user-defined conversions,
5770 either between a constructor and a conversion op, or between two
5772 if (winner && cand1->second_conv
5773 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5774 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5776 struct z_candidate *w, *l;
5777 bool give_warning = false;
5780 w = cand1, l = cand2;
5782 w = cand2, l = cand1;
5784 /* We don't want to complain about `X::operator T1 ()'
5785 beating `X::operator T2 () const', when T2 is a no less
5786 cv-qualified version of T1. */
5787 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5788 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5790 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5791 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5793 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5798 if (!comp_ptr_ttypes (t, f))
5799 give_warning = true;
5802 give_warning = true;
5808 tree source = source_type (TREE_VEC_ELT (w->convs, 0));
5809 if (! DECL_CONSTRUCTOR_P (w->fn))
5810 source = TREE_TYPE (source);
5811 warning ("choosing `%D' over `%D'", w->fn, l->fn);
5812 warning (" for conversion from `%T' to `%T'",
5813 source, TREE_TYPE (w->second_conv));
5814 warning (" because conversion sequence for the argument is better");
5824 F1 is a non-template function and F2 is a template function
5827 if (! cand1->template && cand2->template)
5829 else if (cand1->template && ! cand2->template)
5833 F1 and F2 are template functions and the function template for F1 is
5834 more specialized than the template for F2 according to the partial
5837 if (cand1->template && cand2->template)
5839 winner = more_specialized
5840 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
5842 /* Tell the deduction code how many real function arguments
5843 we saw, not counting the implicit 'this' argument. But,
5844 add_function_candidate() suppresses the "this" argument
5847 [temp.func.order]: The presence of unused ellipsis and default
5848 arguments has no effect on the partial ordering of function
5850 TREE_VEC_LENGTH (cand1->convs)
5851 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
5852 - DECL_CONSTRUCTOR_P (cand1->fn)));
5858 the context is an initialization by user-defined conversion (see
5859 _dcl.init_ and _over.match.user_) and the standard conversion
5860 sequence from the return type of F1 to the destination type (i.e.,
5861 the type of the entity being initialized) is a better conversion
5862 sequence than the standard conversion sequence from the return type
5863 of F2 to the destination type. */
5865 if (cand1->second_conv)
5867 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5872 /* Check whether we can discard a builtin candidate, either because we
5873 have two identical ones or matching builtin and non-builtin candidates.
5875 (Pedantically in the latter case the builtin which matched the user
5876 function should not be added to the overload set, but we spot it here.
5879 ... the builtin candidates include ...
5880 - do not have the same parameter type list as any non-template
5881 non-member candidate. */
5883 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
5884 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
5886 for (i = 0; i < len; ++i)
5887 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5888 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i))))
5890 if (i == TREE_VEC_LENGTH (cand1->convs))
5892 if (cand1->fn == cand2->fn)
5893 /* Two built-in candidates; arbitrarily pick one. */
5895 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5896 /* cand1 is built-in; prefer cand2. */
5899 /* cand2 is built-in; prefer cand1. */
5904 /* If the two functions are the same (this can happen with declarations
5905 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5906 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
5907 && equal_functions (cand1->fn, cand2->fn))
5912 /* Extension: If the worst conversion for one candidate is worse than the
5913 worst conversion for the other, take the first. */
5916 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
5917 struct z_candidate *w = 0, *l = 0;
5919 for (i = 0; i < len; ++i)
5921 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5922 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5923 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5924 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5927 winner = 1, w = cand1, l = cand2;
5929 winner = -1, w = cand2, l = cand1;
5935 ISO C++ says that these are ambiguous, even \
5936 though the worst conversion for the first is better than \
5937 the worst conversion for the second:");
5938 print_z_candidate (_("candidate 1:"), w);
5939 print_z_candidate (_("candidate 2:"), l);
5947 my_friendly_assert (!winner, 20010121);
5951 /* Given a list of candidates for overloading, find the best one, if any.
5952 This algorithm has a worst case of O(2n) (winner is last), and a best
5953 case of O(n/2) (totally ambiguous); much better than a sorting
5956 static struct z_candidate *
5957 tourney (struct z_candidate *candidates)
5959 struct z_candidate *champ = candidates, *challenger;
5961 int champ_compared_to_predecessor = 0;
5963 /* Walk through the list once, comparing each current champ to the next
5964 candidate, knocking out a candidate or two with each comparison. */
5966 for (challenger = champ->next; challenger; )
5968 fate = joust (champ, challenger, 0);
5970 challenger = challenger->next;
5975 champ = challenger->next;
5978 champ_compared_to_predecessor = 0;
5983 champ_compared_to_predecessor = 1;
5986 challenger = champ->next;
5990 /* Make sure the champ is better than all the candidates it hasn't yet
5991 been compared to. */
5993 for (challenger = candidates;
5995 && !(champ_compared_to_predecessor && challenger->next == champ);
5996 challenger = challenger->next)
5998 fate = joust (champ, challenger, 0);
6006 /* Returns nonzero if things of type FROM can be converted to TO. */
6009 can_convert (tree to, tree from)
6011 return can_convert_arg (to, from, NULL_TREE);
6014 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6017 can_convert_arg (tree to, tree from, tree arg)
6019 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6020 return (t && ! ICS_BAD_FLAG (t));
6023 /* Like can_convert_arg, but allows dubious conversions as well. */
6026 can_convert_arg_bad (tree to, tree from, tree arg)
6028 return implicit_conversion (to, from, arg, LOOKUP_NORMAL) != 0;
6031 /* Convert EXPR to TYPE. Return the converted expression.
6033 Note that we allow bad conversions here because by the time we get to
6034 this point we are committed to doing the conversion. If we end up
6035 doing a bad conversion, convert_like will complain. */
6038 perform_implicit_conversion (tree type, tree expr)
6042 if (error_operand_p (expr))
6043 return error_mark_node;
6044 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6048 error ("could not convert `%E' to `%T'", expr, type);
6049 return error_mark_node;
6052 return convert_like (conv, expr);
6055 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6056 is being bound to a temporary. Create and return a new VAR_DECL
6057 with the indicated TYPE; this variable will store the value to
6058 which the reference is bound. */
6061 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6065 /* Create the variable. */
6066 var = build_decl (VAR_DECL, NULL_TREE, type);
6067 DECL_ARTIFICIAL (var) = 1;
6068 TREE_USED (var) = 1;
6070 /* Register the variable. */
6071 if (TREE_STATIC (decl))
6073 /* Namespace-scope or local static; give it a mangled name. */
6076 TREE_STATIC (var) = 1;
6077 name = mangle_ref_init_variable (decl);
6078 DECL_NAME (var) = name;
6079 SET_DECL_ASSEMBLER_NAME (var, name);
6080 var = pushdecl_top_level (var);
6084 /* Create a new cleanup level if necessary. */
6085 maybe_push_cleanup_level (type);
6086 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6087 DECL_CONTEXT (var) = current_function_decl;
6093 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6094 initializing a variable of that TYPE. If DECL is non-NULL, it is
6095 the VAR_DECL being initialized with the EXPR. (In that case, the
6096 type of DECL will be TYPE.)
6098 Return the converted expression. */
6101 initialize_reference (tree type, tree expr, tree decl)
6105 if (type == error_mark_node || error_operand_p (expr))
6106 return error_mark_node;
6108 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6109 if (!conv || ICS_BAD_FLAG (conv))
6111 error ("could not convert `%E' to `%T'", expr, type);
6112 return error_mark_node;
6115 /* If DECL is non-NULL, then this special rule applies:
6119 The temporary to which the reference is bound or the temporary
6120 that is the complete object to which the reference is bound
6121 persists for the lifetime of the reference.
6123 The temporaries created during the evaluation of the expression
6124 initializing the reference, except the temporary to which the
6125 reference is bound, are destroyed at the end of the
6126 full-expression in which they are created.
6128 In that case, we store the converted expression into a new
6129 VAR_DECL in a new scope.
6131 However, we want to be careful not to create temporaries when
6132 they are not required. For example, given:
6135 struct D : public B {};
6139 there is no need to copy the return value from "f"; we can just
6140 extend its lifetime. Similarly, given:
6143 struct T { operator S(); };
6147 we can extend the lifetime of the return value of the conversion
6149 my_friendly_assert (TREE_CODE (conv) == REF_BIND, 20030302);
6153 tree base_conv_type;
6155 /* Skip over the REF_BIND. */
6156 conv = TREE_OPERAND (conv, 0);
6157 /* If the next conversion is a BASE_CONV, skip that too -- but
6158 remember that the conversion was required. */
6159 if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv))
6161 base_conv_type = TREE_TYPE (conv);
6162 conv = TREE_OPERAND (conv, 0);
6165 base_conv_type = NULL_TREE;
6166 /* Perform the remainder of the conversion. */
6167 expr = convert_like (conv, expr);
6168 if (!real_non_cast_lvalue_p (expr))
6173 /* Create the temporary variable. */
6174 type = TREE_TYPE (expr);
6175 var = make_temporary_var_for_ref_to_temp (decl, type);
6176 layout_decl (var, 0);
6177 if (at_function_scope_p ())
6181 add_decl_stmt (var);
6182 cleanup = cxx_maybe_build_cleanup (var);
6184 finish_decl_cleanup (var, cleanup);
6188 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6189 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6190 static_aggregates = tree_cons (NULL_TREE, var,
6193 init = build (INIT_EXPR, type, var, expr);
6194 /* Use its address to initialize the reference variable. */
6195 expr = build_address (var);
6196 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6199 /* Take the address of EXPR. */
6200 expr = build_unary_op (ADDR_EXPR, expr, 0);
6201 /* If a BASE_CONV was required, perform it now. */
6203 expr = (perform_implicit_conversion
6204 (build_pointer_type (base_conv_type), expr));
6205 return build_nop (type, expr);
6208 /* Perform the conversion. */
6209 return convert_like (conv, expr);
6212 #include "gt-cp-call.h"