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 = default_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 exprssion
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 exprsesion
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 determins 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. Array/function to pointer decay must have already happened.
4343 Return the converted value. */
4346 convert_arg_to_ellipsis (tree arg)
4348 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4349 && (TYPE_PRECISION (TREE_TYPE (arg))
4350 < TYPE_PRECISION (double_type_node)))
4351 /* Convert `float' to `double'. */
4352 arg = cp_convert (double_type_node, arg);
4354 /* Convert `short' and `char' to full-size `int'. */
4355 arg = default_conversion (arg);
4357 arg = require_complete_type (arg);
4359 if (arg != error_mark_node && ! pod_type_p (TREE_TYPE (arg)))
4361 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4362 here and do a bitwise copy, but now cp_expr_size will abort if we
4364 warning ("cannot pass objects of non-POD type `%#T' through `...'; \
4365 call will abort at runtime",
4367 arg = call_builtin_trap ();
4373 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4376 build_x_va_arg (tree expr, tree type)
4378 if (processing_template_decl)
4379 return build_min (VA_ARG_EXPR, type, expr);
4381 type = complete_type_or_else (type, NULL_TREE);
4383 if (expr == error_mark_node || !type)
4384 return error_mark_node;
4386 if (! pod_type_p (type))
4388 /* Undefined behavior [expr.call] 5.2.2/7. */
4389 warning ("cannot receive objects of non-POD type `%#T' through `...'",
4393 return build_va_arg (expr, type);
4396 /* TYPE has been given to va_arg. Apply the default conversions which
4397 would have happened when passed via ellipsis. Return the promoted
4398 type, or the passed type if there is no change. */
4401 cxx_type_promotes_to (tree type)
4405 if (TREE_CODE (type) == ARRAY_TYPE)
4406 return build_pointer_type (TREE_TYPE (type));
4408 if (TREE_CODE (type) == FUNCTION_TYPE)
4409 return build_pointer_type (type);
4411 promote = type_promotes_to (type);
4412 if (same_type_p (type, promote))
4418 /* ARG is a default argument expression being passed to a parameter of
4419 the indicated TYPE, which is a parameter to FN. Do any required
4420 conversions. Return the converted value. */
4423 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4425 /* If the ARG is an unparsed default argument expression, the
4426 conversion cannot be performed. */
4427 if (TREE_CODE (arg) == DEFAULT_ARG)
4429 error ("the default argument for parameter %d of `%D' has "
4430 "not yet been parsed",
4432 return error_mark_node;
4435 if (fn && DECL_TEMPLATE_INFO (fn))
4436 arg = tsubst_default_argument (fn, type, arg);
4438 arg = break_out_target_exprs (arg);
4440 if (TREE_CODE (arg) == CONSTRUCTOR)
4442 arg = digest_init (type, arg, 0);
4443 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4444 "default argument", fn, parmnum);
4448 /* This could get clobbered by the following call. */
4449 if (TREE_HAS_CONSTRUCTOR (arg))
4450 arg = copy_node (arg);
4452 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4453 "default argument", fn, parmnum);
4454 arg = convert_for_arg_passing (type, arg);
4460 /* Returns the type which will really be used for passing an argument of
4464 type_passed_as (tree type)
4466 /* Pass classes with copy ctors by invisible reference. */
4467 if (TREE_ADDRESSABLE (type))
4468 type = build_reference_type (type);
4469 else if (PROMOTE_PROTOTYPES
4470 && INTEGRAL_TYPE_P (type)
4471 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4472 type = integer_type_node;
4477 /* Actually perform the appropriate conversion. */
4480 convert_for_arg_passing (tree type, tree val)
4482 if (val == error_mark_node)
4484 /* Pass classes with copy ctors by invisible reference. */
4485 else if (TREE_ADDRESSABLE (type))
4486 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4487 else if (PROMOTE_PROTOTYPES
4488 && INTEGRAL_TYPE_P (type)
4489 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4490 val = default_conversion (val);
4494 /* Subroutine of the various build_*_call functions. Overload resolution
4495 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4496 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4497 bitmask of various LOOKUP_* flags which apply to the call itself. */
4500 build_over_call (struct z_candidate *cand, int flags)
4503 tree args = cand->args;
4504 tree convs = cand->convs;
4505 tree converted_args = NULL_TREE;
4506 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4507 tree conv, arg, val;
4511 /* Give any warnings we noticed during overload resolution. */
4513 for (val = cand->warnings; val; val = TREE_CHAIN (val))
4514 joust (cand, WRAPPER_ZC (TREE_VALUE (val)), 1);
4516 if (DECL_FUNCTION_MEMBER_P (fn))
4517 perform_or_defer_access_check (cand->access_path, fn);
4519 if (args && TREE_CODE (args) != TREE_LIST)
4520 args = build_tree_list (NULL_TREE, args);
4523 /* The implicit parameters to a constructor are not considered by overload
4524 resolution, and must be of the proper type. */
4525 if (DECL_CONSTRUCTOR_P (fn))
4527 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4528 arg = TREE_CHAIN (arg);
4529 parm = TREE_CHAIN (parm);
4530 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4531 /* We should never try to call the abstract constructor. */
4533 if (DECL_HAS_VTT_PARM_P (fn))
4535 converted_args = tree_cons
4536 (NULL_TREE, TREE_VALUE (arg), converted_args);
4537 arg = TREE_CHAIN (arg);
4538 parm = TREE_CHAIN (parm);
4541 /* Bypass access control for 'this' parameter. */
4542 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4544 tree parmtype = TREE_VALUE (parm);
4545 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4549 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
4550 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4551 TREE_TYPE (argtype), fn);
4553 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4554 X is called for an object that is not of type X, or of a type
4555 derived from X, the behavior is undefined.
4557 So we can assume that anything passed as 'this' is non-null, and
4558 optimize accordingly. */
4559 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4560 /* Convert to the base in which the function was declared. */
4561 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4562 converted_arg = build_base_path (PLUS_EXPR,
4564 cand->conversion_path,
4566 /* If fn was found by a using declaration, the conversion path
4567 will be to the derived class, not the base declaring fn. We
4568 must convert from derived to base. */
4569 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4570 TREE_TYPE (parmtype), ba_ignore, NULL);
4572 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4575 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4576 parm = TREE_CHAIN (parm);
4577 arg = TREE_CHAIN (arg);
4583 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4585 tree type = TREE_VALUE (parm);
4587 conv = TREE_VEC_ELT (convs, i);
4588 val = convert_like_with_context
4589 (conv, TREE_VALUE (arg), fn, i - is_method);
4591 val = convert_for_arg_passing (type, val);
4592 converted_args = tree_cons (NULL_TREE, val, converted_args);
4595 /* Default arguments */
4596 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4598 = tree_cons (NULL_TREE,
4599 convert_default_arg (TREE_VALUE (parm),
4600 TREE_PURPOSE (parm),
4605 for (; arg; arg = TREE_CHAIN (arg))
4607 = tree_cons (NULL_TREE,
4608 convert_arg_to_ellipsis (TREE_VALUE (arg)),
4611 converted_args = nreverse (converted_args);
4614 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4617 /* Avoid actually calling copy constructors and copy assignment operators,
4620 if (! flag_elide_constructors)
4621 /* Do things the hard way. */;
4622 else if (TREE_VEC_LENGTH (convs) == 1
4623 && DECL_COPY_CONSTRUCTOR_P (fn))
4626 arg = skip_artificial_parms_for (fn, converted_args);
4627 arg = TREE_VALUE (arg);
4629 /* Pull out the real argument, disregarding const-correctness. */
4631 while (TREE_CODE (targ) == NOP_EXPR
4632 || TREE_CODE (targ) == NON_LVALUE_EXPR
4633 || TREE_CODE (targ) == CONVERT_EXPR)
4634 targ = TREE_OPERAND (targ, 0);
4635 if (TREE_CODE (targ) == ADDR_EXPR)
4637 targ = TREE_OPERAND (targ, 0);
4638 if (!same_type_ignoring_top_level_qualifiers_p
4639 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4648 arg = build_indirect_ref (arg, 0);
4650 /* [class.copy]: the copy constructor is implicitly defined even if
4651 the implementation elided its use. */
4652 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4655 /* If we're creating a temp and we already have one, don't create a
4656 new one. If we're not creating a temp but we get one, use
4657 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4658 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4659 temp or an INIT_EXPR otherwise. */
4660 if (integer_zerop (TREE_VALUE (args)))
4662 if (TREE_CODE (arg) == TARGET_EXPR)
4664 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4665 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4667 else if (TREE_CODE (arg) == TARGET_EXPR
4668 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4671 tree to = stabilize_reference
4672 (build_indirect_ref (TREE_VALUE (args), 0));
4674 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4675 address = build_unary_op (ADDR_EXPR, val, 0);
4676 /* Avoid a warning about this expression, if the address is
4678 TREE_USED (address) = 1;
4682 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4684 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4686 tree to = stabilize_reference
4687 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4689 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4690 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4696 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4698 tree t, *p = &TREE_VALUE (converted_args);
4699 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4702 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4704 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4705 if (TREE_SIDE_EFFECTS (*p))
4706 *p = save_expr (*p);
4707 t = build_pointer_type (TREE_TYPE (fn));
4708 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4709 fn = build_java_interface_fn_ref (fn, *p);
4711 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4714 else if (DECL_INLINE (fn))
4715 fn = inline_conversion (fn);
4717 fn = build_addr_func (fn);
4719 return build_cxx_call (fn, args, converted_args);
4722 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4723 gives the original form of the arguments. This function performs
4724 no overload resolution, conversion, or other high-level
4728 build_cxx_call(tree fn, tree args, tree converted_args)
4732 /* Recognize certain built-in functions so we can make tree-codes
4733 other than CALL_EXPR. We do this when it enables fold-const.c
4734 to do something useful. */
4735 if (TREE_CODE (fn) == ADDR_EXPR
4736 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4737 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4740 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4745 fn = build_call (fn, converted_args);
4747 /* If this call might throw an exception, note that fact. */
4748 fndecl = get_callee_fndecl (fn);
4749 if ((!fndecl || !TREE_NOTHROW (fndecl))
4750 && at_function_scope_p ()
4752 cp_function_chain->can_throw = 1;
4754 /* Some built-in function calls will be evaluated at compile-time in
4758 if (VOID_TYPE_P (TREE_TYPE (fn)))
4761 fn = require_complete_type (fn);
4762 if (fn == error_mark_node)
4763 return error_mark_node;
4765 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4766 fn = build_cplus_new (TREE_TYPE (fn), fn);
4767 return convert_from_reference (fn);
4770 static GTY(()) tree java_iface_lookup_fn;
4772 /* Make an expression which yields the address of the Java interface
4773 method FN. This is achieved by generating a call to libjava's
4774 _Jv_LookupInterfaceMethodIdx(). */
4777 build_java_interface_fn_ref (tree fn, tree instance)
4779 tree lookup_args, lookup_fn, method, idx;
4780 tree klass_ref, iface, iface_ref;
4783 if (!java_iface_lookup_fn)
4785 tree endlink = build_void_list_node ();
4786 tree t = tree_cons (NULL_TREE, ptr_type_node,
4787 tree_cons (NULL_TREE, ptr_type_node,
4788 tree_cons (NULL_TREE, java_int_type_node,
4790 java_iface_lookup_fn
4791 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4792 build_function_type (ptr_type_node, t),
4793 0, NOT_BUILT_IN, NULL, NULL_TREE);
4796 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4797 This is the first entry in the vtable. */
4798 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4801 /* Get the java.lang.Class pointer for the interface being called. */
4802 iface = DECL_CONTEXT (fn);
4803 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4804 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4805 || DECL_CONTEXT (iface_ref) != iface)
4807 error ("could not find class$ field in java interface type `%T'",
4809 return error_mark_node;
4811 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4813 /* Determine the itable index of FN. */
4815 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4817 if (!DECL_VIRTUAL_P (method))
4823 idx = build_int_2 (i, 0);
4825 lookup_args = tree_cons (NULL_TREE, klass_ref,
4826 tree_cons (NULL_TREE, iface_ref,
4827 build_tree_list (NULL_TREE, idx)));
4828 lookup_fn = build1 (ADDR_EXPR,
4829 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4830 java_iface_lookup_fn);
4831 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4834 /* Returns the value to use for the in-charge parameter when making a
4835 call to a function with the indicated NAME. */
4838 in_charge_arg_for_name (tree name)
4840 if (name == base_ctor_identifier
4841 || name == base_dtor_identifier)
4842 return integer_zero_node;
4843 else if (name == complete_ctor_identifier)
4844 return integer_one_node;
4845 else if (name == complete_dtor_identifier)
4846 return integer_two_node;
4847 else if (name == deleting_dtor_identifier)
4848 return integer_three_node;
4850 /* This function should only be called with one of the names listed
4856 /* Build a call to a constructor, destructor, or an assignment
4857 operator for INSTANCE, an expression with class type. NAME
4858 indicates the special member function to call; ARGS are the
4859 arguments. BINFO indicates the base of INSTANCE that is to be
4860 passed as the `this' parameter to the member function called.
4862 FLAGS are the LOOKUP_* flags to use when processing the call.
4864 If NAME indicates a complete object constructor, INSTANCE may be
4865 NULL_TREE. In this case, the caller will call build_cplus_new to
4866 store the newly constructed object into a VAR_DECL. */
4869 build_special_member_call (tree instance, tree name, tree args,
4870 tree binfo, int flags)
4873 /* The type of the subobject to be constructed or destroyed. */
4876 my_friendly_assert (name == complete_ctor_identifier
4877 || name == base_ctor_identifier
4878 || name == complete_dtor_identifier
4879 || name == base_dtor_identifier
4880 || name == deleting_dtor_identifier
4881 || name == ansi_assopname (NOP_EXPR),
4883 my_friendly_assert (binfo != NULL_TREE, 20020712);
4885 class_type = BINFO_TYPE (binfo);
4887 /* Handle the special case where INSTANCE is NULL_TREE. */
4888 if (name == complete_ctor_identifier && !instance)
4890 instance = build_int_2 (0, 0);
4891 TREE_TYPE (instance) = build_pointer_type (class_type);
4892 instance = build1 (INDIRECT_REF, class_type, instance);
4894 else if (name == complete_dtor_identifier
4895 || name == base_dtor_identifier
4896 || name == deleting_dtor_identifier)
4897 my_friendly_assert (args == NULL_TREE, 20020712);
4899 my_friendly_assert (instance != NULL_TREE, 20020712);
4901 /* Resolve the name. */
4902 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
4903 return error_mark_node;
4905 fns = lookup_fnfields (binfo, name, 1);
4907 /* When making a call to a constructor or destructor for a subobject
4908 that uses virtual base classes, pass down a pointer to a VTT for
4910 if ((name == base_ctor_identifier
4911 || name == base_dtor_identifier)
4912 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
4917 /* If the current function is a complete object constructor
4918 or destructor, then we fetch the VTT directly.
4919 Otherwise, we look it up using the VTT we were given. */
4920 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
4921 vtt = decay_conversion (vtt);
4922 vtt = build (COND_EXPR, TREE_TYPE (vtt),
4923 build (EQ_EXPR, boolean_type_node,
4924 current_in_charge_parm, integer_zero_node),
4927 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
4928 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
4929 BINFO_SUBVTT_INDEX (binfo));
4931 args = tree_cons (NULL_TREE, sub_vtt, args);
4934 return build_new_method_call (instance, fns, args, binfo, flags);
4937 /* Return the NAME, as a C string. The NAME indicates a function that
4938 is a member of TYPE. *FREE_P is set to true if the caller must
4939 free the memory returned.
4941 Rather than go through all of this, we should simply set the names
4942 of constructors and destructors appropriately, and dispense with
4943 ctor_identifier, dtor_identifier, etc. */
4946 name_as_c_string (tree name, tree type, bool *free_p)
4950 /* Assume that we will not allocate memory. */
4952 /* Constructors and destructors are special. */
4953 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
4956 = (char *) IDENTIFIER_POINTER (constructor_name (type));
4957 /* For a destructor, add the '~'. */
4958 if (name == complete_dtor_identifier
4959 || name == base_dtor_identifier
4960 || name == deleting_dtor_identifier)
4962 pretty_name = concat ("~", pretty_name, NULL);
4963 /* Remember that we need to free the memory allocated. */
4968 pretty_name = (char *) IDENTIFIER_POINTER (name);
4973 /* Build a call to "INSTANCE.FN (ARGS)". */
4976 build_new_method_call (tree instance, tree fns, tree args,
4977 tree conversion_path, int flags)
4979 struct z_candidate *candidates = 0, *cand;
4980 tree explicit_targs = NULL_TREE;
4981 tree basetype = NULL_TREE;
4984 tree mem_args = NULL_TREE, instance_ptr;
4990 int template_only = 0;
4993 my_friendly_assert (instance != NULL_TREE, 20020729);
4995 if (error_operand_p (instance)
4996 || error_operand_p (fns)
4997 || args == error_mark_node)
4998 return error_mark_node;
5000 /* Process the argument list. */
5002 args = resolve_args (args);
5003 if (args == error_mark_node)
5004 return error_mark_node;
5006 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5007 instance = convert_from_reference (instance);
5008 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5009 instance_ptr = build_this (instance);
5011 if (!BASELINK_P (fns))
5013 call = build_field_call (instance_ptr, fns, args);
5016 error ("call to non-function `%D'", fns);
5017 return error_mark_node;
5020 if (!conversion_path)
5021 conversion_path = BASELINK_BINFO (fns);
5022 access_binfo = BASELINK_ACCESS_BINFO (fns);
5023 optype = BASELINK_OPTYPE (fns);
5024 fns = BASELINK_FUNCTIONS (fns);
5026 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5028 explicit_targs = TREE_OPERAND (fns, 1);
5029 fns = TREE_OPERAND (fns, 0);
5033 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
5034 || TREE_CODE (fns) == TEMPLATE_DECL
5035 || TREE_CODE (fns) == OVERLOAD,
5038 /* XXX this should be handled before we get here. */
5039 if (! IS_AGGR_TYPE (basetype))
5041 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5042 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5043 fns, instance, basetype);
5045 return error_mark_node;
5048 fn = get_first_fn (fns);
5049 name = DECL_NAME (fn);
5051 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5053 /* Callers should explicitly indicate whether they want to construct
5054 the complete object or just the part without virtual bases. */
5055 my_friendly_assert (name != ctor_identifier, 20000408);
5056 /* Similarly for destructors. */
5057 my_friendly_assert (name != dtor_identifier, 20000408);
5060 /* It's OK to call destructors on cv-qualified objects. Therefore,
5061 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5062 if (DECL_DESTRUCTOR_P (fn))
5064 tree type = build_pointer_type (basetype);
5065 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5066 instance_ptr = build_nop (type, instance_ptr);
5069 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5070 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5072 for (fn = fns; fn; fn = OVL_NEXT (fn))
5074 tree t = OVL_CURRENT (fn);
5077 /* We can end up here for copy-init of same or base class. */
5078 if ((flags & LOOKUP_ONLYCONVERTING)
5079 && DECL_NONCONVERTING_P (t))
5082 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5083 this_arglist = mem_args;
5085 this_arglist = args;
5087 if (TREE_CODE (t) == TEMPLATE_DECL)
5088 /* A member template. */
5089 add_template_candidate (&candidates, t,
5092 this_arglist, optype,
5097 else if (! template_only)
5098 add_function_candidate (&candidates, t,
5106 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5109 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5110 if (flags & LOOKUP_SPECULATIVELY)
5112 if (!COMPLETE_TYPE_P (basetype))
5113 cxx_incomplete_type_error (instance_ptr, basetype);
5119 pretty_name = name_as_c_string (name, basetype, &free_p);
5120 error ("no matching function for call to `%T::%s(%A)%#V'",
5121 basetype, pretty_name, user_args,
5122 TREE_TYPE (TREE_TYPE (instance_ptr)));
5126 print_z_candidates (candidates);
5127 return error_mark_node;
5130 cand = tourney (candidates);
5136 pretty_name = name_as_c_string (name, basetype, &free_p);
5137 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
5139 print_z_candidates (candidates);
5142 return error_mark_node;
5145 if (DECL_PURE_VIRTUAL_P (cand->fn)
5146 && instance == current_class_ref
5147 && (DECL_CONSTRUCTOR_P (current_function_decl)
5148 || DECL_DESTRUCTOR_P (current_function_decl))
5149 && ! (flags & LOOKUP_NONVIRTUAL)
5150 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
5151 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5152 "abstract virtual `%#D' called from constructor"
5153 : "abstract virtual `%#D' called from destructor"),
5155 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5156 && is_dummy_object (instance_ptr))
5158 error ("cannot call member function `%D' without object", cand->fn);
5159 return error_mark_node;
5162 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5163 && resolves_to_fixed_type_p (instance, 0))
5164 flags |= LOOKUP_NONVIRTUAL;
5166 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE)
5167 call = build_over_call (cand, flags);
5170 call = build_over_call (cand, flags);
5171 /* In an expression of the form `a->f()' where `f' turns out to
5172 be a static member function, `a' is none-the-less evaluated. */
5173 if (!is_dummy_object (instance_ptr) && TREE_SIDE_EFFECTS (instance))
5174 call = build (COMPOUND_EXPR, TREE_TYPE (call), instance, call);
5180 /* Returns true iff standard conversion sequence ICS1 is a proper
5181 subsequence of ICS2. */
5184 is_subseq (tree ics1, tree ics2)
5186 /* We can assume that a conversion of the same code
5187 between the same types indicates a subsequence since we only get
5188 here if the types we are converting from are the same. */
5190 while (TREE_CODE (ics1) == RVALUE_CONV
5191 || TREE_CODE (ics1) == LVALUE_CONV)
5192 ics1 = TREE_OPERAND (ics1, 0);
5196 while (TREE_CODE (ics2) == RVALUE_CONV
5197 || TREE_CODE (ics2) == LVALUE_CONV)
5198 ics2 = TREE_OPERAND (ics2, 0);
5200 if (TREE_CODE (ics2) == USER_CONV
5201 || TREE_CODE (ics2) == AMBIG_CONV
5202 || TREE_CODE (ics2) == IDENTITY_CONV)
5203 /* At this point, ICS1 cannot be a proper subsequence of
5204 ICS2. We can get a USER_CONV when we are comparing the
5205 second standard conversion sequence of two user conversion
5209 ics2 = TREE_OPERAND (ics2, 0);
5211 if (TREE_CODE (ics2) == TREE_CODE (ics1)
5212 && same_type_p (TREE_TYPE (ics2), TREE_TYPE (ics1))
5213 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2, 0)),
5214 TREE_TYPE (TREE_OPERAND (ics1, 0))))
5219 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5220 be any _TYPE nodes. */
5223 is_properly_derived_from (tree derived, tree base)
5225 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5226 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5229 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5230 considers every class derived from itself. */
5231 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5232 && DERIVED_FROM_P (base, derived));
5235 /* We build the ICS for an implicit object parameter as a pointer
5236 conversion sequence. However, such a sequence should be compared
5237 as if it were a reference conversion sequence. If ICS is the
5238 implicit conversion sequence for an implicit object parameter,
5239 modify it accordingly. */
5242 maybe_handle_implicit_object (tree *ics)
5244 if (ICS_THIS_FLAG (*ics))
5246 /* [over.match.funcs]
5248 For non-static member functions, the type of the
5249 implicit object parameter is "reference to cv X"
5250 where X is the class of which the function is a
5251 member and cv is the cv-qualification on the member
5252 function declaration. */
5254 tree reference_type;
5256 /* The `this' parameter is a pointer to a class type. Make the
5257 implict conversion talk about a reference to that same class
5259 reference_type = TREE_TYPE (TREE_TYPE (*ics));
5260 reference_type = build_reference_type (reference_type);
5262 if (TREE_CODE (t) == QUAL_CONV)
5263 t = TREE_OPERAND (t, 0);
5264 if (TREE_CODE (t) == PTR_CONV)
5265 t = TREE_OPERAND (t, 0);
5266 t = build1 (IDENTITY_CONV, TREE_TYPE (TREE_TYPE (t)), NULL_TREE);
5267 t = direct_reference_binding (reference_type, t);
5272 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5273 and return the type to which the reference refers. Otherwise,
5274 leave *ICS unchanged and return NULL_TREE. */
5277 maybe_handle_ref_bind (tree *ics)
5279 if (TREE_CODE (*ics) == REF_BIND)
5281 tree old_ics = *ics;
5282 tree type = TREE_TYPE (TREE_TYPE (old_ics));
5283 *ics = TREE_OPERAND (old_ics, 0);
5284 ICS_USER_FLAG (*ics) = ICS_USER_FLAG (old_ics);
5285 ICS_BAD_FLAG (*ics) = ICS_BAD_FLAG (old_ics);
5292 /* Compare two implicit conversion sequences according to the rules set out in
5293 [over.ics.rank]. Return values:
5295 1: ics1 is better than ics2
5296 -1: ics2 is better than ics1
5297 0: ics1 and ics2 are indistinguishable */
5300 compare_ics (tree ics1, tree ics2)
5306 tree deref_from_type1 = NULL_TREE;
5307 tree deref_from_type2 = NULL_TREE;
5308 tree deref_to_type1 = NULL_TREE;
5309 tree deref_to_type2 = NULL_TREE;
5312 /* REF_BINDING is nonzero if the result of the conversion sequence
5313 is a reference type. In that case TARGET_TYPE is the
5314 type referred to by the reference. */
5318 /* Handle implicit object parameters. */
5319 maybe_handle_implicit_object (&ics1);
5320 maybe_handle_implicit_object (&ics2);
5322 /* Handle reference parameters. */
5323 target_type1 = maybe_handle_ref_bind (&ics1);
5324 target_type2 = maybe_handle_ref_bind (&ics2);
5328 When comparing the basic forms of implicit conversion sequences (as
5329 defined in _over.best.ics_)
5331 --a standard conversion sequence (_over.ics.scs_) is a better
5332 conversion sequence than a user-defined conversion sequence
5333 or an ellipsis conversion sequence, and
5335 --a user-defined conversion sequence (_over.ics.user_) is a
5336 better conversion sequence than an ellipsis conversion sequence
5337 (_over.ics.ellipsis_). */
5338 rank1 = ICS_RANK (ics1);
5339 rank2 = ICS_RANK (ics2);
5343 else if (rank1 < rank2)
5346 if (rank1 == BAD_RANK)
5348 /* XXX Isn't this an extension? */
5349 /* Both ICS are bad. We try to make a decision based on what
5350 would have happenned if they'd been good. */
5351 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5352 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5354 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5355 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5358 /* We couldn't make up our minds; try to figure it out below. */
5361 if (ICS_ELLIPSIS_FLAG (ics1))
5362 /* Both conversions are ellipsis conversions. */
5365 /* User-defined conversion sequence U1 is a better conversion sequence
5366 than another user-defined conversion sequence U2 if they contain the
5367 same user-defined conversion operator or constructor and if the sec-
5368 ond standard conversion sequence of U1 is better than the second
5369 standard conversion sequence of U2. */
5371 if (ICS_USER_FLAG (ics1))
5375 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5376 if (TREE_CODE (t1) == AMBIG_CONV)
5378 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5379 if (TREE_CODE (t2) == AMBIG_CONV)
5382 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5385 /* We can just fall through here, after setting up
5386 FROM_TYPE1 and FROM_TYPE2. */
5387 from_type1 = TREE_TYPE (t1);
5388 from_type2 = TREE_TYPE (t2);
5392 /* We're dealing with two standard conversion sequences.
5396 Standard conversion sequence S1 is a better conversion
5397 sequence than standard conversion sequence S2 if
5399 --S1 is a proper subsequence of S2 (comparing the conversion
5400 sequences in the canonical form defined by _over.ics.scs_,
5401 excluding any Lvalue Transformation; the identity
5402 conversion sequence is considered to be a subsequence of
5403 any non-identity conversion sequence */
5406 while (TREE_CODE (from_type1) != IDENTITY_CONV)
5407 from_type1 = TREE_OPERAND (from_type1, 0);
5408 from_type1 = TREE_TYPE (from_type1);
5411 while (TREE_CODE (from_type2) != IDENTITY_CONV)
5412 from_type2 = TREE_OPERAND (from_type2, 0);
5413 from_type2 = TREE_TYPE (from_type2);
5416 if (same_type_p (from_type1, from_type2))
5418 if (is_subseq (ics1, ics2))
5420 if (is_subseq (ics2, ics1))
5423 /* Otherwise, one sequence cannot be a subsequence of the other; they
5424 don't start with the same type. This can happen when comparing the
5425 second standard conversion sequence in two user-defined conversion
5432 --the rank of S1 is better than the rank of S2 (by the rules
5435 Standard conversion sequences are ordered by their ranks: an Exact
5436 Match is a better conversion than a Promotion, which is a better
5437 conversion than a Conversion.
5439 Two conversion sequences with the same rank are indistinguishable
5440 unless one of the following rules applies:
5442 --A conversion that is not a conversion of a pointer, or pointer
5443 to member, to bool is better than another conversion that is such
5446 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5447 so that we do not have to check it explicitly. */
5448 if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5450 else if (ICS_STD_RANK (ics2) < ICS_STD_RANK (ics1))
5453 to_type1 = TREE_TYPE (ics1);
5454 to_type2 = TREE_TYPE (ics2);
5456 if (TYPE_PTR_P (from_type1)
5457 && TYPE_PTR_P (from_type2)
5458 && TYPE_PTR_P (to_type1)
5459 && TYPE_PTR_P (to_type2))
5461 deref_from_type1 = TREE_TYPE (from_type1);
5462 deref_from_type2 = TREE_TYPE (from_type2);
5463 deref_to_type1 = TREE_TYPE (to_type1);
5464 deref_to_type2 = TREE_TYPE (to_type2);
5466 /* The rules for pointers to members A::* are just like the rules
5467 for pointers A*, except opposite: if B is derived from A then
5468 A::* converts to B::*, not vice versa. For that reason, we
5469 switch the from_ and to_ variables here. */
5470 else if (TYPE_PTRMEM_P (from_type1)
5471 && TYPE_PTRMEM_P (from_type2)
5472 && TYPE_PTRMEM_P (to_type1)
5473 && TYPE_PTRMEM_P (to_type2))
5475 deref_to_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type1));
5476 deref_to_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type2));
5477 deref_from_type1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type1));
5478 deref_from_type2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type2));
5480 else if (TYPE_PTRMEMFUNC_P (from_type1)
5481 && TYPE_PTRMEMFUNC_P (from_type2)
5482 && TYPE_PTRMEMFUNC_P (to_type1)
5483 && TYPE_PTRMEMFUNC_P (to_type2))
5485 deref_to_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type1);
5486 deref_to_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type2);
5487 deref_from_type1 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type1);
5488 deref_from_type2 = TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type2);
5491 if (deref_from_type1 != NULL_TREE
5492 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5493 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5495 /* This was one of the pointer or pointer-like conversions.
5499 --If class B is derived directly or indirectly from class A,
5500 conversion of B* to A* is better than conversion of B* to
5501 void*, and conversion of A* to void* is better than
5502 conversion of B* to void*. */
5503 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5504 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5506 if (is_properly_derived_from (deref_from_type1,
5509 else if (is_properly_derived_from (deref_from_type2,
5513 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5514 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5516 if (same_type_p (deref_from_type1, deref_from_type2))
5518 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5520 if (is_properly_derived_from (deref_from_type1,
5524 /* We know that DEREF_TO_TYPE1 is `void' here. */
5525 else if (is_properly_derived_from (deref_from_type1,
5530 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5531 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5535 --If class B is derived directly or indirectly from class A
5536 and class C is derived directly or indirectly from B,
5538 --conversion of C* to B* is better than conversion of C* to
5541 --conversion of B* to A* is better than conversion of C* to
5543 if (same_type_p (deref_from_type1, deref_from_type2))
5545 if (is_properly_derived_from (deref_to_type1,
5548 else if (is_properly_derived_from (deref_to_type2,
5552 else if (same_type_p (deref_to_type1, deref_to_type2))
5554 if (is_properly_derived_from (deref_from_type2,
5557 else if (is_properly_derived_from (deref_from_type1,
5563 else if (CLASS_TYPE_P (non_reference (from_type1))
5564 && same_type_p (from_type1, from_type2))
5566 tree from = non_reference (from_type1);
5570 --binding of an expression of type C to a reference of type
5571 B& is better than binding an expression of type C to a
5572 reference of type A&
5574 --conversion of C to B is better than conversion of C to A, */
5575 if (is_properly_derived_from (from, to_type1)
5576 && is_properly_derived_from (from, to_type2))
5578 if (is_properly_derived_from (to_type1, to_type2))
5580 else if (is_properly_derived_from (to_type2, to_type1))
5584 else if (CLASS_TYPE_P (non_reference (to_type1))
5585 && same_type_p (to_type1, to_type2))
5587 tree to = non_reference (to_type1);
5591 --binding of an expression of type B to a reference of type
5592 A& is better than binding an expression of type C to a
5593 reference of type A&,
5595 --onversion of B to A is better than conversion of C to A */
5596 if (is_properly_derived_from (from_type1, to)
5597 && is_properly_derived_from (from_type2, to))
5599 if (is_properly_derived_from (from_type2, from_type1))
5601 else if (is_properly_derived_from (from_type1, from_type2))
5608 --S1 and S2 differ only in their qualification conversion and yield
5609 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5610 qualification signature of type T1 is a proper subset of the cv-
5611 qualification signature of type T2 */
5612 if (TREE_CODE (ics1) == QUAL_CONV
5613 && TREE_CODE (ics2) == QUAL_CONV
5614 && same_type_p (from_type1, from_type2))
5615 return comp_cv_qual_signature (to_type1, to_type2);
5619 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5620 types to which the references refer are the same type except for
5621 top-level cv-qualifiers, and the type to which the reference
5622 initialized by S2 refers is more cv-qualified than the type to
5623 which the reference initialized by S1 refers */
5625 if (target_type1 && target_type2
5626 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5627 return comp_cv_qualification (target_type2, target_type1);
5629 /* Neither conversion sequence is better than the other. */
5633 /* The source type for this standard conversion sequence. */
5636 source_type (tree t)
5638 for (;; t = TREE_OPERAND (t, 0))
5640 if (TREE_CODE (t) == USER_CONV
5641 || TREE_CODE (t) == AMBIG_CONV
5642 || TREE_CODE (t) == IDENTITY_CONV)
5643 return TREE_TYPE (t);
5648 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5649 a pointer to LOSER and re-running joust to produce the warning if WINNER
5650 is actually used. */
5653 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5655 winner->warnings = tree_cons (NULL_TREE,
5656 build_zc_wrapper (loser),
5660 /* Compare two candidates for overloading as described in
5661 [over.match.best]. Return values:
5663 1: cand1 is better than cand2
5664 -1: cand2 is better than cand1
5665 0: cand1 and cand2 are indistinguishable */
5668 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5671 int i, off1 = 0, off2 = 0, len;
5673 /* Candidates that involve bad conversions are always worse than those
5675 if (cand1->viable > cand2->viable)
5677 if (cand1->viable < cand2->viable)
5680 /* If we have two pseudo-candidates for conversions to the same type,
5681 or two candidates for the same function, arbitrarily pick one. */
5682 if (cand1->fn == cand2->fn
5683 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5686 /* a viable function F1
5687 is defined to be a better function than another viable function F2 if
5688 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5689 ICSi(F2), and then */
5691 /* for some argument j, ICSj(F1) is a better conversion sequence than
5694 /* For comparing static and non-static member functions, we ignore
5695 the implicit object parameter of the non-static function. The
5696 standard says to pretend that the static function has an object
5697 parm, but that won't work with operator overloading. */
5698 len = TREE_VEC_LENGTH (cand1->convs);
5699 if (len != TREE_VEC_LENGTH (cand2->convs))
5701 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5702 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5704 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5705 && DECL_STATIC_FUNCTION_P (cand2->fn))
5714 for (i = 0; i < len; ++i)
5716 tree t1 = TREE_VEC_ELT (cand1->convs, i+off1);
5717 tree t2 = TREE_VEC_ELT (cand2->convs, i+off2);
5718 int comp = compare_ics (t1, t2);
5723 && ICS_RANK (t1) + ICS_RANK (t2) == STD_RANK + PROMO_RANK
5724 && TREE_CODE (t1) == STD_CONV
5725 && TREE_CODE (t2) == STD_CONV
5726 && TREE_CODE (TREE_TYPE (t1)) == INTEGER_TYPE
5727 && TREE_CODE (TREE_TYPE (t2)) == INTEGER_TYPE
5728 && (TYPE_PRECISION (TREE_TYPE (t1))
5729 == TYPE_PRECISION (TREE_TYPE (t2)))
5730 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1, 0)))
5731 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1, 0)))
5734 tree type = TREE_TYPE (TREE_OPERAND (t1, 0));
5736 struct z_candidate *w, *l;
5738 type1 = TREE_TYPE (t1), type2 = TREE_TYPE (t2),
5739 w = cand1, l = cand2;
5741 type1 = TREE_TYPE (t2), type2 = TREE_TYPE (t1),
5742 w = cand2, l = cand1;
5746 warning ("passing `%T' chooses `%T' over `%T'",
5747 type, type1, type2);
5748 warning (" in call to `%D'", w->fn);
5754 if (winner && comp != winner)
5763 /* warn about confusing overload resolution for user-defined conversions,
5764 either between a constructor and a conversion op, or between two
5766 if (winner && warn_conversion && cand1->second_conv
5767 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5768 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5770 struct z_candidate *w, *l;
5771 bool give_warning = false;
5774 w = cand1, l = cand2;
5776 w = cand2, l = cand1;
5778 /* We don't want to complain about `X::operator T1 ()'
5779 beating `X::operator T2 () const', when T2 is a no less
5780 cv-qualified version of T1. */
5781 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5782 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5784 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5785 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5787 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5792 if (!comp_ptr_ttypes (t, f))
5793 give_warning = true;
5796 give_warning = true;
5802 tree source = source_type (TREE_VEC_ELT (w->convs, 0));
5803 if (! DECL_CONSTRUCTOR_P (w->fn))
5804 source = TREE_TYPE (source);
5805 warning ("choosing `%D' over `%D'", w->fn, l->fn);
5806 warning (" for conversion from `%T' to `%T'",
5807 source, TREE_TYPE (w->second_conv));
5808 warning (" because conversion sequence for the argument is better");
5818 F1 is a non-template function and F2 is a template function
5821 if (! cand1->template && cand2->template)
5823 else if (cand1->template && ! cand2->template)
5827 F1 and F2 are template functions and the function template for F1 is
5828 more specialized than the template for F2 according to the partial
5831 if (cand1->template && cand2->template)
5833 winner = more_specialized
5834 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
5836 /* Tell the deduction code how many real function arguments
5837 we saw, not counting the implicit 'this' argument. But,
5838 add_function_candidate() suppresses the "this" argument
5841 [temp.func.order]: The presence of unused ellipsis and default
5842 arguments has no effect on the partial ordering of function
5844 TREE_VEC_LENGTH (cand1->convs)
5845 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
5846 - DECL_CONSTRUCTOR_P (cand1->fn)));
5852 the context is an initialization by user-defined conversion (see
5853 _dcl.init_ and _over.match.user_) and the standard conversion
5854 sequence from the return type of F1 to the destination type (i.e.,
5855 the type of the entity being initialized) is a better conversion
5856 sequence than the standard conversion sequence from the return type
5857 of F2 to the destination type. */
5859 if (cand1->second_conv)
5861 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5866 /* Check whether we can discard a builtin candidate, either because we
5867 have two identical ones or matching builtin and non-builtin candidates.
5869 (Pedantically in the latter case the builtin which matched the user
5870 function should not be added to the overload set, but we spot it here.
5873 ... the builtin candidates include ...
5874 - do not have the same parameter type list as any non-template
5875 non-member candidate. */
5877 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
5878 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
5880 for (i = 0; i < len; ++i)
5881 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5882 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i))))
5884 if (i == TREE_VEC_LENGTH (cand1->convs))
5886 if (cand1->fn == cand2->fn)
5887 /* Two built-in candidates; arbitrarily pick one. */
5889 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5890 /* cand1 is built-in; prefer cand2. */
5893 /* cand2 is built-in; prefer cand1. */
5898 /* If the two functions are the same (this can happen with declarations
5899 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5900 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
5901 && equal_functions (cand1->fn, cand2->fn))
5906 /* Extension: If the worst conversion for one candidate is worse than the
5907 worst conversion for the other, take the first. */
5910 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
5911 struct z_candidate *w = 0, *l = 0;
5913 for (i = 0; i < len; ++i)
5915 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5916 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5917 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5918 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5921 winner = 1, w = cand1, l = cand2;
5923 winner = -1, w = cand2, l = cand1;
5929 ISO C++ says that these are ambiguous, even \
5930 though the worst conversion for the first is better than \
5931 the worst conversion for the second:");
5932 print_z_candidate (_("candidate 1:"), w);
5933 print_z_candidate (_("candidate 2:"), l);
5941 my_friendly_assert (!winner, 20010121);
5945 /* Given a list of candidates for overloading, find the best one, if any.
5946 This algorithm has a worst case of O(2n) (winner is last), and a best
5947 case of O(n/2) (totally ambiguous); much better than a sorting
5950 static struct z_candidate *
5951 tourney (struct z_candidate *candidates)
5953 struct z_candidate *champ = candidates, *challenger;
5955 int champ_compared_to_predecessor = 0;
5957 /* Walk through the list once, comparing each current champ to the next
5958 candidate, knocking out a candidate or two with each comparison. */
5960 for (challenger = champ->next; challenger; )
5962 fate = joust (champ, challenger, 0);
5964 challenger = challenger->next;
5969 champ = challenger->next;
5972 champ_compared_to_predecessor = 0;
5977 champ_compared_to_predecessor = 1;
5980 challenger = champ->next;
5984 /* Make sure the champ is better than all the candidates it hasn't yet
5985 been compared to. */
5987 for (challenger = candidates;
5989 && !(champ_compared_to_predecessor && challenger->next == champ);
5990 challenger = challenger->next)
5992 fate = joust (champ, challenger, 0);
6000 /* Returns nonzero if things of type FROM can be converted to TO. */
6003 can_convert (tree to, tree from)
6005 return can_convert_arg (to, from, NULL_TREE);
6008 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6011 can_convert_arg (tree to, tree from, tree arg)
6013 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6014 return (t && ! ICS_BAD_FLAG (t));
6017 /* Like can_convert_arg, but allows dubious conversions as well. */
6020 can_convert_arg_bad (tree to, tree from, tree arg)
6022 return implicit_conversion (to, from, arg, LOOKUP_NORMAL) != 0;
6025 /* Convert EXPR to TYPE. Return the converted expression.
6027 Note that we allow bad conversions here because by the time we get to
6028 this point we are committed to doing the conversion. If we end up
6029 doing a bad conversion, convert_like will complain. */
6032 perform_implicit_conversion (tree type, tree expr)
6036 if (error_operand_p (expr))
6037 return error_mark_node;
6038 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6042 error ("could not convert `%E' to `%T'", expr, type);
6043 return error_mark_node;
6046 return convert_like (conv, expr);
6049 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6050 permitted. If the conversion is valid, the converted expression is
6051 returned. Otherwise, NULL_TREE is returned. */
6054 perform_direct_initialization_if_possible (tree type, tree expr)
6058 if (type == error_mark_node || error_operand_p (expr))
6059 return error_mark_node;
6060 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6062 if (!conv || ICS_BAD_FLAG (conv))
6064 return convert_like_real (conv, expr, NULL_TREE, 0, 0,
6065 /*issue_conversion_warnings=*/false);
6068 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6069 is being bound to a temporary. Create and return a new VAR_DECL
6070 with the indicated TYPE; this variable will store the value to
6071 which the reference is bound. */
6074 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6078 /* Create the variable. */
6079 var = build_decl (VAR_DECL, NULL_TREE, type);
6080 DECL_ARTIFICIAL (var) = 1;
6081 TREE_USED (var) = 1;
6083 /* Register the variable. */
6084 if (TREE_STATIC (decl))
6086 /* Namespace-scope or local static; give it a mangled name. */
6089 TREE_STATIC (var) = 1;
6090 name = mangle_ref_init_variable (decl);
6091 DECL_NAME (var) = name;
6092 SET_DECL_ASSEMBLER_NAME (var, name);
6093 var = pushdecl_top_level (var);
6097 /* Create a new cleanup level if necessary. */
6098 maybe_push_cleanup_level (type);
6099 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6100 DECL_CONTEXT (var) = current_function_decl;
6106 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6107 initializing a variable of that TYPE. If DECL is non-NULL, it is
6108 the VAR_DECL being initialized with the EXPR. (In that case, the
6109 type of DECL will be TYPE.)
6111 Return the converted expression. */
6114 initialize_reference (tree type, tree expr, tree decl)
6118 if (type == error_mark_node || error_operand_p (expr))
6119 return error_mark_node;
6121 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6122 if (!conv || ICS_BAD_FLAG (conv))
6124 error ("could not convert `%E' to `%T'", expr, type);
6125 return error_mark_node;
6128 /* If DECL is non-NULL, then this special rule applies:
6132 The temporary to which the reference is bound or the temporary
6133 that is the complete object to which the reference is bound
6134 persists for the lifetime of the reference.
6136 The temporaries created during the evaluation of the expression
6137 initializing the reference, except the temporary to which the
6138 reference is bound, are destroyed at the end of the
6139 full-expression in which they are created.
6141 In that case, we store the converted expression into a new
6142 VAR_DECL in a new scope.
6144 However, we want to be careful not to create temporaries when
6145 they are not required. For example, given:
6148 struct D : public B {};
6152 there is no need to copy the return value from "f"; we can just
6153 extend its lifetime. Similarly, given:
6156 struct T { operator S(); };
6160 we can extend the lifetime of the return value of the conversion
6162 my_friendly_assert (TREE_CODE (conv) == REF_BIND, 20030302);
6166 tree base_conv_type;
6168 /* Skip over the REF_BIND. */
6169 conv = TREE_OPERAND (conv, 0);
6170 /* If the next conversion is a BASE_CONV, skip that too -- but
6171 remember that the conversion was required. */
6172 if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv))
6174 base_conv_type = TREE_TYPE (conv);
6175 conv = TREE_OPERAND (conv, 0);
6178 base_conv_type = NULL_TREE;
6179 /* Perform the remainder of the conversion. */
6180 expr = convert_like (conv, expr);
6181 if (!real_non_cast_lvalue_p (expr))
6186 /* Create the temporary variable. */
6187 type = TREE_TYPE (expr);
6188 var = make_temporary_var_for_ref_to_temp (decl, type);
6189 layout_decl (var, 0);
6190 if (at_function_scope_p ())
6194 add_decl_stmt (var);
6195 cleanup = cxx_maybe_build_cleanup (var);
6197 finish_decl_cleanup (var, cleanup);
6201 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6202 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6203 static_aggregates = tree_cons (NULL_TREE, var,
6206 init = build (INIT_EXPR, type, var, expr);
6207 /* Use its address to initialize the reference variable. */
6208 expr = build_address (var);
6209 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6212 /* Take the address of EXPR. */
6213 expr = build_unary_op (ADDR_EXPR, expr, 0);
6214 /* If a BASE_CONV was required, perform it now. */
6216 expr = (perform_implicit_conversion
6217 (build_pointer_type (base_conv_type), expr));
6218 return build_nop (type, expr);
6221 /* Perform the conversion. */
6222 return convert_like (conv, expr);
6225 #include "gt-cp-call.h"