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 /*issue_conversion_warnings=*/true)
51 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
52 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
53 /*issue_conversion_warnings=*/true)
54 static tree convert_like_real (tree, tree, tree, int, int, bool);
55 static void op_error (enum tree_code, enum tree_code, tree, tree,
57 static tree build_object_call (tree, tree);
58 static tree resolve_args (tree);
59 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
60 static void print_z_candidate (const char *, struct z_candidate *);
61 static void print_z_candidates (struct z_candidate *);
62 static tree build_this (tree);
63 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
64 static bool any_strictly_viable (struct z_candidate *);
65 static struct z_candidate *add_template_candidate
66 (struct z_candidate **, tree, tree, tree, tree, tree,
67 tree, tree, int, unification_kind_t);
68 static struct z_candidate *add_template_candidate_real
69 (struct z_candidate **, tree, tree, tree, tree, tree,
70 tree, tree, int, tree, unification_kind_t);
71 static struct z_candidate *add_template_conv_candidate
72 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
73 static void add_builtin_candidates
74 (struct z_candidate **, enum tree_code, enum tree_code,
76 static void add_builtin_candidate
77 (struct z_candidate **, enum tree_code, enum tree_code,
78 tree, tree, tree, tree *, tree *, int);
79 static bool is_complete (tree);
80 static void build_builtin_candidate
81 (struct z_candidate **, tree, tree, tree, tree *, tree *,
83 static struct z_candidate *add_conv_candidate
84 (struct z_candidate **, tree, tree, tree, tree, tree);
85 static struct z_candidate *add_function_candidate
86 (struct z_candidate **, tree, tree, tree, tree, tree, int);
87 static tree implicit_conversion (tree, tree, tree, int);
88 static tree standard_conversion (tree, tree, tree);
89 static tree reference_binding (tree, tree, tree, int);
90 static tree non_reference (tree);
91 static tree build_conv (enum tree_code, tree, tree);
92 static bool is_subseq (tree, tree);
93 static tree maybe_handle_ref_bind (tree *);
94 static void maybe_handle_implicit_object (tree *);
95 static struct z_candidate *add_candidate
96 (struct z_candidate **, tree, tree, tree, tree, tree, int);
97 static tree source_type (tree);
98 static void add_warning (struct z_candidate *, struct z_candidate *);
99 static bool reference_related_p (tree, tree);
100 static bool reference_compatible_p (tree, tree);
101 static tree convert_class_to_reference (tree, tree, tree);
102 static tree direct_reference_binding (tree, tree);
103 static bool promoted_arithmetic_type_p (tree);
104 static tree conditional_conversion (tree, tree);
105 static char *name_as_c_string (tree, tree, bool *);
106 static tree call_builtin_trap (void);
107 static tree prep_operand (tree);
108 static void add_candidates (tree, tree, tree, bool, tree, tree,
109 int, struct z_candidate **);
110 static tree merge_conversion_sequences (tree, tree);
113 build_vfield_ref (tree datum, tree type)
115 if (datum == error_mark_node)
116 return error_mark_node;
118 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
119 datum = convert_from_reference (datum);
121 if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
122 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
123 datum = convert_to_base (datum, type, /*check_access=*/false);
125 return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
126 datum, TYPE_VFIELD (type));
129 /* Build a call to a member of an object. I.e., one that overloads
130 operator ()(), or is a pointer-to-function or pointer-to-method. */
133 build_field_call (tree instance_ptr, tree decl, tree parms)
137 if (decl == error_mark_node || decl == NULL_TREE)
140 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
142 /* If it's a field, try overloading operator (),
143 or calling if the field is a pointer-to-function. */
144 instance = build_indirect_ref (instance_ptr, NULL);
145 instance = build_class_member_access_expr (instance, decl,
146 /*access_path=*/NULL_TREE,
147 /*preserve_reference=*/false);
149 if (instance == error_mark_node)
150 return error_mark_node;
152 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
153 return build_new_op (CALL_EXPR, LOOKUP_NORMAL,
154 instance, parms, NULL_TREE);
155 else if (TREE_CODE (TREE_TYPE (instance)) == FUNCTION_TYPE
156 || (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE
157 && (TREE_CODE (TREE_TYPE (TREE_TYPE (instance)))
159 return build_function_call (instance, parms);
165 /* Returns nonzero iff the destructor name specified in NAME
166 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
170 check_dtor_name (tree basetype, tree name)
172 name = TREE_OPERAND (name, 0);
174 /* Just accept something we've already complained about. */
175 if (name == error_mark_node)
178 if (TREE_CODE (name) == TYPE_DECL)
179 name = TREE_TYPE (name);
180 else if (TYPE_P (name))
182 else if (TREE_CODE (name) == IDENTIFIER_NODE)
184 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
185 || (TREE_CODE (basetype) == ENUMERAL_TYPE
186 && name == TYPE_IDENTIFIER (basetype)))
189 name = get_type_value (name);
193 template <class T> struct S { ~S(); };
197 NAME will be a class template. */
198 else if (DECL_CLASS_TEMPLATE_P (name))
203 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
208 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
209 This is how virtual function calls are avoided. */
212 build_scoped_method_call (tree exp, tree basetype, tree name, tree parms)
214 /* Because this syntactic form does not allow
215 a pointer to a base class to be `stolen',
216 we need not protect the derived->base conversion
219 @@ But we do have to check access privileges later. */
221 tree type = TREE_TYPE (exp);
223 if (type == error_mark_node
224 || basetype == error_mark_node)
225 return error_mark_node;
227 if (processing_template_decl)
229 name = build_min_nt (SCOPE_REF, basetype, name);
230 return build_min_nt (METHOD_CALL_EXPR, name, exp, parms, NULL_TREE);
233 if (TREE_CODE (type) == REFERENCE_TYPE)
234 type = TREE_TYPE (type);
236 if (TREE_CODE (basetype) == TREE_VEC)
239 basetype = BINFO_TYPE (binfo);
244 /* Check the destructor call syntax. */
245 if (TREE_CODE (name) == BIT_NOT_EXPR)
247 /* We can get here if someone writes their destructor call like
248 `obj.NS::~T()'; this isn't really a scoped method call, so hand
250 if (TREE_CODE (basetype) == NAMESPACE_DECL)
251 return build_method_call (exp, name, parms, NULL_TREE, LOOKUP_NORMAL);
253 if (! check_dtor_name (basetype, name))
254 error ("qualified type `%T' does not match destructor name `~%T'",
255 basetype, TREE_OPERAND (name, 0));
257 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
258 that explicit ~int is caught in the parser; this deals with typedefs
259 and template parms. */
260 if (! IS_AGGR_TYPE (basetype))
262 if (TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (basetype))
263 error ("type of `%E' does not match destructor type `%T' (type was `%T')",
264 exp, basetype, type);
266 return convert_to_void (exp, /*implicit=*/NULL);
270 if (TREE_CODE (basetype) == NAMESPACE_DECL)
272 error ("`%D' is a namespace", basetype);
273 return error_mark_node;
275 if (! is_aggr_type (basetype, 1))
276 return error_mark_node;
278 if (! IS_AGGR_TYPE (type))
280 error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
282 return error_mark_node;
285 decl = build_scoped_ref (exp, basetype, &binfo);
289 /* Call to a destructor. */
290 if (TREE_CODE (name) == BIT_NOT_EXPR)
292 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl)))
293 return convert_to_void (exp, /*implicit=*/NULL);
295 return build_delete (TREE_TYPE (decl), decl,
296 sfk_complete_destructor,
297 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR,
301 /* Call to a method. */
302 return build_method_call (decl, name, parms, binfo,
303 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
305 return error_mark_node;
308 /* We want the address of a function or method. We avoid creating a
309 pointer-to-member function. */
312 build_addr_func (tree function)
314 tree type = TREE_TYPE (function);
316 /* We have to do these by hand to avoid real pointer to member
318 if (TREE_CODE (type) == METHOD_TYPE)
320 if (TREE_CODE (function) == OFFSET_REF)
322 tree object = build_address (TREE_OPERAND (function, 0));
323 return get_member_function_from_ptrfunc (&object,
324 TREE_OPERAND (function, 1));
326 function = build_address (function);
329 function = decay_conversion (function);
334 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
335 POINTER_TYPE to those. Note, pointer to member function types
336 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
339 build_call (tree function, tree parms)
341 int is_constructor = 0;
348 function = build_addr_func (function);
350 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
352 sorry ("unable to call pointer to member function here");
353 return error_mark_node;
356 fntype = TREE_TYPE (TREE_TYPE (function));
357 result_type = TREE_TYPE (fntype);
359 if (TREE_CODE (function) == ADDR_EXPR
360 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
361 decl = TREE_OPERAND (function, 0);
365 /* We check both the decl and the type; a function may be known not to
366 throw without being declared throw(). */
367 nothrow = ((decl && TREE_NOTHROW (decl))
368 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
370 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
371 current_function_returns_abnormally = 1;
373 if (decl && TREE_DEPRECATED (decl))
374 warn_deprecated_use (decl);
375 require_complete_eh_spec_types (fntype, decl);
377 if (decl && DECL_CONSTRUCTOR_P (decl))
380 if (decl && ! TREE_USED (decl))
382 /* We invoke build_call directly for several library functions.
383 These may have been declared normally if we're building libgcc,
384 so we can't just check DECL_ARTIFICIAL. */
385 if (DECL_ARTIFICIAL (decl)
386 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
392 /* Don't pass empty class objects by value. This is useful
393 for tags in STL, which are used to control overload resolution.
394 We don't need to handle other cases of copying empty classes. */
395 if (! decl || ! DECL_BUILT_IN (decl))
396 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
397 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
398 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
400 tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
401 TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
402 TREE_VALUE (tmp), t);
405 function = build_nt (CALL_EXPR, function, parms, NULL_TREE);
406 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
407 TREE_TYPE (function) = result_type;
408 TREE_SIDE_EFFECTS (function) = 1;
409 TREE_NOTHROW (function) = nothrow;
414 /* Build something of the form ptr->method (args)
415 or object.method (args). This can also build
416 calls to constructors, and find friends.
418 Member functions always take their class variable
421 INSTANCE is a class instance.
423 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
425 PARMS help to figure out what that NAME really refers to.
427 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
428 down to the real instance type to use for access checking. We need this
429 information to get protected accesses correct. This parameter is used
430 by build_member_call.
432 FLAGS is the logical disjunction of zero or more LOOKUP_
433 flags. See cp-tree.h for more info.
435 If this is all OK, calls build_function_call with the resolved
438 This function must also handle being called to perform
439 initialization, promotion/coercion of arguments, and
440 instantiation of default parameters.
442 Note that NAME may refer to an instance variable name. If
443 `operator()()' is defined for the type of that field, then we return
446 #ifdef GATHER_STATISTICS
447 extern int n_build_method_call;
451 build_method_call (tree instance, tree name, tree parms,
452 tree basetype_path, int flags)
456 tree template_args = NULL_TREE;
457 bool has_template_args = false;
459 #ifdef GATHER_STATISTICS
460 n_build_method_call++;
463 if (instance == error_mark_node
464 || name == error_mark_node
465 || parms == error_mark_node
466 || (instance && TREE_TYPE (instance) == error_mark_node))
467 return error_mark_node;
469 if (processing_template_decl)
470 return build_min_nt (METHOD_CALL_EXPR, name, instance, parms, NULL_TREE);
472 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
473 instance = convert_from_reference (instance);
474 object_type = TREE_TYPE (instance);
476 if (TREE_CODE (name) == BIT_NOT_EXPR)
481 error ("destructors take no parameters");
483 if (! check_dtor_name (object_type, name))
485 ("destructor name `~%T' does not match type `%T' of expression",
486 TREE_OPERAND (name, 0), object_type);
488 if (! TYPE_HAS_DESTRUCTOR (complete_type (object_type)))
489 return convert_to_void (instance, /*implicit=*/NULL);
490 instance = default_conversion (instance);
491 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
492 return build_delete (build_pointer_type (object_type),
493 instance_ptr, sfk_complete_destructor,
494 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
497 if (!CLASS_TYPE_P (object_type))
499 if ((flags & LOOKUP_COMPLAIN)
500 && TREE_TYPE (instance) != error_mark_node)
501 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
502 name, instance, object_type);
503 return error_mark_node;
506 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
508 template_args = TREE_OPERAND (name, 1);
509 has_template_args = true;
510 name = TREE_OPERAND (name, 0);
512 if (TREE_CODE (name) == OVERLOAD)
513 name = DECL_NAME (get_first_fn (name));
514 else if (DECL_P (name))
515 name = DECL_NAME (name);
516 if (has_template_args)
517 fn = lookup_fnfields (object_type, name, /*protect=*/2);
519 fn = lookup_member (object_type, name, /*protect=*/2, /*want_type=*/false);
521 if (fn && TREE_CODE (fn) == TREE_LIST && !BASELINK_P (fn))
523 error ("request for member `%D' is ambiguous", name);
524 print_candidates (fn);
525 return error_mark_node;
528 /* If the name could not be found, issue an error. */
531 unqualified_name_lookup_error (name);
532 return error_mark_node;
535 if (BASELINK_P (fn) && has_template_args)
536 BASELINK_FUNCTIONS (fn)
537 = build_nt (TEMPLATE_ID_EXPR,
538 BASELINK_FUNCTIONS (fn),
540 if (BASELINK_P (fn) && basetype_path)
541 BASELINK_ACCESS_BINFO (fn) = basetype_path;
543 return build_new_method_call (instance, fn, parms,
544 /*conversion_path=*/NULL_TREE, flags);
547 /* New overloading code. */
549 struct z_candidate GTY(()) {
550 /* The FUNCTION_DECL that will be called if this candidate is
551 selected by overload resolution. */
553 /* The arguments to use when calling this function. */
555 /* The implicit conversion sequences for each of the arguments to
558 /* If FN is a user-defined conversion, the standard conversion
559 sequence from the type returned by FN to the desired destination
563 /* If FN is a member function, the binfo indicating the path used to
564 qualify the name of FN at the call site. This path is used to
565 determine whether or not FN is accessible if it is selected by
566 overload resolution. The DECL_CONTEXT of FN will always be a
567 (possibly improper) base of this binfo. */
569 /* If FN is a non-static member function, the binfo indicating the
570 subobject to which the `this' pointer should be converted if FN
571 is selected by overload resolution. The type pointed to the by
572 the `this' pointer must correspond to the most derived class
573 indicated by the CONVERSION_PATH. */
574 tree conversion_path;
577 struct z_candidate *next;
580 #define IDENTITY_RANK 0
586 #define ELLIPSIS_RANK 6
589 #define ICS_RANK(NODE) \
590 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
591 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
592 : ICS_USER_FLAG (NODE) ? USER_RANK \
593 : ICS_STD_RANK (NODE))
595 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
597 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
598 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
599 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
600 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
602 /* In a REF_BIND or a BASE_CONV, this indicates that a temporary
603 should be created to hold the result of the conversion. */
604 #define NEED_TEMPORARY_P(NODE) TREE_LANG_FLAG_4 (NODE)
606 #define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1))
607 #define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
610 null_ptr_cst_p (tree t)
614 A null pointer constant is an integral constant expression
615 (_expr.const_) rvalue of integer type that evaluates to zero. */
617 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
623 /* Returns nonzero if PARMLIST consists of only default parms and/or
627 sufficient_parms_p (tree parmlist)
629 for (; parmlist && parmlist != void_list_node;
630 parmlist = TREE_CHAIN (parmlist))
631 if (!TREE_PURPOSE (parmlist))
637 build_conv (enum tree_code code, tree type, tree from)
640 int rank = ICS_STD_RANK (from);
642 /* We can't use buildl1 here because CODE could be USER_CONV, which
643 takes two arguments. In that case, the caller is responsible for
644 filling in the second argument. */
645 t = make_node (code);
646 TREE_TYPE (t) = type;
647 TREE_OPERAND (t, 0) = from;
660 if (rank < EXACT_RANK)
666 ICS_STD_RANK (t) = rank;
667 ICS_USER_FLAG (t) = (code == USER_CONV || ICS_USER_FLAG (from));
668 ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);
672 /* If T is a REFERENCE_TYPE return the type to which T refers.
673 Otherwise, return T itself. */
676 non_reference (tree t)
678 if (TREE_CODE (t) == REFERENCE_TYPE)
684 strip_top_quals (tree t)
686 if (TREE_CODE (t) == ARRAY_TYPE)
688 return TYPE_MAIN_VARIANT (t);
691 /* Returns the standard conversion path (see [conv]) from type FROM to type
692 TO, if any. For proper handling of null pointer constants, you must
693 also pass the expression EXPR to convert from. */
696 standard_conversion (tree to, tree from, tree expr)
698 enum tree_code fcode, tcode;
700 bool fromref = false;
702 if (TREE_CODE (to) == REFERENCE_TYPE)
704 if (TREE_CODE (from) == REFERENCE_TYPE)
707 from = TREE_TYPE (from);
709 to = strip_top_quals (to);
710 from = strip_top_quals (from);
712 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
713 && expr && type_unknown_p (expr))
715 expr = instantiate_type (to, expr, tf_none);
716 if (expr == error_mark_node)
718 from = TREE_TYPE (expr);
721 fcode = TREE_CODE (from);
722 tcode = TREE_CODE (to);
724 conv = build1 (IDENTITY_CONV, from, expr);
726 if (fcode == FUNCTION_TYPE)
728 from = build_pointer_type (from);
729 fcode = TREE_CODE (from);
730 conv = build_conv (LVALUE_CONV, from, conv);
732 else if (fcode == ARRAY_TYPE)
734 from = build_pointer_type (TREE_TYPE (from));
735 fcode = TREE_CODE (from);
736 conv = build_conv (LVALUE_CONV, from, conv);
738 else if (fromref || (expr && lvalue_p (expr)))
739 conv = build_conv (RVALUE_CONV, from, conv);
741 /* Allow conversion between `__complex__' data types */
742 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
744 /* The standard conversion sequence to convert FROM to TO is
745 the standard conversion sequence to perform componentwise
747 tree part_conv = standard_conversion
748 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
752 conv = build_conv (TREE_CODE (part_conv), to, conv);
753 ICS_STD_RANK (conv) = ICS_STD_RANK (part_conv);
761 if (same_type_p (from, to))
764 if ((tcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (to))
765 && expr && null_ptr_cst_p (expr))
767 conv = build_conv (STD_CONV, to, conv);
769 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
770 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
772 /* For backwards brain damage compatibility, allow interconversion of
773 pointers and integers with a pedwarn. */
774 conv = build_conv (STD_CONV, to, conv);
775 ICS_BAD_FLAG (conv) = 1;
777 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE
778 && TYPE_PRECISION (to) == TYPE_PRECISION (from))
780 /* For backwards brain damage compatibility, allow interconversion of
781 enums and integers with a pedwarn. */
782 conv = build_conv (STD_CONV, to, conv);
783 ICS_BAD_FLAG (conv) = 1;
785 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE)
787 enum tree_code ufcode = TREE_CODE (TREE_TYPE (from));
788 enum tree_code utcode = TREE_CODE (TREE_TYPE (to));
790 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
793 else if (utcode == VOID_TYPE && ufcode != OFFSET_TYPE
794 && ufcode != FUNCTION_TYPE)
796 from = build_pointer_type
797 (cp_build_qualified_type (void_type_node,
798 cp_type_quals (TREE_TYPE (from))));
799 conv = build_conv (PTR_CONV, from, conv);
801 else if (ufcode == OFFSET_TYPE && utcode == OFFSET_TYPE)
803 tree fbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (from));
804 tree tbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (to));
806 if (DERIVED_FROM_P (fbase, tbase)
807 && (same_type_ignoring_top_level_qualifiers_p
808 (TREE_TYPE (TREE_TYPE (from)),
809 TREE_TYPE (TREE_TYPE (to)))))
811 from = build_ptrmem_type (tbase, TREE_TYPE (TREE_TYPE (from)));
812 conv = build_conv (PMEM_CONV, from, conv);
815 else if (IS_AGGR_TYPE (TREE_TYPE (from))
816 && IS_AGGR_TYPE (TREE_TYPE (to)))
818 if (DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
821 cp_build_qualified_type (TREE_TYPE (to),
822 cp_type_quals (TREE_TYPE (from)));
823 from = build_pointer_type (from);
824 conv = build_conv (PTR_CONV, from, conv);
828 if (same_type_p (from, to))
830 else if (comp_ptr_ttypes (TREE_TYPE (to), TREE_TYPE (from)))
831 conv = build_conv (QUAL_CONV, to, conv);
832 else if (expr && string_conv_p (to, expr, 0))
833 /* converting from string constant to char *. */
834 conv = build_conv (QUAL_CONV, to, conv);
835 else if (ptr_reasonably_similar (TREE_TYPE (to), TREE_TYPE (from)))
837 conv = build_conv (PTR_CONV, to, conv);
838 ICS_BAD_FLAG (conv) = 1;
845 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
847 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
848 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
849 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
850 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
852 if (!DERIVED_FROM_P (fbase, tbase)
853 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
854 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
855 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
856 || cp_type_quals (fbase) != cp_type_quals (tbase))
859 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
860 from = build_cplus_method_type (from, TREE_TYPE (fromfn),
861 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
862 from = build_ptrmemfunc_type (build_pointer_type (from));
863 conv = build_conv (PMEM_CONV, from, conv);
865 else if (tcode == BOOLEAN_TYPE)
867 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE
868 || fcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (from)))
871 conv = build_conv (STD_CONV, to, conv);
872 if (fcode == POINTER_TYPE
873 || (TYPE_PTRMEMFUNC_P (from) && ICS_STD_RANK (conv) < PBOOL_RANK))
874 ICS_STD_RANK (conv) = PBOOL_RANK;
876 /* We don't check for ENUMERAL_TYPE here because there are no standard
877 conversions to enum type. */
878 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
879 || tcode == REAL_TYPE)
881 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
883 conv = build_conv (STD_CONV, to, conv);
885 /* Give this a better rank if it's a promotion. */
886 if (to == type_promotes_to (from)
887 && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK)
888 ICS_STD_RANK (conv) = PROMO_RANK;
890 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
891 && is_properly_derived_from (from, to))
893 if (TREE_CODE (conv) == RVALUE_CONV)
894 conv = TREE_OPERAND (conv, 0);
895 conv = build_conv (BASE_CONV, to, conv);
896 /* The derived-to-base conversion indicates the initialization
897 of a parameter with base type from an object of a derived
898 type. A temporary object is created to hold the result of
900 NEED_TEMPORARY_P (conv) = 1;
908 /* Returns nonzero if T1 is reference-related to T2. */
911 reference_related_p (tree t1, tree t2)
913 t1 = TYPE_MAIN_VARIANT (t1);
914 t2 = TYPE_MAIN_VARIANT (t2);
918 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
919 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
921 return (same_type_p (t1, t2)
922 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
923 && DERIVED_FROM_P (t1, t2)));
926 /* Returns nonzero if T1 is reference-compatible with T2. */
929 reference_compatible_p (tree t1, tree t2)
933 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
934 reference-related to T2 and cv1 is the same cv-qualification as,
935 or greater cv-qualification than, cv2. */
936 return (reference_related_p (t1, t2)
937 && at_least_as_qualified_p (t1, t2));
940 /* Determine whether or not the EXPR (of class type S) can be
941 converted to T as in [over.match.ref]. */
944 convert_class_to_reference (tree t, tree s, tree expr)
950 struct z_candidate *candidates;
951 struct z_candidate *cand;
954 conversions = lookup_conversions (s);
960 Assuming that "cv1 T" is the underlying type of the reference
961 being initialized, and "cv S" is the type of the initializer
962 expression, with S a class type, the candidate functions are
965 --The conversion functions of S and its base classes are
966 considered. Those that are not hidden within S and yield type
967 "reference to cv2 T2", where "cv1 T" is reference-compatible
968 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
970 The argument list has one argument, which is the initializer
975 /* Conceptually, we should take the address of EXPR and put it in
976 the argument list. Unfortunately, however, that can result in
977 error messages, which we should not issue now because we are just
978 trying to find a conversion operator. Therefore, we use NULL,
979 cast to the appropriate type. */
980 arglist = build_int_2 (0, 0);
981 TREE_TYPE (arglist) = build_pointer_type (s);
982 arglist = build_tree_list (NULL_TREE, arglist);
984 reference_type = build_reference_type (t);
988 tree fns = TREE_VALUE (conversions);
990 for (; fns; fns = OVL_NEXT (fns))
992 tree f = OVL_CURRENT (fns);
993 tree t2 = TREE_TYPE (TREE_TYPE (f));
997 /* If this is a template function, try to get an exact
999 if (TREE_CODE (f) == TEMPLATE_DECL)
1001 cand = add_template_candidate (&candidates,
1007 TREE_PURPOSE (conversions),
1013 /* Now, see if the conversion function really returns
1014 an lvalue of the appropriate type. From the
1015 point of view of unification, simply returning an
1016 rvalue of the right type is good enough. */
1018 t2 = TREE_TYPE (TREE_TYPE (f));
1019 if (TREE_CODE (t2) != REFERENCE_TYPE
1020 || !reference_compatible_p (t, TREE_TYPE (t2)))
1022 candidates = candidates->next;
1027 else if (TREE_CODE (t2) == REFERENCE_TYPE
1028 && reference_compatible_p (t, TREE_TYPE (t2)))
1029 cand = add_function_candidate (&candidates, f, s, arglist,
1031 TREE_PURPOSE (conversions),
1035 /* Build a standard conversion sequence indicating the
1036 binding from the reference type returned by the
1037 function to the desired REFERENCE_TYPE. */
1039 = (direct_reference_binding
1041 build1 (IDENTITY_CONV,
1042 TREE_TYPE (TREE_TYPE (TREE_TYPE (cand->fn))),
1045 conversions = TREE_CHAIN (conversions);
1048 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1049 /* If none of the conversion functions worked out, let our caller
1054 cand = tourney (candidates);
1058 /* Now that we know that this is the function we're going to use fix
1059 the dummy first argument. */
1060 cand->args = tree_cons (NULL_TREE,
1062 TREE_CHAIN (cand->args));
1064 /* Build a user-defined conversion sequence representing the
1066 conv = build_conv (USER_CONV,
1067 TREE_TYPE (TREE_TYPE (cand->fn)),
1068 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
1069 TREE_OPERAND (conv, 1) = build_zc_wrapper (cand);
1071 /* Merge it with the standard conversion sequence from the
1072 conversion function's return type to the desired type. */
1073 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1075 if (cand->viable == -1)
1076 ICS_BAD_FLAG (conv) = 1;
1078 return cand->second_conv;
1081 /* A reference of the indicated TYPE is being bound directly to the
1082 expression represented by the implicit conversion sequence CONV.
1083 Return a conversion sequence for this binding. */
1086 direct_reference_binding (tree type, tree conv)
1090 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
1091 my_friendly_assert (TREE_CODE (TREE_TYPE (conv)) != REFERENCE_TYPE,
1094 t = TREE_TYPE (type);
1098 When a parameter of reference type binds directly
1099 (_dcl.init.ref_) to an argument expression, the implicit
1100 conversion sequence is the identity conversion, unless the
1101 argument expression has a type that is a derived class of the
1102 parameter type, in which case the implicit conversion sequence is
1103 a derived-to-base Conversion.
1105 If the parameter binds directly to the result of applying a
1106 conversion function to the argument expression, the implicit
1107 conversion sequence is a user-defined conversion sequence
1108 (_over.ics.user_), with the second standard conversion sequence
1109 either an identity conversion or, if the conversion function
1110 returns an entity of a type that is a derived class of the
1111 parameter type, a derived-to-base conversion. */
1112 if (!same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (conv)))
1114 /* Represent the derived-to-base conversion. */
1115 conv = build_conv (BASE_CONV, t, conv);
1116 /* We will actually be binding to the base-class subobject in
1117 the derived class, so we mark this conversion appropriately.
1118 That way, convert_like knows not to generate a temporary. */
1119 NEED_TEMPORARY_P (conv) = 0;
1121 return build_conv (REF_BIND, type, conv);
1124 /* Returns the conversion path from type FROM to reference type TO for
1125 purposes of reference binding. For lvalue binding, either pass a
1126 reference type to FROM or an lvalue expression to EXPR. If the
1127 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1128 the conversion returned. */
1131 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1133 tree conv = NULL_TREE;
1134 tree to = TREE_TYPE (rto);
1138 cp_lvalue_kind lvalue_p = clk_none;
1140 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1142 expr = instantiate_type (to, expr, tf_none);
1143 if (expr == error_mark_node)
1145 from = TREE_TYPE (expr);
1148 if (TREE_CODE (from) == REFERENCE_TYPE)
1150 /* Anything with reference type is an lvalue. */
1151 lvalue_p = clk_ordinary;
1152 from = TREE_TYPE (from);
1155 lvalue_p = real_lvalue_p (expr);
1157 /* Figure out whether or not the types are reference-related and
1158 reference compatible. We have do do this after stripping
1159 references from FROM. */
1160 related_p = reference_related_p (to, from);
1161 compatible_p = reference_compatible_p (to, from);
1163 if (lvalue_p && compatible_p)
1167 If the initializer expression
1169 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1170 is reference-compatible with "cv2 T2,"
1172 the reference is bound directly to the initializer expression
1174 conv = build1 (IDENTITY_CONV, from, expr);
1175 conv = direct_reference_binding (rto, conv);
1176 if ((lvalue_p & clk_bitfield) != 0
1177 && CP_TYPE_CONST_NON_VOLATILE_P (to))
1178 /* For the purposes of overload resolution, we ignore the fact
1179 this expression is a bitfield. (In particular,
1180 [over.ics.ref] says specifically that a function with a
1181 non-const reference parameter is viable even if the
1182 argument is a bitfield.)
1184 However, when we actually call the function we must create
1185 a temporary to which to bind the reference. If the
1186 reference is volatile, or isn't const, then we cannot make
1187 a temporary, so we just issue an error when the conversion
1189 NEED_TEMPORARY_P (conv) = 1;
1192 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1196 If the initializer expression
1198 -- has a class type (i.e., T2 is a class type) can be
1199 implicitly converted to an lvalue of type "cv3 T3," where
1200 "cv1 T1" is reference-compatible with "cv3 T3". (this
1201 conversion is selected by enumerating the applicable
1202 conversion functions (_over.match.ref_) and choosing the
1203 best one through overload resolution. (_over.match_).
1205 the reference is bound to the lvalue result of the conversion
1206 in the second case. */
1207 conv = convert_class_to_reference (to, from, expr);
1212 /* From this point on, we conceptually need temporaries, even if we
1213 elide them. Only the cases above are "direct bindings". */
1214 if (flags & LOOKUP_NO_TEMP_BIND)
1219 When a parameter of reference type is not bound directly to an
1220 argument expression, the conversion sequence is the one required
1221 to convert the argument expression to the underlying type of the
1222 reference according to _over.best.ics_. Conceptually, this
1223 conversion sequence corresponds to copy-initializing a temporary
1224 of the underlying type with the argument expression. Any
1225 difference in top-level cv-qualification is subsumed by the
1226 initialization itself and does not constitute a conversion. */
1230 Otherwise, the reference shall be to a non-volatile const type. */
1231 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1236 If the initializer expression is an rvalue, with T2 a class type,
1237 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1238 is bound in one of the following ways:
1240 -- The reference is bound to the object represented by the rvalue
1241 or to a sub-object within that object.
1245 We use the first alternative. The implicit conversion sequence
1246 is supposed to be same as we would obtain by generating a
1247 temporary. Fortunately, if the types are reference compatible,
1248 then this is either an identity conversion or the derived-to-base
1249 conversion, just as for direct binding. */
1250 if (CLASS_TYPE_P (from) && compatible_p)
1252 conv = build1 (IDENTITY_CONV, from, expr);
1253 return direct_reference_binding (rto, conv);
1258 Otherwise, a temporary of type "cv1 T1" is created and
1259 initialized from the initializer expression using the rules for a
1260 non-reference copy initialization. If T1 is reference-related to
1261 T2, cv1 must be the same cv-qualification as, or greater
1262 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1263 if (related_p && !at_least_as_qualified_p (to, from))
1266 conv = implicit_conversion (to, from, expr, flags);
1270 conv = build_conv (REF_BIND, rto, conv);
1271 /* This reference binding, unlike those above, requires the
1272 creation of a temporary. */
1273 NEED_TEMPORARY_P (conv) = 1;
1278 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1279 to type TO. The optional expression EXPR may affect the conversion.
1280 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1284 implicit_conversion (tree to, tree from, tree expr, int flags)
1288 if (from == error_mark_node || to == error_mark_node
1289 || expr == error_mark_node)
1292 if (TREE_CODE (to) == REFERENCE_TYPE)
1293 conv = reference_binding (to, from, expr, flags);
1295 conv = standard_conversion (to, from, expr);
1300 if (expr != NULL_TREE
1301 && (IS_AGGR_TYPE (from)
1302 || IS_AGGR_TYPE (to))
1303 && (flags & LOOKUP_NO_CONVERSION) == 0)
1305 struct z_candidate *cand;
1307 cand = build_user_type_conversion_1
1308 (to, expr, LOOKUP_ONLYCONVERTING);
1310 conv = cand->second_conv;
1312 /* We used to try to bind a reference to a temporary here, but that
1313 is now handled by the recursive call to this function at the end
1314 of reference_binding. */
1321 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1324 static struct z_candidate *
1325 add_candidate (struct z_candidate **candidates,
1326 tree fn, tree args, tree convs, tree access_path,
1327 tree conversion_path, int viable)
1329 struct z_candidate *cand
1330 = (struct z_candidate *) ggc_alloc_cleared (sizeof (struct z_candidate));
1334 cand->convs = convs;
1335 cand->access_path = access_path;
1336 cand->conversion_path = conversion_path;
1337 cand->viable = viable;
1338 cand->next = *candidates;
1344 /* Create an overload candidate for the function or method FN called with
1345 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1346 to implicit_conversion.
1348 CTYPE, if non-NULL, is the type we want to pretend this function
1349 comes from for purposes of overload resolution. */
1351 static struct z_candidate *
1352 add_function_candidate (struct z_candidate **candidates,
1353 tree fn, tree ctype, tree arglist,
1354 tree access_path, tree conversion_path,
1357 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1360 tree parmnode, argnode;
1364 /* Built-in functions that haven't been declared don't really
1366 if (DECL_ANTICIPATED (fn))
1369 /* The `this', `in_chrg' and VTT arguments to constructors are not
1370 considered in overload resolution. */
1371 if (DECL_CONSTRUCTOR_P (fn))
1373 parmlist = skip_artificial_parms_for (fn, parmlist);
1374 orig_arglist = arglist;
1375 arglist = skip_artificial_parms_for (fn, arglist);
1378 orig_arglist = arglist;
1380 len = list_length (arglist);
1381 convs = make_tree_vec (len);
1383 /* 13.3.2 - Viable functions [over.match.viable]
1384 First, to be a viable function, a candidate function shall have enough
1385 parameters to agree in number with the arguments in the list.
1387 We need to check this first; otherwise, checking the ICSes might cause
1388 us to produce an ill-formed template instantiation. */
1390 parmnode = parmlist;
1391 for (i = 0; i < len; ++i)
1393 if (parmnode == NULL_TREE || parmnode == void_list_node)
1395 parmnode = TREE_CHAIN (parmnode);
1398 if (i < len && parmnode)
1401 /* Make sure there are default args for the rest of the parms. */
1402 else if (!sufficient_parms_p (parmnode))
1408 /* Second, for F to be a viable function, there shall exist for each
1409 argument an implicit conversion sequence that converts that argument
1410 to the corresponding parameter of F. */
1412 parmnode = parmlist;
1415 for (i = 0; i < len; ++i)
1417 tree arg = TREE_VALUE (argnode);
1418 tree argtype = lvalue_type (arg);
1422 if (parmnode == void_list_node)
1425 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1426 && ! DECL_CONSTRUCTOR_P (fn));
1430 tree parmtype = TREE_VALUE (parmnode);
1432 /* The type of the implicit object parameter ('this') for
1433 overload resolution is not always the same as for the
1434 function itself; conversion functions are considered to
1435 be members of the class being converted, and functions
1436 introduced by a using-declaration are considered to be
1437 members of the class that uses them.
1439 Since build_over_call ignores the ICS for the `this'
1440 parameter, we can just change the parm type. */
1441 if (ctype && is_this)
1444 = build_qualified_type (ctype,
1445 TYPE_QUALS (TREE_TYPE (parmtype)));
1446 parmtype = build_pointer_type (parmtype);
1449 t = implicit_conversion (parmtype, argtype, arg, flags);
1453 t = build1 (IDENTITY_CONV, argtype, arg);
1454 ICS_ELLIPSIS_FLAG (t) = 1;
1458 ICS_THIS_FLAG (t) = 1;
1460 TREE_VEC_ELT (convs, i) = t;
1467 if (ICS_BAD_FLAG (t))
1471 parmnode = TREE_CHAIN (parmnode);
1472 argnode = TREE_CHAIN (argnode);
1476 return add_candidate (candidates, fn, orig_arglist, convs, access_path,
1477 conversion_path, viable);
1480 /* Create an overload candidate for the conversion function FN which will
1481 be invoked for expression OBJ, producing a pointer-to-function which
1482 will in turn be called with the argument list ARGLIST, and add it to
1483 CANDIDATES. FLAGS is passed on to implicit_conversion.
1485 Actually, we don't really care about FN; we care about the type it
1486 converts to. There may be multiple conversion functions that will
1487 convert to that type, and we rely on build_user_type_conversion_1 to
1488 choose the best one; so when we create our candidate, we record the type
1489 instead of the function. */
1491 static struct z_candidate *
1492 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1493 tree arglist, tree access_path, tree conversion_path)
1495 tree totype = TREE_TYPE (TREE_TYPE (fn));
1496 int i, len, viable, flags;
1497 tree parmlist, convs, parmnode, argnode;
1499 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1500 parmlist = TREE_TYPE (parmlist);
1501 parmlist = TYPE_ARG_TYPES (parmlist);
1503 len = list_length (arglist) + 1;
1504 convs = make_tree_vec (len);
1505 parmnode = parmlist;
1508 flags = LOOKUP_NORMAL;
1510 /* Don't bother looking up the same type twice. */
1511 if (*candidates && (*candidates)->fn == totype)
1514 for (i = 0; i < len; ++i)
1516 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1517 tree argtype = lvalue_type (arg);
1521 t = implicit_conversion (totype, argtype, arg, flags);
1522 else if (parmnode == void_list_node)
1525 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1528 t = build1 (IDENTITY_CONV, argtype, arg);
1529 ICS_ELLIPSIS_FLAG (t) = 1;
1532 TREE_VEC_ELT (convs, i) = t;
1536 if (ICS_BAD_FLAG (t))
1543 parmnode = TREE_CHAIN (parmnode);
1544 argnode = TREE_CHAIN (argnode);
1550 if (!sufficient_parms_p (parmnode))
1553 return add_candidate (candidates, totype, arglist, convs, access_path,
1554 conversion_path, viable);
1558 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1559 tree type1, tree type2, tree *args, tree *argtypes,
1569 convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
1571 for (i = 0; i < 2; ++i)
1576 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1580 /* We need something for printing the candidate. */
1581 t = build1 (IDENTITY_CONV, types[i], NULL_TREE);
1583 else if (ICS_BAD_FLAG (t))
1585 TREE_VEC_ELT (convs, i) = t;
1588 /* For COND_EXPR we rearranged the arguments; undo that now. */
1591 TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1);
1592 TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0);
1593 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1595 TREE_VEC_ELT (convs, 0) = t;
1600 add_candidate (candidates, fnname, /*args=*/NULL_TREE, convs,
1601 /*access_path=*/NULL_TREE,
1602 /*conversion_path=*/NULL_TREE,
1607 is_complete (tree t)
1609 return COMPLETE_TYPE_P (complete_type (t));
1612 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1615 promoted_arithmetic_type_p (tree type)
1619 In this section, the term promoted integral type is used to refer
1620 to those integral types which are preserved by integral promotion
1621 (including e.g. int and long but excluding e.g. char).
1622 Similarly, the term promoted arithmetic type refers to promoted
1623 integral types plus floating types. */
1624 return ((INTEGRAL_TYPE_P (type)
1625 && same_type_p (type_promotes_to (type), type))
1626 || TREE_CODE (type) == REAL_TYPE);
1629 /* Create any builtin operator overload candidates for the operator in
1630 question given the converted operand types TYPE1 and TYPE2. The other
1631 args are passed through from add_builtin_candidates to
1632 build_builtin_candidate.
1634 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1635 If CODE is requires candidates operands of the same type of the kind
1636 of which TYPE1 and TYPE2 are, we add both candidates
1637 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1640 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1641 enum tree_code code2, tree fnname, tree type1,
1642 tree type2, tree *args, tree *argtypes, int flags)
1646 case POSTINCREMENT_EXPR:
1647 case POSTDECREMENT_EXPR:
1648 args[1] = integer_zero_node;
1649 type2 = integer_type_node;
1658 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1659 and VQ is either volatile or empty, there exist candidate operator
1660 functions of the form
1661 VQ T& operator++(VQ T&);
1662 T operator++(VQ T&, int);
1663 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1664 type other than bool, and VQ is either volatile or empty, there exist
1665 candidate operator functions of the form
1666 VQ T& operator--(VQ T&);
1667 T operator--(VQ T&, int);
1668 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1669 complete object type, and VQ is either volatile or empty, there exist
1670 candidate operator functions of the form
1671 T*VQ& operator++(T*VQ&);
1672 T*VQ& operator--(T*VQ&);
1673 T* operator++(T*VQ&, int);
1674 T* operator--(T*VQ&, int); */
1676 case POSTDECREMENT_EXPR:
1677 case PREDECREMENT_EXPR:
1678 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1680 case POSTINCREMENT_EXPR:
1681 case PREINCREMENT_EXPR:
1682 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1684 type1 = build_reference_type (type1);
1689 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1690 exist candidate operator functions of the form
1694 8 For every function type T, there exist candidate operator functions of
1696 T& operator*(T*); */
1699 if (TREE_CODE (type1) == POINTER_TYPE
1700 && (TYPE_PTROB_P (type1)
1701 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1705 /* 9 For every type T, there exist candidate operator functions of the form
1708 10For every promoted arithmetic type T, there exist candidate operator
1709 functions of the form
1713 case CONVERT_EXPR: /* unary + */
1714 if (TREE_CODE (type1) == POINTER_TYPE
1715 && TREE_CODE (TREE_TYPE (type1)) != OFFSET_TYPE)
1718 if (ARITHMETIC_TYPE_P (type1))
1722 /* 11For every promoted integral type T, there exist candidate operator
1723 functions of the form
1727 if (INTEGRAL_TYPE_P (type1))
1731 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1732 is the same type as C2 or is a derived class of C2, T is a complete
1733 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1734 there exist candidate operator functions of the form
1735 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1736 where CV12 is the union of CV1 and CV2. */
1739 if (TREE_CODE (type1) == POINTER_TYPE
1740 && (TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2)))
1742 tree c1 = TREE_TYPE (type1);
1743 tree c2 = (TYPE_PTRMEMFUNC_P (type2)
1744 ? TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2)))
1745 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2)));
1747 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1748 && (TYPE_PTRMEMFUNC_P (type2)
1749 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1754 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1755 didate operator functions of the form
1760 bool operator<(L, R);
1761 bool operator>(L, R);
1762 bool operator<=(L, R);
1763 bool operator>=(L, R);
1764 bool operator==(L, R);
1765 bool operator!=(L, R);
1766 where LR is the result of the usual arithmetic conversions between
1769 14For every pair of types T and I, where T is a cv-qualified or cv-
1770 unqualified complete object type and I is a promoted integral type,
1771 there exist candidate operator functions of the form
1772 T* operator+(T*, I);
1773 T& operator[](T*, I);
1774 T* operator-(T*, I);
1775 T* operator+(I, T*);
1776 T& operator[](I, T*);
1778 15For every T, where T is a pointer to complete object type, there exist
1779 candidate operator functions of the form112)
1780 ptrdiff_t operator-(T, T);
1782 16For every pointer or enumeration type T, there exist candidate operator
1783 functions of the form
1784 bool operator<(T, T);
1785 bool operator>(T, T);
1786 bool operator<=(T, T);
1787 bool operator>=(T, T);
1788 bool operator==(T, T);
1789 bool operator!=(T, T);
1791 17For every pointer to member type T, there exist candidate operator
1792 functions of the form
1793 bool operator==(T, T);
1794 bool operator!=(T, T); */
1797 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1799 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1801 type2 = ptrdiff_type_node;
1805 case TRUNC_DIV_EXPR:
1806 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1812 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1813 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1815 if ((TYPE_PTRMEMFUNC_P (type1) || TYPE_PTRMEM_P (type1))
1816 && null_ptr_cst_p (args[1]))
1821 if ((TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2))
1822 && null_ptr_cst_p (args[0]))
1834 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1836 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1838 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1840 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1845 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1853 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1856 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1858 type1 = ptrdiff_type_node;
1861 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1863 type2 = ptrdiff_type_node;
1868 /* 18For every pair of promoted integral types L and R, there exist candi-
1869 date operator functions of the form
1876 where LR is the result of the usual arithmetic conversions between
1879 case TRUNC_MOD_EXPR:
1885 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1889 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1890 type, VQ is either volatile or empty, and R is a promoted arithmetic
1891 type, there exist candidate operator functions of the form
1892 VQ L& operator=(VQ L&, R);
1893 VQ L& operator*=(VQ L&, R);
1894 VQ L& operator/=(VQ L&, R);
1895 VQ L& operator+=(VQ L&, R);
1896 VQ L& operator-=(VQ L&, R);
1898 20For every pair T, VQ), where T is any type and VQ is either volatile
1899 or empty, there exist candidate operator functions of the form
1900 T*VQ& operator=(T*VQ&, T*);
1902 21For every pair T, VQ), where T is a pointer to member type and VQ is
1903 either volatile or empty, there exist candidate operator functions of
1905 VQ T& operator=(VQ T&, T);
1907 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1908 unqualified complete object type, VQ is either volatile or empty, and
1909 I is a promoted integral type, there exist candidate operator func-
1911 T*VQ& operator+=(T*VQ&, I);
1912 T*VQ& operator-=(T*VQ&, I);
1914 23For every triple L, VQ, R), where L is an integral or enumeration
1915 type, VQ is either volatile or empty, and R is a promoted integral
1916 type, there exist candidate operator functions of the form
1918 VQ L& operator%=(VQ L&, R);
1919 VQ L& operator<<=(VQ L&, R);
1920 VQ L& operator>>=(VQ L&, R);
1921 VQ L& operator&=(VQ L&, R);
1922 VQ L& operator^=(VQ L&, R);
1923 VQ L& operator|=(VQ L&, R); */
1930 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1932 type2 = ptrdiff_type_node;
1936 case TRUNC_DIV_EXPR:
1937 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1941 case TRUNC_MOD_EXPR:
1947 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1952 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1954 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1955 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1956 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1957 || ((TYPE_PTRMEMFUNC_P (type1)
1958 || TREE_CODE (type1) == POINTER_TYPE)
1959 && null_ptr_cst_p (args[1])))
1969 type1 = build_reference_type (type1);
1975 For every pair of promoted arithmetic types L and R, there
1976 exist candidate operator functions of the form
1978 LR operator?(bool, L, R);
1980 where LR is the result of the usual arithmetic conversions
1981 between types L and R.
1983 For every type T, where T is a pointer or pointer-to-member
1984 type, there exist candidate operator functions of the form T
1985 operator?(bool, T, T); */
1987 if (promoted_arithmetic_type_p (type1)
1988 && promoted_arithmetic_type_p (type2))
1992 /* Otherwise, the types should be pointers. */
1993 if (!(TREE_CODE (type1) == POINTER_TYPE
1994 || TYPE_PTRMEM_P (type1)
1995 || TYPE_PTRMEMFUNC_P (type1))
1996 || !(TREE_CODE (type2) == POINTER_TYPE
1997 || TYPE_PTRMEM_P (type2)
1998 || TYPE_PTRMEMFUNC_P (type2)))
2001 /* We don't check that the two types are the same; the logic
2002 below will actually create two candidates; one in which both
2003 parameter types are TYPE1, and one in which both parameter
2011 /* If we're dealing with two pointer types or two enumeral types,
2012 we need candidates for both of them. */
2013 if (type2 && !same_type_p (type1, type2)
2014 && TREE_CODE (type1) == TREE_CODE (type2)
2015 && (TREE_CODE (type1) == REFERENCE_TYPE
2016 || (TREE_CODE (type1) == POINTER_TYPE
2017 && TYPE_PTRMEM_P (type1) == TYPE_PTRMEM_P (type2))
2018 || TYPE_PTRMEMFUNC_P (type1)
2019 || IS_AGGR_TYPE (type1)
2020 || TREE_CODE (type1) == ENUMERAL_TYPE))
2022 build_builtin_candidate
2023 (candidates, fnname, type1, type1, args, argtypes, flags);
2024 build_builtin_candidate
2025 (candidates, fnname, type2, type2, args, argtypes, flags);
2029 build_builtin_candidate
2030 (candidates, fnname, type1, type2, args, argtypes, flags);
2034 type_decays_to (tree type)
2036 if (TREE_CODE (type) == ARRAY_TYPE)
2037 return build_pointer_type (TREE_TYPE (type));
2038 if (TREE_CODE (type) == FUNCTION_TYPE)
2039 return build_pointer_type (type);
2043 /* There are three conditions of builtin candidates:
2045 1) bool-taking candidates. These are the same regardless of the input.
2046 2) pointer-pair taking candidates. These are generated for each type
2047 one of the input types converts to.
2048 3) arithmetic candidates. According to the standard, we should generate
2049 all of these, but I'm trying not to...
2051 Here we generate a superset of the possible candidates for this particular
2052 case. That is a subset of the full set the standard defines, plus some
2053 other cases which the standard disallows. add_builtin_candidate will
2054 filter out the invalid set. */
2057 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2058 enum tree_code code2, tree fnname, tree *args,
2063 tree type, argtypes[3];
2064 /* TYPES[i] is the set of possible builtin-operator parameter types
2065 we will consider for the Ith argument. These are represented as
2066 a TREE_LIST; the TREE_VALUE of each node is the potential
2070 for (i = 0; i < 3; ++i)
2073 argtypes[i] = lvalue_type (args[i]);
2075 argtypes[i] = NULL_TREE;
2080 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2081 and VQ is either volatile or empty, there exist candidate operator
2082 functions of the form
2083 VQ T& operator++(VQ T&); */
2085 case POSTINCREMENT_EXPR:
2086 case PREINCREMENT_EXPR:
2087 case POSTDECREMENT_EXPR:
2088 case PREDECREMENT_EXPR:
2093 /* 24There also exist candidate operator functions of the form
2094 bool operator!(bool);
2095 bool operator&&(bool, bool);
2096 bool operator||(bool, bool); */
2098 case TRUTH_NOT_EXPR:
2099 build_builtin_candidate
2100 (candidates, fnname, boolean_type_node,
2101 NULL_TREE, args, argtypes, flags);
2104 case TRUTH_ORIF_EXPR:
2105 case TRUTH_ANDIF_EXPR:
2106 build_builtin_candidate
2107 (candidates, fnname, boolean_type_node,
2108 boolean_type_node, args, argtypes, flags);
2130 types[0] = types[1] = NULL_TREE;
2132 for (i = 0; i < 2; ++i)
2136 else if (IS_AGGR_TYPE (argtypes[i]))
2140 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2143 convs = lookup_conversions (argtypes[i]);
2145 if (code == COND_EXPR)
2147 if (real_lvalue_p (args[i]))
2148 types[i] = tree_cons
2149 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2151 types[i] = tree_cons
2152 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2158 for (; convs; convs = TREE_CHAIN (convs))
2160 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2163 && (TREE_CODE (type) != REFERENCE_TYPE
2164 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2167 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2168 types[i] = tree_cons (NULL_TREE, type, types[i]);
2170 type = non_reference (type);
2171 if (i != 0 || ! ref1)
2173 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2174 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2175 types[i] = tree_cons (NULL_TREE, type, types[i]);
2176 if (INTEGRAL_TYPE_P (type))
2177 type = type_promotes_to (type);
2180 if (! value_member (type, types[i]))
2181 types[i] = tree_cons (NULL_TREE, type, types[i]);
2186 if (code == COND_EXPR && real_lvalue_p (args[i]))
2187 types[i] = tree_cons
2188 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2189 type = non_reference (argtypes[i]);
2190 if (i != 0 || ! ref1)
2192 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2193 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2194 types[i] = tree_cons (NULL_TREE, type, types[i]);
2195 if (INTEGRAL_TYPE_P (type))
2196 type = type_promotes_to (type);
2198 types[i] = tree_cons (NULL_TREE, type, types[i]);
2202 /* Run through the possible parameter types of both arguments,
2203 creating candidates with those parameter types. */
2204 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2207 for (type = types[1]; type; type = TREE_CHAIN (type))
2208 add_builtin_candidate
2209 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2210 TREE_VALUE (type), args, argtypes, flags);
2212 add_builtin_candidate
2213 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2214 NULL_TREE, args, argtypes, flags);
2221 /* If TMPL can be successfully instantiated as indicated by
2222 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2224 TMPL is the template. EXPLICIT_TARGS are any explicit template
2225 arguments. ARGLIST is the arguments provided at the call-site.
2226 The RETURN_TYPE is the desired type for conversion operators. If
2227 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2228 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2229 add_conv_candidate. */
2231 static struct z_candidate*
2232 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2233 tree ctype, tree explicit_targs, tree arglist,
2234 tree return_type, tree access_path,
2235 tree conversion_path, int flags, tree obj,
2236 unification_kind_t strict)
2238 int ntparms = DECL_NTPARMS (tmpl);
2239 tree targs = make_tree_vec (ntparms);
2240 tree args_without_in_chrg = arglist;
2241 struct z_candidate *cand;
2245 /* We don't do deduction on the in-charge parameter, the VTT
2246 parameter or 'this'. */
2247 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2248 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2250 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2251 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2252 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
2253 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2255 i = fn_type_unification (tmpl, explicit_targs, targs,
2256 args_without_in_chrg,
2257 return_type, strict, -1);
2262 fn = instantiate_template (tmpl, targs, tf_none);
2263 if (fn == error_mark_node)
2268 A member function template is never instantiated to perform the
2269 copy of a class object to an object of its class type.
2271 It's a little unclear what this means; the standard explicitly
2272 does allow a template to be used to copy a class. For example,
2277 template <class T> A(const T&);
2280 void g () { A a (f ()); }
2282 the member template will be used to make the copy. The section
2283 quoted above appears in the paragraph that forbids constructors
2284 whose only parameter is (a possibly cv-qualified variant of) the
2285 class type, and a logical interpretation is that the intent was
2286 to forbid the instantiation of member templates which would then
2288 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2290 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2291 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2296 if (obj != NULL_TREE)
2297 /* Aha, this is a conversion function. */
2298 cand = add_conv_candidate (candidates, fn, obj, access_path,
2299 conversion_path, arglist);
2301 cand = add_function_candidate (candidates, fn, ctype,
2302 arglist, access_path,
2303 conversion_path, flags);
2304 if (DECL_TI_TEMPLATE (fn) != tmpl)
2305 /* This situation can occur if a member template of a template
2306 class is specialized. Then, instantiate_template might return
2307 an instantiation of the specialization, in which case the
2308 DECL_TI_TEMPLATE field will point at the original
2309 specialization. For example:
2311 template <class T> struct S { template <class U> void f(U);
2312 template <> void f(int) {}; };
2316 Here, TMPL will be template <class U> S<double>::f(U).
2317 And, instantiate template will give us the specialization
2318 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2319 for this will point at template <class T> template <> S<T>::f(int),
2320 so that we can find the definition. For the purposes of
2321 overload resolution, however, we want the original TMPL. */
2322 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2324 cand->template = DECL_TEMPLATE_INFO (fn);
2330 static struct z_candidate *
2331 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2332 tree explicit_targs, tree arglist, tree return_type,
2333 tree access_path, tree conversion_path, int flags,
2334 unification_kind_t strict)
2337 add_template_candidate_real (candidates, tmpl, ctype,
2338 explicit_targs, arglist, return_type,
2339 access_path, conversion_path,
2340 flags, NULL_TREE, strict);
2344 static struct z_candidate *
2345 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2346 tree obj, tree arglist, tree return_type,
2347 tree access_path, tree conversion_path)
2350 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2351 arglist, return_type, access_path,
2352 conversion_path, 0, obj, DEDUCE_CONV);
2355 /* The CANDS are the set of candidates that were considered for
2356 overload resolution. Return the set of viable candidates. If none
2357 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2358 is true if a candidate should be considered viable only if it is
2361 static struct z_candidate*
2362 splice_viable (struct z_candidate *cands,
2366 struct z_candidate *viable;
2367 struct z_candidate **last_viable;
2368 struct z_candidate **cand;
2371 last_viable = &viable;
2372 *any_viable_p = false;
2377 struct z_candidate *c = *cand;
2378 if (strict_p ? c->viable == 1 : c->viable)
2383 last_viable = &c->next;
2384 *any_viable_p = true;
2390 return viable ? viable : cands;
2394 any_strictly_viable (struct z_candidate *cands)
2396 for (; cands; cands = cands->next)
2397 if (cands->viable == 1)
2403 build_this (tree obj)
2405 /* Fix this to work on non-lvalues. */
2406 return build_unary_op (ADDR_EXPR, obj, 0);
2409 /* Returns true iff functions are equivalent. Equivalent functions are
2410 not '==' only if one is a function-local extern function or if
2411 both are extern "C". */
2414 equal_functions (tree fn1, tree fn2)
2416 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2417 || DECL_EXTERN_C_FUNCTION_P (fn1))
2418 return decls_match (fn1, fn2);
2422 /* Print information about one overload candidate CANDIDATE. MSGSTR
2423 is the text to print before the candidate itself.
2425 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2426 to have been run through gettext by the caller. This wart makes
2427 life simpler in print_z_candidates and for the translators. */
2430 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2432 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2434 if (TREE_VEC_LENGTH (candidate->convs) == 3)
2435 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2436 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2437 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)),
2438 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 2)));
2439 else if (TREE_VEC_LENGTH (candidate->convs) == 2)
2440 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2441 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)),
2442 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 1)));
2444 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2445 TREE_TYPE (TREE_VEC_ELT (candidate->convs, 0)));
2447 else if (TYPE_P (candidate->fn))
2448 inform ("%s %T <conversion>", msgstr, candidate->fn);
2449 else if (candidate->viable == -1)
2450 inform ("%H%s %+#D <near match>",
2451 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
2453 inform ("%H%s %+#D",
2454 &DECL_SOURCE_LOCATION (candidate->fn), msgstr, candidate->fn);
2458 print_z_candidates (struct z_candidate *candidates)
2461 struct z_candidate *cand1;
2462 struct z_candidate **cand2;
2464 /* There may be duplicates in the set of candidates. We put off
2465 checking this condition as long as possible, since we have no way
2466 to eliminate duplicates from a set of functions in less than n^2
2467 time. Now we are about to emit an error message, so it is more
2468 permissible to go slowly. */
2469 for (cand1 = candidates; cand1; cand1 = cand1->next)
2471 tree fn = cand1->fn;
2472 /* Skip builtin candidates and conversion functions. */
2473 if (TREE_CODE (fn) != FUNCTION_DECL)
2475 cand2 = &cand1->next;
2478 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2479 && equal_functions (fn, (*cand2)->fn))
2480 *cand2 = (*cand2)->next;
2482 cand2 = &(*cand2)->next;
2489 str = _("candidates are:");
2490 print_z_candidate (str, candidates);
2491 if (candidates->next)
2493 /* Indent successive candidates by the width of the translation
2494 of the above string. */
2495 size_t len = gcc_gettext_width (str) + 1;
2496 char *spaces = alloca (len);
2497 memset (spaces, ' ', len-1);
2498 spaces[len - 1] = '\0';
2500 candidates = candidates->next;
2503 print_z_candidate (spaces, candidates);
2504 candidates = candidates->next;
2510 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2511 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2512 the result of the conversion function to convert it to the final
2513 desired type. Merge the the two sequences into a single sequence,
2514 and return the merged sequence. */
2517 merge_conversion_sequences (tree user_seq, tree std_seq)
2521 my_friendly_assert (TREE_CODE (user_seq) == USER_CONV,
2524 /* Find the end of the second conversion sequence. */
2526 while (TREE_CODE (*t) != IDENTITY_CONV)
2527 t = &TREE_OPERAND (*t, 0);
2529 /* Replace the identity conversion with the user conversion
2533 /* The entire sequence is a user-conversion sequence. */
2534 ICS_USER_FLAG (std_seq) = 1;
2539 /* Returns the best overload candidate to perform the requested
2540 conversion. This function is used for three the overloading situations
2541 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2542 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2543 per [dcl.init.ref], so we ignore temporary bindings. */
2545 static struct z_candidate *
2546 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2548 struct z_candidate *candidates, *cand;
2549 tree fromtype = TREE_TYPE (expr);
2550 tree ctors = NULL_TREE, convs = NULL_TREE;
2551 tree args = NULL_TREE;
2554 /* We represent conversion within a hierarchy using RVALUE_CONV and
2555 BASE_CONV, as specified by [over.best.ics]; these become plain
2556 constructor calls, as specified in [dcl.init]. */
2557 my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2558 || !DERIVED_FROM_P (totype, fromtype), 20011226);
2560 if (IS_AGGR_TYPE (totype))
2561 ctors = lookup_fnfields (TYPE_BINFO (totype),
2562 complete_ctor_identifier,
2565 if (IS_AGGR_TYPE (fromtype))
2566 convs = lookup_conversions (fromtype);
2569 flags |= LOOKUP_NO_CONVERSION;
2575 ctors = BASELINK_FUNCTIONS (ctors);
2577 t = build_int_2 (0, 0);
2578 TREE_TYPE (t) = build_pointer_type (totype);
2579 args = build_tree_list (NULL_TREE, expr);
2580 /* We should never try to call the abstract or base constructor
2582 my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2583 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),
2585 args = tree_cons (NULL_TREE, t, args);
2587 for (; ctors; ctors = OVL_NEXT (ctors))
2589 tree ctor = OVL_CURRENT (ctors);
2590 if (DECL_NONCONVERTING_P (ctor))
2593 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2594 cand = add_template_candidate (&candidates, ctor, totype,
2595 NULL_TREE, args, NULL_TREE,
2596 TYPE_BINFO (totype),
2597 TYPE_BINFO (totype),
2601 cand = add_function_candidate (&candidates, ctor, totype,
2602 args, TYPE_BINFO (totype),
2603 TYPE_BINFO (totype),
2607 cand->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE);
2611 args = build_tree_list (NULL_TREE, build_this (expr));
2613 for (; convs; convs = TREE_CHAIN (convs))
2616 tree conversion_path = TREE_PURPOSE (convs);
2617 int convflags = LOOKUP_NO_CONVERSION;
2619 /* If we are called to convert to a reference type, we are trying to
2620 find an lvalue binding, so don't even consider temporaries. If
2621 we don't find an lvalue binding, the caller will try again to
2622 look for a temporary binding. */
2623 if (TREE_CODE (totype) == REFERENCE_TYPE)
2624 convflags |= LOOKUP_NO_TEMP_BIND;
2626 for (fns = TREE_VALUE (convs); fns; fns = OVL_NEXT (fns))
2628 tree fn = OVL_CURRENT (fns);
2630 /* [over.match.funcs] For conversion functions, the function
2631 is considered to be a member of the class of the implicit
2632 object argument for the purpose of defining the type of
2633 the implicit object parameter.
2635 So we pass fromtype as CTYPE to add_*_candidate. */
2637 if (TREE_CODE (fn) == TEMPLATE_DECL)
2638 cand = add_template_candidate (&candidates, fn, fromtype,
2641 TYPE_BINFO (fromtype),
2646 cand = add_function_candidate (&candidates, fn, fromtype,
2648 TYPE_BINFO (fromtype),
2654 tree ics = implicit_conversion (totype,
2655 TREE_TYPE (TREE_TYPE (cand->fn)),
2658 cand->second_conv = ics;
2660 if (ics == NULL_TREE)
2662 else if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
2668 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2672 cand = tourney (candidates);
2675 if (flags & LOOKUP_COMPLAIN)
2677 error ("conversion from `%T' to `%T' is ambiguous",
2679 print_z_candidates (candidates);
2682 cand = candidates; /* any one will do */
2683 cand->second_conv = build1 (AMBIG_CONV, totype, expr);
2684 ICS_USER_FLAG (cand->second_conv) = 1;
2685 if (!any_strictly_viable (candidates))
2686 ICS_BAD_FLAG (cand->second_conv) = 1;
2687 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2688 ambiguous conversion is no worse than another user-defined
2694 /* Build the user conversion sequence. */
2697 (DECL_CONSTRUCTOR_P (cand->fn)
2698 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2699 build1 (IDENTITY_CONV, TREE_TYPE (expr), expr));
2700 TREE_OPERAND (convs, 1) = build_zc_wrapper (cand);
2702 /* Combine it with the second conversion sequence. */
2703 cand->second_conv = merge_conversion_sequences (convs,
2706 if (cand->viable == -1)
2707 ICS_BAD_FLAG (cand->second_conv) = 1;
2713 build_user_type_conversion (tree totype, tree expr, int flags)
2715 struct z_candidate *cand
2716 = build_user_type_conversion_1 (totype, expr, flags);
2720 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
2721 return error_mark_node;
2722 return convert_from_reference (convert_like (cand->second_conv, expr));
2727 /* Find the possibly overloaded set of functions corresponding to a
2728 call of the form SCOPE::NAME (...). NAME might be a
2729 TEMPLATE_ID_EXPR, OVERLOAD, _DECL, IDENTIFIER_NODE or LOOKUP_EXPR. */
2732 resolve_scoped_fn_name (tree scope, tree name)
2734 tree fn = NULL_TREE;
2735 tree template_args = NULL_TREE;
2736 bool is_template_id = TREE_CODE (name) == TEMPLATE_ID_EXPR;
2740 template_args = TREE_OPERAND (name, 1);
2741 name = TREE_OPERAND (name, 0);
2743 if (TREE_CODE (name) == OVERLOAD)
2744 name = DECL_NAME (get_first_fn (name));
2745 else if (TREE_CODE (name) == LOOKUP_EXPR)
2746 name = TREE_OPERAND (name, 0);
2748 if (TREE_CODE (scope) == NAMESPACE_DECL)
2749 fn = lookup_namespace_name (scope, name);
2750 else if (!CLASS_TYPE_P (scope))
2752 error ("`%T' is not a class type", scope);
2753 return error_mark_node;
2757 if (!TYPE_BEING_DEFINED (scope)
2758 && !COMPLETE_TYPE_P (complete_type (scope)))
2760 error ("incomplete type '%T' cannot be used to name a scope",
2762 return error_mark_node;
2765 if (BASELINK_P (name))
2768 fn = lookup_member (scope, name, /*protect=*/1, /*want_type=*/false);
2769 if (fn && current_class_type)
2770 fn = (adjust_result_of_qualified_name_lookup
2771 (fn, scope, current_class_type));
2773 /* It might be the name of a function pointer member. */
2774 if (fn && TREE_CODE (fn) == FIELD_DECL)
2775 fn = finish_non_static_data_member (fn, scope);
2780 error ("'%D' has no member named '%E'", scope, name);
2781 return error_mark_node;
2787 if (BASELINK_P (fn))
2788 fns = BASELINK_FUNCTIONS (fns);
2789 fns = build_nt (TEMPLATE_ID_EXPR, fns, template_args);
2790 if (BASELINK_P (fn))
2791 BASELINK_FUNCTIONS (fn) = fns;
2799 /* Do any initial processing on the arguments to a function call. */
2802 resolve_args (tree args)
2805 for (t = args; t; t = TREE_CHAIN (t))
2807 tree arg = TREE_VALUE (t);
2809 if (arg == error_mark_node)
2810 return error_mark_node;
2811 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2813 error ("invalid use of void expression");
2814 return error_mark_node;
2816 arg = convert_from_reference (arg);
2817 TREE_VALUE (t) = arg;
2822 /* Perform overload resolution on FN, which is called with the ARGS.
2824 Return the candidate function selected by overload resolution, or
2825 NULL if the event that overload resolution failed. In the case
2826 that overload resolution fails, *CANDIDATES will be the set of
2827 candidates considered, and ANY_VIABLE_P will be set to true or
2828 false to indicate whether or not any of the candidates were
2831 The ARGS should already have gone through RESOLVE_ARGS before this
2832 function is called. */
2834 static struct z_candidate *
2835 perform_overload_resolution (tree fn,
2837 struct z_candidate **candidates,
2840 struct z_candidate *cand;
2841 tree explicit_targs = NULL_TREE;
2842 int template_only = 0;
2845 *any_viable_p = true;
2847 /* Check FN and ARGS. */
2848 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
2849 || TREE_CODE (fn) == TEMPLATE_DECL
2850 || TREE_CODE (fn) == OVERLOAD
2851 || TREE_CODE (fn) == TEMPLATE_ID_EXPR,
2853 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
2856 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2858 explicit_targs = TREE_OPERAND (fn, 1);
2859 fn = TREE_OPERAND (fn, 0);
2863 /* Add the various candidate functions. */
2864 add_candidates (fn, args, explicit_targs, template_only,
2865 /*conversion_path=*/NULL_TREE,
2866 /*access_path=*/NULL_TREE,
2870 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2874 cand = tourney (*candidates);
2878 /* Return an expression for a call to FN (a namespace-scope function,
2879 or a static member function) with the ARGS. */
2882 build_new_function_call (tree fn, tree args)
2884 struct z_candidate *candidates, *cand;
2887 args = resolve_args (args);
2888 if (args == error_mark_node)
2889 return error_mark_node;
2891 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2895 if (!any_viable_p && candidates && ! candidates->next)
2896 return build_function_call (candidates->fn, args);
2897 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2898 fn = TREE_OPERAND (fn, 0);
2900 error ("no matching function for call to `%D(%A)'",
2901 DECL_NAME (OVL_CURRENT (fn)), args);
2903 error ("call of overloaded `%D(%A)' is ambiguous",
2904 DECL_NAME (OVL_CURRENT (fn)), args);
2906 print_z_candidates (candidates);
2907 return error_mark_node;
2910 return build_over_call (cand, LOOKUP_NORMAL);
2913 /* Build a call to a global operator new. FNNAME is the name of the
2914 operator (either "operator new" or "operator new[]") and ARGS are
2915 the arguments provided. *SIZE points to the total number of bytes
2916 required by the allocation, and is updated if that is changed here.
2917 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2918 function determines that no cookie should be used, after all,
2919 *COOKIE_SIZE is set to NULL_TREE. */
2922 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2925 struct z_candidate *candidates;
2926 struct z_candidate *cand;
2929 args = tree_cons (NULL_TREE, *size, args);
2930 args = resolve_args (args);
2931 if (args == error_mark_node)
2934 fns = lookup_function_nonclass (fnname, args);
2936 /* Figure out what function is being called. */
2937 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2939 /* If no suitable function could be found, issue an error message
2944 error ("no matching function for call to `%D(%A)'",
2945 DECL_NAME (OVL_CURRENT (fns)), args);
2947 error ("call of overloaded `%D(%A)' is ambiguous",
2948 DECL_NAME (OVL_CURRENT (fns)), args);
2950 print_z_candidates (candidates);
2951 return error_mark_node;
2954 /* If a cookie is required, add some extra space. Whether
2955 or not a cookie is required cannot be determined until
2956 after we know which function was called. */
2959 bool use_cookie = true;
2960 if (!abi_version_at_least (2))
2962 tree placement = TREE_CHAIN (args);
2963 /* In G++ 3.2, the check was implemented incorrectly; it
2964 looked at the placement expression, rather than the
2965 type of the function. */
2966 if (placement && !TREE_CHAIN (placement)
2967 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2975 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2976 /* Skip the size_t parameter. */
2977 arg_types = TREE_CHAIN (arg_types);
2978 /* Check the remaining parameters (if any). */
2980 && TREE_CHAIN (arg_types) == void_list_node
2981 && same_type_p (TREE_VALUE (arg_types),
2985 /* If we need a cookie, adjust the number of bytes allocated. */
2988 /* Update the total size. */
2989 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2990 /* Update the argument list to reflect the adjusted size. */
2991 TREE_VALUE (args) = *size;
2994 *cookie_size = NULL_TREE;
2997 /* Build the CALL_EXPR. */
2998 return build_over_call (cand, LOOKUP_NORMAL);
3002 build_object_call (tree obj, tree args)
3004 struct z_candidate *candidates = 0, *cand;
3005 tree fns, convs, mem_args = NULL_TREE;
3006 tree type = TREE_TYPE (obj);
3009 if (TYPE_PTRMEMFUNC_P (type))
3011 /* It's no good looking for an overloaded operator() on a
3012 pointer-to-member-function. */
3013 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3014 return error_mark_node;
3017 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3018 if (fns == error_mark_node)
3019 return error_mark_node;
3021 args = resolve_args (args);
3023 if (args == error_mark_node)
3024 return error_mark_node;
3028 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
3029 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
3031 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
3033 tree fn = OVL_CURRENT (fns);
3034 if (TREE_CODE (fn) == TEMPLATE_DECL)
3035 add_template_candidate (&candidates, fn, base, NULL_TREE,
3036 mem_args, NULL_TREE,
3039 LOOKUP_NORMAL, DEDUCE_CALL);
3041 add_function_candidate
3042 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3043 TYPE_BINFO (type), LOOKUP_NORMAL);
3047 convs = lookup_conversions (type);
3049 for (; convs; convs = TREE_CHAIN (convs))
3051 tree fns = TREE_VALUE (convs);
3052 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3054 if ((TREE_CODE (totype) == POINTER_TYPE
3055 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3056 || (TREE_CODE (totype) == REFERENCE_TYPE
3057 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3058 || (TREE_CODE (totype) == REFERENCE_TYPE
3059 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3060 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3061 for (; fns; fns = OVL_NEXT (fns))
3063 tree fn = OVL_CURRENT (fns);
3064 if (TREE_CODE (fn) == TEMPLATE_DECL)
3065 add_template_conv_candidate
3066 (&candidates, fn, obj, args, totype,
3067 /*access_path=*/NULL_TREE,
3068 /*conversion_path=*/NULL_TREE);
3070 add_conv_candidate (&candidates, fn, obj, args,
3071 /*conversion_path=*/NULL_TREE,
3072 /*access_path=*/NULL_TREE);
3076 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3079 error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
3080 print_z_candidates (candidates);
3081 return error_mark_node;
3084 cand = tourney (candidates);
3087 error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
3088 print_z_candidates (candidates);
3089 return error_mark_node;
3092 /* Since cand->fn will be a type, not a function, for a conversion
3093 function, we must be careful not to unconditionally look at
3095 if (TREE_CODE (cand->fn) == FUNCTION_DECL
3096 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3097 return build_over_call (cand, LOOKUP_NORMAL);
3099 obj = convert_like_with_context
3100 (TREE_VEC_ELT (cand->convs, 0), obj, cand->fn, -1);
3103 return build_function_call (obj, args);
3107 op_error (enum tree_code code, enum tree_code code2,
3108 tree arg1, tree arg2, tree arg3, const char *problem)
3112 if (code == MODIFY_EXPR)
3113 opname = assignment_operator_name_info[code2].name;
3115 opname = operator_name_info[code].name;
3120 error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
3121 problem, arg1, arg2, arg3);
3124 case POSTINCREMENT_EXPR:
3125 case POSTDECREMENT_EXPR:
3126 error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname);
3130 error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2);
3135 error ("%s for 'operator%s' in '%E %s %E'",
3136 problem, opname, arg1, opname, arg2);
3138 error ("%s for 'operator%s' in '%s%E'",
3139 problem, opname, opname, arg1);
3144 /* Return the implicit conversion sequence that could be used to
3145 convert E1 to E2 in [expr.cond]. */
3148 conditional_conversion (tree e1, tree e2)
3150 tree t1 = non_reference (TREE_TYPE (e1));
3151 tree t2 = non_reference (TREE_TYPE (e2));
3157 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3158 implicitly converted (clause _conv_) to the type "reference to
3159 T2", subject to the constraint that in the conversion the
3160 reference must bind directly (_dcl.init.ref_) to E1. */
3161 if (real_lvalue_p (e2))
3163 conv = implicit_conversion (build_reference_type (t2),
3166 LOOKUP_NO_TEMP_BIND);
3173 If E1 and E2 have class type, and the underlying class types are
3174 the same or one is a base class of the other: E1 can be converted
3175 to match E2 if the class of T2 is the same type as, or a base
3176 class of, the class of T1, and the cv-qualification of T2 is the
3177 same cv-qualification as, or a greater cv-qualification than, the
3178 cv-qualification of T1. If the conversion is applied, E1 is
3179 changed to an rvalue of type T2 that still refers to the original
3180 source class object (or the appropriate subobject thereof).
3182 FIXME we can't express an rvalue that refers to the original object;
3183 we have to create a new one. */
3184 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3185 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3187 if (good_base && at_least_as_qualified_p (t2, t1))
3189 conv = build1 (IDENTITY_CONV, t1, e1);
3190 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3191 TYPE_MAIN_VARIANT (t2)))
3193 conv = build_conv (BASE_CONV, t2, conv);
3194 NEED_TEMPORARY_P (conv) = 1;
3197 conv = build_conv (RVALUE_CONV, t2, conv);
3206 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3207 converted to the type that expression E2 would have if E2 were
3208 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3209 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3212 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3213 arguments to the conditional expression. */
3216 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3221 tree result_type = NULL_TREE;
3222 bool lvalue_p = true;
3223 struct z_candidate *candidates = 0;
3224 struct z_candidate *cand;
3226 /* As a G++ extension, the second argument to the conditional can be
3227 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3228 c'.) If the second operand is omitted, make sure it is
3229 calculated only once. */
3233 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3235 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3236 if (real_lvalue_p (arg1))
3237 arg2 = arg1 = stabilize_reference (arg1);
3239 arg2 = arg1 = save_expr (arg1);
3244 The first expr ession is implicitly converted to bool (clause
3246 arg1 = cp_convert (boolean_type_node, arg1);
3248 /* If something has already gone wrong, just pass that fact up the
3250 if (arg1 == error_mark_node
3251 || arg2 == error_mark_node
3252 || arg3 == error_mark_node
3253 || TREE_TYPE (arg1) == error_mark_node
3254 || TREE_TYPE (arg2) == error_mark_node
3255 || TREE_TYPE (arg3) == error_mark_node)
3256 return error_mark_node;
3260 If either the second or the third operand has type (possibly
3261 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3262 array-to-pointer (_conv.array_), and function-to-pointer
3263 (_conv.func_) standard conversions are performed on the second
3264 and third operands. */
3265 arg2_type = TREE_TYPE (arg2);
3266 arg3_type = TREE_TYPE (arg3);
3267 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3269 /* Do the conversions. We don't these for `void' type arguments
3270 since it can't have any effect and since decay_conversion
3271 does not handle that case gracefully. */
3272 if (!VOID_TYPE_P (arg2_type))
3273 arg2 = decay_conversion (arg2);
3274 if (!VOID_TYPE_P (arg3_type))
3275 arg3 = decay_conversion (arg3);
3276 arg2_type = TREE_TYPE (arg2);
3277 arg3_type = TREE_TYPE (arg3);
3281 One of the following shall hold:
3283 --The second or the third operand (but not both) is a
3284 throw-expression (_except.throw_); the result is of the
3285 type of the other and is an rvalue.
3287 --Both the second and the third operands have type void; the
3288 result is of type void and is an rvalue. */
3289 if ((TREE_CODE (arg2) == THROW_EXPR)
3290 ^ (TREE_CODE (arg3) == THROW_EXPR))
3291 result_type = ((TREE_CODE (arg2) == THROW_EXPR)
3292 ? arg3_type : arg2_type);
3293 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3294 result_type = void_type_node;
3297 error ("`%E' has type `void' and is not a throw-expression",
3298 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3299 return error_mark_node;
3303 goto valid_operands;
3307 Otherwise, if the second and third operand have different types,
3308 and either has (possibly cv-qualified) class type, an attempt is
3309 made to convert each of those operands to the type of the other. */
3310 else if (!same_type_p (arg2_type, arg3_type)
3311 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3313 tree conv2 = conditional_conversion (arg2, arg3);
3314 tree conv3 = conditional_conversion (arg3, arg2);
3318 If both can be converted, or one can be converted but the
3319 conversion is ambiguous, the program is ill-formed. If
3320 neither can be converted, the operands are left unchanged and
3321 further checking is performed as described below. If exactly
3322 one conversion is possible, that conversion is applied to the
3323 chosen operand and the converted operand is used in place of
3324 the original operand for the remainder of this section. */
3325 if ((conv2 && !ICS_BAD_FLAG (conv2)
3326 && conv3 && !ICS_BAD_FLAG (conv3))
3327 || (conv2 && TREE_CODE (conv2) == AMBIG_CONV)
3328 || (conv3 && TREE_CODE (conv3) == AMBIG_CONV))
3330 error ("operands to ?: have different types");
3331 return error_mark_node;
3333 else if (conv2 && !ICS_BAD_FLAG (conv2))
3335 arg2 = convert_like (conv2, arg2);
3336 arg2 = convert_from_reference (arg2);
3337 if (!same_type_p (TREE_TYPE (arg2), arg3_type))
3339 arg2_type = TREE_TYPE (arg2);
3341 else if (conv3 && !ICS_BAD_FLAG (conv3))
3343 arg3 = convert_like (conv3, arg3);
3344 arg3 = convert_from_reference (arg3);
3345 if (!same_type_p (TREE_TYPE (arg3), arg2_type))
3347 arg3_type = TREE_TYPE (arg3);
3353 If the second and third operands are lvalues and have the same
3354 type, the result is of that type and is an lvalue. */
3355 if (real_lvalue_p (arg2) && real_lvalue_p (arg3) &&
3356 same_type_p (arg2_type, arg3_type))
3358 result_type = arg2_type;
3359 goto valid_operands;
3364 Otherwise, the result is an rvalue. If the second and third
3365 operand do not have the same type, and either has (possibly
3366 cv-qualified) class type, overload resolution is used to
3367 determine the conversions (if any) to be applied to the operands
3368 (_over.match.oper_, _over.built_). */
3370 if (!same_type_p (arg2_type, arg3_type)
3371 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3377 /* Rearrange the arguments so that add_builtin_candidate only has
3378 to know about two args. In build_builtin_candidates, the
3379 arguments are unscrambled. */
3383 add_builtin_candidates (&candidates,
3386 ansi_opname (COND_EXPR),
3392 If the overload resolution fails, the program is
3394 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3397 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3398 print_z_candidates (candidates);
3399 return error_mark_node;
3401 cand = tourney (candidates);
3404 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3405 print_z_candidates (candidates);
3406 return error_mark_node;
3411 Otherwise, the conversions thus determined are applied, and
3412 the converted operands are used in place of the original
3413 operands for the remainder of this section. */
3414 conv = TREE_VEC_ELT (cand->convs, 0);
3415 arg1 = convert_like (conv, arg1);
3416 conv = TREE_VEC_ELT (cand->convs, 1);
3417 arg2 = convert_like (conv, arg2);
3418 conv = TREE_VEC_ELT (cand->convs, 2);
3419 arg3 = convert_like (conv, arg3);
3424 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3425 and function-to-pointer (_conv.func_) standard conversions are
3426 performed on the second and third operands.
3428 We need to force the lvalue-to-rvalue conversion here for class types,
3429 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3430 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3433 We use ocp_convert rather than build_user_type_conversion because the
3434 latter returns NULL_TREE on failure, while the former gives an error. */
3436 arg2 = force_rvalue (arg2);
3437 arg2_type = TREE_TYPE (arg2);
3439 arg3 = force_rvalue (arg3);
3440 arg3_type = TREE_TYPE (arg3);
3442 if (arg2 == error_mark_node || arg3 == error_mark_node)
3443 return error_mark_node;
3447 After those conversions, one of the following shall hold:
3449 --The second and third operands have the same type; the result is of
3451 if (same_type_p (arg2_type, arg3_type))
3452 result_type = arg2_type;
3455 --The second and third operands have arithmetic or enumeration
3456 type; the usual arithmetic conversions are performed to bring
3457 them to a common type, and the result is of that type. */
3458 else if ((ARITHMETIC_TYPE_P (arg2_type)
3459 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3460 && (ARITHMETIC_TYPE_P (arg3_type)
3461 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3463 /* In this case, there is always a common type. */
3464 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3467 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3468 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3469 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3470 arg2_type, arg3_type);
3471 else if (extra_warnings
3472 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3473 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3474 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3475 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3476 warning ("enumeral and non-enumeral type in conditional expression");
3478 arg2 = perform_implicit_conversion (result_type, arg2);
3479 arg3 = perform_implicit_conversion (result_type, arg3);
3483 --The second and third operands have pointer type, or one has
3484 pointer type and the other is a null pointer constant; pointer
3485 conversions (_conv.ptr_) and qualification conversions
3486 (_conv.qual_) are performed to bring them to their composite
3487 pointer type (_expr.rel_). The result is of the composite
3490 --The second and third operands have pointer to member type, or
3491 one has pointer to member type and the other is a null pointer
3492 constant; pointer to member conversions (_conv.mem_) and
3493 qualification conversions (_conv.qual_) are performed to bring
3494 them to a common type, whose cv-qualification shall match the
3495 cv-qualification of either the second or the third operand.
3496 The result is of the common type. */
3497 else if ((null_ptr_cst_p (arg2)
3498 && (TYPE_PTR_P (arg3_type) || TYPE_PTRMEM_P (arg3_type)
3499 || TYPE_PTRMEMFUNC_P (arg3_type)))
3500 || (null_ptr_cst_p (arg3)
3501 && (TYPE_PTR_P (arg2_type) || TYPE_PTRMEM_P (arg2_type)
3502 || TYPE_PTRMEMFUNC_P (arg2_type)))
3503 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3504 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3505 || (TYPE_PTRMEMFUNC_P (arg2_type)
3506 && TYPE_PTRMEMFUNC_P (arg3_type)))
3508 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3509 arg3, "conditional expression");
3510 arg2 = perform_implicit_conversion (result_type, arg2);
3511 arg3 = perform_implicit_conversion (result_type, arg3);
3516 error ("operands to ?: have different types");
3517 return error_mark_node;
3521 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3522 /* We can't use result_type below, as fold might have returned a
3525 /* Expand both sides into the same slot, hopefully the target of the
3526 ?: expression. We used to check for TARGET_EXPRs here, but now we
3527 sometimes wrap them in NOP_EXPRs so the test would fail. */
3528 if (!lvalue_p && IS_AGGR_TYPE (TREE_TYPE (result)))
3529 result = get_target_expr (result);
3531 /* If this expression is an rvalue, but might be mistaken for an
3532 lvalue, we must add a NON_LVALUE_EXPR. */
3533 if (!lvalue_p && real_lvalue_p (result))
3534 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3539 /* OPERAND is an operand to an expression. Perform necessary steps
3540 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3544 prep_operand (tree operand)
3548 operand = convert_from_reference (operand);
3549 if (CLASS_TYPE_P (TREE_TYPE (operand))
3550 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3551 /* Make sure the template type is instantiated now. */
3552 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3558 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3559 OVERLOAD) to the CANDIDATES, returning an updated list of
3560 CANDIDATES. The ARGS are the arguments provided to the call,
3561 without any implicit object parameter. The EXPLICIT_TARGS are
3562 explicit template arguments provided. TEMPLATE_ONLY is true if
3563 only template fucntions should be considered. CONVERSION_PATH,
3564 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3567 add_candidates (tree fns, tree args,
3568 tree explicit_targs, bool template_only,
3569 tree conversion_path, tree access_path,
3571 struct z_candidate **candidates)
3574 tree non_static_args;
3576 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3577 /* Delay creating the implicit this parameter until it is needed. */
3578 non_static_args = NULL_TREE;
3585 fn = OVL_CURRENT (fns);
3586 /* Figure out which set of arguments to use. */
3587 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3589 /* If this function is a non-static member, prepend the implicit
3590 object parameter. */
3591 if (!non_static_args)
3592 non_static_args = tree_cons (NULL_TREE,
3593 build_this (TREE_VALUE (args)),
3595 fn_args = non_static_args;
3598 /* Otherwise, just use the list of arguments provided. */
3601 if (TREE_CODE (fn) == TEMPLATE_DECL)
3602 add_template_candidate (candidates,
3612 else if (!template_only)
3613 add_function_candidate (candidates,
3620 fns = OVL_NEXT (fns);
3625 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3)
3627 struct z_candidate *candidates = 0, *cand;
3628 tree arglist, fnname;
3630 enum tree_code code2 = NOP_EXPR;
3635 if (error_operand_p (arg1)
3636 || error_operand_p (arg2)
3637 || error_operand_p (arg3))
3638 return error_mark_node;
3640 if (code == MODIFY_EXPR)
3642 code2 = TREE_CODE (arg3);
3644 fnname = ansi_assopname (code2);
3647 fnname = ansi_opname (code);
3649 arg1 = prep_operand (arg1);
3655 case VEC_DELETE_EXPR:
3657 /* Use build_op_new_call and build_op_delete_call instead. */
3661 return build_object_call (arg1, arg2);
3667 arg2 = prep_operand (arg2);
3668 arg3 = prep_operand (arg3);
3670 if (code == COND_EXPR)
3672 if (arg2 == NULL_TREE
3673 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3674 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3675 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3676 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3679 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3680 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3683 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3684 arg2 = integer_zero_node;
3686 arglist = NULL_TREE;
3688 arglist = tree_cons (NULL_TREE, arg3, arglist);
3690 arglist = tree_cons (NULL_TREE, arg2, arglist);
3691 arglist = tree_cons (NULL_TREE, arg1, arglist);
3693 /* Add namespace-scope operators to the list of functions to
3695 add_candidates (lookup_function_nonclass (fnname, arglist),
3696 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3697 flags, &candidates);
3698 /* Add class-member operators to the candidate set. */
3699 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3703 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3704 if (fns == error_mark_node)
3707 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3709 BASELINK_BINFO (fns),
3710 TYPE_BINFO (TREE_TYPE (arg1)),
3711 flags, &candidates);
3714 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3715 to know about two args; a builtin candidate will always have a first
3716 parameter of type bool. We'll handle that in
3717 build_builtin_candidate. */
3718 if (code == COND_EXPR)
3728 args[2] = NULL_TREE;
3731 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3737 /* For these, the built-in candidates set is empty
3738 [over.match.oper]/3. We don't want non-strict matches
3739 because exact matches are always possible with built-in
3740 operators. The built-in candidate set for COMPONENT_REF
3741 would be empty too, but since there are no such built-in
3742 operators, we accept non-strict matches for them. */
3747 strict_p = pedantic;
3751 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3756 case POSTINCREMENT_EXPR:
3757 case POSTDECREMENT_EXPR:
3758 /* Look for an `operator++ (int)'. If they didn't have
3759 one, then we fall back to the old way of doing things. */
3760 if (flags & LOOKUP_COMPLAIN)
3761 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3763 operator_name_info[code].name);
3764 if (code == POSTINCREMENT_EXPR)
3765 code = PREINCREMENT_EXPR;
3767 code = PREDECREMENT_EXPR;
3768 return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
3770 /* The caller will deal with these. */
3779 if (flags & LOOKUP_COMPLAIN)
3781 op_error (code, code2, arg1, arg2, arg3, "no match");
3782 print_z_candidates (candidates);
3784 return error_mark_node;
3787 cand = tourney (candidates);
3790 if (flags & LOOKUP_COMPLAIN)
3792 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3793 print_z_candidates (candidates);
3795 return error_mark_node;
3798 if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3801 && fnname == ansi_assopname (NOP_EXPR)
3802 && DECL_ARTIFICIAL (cand->fn)
3804 && ! candidates->next->next)
3806 warning ("using synthesized `%#D' for copy assignment",
3808 cp_warning_at (" where cfront would use `%#D'",
3810 ? candidates->next->fn
3814 return build_over_call (cand, LOOKUP_NORMAL);
3817 /* Check for comparison of different enum types. */
3826 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3827 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3828 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3829 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3831 warning ("comparison between `%#T' and `%#T'",
3832 TREE_TYPE (arg1), TREE_TYPE (arg2));
3839 /* We need to strip any leading REF_BIND so that bitfields don't cause
3840 errors. This should not remove any important conversions, because
3841 builtins don't apply to class objects directly. */
3842 conv = TREE_VEC_ELT (cand->convs, 0);
3843 if (TREE_CODE (conv) == REF_BIND)
3844 conv = TREE_OPERAND (conv, 0);
3845 arg1 = convert_like (conv, arg1);
3848 conv = TREE_VEC_ELT (cand->convs, 1);
3849 if (TREE_CODE (conv) == REF_BIND)
3850 conv = TREE_OPERAND (conv, 0);
3851 arg2 = convert_like (conv, arg2);
3855 conv = TREE_VEC_ELT (cand->convs, 2);
3856 if (TREE_CODE (conv) == REF_BIND)
3857 conv = TREE_OPERAND (conv, 0);
3858 arg3 = convert_like (conv, arg3);
3865 return build_modify_expr (arg1, code2, arg2);
3868 return build_indirect_ref (arg1, "unary *");
3873 case TRUNC_DIV_EXPR:
3884 case TRUNC_MOD_EXPR:
3888 case TRUTH_ANDIF_EXPR:
3889 case TRUTH_ORIF_EXPR:
3890 return cp_build_binary_op (code, arg1, arg2);
3895 case TRUTH_NOT_EXPR:
3896 case PREINCREMENT_EXPR:
3897 case POSTINCREMENT_EXPR:
3898 case PREDECREMENT_EXPR:
3899 case POSTDECREMENT_EXPR:
3902 return build_unary_op (code, arg1, candidates != 0);
3905 return build_array_ref (arg1, arg2);
3908 return build_conditional_expr (arg1, arg2, arg3);
3911 return build_m_component_ref
3912 (build_indirect_ref (arg1, NULL), arg2);
3914 /* The caller will deal with these. */
3926 /* Build a call to operator delete. This has to be handled very specially,
3927 because the restrictions on what signatures match are different from all
3928 other call instances. For a normal delete, only a delete taking (void *)
3929 or (void *, size_t) is accepted. For a placement delete, only an exact
3930 match with the placement new is accepted.
3932 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3933 ADDR is the pointer to be deleted.
3934 SIZE is the size of the memory block to be deleted.
3935 FLAGS are the usual overloading flags.
3936 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3939 build_op_delete_call (enum tree_code code, tree addr, tree size,
3940 int flags, tree placement)
3942 tree fn = NULL_TREE;
3943 tree fns, fnname, argtypes, args, type;
3946 if (addr == error_mark_node)
3947 return error_mark_node;
3949 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3951 fnname = ansi_opname (code);
3953 if (IS_AGGR_TYPE (type) && ! (flags & LOOKUP_GLOBAL))
3956 If the result of the lookup is ambiguous or inaccessible, or if
3957 the lookup selects a placement deallocation function, the
3958 program is ill-formed.
3960 Therefore, we ask lookup_fnfields to complain ambout ambiguity. */
3962 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3963 if (fns == error_mark_node)
3964 return error_mark_node;
3969 if (fns == NULL_TREE)
3970 fns = lookup_name_nonclass (fnname);
3977 /* Find the allocation function that is being called. */
3978 call_expr = placement;
3979 /* Sometimes we have a COMPOUND_EXPR, rather than a simple
3981 while (TREE_CODE (call_expr) == COMPOUND_EXPR)
3982 call_expr = TREE_OPERAND (call_expr, 1);
3983 /* Extract the function. */
3984 alloc_fn = get_callee_fndecl (call_expr);
3985 my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
3986 /* Then the second parm type. */
3987 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3988 /* Also the second argument. */
3989 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3993 /* First try it without the size argument. */
3994 argtypes = void_list_node;
3998 /* Strip const and volatile from addr. */
3999 addr = cp_convert (ptr_type_node, addr);
4001 /* We make two tries at finding a matching `operator delete'. On
4002 the first pass, we look for a one-operator (or placement)
4003 operator delete. If we're not doing placement delete, then on
4004 the second pass we look for a two-argument delete. */
4005 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4007 /* Go through the `operator delete' functions looking for one
4008 with a matching type. */
4009 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4015 /* The first argument must be "void *". */
4016 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4017 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4020 /* On the first pass, check the rest of the arguments. */
4023 while (argtypes && t)
4025 if (!same_type_p (TREE_VALUE (argtypes),
4028 argtypes = TREE_CHAIN (argtypes);
4031 if (!argtypes && !t)
4034 /* On the second pass, the second argument must be
4037 && same_type_p (TREE_VALUE (t), sizetype)
4038 && TREE_CHAIN (t) == void_list_node)
4042 /* If we found a match, we're done. */
4047 /* If we have a matching function, call it. */
4050 /* Make sure we have the actual function, and not an
4052 fn = OVL_CURRENT (fn);
4054 /* If the FN is a member function, make sure that it is
4056 if (DECL_CLASS_SCOPE_P (fn))
4057 perform_or_defer_access_check (TYPE_BINFO (type), fn);
4060 args = tree_cons (NULL_TREE, addr, args);
4062 args = tree_cons (NULL_TREE, addr,
4063 build_tree_list (NULL_TREE, size));
4065 return build_function_call (fn, args);
4068 /* If we are doing placement delete we do nothing if we don't find a
4069 matching op delete. */
4073 error ("no suitable `operator %s' for `%T'",
4074 operator_name_info[(int)code].name, type);
4075 return error_mark_node;
4078 /* If the current scope isn't allowed to access DECL along
4079 BASETYPE_PATH, give an error. The most derived class in
4080 BASETYPE_PATH is the one used to qualify DECL. */
4083 enforce_access (tree basetype_path, tree decl)
4085 my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624);
4087 if (!accessible_p (basetype_path, decl))
4089 if (TREE_PRIVATE (decl))
4090 cp_error_at ("`%+#D' is private", decl);
4091 else if (TREE_PROTECTED (decl))
4092 cp_error_at ("`%+#D' is protected", decl);
4094 cp_error_at ("`%+#D' is inaccessible", decl);
4095 error ("within this context");
4102 /* Perform the conversions in CONVS on the expression EXPR. FN and
4103 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4104 indicates the `this' argument of a method. INNER is nonzero when
4105 being called to continue a conversion chain. It is negative when a
4106 reference binding will be applied, positive otherwise. If
4107 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4108 conversions will be emitted if appropriate. */
4111 convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner,
4112 bool issue_conversion_warnings)
4116 tree totype = TREE_TYPE (convs);
4118 if (ICS_BAD_FLAG (convs)
4119 && TREE_CODE (convs) != USER_CONV
4120 && TREE_CODE (convs) != AMBIG_CONV
4121 && TREE_CODE (convs) != REF_BIND)
4124 for (; t; t = TREE_OPERAND (t, 0))
4126 if (TREE_CODE (t) == USER_CONV || !ICS_BAD_FLAG (t))
4128 expr = convert_like_real (t, expr, fn, argnum, 1,
4129 /*issue_conversion_warnings=*/false);
4132 else if (TREE_CODE (t) == AMBIG_CONV)
4133 return convert_like_real (t, expr, fn, argnum, 1,
4134 /*issue_conversion_warnings=*/false);
4135 else if (TREE_CODE (t) == IDENTITY_CONV)
4138 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
4140 pedwarn (" initializing argument %P of `%D'", argnum, fn);
4141 return cp_convert (totype, expr);
4144 if (issue_conversion_warnings)
4145 expr = dubious_conversion_warnings
4146 (totype, expr, "argument", fn, argnum);
4147 switch (TREE_CODE (convs))
4151 struct z_candidate *cand = USER_CONV_CAND (convs);
4152 tree convfn = cand->fn;
4155 if (DECL_CONSTRUCTOR_P (convfn))
4157 tree t = build_int_2 (0, 0);
4158 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
4160 args = build_tree_list (NULL_TREE, expr);
4161 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
4162 || DECL_HAS_VTT_PARM_P (convfn))
4163 /* We should never try to call the abstract or base constructor
4166 args = tree_cons (NULL_TREE, t, args);
4169 args = build_this (expr);
4170 expr = build_over_call (cand, LOOKUP_NORMAL);
4172 /* If this is a constructor or a function returning an aggr type,
4173 we need to build up a TARGET_EXPR. */
4174 if (DECL_CONSTRUCTOR_P (convfn))
4175 expr = build_cplus_new (totype, expr);
4177 /* The result of the call is then used to direct-initialize the object
4178 that is the destination of the copy-initialization. [dcl.init]
4180 Note that this step is not reflected in the conversion sequence;
4181 it affects the semantics when we actually perform the
4182 conversion, but is not considered during overload resolution.
4184 If the target is a class, that means call a ctor. */
4185 if (IS_AGGR_TYPE (totype)
4186 && (inner >= 0 || !lvalue_p (expr)))
4188 savew = warningcount, savee = errorcount;
4189 expr = build_special_member_call
4190 (NULL_TREE, complete_ctor_identifier,
4191 build_tree_list (NULL_TREE, expr), TYPE_BINFO (totype),
4192 /* Core issue 84, now a DR, says that we don't allow UDCs
4193 for these args (which deliberately breaks copy-init of an
4194 auto_ptr<Base> from an auto_ptr<Derived>). */
4195 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION);
4197 /* Tell the user where this failing constructor call came from. */
4200 if (warningcount > savew)
4202 (" initializing argument %P of `%D' from result of `%D'",
4203 argnum, fn, convfn);
4204 else if (errorcount > savee)
4206 (" initializing argument %P of `%D' from result of `%D'",
4207 argnum, fn, convfn);
4211 if (warningcount > savew)
4212 warning (" initializing temporary from result of `%D'",
4214 else if (errorcount > savee)
4215 error (" initializing temporary from result of `%D'",
4218 expr = build_cplus_new (totype, expr);
4223 if (type_unknown_p (expr))
4224 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4225 /* Convert a non-array constant variable to its underlying value, unless we
4226 are about to bind it to a reference, in which case we need to
4227 leave it as an lvalue. */
4229 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4230 expr = decl_constant_value (expr);
4233 /* Call build_user_type_conversion again for the error. */
4234 return build_user_type_conversion
4235 (totype, TREE_OPERAND (convs, 0), LOOKUP_NORMAL);
4241 expr = convert_like_real (TREE_OPERAND (convs, 0), expr, fn, argnum,
4242 TREE_CODE (convs) == REF_BIND ? -1 : 1,
4243 /*issue_conversion_warnings=*/false);
4244 if (expr == error_mark_node)
4245 return error_mark_node;
4247 switch (TREE_CODE (convs))
4250 if (! IS_AGGR_TYPE (totype))
4252 /* else fall through */
4254 if (TREE_CODE (convs) == BASE_CONV && !NEED_TEMPORARY_P (convs))
4256 /* We are going to bind a reference directly to a base-class
4257 subobject of EXPR. */
4258 tree base_ptr = build_pointer_type (totype);
4260 /* Build an expression for `*((base*) &expr)'. */
4261 expr = build_unary_op (ADDR_EXPR, expr, 0);
4262 expr = perform_implicit_conversion (base_ptr, expr);
4263 expr = build_indirect_ref (expr, "implicit conversion");
4267 /* Copy-initialization where the cv-unqualified version of the source
4268 type is the same class as, or a derived class of, the class of the
4269 destination [is treated as direct-initialization]. [dcl.init] */
4270 savew = warningcount, savee = errorcount;
4271 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4272 build_tree_list (NULL_TREE, expr),
4273 TYPE_BINFO (totype),
4274 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING);
4277 if (warningcount > savew)
4278 warning (" initializing argument %P of `%D'", argnum, fn);
4279 else if (errorcount > savee)
4280 error (" initializing argument %P of `%D'", argnum, fn);
4282 return build_cplus_new (totype, expr);
4286 tree ref_type = totype;
4288 /* If necessary, create a temporary. */
4289 if (NEED_TEMPORARY_P (convs) || !non_cast_lvalue_p (expr))
4291 tree type = TREE_TYPE (TREE_OPERAND (convs, 0));
4292 expr = build_target_expr_with_type (expr, type);
4295 /* Take the address of the thing to which we will bind the
4297 expr = build_unary_op (ADDR_EXPR, expr, 1);
4298 if (expr == error_mark_node)
4299 return error_mark_node;
4301 /* Convert it to a pointer to the type referred to by the
4302 reference. This will adjust the pointer if a derived to
4303 base conversion is being performed. */
4304 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4306 /* Convert the pointer to the desired reference type. */
4307 return build_nop (ref_type, expr);
4311 return decay_conversion (expr);
4314 /* Warn about deprecated conversion if appropriate. */
4315 string_conv_p (totype, expr, 1);
4321 return ocp_convert (totype, expr, CONV_IMPLICIT,
4322 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4325 /* Build a call to __builtin_trap which can be used in an expression. */
4328 call_builtin_trap (void)
4330 tree fn = get_identifier ("__builtin_trap");
4331 if (IDENTIFIER_GLOBAL_VALUE (fn))
4332 fn = IDENTIFIER_GLOBAL_VALUE (fn);
4336 fn = build_call (fn, NULL_TREE);
4337 fn = build (COMPOUND_EXPR, integer_type_node, fn, integer_zero_node);
4341 /* ARG is being passed to a varargs function. Perform any conversions
4342 required. Return the converted value. */
4345 convert_arg_to_ellipsis (tree arg)
4349 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4350 standard conversions are performed. */
4351 arg = decay_conversion (arg);
4354 If the argument has integral or enumeration type that is subject
4355 to the integral promotions (_conv.prom_), or a floating point
4356 type that is subject to the floating point promotion
4357 (_conv.fpprom_), the value of the argument is converted to the
4358 promoted type before the call. */
4359 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4360 && (TYPE_PRECISION (TREE_TYPE (arg))
4361 < TYPE_PRECISION (double_type_node)))
4362 arg = cp_convert (double_type_node, arg);
4363 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4364 arg = perform_integral_promotions (arg);
4366 arg = require_complete_type (arg);
4368 if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
4370 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4371 here and do a bitwise copy, but now cp_expr_size will abort if we
4373 warning ("cannot pass objects of non-POD type `%#T' through `...'; \
4374 call will abort at runtime",
4376 arg = call_builtin_trap ();
4382 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4385 build_x_va_arg (tree expr, tree type)
4387 if (processing_template_decl)
4388 return build_min (VA_ARG_EXPR, type, expr);
4390 type = complete_type_or_else (type, NULL_TREE);
4392 if (expr == error_mark_node || !type)
4393 return error_mark_node;
4395 if (! pod_type_p (type))
4397 /* Undefined behavior [expr.call] 5.2.2/7. */
4398 warning ("cannot receive objects of non-POD type `%#T' through `...'",
4402 return build_va_arg (expr, type);
4405 /* TYPE has been given to va_arg. Apply the default conversions which
4406 would have happened when passed via ellipsis. Return the promoted
4407 type, or the passed type if there is no change. */
4410 cxx_type_promotes_to (tree type)
4414 if (TREE_CODE (type) == ARRAY_TYPE)
4415 return build_pointer_type (TREE_TYPE (type));
4417 if (TREE_CODE (type) == FUNCTION_TYPE)
4418 return build_pointer_type (type);
4420 promote = type_promotes_to (type);
4421 if (same_type_p (type, promote))
4427 /* ARG is a default argument expression being passed to a parameter of
4428 the indicated TYPE, which is a parameter to FN. Do any required
4429 conversions. Return the converted value. */
4432 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4434 /* If the ARG is an unparsed default argument expression, the
4435 conversion cannot be performed. */
4436 if (TREE_CODE (arg) == DEFAULT_ARG)
4438 error ("the default argument for parameter %d of `%D' has "
4439 "not yet been parsed",
4441 return error_mark_node;
4444 if (fn && DECL_TEMPLATE_INFO (fn))
4445 arg = tsubst_default_argument (fn, type, arg);
4447 arg = break_out_target_exprs (arg);
4449 if (TREE_CODE (arg) == CONSTRUCTOR)
4451 arg = digest_init (type, arg, 0);
4452 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4453 "default argument", fn, parmnum);
4457 /* This could get clobbered by the following call. */
4458 if (TREE_HAS_CONSTRUCTOR (arg))
4459 arg = copy_node (arg);
4461 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4462 "default argument", fn, parmnum);
4463 arg = convert_for_arg_passing (type, arg);
4469 /* Returns the type which will really be used for passing an argument of
4473 type_passed_as (tree type)
4475 /* Pass classes with copy ctors by invisible reference. */
4476 if (TREE_ADDRESSABLE (type))
4477 type = build_reference_type (type);
4478 else if (PROMOTE_PROTOTYPES
4479 && INTEGRAL_TYPE_P (type)
4480 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4481 type = integer_type_node;
4486 /* Actually perform the appropriate conversion. */
4489 convert_for_arg_passing (tree type, tree val)
4491 if (val == error_mark_node)
4493 /* Pass classes with copy ctors by invisible reference. */
4494 else if (TREE_ADDRESSABLE (type))
4495 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4496 else if (PROMOTE_PROTOTYPES
4497 && INTEGRAL_TYPE_P (type)
4498 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4499 val = perform_integral_promotions (val);
4503 /* Subroutine of the various build_*_call functions. Overload resolution
4504 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4505 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4506 bitmask of various LOOKUP_* flags which apply to the call itself. */
4509 build_over_call (struct z_candidate *cand, int flags)
4512 tree args = cand->args;
4513 tree convs = cand->convs;
4514 tree converted_args = NULL_TREE;
4515 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4516 tree conv, arg, val;
4520 /* Give any warnings we noticed during overload resolution. */
4522 for (val = cand->warnings; val; val = TREE_CHAIN (val))
4523 joust (cand, WRAPPER_ZC (TREE_VALUE (val)), 1);
4525 if (DECL_FUNCTION_MEMBER_P (fn))
4526 perform_or_defer_access_check (cand->access_path, fn);
4528 if (args && TREE_CODE (args) != TREE_LIST)
4529 args = build_tree_list (NULL_TREE, args);
4532 /* The implicit parameters to a constructor are not considered by overload
4533 resolution, and must be of the proper type. */
4534 if (DECL_CONSTRUCTOR_P (fn))
4536 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4537 arg = TREE_CHAIN (arg);
4538 parm = TREE_CHAIN (parm);
4539 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4540 /* We should never try to call the abstract constructor. */
4542 if (DECL_HAS_VTT_PARM_P (fn))
4544 converted_args = tree_cons
4545 (NULL_TREE, TREE_VALUE (arg), converted_args);
4546 arg = TREE_CHAIN (arg);
4547 parm = TREE_CHAIN (parm);
4550 /* Bypass access control for 'this' parameter. */
4551 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4553 tree parmtype = TREE_VALUE (parm);
4554 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4558 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
4559 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4560 TREE_TYPE (argtype), fn);
4562 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4563 X is called for an object that is not of type X, or of a type
4564 derived from X, the behavior is undefined.
4566 So we can assume that anything passed as 'this' is non-null, and
4567 optimize accordingly. */
4568 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4569 /* Convert to the base in which the function was declared. */
4570 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4571 converted_arg = build_base_path (PLUS_EXPR,
4573 cand->conversion_path,
4575 /* If fn was found by a using declaration, the conversion path
4576 will be to the derived class, not the base declaring fn. We
4577 must convert from derived to base. */
4578 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4579 TREE_TYPE (parmtype), ba_ignore, NULL);
4581 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4584 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4585 parm = TREE_CHAIN (parm);
4586 arg = TREE_CHAIN (arg);
4592 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4594 tree type = TREE_VALUE (parm);
4596 conv = TREE_VEC_ELT (convs, i);
4597 val = convert_like_with_context
4598 (conv, TREE_VALUE (arg), fn, i - is_method);
4600 val = convert_for_arg_passing (type, val);
4601 converted_args = tree_cons (NULL_TREE, val, converted_args);
4604 /* Default arguments */
4605 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4607 = tree_cons (NULL_TREE,
4608 convert_default_arg (TREE_VALUE (parm),
4609 TREE_PURPOSE (parm),
4614 for (; arg; arg = TREE_CHAIN (arg))
4616 = tree_cons (NULL_TREE,
4617 convert_arg_to_ellipsis (TREE_VALUE (arg)),
4620 converted_args = nreverse (converted_args);
4623 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4626 /* Avoid actually calling copy constructors and copy assignment operators,
4629 if (! flag_elide_constructors)
4630 /* Do things the hard way. */;
4631 else if (TREE_VEC_LENGTH (convs) == 1
4632 && DECL_COPY_CONSTRUCTOR_P (fn))
4635 arg = skip_artificial_parms_for (fn, converted_args);
4636 arg = TREE_VALUE (arg);
4638 /* Pull out the real argument, disregarding const-correctness. */
4640 while (TREE_CODE (targ) == NOP_EXPR
4641 || TREE_CODE (targ) == NON_LVALUE_EXPR
4642 || TREE_CODE (targ) == CONVERT_EXPR)
4643 targ = TREE_OPERAND (targ, 0);
4644 if (TREE_CODE (targ) == ADDR_EXPR)
4646 targ = TREE_OPERAND (targ, 0);
4647 if (!same_type_ignoring_top_level_qualifiers_p
4648 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4657 arg = build_indirect_ref (arg, 0);
4659 /* [class.copy]: the copy constructor is implicitly defined even if
4660 the implementation elided its use. */
4661 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4664 /* If we're creating a temp and we already have one, don't create a
4665 new one. If we're not creating a temp but we get one, use
4666 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4667 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4668 temp or an INIT_EXPR otherwise. */
4669 if (integer_zerop (TREE_VALUE (args)))
4671 if (TREE_CODE (arg) == TARGET_EXPR)
4673 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4674 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4676 else if (TREE_CODE (arg) == TARGET_EXPR
4677 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4680 tree to = stabilize_reference
4681 (build_indirect_ref (TREE_VALUE (args), 0));
4683 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4684 address = build_unary_op (ADDR_EXPR, val, 0);
4685 /* Avoid a warning about this expression, if the address is
4687 TREE_USED (address) = 1;
4691 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4693 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4695 tree to = stabilize_reference
4696 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4698 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4699 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4705 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4707 tree t, *p = &TREE_VALUE (converted_args);
4708 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4711 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4713 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4714 if (TREE_SIDE_EFFECTS (*p))
4715 *p = save_expr (*p);
4716 t = build_pointer_type (TREE_TYPE (fn));
4717 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4718 fn = build_java_interface_fn_ref (fn, *p);
4720 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4723 else if (DECL_INLINE (fn))
4724 fn = inline_conversion (fn);
4726 fn = build_addr_func (fn);
4728 return build_cxx_call (fn, args, converted_args);
4731 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4732 gives the original form of the arguments. This function performs
4733 no overload resolution, conversion, or other high-level
4737 build_cxx_call(tree fn, tree args, tree converted_args)
4741 /* Recognize certain built-in functions so we can make tree-codes
4742 other than CALL_EXPR. We do this when it enables fold-const.c
4743 to do something useful. */
4744 if (TREE_CODE (fn) == ADDR_EXPR
4745 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4746 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4749 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4754 fn = build_call (fn, converted_args);
4756 /* If this call might throw an exception, note that fact. */
4757 fndecl = get_callee_fndecl (fn);
4758 if ((!fndecl || !TREE_NOTHROW (fndecl))
4759 && at_function_scope_p ()
4761 cp_function_chain->can_throw = 1;
4763 /* Some built-in function calls will be evaluated at compile-time in
4767 if (VOID_TYPE_P (TREE_TYPE (fn)))
4770 fn = require_complete_type (fn);
4771 if (fn == error_mark_node)
4772 return error_mark_node;
4774 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4775 fn = build_cplus_new (TREE_TYPE (fn), fn);
4776 return convert_from_reference (fn);
4779 static GTY(()) tree java_iface_lookup_fn;
4781 /* Make an expression which yields the address of the Java interface
4782 method FN. This is achieved by generating a call to libjava's
4783 _Jv_LookupInterfaceMethodIdx(). */
4786 build_java_interface_fn_ref (tree fn, tree instance)
4788 tree lookup_args, lookup_fn, method, idx;
4789 tree klass_ref, iface, iface_ref;
4792 if (!java_iface_lookup_fn)
4794 tree endlink = build_void_list_node ();
4795 tree t = tree_cons (NULL_TREE, ptr_type_node,
4796 tree_cons (NULL_TREE, ptr_type_node,
4797 tree_cons (NULL_TREE, java_int_type_node,
4799 java_iface_lookup_fn
4800 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4801 build_function_type (ptr_type_node, t),
4802 0, NOT_BUILT_IN, NULL, NULL_TREE);
4805 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4806 This is the first entry in the vtable. */
4807 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4810 /* Get the java.lang.Class pointer for the interface being called. */
4811 iface = DECL_CONTEXT (fn);
4812 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4813 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4814 || DECL_CONTEXT (iface_ref) != iface)
4816 error ("could not find class$ field in java interface type `%T'",
4818 return error_mark_node;
4820 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4822 /* Determine the itable index of FN. */
4824 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4826 if (!DECL_VIRTUAL_P (method))
4832 idx = build_int_2 (i, 0);
4834 lookup_args = tree_cons (NULL_TREE, klass_ref,
4835 tree_cons (NULL_TREE, iface_ref,
4836 build_tree_list (NULL_TREE, idx)));
4837 lookup_fn = build1 (ADDR_EXPR,
4838 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4839 java_iface_lookup_fn);
4840 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4843 /* Returns the value to use for the in-charge parameter when making a
4844 call to a function with the indicated NAME. */
4847 in_charge_arg_for_name (tree name)
4849 if (name == base_ctor_identifier
4850 || name == base_dtor_identifier)
4851 return integer_zero_node;
4852 else if (name == complete_ctor_identifier)
4853 return integer_one_node;
4854 else if (name == complete_dtor_identifier)
4855 return integer_two_node;
4856 else if (name == deleting_dtor_identifier)
4857 return integer_three_node;
4859 /* This function should only be called with one of the names listed
4865 /* Build a call to a constructor, destructor, or an assignment
4866 operator for INSTANCE, an expression with class type. NAME
4867 indicates the special member function to call; ARGS are the
4868 arguments. BINFO indicates the base of INSTANCE that is to be
4869 passed as the `this' parameter to the member function called.
4871 FLAGS are the LOOKUP_* flags to use when processing the call.
4873 If NAME indicates a complete object constructor, INSTANCE may be
4874 NULL_TREE. In this case, the caller will call build_cplus_new to
4875 store the newly constructed object into a VAR_DECL. */
4878 build_special_member_call (tree instance, tree name, tree args,
4879 tree binfo, int flags)
4882 /* The type of the subobject to be constructed or destroyed. */
4885 my_friendly_assert (name == complete_ctor_identifier
4886 || name == base_ctor_identifier
4887 || name == complete_dtor_identifier
4888 || name == base_dtor_identifier
4889 || name == deleting_dtor_identifier
4890 || name == ansi_assopname (NOP_EXPR),
4892 my_friendly_assert (binfo != NULL_TREE, 20020712);
4894 class_type = BINFO_TYPE (binfo);
4896 /* Handle the special case where INSTANCE is NULL_TREE. */
4897 if (name == complete_ctor_identifier && !instance)
4899 instance = build_int_2 (0, 0);
4900 TREE_TYPE (instance) = build_pointer_type (class_type);
4901 instance = build1 (INDIRECT_REF, class_type, instance);
4903 else if (name == complete_dtor_identifier
4904 || name == base_dtor_identifier
4905 || name == deleting_dtor_identifier)
4906 my_friendly_assert (args == NULL_TREE, 20020712);
4908 my_friendly_assert (instance != NULL_TREE, 20020712);
4910 /* Resolve the name. */
4911 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
4912 return error_mark_node;
4914 fns = lookup_fnfields (binfo, name, 1);
4916 /* When making a call to a constructor or destructor for a subobject
4917 that uses virtual base classes, pass down a pointer to a VTT for
4919 if ((name == base_ctor_identifier
4920 || name == base_dtor_identifier)
4921 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
4926 /* If the current function is a complete object constructor
4927 or destructor, then we fetch the VTT directly.
4928 Otherwise, we look it up using the VTT we were given. */
4929 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
4930 vtt = decay_conversion (vtt);
4931 vtt = build (COND_EXPR, TREE_TYPE (vtt),
4932 build (EQ_EXPR, boolean_type_node,
4933 current_in_charge_parm, integer_zero_node),
4936 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
4937 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
4938 BINFO_SUBVTT_INDEX (binfo));
4940 args = tree_cons (NULL_TREE, sub_vtt, args);
4943 return build_new_method_call (instance, fns, args, binfo, flags);
4946 /* Return the NAME, as a C string. The NAME indicates a function that
4947 is a member of TYPE. *FREE_P is set to true if the caller must
4948 free the memory returned.
4950 Rather than go through all of this, we should simply set the names
4951 of constructors and destructors appropriately, and dispense with
4952 ctor_identifier, dtor_identifier, etc. */
4955 name_as_c_string (tree name, tree type, bool *free_p)
4959 /* Assume that we will not allocate memory. */
4961 /* Constructors and destructors are special. */
4962 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4965 = (char *) IDENTIFIER_POINTER (constructor_name (type));
4966 /* For a destructor, add the '~'. */
4967 if (name == complete_dtor_identifier
4968 || name == base_dtor_identifier
4969 || name == deleting_dtor_identifier)
4971 pretty_name = concat ("~", pretty_name, NULL);
4972 /* Remember that we need to free the memory allocated. */
4977 pretty_name = (char *) IDENTIFIER_POINTER (name);
4982 /* Build a call to "INSTANCE.FN (ARGS)". */
4985 build_new_method_call (tree instance, tree fns, tree args,
4986 tree conversion_path, int flags)
4988 struct z_candidate *candidates = 0, *cand;
4989 tree explicit_targs = NULL_TREE;
4990 tree basetype = NULL_TREE;
4993 tree mem_args = NULL_TREE, instance_ptr;
4999 int template_only = 0;
5002 my_friendly_assert (instance != NULL_TREE, 20020729);
5004 if (error_operand_p (instance)
5005 || error_operand_p (fns)
5006 || args == error_mark_node)
5007 return error_mark_node;
5009 /* Process the argument list. */
5011 args = resolve_args (args);
5012 if (args == error_mark_node)
5013 return error_mark_node;
5015 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5016 instance = convert_from_reference (instance);
5017 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5018 instance_ptr = build_this (instance);
5020 if (!BASELINK_P (fns))
5022 call = build_field_call (instance_ptr, fns, args);
5025 error ("call to non-function `%D'", fns);
5026 return error_mark_node;
5029 if (!conversion_path)
5030 conversion_path = BASELINK_BINFO (fns);
5031 access_binfo = BASELINK_ACCESS_BINFO (fns);
5032 optype = BASELINK_OPTYPE (fns);
5033 fns = BASELINK_FUNCTIONS (fns);
5035 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5037 explicit_targs = TREE_OPERAND (fns, 1);
5038 fns = TREE_OPERAND (fns, 0);
5042 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
5043 || TREE_CODE (fns) == TEMPLATE_DECL
5044 || TREE_CODE (fns) == OVERLOAD,
5047 /* XXX this should be handled before we get here. */
5048 if (! IS_AGGR_TYPE (basetype))
5050 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5051 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5052 fns, instance, basetype);
5054 return error_mark_node;
5057 fn = get_first_fn (fns);
5058 name = DECL_NAME (fn);
5060 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5062 /* Callers should explicitly indicate whether they want to construct
5063 the complete object or just the part without virtual bases. */
5064 my_friendly_assert (name != ctor_identifier, 20000408);
5065 /* Similarly for destructors. */
5066 my_friendly_assert (name != dtor_identifier, 20000408);
5069 /* It's OK to call destructors on cv-qualified objects. Therefore,
5070 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5071 if (DECL_DESTRUCTOR_P (fn))
5073 tree type = build_pointer_type (basetype);
5074 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5075 instance_ptr = build_nop (type, instance_ptr);
5078 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5079 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5081 for (fn = fns; fn; fn = OVL_NEXT (fn))
5083 tree t = OVL_CURRENT (fn);
5086 /* We can end up here for copy-init of same or base class. */
5087 if ((flags & LOOKUP_ONLYCONVERTING)
5088 && DECL_NONCONVERTING_P (t))
5091 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5092 this_arglist = mem_args;
5094 this_arglist = args;
5096 if (TREE_CODE (t) == TEMPLATE_DECL)
5097 /* A member template. */
5098 add_template_candidate (&candidates, t,
5101 this_arglist, optype,
5106 else if (! template_only)
5107 add_function_candidate (&candidates, t,
5115 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5118 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5119 if (flags & LOOKUP_SPECULATIVELY)
5121 if (!COMPLETE_TYPE_P (basetype))
5122 cxx_incomplete_type_error (instance_ptr, basetype);
5128 pretty_name = name_as_c_string (name, basetype, &free_p);
5129 error ("no matching function for call to `%T::%s(%A)%#V'",
5130 basetype, pretty_name, user_args,
5131 TREE_TYPE (TREE_TYPE (instance_ptr)));
5135 print_z_candidates (candidates);
5136 return error_mark_node;
5139 cand = tourney (candidates);
5145 pretty_name = name_as_c_string (name, basetype, &free_p);
5146 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
5148 print_z_candidates (candidates);
5151 return error_mark_node;
5154 if (DECL_PURE_VIRTUAL_P (cand->fn)
5155 && instance == current_class_ref
5156 && (DECL_CONSTRUCTOR_P (current_function_decl)
5157 || DECL_DESTRUCTOR_P (current_function_decl))
5158 && ! (flags & LOOKUP_NONVIRTUAL)
5159 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
5160 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5161 "abstract virtual `%#D' called from constructor"
5162 : "abstract virtual `%#D' called from destructor"),
5164 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5165 && is_dummy_object (instance_ptr))
5167 error ("cannot call member function `%D' without object", cand->fn);
5168 return error_mark_node;
5171 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5172 && resolves_to_fixed_type_p (instance, 0))
5173 flags |= LOOKUP_NONVIRTUAL;
5175 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE)
5176 call = build_over_call (cand, flags);
5179 call = build_over_call (cand, flags);
5180 /* In an expression of the form `a->f()' where `f' turns out to
5181 be a static member function, `a' is none-the-less evaluated. */
5182 if (!is_dummy_object (instance_ptr) && TREE_SIDE_EFFECTS (instance))
5183 call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call);
5189 /* Returns true iff standard conversion sequence ICS1 is a proper
5190 subsequence of ICS2. */
5193 is_subseq (tree ics1, tree ics2)
5195 /* We can assume that a conversion of the same code
5196 between the same types indicates a subsequence since we only get
5197 here if the types we are converting from are the same. */
5199 while (TREE_CODE (ics1) == RVALUE_CONV
5200 || TREE_CODE (ics1) == LVALUE_CONV)
5201 ics1 = TREE_OPERAND (ics1, 0);
5205 while (TREE_CODE (ics2) == RVALUE_CONV
5206 || TREE_CODE (ics2) == LVALUE_CONV)
5207 ics2 = TREE_OPERAND (ics2, 0);
5209 if (TREE_CODE (ics2) == USER_CONV
5210 || TREE_CODE (ics2) == AMBIG_CONV
5211 || TREE_CODE (ics2) == IDENTITY_CONV)
5212 /* At this point, ICS1 cannot be a proper subsequence of
5213 ICS2. We can get a USER_CONV when we are comparing the
5214 second standard conversion sequence of two user conversion
5218 ics2 = TREE_OPERAND (ics2, 0);
5220 if (TREE_CODE (ics2) == TREE_CODE (ics1)
5221 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
5222 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
5223 TREE_TYPE (TREE_OPERAND (ics1, 0))))
5228 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5229 be any _TYPE nodes. */
5232 is_properly_derived_from (tree derived, tree base)
5234 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5235 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5238 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5239 considers every class derived from itself. */
5240 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5241 && DERIVED_FROM_P (base, derived));
5244 /* We build the ICS for an implicit object parameter as a pointer
5245 conversion sequence. However, such a sequence should be compared
5246 as if it were a reference conversion sequence. If ICS is the
5247 implicit conversion sequence for an implicit object parameter,
5248 modify it accordingly. */
5251 maybe_handle_implicit_object (tree *ics)
5253 if (ICS_THIS_FLAG (*ics))
5255 /* [over.match.funcs]
5257 For non-static member functions, the type of the
5258 implicit object parameter is "reference to cv X"
5259 where X is the class of which the function is a
5260 member and cv is the cv-qualification on the member
5261 function declaration. */
5263 tree reference_type;
5265 /* The `this' parameter is a pointer to a class type. Make the
5266 implicit conversion talk about a reference to that same class
5268 reference_type = TREE_TYPE (TREE_TYPE (*ics));
5269 reference_type = build_reference_type (reference_type);
5271 if (TREE_CODE (t) == QUAL_CONV)
5272 t = TREE_OPERAND (t, 0);
5273 if (TREE_CODE (t) == PTR_CONV)
5274 t = TREE_OPERAND (t, 0);
5275 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
5276 t = direct_reference_binding (reference_type, t);
5281 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5282 and return the type to which the reference refers. Otherwise,
5283 leave *ICS unchanged and return NULL_TREE. */
5286 maybe_handle_ref_bind (tree *ics)
5288 if (TREE_CODE (*ics) == REF_BIND)
5290 tree old_ics = *ics;
5291 tree type = TREE_TYPE (TREE_TYPE (old_ics));
5292 *ics = TREE_OPERAND (old_ics, 0);
5293 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
5294 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
5301 /* Compare two implicit conversion sequences according to the rules set out in
5302 [over.ics.rank]. Return values:
5304 1: ics1 is better than ics2
5305 -1: ics2 is better than ics1
5306 0: ics1 and ics2 are indistinguishable */
5309 compare_ics (tree ics1, tree ics2)
5315 tree deref_from_type1 = NULL_TREE;
5316 tree deref_from_type2 = NULL_TREE;
5317 tree deref_to_type1 = NULL_TREE;
5318 tree deref_to_type2 = NULL_TREE;
5321 /* REF_BINDING is nonzero if the result of the conversion sequence
5322 is a reference type. In that case TARGET_TYPE is the
5323 type referred to by the reference. */
5327 /* Handle implicit object parameters. */
5328 maybe_handle_implicit_object (&ics1);
5329 maybe_handle_implicit_object (&ics2);
5331 /* Handle reference parameters. */
5332 target_type1 = maybe_handle_ref_bind (&ics1);
5333 target_type2 = maybe_handle_ref_bind (&ics2);
5337 When comparing the basic forms of implicit conversion sequences (as
5338 defined in _over.best.ics_)
5340 --a standard conversion sequence (_over.ics.scs_) is a better
5341 conversion sequence than a user-defined conversion sequence
5342 or an ellipsis conversion sequence, and
5344 --a user-defined conversion sequence (_over.ics.user_) is a
5345 better conversion sequence than an ellipsis conversion sequence
5346 (_over.ics.ellipsis_). */
5347 rank1 = ICS_RANK (ics1);
5348 rank2 = ICS_RANK (ics2);
5352 else if (rank1 < rank2)
5355 if (rank1 == BAD_RANK)
5357 /* XXX Isn't this an extension? */
5358 /* Both ICS are bad. We try to make a decision based on what
5359 would have happenned if they'd been good. */
5360 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5361 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5363 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5364 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5367 /* We couldn't make up our minds; try to figure it out below. */
5370 if (ICS_ELLIPSIS_FLAG (ics1))
5371 /* Both conversions are ellipsis conversions. */
5374 /* User-defined conversion sequence U1 is a better conversion sequence
5375 than another user-defined conversion sequence U2 if they contain the
5376 same user-defined conversion operator or constructor and if the sec-
5377 ond standard conversion sequence of U1 is better than the second
5378 standard conversion sequence of U2. */
5380 if (ICS_USER_FLAG (ics1))
5384 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5385 if (TREE_CODE (t1) == AMBIG_CONV)
5387 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5388 if (TREE_CODE (t2) == AMBIG_CONV)
5391 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5394 /* We can just fall through here, after setting up
5395 FROM_TYPE1 and FROM_TYPE2. */
5396 from_type1 = TREE_TYPE (t1);
5397 from_type2 = TREE_TYPE (t2);
5401 /* We're dealing with two standard conversion sequences.
5405 Standard conversion sequence S1 is a better conversion
5406 sequence than standard conversion sequence S2 if
5408 --S1 is a proper subsequence of S2 (comparing the conversion
5409 sequences in the canonical form defined by _over.ics.scs_,
5410 excluding any Lvalue Transformation; the identity
5411 conversion sequence is considered to be a subsequence of
5412 any non-identity conversion sequence */
5415 while (TREE_CODE (from_type1) != IDENTITY_CONV)
5416 from_type1 = TREE_OPERAND (from_type1, 0);
5417 from_type1 = TREE_TYPE (from_type1);
5420 while (TREE_CODE (from_type2) != IDENTITY_CONV)
5421 from_type2 = TREE_OPERAND (from_type2, 0);
5422 from_type2 = TREE_TYPE (from_type2);
5425 if (same_type_p (from_type1, from_type2))
5427 if (is_subseq (ics1, ics2))
5429 if (is_subseq (ics2, ics1))
5432 /* Otherwise, one sequence cannot be a subsequence of the other; they
5433 don't start with the same type. This can happen when comparing the
5434 second standard conversion sequence in two user-defined conversion
5441 --the rank of S1 is better than the rank of S2 (by the rules
5444 Standard conversion sequences are ordered by their ranks: an Exact
5445 Match is a better conversion than a Promotion, which is a better
5446 conversion than a Conversion.
5448 Two conversion sequences with the same rank are indistinguishable
5449 unless one of the following rules applies:
5451 --A conversion that is not a conversion of a pointer, or pointer
5452 to member, to bool is better than another conversion that is such
5455 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5456 so that we do not have to check it explicitly. */
5457 if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5459 else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1))
5462 to_type1 = TREE_TYPE (ics1);
5463 to_type2 = TREE_TYPE (ics2);
5465 if (TYPE_PTR_P (from_type1)
5466 && TYPE_PTR_P (from_type2)
5467 && TYPE_PTR_P (to_type1)
5468 && TYPE_PTR_P (to_type2))
5470 deref_from_type1 = TREE_TYPE (from_type1);
5471 deref_from_type2 = TREE_TYPE (from_type2);
5472 deref_to_type1 = TREE_TYPE (to_type1);
5473 deref_to_type2 = TREE_TYPE (to_type2);
5475 /* The rules for pointers to members A::* are just like the rules
5476 for pointers A*, except opposite: if B is derived from A then
5477 A::* converts to B::*, not vice versa. For that reason, we
5478 switch the from_ and to_ variables here. */
5479 else if (TYPE_PTRMEM_P (from_type1)
5480 && TYPE_PTRMEM_P (from_type2)
5481 && TYPE_PTRMEM_P (to_type1)
5482 && TYPE_PTRMEM_P (to_type2))
5484 deref_to_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type1));
5485 deref_to_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type2));
5486 deref_from_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type1));
5487 deref_from_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type2));
5489 else if (TYPE_PTRMEMFUNC_P (from_type1)
5490 && TYPE_PTRMEMFUNC_P (from_type2)
5491 && TYPE_PTRMEMFUNC_P (to_type1)
5492 && TYPE_PTRMEMFUNC_P (to_type2))
5494 deref_to_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type1);
5495 deref_to_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type2);
5496 deref_from_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type1);
5497 deref_from_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type2);
5500 if (deref_from_type1 != NULL_TREE
5501 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5502 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5504 /* This was one of the pointer or pointer-like conversions.
5508 --If class B is derived directly or indirectly from class A,
5509 conversion of B* to A* is better than conversion of B* to
5510 void*, and conversion of A* to void* is better than
5511 conversion of B* to void*. */
5512 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5513 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5515 if (is_properly_derived_from (deref_from_type1,
5518 else if (is_properly_derived_from (deref_from_type2,
5522 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5523 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5525 if (same_type_p (deref_from_type1, deref_from_type2))
5527 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5529 if (is_properly_derived_from (deref_from_type1,
5533 /* We know that DEREF_TO_TYPE1 is `void' here. */
5534 else if (is_properly_derived_from (deref_from_type1,
5539 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5540 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5544 --If class B is derived directly or indirectly from class A
5545 and class C is derived directly or indirectly from B,
5547 --conversion of C* to B* is better than conversion of C* to
5550 --conversion of B* to A* is better than conversion of C* to
5552 if (same_type_p (deref_from_type1, deref_from_type2))
5554 if (is_properly_derived_from (deref_to_type1,
5557 else if (is_properly_derived_from (deref_to_type2,
5561 else if (same_type_p (deref_to_type1, deref_to_type2))
5563 if (is_properly_derived_from (deref_from_type2,
5566 else if (is_properly_derived_from (deref_from_type1,
5572 else if (CLASS_TYPE_P (non_reference (from_type1))
5573 && same_type_p (from_type1, from_type2))
5575 tree from = non_reference (from_type1);
5579 --binding of an expression of type C to a reference of type
5580 B& is better than binding an expression of type C to a
5581 reference of type A&
5583 --conversion of C to B is better than conversion of C to A, */
5584 if (is_properly_derived_from (from, to_type1)
5585 && is_properly_derived_from (from, to_type2))
5587 if (is_properly_derived_from (to_type1, to_type2))
5589 else if (is_properly_derived_from (to_type2, to_type1))
5593 else if (CLASS_TYPE_P (non_reference (to_type1))
5594 && same_type_p (to_type1, to_type2))
5596 tree to = non_reference (to_type1);
5600 --binding of an expression of type B to a reference of type
5601 A& is better than binding an expression of type C to a
5602 reference of type A&,
5604 --onversion of B to A is better than conversion of C to A */
5605 if (is_properly_derived_from (from_type1, to)
5606 && is_properly_derived_from (from_type2, to))
5608 if (is_properly_derived_from (from_type2, from_type1))
5610 else if (is_properly_derived_from (from_type1, from_type2))
5617 --S1 and S2 differ only in their qualification conversion and yield
5618 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5619 qualification signature of type T1 is a proper subset of the cv-
5620 qualification signature of type T2 */
5621 if (TREE_CODE (ics1) == QUAL_CONV
5622 && TREE_CODE (ics2) == QUAL_CONV
5623 && same_type_p (from_type1, from_type2))
5624 return comp_cv_qual_signature (to_type1, to_type2);
5628 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5629 types to which the references refer are the same type except for
5630 top-level cv-qualifiers, and the type to which the reference
5631 initialized by S2 refers is more cv-qualified than the type to
5632 which the reference initialized by S1 refers */
5634 if (target_type1 && target_type2
5635 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5636 return comp_cv_qualification (target_type2, target_type1);
5638 /* Neither conversion sequence is better than the other. */
5642 /* The source type for this standard conversion sequence. */
5645 source_type (tree t)
5647 for (;; t = TREE_OPERAND (t, 0))
5649 if (TREE_CODE (t) == USER_CONV
5650 || TREE_CODE (t) == AMBIG_CONV
5651 || TREE_CODE (t) == IDENTITY_CONV)
5652 return TREE_TYPE (t);
5657 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5658 a pointer to LOSER and re-running joust to produce the warning if WINNER
5659 is actually used. */
5662 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5664 winner->warnings = tree_cons (NULL_TREE,
5665 build_zc_wrapper (loser),
5669 /* Compare two candidates for overloading as described in
5670 [over.match.best]. Return values:
5672 1: cand1 is better than cand2
5673 -1: cand2 is better than cand1
5674 0: cand1 and cand2 are indistinguishable */
5677 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5680 int i, off1 = 0, off2 = 0, len;
5682 /* Candidates that involve bad conversions are always worse than those
5684 if (cand1->viable > cand2->viable)
5686 if (cand1->viable < cand2->viable)
5689 /* If we have two pseudo-candidates for conversions to the same type,
5690 or two candidates for the same function, arbitrarily pick one. */
5691 if (cand1->fn == cand2->fn
5692 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5695 /* a viable function F1
5696 is defined to be a better function than another viable function F2 if
5697 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5698 ICSi(F2), and then */
5700 /* for some argument j, ICSj(F1) is a better conversion sequence than
5703 /* For comparing static and non-static member functions, we ignore
5704 the implicit object parameter of the non-static function. The
5705 standard says to pretend that the static function has an object
5706 parm, but that won't work with operator overloading. */
5707 len = TREE_VEC_LENGTH (cand1->convs);
5708 if (len != TREE_VEC_LENGTH (cand2->convs))
5710 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5711 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5713 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5714 && DECL_STATIC_FUNCTION_P (cand2->fn))
5723 for (i = 0; i < len; ++i)
5725 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5726 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5727 int comp = compare_ics (t1, t2);
5732 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5733 && TREE_CODE (t1) == STD_CONV
5734 && TREE_CODE (t2) == STD_CONV
5735 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5736 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5737 && (TYPE_PRECISION (TREE_TYPE (t1))
5738 == TYPE_PRECISION (TREE_TYPE (t2)))
5739 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5740 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5743 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5745 struct z_candidate *w, *l;
5747 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5748 w = cand1, l = cand2;
5750 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5751 w = cand2, l = cand1;
5755 warning ("passing `%T' chooses `%T' over `%T'",
5756 type, type1, type2);
5757 warning (" in call to `%D'", w->fn);
5763 if (winner && comp != winner)
5772 /* warn about confusing overload resolution for user-defined conversions,
5773 either between a constructor and a conversion op, or between two
5775 if (winner && warn_conversion && cand1->second_conv
5776 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5777 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5779 struct z_candidate *w, *l;
5780 bool give_warning = false;
5783 w = cand1, l = cand2;
5785 w = cand2, l = cand1;
5787 /* We don't want to complain about `X::operator T1 ()'
5788 beating `X::operator T2 () const', when T2 is a no less
5789 cv-qualified version of T1. */
5790 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5791 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5793 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5794 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5796 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5801 if (!comp_ptr_ttypes (t, f))
5802 give_warning = true;
5805 give_warning = true;
5811 tree source = source_type (TREE_VEC_ELT (w->convs, 0));
5812 if (! DECL_CONSTRUCTOR_P (w->fn))
5813 source = TREE_TYPE (source);
5814 warning ("choosing `%D' over `%D'", w->fn, l->fn);
5815 warning (" for conversion from `%T' to `%T'",
5816 source, TREE_TYPE (w->second_conv));
5817 warning (" because conversion sequence for the argument is better");
5827 F1 is a non-template function and F2 is a template function
5830 if (! cand1->template && cand2->template)
5832 else if (cand1->template && ! cand2->template)
5836 F1 and F2 are template functions and the function template for F1 is
5837 more specialized than the template for F2 according to the partial
5840 if (cand1->template && cand2->template)
5842 winner = more_specialized
5843 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
5845 /* Tell the deduction code how many real function arguments
5846 we saw, not counting the implicit 'this' argument. But,
5847 add_function_candidate() suppresses the "this" argument
5850 [temp.func.order]: The presence of unused ellipsis and default
5851 arguments has no effect on the partial ordering of function
5853 TREE_VEC_LENGTH (cand1->convs)
5854 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
5855 - DECL_CONSTRUCTOR_P (cand1->fn)));
5861 the context is an initialization by user-defined conversion (see
5862 _dcl.init_ and _over.match.user_) and the standard conversion
5863 sequence from the return type of F1 to the destination type (i.e.,
5864 the type of the entity being initialized) is a better conversion
5865 sequence than the standard conversion sequence from the return type
5866 of F2 to the destination type. */
5868 if (cand1->second_conv)
5870 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5875 /* Check whether we can discard a builtin candidate, either because we
5876 have two identical ones or matching builtin and non-builtin candidates.
5878 (Pedantically in the latter case the builtin which matched the user
5879 function should not be added to the overload set, but we spot it here.
5882 ... the builtin candidates include ...
5883 - do not have the same parameter type list as any non-template
5884 non-member candidate. */
5886 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
5887 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
5889 for (i = 0; i < len; ++i)
5890 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5891 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i))))
5893 if (i == TREE_VEC_LENGTH (cand1->convs))
5895 if (cand1->fn == cand2->fn)
5896 /* Two built-in candidates; arbitrarily pick one. */
5898 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5899 /* cand1 is built-in; prefer cand2. */
5902 /* cand2 is built-in; prefer cand1. */
5907 /* If the two functions are the same (this can happen with declarations
5908 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5909 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
5910 && equal_functions (cand1->fn, cand2->fn))
5915 /* Extension: If the worst conversion for one candidate is worse than the
5916 worst conversion for the other, take the first. */
5919 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
5920 struct z_candidate *w = 0, *l = 0;
5922 for (i = 0; i < len; ++i)
5924 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5925 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5926 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5927 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5930 winner = 1, w = cand1, l = cand2;
5932 winner = -1, w = cand2, l = cand1;
5938 ISO C++ says that these are ambiguous, even \
5939 though the worst conversion for the first is better than \
5940 the worst conversion for the second:");
5941 print_z_candidate (_("candidate 1:"), w);
5942 print_z_candidate (_("candidate 2:"), l);
5950 my_friendly_assert (!winner, 20010121);
5954 /* Given a list of candidates for overloading, find the best one, if any.
5955 This algorithm has a worst case of O(2n) (winner is last), and a best
5956 case of O(n/2) (totally ambiguous); much better than a sorting
5959 static struct z_candidate *
5960 tourney (struct z_candidate *candidates)
5962 struct z_candidate *champ = candidates, *challenger;
5964 int champ_compared_to_predecessor = 0;
5966 /* Walk through the list once, comparing each current champ to the next
5967 candidate, knocking out a candidate or two with each comparison. */
5969 for (challenger = champ->next; challenger; )
5971 fate = joust (champ, challenger, 0);
5973 challenger = challenger->next;
5978 champ = challenger->next;
5981 champ_compared_to_predecessor = 0;
5986 champ_compared_to_predecessor = 1;
5989 challenger = champ->next;
5993 /* Make sure the champ is better than all the candidates it hasn't yet
5994 been compared to. */
5996 for (challenger = candidates;
5998 && !(champ_compared_to_predecessor && challenger->next == champ);
5999 challenger = challenger->next)
6001 fate = joust (champ, challenger, 0);
6009 /* Returns nonzero if things of type FROM can be converted to TO. */
6012 can_convert (tree to, tree from)
6014 return can_convert_arg (to, from, NULL_TREE);
6017 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6020 can_convert_arg (tree to, tree from, tree arg)
6022 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6023 return (t && ! ICS_BAD_FLAG (t));
6026 /* Like can_convert_arg, but allows dubious conversions as well. */
6029 can_convert_arg_bad (tree to, tree from, tree arg)
6031 return implicit_conversion (to, from, arg, LOOKUP_NORMAL) != 0;
6034 /* Convert EXPR to TYPE. Return the converted expression.
6036 Note that we allow bad conversions here because by the time we get to
6037 this point we are committed to doing the conversion. If we end up
6038 doing a bad conversion, convert_like will complain. */
6041 perform_implicit_conversion (tree type, tree expr)
6045 if (error_operand_p (expr))
6046 return error_mark_node;
6047 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6051 error ("could not convert `%E' to `%T'", expr, type);
6052 return error_mark_node;
6055 return convert_like (conv, expr);
6058 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6059 permitted. If the conversion is valid, the converted expression is
6060 returned. Otherwise, NULL_TREE is returned. */
6063 perform_direct_initialization_if_possible (tree type, tree expr)
6067 if (type == error_mark_node || error_operand_p (expr))
6068 return error_mark_node;
6069 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6071 if (!conv || ICS_BAD_FLAG (conv))
6073 return convert_like_real (conv, expr, NULL_TREE, 0, 0,
6074 /*issue_conversion_warnings=*/false);
6077 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6078 is being bound to a temporary. Create and return a new VAR_DECL
6079 with the indicated TYPE; this variable will store the value to
6080 which the reference is bound. */
6083 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6087 /* Create the variable. */
6088 var = build_decl (VAR_DECL, NULL_TREE, type);
6089 DECL_ARTIFICIAL (var) = 1;
6090 TREE_USED (var) = 1;
6092 /* Register the variable. */
6093 if (TREE_STATIC (decl))
6095 /* Namespace-scope or local static; give it a mangled name. */
6098 TREE_STATIC (var) = 1;
6099 name = mangle_ref_init_variable (decl);
6100 DECL_NAME (var) = name;
6101 SET_DECL_ASSEMBLER_NAME (var, name);
6102 var = pushdecl_top_level (var);
6106 /* Create a new cleanup level if necessary. */
6107 maybe_push_cleanup_level (type);
6108 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6109 DECL_CONTEXT (var) = current_function_decl;
6115 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6116 initializing a variable of that TYPE. If DECL is non-NULL, it is
6117 the VAR_DECL being initialized with the EXPR. (In that case, the
6118 type of DECL will be TYPE.)
6120 Return the converted expression. */
6123 initialize_reference (tree type, tree expr, tree decl)
6127 if (type == error_mark_node || error_operand_p (expr))
6128 return error_mark_node;
6130 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6131 if (!conv || ICS_BAD_FLAG (conv))
6133 error ("could not convert `%E' to `%T'", expr, type);
6134 return error_mark_node;
6137 /* If DECL is non-NULL, then this special rule applies:
6141 The temporary to which the reference is bound or the temporary
6142 that is the complete object to which the reference is bound
6143 persists for the lifetime of the reference.
6145 The temporaries created during the evaluation of the expression
6146 initializing the reference, except the temporary to which the
6147 reference is bound, are destroyed at the end of the
6148 full-expression in which they are created.
6150 In that case, we store the converted expression into a new
6151 VAR_DECL in a new scope.
6153 However, we want to be careful not to create temporaries when
6154 they are not required. For example, given:
6157 struct D : public B {};
6161 there is no need to copy the return value from "f"; we can just
6162 extend its lifetime. Similarly, given:
6165 struct T { operator S(); };
6169 we can extend the lifetime of the return value of the conversion
6171 my_friendly_assert (TREE_CODE (conv) == REF_BIND, 20030302);
6175 tree base_conv_type;
6177 /* Skip over the REF_BIND. */
6178 conv = TREE_OPERAND (conv, 0);
6179 /* If the next conversion is a BASE_CONV, skip that too -- but
6180 remember that the conversion was required. */
6181 if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv))
6183 base_conv_type = TREE_TYPE (conv);
6184 conv = TREE_OPERAND (conv, 0);
6187 base_conv_type = NULL_TREE;
6188 /* Perform the remainder of the conversion. */
6189 expr = convert_like (conv, expr);
6190 if (!real_non_cast_lvalue_p (expr))
6195 /* Create the temporary variable. */
6196 type = TREE_TYPE (expr);
6197 var = make_temporary_var_for_ref_to_temp (decl, type);
6198 layout_decl (var, 0);
6199 if (at_function_scope_p ())
6203 add_decl_stmt (var);
6204 cleanup = cxx_maybe_build_cleanup (var);
6206 finish_decl_cleanup (var, cleanup);
6210 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6211 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6212 static_aggregates = tree_cons (NULL_TREE, var,
6215 init = build (INIT_EXPR, type, var, expr);
6216 /* Use its address to initialize the reference variable. */
6217 expr = build_address (var);
6218 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6221 /* Take the address of EXPR. */
6222 expr = build_unary_op (ADDR_EXPR, expr, 0);
6223 /* If a BASE_CONV was required, perform it now. */
6225 expr = (perform_implicit_conversion
6226 (build_pointer_type (base_conv_type), expr));
6227 return build_nop (type, expr);
6230 /* Perform the conversion. */
6231 return convert_like (conv, expr);
6234 #include "gt-cp-call.h"