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, 2004, 2005, 2006, 2007, 2008, 2009,
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com) and
7 modified by Brendan Kehoe (brendan@cygnus.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
16 GCC is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
26 /* High-level class interface. */
30 #include "coretypes.h"
37 #include "diagnostic-core.h"
41 #include "langhooks.h"
42 #include "c-family/c-objc.h"
45 /* The various kinds of conversion. */
47 typedef enum conversion_kind {
63 /* The rank of the conversion. Order of the enumerals matters; better
64 conversions should come earlier in the list. */
66 typedef enum conversion_rank {
77 /* An implicit conversion sequence, in the sense of [over.best.ics].
78 The first conversion to be performed is at the end of the chain.
79 That conversion is always a cr_identity conversion. */
81 typedef struct conversion conversion;
83 /* The kind of conversion represented by this step. */
85 /* The rank of this conversion. */
87 BOOL_BITFIELD user_conv_p : 1;
88 BOOL_BITFIELD ellipsis_p : 1;
89 BOOL_BITFIELD this_p : 1;
90 /* True if this conversion would be permitted with a bending of
91 language standards, e.g. disregarding pointer qualifiers or
92 converting integers to pointers. */
93 BOOL_BITFIELD bad_p : 1;
94 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
95 temporary should be created to hold the result of the
97 BOOL_BITFIELD need_temporary_p : 1;
98 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
99 from a pointer-to-derived to pointer-to-base is being performed. */
100 BOOL_BITFIELD base_p : 1;
101 /* If KIND is ck_ref_bind, true when either an lvalue reference is
102 being bound to an lvalue expression or an rvalue reference is
103 being bound to an rvalue expression. If KIND is ck_rvalue,
104 true when we should treat an lvalue as an rvalue (12.8p33). If
105 KIND is ck_base, always false. */
106 BOOL_BITFIELD rvaluedness_matches_p: 1;
107 BOOL_BITFIELD check_narrowing: 1;
108 /* The type of the expression resulting from the conversion. */
111 /* The next conversion in the chain. Since the conversions are
112 arranged from outermost to innermost, the NEXT conversion will
113 actually be performed before this conversion. This variant is
114 used only when KIND is neither ck_identity nor ck_ambig. */
116 /* The expression at the beginning of the conversion chain. This
117 variant is used only if KIND is ck_identity or ck_ambig. */
119 /* The array of conversions for an initializer_list. */
122 /* The function candidate corresponding to this conversion
123 sequence. This field is only used if KIND is ck_user. */
124 struct z_candidate *cand;
127 #define CONVERSION_RANK(NODE) \
128 ((NODE)->bad_p ? cr_bad \
129 : (NODE)->ellipsis_p ? cr_ellipsis \
130 : (NODE)->user_conv_p ? cr_user \
133 #define BAD_CONVERSION_RANK(NODE) \
134 ((NODE)->ellipsis_p ? cr_ellipsis \
135 : (NODE)->user_conv_p ? cr_user \
138 static struct obstack conversion_obstack;
139 static bool conversion_obstack_initialized;
140 struct rejection_reason;
142 static struct z_candidate * tourney (struct z_candidate *);
143 static int equal_functions (tree, tree);
144 static int joust (struct z_candidate *, struct z_candidate *, bool);
145 static int compare_ics (conversion *, conversion *);
146 static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
147 static tree build_java_interface_fn_ref (tree, tree);
148 #define convert_like(CONV, EXPR, COMPLAIN) \
149 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
150 /*issue_conversion_warnings=*/true, \
151 /*c_cast_p=*/false, (COMPLAIN))
152 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
153 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
154 /*issue_conversion_warnings=*/true, \
155 /*c_cast_p=*/false, (COMPLAIN))
156 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
157 bool, tsubst_flags_t);
158 static void op_error (enum tree_code, enum tree_code, tree, tree,
160 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
161 static void print_z_candidate (const char *, struct z_candidate *);
162 static void print_z_candidates (location_t, struct z_candidate *);
163 static tree build_this (tree);
164 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
165 static bool any_strictly_viable (struct z_candidate *);
166 static struct z_candidate *add_template_candidate
167 (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
168 tree, tree, tree, int, unification_kind_t);
169 static struct z_candidate *add_template_candidate_real
170 (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
171 tree, tree, tree, int, tree, unification_kind_t);
172 static struct z_candidate *add_template_conv_candidate
173 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
175 static void add_builtin_candidates
176 (struct z_candidate **, enum tree_code, enum tree_code,
178 static void add_builtin_candidate
179 (struct z_candidate **, enum tree_code, enum tree_code,
180 tree, tree, tree, tree *, tree *, int);
181 static bool is_complete (tree);
182 static void build_builtin_candidate
183 (struct z_candidate **, tree, tree, tree, tree *, tree *,
185 static struct z_candidate *add_conv_candidate
186 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
188 static struct z_candidate *add_function_candidate
189 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
191 static conversion *implicit_conversion (tree, tree, tree, bool, int);
192 static conversion *standard_conversion (tree, tree, tree, bool, int);
193 static conversion *reference_binding (tree, tree, tree, bool, int);
194 static conversion *build_conv (conversion_kind, tree, conversion *);
195 static conversion *build_list_conv (tree, tree, int);
196 static bool is_subseq (conversion *, conversion *);
197 static conversion *maybe_handle_ref_bind (conversion **);
198 static void maybe_handle_implicit_object (conversion **);
199 static struct z_candidate *add_candidate
200 (struct z_candidate **, tree, tree, const VEC(tree,gc) *, size_t,
201 conversion **, tree, tree, int, struct rejection_reason *);
202 static tree source_type (conversion *);
203 static void add_warning (struct z_candidate *, struct z_candidate *);
204 static bool reference_compatible_p (tree, tree);
205 static conversion *convert_class_to_reference (tree, tree, tree, int);
206 static conversion *direct_reference_binding (tree, conversion *);
207 static bool promoted_arithmetic_type_p (tree);
208 static conversion *conditional_conversion (tree, tree);
209 static char *name_as_c_string (tree, tree, bool *);
210 static tree prep_operand (tree);
211 static void add_candidates (tree, tree, const VEC(tree,gc) *, tree, tree, bool,
212 tree, tree, int, struct z_candidate **);
213 static conversion *merge_conversion_sequences (conversion *, conversion *);
214 static bool magic_varargs_p (tree);
215 static tree build_temp (tree, tree, int, diagnostic_t *, tsubst_flags_t);
217 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
218 NAME can take many forms... */
221 check_dtor_name (tree basetype, tree name)
223 /* Just accept something we've already complained about. */
224 if (name == error_mark_node)
227 if (TREE_CODE (name) == TYPE_DECL)
228 name = TREE_TYPE (name);
229 else if (TYPE_P (name))
231 else if (TREE_CODE (name) == IDENTIFIER_NODE)
233 if ((MAYBE_CLASS_TYPE_P (basetype)
234 && name == constructor_name (basetype))
235 || (TREE_CODE (basetype) == ENUMERAL_TYPE
236 && name == TYPE_IDENTIFIER (basetype)))
239 name = get_type_value (name);
245 template <class T> struct S { ~S(); };
249 NAME will be a class template. */
250 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
254 if (!name || name == error_mark_node)
256 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
259 /* We want the address of a function or method. We avoid creating a
260 pointer-to-member function. */
263 build_addr_func (tree function)
265 tree type = TREE_TYPE (function);
267 /* We have to do these by hand to avoid real pointer to member
269 if (TREE_CODE (type) == METHOD_TYPE)
271 if (TREE_CODE (function) == OFFSET_REF)
273 tree object = build_address (TREE_OPERAND (function, 0));
274 return get_member_function_from_ptrfunc (&object,
275 TREE_OPERAND (function, 1));
277 function = build_address (function);
280 function = decay_conversion (function);
285 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
286 POINTER_TYPE to those. Note, pointer to member function types
287 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
288 two variants. build_call_a is the primitive taking an array of
289 arguments, while build_call_n is a wrapper that handles varargs. */
292 build_call_n (tree function, int n, ...)
295 return build_call_a (function, 0, NULL);
298 tree *argarray = XALLOCAVEC (tree, n);
303 for (i = 0; i < n; i++)
304 argarray[i] = va_arg (ap, tree);
306 return build_call_a (function, n, argarray);
311 build_call_a (tree function, int n, tree *argarray)
313 int is_constructor = 0;
320 function = build_addr_func (function);
322 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
323 fntype = TREE_TYPE (TREE_TYPE (function));
324 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
325 || TREE_CODE (fntype) == METHOD_TYPE);
326 result_type = TREE_TYPE (fntype);
327 /* An rvalue has no cv-qualifiers. */
328 if (SCALAR_TYPE_P (result_type) || VOID_TYPE_P (result_type))
329 result_type = cv_unqualified (result_type);
331 if (TREE_CODE (function) == ADDR_EXPR
332 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
334 decl = TREE_OPERAND (function, 0);
335 if (!TREE_USED (decl))
337 /* We invoke build_call directly for several library
338 functions. These may have been declared normally if
339 we're building libgcc, so we can't just check
341 gcc_assert (DECL_ARTIFICIAL (decl)
342 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
350 /* We check both the decl and the type; a function may be known not to
351 throw without being declared throw(). */
352 nothrow = ((decl && TREE_NOTHROW (decl))
353 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
355 if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)
356 current_function_returns_abnormally = 1;
358 if (decl && TREE_DEPRECATED (decl))
359 warn_deprecated_use (decl, NULL_TREE);
360 require_complete_eh_spec_types (fntype, decl);
362 if (decl && DECL_CONSTRUCTOR_P (decl))
365 /* Don't pass empty class objects by value. This is useful
366 for tags in STL, which are used to control overload resolution.
367 We don't need to handle other cases of copying empty classes. */
368 if (! decl || ! DECL_BUILT_IN (decl))
369 for (i = 0; i < n; i++)
370 if (is_empty_class (TREE_TYPE (argarray[i]))
371 && ! TREE_ADDRESSABLE (TREE_TYPE (argarray[i])))
373 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (argarray[i]));
374 argarray[i] = build2 (COMPOUND_EXPR, TREE_TYPE (t),
378 function = build_call_array_loc (input_location,
379 result_type, function, n, argarray);
380 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
381 TREE_NOTHROW (function) = nothrow;
386 /* Build something of the form ptr->method (args)
387 or object.method (args). This can also build
388 calls to constructors, and find friends.
390 Member functions always take their class variable
393 INSTANCE is a class instance.
395 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
397 PARMS help to figure out what that NAME really refers to.
399 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
400 down to the real instance type to use for access checking. We need this
401 information to get protected accesses correct.
403 FLAGS is the logical disjunction of zero or more LOOKUP_
404 flags. See cp-tree.h for more info.
406 If this is all OK, calls build_function_call with the resolved
409 This function must also handle being called to perform
410 initialization, promotion/coercion of arguments, and
411 instantiation of default parameters.
413 Note that NAME may refer to an instance variable name. If
414 `operator()()' is defined for the type of that field, then we return
417 /* New overloading code. */
419 typedef struct z_candidate z_candidate;
421 typedef struct candidate_warning candidate_warning;
422 struct candidate_warning {
424 candidate_warning *next;
427 /* Information for providing diagnostics about why overloading failed. */
429 enum rejection_reason_code {
433 rr_bad_arg_conversion
436 struct conversion_info {
437 /* The index of the argument, 0-based. */
439 /* The type of the actual argument. */
441 /* The type of the formal argument. */
445 struct rejection_reason {
446 enum rejection_reason_code code;
448 /* Information about an arity mismatch. */
450 /* The expected number of arguments. */
452 /* The actual number of arguments in the call. */
454 /* Whether the call was a varargs call. */
457 /* Information about an argument conversion mismatch. */
458 struct conversion_info conversion;
459 /* Same, but for bad argument conversions. */
460 struct conversion_info bad_conversion;
465 /* The FUNCTION_DECL that will be called if this candidate is
466 selected by overload resolution. */
468 /* If not NULL_TREE, the first argument to use when calling this
471 /* The rest of the arguments to use when calling this function. If
472 there are no further arguments this may be NULL or it may be an
474 const VEC(tree,gc) *args;
475 /* The implicit conversion sequences for each of the arguments to
478 /* The number of implicit conversion sequences. */
480 /* If FN is a user-defined conversion, the standard conversion
481 sequence from the type returned by FN to the desired destination
483 conversion *second_conv;
485 struct rejection_reason *reason;
486 /* If FN is a member function, the binfo indicating the path used to
487 qualify the name of FN at the call site. This path is used to
488 determine whether or not FN is accessible if it is selected by
489 overload resolution. The DECL_CONTEXT of FN will always be a
490 (possibly improper) base of this binfo. */
492 /* If FN is a non-static member function, the binfo indicating the
493 subobject to which the `this' pointer should be converted if FN
494 is selected by overload resolution. The type pointed to the by
495 the `this' pointer must correspond to the most derived class
496 indicated by the CONVERSION_PATH. */
497 tree conversion_path;
500 candidate_warning *warnings;
504 /* Returns true iff T is a null pointer constant in the sense of
508 null_ptr_cst_p (tree t)
512 A null pointer constant is an integral constant expression
513 (_expr.const_) rvalue of integer type that evaluates to zero or
514 an rvalue of type std::nullptr_t. */
515 if (NULLPTR_TYPE_P (TREE_TYPE (t)))
517 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)))
519 if (cxx_dialect >= cxx0x)
521 t = fold_non_dependent_expr (t);
522 t = maybe_constant_value (t);
523 if (TREE_CONSTANT (t) && integer_zerop (t))
528 t = integral_constant_value (t);
530 if (integer_zerop (t) && !TREE_OVERFLOW (t))
537 /* Returns nonzero if PARMLIST consists of only default parms and/or
541 sufficient_parms_p (const_tree parmlist)
543 for (; parmlist && parmlist != void_list_node;
544 parmlist = TREE_CHAIN (parmlist))
545 if (!TREE_PURPOSE (parmlist))
550 /* Allocate N bytes of memory from the conversion obstack. The memory
551 is zeroed before being returned. */
554 conversion_obstack_alloc (size_t n)
557 if (!conversion_obstack_initialized)
559 gcc_obstack_init (&conversion_obstack);
560 conversion_obstack_initialized = true;
562 p = obstack_alloc (&conversion_obstack, n);
567 /* Allocate rejection reasons. */
569 static struct rejection_reason *
570 alloc_rejection (enum rejection_reason_code code)
572 struct rejection_reason *p;
573 p = (struct rejection_reason *) conversion_obstack_alloc (sizeof *p);
578 static struct rejection_reason *
579 arity_rejection (tree first_arg, int expected, int actual)
581 struct rejection_reason *r = alloc_rejection (rr_arity);
582 int adjust = first_arg != NULL_TREE;
583 r->u.arity.expected = expected - adjust;
584 r->u.arity.actual = actual - adjust;
588 static struct rejection_reason *
589 arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to)
591 struct rejection_reason *r = alloc_rejection (rr_arg_conversion);
592 int adjust = first_arg != NULL_TREE;
593 r->u.conversion.n_arg = n_arg - adjust;
594 r->u.conversion.from_type = from;
595 r->u.conversion.to_type = to;
599 static struct rejection_reason *
600 bad_arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to)
602 struct rejection_reason *r = alloc_rejection (rr_bad_arg_conversion);
603 int adjust = first_arg != NULL_TREE;
604 r->u.bad_conversion.n_arg = n_arg - adjust;
605 r->u.bad_conversion.from_type = from;
606 r->u.bad_conversion.to_type = to;
610 /* Dynamically allocate a conversion. */
613 alloc_conversion (conversion_kind kind)
616 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
621 #ifdef ENABLE_CHECKING
623 /* Make sure that all memory on the conversion obstack has been
627 validate_conversion_obstack (void)
629 if (conversion_obstack_initialized)
630 gcc_assert ((obstack_next_free (&conversion_obstack)
631 == obstack_base (&conversion_obstack)));
634 #endif /* ENABLE_CHECKING */
636 /* Dynamically allocate an array of N conversions. */
639 alloc_conversions (size_t n)
641 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
645 build_conv (conversion_kind code, tree type, conversion *from)
648 conversion_rank rank = CONVERSION_RANK (from);
650 /* Note that the caller is responsible for filling in t->cand for
651 user-defined conversions. */
652 t = alloc_conversion (code);
675 t->user_conv_p = (code == ck_user || from->user_conv_p);
676 t->bad_p = from->bad_p;
681 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
682 specialization of std::initializer_list<T>, if such a conversion is
686 build_list_conv (tree type, tree ctor, int flags)
688 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
689 unsigned len = CONSTRUCTOR_NELTS (ctor);
690 conversion **subconvs = alloc_conversions (len);
695 /* Within a list-initialization we can have more user-defined
697 flags &= ~LOOKUP_NO_CONVERSION;
698 /* But no narrowing conversions. */
699 flags |= LOOKUP_NO_NARROWING;
701 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
704 = implicit_conversion (elttype, TREE_TYPE (val), val,
712 t = alloc_conversion (ck_list);
714 t->u.list = subconvs;
717 for (i = 0; i < len; ++i)
719 conversion *sub = subconvs[i];
720 if (sub->rank > t->rank)
722 if (sub->user_conv_p)
723 t->user_conv_p = true;
731 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
732 is a valid aggregate initializer for array type ATYPE. */
735 can_convert_array (tree atype, tree ctor, int flags)
738 tree elttype = TREE_TYPE (atype);
739 for (i = 0; i < CONSTRUCTOR_NELTS (ctor); ++i)
741 tree val = CONSTRUCTOR_ELT (ctor, i)->value;
743 if (TREE_CODE (elttype) == ARRAY_TYPE
744 && TREE_CODE (val) == CONSTRUCTOR)
745 ok = can_convert_array (elttype, val, flags);
747 ok = can_convert_arg (elttype, TREE_TYPE (val), val, flags);
754 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
755 aggregate class, if such a conversion is possible. */
758 build_aggr_conv (tree type, tree ctor, int flags)
760 unsigned HOST_WIDE_INT i = 0;
762 tree field = next_initializable_field (TYPE_FIELDS (type));
763 tree empty_ctor = NULL_TREE;
765 for (; field; field = next_initializable_field (DECL_CHAIN (field)))
767 tree ftype = TREE_TYPE (field);
771 if (i < CONSTRUCTOR_NELTS (ctor))
772 val = CONSTRUCTOR_ELT (ctor, i)->value;
775 if (empty_ctor == NULL_TREE)
776 empty_ctor = build_constructor (init_list_type_node, NULL);
781 if (TREE_CODE (ftype) == ARRAY_TYPE
782 && TREE_CODE (val) == CONSTRUCTOR)
783 ok = can_convert_array (ftype, val, flags);
785 ok = can_convert_arg (ftype, TREE_TYPE (val), val, flags);
790 if (TREE_CODE (type) == UNION_TYPE)
794 if (i < CONSTRUCTOR_NELTS (ctor))
797 c = alloc_conversion (ck_aggr);
800 c->user_conv_p = true;
805 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
806 array type, if such a conversion is possible. */
809 build_array_conv (tree type, tree ctor, int flags)
812 unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
813 tree elttype = TREE_TYPE (type);
818 enum conversion_rank rank = cr_exact;
820 if (TYPE_DOMAIN (type))
822 unsigned HOST_WIDE_INT alen = tree_low_cst (array_type_nelts_top (type), 1);
827 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
830 = implicit_conversion (elttype, TREE_TYPE (val), val,
835 if (sub->rank > rank)
837 if (sub->user_conv_p)
843 c = alloc_conversion (ck_aggr);
846 c->user_conv_p = user;
852 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
853 complex type, if such a conversion is possible. */
856 build_complex_conv (tree type, tree ctor, int flags)
859 unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
860 tree elttype = TREE_TYPE (type);
865 enum conversion_rank rank = cr_exact;
870 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
873 = implicit_conversion (elttype, TREE_TYPE (val), val,
878 if (sub->rank > rank)
880 if (sub->user_conv_p)
886 c = alloc_conversion (ck_aggr);
889 c->user_conv_p = user;
895 /* Build a representation of the identity conversion from EXPR to
896 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
899 build_identity_conv (tree type, tree expr)
903 c = alloc_conversion (ck_identity);
910 /* Converting from EXPR to TYPE was ambiguous in the sense that there
911 were multiple user-defined conversions to accomplish the job.
912 Build a conversion that indicates that ambiguity. */
915 build_ambiguous_conv (tree type, tree expr)
919 c = alloc_conversion (ck_ambig);
927 strip_top_quals (tree t)
929 if (TREE_CODE (t) == ARRAY_TYPE)
931 return cp_build_qualified_type (t, 0);
934 /* Returns the standard conversion path (see [conv]) from type FROM to type
935 TO, if any. For proper handling of null pointer constants, you must
936 also pass the expression EXPR to convert from. If C_CAST_P is true,
937 this conversion is coming from a C-style cast. */
940 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
943 enum tree_code fcode, tcode;
945 bool fromref = false;
948 to = non_reference (to);
949 if (TREE_CODE (from) == REFERENCE_TYPE)
952 from = TREE_TYPE (from);
955 to = strip_top_quals (to);
956 from = strip_top_quals (from);
958 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
959 && expr && type_unknown_p (expr))
961 tsubst_flags_t tflags = tf_conv;
962 if (!(flags & LOOKUP_PROTECT))
963 tflags |= tf_no_access_control;
964 expr = instantiate_type (to, expr, tflags);
965 if (expr == error_mark_node)
967 from = TREE_TYPE (expr);
970 fcode = TREE_CODE (from);
971 tcode = TREE_CODE (to);
973 conv = build_identity_conv (from, expr);
974 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
976 from = type_decays_to (from);
977 fcode = TREE_CODE (from);
978 conv = build_conv (ck_lvalue, from, conv);
980 else if (fromref || (expr && lvalue_p (expr)))
985 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
988 from = strip_top_quals (bitfield_type);
989 fcode = TREE_CODE (from);
992 conv = build_conv (ck_rvalue, from, conv);
993 if (flags & LOOKUP_PREFER_RVALUE)
994 conv->rvaluedness_matches_p = true;
997 /* Allow conversion between `__complex__' data types. */
998 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
1000 /* The standard conversion sequence to convert FROM to TO is
1001 the standard conversion sequence to perform componentwise
1003 conversion *part_conv = standard_conversion
1004 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
1008 conv = build_conv (part_conv->kind, to, conv);
1009 conv->rank = part_conv->rank;
1017 if (same_type_p (from, to))
1019 if (CLASS_TYPE_P (to) && conv->kind == ck_rvalue)
1020 conv->type = qualified_to;
1025 A null pointer constant can be converted to a pointer type; ... A
1026 null pointer constant of integral type can be converted to an
1027 rvalue of type std::nullptr_t. */
1028 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)
1029 || NULLPTR_TYPE_P (to))
1030 && expr && null_ptr_cst_p (expr))
1031 conv = build_conv (ck_std, to, conv);
1032 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
1033 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
1035 /* For backwards brain damage compatibility, allow interconversion of
1036 pointers and integers with a pedwarn. */
1037 conv = build_conv (ck_std, to, conv);
1040 else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
1042 /* For backwards brain damage compatibility, allow interconversion of
1043 enums and integers with a pedwarn. */
1044 conv = build_conv (ck_std, to, conv);
1047 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
1048 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
1053 if (tcode == POINTER_TYPE
1054 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
1057 else if (VOID_TYPE_P (TREE_TYPE (to))
1058 && !TYPE_PTRMEM_P (from)
1059 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
1061 tree nfrom = TREE_TYPE (from);
1062 from = build_pointer_type
1063 (cp_build_qualified_type (void_type_node,
1064 cp_type_quals (nfrom)));
1065 conv = build_conv (ck_ptr, from, conv);
1067 else if (TYPE_PTRMEM_P (from))
1069 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
1070 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
1072 if (DERIVED_FROM_P (fbase, tbase)
1073 && (same_type_ignoring_top_level_qualifiers_p
1074 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
1075 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
1077 from = build_ptrmem_type (tbase,
1078 TYPE_PTRMEM_POINTED_TO_TYPE (from));
1079 conv = build_conv (ck_pmem, from, conv);
1081 else if (!same_type_p (fbase, tbase))
1084 else if (CLASS_TYPE_P (TREE_TYPE (from))
1085 && CLASS_TYPE_P (TREE_TYPE (to))
1088 An rvalue of type "pointer to cv D," where D is a
1089 class type, can be converted to an rvalue of type
1090 "pointer to cv B," where B is a base class (clause
1091 _class.derived_) of D. If B is an inaccessible
1092 (clause _class.access_) or ambiguous
1093 (_class.member.lookup_) base class of D, a program
1094 that necessitates this conversion is ill-formed.
1095 Therefore, we use DERIVED_FROM_P, and do not check
1096 access or uniqueness. */
1097 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
1100 cp_build_qualified_type (TREE_TYPE (to),
1101 cp_type_quals (TREE_TYPE (from)));
1102 from = build_pointer_type (from);
1103 conv = build_conv (ck_ptr, from, conv);
1104 conv->base_p = true;
1107 if (tcode == POINTER_TYPE)
1109 to_pointee = TREE_TYPE (to);
1110 from_pointee = TREE_TYPE (from);
1114 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
1115 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
1118 if (same_type_p (from, to))
1120 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
1121 /* In a C-style cast, we ignore CV-qualification because we
1122 are allowed to perform a static_cast followed by a
1124 conv = build_conv (ck_qual, to, conv);
1125 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
1126 conv = build_conv (ck_qual, to, conv);
1127 else if (expr && string_conv_p (to, expr, 0))
1128 /* converting from string constant to char *. */
1129 conv = build_conv (ck_qual, to, conv);
1130 /* Allow conversions among compatible ObjC pointer types (base
1131 conversions have been already handled above). */
1132 else if (c_dialect_objc ()
1133 && objc_compare_types (to, from, -4, NULL_TREE))
1134 conv = build_conv (ck_ptr, to, conv);
1135 else if (ptr_reasonably_similar (to_pointee, from_pointee))
1137 conv = build_conv (ck_ptr, to, conv);
1145 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
1147 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
1148 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
1149 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
1150 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
1152 if (!DERIVED_FROM_P (fbase, tbase)
1153 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
1154 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
1155 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
1156 || cp_type_quals (fbase) != cp_type_quals (tbase))
1159 from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
1160 from = build_ptrmemfunc_type (build_pointer_type (from));
1161 conv = build_conv (ck_pmem, from, conv);
1162 conv->base_p = true;
1164 else if (tcode == BOOLEAN_TYPE)
1168 An rvalue of arithmetic, unscoped enumeration, pointer, or
1169 pointer to member type can be converted to an rvalue of type
1170 bool. ... An rvalue of type std::nullptr_t can be converted
1171 to an rvalue of type bool; */
1172 if (ARITHMETIC_TYPE_P (from)
1173 || UNSCOPED_ENUM_P (from)
1174 || fcode == POINTER_TYPE
1175 || TYPE_PTR_TO_MEMBER_P (from)
1176 || NULLPTR_TYPE_P (from))
1178 conv = build_conv (ck_std, to, conv);
1179 if (fcode == POINTER_TYPE
1180 || TYPE_PTRMEM_P (from)
1181 || (TYPE_PTRMEMFUNC_P (from)
1182 && conv->rank < cr_pbool)
1183 || NULLPTR_TYPE_P (from))
1184 conv->rank = cr_pbool;
1190 /* We don't check for ENUMERAL_TYPE here because there are no standard
1191 conversions to enum type. */
1192 /* As an extension, allow conversion to complex type. */
1193 else if (ARITHMETIC_TYPE_P (to))
1195 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
1196 || SCOPED_ENUM_P (from))
1198 conv = build_conv (ck_std, to, conv);
1200 /* Give this a better rank if it's a promotion. */
1201 if (same_type_p (to, type_promotes_to (from))
1202 && conv->u.next->rank <= cr_promotion)
1203 conv->rank = cr_promotion;
1205 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
1206 && vector_types_convertible_p (from, to, false))
1207 return build_conv (ck_std, to, conv);
1208 else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
1209 && is_properly_derived_from (from, to))
1211 if (conv->kind == ck_rvalue)
1212 conv = conv->u.next;
1213 conv = build_conv (ck_base, to, conv);
1214 /* The derived-to-base conversion indicates the initialization
1215 of a parameter with base type from an object of a derived
1216 type. A temporary object is created to hold the result of
1217 the conversion unless we're binding directly to a reference. */
1218 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
1223 if (flags & LOOKUP_NO_NARROWING)
1224 conv->check_narrowing = true;
1229 /* Returns nonzero if T1 is reference-related to T2. */
1232 reference_related_p (tree t1, tree t2)
1234 if (t1 == error_mark_node || t2 == error_mark_node)
1237 t1 = TYPE_MAIN_VARIANT (t1);
1238 t2 = TYPE_MAIN_VARIANT (t2);
1242 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1243 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1245 return (same_type_p (t1, t2)
1246 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
1247 && DERIVED_FROM_P (t1, t2)));
1250 /* Returns nonzero if T1 is reference-compatible with T2. */
1253 reference_compatible_p (tree t1, tree t2)
1257 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1258 reference-related to T2 and cv1 is the same cv-qualification as,
1259 or greater cv-qualification than, cv2. */
1260 return (reference_related_p (t1, t2)
1261 && at_least_as_qualified_p (t1, t2));
1264 /* Determine whether or not the EXPR (of class type S) can be
1265 converted to T as in [over.match.ref]. */
1268 convert_class_to_reference_1 (tree reference_type, tree s, tree expr, int flags)
1274 struct z_candidate *candidates;
1275 struct z_candidate *cand;
1281 conversions = lookup_conversions (s);
1287 Assuming that "cv1 T" is the underlying type of the reference
1288 being initialized, and "cv S" is the type of the initializer
1289 expression, with S a class type, the candidate functions are
1290 selected as follows:
1292 --The conversion functions of S and its base classes are
1293 considered. Those that are not hidden within S and yield type
1294 "reference to cv2 T2", where "cv1 T" is reference-compatible
1295 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1297 The argument list has one argument, which is the initializer
1302 /* Conceptually, we should take the address of EXPR and put it in
1303 the argument list. Unfortunately, however, that can result in
1304 error messages, which we should not issue now because we are just
1305 trying to find a conversion operator. Therefore, we use NULL,
1306 cast to the appropriate type. */
1307 first_arg = build_int_cst (build_pointer_type (s), 0);
1309 t = TREE_TYPE (reference_type);
1311 /* We're performing a user-defined conversion to a desired type, so set
1312 this for the benefit of add_candidates. */
1313 flags |= LOOKUP_NO_CONVERSION;
1315 for (; conversions; conversions = TREE_CHAIN (conversions))
1317 tree fns = TREE_VALUE (conversions);
1318 tree binfo = TREE_PURPOSE (conversions);
1319 struct z_candidate *old_candidates = candidates;;
1321 add_candidates (fns, first_arg, NULL, reference_type,
1323 binfo, TYPE_BINFO (s),
1324 flags, &candidates);
1326 for (cand = candidates; cand != old_candidates; cand = cand->next)
1328 /* Now, see if the conversion function really returns
1329 an lvalue of the appropriate type. From the
1330 point of view of unification, simply returning an
1331 rvalue of the right type is good enough. */
1333 tree t2 = TREE_TYPE (TREE_TYPE (f));
1334 if (cand->viable == 0)
1335 /* Don't bother looking more closely. */;
1336 else if (TREE_CODE (t2) != REFERENCE_TYPE
1337 || !reference_compatible_p (t, TREE_TYPE (t2)))
1339 /* No need to set cand->reason here; this is most likely
1340 an ambiguous match. If it's not, either this candidate
1341 will win, or we will have identified a reason for it
1347 conversion *identity_conv;
1348 /* Build a standard conversion sequence indicating the
1349 binding from the reference type returned by the
1350 function to the desired REFERENCE_TYPE. */
1352 = build_identity_conv (TREE_TYPE (TREE_TYPE
1353 (TREE_TYPE (cand->fn))),
1356 = (direct_reference_binding
1357 (reference_type, identity_conv));
1358 cand->second_conv->rvaluedness_matches_p
1359 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1360 == TYPE_REF_IS_RVALUE (reference_type);
1361 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1363 /* Don't allow binding of lvalues to rvalue references. */
1364 if (TYPE_REF_IS_RVALUE (reference_type)
1365 && !TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn))))
1366 cand->second_conv->bad_p = true;
1371 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1372 /* If none of the conversion functions worked out, let our caller
1377 cand = tourney (candidates);
1381 /* Now that we know that this is the function we're going to use fix
1382 the dummy first argument. */
1383 gcc_assert (cand->first_arg == NULL_TREE
1384 || integer_zerop (cand->first_arg));
1385 cand->first_arg = build_this (expr);
1387 /* Build a user-defined conversion sequence representing the
1389 conv = build_conv (ck_user,
1390 TREE_TYPE (TREE_TYPE (cand->fn)),
1391 build_identity_conv (TREE_TYPE (expr), expr));
1394 if (cand->viable == -1)
1397 /* Merge it with the standard conversion sequence from the
1398 conversion function's return type to the desired type. */
1399 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1401 return cand->second_conv;
1404 /* Wrapper for above. */
1407 convert_class_to_reference (tree reference_type, tree s, tree expr, int flags)
1410 bool subtime = timevar_cond_start (TV_OVERLOAD);
1411 ret = convert_class_to_reference_1 (reference_type, s, expr, flags);
1412 timevar_cond_stop (TV_OVERLOAD, subtime);
1416 /* A reference of the indicated TYPE is being bound directly to the
1417 expression represented by the implicit conversion sequence CONV.
1418 Return a conversion sequence for this binding. */
1421 direct_reference_binding (tree type, conversion *conv)
1425 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1426 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1428 t = TREE_TYPE (type);
1432 When a parameter of reference type binds directly
1433 (_dcl.init.ref_) to an argument expression, the implicit
1434 conversion sequence is the identity conversion, unless the
1435 argument expression has a type that is a derived class of the
1436 parameter type, in which case the implicit conversion sequence is
1437 a derived-to-base Conversion.
1439 If the parameter binds directly to the result of applying a
1440 conversion function to the argument expression, the implicit
1441 conversion sequence is a user-defined conversion sequence
1442 (_over.ics.user_), with the second standard conversion sequence
1443 either an identity conversion or, if the conversion function
1444 returns an entity of a type that is a derived class of the
1445 parameter type, a derived-to-base conversion. */
1446 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1448 /* Represent the derived-to-base conversion. */
1449 conv = build_conv (ck_base, t, conv);
1450 /* We will actually be binding to the base-class subobject in
1451 the derived class, so we mark this conversion appropriately.
1452 That way, convert_like knows not to generate a temporary. */
1453 conv->need_temporary_p = false;
1455 return build_conv (ck_ref_bind, type, conv);
1458 /* Returns the conversion path from type FROM to reference type TO for
1459 purposes of reference binding. For lvalue binding, either pass a
1460 reference type to FROM or an lvalue expression to EXPR. If the
1461 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1462 the conversion returned. If C_CAST_P is true, this
1463 conversion is coming from a C-style cast. */
1466 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1468 conversion *conv = NULL;
1469 tree to = TREE_TYPE (rto);
1474 cp_lvalue_kind is_lvalue = clk_none;
1476 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1478 expr = instantiate_type (to, expr, tf_none);
1479 if (expr == error_mark_node)
1481 from = TREE_TYPE (expr);
1484 if (TREE_CODE (from) == REFERENCE_TYPE)
1486 /* Anything with reference type is an lvalue. */
1487 is_lvalue = clk_ordinary;
1488 from = TREE_TYPE (from);
1491 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1493 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1494 conv = implicit_conversion (to, from, expr, c_cast_p,
1496 if (!CLASS_TYPE_P (to)
1497 && CONSTRUCTOR_NELTS (expr) == 1)
1499 expr = CONSTRUCTOR_ELT (expr, 0)->value;
1500 if (error_operand_p (expr))
1502 from = TREE_TYPE (expr);
1506 if (is_lvalue == clk_none && expr)
1507 is_lvalue = real_lvalue_p (expr);
1510 if ((is_lvalue & clk_bitfield) != 0)
1511 tfrom = unlowered_expr_type (expr);
1513 /* Figure out whether or not the types are reference-related and
1514 reference compatible. We have do do this after stripping
1515 references from FROM. */
1516 related_p = reference_related_p (to, tfrom);
1517 /* If this is a C cast, first convert to an appropriately qualified
1518 type, so that we can later do a const_cast to the desired type. */
1519 if (related_p && c_cast_p
1520 && !at_least_as_qualified_p (to, tfrom))
1521 to = cp_build_qualified_type (to, cp_type_quals (tfrom));
1522 compatible_p = reference_compatible_p (to, tfrom);
1524 /* Directly bind reference when target expression's type is compatible with
1525 the reference and expression is an lvalue. In DR391, the wording in
1526 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1527 const and rvalue references to rvalues of compatible class type.
1528 We should also do direct bindings for non-class "rvalues" derived from
1529 rvalue references. */
1532 || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1533 && !(flags & LOOKUP_NO_TEMP_BIND))
1534 || TYPE_REF_IS_RVALUE (rto))
1535 && (CLASS_TYPE_P (from)
1536 || TREE_CODE (from) == ARRAY_TYPE
1537 || (expr && lvalue_p (expr))))))
1541 If the initializer expression
1543 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1544 is reference-compatible with "cv2 T2,"
1546 the reference is bound directly to the initializer expression
1550 If the initializer expression is an rvalue, with T2 a class type,
1551 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1552 is bound to the object represented by the rvalue or to a sub-object
1553 within that object. */
1555 conv = build_identity_conv (tfrom, expr);
1556 conv = direct_reference_binding (rto, conv);
1558 if (flags & LOOKUP_PREFER_RVALUE)
1559 /* The top-level caller requested that we pretend that the lvalue
1560 be treated as an rvalue. */
1561 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1563 conv->rvaluedness_matches_p
1564 = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1566 if ((is_lvalue & clk_bitfield) != 0
1567 || ((is_lvalue & clk_packed) != 0 && !TYPE_PACKED (to)))
1568 /* For the purposes of overload resolution, we ignore the fact
1569 this expression is a bitfield or packed field. (In particular,
1570 [over.ics.ref] says specifically that a function with a
1571 non-const reference parameter is viable even if the
1572 argument is a bitfield.)
1574 However, when we actually call the function we must create
1575 a temporary to which to bind the reference. If the
1576 reference is volatile, or isn't const, then we cannot make
1577 a temporary, so we just issue an error when the conversion
1579 conv->need_temporary_p = true;
1581 /* Don't allow binding of lvalues (other than function lvalues) to
1582 rvalue references. */
1583 if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1584 && TREE_CODE (to) != FUNCTION_TYPE
1585 && !(flags & LOOKUP_PREFER_RVALUE))
1590 /* [class.conv.fct] A conversion function is never used to convert a
1591 (possibly cv-qualified) object to the (possibly cv-qualified) same
1592 object type (or a reference to it), to a (possibly cv-qualified) base
1593 class of that type (or a reference to it).... */
1594 else if (CLASS_TYPE_P (from) && !related_p
1595 && !(flags & LOOKUP_NO_CONVERSION))
1599 If the initializer expression
1601 -- has a class type (i.e., T2 is a class type) can be
1602 implicitly converted to an lvalue of type "cv3 T3," where
1603 "cv1 T1" is reference-compatible with "cv3 T3". (this
1604 conversion is selected by enumerating the applicable
1605 conversion functions (_over.match.ref_) and choosing the
1606 best one through overload resolution. (_over.match_).
1608 the reference is bound to the lvalue result of the conversion
1609 in the second case. */
1610 conv = convert_class_to_reference (rto, from, expr, flags);
1615 /* From this point on, we conceptually need temporaries, even if we
1616 elide them. Only the cases above are "direct bindings". */
1617 if (flags & LOOKUP_NO_TEMP_BIND)
1622 When a parameter of reference type is not bound directly to an
1623 argument expression, the conversion sequence is the one required
1624 to convert the argument expression to the underlying type of the
1625 reference according to _over.best.ics_. Conceptually, this
1626 conversion sequence corresponds to copy-initializing a temporary
1627 of the underlying type with the argument expression. Any
1628 difference in top-level cv-qualification is subsumed by the
1629 initialization itself and does not constitute a conversion. */
1633 Otherwise, the reference shall be to a non-volatile const type.
1635 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1636 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1641 Otherwise, a temporary of type "cv1 T1" is created and
1642 initialized from the initializer expression using the rules for a
1643 non-reference copy initialization. If T1 is reference-related to
1644 T2, cv1 must be the same cv-qualification as, or greater
1645 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1646 if (related_p && !at_least_as_qualified_p (to, from))
1649 /* We're generating a temporary now, but don't bind any more in the
1650 conversion (specifically, don't slice the temporary returned by a
1651 conversion operator). */
1652 flags |= LOOKUP_NO_TEMP_BIND;
1654 /* Core issue 899: When [copy-]initializing a temporary to be bound
1655 to the first parameter of a copy constructor (12.8) called with
1656 a single argument in the context of direct-initialization,
1657 explicit conversion functions are also considered.
1659 So don't set LOOKUP_ONLYCONVERTING in that case. */
1660 if (!(flags & LOOKUP_COPY_PARM))
1661 flags |= LOOKUP_ONLYCONVERTING;
1664 conv = implicit_conversion (to, from, expr, c_cast_p,
1669 conv = build_conv (ck_ref_bind, rto, conv);
1670 /* This reference binding, unlike those above, requires the
1671 creation of a temporary. */
1672 conv->need_temporary_p = true;
1673 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1678 /* Returns the implicit conversion sequence (see [over.ics]) from type
1679 FROM to type TO. The optional expression EXPR may affect the
1680 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1681 true, this conversion is coming from a C-style cast. */
1684 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1689 if (from == error_mark_node || to == error_mark_node
1690 || expr == error_mark_node)
1693 if (TREE_CODE (to) == REFERENCE_TYPE)
1694 conv = reference_binding (to, from, expr, c_cast_p, flags);
1696 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1701 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1703 if (is_std_init_list (to))
1704 return build_list_conv (to, expr, flags);
1706 /* As an extension, allow list-initialization of _Complex. */
1707 if (TREE_CODE (to) == COMPLEX_TYPE)
1709 conv = build_complex_conv (to, expr, flags);
1714 /* Allow conversion from an initializer-list with one element to a
1716 if (SCALAR_TYPE_P (to))
1718 int nelts = CONSTRUCTOR_NELTS (expr);
1722 elt = build_value_init (to, tf_none);
1723 else if (nelts == 1)
1724 elt = CONSTRUCTOR_ELT (expr, 0)->value;
1726 elt = error_mark_node;
1728 conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1732 conv->check_narrowing = true;
1733 if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1734 /* Too many levels of braces, i.e. '{{1}}'. */
1739 else if (TREE_CODE (to) == ARRAY_TYPE)
1740 return build_array_conv (to, expr, flags);
1743 if (expr != NULL_TREE
1744 && (MAYBE_CLASS_TYPE_P (from)
1745 || MAYBE_CLASS_TYPE_P (to))
1746 && (flags & LOOKUP_NO_CONVERSION) == 0)
1748 struct z_candidate *cand;
1749 int convflags = (flags & (LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING
1750 |LOOKUP_NO_NARROWING));
1752 if (CLASS_TYPE_P (to)
1753 && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1754 && BRACE_ENCLOSED_INITIALIZER_P (expr))
1755 return build_aggr_conv (to, expr, flags);
1757 cand = build_user_type_conversion_1 (to, expr, convflags);
1759 conv = cand->second_conv;
1761 /* We used to try to bind a reference to a temporary here, but that
1762 is now handled after the recursive call to this function at the end
1763 of reference_binding. */
1770 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1771 functions. ARGS will not be changed until a single candidate is
1774 static struct z_candidate *
1775 add_candidate (struct z_candidate **candidates,
1776 tree fn, tree first_arg, const VEC(tree,gc) *args,
1777 size_t num_convs, conversion **convs,
1778 tree access_path, tree conversion_path,
1779 int viable, struct rejection_reason *reason)
1781 struct z_candidate *cand = (struct z_candidate *)
1782 conversion_obstack_alloc (sizeof (struct z_candidate));
1785 cand->first_arg = first_arg;
1787 cand->convs = convs;
1788 cand->num_convs = num_convs;
1789 cand->access_path = access_path;
1790 cand->conversion_path = conversion_path;
1791 cand->viable = viable;
1792 cand->reason = reason;
1793 cand->next = *candidates;
1799 /* Return the number of remaining arguments in the parameter list
1800 beginning with ARG. */
1803 remaining_arguments (tree arg)
1807 for (n = 0; arg != NULL_TREE && arg != void_list_node;
1808 arg = TREE_CHAIN (arg))
1814 /* Create an overload candidate for the function or method FN called
1815 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1816 FLAGS is passed on to implicit_conversion.
1818 This does not change ARGS.
1820 CTYPE, if non-NULL, is the type we want to pretend this function
1821 comes from for purposes of overload resolution. */
1823 static struct z_candidate *
1824 add_function_candidate (struct z_candidate **candidates,
1825 tree fn, tree ctype, tree first_arg,
1826 const VEC(tree,gc) *args, tree access_path,
1827 tree conversion_path, int flags)
1829 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1833 tree orig_first_arg = first_arg;
1836 struct rejection_reason *reason = NULL;
1838 /* At this point we should not see any functions which haven't been
1839 explicitly declared, except for friend functions which will have
1840 been found using argument dependent lookup. */
1841 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1843 /* The `this', `in_chrg' and VTT arguments to constructors are not
1844 considered in overload resolution. */
1845 if (DECL_CONSTRUCTOR_P (fn))
1847 parmlist = skip_artificial_parms_for (fn, parmlist);
1848 skip = num_artificial_parms_for (fn);
1849 if (skip > 0 && first_arg != NULL_TREE)
1852 first_arg = NULL_TREE;
1858 len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1859 convs = alloc_conversions (len);
1861 /* 13.3.2 - Viable functions [over.match.viable]
1862 First, to be a viable function, a candidate function shall have enough
1863 parameters to agree in number with the arguments in the list.
1865 We need to check this first; otherwise, checking the ICSes might cause
1866 us to produce an ill-formed template instantiation. */
1868 parmnode = parmlist;
1869 for (i = 0; i < len; ++i)
1871 if (parmnode == NULL_TREE || parmnode == void_list_node)
1873 parmnode = TREE_CHAIN (parmnode);
1876 if ((i < len && parmnode)
1877 || !sufficient_parms_p (parmnode))
1879 int remaining = remaining_arguments (parmnode);
1881 reason = arity_rejection (first_arg, i + remaining, len);
1883 /* When looking for a function from a subobject from an implicit
1884 copy/move constructor/operator=, don't consider anything that takes (a
1885 reference to) an unrelated type. See c++/44909 and core 1092. */
1886 else if (parmlist && (flags & LOOKUP_DEFAULTED))
1888 if (DECL_CONSTRUCTOR_P (fn))
1890 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1891 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1897 parmnode = chain_index (i-1, parmlist);
1898 if (!reference_related_p (non_reference (TREE_VALUE (parmnode)),
1903 /* This only applies at the top level. */
1904 flags &= ~LOOKUP_DEFAULTED;
1910 /* Second, for F to be a viable function, there shall exist for each
1911 argument an implicit conversion sequence that converts that argument
1912 to the corresponding parameter of F. */
1914 parmnode = parmlist;
1916 for (i = 0; i < len; ++i)
1918 tree arg, argtype, to_type;
1922 if (parmnode == void_list_node)
1925 if (i == 0 && first_arg != NULL_TREE)
1928 arg = VEC_index (tree, args,
1929 i + skip - (first_arg != NULL_TREE ? 1 : 0));
1930 argtype = lvalue_type (arg);
1932 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1933 && ! DECL_CONSTRUCTOR_P (fn));
1937 tree parmtype = TREE_VALUE (parmnode);
1940 parmnode = TREE_CHAIN (parmnode);
1942 /* The type of the implicit object parameter ('this') for
1943 overload resolution is not always the same as for the
1944 function itself; conversion functions are considered to
1945 be members of the class being converted, and functions
1946 introduced by a using-declaration are considered to be
1947 members of the class that uses them.
1949 Since build_over_call ignores the ICS for the `this'
1950 parameter, we can just change the parm type. */
1951 if (ctype && is_this)
1953 parmtype = cp_build_qualified_type
1954 (ctype, cp_type_quals (TREE_TYPE (parmtype)));
1955 parmtype = build_pointer_type (parmtype);
1958 /* Core issue 899: When [copy-]initializing a temporary to be bound
1959 to the first parameter of a copy constructor (12.8) called with
1960 a single argument in the context of direct-initialization,
1961 explicit conversion functions are also considered.
1963 So set LOOKUP_COPY_PARM to let reference_binding know that
1964 it's being called in that context. We generalize the above
1965 to handle move constructors and template constructors as well;
1966 the standardese should soon be updated similarly. */
1967 if (ctype && i == 0 && (len-skip == 1)
1968 && !(flags & LOOKUP_ONLYCONVERTING)
1969 && DECL_CONSTRUCTOR_P (fn)
1970 && parmtype != error_mark_node
1971 && (same_type_ignoring_top_level_qualifiers_p
1972 (non_reference (parmtype), ctype)))
1974 lflags |= LOOKUP_COPY_PARM;
1975 /* We allow user-defined conversions within init-lists, but
1976 not for the copy constructor. */
1977 if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1978 lflags |= LOOKUP_NO_CONVERSION;
1981 lflags |= LOOKUP_ONLYCONVERTING;
1983 t = implicit_conversion (parmtype, argtype, arg,
1984 /*c_cast_p=*/false, lflags);
1989 t = build_identity_conv (argtype, arg);
1990 t->ellipsis_p = true;
2001 reason = arg_conversion_rejection (first_arg, i, argtype, to_type);
2008 reason = bad_arg_conversion_rejection (first_arg, i, argtype, to_type);
2013 return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
2014 access_path, conversion_path, viable, reason);
2017 /* Create an overload candidate for the conversion function FN which will
2018 be invoked for expression OBJ, producing a pointer-to-function which
2019 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2020 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2021 passed on to implicit_conversion.
2023 Actually, we don't really care about FN; we care about the type it
2024 converts to. There may be multiple conversion functions that will
2025 convert to that type, and we rely on build_user_type_conversion_1 to
2026 choose the best one; so when we create our candidate, we record the type
2027 instead of the function. */
2029 static struct z_candidate *
2030 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
2031 tree first_arg, const VEC(tree,gc) *arglist,
2032 tree access_path, tree conversion_path)
2034 tree totype = TREE_TYPE (TREE_TYPE (fn));
2035 int i, len, viable, flags;
2036 tree parmlist, parmnode;
2038 struct rejection_reason *reason;
2040 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
2041 parmlist = TREE_TYPE (parmlist);
2042 parmlist = TYPE_ARG_TYPES (parmlist);
2044 len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
2045 convs = alloc_conversions (len);
2046 parmnode = parmlist;
2048 flags = LOOKUP_IMPLICIT;
2051 /* Don't bother looking up the same type twice. */
2052 if (*candidates && (*candidates)->fn == totype)
2055 for (i = 0; i < len; ++i)
2057 tree arg, argtype, convert_type = NULL_TREE;
2062 else if (i == 1 && first_arg != NULL_TREE)
2065 arg = VEC_index (tree, arglist,
2066 i - (first_arg != NULL_TREE ? 1 : 0) - 1);
2067 argtype = lvalue_type (arg);
2071 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
2073 convert_type = totype;
2075 else if (parmnode == void_list_node)
2079 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
2080 /*c_cast_p=*/false, flags);
2081 convert_type = TREE_VALUE (parmnode);
2085 t = build_identity_conv (argtype, arg);
2086 t->ellipsis_p = true;
2087 convert_type = argtype;
2097 reason = bad_arg_conversion_rejection (NULL_TREE, i, argtype, convert_type);
2104 parmnode = TREE_CHAIN (parmnode);
2108 || ! sufficient_parms_p (parmnode))
2110 int remaining = remaining_arguments (parmnode);
2112 reason = arity_rejection (NULL_TREE, i + remaining, len);
2115 return add_candidate (candidates, totype, first_arg, arglist, len, convs,
2116 access_path, conversion_path, viable, reason);
2120 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
2121 tree type1, tree type2, tree *args, tree *argtypes,
2129 struct rejection_reason *reason = NULL;
2134 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
2135 convs = alloc_conversions (num_convs);
2137 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2138 conversion ops are allowed. We handle that here by just checking for
2139 boolean_type_node because other operators don't ask for it. COND_EXPR
2140 also does contextual conversion to bool for the first operand, but we
2141 handle that in build_conditional_expr, and type1 here is operand 2. */
2142 if (type1 != boolean_type_node)
2143 flags |= LOOKUP_ONLYCONVERTING;
2145 for (i = 0; i < 2; ++i)
2150 t = implicit_conversion (types[i], argtypes[i], args[i],
2151 /*c_cast_p=*/false, flags);
2155 /* We need something for printing the candidate. */
2156 t = build_identity_conv (types[i], NULL_TREE);
2157 reason = arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2162 reason = bad_arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2167 /* For COND_EXPR we rearranged the arguments; undo that now. */
2170 convs[2] = convs[1];
2171 convs[1] = convs[0];
2172 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
2173 /*c_cast_p=*/false, flags);
2179 reason = arg_conversion_rejection (NULL_TREE, 0, argtypes[2],
2184 add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
2186 /*access_path=*/NULL_TREE,
2187 /*conversion_path=*/NULL_TREE,
2192 is_complete (tree t)
2194 return COMPLETE_TYPE_P (complete_type (t));
2197 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2200 promoted_arithmetic_type_p (tree type)
2204 In this section, the term promoted integral type is used to refer
2205 to those integral types which are preserved by integral promotion
2206 (including e.g. int and long but excluding e.g. char).
2207 Similarly, the term promoted arithmetic type refers to promoted
2208 integral types plus floating types. */
2209 return ((CP_INTEGRAL_TYPE_P (type)
2210 && same_type_p (type_promotes_to (type), type))
2211 || TREE_CODE (type) == REAL_TYPE);
2214 /* Create any builtin operator overload candidates for the operator in
2215 question given the converted operand types TYPE1 and TYPE2. The other
2216 args are passed through from add_builtin_candidates to
2217 build_builtin_candidate.
2219 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2220 If CODE is requires candidates operands of the same type of the kind
2221 of which TYPE1 and TYPE2 are, we add both candidates
2222 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2225 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
2226 enum tree_code code2, tree fnname, tree type1,
2227 tree type2, tree *args, tree *argtypes, int flags)
2231 case POSTINCREMENT_EXPR:
2232 case POSTDECREMENT_EXPR:
2233 args[1] = integer_zero_node;
2234 type2 = integer_type_node;
2243 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2244 and VQ is either volatile or empty, there exist candidate operator
2245 functions of the form
2246 VQ T& operator++(VQ T&);
2247 T operator++(VQ T&, int);
2248 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2249 type other than bool, and VQ is either volatile or empty, there exist
2250 candidate operator functions of the form
2251 VQ T& operator--(VQ T&);
2252 T operator--(VQ T&, int);
2253 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2254 complete object type, and VQ is either volatile or empty, there exist
2255 candidate operator functions of the form
2256 T*VQ& operator++(T*VQ&);
2257 T*VQ& operator--(T*VQ&);
2258 T* operator++(T*VQ&, int);
2259 T* operator--(T*VQ&, int); */
2261 case POSTDECREMENT_EXPR:
2262 case PREDECREMENT_EXPR:
2263 if (TREE_CODE (type1) == BOOLEAN_TYPE)
2265 case POSTINCREMENT_EXPR:
2266 case PREINCREMENT_EXPR:
2267 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
2269 type1 = build_reference_type (type1);
2274 /* 7 For every cv-qualified or cv-unqualified object type T, there
2275 exist candidate operator functions of the form
2279 8 For every function type T, there exist candidate operator functions of
2281 T& operator*(T*); */
2284 if (TREE_CODE (type1) == POINTER_TYPE
2285 && !uses_template_parms (TREE_TYPE (type1))
2286 && (TYPE_PTROB_P (type1)
2287 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
2291 /* 9 For every type T, there exist candidate operator functions of the form
2294 10For every promoted arithmetic type T, there exist candidate operator
2295 functions of the form
2299 case UNARY_PLUS_EXPR: /* unary + */
2300 if (TREE_CODE (type1) == POINTER_TYPE)
2303 if (ARITHMETIC_TYPE_P (type1))
2307 /* 11For every promoted integral type T, there exist candidate operator
2308 functions of the form
2312 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
2316 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2317 is the same type as C2 or is a derived class of C2, T is a complete
2318 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2319 there exist candidate operator functions of the form
2320 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2321 where CV12 is the union of CV1 and CV2. */
2324 if (TREE_CODE (type1) == POINTER_TYPE
2325 && TYPE_PTR_TO_MEMBER_P (type2))
2327 tree c1 = TREE_TYPE (type1);
2328 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
2330 if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
2331 && (TYPE_PTRMEMFUNC_P (type2)
2332 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
2337 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2338 didate operator functions of the form
2343 bool operator<(L, R);
2344 bool operator>(L, R);
2345 bool operator<=(L, R);
2346 bool operator>=(L, R);
2347 bool operator==(L, R);
2348 bool operator!=(L, R);
2349 where LR is the result of the usual arithmetic conversions between
2352 14For every pair of types T and I, where T is a cv-qualified or cv-
2353 unqualified complete object type and I is a promoted integral type,
2354 there exist candidate operator functions of the form
2355 T* operator+(T*, I);
2356 T& operator[](T*, I);
2357 T* operator-(T*, I);
2358 T* operator+(I, T*);
2359 T& operator[](I, T*);
2361 15For every T, where T is a pointer to complete object type, there exist
2362 candidate operator functions of the form112)
2363 ptrdiff_t operator-(T, T);
2365 16For every pointer or enumeration type T, there exist candidate operator
2366 functions of the form
2367 bool operator<(T, T);
2368 bool operator>(T, T);
2369 bool operator<=(T, T);
2370 bool operator>=(T, T);
2371 bool operator==(T, T);
2372 bool operator!=(T, T);
2374 17For every pointer to member type T, there exist candidate operator
2375 functions of the form
2376 bool operator==(T, T);
2377 bool operator!=(T, T); */
2380 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2382 if (TYPE_PTROB_P (type1)
2383 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2385 type2 = ptrdiff_type_node;
2389 case TRUNC_DIV_EXPR:
2390 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2396 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2397 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2399 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2404 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2416 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2418 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2420 if (TREE_CODE (type1) == ENUMERAL_TYPE
2421 && TREE_CODE (type2) == ENUMERAL_TYPE)
2423 if (TYPE_PTR_P (type1)
2424 && null_ptr_cst_p (args[1])
2425 && !uses_template_parms (type1))
2430 if (null_ptr_cst_p (args[0])
2431 && TYPE_PTR_P (type2)
2432 && !uses_template_parms (type2))
2440 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2443 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2445 type1 = ptrdiff_type_node;
2448 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2450 type2 = ptrdiff_type_node;
2455 /* 18For every pair of promoted integral types L and R, there exist candi-
2456 date operator functions of the form
2463 where LR is the result of the usual arithmetic conversions between
2466 case TRUNC_MOD_EXPR:
2472 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2476 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2477 type, VQ is either volatile or empty, and R is a promoted arithmetic
2478 type, there exist candidate operator functions of the form
2479 VQ L& operator=(VQ L&, R);
2480 VQ L& operator*=(VQ L&, R);
2481 VQ L& operator/=(VQ L&, R);
2482 VQ L& operator+=(VQ L&, R);
2483 VQ L& operator-=(VQ L&, R);
2485 20For every pair T, VQ), where T is any type and VQ is either volatile
2486 or empty, there exist candidate operator functions of the form
2487 T*VQ& operator=(T*VQ&, T*);
2489 21For every pair T, VQ), where T is a pointer to member type and VQ is
2490 either volatile or empty, there exist candidate operator functions of
2492 VQ T& operator=(VQ T&, T);
2494 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2495 unqualified complete object type, VQ is either volatile or empty, and
2496 I is a promoted integral type, there exist candidate operator func-
2498 T*VQ& operator+=(T*VQ&, I);
2499 T*VQ& operator-=(T*VQ&, I);
2501 23For every triple L, VQ, R), where L is an integral or enumeration
2502 type, VQ is either volatile or empty, and R is a promoted integral
2503 type, there exist candidate operator functions of the form
2505 VQ L& operator%=(VQ L&, R);
2506 VQ L& operator<<=(VQ L&, R);
2507 VQ L& operator>>=(VQ L&, R);
2508 VQ L& operator&=(VQ L&, R);
2509 VQ L& operator^=(VQ L&, R);
2510 VQ L& operator|=(VQ L&, R); */
2517 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2519 type2 = ptrdiff_type_node;
2523 case TRUNC_DIV_EXPR:
2524 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2528 case TRUNC_MOD_EXPR:
2534 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2539 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2541 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2542 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2543 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2544 || ((TYPE_PTRMEMFUNC_P (type1)
2545 || TREE_CODE (type1) == POINTER_TYPE)
2546 && null_ptr_cst_p (args[1])))
2556 type1 = build_reference_type (type1);
2562 For every pair of promoted arithmetic types L and R, there
2563 exist candidate operator functions of the form
2565 LR operator?(bool, L, R);
2567 where LR is the result of the usual arithmetic conversions
2568 between types L and R.
2570 For every type T, where T is a pointer or pointer-to-member
2571 type, there exist candidate operator functions of the form T
2572 operator?(bool, T, T); */
2574 if (promoted_arithmetic_type_p (type1)
2575 && promoted_arithmetic_type_p (type2))
2579 /* Otherwise, the types should be pointers. */
2580 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2581 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2584 /* We don't check that the two types are the same; the logic
2585 below will actually create two candidates; one in which both
2586 parameter types are TYPE1, and one in which both parameter
2592 if (ARITHMETIC_TYPE_P (type1))
2600 /* If we're dealing with two pointer types or two enumeral types,
2601 we need candidates for both of them. */
2602 if (type2 && !same_type_p (type1, type2)
2603 && TREE_CODE (type1) == TREE_CODE (type2)
2604 && (TREE_CODE (type1) == REFERENCE_TYPE
2605 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2606 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2607 || TYPE_PTRMEMFUNC_P (type1)
2608 || MAYBE_CLASS_TYPE_P (type1)
2609 || TREE_CODE (type1) == ENUMERAL_TYPE))
2611 build_builtin_candidate
2612 (candidates, fnname, type1, type1, args, argtypes, flags);
2613 build_builtin_candidate
2614 (candidates, fnname, type2, type2, args, argtypes, flags);
2618 build_builtin_candidate
2619 (candidates, fnname, type1, type2, args, argtypes, flags);
2623 type_decays_to (tree type)
2625 if (TREE_CODE (type) == ARRAY_TYPE)
2626 return build_pointer_type (TREE_TYPE (type));
2627 if (TREE_CODE (type) == FUNCTION_TYPE)
2628 return build_pointer_type (type);
2629 if (!MAYBE_CLASS_TYPE_P (type))
2630 type = cv_unqualified (type);
2634 /* There are three conditions of builtin candidates:
2636 1) bool-taking candidates. These are the same regardless of the input.
2637 2) pointer-pair taking candidates. These are generated for each type
2638 one of the input types converts to.
2639 3) arithmetic candidates. According to the standard, we should generate
2640 all of these, but I'm trying not to...
2642 Here we generate a superset of the possible candidates for this particular
2643 case. That is a subset of the full set the standard defines, plus some
2644 other cases which the standard disallows. add_builtin_candidate will
2645 filter out the invalid set. */
2648 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2649 enum tree_code code2, tree fnname, tree *args,
2654 tree type, argtypes[3], t;
2655 /* TYPES[i] is the set of possible builtin-operator parameter types
2656 we will consider for the Ith argument. */
2657 VEC(tree,gc) *types[2];
2660 for (i = 0; i < 3; ++i)
2663 argtypes[i] = unlowered_expr_type (args[i]);
2665 argtypes[i] = NULL_TREE;
2670 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2671 and VQ is either volatile or empty, there exist candidate operator
2672 functions of the form
2673 VQ T& operator++(VQ T&); */
2675 case POSTINCREMENT_EXPR:
2676 case PREINCREMENT_EXPR:
2677 case POSTDECREMENT_EXPR:
2678 case PREDECREMENT_EXPR:
2683 /* 24There also exist candidate operator functions of the form
2684 bool operator!(bool);
2685 bool operator&&(bool, bool);
2686 bool operator||(bool, bool); */
2688 case TRUTH_NOT_EXPR:
2689 build_builtin_candidate
2690 (candidates, fnname, boolean_type_node,
2691 NULL_TREE, args, argtypes, flags);
2694 case TRUTH_ORIF_EXPR:
2695 case TRUTH_ANDIF_EXPR:
2696 build_builtin_candidate
2697 (candidates, fnname, boolean_type_node,
2698 boolean_type_node, args, argtypes, flags);
2720 types[0] = make_tree_vector ();
2721 types[1] = make_tree_vector ();
2723 for (i = 0; i < 2; ++i)
2727 else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2731 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2734 convs = lookup_conversions (argtypes[i]);
2736 if (code == COND_EXPR)
2738 if (real_lvalue_p (args[i]))
2739 VEC_safe_push (tree, gc, types[i],
2740 build_reference_type (argtypes[i]));
2742 VEC_safe_push (tree, gc, types[i],
2743 TYPE_MAIN_VARIANT (argtypes[i]));
2749 for (; convs; convs = TREE_CHAIN (convs))
2751 type = TREE_TYPE (convs);
2754 && (TREE_CODE (type) != REFERENCE_TYPE
2755 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2758 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2759 VEC_safe_push (tree, gc, types[i], type);
2761 type = non_reference (type);
2762 if (i != 0 || ! ref1)
2764 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2765 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2766 VEC_safe_push (tree, gc, types[i], type);
2767 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2768 type = type_promotes_to (type);
2771 if (! vec_member (type, types[i]))
2772 VEC_safe_push (tree, gc, types[i], type);
2777 if (code == COND_EXPR && real_lvalue_p (args[i]))
2778 VEC_safe_push (tree, gc, types[i],
2779 build_reference_type (argtypes[i]));
2780 type = non_reference (argtypes[i]);
2781 if (i != 0 || ! ref1)
2783 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2784 if (enum_p && UNSCOPED_ENUM_P (type))
2785 VEC_safe_push (tree, gc, types[i], type);
2786 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2787 type = type_promotes_to (type);
2789 VEC_safe_push (tree, gc, types[i], type);
2793 /* Run through the possible parameter types of both arguments,
2794 creating candidates with those parameter types. */
2795 FOR_EACH_VEC_ELT_REVERSE (tree, types[0], ix, t)
2800 if (!VEC_empty (tree, types[1]))
2801 FOR_EACH_VEC_ELT_REVERSE (tree, types[1], jx, u)
2802 add_builtin_candidate
2803 (candidates, code, code2, fnname, t,
2804 u, args, argtypes, flags);
2806 add_builtin_candidate
2807 (candidates, code, code2, fnname, t,
2808 NULL_TREE, args, argtypes, flags);
2811 release_tree_vector (types[0]);
2812 release_tree_vector (types[1]);
2816 /* If TMPL can be successfully instantiated as indicated by
2817 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2819 TMPL is the template. EXPLICIT_TARGS are any explicit template
2820 arguments. ARGLIST is the arguments provided at the call-site.
2821 This does not change ARGLIST. The RETURN_TYPE is the desired type
2822 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2823 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2824 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2826 static struct z_candidate*
2827 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2828 tree ctype, tree explicit_targs, tree first_arg,
2829 const VEC(tree,gc) *arglist, tree return_type,
2830 tree access_path, tree conversion_path,
2831 int flags, tree obj, unification_kind_t strict)
2833 int ntparms = DECL_NTPARMS (tmpl);
2834 tree targs = make_tree_vec (ntparms);
2835 unsigned int len = VEC_length (tree, arglist);
2836 unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2837 unsigned int skip_without_in_chrg = 0;
2838 tree first_arg_without_in_chrg = first_arg;
2839 tree *args_without_in_chrg;
2840 unsigned int nargs_without_in_chrg;
2841 unsigned int ia, ix;
2843 struct z_candidate *cand;
2846 struct rejection_reason *reason = NULL;
2848 /* We don't do deduction on the in-charge parameter, the VTT
2849 parameter or 'this'. */
2850 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2852 if (first_arg_without_in_chrg != NULL_TREE)
2853 first_arg_without_in_chrg = NULL_TREE;
2855 ++skip_without_in_chrg;
2858 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2859 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2860 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2862 if (first_arg_without_in_chrg != NULL_TREE)
2863 first_arg_without_in_chrg = NULL_TREE;
2865 ++skip_without_in_chrg;
2868 if (len < skip_without_in_chrg)
2871 nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2872 + (len - skip_without_in_chrg));
2873 args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2875 if (first_arg_without_in_chrg != NULL_TREE)
2877 args_without_in_chrg[ia] = first_arg_without_in_chrg;
2880 for (ix = skip_without_in_chrg;
2881 VEC_iterate (tree, arglist, ix, arg);
2884 args_without_in_chrg[ia] = arg;
2887 gcc_assert (ia == nargs_without_in_chrg);
2889 i = fn_type_unification (tmpl, explicit_targs, targs,
2890 args_without_in_chrg,
2891 nargs_without_in_chrg,
2892 return_type, strict, flags);
2897 fn = instantiate_template (tmpl, targs, tf_none);
2898 if (fn == error_mark_node)
2903 A member function template is never instantiated to perform the
2904 copy of a class object to an object of its class type.
2906 It's a little unclear what this means; the standard explicitly
2907 does allow a template to be used to copy a class. For example,
2912 template <class T> A(const T&);
2915 void g () { A a (f ()); }
2917 the member template will be used to make the copy. The section
2918 quoted above appears in the paragraph that forbids constructors
2919 whose only parameter is (a possibly cv-qualified variant of) the
2920 class type, and a logical interpretation is that the intent was
2921 to forbid the instantiation of member templates which would then
2923 if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2925 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2926 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2931 if (obj != NULL_TREE)
2932 /* Aha, this is a conversion function. */
2933 cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2934 access_path, conversion_path);
2936 cand = add_function_candidate (candidates, fn, ctype,
2937 first_arg, arglist, access_path,
2938 conversion_path, flags);
2939 if (DECL_TI_TEMPLATE (fn) != tmpl)
2940 /* This situation can occur if a member template of a template
2941 class is specialized. Then, instantiate_template might return
2942 an instantiation of the specialization, in which case the
2943 DECL_TI_TEMPLATE field will point at the original
2944 specialization. For example:
2946 template <class T> struct S { template <class U> void f(U);
2947 template <> void f(int) {}; };
2951 Here, TMPL will be template <class U> S<double>::f(U).
2952 And, instantiate template will give us the specialization
2953 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2954 for this will point at template <class T> template <> S<T>::f(int),
2955 so that we can find the definition. For the purposes of
2956 overload resolution, however, we want the original TMPL. */
2957 cand->template_decl = build_template_info (tmpl, targs);
2959 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2960 cand->explicit_targs = explicit_targs;
2964 return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2965 access_path, conversion_path, 0, reason);
2969 static struct z_candidate *
2970 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2971 tree explicit_targs, tree first_arg,
2972 const VEC(tree,gc) *arglist, tree return_type,
2973 tree access_path, tree conversion_path, int flags,
2974 unification_kind_t strict)
2977 add_template_candidate_real (candidates, tmpl, ctype,
2978 explicit_targs, first_arg, arglist,
2979 return_type, access_path, conversion_path,
2980 flags, NULL_TREE, strict);
2984 static struct z_candidate *
2985 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2986 tree obj, tree first_arg,
2987 const VEC(tree,gc) *arglist,
2988 tree return_type, tree access_path,
2989 tree conversion_path)
2992 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2993 first_arg, arglist, return_type, access_path,
2994 conversion_path, 0, obj, DEDUCE_CONV);
2997 /* The CANDS are the set of candidates that were considered for
2998 overload resolution. Return the set of viable candidates, or CANDS
2999 if none are viable. If any of the candidates were viable, set
3000 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3001 considered viable only if it is strictly viable. */
3003 static struct z_candidate*
3004 splice_viable (struct z_candidate *cands,
3008 struct z_candidate *viable;
3009 struct z_candidate **last_viable;
3010 struct z_candidate **cand;
3013 last_viable = &viable;
3014 *any_viable_p = false;
3019 struct z_candidate *c = *cand;
3020 if (strict_p ? c->viable == 1 : c->viable)
3025 last_viable = &c->next;
3026 *any_viable_p = true;
3032 return viable ? viable : cands;
3036 any_strictly_viable (struct z_candidate *cands)
3038 for (; cands; cands = cands->next)
3039 if (cands->viable == 1)
3044 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3045 words, it is about to become the "this" pointer for a member
3046 function call. Take the address of the object. */
3049 build_this (tree obj)
3051 /* In a template, we are only concerned about the type of the
3052 expression, so we can take a shortcut. */
3053 if (processing_template_decl)
3054 return build_address (obj);
3056 return cp_build_addr_expr (obj, tf_warning_or_error);
3059 /* Returns true iff functions are equivalent. Equivalent functions are
3060 not '==' only if one is a function-local extern function or if
3061 both are extern "C". */
3064 equal_functions (tree fn1, tree fn2)
3066 if (TREE_CODE (fn1) != TREE_CODE (fn2))
3068 if (TREE_CODE (fn1) == TEMPLATE_DECL)
3070 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
3071 || DECL_EXTERN_C_FUNCTION_P (fn1))
3072 return decls_match (fn1, fn2);
3076 /* Print information about a candidate being rejected due to INFO. */
3079 print_conversion_rejection (location_t loc, struct conversion_info *info)
3081 if (info->n_arg == -1)
3082 /* Conversion of implicit `this' argument failed. */
3083 inform (loc, " no known conversion for implicit "
3084 "%<this%> parameter from %qT to %qT",
3085 info->from_type, info->to_type);
3087 inform (loc, " no known conversion for argument %d from %qT to %qT",
3088 info->n_arg+1, info->from_type, info->to_type);
3091 /* Print information about one overload candidate CANDIDATE. MSGSTR
3092 is the text to print before the candidate itself.
3094 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3095 to have been run through gettext by the caller. This wart makes
3096 life simpler in print_z_candidates and for the translators. */
3099 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
3101 const char *msg = (msgstr == NULL
3103 : ACONCAT ((msgstr, " ", NULL)));
3104 location_t loc = location_of (candidate->fn);
3106 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
3108 if (candidate->num_convs == 3)
3109 inform (input_location, "%s%D(%T, %T, %T) <built-in>", msg, candidate->fn,
3110 candidate->convs[0]->type,
3111 candidate->convs[1]->type,
3112 candidate->convs[2]->type);
3113 else if (candidate->num_convs == 2)
3114 inform (input_location, "%s%D(%T, %T) <built-in>", msg, candidate->fn,
3115 candidate->convs[0]->type,
3116 candidate->convs[1]->type);
3118 inform (input_location, "%s%D(%T) <built-in>", msg, candidate->fn,
3119 candidate->convs[0]->type);
3121 else if (TYPE_P (candidate->fn))
3122 inform (input_location, "%s%T <conversion>", msg, candidate->fn);
3123 else if (candidate->viable == -1)
3124 inform (loc, "%s%#D <near match>", msg, candidate->fn);
3125 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
3126 inform (loc, "%s%#D <deleted>", msg, candidate->fn);
3128 inform (loc, "%s%#D", msg, candidate->fn);
3129 /* Give the user some information about why this candidate failed. */
3130 if (candidate->reason != NULL)
3132 struct rejection_reason *r = candidate->reason;
3137 inform_n (loc, r->u.arity.expected,
3138 " candidate expects %d argument, %d provided",
3139 " candidate expects %d arguments, %d provided",
3140 r->u.arity.expected, r->u.arity.actual);
3142 case rr_arg_conversion:
3143 print_conversion_rejection (loc, &r->u.conversion);
3145 case rr_bad_arg_conversion:
3146 print_conversion_rejection (loc, &r->u.bad_conversion);
3150 /* This candidate didn't have any issues or we failed to
3151 handle a particular code. Either way... */
3158 print_z_candidates (location_t loc, struct z_candidate *candidates)
3160 struct z_candidate *cand1;
3161 struct z_candidate **cand2;
3167 /* Remove non-viable deleted candidates. */
3169 for (cand2 = &cand1; *cand2; )
3171 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
3172 && !(*cand2)->viable
3173 && DECL_DELETED_FN ((*cand2)->fn))
3174 *cand2 = (*cand2)->next;
3176 cand2 = &(*cand2)->next;
3178 /* ...if there are any non-deleted ones. */
3182 /* There may be duplicates in the set of candidates. We put off
3183 checking this condition as long as possible, since we have no way
3184 to eliminate duplicates from a set of functions in less than n^2
3185 time. Now we are about to emit an error message, so it is more
3186 permissible to go slowly. */
3187 for (cand1 = candidates; cand1; cand1 = cand1->next)
3189 tree fn = cand1->fn;
3190 /* Skip builtin candidates and conversion functions. */
3193 cand2 = &cand1->next;
3196 if (DECL_P ((*cand2)->fn)
3197 && equal_functions (fn, (*cand2)->fn))
3198 *cand2 = (*cand2)->next;
3200 cand2 = &(*cand2)->next;
3204 for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next)
3207 inform_n (loc, n_candidates, "candidate is:", "candidates are:");
3208 for (; candidates; candidates = candidates->next)
3209 print_z_candidate (NULL, candidates);
3212 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3213 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3214 the result of the conversion function to convert it to the final
3215 desired type. Merge the two sequences into a single sequence,
3216 and return the merged sequence. */
3219 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
3223 gcc_assert (user_seq->kind == ck_user);
3225 /* Find the end of the second conversion sequence. */
3227 while ((*t)->kind != ck_identity)
3228 t = &((*t)->u.next);
3230 /* Replace the identity conversion with the user conversion
3234 /* The entire sequence is a user-conversion sequence. */
3235 std_seq->user_conv_p = true;
3240 /* Handle overload resolution for initializing an object of class type from
3241 an initializer list. First we look for a suitable constructor that
3242 takes a std::initializer_list; if we don't find one, we then look for a
3243 non-list constructor.
3245 Parameters are as for add_candidates, except that the arguments are in
3246 the form of a CONSTRUCTOR (the initializer list) rather than a VEC, and
3247 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3250 add_list_candidates (tree fns, tree first_arg,
3251 tree init_list, tree totype,
3252 tree explicit_targs, bool template_only,
3253 tree conversion_path, tree access_path,
3255 struct z_candidate **candidates)
3259 gcc_assert (*candidates == NULL);
3261 /* For list-initialization we consider explicit constructors, but
3262 give an error if one is selected. */
3263 flags &= ~LOOKUP_ONLYCONVERTING;
3264 /* And we don't allow narrowing conversions. We also use this flag to
3265 avoid the copy constructor call for copy-list-initialization. */
3266 flags |= LOOKUP_NO_NARROWING;
3268 /* Always use the default constructor if the list is empty (DR 990). */
3269 if (CONSTRUCTOR_NELTS (init_list) == 0
3270 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
3272 /* If the class has a list ctor, try passing the list as a single
3273 argument first, but only consider list ctors. */
3274 else if (TYPE_HAS_LIST_CTOR (totype))
3276 flags |= LOOKUP_LIST_ONLY;
3277 args = make_tree_vector_single (init_list);
3278 add_candidates (fns, first_arg, args, NULL_TREE,
3279 explicit_targs, template_only, conversion_path,
3280 access_path, flags, candidates);
3281 if (any_strictly_viable (*candidates))
3285 args = ctor_to_vec (init_list);
3287 /* We aren't looking for list-ctors anymore. */
3288 flags &= ~LOOKUP_LIST_ONLY;
3289 /* We allow more user-defined conversions within an init-list. */
3290 flags &= ~LOOKUP_NO_CONVERSION;
3291 /* But not for the copy ctor. */
3292 flags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
3294 add_candidates (fns, first_arg, args, NULL_TREE,
3295 explicit_targs, template_only, conversion_path,
3296 access_path, flags, candidates);
3299 /* Returns the best overload candidate to perform the requested
3300 conversion. This function is used for three the overloading situations
3301 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3302 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
3303 per [dcl.init.ref], so we ignore temporary bindings. */
3305 static struct z_candidate *
3306 build_user_type_conversion_1 (tree totype, tree expr, int flags)
3308 struct z_candidate *candidates, *cand;
3309 tree fromtype = TREE_TYPE (expr);
3310 tree ctors = NULL_TREE;
3311 tree conv_fns = NULL_TREE;
3312 conversion *conv = NULL;
3313 tree first_arg = NULL_TREE;
3314 VEC(tree,gc) *args = NULL;
3318 /* We represent conversion within a hierarchy using RVALUE_CONV and
3319 BASE_CONV, as specified by [over.best.ics]; these become plain
3320 constructor calls, as specified in [dcl.init]. */
3321 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
3322 || !DERIVED_FROM_P (totype, fromtype));
3324 if (MAYBE_CLASS_TYPE_P (totype))
3325 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3326 creating a garbage BASELINK; constructors can't be inherited. */
3327 ctors = lookup_fnfields_slot (totype, complete_ctor_identifier);
3329 if (MAYBE_CLASS_TYPE_P (fromtype))
3331 tree to_nonref = non_reference (totype);
3332 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
3333 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
3334 && DERIVED_FROM_P (to_nonref, fromtype)))
3336 /* [class.conv.fct] A conversion function is never used to
3337 convert a (possibly cv-qualified) object to the (possibly
3338 cv-qualified) same object type (or a reference to it), to a
3339 (possibly cv-qualified) base class of that type (or a
3340 reference to it)... */
3343 conv_fns = lookup_conversions (fromtype);
3347 flags |= LOOKUP_NO_CONVERSION;
3348 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3349 flags |= LOOKUP_NO_NARROWING;
3351 /* It's OK to bind a temporary for converting constructor arguments, but
3352 not in converting the return value of a conversion operator. */
3353 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
3354 flags &= ~LOOKUP_NO_TEMP_BIND;
3358 int ctorflags = flags;
3360 first_arg = build_int_cst (build_pointer_type (totype), 0);
3362 /* We should never try to call the abstract or base constructor
3364 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
3365 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
3367 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3369 /* List-initialization. */
3370 add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
3371 false, TYPE_BINFO (totype), TYPE_BINFO (totype),
3372 ctorflags, &candidates);
3376 args = make_tree_vector_single (expr);
3377 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
3378 TYPE_BINFO (totype), TYPE_BINFO (totype),
3379 ctorflags, &candidates);
3382 for (cand = candidates; cand; cand = cand->next)
3384 cand->second_conv = build_identity_conv (totype, NULL_TREE);
3386 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3387 set, then this is copy-initialization. In that case, "The
3388 result of the call is then used to direct-initialize the
3389 object that is the destination of the copy-initialization."
3392 We represent this in the conversion sequence with an
3393 rvalue conversion, which means a constructor call. */
3394 if (TREE_CODE (totype) != REFERENCE_TYPE
3395 && !(convflags & LOOKUP_NO_TEMP_BIND))
3397 = build_conv (ck_rvalue, totype, cand->second_conv);
3402 first_arg = build_this (expr);
3404 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3406 tree conversion_path = TREE_PURPOSE (conv_fns);
3407 struct z_candidate *old_candidates;
3409 /* If we are called to convert to a reference type, we are trying to
3410 find an lvalue binding, so don't even consider temporaries. If
3411 we don't find an lvalue binding, the caller will try again to
3412 look for a temporary binding. */
3413 if (TREE_CODE (totype) == REFERENCE_TYPE)
3414 convflags |= LOOKUP_NO_TEMP_BIND;
3416 old_candidates = candidates;
3417 add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3419 conversion_path, TYPE_BINFO (fromtype),
3420 flags, &candidates);
3422 for (cand = candidates; cand != old_candidates; cand = cand->next)
3425 = implicit_conversion (totype,
3426 TREE_TYPE (TREE_TYPE (cand->fn)),
3428 /*c_cast_p=*/false, convflags);
3430 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3431 copy-initialization. In that case, "The result of the
3432 call is then used to direct-initialize the object that is
3433 the destination of the copy-initialization." [dcl.init]
3435 We represent this in the conversion sequence with an
3436 rvalue conversion, which means a constructor call. But
3437 don't add a second rvalue conversion if there's already
3438 one there. Which there really shouldn't be, but it's
3439 harmless since we'd add it here anyway. */
3440 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3441 && !(convflags & LOOKUP_NO_TEMP_BIND))
3442 ics = build_conv (ck_rvalue, totype, ics);
3444 cand->second_conv = ics;
3448 tree rettype = TREE_TYPE (TREE_TYPE (cand->fn));
3450 cand->reason = arg_conversion_rejection (NULL_TREE, -1,
3453 else if (cand->viable == 1 && ics->bad_p)
3455 tree rettype = TREE_TYPE (TREE_TYPE (cand->fn));
3458 = bad_arg_conversion_rejection (NULL_TREE, -1,
3464 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3468 release_tree_vector (args);
3472 cand = tourney (candidates);
3475 if (flags & LOOKUP_COMPLAIN)
3477 error ("conversion from %qT to %qT is ambiguous",
3479 print_z_candidates (location_of (expr), candidates);
3482 cand = candidates; /* any one will do */
3483 cand->second_conv = build_ambiguous_conv (totype, expr);
3484 cand->second_conv->user_conv_p = true;
3485 if (!any_strictly_viable (candidates))
3486 cand->second_conv->bad_p = true;
3487 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3488 ambiguous conversion is no worse than another user-defined
3494 /* Build the user conversion sequence. */
3497 (DECL_CONSTRUCTOR_P (cand->fn)
3498 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3499 build_identity_conv (TREE_TYPE (expr), expr));
3502 /* Remember that this was a list-initialization. */
3503 if (flags & LOOKUP_NO_NARROWING)
3504 conv->check_narrowing = true;
3506 /* Combine it with the second conversion sequence. */
3507 cand->second_conv = merge_conversion_sequences (conv,
3510 if (cand->viable == -1)
3511 cand->second_conv->bad_p = true;
3516 /* Wrapper for above. */
3519 build_user_type_conversion (tree totype, tree expr, int flags)
3521 struct z_candidate *cand;
3524 timevar_start (TV_OVERLOAD);
3525 cand = build_user_type_conversion_1 (totype, expr, flags);
3529 if (cand->second_conv->kind == ck_ambig)
3530 ret = error_mark_node;
3533 expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3534 ret = convert_from_reference (expr);
3540 timevar_stop (TV_OVERLOAD);
3544 /* Subroutine of convert_nontype_argument.
3546 EXPR is an argument for a template non-type parameter of integral or
3547 enumeration type. Do any necessary conversions (that are permitted for
3548 non-type arguments) to convert it to the parameter type.
3550 If conversion is successful, returns the converted expression;
3551 otherwise, returns error_mark_node. */
3554 build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain)
3560 if (error_operand_p (expr))
3561 return error_mark_node;
3563 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3565 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3566 p = conversion_obstack_alloc (0);
3568 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
3572 /* for a non-type template-parameter of integral or
3573 enumeration type, integral promotions (4.5) and integral
3574 conversions (4.7) are applied. */
3575 /* It should be sufficient to check the outermost conversion step, since
3576 there are no qualification conversions to integer type. */
3580 /* A conversion function is OK. If it isn't constexpr, we'll
3581 complain later that the argument isn't constant. */
3583 /* The lvalue-to-rvalue conversion is OK. */
3589 t = conv->u.next->type;
3590 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
3593 if (complain & tf_error)
3594 error ("conversion from %qT to %qT not considered for "
3595 "non-type template argument", t, type);
3596 /* and fall through. */
3604 expr = convert_like (conv, expr, complain);
3606 expr = error_mark_node;
3608 /* Free all the conversions we allocated. */
3609 obstack_free (&conversion_obstack, p);
3614 /* Do any initial processing on the arguments to a function call. */
3616 static VEC(tree,gc) *
3617 resolve_args (VEC(tree,gc) *args, tsubst_flags_t complain)
3622 FOR_EACH_VEC_ELT (tree, args, ix, arg)
3624 if (error_operand_p (arg))
3626 else if (VOID_TYPE_P (TREE_TYPE (arg)))
3628 if (complain & tf_error)
3629 error ("invalid use of void expression");
3632 else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3638 /* Perform overload resolution on FN, which is called with the ARGS.
3640 Return the candidate function selected by overload resolution, or
3641 NULL if the event that overload resolution failed. In the case
3642 that overload resolution fails, *CANDIDATES will be the set of
3643 candidates considered, and ANY_VIABLE_P will be set to true or
3644 false to indicate whether or not any of the candidates were
3647 The ARGS should already have gone through RESOLVE_ARGS before this
3648 function is called. */
3650 static struct z_candidate *
3651 perform_overload_resolution (tree fn,
3652 const VEC(tree,gc) *args,
3653 struct z_candidate **candidates,
3656 struct z_candidate *cand;
3657 tree explicit_targs;
3660 bool subtime = timevar_cond_start (TV_OVERLOAD);
3662 explicit_targs = NULL_TREE;
3666 *any_viable_p = true;
3669 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3670 || TREE_CODE (fn) == TEMPLATE_DECL
3671 || TREE_CODE (fn) == OVERLOAD
3672 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3674 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3676 explicit_targs = TREE_OPERAND (fn, 1);
3677 fn = TREE_OPERAND (fn, 0);
3681 /* Add the various candidate functions. */
3682 add_candidates (fn, NULL_TREE, args, NULL_TREE,
3683 explicit_targs, template_only,
3684 /*conversion_path=*/NULL_TREE,
3685 /*access_path=*/NULL_TREE,
3689 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3691 cand = tourney (*candidates);
3695 timevar_cond_stop (TV_OVERLOAD, subtime);
3699 /* Print an error message about being unable to build a call to FN with
3700 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
3701 be located; CANDIDATES is a possibly empty list of such
3705 print_error_for_call_failure (tree fn, VEC(tree,gc) *args, bool any_viable_p,
3706 struct z_candidate *candidates)
3708 tree name = DECL_NAME (OVL_CURRENT (fn));
3709 location_t loc = location_of (name);
3712 error_at (loc, "no matching function for call to %<%D(%A)%>",
3713 name, build_tree_list_vec (args));
3715 error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous",
3716 name, build_tree_list_vec (args));
3718 print_z_candidates (loc, candidates);
3721 /* Return an expression for a call to FN (a namespace-scope function,
3722 or a static member function) with the ARGS. This may change
3726 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3727 tsubst_flags_t complain)
3729 struct z_candidate *candidates, *cand;
3734 if (args != NULL && *args != NULL)
3736 *args = resolve_args (*args, complain);
3738 return error_mark_node;
3741 /* If this function was found without using argument dependent
3742 lookup, then we want to ignore any undeclared friend
3748 fn = remove_hidden_names (fn);
3751 if (complain & tf_error)
3752 print_error_for_call_failure (orig_fn, *args, false, NULL);
3753 return error_mark_node;
3757 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3758 p = conversion_obstack_alloc (0);
3760 cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3764 if (complain & tf_error)
3766 if (!any_viable_p && candidates && ! candidates->next
3767 && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3768 return cp_build_function_call_vec (candidates->fn, args, complain);
3769 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3770 fn = TREE_OPERAND (fn, 0);
3771 print_error_for_call_failure (fn, *args, any_viable_p, candidates);
3773 result = error_mark_node;
3777 int flags = LOOKUP_NORMAL;
3778 /* If fn is template_id_expr, the call has explicit template arguments
3779 (e.g. func<int>(5)), communicate this info to build_over_call
3780 through flags so that later we can use it to decide whether to warn
3781 about peculiar null pointer conversion. */
3782 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3783 flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
3784 result = build_over_call (cand, flags, complain);
3787 /* Free all the conversions we allocated. */
3788 obstack_free (&conversion_obstack, p);
3793 /* Build a call to a global operator new. FNNAME is the name of the
3794 operator (either "operator new" or "operator new[]") and ARGS are
3795 the arguments provided. This may change ARGS. *SIZE points to the
3796 total number of bytes required by the allocation, and is updated if
3797 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3798 be used. If this function determines that no cookie should be
3799 used, after all, *COOKIE_SIZE is set to NULL_TREE. If FN is
3800 non-NULL, it will be set, upon return, to the allocation function
3804 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3805 tree *size, tree *cookie_size,
3809 struct z_candidate *candidates;
3810 struct z_candidate *cand;
3815 VEC_safe_insert (tree, gc, *args, 0, *size);
3816 *args = resolve_args (*args, tf_warning_or_error);
3818 return error_mark_node;
3824 If this lookup fails to find the name, or if the allocated type
3825 is not a class type, the allocation function's name is looked
3826 up in the global scope.
3828 we disregard block-scope declarations of "operator new". */
3829 fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3831 /* Figure out what function is being called. */
3832 cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3834 /* If no suitable function could be found, issue an error message
3838 print_error_for_call_failure (fns, *args, any_viable_p, candidates);
3839 return error_mark_node;
3842 /* If a cookie is required, add some extra space. Whether
3843 or not a cookie is required cannot be determined until
3844 after we know which function was called. */
3847 bool use_cookie = true;
3848 if (!abi_version_at_least (2))
3850 /* In G++ 3.2, the check was implemented incorrectly; it
3851 looked at the placement expression, rather than the
3852 type of the function. */
3853 if (VEC_length (tree, *args) == 2
3854 && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3862 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3863 /* Skip the size_t parameter. */
3864 arg_types = TREE_CHAIN (arg_types);
3865 /* Check the remaining parameters (if any). */
3867 && TREE_CHAIN (arg_types) == void_list_node
3868 && same_type_p (TREE_VALUE (arg_types),
3872 /* If we need a cookie, adjust the number of bytes allocated. */
3875 /* Update the total size. */
3876 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3877 /* Update the argument list to reflect the adjusted size. */
3878 VEC_replace (tree, *args, 0, *size);
3881 *cookie_size = NULL_TREE;
3884 /* Tell our caller which function we decided to call. */
3888 /* Build the CALL_EXPR. */
3889 return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3892 /* Build a new call to operator(). This may change ARGS. */
3895 build_op_call_1 (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3897 struct z_candidate *candidates = 0, *cand;
3898 tree fns, convs, first_mem_arg = NULL_TREE;
3899 tree type = TREE_TYPE (obj);
3901 tree result = NULL_TREE;
3904 if (error_operand_p (obj))
3905 return error_mark_node;
3907 obj = prep_operand (obj);
3909 if (TYPE_PTRMEMFUNC_P (type))
3911 if (complain & tf_error)
3912 /* It's no good looking for an overloaded operator() on a
3913 pointer-to-member-function. */
3914 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3915 return error_mark_node;
3918 if (TYPE_BINFO (type))
3920 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3921 if (fns == error_mark_node)
3922 return error_mark_node;
3927 if (args != NULL && *args != NULL)
3929 *args = resolve_args (*args, complain);
3931 return error_mark_node;
3934 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3935 p = conversion_obstack_alloc (0);
3939 first_mem_arg = build_this (obj);
3941 add_candidates (BASELINK_FUNCTIONS (fns),
3942 first_mem_arg, *args, NULL_TREE,
3944 BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
3945 LOOKUP_NORMAL, &candidates);
3948 convs = lookup_conversions (type);
3950 for (; convs; convs = TREE_CHAIN (convs))
3952 tree fns = TREE_VALUE (convs);
3953 tree totype = TREE_TYPE (convs);
3955 if ((TREE_CODE (totype) == POINTER_TYPE
3956 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3957 || (TREE_CODE (totype) == REFERENCE_TYPE
3958 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3959 || (TREE_CODE (totype) == REFERENCE_TYPE
3960 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3961 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3962 for (; fns; fns = OVL_NEXT (fns))
3964 tree fn = OVL_CURRENT (fns);
3966 if (DECL_NONCONVERTING_P (fn))
3969 if (TREE_CODE (fn) == TEMPLATE_DECL)
3970 add_template_conv_candidate
3971 (&candidates, fn, obj, NULL_TREE, *args, totype,
3972 /*access_path=*/NULL_TREE,
3973 /*conversion_path=*/NULL_TREE);
3975 add_conv_candidate (&candidates, fn, obj, NULL_TREE,
3976 *args, /*conversion_path=*/NULL_TREE,
3977 /*access_path=*/NULL_TREE);
3981 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3984 if (complain & tf_error)
3986 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
3987 build_tree_list_vec (*args));
3988 print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
3990 result = error_mark_node;
3994 cand = tourney (candidates);
3997 if (complain & tf_error)
3999 error ("call of %<(%T) (%A)%> is ambiguous",
4000 TREE_TYPE (obj), build_tree_list_vec (*args));
4001 print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4003 result = error_mark_node;
4005 /* Since cand->fn will be a type, not a function, for a conversion
4006 function, we must be careful not to unconditionally look at
4008 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
4009 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
4010 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4013 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
4015 obj = convert_from_reference (obj);
4016 result = cp_build_function_call_vec (obj, args, complain);
4020 /* Free all the conversions we allocated. */
4021 obstack_free (&conversion_obstack, p);
4026 /* Wrapper for above. */
4029 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
4032 timevar_start (TV_OVERLOAD);
4033 ret = build_op_call_1 (obj, args, complain);
4034 timevar_stop (TV_OVERLOAD);
4039 op_error (enum tree_code code, enum tree_code code2,
4040 tree arg1, tree arg2, tree arg3, bool match)
4044 if (code == MODIFY_EXPR)
4045 opname = assignment_operator_name_info[code2].name;
4047 opname = operator_name_info[code].name;
4053 error ("ambiguous overload for ternary %<operator?:%> "
4054 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
4056 error ("no match for ternary %<operator?:%> "
4057 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
4060 case POSTINCREMENT_EXPR:
4061 case POSTDECREMENT_EXPR:
4063 error ("ambiguous overload for %<operator%s%> in %<%E%s%>",
4064 opname, arg1, opname);
4066 error ("no match for %<operator%s%> in %<%E%s%>",
4067 opname, arg1, opname);
4072 error ("ambiguous overload for %<operator[]%> in %<%E[%E]%>",
4075 error ("no match for %<operator[]%> in %<%E[%E]%>",
4082 error ("ambiguous overload for %qs in %<%s %E%>",
4083 opname, opname, arg1);
4085 error ("no match for %qs in %<%s %E%>",
4086 opname, opname, arg1);
4092 error ("ambiguous overload for %<operator%s%> in %<%E %s %E%>",
4093 opname, arg1, opname, arg2);
4095 error ("no match for %<operator%s%> in %<%E %s %E%>",
4096 opname, arg1, opname, arg2);
4099 error ("ambiguous overload for %<operator%s%> in %<%s%E%>",
4100 opname, opname, arg1);
4102 error ("no match for %<operator%s%> in %<%s%E%>",
4103 opname, opname, arg1);
4108 /* Return the implicit conversion sequence that could be used to
4109 convert E1 to E2 in [expr.cond]. */
4112 conditional_conversion (tree e1, tree e2)
4114 tree t1 = non_reference (TREE_TYPE (e1));
4115 tree t2 = non_reference (TREE_TYPE (e2));
4121 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4122 implicitly converted (clause _conv_) to the type "reference to
4123 T2", subject to the constraint that in the conversion the
4124 reference must bind directly (_dcl.init.ref_) to E1. */
4125 if (real_lvalue_p (e2))
4127 conv = implicit_conversion (build_reference_type (t2),
4131 LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING);
4138 If E1 and E2 have class type, and the underlying class types are
4139 the same or one is a base class of the other: E1 can be converted
4140 to match E2 if the class of T2 is the same type as, or a base
4141 class of, the class of T1, and the cv-qualification of T2 is the
4142 same cv-qualification as, or a greater cv-qualification than, the
4143 cv-qualification of T1. If the conversion is applied, E1 is
4144 changed to an rvalue of type T2 that still refers to the original
4145 source class object (or the appropriate subobject thereof). */
4146 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
4147 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
4149 if (good_base && at_least_as_qualified_p (t2, t1))
4151 conv = build_identity_conv (t1, e1);
4152 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
4153 TYPE_MAIN_VARIANT (t2)))
4154 conv = build_conv (ck_base, t2, conv);
4156 conv = build_conv (ck_rvalue, t2, conv);
4165 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4166 converted to the type that expression E2 would have if E2 were
4167 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4168 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
4172 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4173 arguments to the conditional expression. */
4176 build_conditional_expr_1 (tree arg1, tree arg2, tree arg3,
4177 tsubst_flags_t complain)
4181 tree result = NULL_TREE;
4182 tree result_type = NULL_TREE;
4183 bool lvalue_p = true;
4184 struct z_candidate *candidates = 0;
4185 struct z_candidate *cand;
4188 /* As a G++ extension, the second argument to the conditional can be
4189 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4190 c'.) If the second operand is omitted, make sure it is
4191 calculated only once. */
4194 if (complain & tf_error)
4195 pedwarn (input_location, OPT_pedantic,
4196 "ISO C++ forbids omitting the middle term of a ?: expression");
4198 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4199 if (real_lvalue_p (arg1))
4200 arg2 = arg1 = stabilize_reference (arg1);
4202 arg2 = arg1 = save_expr (arg1);
4207 The first expression is implicitly converted to bool (clause
4209 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
4212 /* If something has already gone wrong, just pass that fact up the
4214 if (error_operand_p (arg1)
4215 || error_operand_p (arg2)
4216 || error_operand_p (arg3))
4217 return error_mark_node;
4221 If either the second or the third operand has type (possibly
4222 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4223 array-to-pointer (_conv.array_), and function-to-pointer
4224 (_conv.func_) standard conversions are performed on the second
4225 and third operands. */
4226 arg2_type = unlowered_expr_type (arg2);
4227 arg3_type = unlowered_expr_type (arg3);
4228 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
4230 /* Do the conversions. We don't these for `void' type arguments
4231 since it can't have any effect and since decay_conversion
4232 does not handle that case gracefully. */
4233 if (!VOID_TYPE_P (arg2_type))
4234 arg2 = decay_conversion (arg2);
4235 if (!VOID_TYPE_P (arg3_type))
4236 arg3 = decay_conversion (arg3);
4237 arg2_type = TREE_TYPE (arg2);
4238 arg3_type = TREE_TYPE (arg3);
4242 One of the following shall hold:
4244 --The second or the third operand (but not both) is a
4245 throw-expression (_except.throw_); the result is of the
4246 type of the other and is an rvalue.
4248 --Both the second and the third operands have type void; the
4249 result is of type void and is an rvalue.
4251 We must avoid calling force_rvalue for expressions of type
4252 "void" because it will complain that their value is being
4254 if (TREE_CODE (arg2) == THROW_EXPR
4255 && TREE_CODE (arg3) != THROW_EXPR)
4257 if (!VOID_TYPE_P (arg3_type))
4259 arg3 = force_rvalue (arg3, complain);
4260 if (arg3 == error_mark_node)
4261 return error_mark_node;
4263 arg3_type = TREE_TYPE (arg3);
4264 result_type = arg3_type;
4266 else if (TREE_CODE (arg2) != THROW_EXPR
4267 && TREE_CODE (arg3) == THROW_EXPR)
4269 if (!VOID_TYPE_P (arg2_type))
4271 arg2 = force_rvalue (arg2, complain);
4272 if (arg2 == error_mark_node)
4273 return error_mark_node;
4275 arg2_type = TREE_TYPE (arg2);
4276 result_type = arg2_type;
4278 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
4279 result_type = void_type_node;
4282 if (complain & tf_error)
4284 if (VOID_TYPE_P (arg2_type))
4285 error ("second operand to the conditional operator "
4286 "is of type %<void%>, "
4287 "but the third operand is neither a throw-expression "
4288 "nor of type %<void%>");
4290 error ("third operand to the conditional operator "
4291 "is of type %<void%>, "
4292 "but the second operand is neither a throw-expression "
4293 "nor of type %<void%>");
4295 return error_mark_node;
4299 goto valid_operands;
4303 Otherwise, if the second and third operand have different types,
4304 and either has (possibly cv-qualified) class type, an attempt is
4305 made to convert each of those operands to the type of the other. */
4306 else if (!same_type_p (arg2_type, arg3_type)
4307 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
4312 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4313 p = conversion_obstack_alloc (0);
4315 conv2 = conditional_conversion (arg2, arg3);
4316 conv3 = conditional_conversion (arg3, arg2);
4320 If both can be converted, or one can be converted but the
4321 conversion is ambiguous, the program is ill-formed. If
4322 neither can be converted, the operands are left unchanged and
4323 further checking is performed as described below. If exactly
4324 one conversion is possible, that conversion is applied to the
4325 chosen operand and the converted operand is used in place of
4326 the original operand for the remainder of this section. */
4327 if ((conv2 && !conv2->bad_p
4328 && conv3 && !conv3->bad_p)
4329 || (conv2 && conv2->kind == ck_ambig)
4330 || (conv3 && conv3->kind == ck_ambig))
4332 error ("operands to ?: have different types %qT and %qT",
4333 arg2_type, arg3_type);
4334 result = error_mark_node;
4336 else if (conv2 && (!conv2->bad_p || !conv3))
4338 arg2 = convert_like (conv2, arg2, complain);
4339 arg2 = convert_from_reference (arg2);
4340 arg2_type = TREE_TYPE (arg2);
4341 /* Even if CONV2 is a valid conversion, the result of the
4342 conversion may be invalid. For example, if ARG3 has type
4343 "volatile X", and X does not have a copy constructor
4344 accepting a "volatile X&", then even if ARG2 can be
4345 converted to X, the conversion will fail. */
4346 if (error_operand_p (arg2))
4347 result = error_mark_node;
4349 else if (conv3 && (!conv3->bad_p || !conv2))
4351 arg3 = convert_like (conv3, arg3, complain);
4352 arg3 = convert_from_reference (arg3);
4353 arg3_type = TREE_TYPE (arg3);
4354 if (error_operand_p (arg3))
4355 result = error_mark_node;
4358 /* Free all the conversions we allocated. */
4359 obstack_free (&conversion_obstack, p);
4364 /* If, after the conversion, both operands have class type,
4365 treat the cv-qualification of both operands as if it were the
4366 union of the cv-qualification of the operands.
4368 The standard is not clear about what to do in this
4369 circumstance. For example, if the first operand has type
4370 "const X" and the second operand has a user-defined
4371 conversion to "volatile X", what is the type of the second
4372 operand after this step? Making it be "const X" (matching
4373 the first operand) seems wrong, as that discards the
4374 qualification without actually performing a copy. Leaving it
4375 as "volatile X" seems wrong as that will result in the
4376 conditional expression failing altogether, even though,
4377 according to this step, the one operand could be converted to
4378 the type of the other. */
4379 if ((conv2 || conv3)
4380 && CLASS_TYPE_P (arg2_type)
4381 && cp_type_quals (arg2_type) != cp_type_quals (arg3_type))
4382 arg2_type = arg3_type =
4383 cp_build_qualified_type (arg2_type,
4384 cp_type_quals (arg2_type)
4385 | cp_type_quals (arg3_type));
4390 If the second and third operands are lvalues and have the same
4391 type, the result is of that type and is an lvalue. */
4392 if (real_lvalue_p (arg2)
4393 && real_lvalue_p (arg3)
4394 && same_type_p (arg2_type, arg3_type))
4396 result_type = arg2_type;
4397 arg2 = mark_lvalue_use (arg2);
4398 arg3 = mark_lvalue_use (arg3);
4399 goto valid_operands;
4404 Otherwise, the result is an rvalue. If the second and third
4405 operand do not have the same type, and either has (possibly
4406 cv-qualified) class type, overload resolution is used to
4407 determine the conversions (if any) to be applied to the operands
4408 (_over.match.oper_, _over.built_). */
4410 if (!same_type_p (arg2_type, arg3_type)
4411 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
4417 /* Rearrange the arguments so that add_builtin_candidate only has
4418 to know about two args. In build_builtin_candidate, the
4419 arguments are unscrambled. */
4423 add_builtin_candidates (&candidates,
4426 ansi_opname (COND_EXPR),
4432 If the overload resolution fails, the program is
4434 candidates = splice_viable (candidates, pedantic, &any_viable_p);
4437 if (complain & tf_error)
4439 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
4440 print_z_candidates (location_of (arg1), candidates);
4442 return error_mark_node;
4444 cand = tourney (candidates);
4447 if (complain & tf_error)
4449 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
4450 print_z_candidates (location_of (arg1), candidates);
4452 return error_mark_node;
4457 Otherwise, the conversions thus determined are applied, and
4458 the converted operands are used in place of the original
4459 operands for the remainder of this section. */
4460 conv = cand->convs[0];
4461 arg1 = convert_like (conv, arg1, complain);
4462 conv = cand->convs[1];
4463 arg2 = convert_like (conv, arg2, complain);
4464 arg2_type = TREE_TYPE (arg2);
4465 conv = cand->convs[2];
4466 arg3 = convert_like (conv, arg3, complain);
4467 arg3_type = TREE_TYPE (arg3);
4472 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
4473 and function-to-pointer (_conv.func_) standard conversions are
4474 performed on the second and third operands.
4476 We need to force the lvalue-to-rvalue conversion here for class types,
4477 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
4478 that isn't wrapped with a TARGET_EXPR plays havoc with exception
4481 arg2 = force_rvalue (arg2, complain);
4482 if (!CLASS_TYPE_P (arg2_type))
4483 arg2_type = TREE_TYPE (arg2);
4485 arg3 = force_rvalue (arg3, complain);
4486 if (!CLASS_TYPE_P (arg3_type))
4487 arg3_type = TREE_TYPE (arg3);
4489 if (arg2 == error_mark_node || arg3 == error_mark_node)
4490 return error_mark_node;
4494 After those conversions, one of the following shall hold:
4496 --The second and third operands have the same type; the result is of
4498 if (same_type_p (arg2_type, arg3_type))
4499 result_type = arg2_type;
4502 --The second and third operands have arithmetic or enumeration
4503 type; the usual arithmetic conversions are performed to bring
4504 them to a common type, and the result is of that type. */
4505 else if ((ARITHMETIC_TYPE_P (arg2_type)
4506 || UNSCOPED_ENUM_P (arg2_type))
4507 && (ARITHMETIC_TYPE_P (arg3_type)
4508 || UNSCOPED_ENUM_P (arg3_type)))
4510 /* In this case, there is always a common type. */
4511 result_type = type_after_usual_arithmetic_conversions (arg2_type,
4513 do_warn_double_promotion (result_type, arg2_type, arg3_type,
4514 "implicit conversion from %qT to %qT to "
4515 "match other result of conditional",
4518 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
4519 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
4521 if (complain & tf_warning)
4523 "enumeral mismatch in conditional expression: %qT vs %qT",
4524 arg2_type, arg3_type);
4526 else if (extra_warnings
4527 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
4528 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
4529 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
4530 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
4532 if (complain & tf_warning)
4534 "enumeral and non-enumeral type in conditional expression");
4537 arg2 = perform_implicit_conversion (result_type, arg2, complain);
4538 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4542 --The second and third operands have pointer type, or one has
4543 pointer type and the other is a null pointer constant; pointer
4544 conversions (_conv.ptr_) and qualification conversions
4545 (_conv.qual_) are performed to bring them to their composite
4546 pointer type (_expr.rel_). The result is of the composite
4549 --The second and third operands have pointer to member type, or
4550 one has pointer to member type and the other is a null pointer
4551 constant; pointer to member conversions (_conv.mem_) and
4552 qualification conversions (_conv.qual_) are performed to bring
4553 them to a common type, whose cv-qualification shall match the
4554 cv-qualification of either the second or the third operand.
4555 The result is of the common type. */
4556 else if ((null_ptr_cst_p (arg2)
4557 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
4558 || (null_ptr_cst_p (arg3)
4559 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
4560 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
4561 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
4562 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
4564 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
4565 arg3, CPO_CONDITIONAL_EXPR,
4567 if (result_type == error_mark_node)
4568 return error_mark_node;
4569 arg2 = perform_implicit_conversion (result_type, arg2, complain);
4570 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4575 if (complain & tf_error)
4576 error ("operands to ?: have different types %qT and %qT",
4577 arg2_type, arg3_type);
4578 return error_mark_node;
4582 result = build3 (COND_EXPR, result_type, arg1, arg2, arg3);
4583 if (!cp_unevaluated_operand)
4584 /* Avoid folding within decltype (c++/42013) and noexcept. */
4585 result = fold_if_not_in_template (result);
4587 /* We can't use result_type below, as fold might have returned a
4592 /* Expand both sides into the same slot, hopefully the target of
4593 the ?: expression. We used to check for TARGET_EXPRs here,
4594 but now we sometimes wrap them in NOP_EXPRs so the test would
4596 if (CLASS_TYPE_P (TREE_TYPE (result)))
4597 result = get_target_expr (result);
4598 /* If this expression is an rvalue, but might be mistaken for an
4599 lvalue, we must add a NON_LVALUE_EXPR. */
4600 result = rvalue (result);
4606 /* Wrapper for above. */
4609 build_conditional_expr (tree arg1, tree arg2, tree arg3,
4610 tsubst_flags_t complain)
4613 bool subtime = timevar_cond_start (TV_OVERLOAD);
4614 ret = build_conditional_expr_1 (arg1, arg2, arg3, complain);
4615 timevar_cond_stop (TV_OVERLOAD, subtime);
4619 /* OPERAND is an operand to an expression. Perform necessary steps
4620 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4624 prep_operand (tree operand)
4628 if (CLASS_TYPE_P (TREE_TYPE (operand))
4629 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
4630 /* Make sure the template type is instantiated now. */
4631 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
4637 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4638 OVERLOAD) to the CANDIDATES, returning an updated list of
4639 CANDIDATES. The ARGS are the arguments provided to the call;
4640 if FIRST_ARG is non-null it is the implicit object argument,
4641 otherwise the first element of ARGS is used if needed. The
4642 EXPLICIT_TARGS are explicit template arguments provided.
4643 TEMPLATE_ONLY is true if only template functions should be
4644 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4645 add_function_candidate. */
4648 add_candidates (tree fns, tree first_arg, const VEC(tree,gc) *args,
4650 tree explicit_targs, bool template_only,
4651 tree conversion_path, tree access_path,
4653 struct z_candidate **candidates)
4656 const VEC(tree,gc) *non_static_args;
4657 bool check_list_ctor;
4658 bool check_converting;
4659 unification_kind_t strict;
4665 /* Precalculate special handling of constructors and conversion ops. */
4666 fn = OVL_CURRENT (fns);
4667 if (DECL_CONV_FN_P (fn))
4669 check_list_ctor = false;
4670 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4671 if (flags & LOOKUP_NO_CONVERSION)
4672 /* We're doing return_type(x). */
4673 strict = DEDUCE_CONV;
4675 /* We're doing x.operator return_type(). */
4676 strict = DEDUCE_EXACT;
4677 /* [over.match.funcs] For conversion functions, the function
4678 is considered to be a member of the class of the implicit
4679 object argument for the purpose of defining the type of
4680 the implicit object parameter. */
4681 ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
4685 if (DECL_CONSTRUCTOR_P (fn))
4687 check_list_ctor = !!(flags & LOOKUP_LIST_ONLY);
4688 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4692 check_list_ctor = false;
4693 check_converting = false;
4695 strict = DEDUCE_CALL;
4696 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
4700 non_static_args = args;
4702 /* Delay creating the implicit this parameter until it is needed. */
4703 non_static_args = NULL;
4705 for (; fns; fns = OVL_NEXT (fns))
4708 const VEC(tree,gc) *fn_args;
4710 fn = OVL_CURRENT (fns);
4712 if (check_converting && DECL_NONCONVERTING_P (fn))
4714 if (check_list_ctor && !is_list_ctor (fn))
4717 /* Figure out which set of arguments to use. */
4718 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
4720 /* If this function is a non-static member and we didn't get an
4721 implicit object argument, move it out of args. */
4722 if (first_arg == NULL_TREE)
4726 VEC(tree,gc) *tempvec
4727 = VEC_alloc (tree, gc, VEC_length (tree, args) - 1);
4728 for (ix = 1; VEC_iterate (tree, args, ix, arg); ++ix)
4729 VEC_quick_push (tree, tempvec, arg);
4730 non_static_args = tempvec;
4731 first_arg = build_this (VEC_index (tree, args, 0));
4734 fn_first_arg = first_arg;
4735 fn_args = non_static_args;
4739 /* Otherwise, just use the list of arguments provided. */
4740 fn_first_arg = NULL_TREE;
4744 if (TREE_CODE (fn) == TEMPLATE_DECL)
4745 add_template_candidate (candidates,
4756 else if (!template_only)
4757 add_function_candidate (candidates,
4768 /* Even unsigned enum types promote to signed int. We don't want to
4769 issue -Wsign-compare warnings for this case. Here ORIG_ARG is the
4770 original argument and ARG is the argument after any conversions
4771 have been applied. We set TREE_NO_WARNING if we have added a cast
4772 from an unsigned enum type to a signed integer type. */
4775 avoid_sign_compare_warnings (tree orig_arg, tree arg)
4777 if (orig_arg != NULL_TREE
4780 && TREE_CODE (TREE_TYPE (orig_arg)) == ENUMERAL_TYPE
4781 && TYPE_UNSIGNED (TREE_TYPE (orig_arg))
4782 && INTEGRAL_TYPE_P (TREE_TYPE (arg))
4783 && !TYPE_UNSIGNED (TREE_TYPE (arg)))
4784 TREE_NO_WARNING (arg) = 1;
4788 build_new_op_1 (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
4789 bool *overloaded_p, tsubst_flags_t complain)
4791 tree orig_arg1 = arg1;
4792 tree orig_arg2 = arg2;
4793 tree orig_arg3 = arg3;
4794 struct z_candidate *candidates = 0, *cand;
4795 VEC(tree,gc) *arglist;
4798 tree result = NULL_TREE;
4799 bool result_valid_p = false;
4800 enum tree_code code2 = NOP_EXPR;
4801 enum tree_code code_orig_arg1 = ERROR_MARK;
4802 enum tree_code code_orig_arg2 = ERROR_MARK;
4808 if (error_operand_p (arg1)
4809 || error_operand_p (arg2)
4810 || error_operand_p (arg3))
4811 return error_mark_node;
4813 if (code == MODIFY_EXPR)
4815 code2 = TREE_CODE (arg3);
4817 fnname = ansi_assopname (code2);
4820 fnname = ansi_opname (code);
4822 arg1 = prep_operand (arg1);
4828 case VEC_DELETE_EXPR:
4830 /* Use build_op_new_call and build_op_delete_call instead. */
4834 /* Use build_op_call instead. */
4837 case TRUTH_ORIF_EXPR:
4838 case TRUTH_ANDIF_EXPR:
4839 case TRUTH_AND_EXPR:
4841 /* These are saved for the sake of warn_logical_operator. */
4842 code_orig_arg1 = TREE_CODE (arg1);
4843 code_orig_arg2 = TREE_CODE (arg2);
4849 arg2 = prep_operand (arg2);
4850 arg3 = prep_operand (arg3);
4852 if (code == COND_EXPR)
4853 /* Use build_conditional_expr instead. */
4855 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4856 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4859 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4860 arg2 = integer_zero_node;
4862 arglist = VEC_alloc (tree, gc, 3);
4863 VEC_quick_push (tree, arglist, arg1);
4864 if (arg2 != NULL_TREE)
4865 VEC_quick_push (tree, arglist, arg2);
4866 if (arg3 != NULL_TREE)
4867 VEC_quick_push (tree, arglist, arg3);
4869 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4870 p = conversion_obstack_alloc (0);
4872 /* Add namespace-scope operators to the list of functions to
4874 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
4875 NULL_TREE, arglist, NULL_TREE,
4876 NULL_TREE, false, NULL_TREE, NULL_TREE,
4877 flags, &candidates);
4878 /* Add class-member operators to the candidate set. */
4879 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
4883 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
4884 if (fns == error_mark_node)
4886 result = error_mark_node;
4887 goto user_defined_result_ready;
4890 add_candidates (BASELINK_FUNCTIONS (fns),
4891 NULL_TREE, arglist, NULL_TREE,
4893 BASELINK_BINFO (fns),
4894 BASELINK_ACCESS_BINFO (fns),
4895 flags, &candidates);
4900 args[2] = NULL_TREE;
4902 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
4908 /* For these, the built-in candidates set is empty
4909 [over.match.oper]/3. We don't want non-strict matches
4910 because exact matches are always possible with built-in
4911 operators. The built-in candidate set for COMPONENT_REF
4912 would be empty too, but since there are no such built-in
4913 operators, we accept non-strict matches for them. */
4918 strict_p = pedantic;
4922 candidates = splice_viable (candidates, strict_p, &any_viable_p);
4927 case POSTINCREMENT_EXPR:
4928 case POSTDECREMENT_EXPR:
4929 /* Don't try anything fancy if we're not allowed to produce
4931 if (!(complain & tf_error))
4932 return error_mark_node;
4934 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
4935 distinguish between prefix and postfix ++ and
4936 operator++() was used for both, so we allow this with
4938 if (flags & LOOKUP_COMPLAIN)
4940 const char *msg = (flag_permissive)
4941 ? G_("no %<%D(int)%> declared for postfix %qs,"
4942 " trying prefix operator instead")
4943 : G_("no %<%D(int)%> declared for postfix %qs");
4944 permerror (input_location, msg, fnname,
4945 operator_name_info[code].name);
4948 if (!flag_permissive)
4949 return error_mark_node;
4951 if (code == POSTINCREMENT_EXPR)
4952 code = PREINCREMENT_EXPR;
4954 code = PREDECREMENT_EXPR;
4955 result = build_new_op_1 (code, flags, arg1, NULL_TREE, NULL_TREE,
4956 overloaded_p, complain);
4959 /* The caller will deal with these. */
4964 result_valid_p = true;
4968 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4970 /* If one of the arguments of the operator represents
4971 an invalid use of member function pointer, try to report
4972 a meaningful error ... */
4973 if (invalid_nonstatic_memfn_p (arg1, tf_error)
4974 || invalid_nonstatic_memfn_p (arg2, tf_error)
4975 || invalid_nonstatic_memfn_p (arg3, tf_error))
4976 /* We displayed the error message. */;
4979 /* ... Otherwise, report the more generic
4980 "no matching operator found" error */
4981 op_error (code, code2, arg1, arg2, arg3, FALSE);
4982 print_z_candidates (input_location, candidates);
4985 result = error_mark_node;
4991 cand = tourney (candidates);
4994 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4996 op_error (code, code2, arg1, arg2, arg3, TRUE);
4997 print_z_candidates (input_location, candidates);
4999 result = error_mark_node;
5001 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
5004 *overloaded_p = true;
5006 if (resolve_args (arglist, complain) == NULL)
5007 result = error_mark_node;
5009 result = build_over_call (cand, LOOKUP_NORMAL, complain);
5013 /* Give any warnings we noticed during overload resolution. */
5014 if (cand->warnings && (complain & tf_warning))
5016 struct candidate_warning *w;
5017 for (w = cand->warnings; w; w = w->next)
5018 joust (cand, w->loser, 1);
5021 /* Check for comparison of different enum types. */
5030 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
5031 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
5032 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
5033 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
5034 && (complain & tf_warning))
5036 warning (OPT_Wenum_compare,
5037 "comparison between %q#T and %q#T",
5038 TREE_TYPE (arg1), TREE_TYPE (arg2));
5045 /* We need to strip any leading REF_BIND so that bitfields
5046 don't cause errors. This should not remove any important
5047 conversions, because builtins don't apply to class
5048 objects directly. */
5049 conv = cand->convs[0];
5050 if (conv->kind == ck_ref_bind)
5051 conv = conv->u.next;
5052 arg1 = convert_like (conv, arg1, complain);
5056 /* We need to call warn_logical_operator before
5057 converting arg2 to a boolean_type. */
5058 if (complain & tf_warning)
5059 warn_logical_operator (input_location, code, boolean_type_node,
5060 code_orig_arg1, arg1,
5061 code_orig_arg2, arg2);
5063 conv = cand->convs[1];
5064 if (conv->kind == ck_ref_bind)
5065 conv = conv->u.next;
5066 arg2 = convert_like (conv, arg2, complain);
5070 conv = cand->convs[2];
5071 if (conv->kind == ck_ref_bind)
5072 conv = conv->u.next;
5073 arg3 = convert_like (conv, arg3, complain);
5079 user_defined_result_ready:
5081 /* Free all the conversions we allocated. */
5082 obstack_free (&conversion_obstack, p);
5084 if (result || result_valid_p)
5088 avoid_sign_compare_warnings (orig_arg1, arg1);
5089 avoid_sign_compare_warnings (orig_arg2, arg2);
5090 avoid_sign_compare_warnings (orig_arg3, arg3);
5095 return cp_build_modify_expr (arg1, code2, arg2, complain);
5098 return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
5100 case TRUTH_ANDIF_EXPR:
5101 case TRUTH_ORIF_EXPR:
5102 case TRUTH_AND_EXPR:
5104 warn_logical_operator (input_location, code, boolean_type_node,
5105 code_orig_arg1, arg1, code_orig_arg2, arg2);
5110 case TRUNC_DIV_EXPR:
5121 case TRUNC_MOD_EXPR:
5125 return cp_build_binary_op (input_location, code, arg1, arg2, complain);
5127 case UNARY_PLUS_EXPR:
5130 case TRUTH_NOT_EXPR:
5131 case PREINCREMENT_EXPR:
5132 case POSTINCREMENT_EXPR:
5133 case PREDECREMENT_EXPR:
5134 case POSTDECREMENT_EXPR:
5137 return cp_build_unary_op (code, arg1, candidates != 0, complain);
5140 return cp_build_array_ref (input_location, arg1, arg2, complain);
5143 return build_m_component_ref (cp_build_indirect_ref (arg1, RO_NULL,
5147 /* The caller will deal with these. */
5159 /* Wrapper for above. */
5162 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
5163 bool *overloaded_p, tsubst_flags_t complain)
5166 bool subtime = timevar_cond_start (TV_OVERLOAD);
5167 ret = build_new_op_1 (code, flags, arg1, arg2, arg3, overloaded_p, complain);
5168 timevar_cond_stop (TV_OVERLOAD, subtime);
5172 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5173 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5176 non_placement_deallocation_fn_p (tree t)
5178 /* A template instance is never a usual deallocation function,
5179 regardless of its signature. */
5180 if (TREE_CODE (t) == TEMPLATE_DECL
5181 || primary_template_instantiation_p (t))
5184 /* If a class T has a member deallocation function named operator delete
5185 with exactly one parameter, then that function is a usual
5186 (non-placement) deallocation function. If class T does not declare
5187 such an operator delete but does declare a member deallocation
5188 function named operator delete with exactly two parameters, the second
5189 of which has type std::size_t (18.2), then this function is a usual
5190 deallocation function. */
5191 t = FUNCTION_ARG_CHAIN (t);
5192 if (t == void_list_node
5193 || (t && same_type_p (TREE_VALUE (t), size_type_node)
5194 && TREE_CHAIN (t) == void_list_node))
5199 /* Build a call to operator delete. This has to be handled very specially,
5200 because the restrictions on what signatures match are different from all
5201 other call instances. For a normal delete, only a delete taking (void *)
5202 or (void *, size_t) is accepted. For a placement delete, only an exact
5203 match with the placement new is accepted.
5205 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5206 ADDR is the pointer to be deleted.
5207 SIZE is the size of the memory block to be deleted.
5208 GLOBAL_P is true if the delete-expression should not consider
5209 class-specific delete operators.
5210 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5212 If this call to "operator delete" is being generated as part to
5213 deallocate memory allocated via a new-expression (as per [expr.new]
5214 which requires that if the initialization throws an exception then
5215 we call a deallocation function), then ALLOC_FN is the allocation
5219 build_op_delete_call (enum tree_code code, tree addr, tree size,
5220 bool global_p, tree placement,
5223 tree fn = NULL_TREE;
5224 tree fns, fnname, type, t;
5226 if (addr == error_mark_node)
5227 return error_mark_node;
5229 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
5231 fnname = ansi_opname (code);
5233 if (CLASS_TYPE_P (type)
5234 && COMPLETE_TYPE_P (complete_type (type))
5238 If the result of the lookup is ambiguous or inaccessible, or if
5239 the lookup selects a placement deallocation function, the
5240 program is ill-formed.
5242 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5244 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
5245 if (fns == error_mark_node)
5246 return error_mark_node;
5251 if (fns == NULL_TREE)
5252 fns = lookup_name_nonclass (fnname);
5254 /* Strip const and volatile from addr. */
5255 addr = cp_convert (ptr_type_node, addr);
5259 /* "A declaration of a placement deallocation function matches the
5260 declaration of a placement allocation function if it has the same
5261 number of parameters and, after parameter transformations (8.3.5),
5262 all parameter types except the first are identical."
5264 So we build up the function type we want and ask instantiate_type
5265 to get it for us. */
5266 t = FUNCTION_ARG_CHAIN (alloc_fn);
5267 t = tree_cons (NULL_TREE, ptr_type_node, t);
5268 t = build_function_type (void_type_node, t);
5270 fn = instantiate_type (t, fns, tf_none);
5271 if (fn == error_mark_node)
5274 if (BASELINK_P (fn))
5275 fn = BASELINK_FUNCTIONS (fn);
5277 /* "If the lookup finds the two-parameter form of a usual deallocation
5278 function (3.7.4.2) and that function, considered as a placement
5279 deallocation function, would have been selected as a match for the
5280 allocation function, the program is ill-formed." */
5281 if (non_placement_deallocation_fn_p (fn))
5283 /* But if the class has an operator delete (void *), then that is
5284 the usual deallocation function, so we shouldn't complain
5285 about using the operator delete (void *, size_t). */
5286 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
5287 t; t = OVL_NEXT (t))
5289 tree elt = OVL_CURRENT (t);
5290 if (non_placement_deallocation_fn_p (elt)
5291 && FUNCTION_ARG_CHAIN (elt) == void_list_node)
5294 permerror (0, "non-placement deallocation function %q+D", fn);
5295 permerror (input_location, "selected for placement delete");
5300 /* "Any non-placement deallocation function matches a non-placement
5301 allocation function. If the lookup finds a single matching
5302 deallocation function, that function will be called; otherwise, no
5303 deallocation function will be called." */
5304 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
5305 t; t = OVL_NEXT (t))
5307 tree elt = OVL_CURRENT (t);
5308 if (non_placement_deallocation_fn_p (elt))
5311 /* "If a class T has a member deallocation function named
5312 operator delete with exactly one parameter, then that
5313 function is a usual (non-placement) deallocation
5314 function. If class T does not declare such an operator
5315 delete but does declare a member deallocation function named
5316 operator delete with exactly two parameters, the second of
5317 which has type std::size_t (18.2), then this function is a
5318 usual deallocation function."
5320 So (void*) beats (void*, size_t). */
5321 if (FUNCTION_ARG_CHAIN (fn) == void_list_node)
5326 /* If we have a matching function, call it. */
5329 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
5331 /* If the FN is a member function, make sure that it is
5333 if (BASELINK_P (fns))
5334 perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn);
5336 /* Core issue 901: It's ok to new a type with deleted delete. */
5337 if (DECL_DELETED_FN (fn) && alloc_fn)
5342 /* The placement args might not be suitable for overload
5343 resolution at this point, so build the call directly. */
5344 int nargs = call_expr_nargs (placement);
5345 tree *argarray = XALLOCAVEC (tree, nargs);
5348 for (i = 1; i < nargs; i++)
5349 argarray[i] = CALL_EXPR_ARG (placement, i);
5351 return build_cxx_call (fn, nargs, argarray);
5356 VEC(tree,gc) *args = VEC_alloc (tree, gc, 2);
5357 VEC_quick_push (tree, args, addr);
5358 if (FUNCTION_ARG_CHAIN (fn) != void_list_node)
5359 VEC_quick_push (tree, args, size);
5360 ret = cp_build_function_call_vec (fn, &args, tf_warning_or_error);
5361 VEC_free (tree, gc, args);
5368 If no unambiguous matching deallocation function can be found,
5369 propagating the exception does not cause the object's memory to
5374 warning (0, "no corresponding deallocation function for %qD",
5379 error ("no suitable %<operator %s%> for %qT",
5380 operator_name_info[(int)code].name, type);
5381 return error_mark_node;
5384 /* If the current scope isn't allowed to access DECL along
5385 BASETYPE_PATH, give an error. The most derived class in
5386 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
5387 the declaration to use in the error diagnostic. */
5390 enforce_access (tree basetype_path, tree decl, tree diag_decl)
5392 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
5394 if (!accessible_p (basetype_path, decl, true))
5396 if (TREE_PRIVATE (decl))
5397 error ("%q+#D is private", diag_decl);
5398 else if (TREE_PROTECTED (decl))
5399 error ("%q+#D is protected", diag_decl);
5401 error ("%q+#D is inaccessible", diag_decl);
5402 error ("within this context");
5409 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
5410 bitwise or of LOOKUP_* values. If any errors are warnings are
5411 generated, set *DIAGNOSTIC_FN to "error" or "warning",
5412 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
5416 build_temp (tree expr, tree type, int flags,
5417 diagnostic_t *diagnostic_kind, tsubst_flags_t complain)
5422 savew = warningcount, savee = errorcount;
5423 args = make_tree_vector_single (expr);
5424 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
5425 &args, type, flags, complain);
5426 release_tree_vector (args);
5427 if (warningcount > savew)
5428 *diagnostic_kind = DK_WARNING;
5429 else if (errorcount > savee)
5430 *diagnostic_kind = DK_ERROR;
5432 *diagnostic_kind = DK_UNSPECIFIED;
5436 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
5437 EXPR is implicitly converted to type TOTYPE.
5438 FN and ARGNUM are used for diagnostics. */
5441 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
5443 tree t = non_reference (totype);
5445 /* Issue warnings about peculiar, but valid, uses of NULL. */
5446 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
5449 warning_at (input_location, OPT_Wconversion_null,
5450 "passing NULL to non-pointer argument %P of %qD",
5453 warning_at (input_location, OPT_Wconversion_null,
5454 "converting to non-pointer type %qT from NULL", t);
5457 /* Issue warnings if "false" is converted to a NULL pointer */
5458 else if (expr == boolean_false_node && POINTER_TYPE_P (t))
5461 warning_at (input_location, OPT_Wconversion_null,
5462 "converting %<false%> to pointer type for argument %P "
5463 "of %qD", argnum, fn);
5465 warning_at (input_location, OPT_Wconversion_null,
5466 "converting %<false%> to pointer type %qT", t);
5470 /* Perform the conversions in CONVS on the expression EXPR. FN and
5471 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
5472 indicates the `this' argument of a method. INNER is nonzero when
5473 being called to continue a conversion chain. It is negative when a
5474 reference binding will be applied, positive otherwise. If
5475 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
5476 conversions will be emitted if appropriate. If C_CAST_P is true,
5477 this conversion is coming from a C-style cast; in that case,
5478 conversions to inaccessible bases are permitted. */
5481 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
5482 int inner, bool issue_conversion_warnings,
5483 bool c_cast_p, tsubst_flags_t complain)
5485 tree totype = convs->type;
5486 diagnostic_t diag_kind;
5490 && convs->kind != ck_user
5491 && convs->kind != ck_list
5492 && convs->kind != ck_ambig
5493 && convs->kind != ck_ref_bind
5494 && convs->kind != ck_rvalue
5495 && convs->kind != ck_base)
5497 conversion *t = convs;
5499 /* Give a helpful error if this is bad because of excess braces. */
5500 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
5501 && SCALAR_TYPE_P (totype)
5502 && CONSTRUCTOR_NELTS (expr) > 0
5503 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
5504 permerror (input_location, "too many braces around initializer for %qT", totype);
5506 for (; t; t = convs->u.next)
5508 if (t->kind == ck_user || !t->bad_p)
5510 expr = convert_like_real (t, expr, fn, argnum, 1,
5511 /*issue_conversion_warnings=*/false,
5516 else if (t->kind == ck_ambig)
5517 return convert_like_real (t, expr, fn, argnum, 1,
5518 /*issue_conversion_warnings=*/false,
5521 else if (t->kind == ck_identity)
5524 if (complain & tf_error)
5526 permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
5528 permerror (DECL_SOURCE_LOCATION (fn),
5529 " initializing argument %P of %qD", argnum, fn);
5532 return error_mark_node;
5534 return cp_convert (totype, expr);
5537 if (issue_conversion_warnings && (complain & tf_warning))
5538 conversion_null_warnings (totype, expr, fn, argnum);
5540 switch (convs->kind)
5544 struct z_candidate *cand = convs->cand;
5545 tree convfn = cand->fn;
5548 expr = mark_rvalue_use (expr);
5550 /* When converting from an init list we consider explicit
5551 constructors, but actually trying to call one is an error. */
5552 if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn)
5553 /* Unless we're calling it for value-initialization from an
5554 empty list, since that is handled separately in 8.5.4. */
5555 && cand->num_convs > 0)
5557 if (complain & tf_error)
5558 error ("converting to %qT from initializer list would use "
5559 "explicit constructor %qD", totype, convfn);
5561 return error_mark_node;
5564 /* Set user_conv_p on the argument conversions, so rvalue/base
5565 handling knows not to allow any more UDCs. */
5566 for (i = 0; i < cand->num_convs; ++i)
5567 cand->convs[i]->user_conv_p = true;
5569 expr = build_over_call (cand, LOOKUP_NORMAL, complain);
5571 /* If this is a constructor or a function returning an aggr type,
5572 we need to build up a TARGET_EXPR. */
5573 if (DECL_CONSTRUCTOR_P (convfn))
5575 expr = build_cplus_new (totype, expr, complain);
5577 /* Remember that this was list-initialization. */
5578 if (convs->check_narrowing)
5579 TARGET_EXPR_LIST_INIT_P (expr) = true;
5585 expr = mark_rvalue_use (expr);
5586 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
5588 int nelts = CONSTRUCTOR_NELTS (expr);
5590 expr = build_value_init (totype, tf_warning_or_error);
5591 else if (nelts == 1)
5592 expr = CONSTRUCTOR_ELT (expr, 0)->value;
5597 if (type_unknown_p (expr))
5598 expr = instantiate_type (totype, expr, complain);
5599 /* Convert a constant to its underlying value, unless we are
5600 about to bind it to a reference, in which case we need to
5601 leave it as an lvalue. */
5604 expr = decl_constant_value (expr);
5605 if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
5606 /* If __null has been converted to an integer type, we do not
5607 want to warn about uses of EXPR as an integer, rather than
5609 expr = build_int_cst (totype, 0);
5613 if (complain & tf_error)
5615 /* Call build_user_type_conversion again for the error. */
5616 build_user_type_conversion (totype, convs->u.expr, LOOKUP_NORMAL);
5618 error (" initializing argument %P of %q+D", argnum, fn);
5620 return error_mark_node;
5624 /* Conversion to std::initializer_list<T>. */
5625 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
5626 tree new_ctor = build_constructor (init_list_type_node, NULL);
5627 unsigned len = CONSTRUCTOR_NELTS (expr);
5628 tree array, val, field;
5629 VEC(constructor_elt,gc) *vec = NULL;
5632 /* Convert all the elements. */
5633 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
5635 tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
5636 1, false, false, complain);
5637 if (sub == error_mark_node)
5639 if (!BRACE_ENCLOSED_INITIALIZER_P (val))
5640 check_narrowing (TREE_TYPE (sub), val);
5641 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
5642 if (!TREE_CONSTANT (sub))
5643 TREE_CONSTANT (new_ctor) = false;
5645 /* Build up the array. */
5646 elttype = cp_build_qualified_type
5647 (elttype, cp_type_quals (elttype) | TYPE_QUAL_CONST);
5648 array = build_array_of_n_type (elttype, len);
5649 array = finish_compound_literal (array, new_ctor, complain);
5651 /* Build up the initializer_list object. */
5652 totype = complete_type (totype);
5653 field = next_initializable_field (TYPE_FIELDS (totype));
5654 CONSTRUCTOR_APPEND_ELT (vec, field, decay_conversion (array));
5655 field = next_initializable_field (DECL_CHAIN (field));
5656 CONSTRUCTOR_APPEND_ELT (vec, field, size_int (len));
5657 new_ctor = build_constructor (totype, vec);
5658 return get_target_expr (new_ctor);
5662 if (TREE_CODE (totype) == COMPLEX_TYPE)
5664 tree real = CONSTRUCTOR_ELT (expr, 0)->value;
5665 tree imag = CONSTRUCTOR_ELT (expr, 1)->value;
5666 real = perform_implicit_conversion (TREE_TYPE (totype),
5668 imag = perform_implicit_conversion (TREE_TYPE (totype),
5670 expr = build2 (COMPLEX_EXPR, totype, real, imag);
5671 return fold_if_not_in_template (expr);
5673 return get_target_expr (digest_init (totype, expr));
5679 expr = convert_like_real (convs->u.next, expr, fn, argnum,
5680 convs->kind == ck_ref_bind ? -1 : 1,
5681 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
5684 if (expr == error_mark_node)
5685 return error_mark_node;
5687 switch (convs->kind)
5690 expr = decay_conversion (expr);
5691 if (! MAYBE_CLASS_TYPE_P (totype))
5693 /* Else fall through. */
5695 if (convs->kind == ck_base && !convs->need_temporary_p)
5697 /* We are going to bind a reference directly to a base-class
5698 subobject of EXPR. */
5699 /* Build an expression for `*((base*) &expr)'. */
5700 expr = cp_build_addr_expr (expr, complain);
5701 expr = convert_to_base (expr, build_pointer_type (totype),
5702 !c_cast_p, /*nonnull=*/true, complain);
5703 expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
5707 /* Copy-initialization where the cv-unqualified version of the source
5708 type is the same class as, or a derived class of, the class of the
5709 destination [is treated as direct-initialization]. [dcl.init] */
5710 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
5711 if (convs->user_conv_p)
5712 /* This conversion is being done in the context of a user-defined
5713 conversion (i.e. the second step of copy-initialization), so
5714 don't allow any more. */
5715 flags |= LOOKUP_NO_CONVERSION;
5716 if (convs->rvaluedness_matches_p)
5717 flags |= LOOKUP_PREFER_RVALUE;
5718 if (TREE_CODE (expr) == TARGET_EXPR
5719 && TARGET_EXPR_LIST_INIT_P (expr))
5720 /* Copy-list-initialization doesn't actually involve a copy. */
5722 expr = build_temp (expr, totype, flags, &diag_kind, complain);
5723 if (diag_kind && fn)
5725 if ((complain & tf_error))
5726 emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (fn), 0,
5727 " initializing argument %P of %qD", argnum, fn);
5728 else if (diag_kind == DK_ERROR)
5729 return error_mark_node;
5731 return build_cplus_new (totype, expr, complain);
5735 tree ref_type = totype;
5737 if (convs->bad_p && TYPE_REF_IS_RVALUE (ref_type)
5738 && real_lvalue_p (expr))
5740 if (complain & tf_error)
5742 error ("cannot bind %qT lvalue to %qT",
5743 TREE_TYPE (expr), totype);
5745 error (" initializing argument %P of %q+D", argnum, fn);
5747 return error_mark_node;
5750 /* If necessary, create a temporary.
5752 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
5753 that need temporaries, even when their types are reference
5754 compatible with the type of reference being bound, so the
5755 upcoming call to cp_build_addr_expr doesn't fail. */
5756 if (convs->need_temporary_p
5757 || TREE_CODE (expr) == CONSTRUCTOR
5758 || TREE_CODE (expr) == VA_ARG_EXPR)
5760 /* Otherwise, a temporary of type "cv1 T1" is created and
5761 initialized from the initializer expression using the rules
5762 for a non-reference copy-initialization (8.5). */
5764 tree type = TREE_TYPE (ref_type);
5765 cp_lvalue_kind lvalue = real_lvalue_p (expr);
5767 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5768 (type, convs->u.next->type));
5769 if (!CP_TYPE_CONST_NON_VOLATILE_P (type)
5770 && !TYPE_REF_IS_RVALUE (ref_type))
5772 if (complain & tf_error)
5774 /* If the reference is volatile or non-const, we
5775 cannot create a temporary. */
5776 if (lvalue & clk_bitfield)
5777 error ("cannot bind bitfield %qE to %qT",
5779 else if (lvalue & clk_packed)
5780 error ("cannot bind packed field %qE to %qT",
5783 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
5785 return error_mark_node;
5787 /* If the source is a packed field, and we must use a copy
5788 constructor, then building the target expr will require
5789 binding the field to the reference parameter to the
5790 copy constructor, and we'll end up with an infinite
5791 loop. If we can use a bitwise copy, then we'll be
5793 if ((lvalue & clk_packed)
5794 && CLASS_TYPE_P (type)
5795 && type_has_nontrivial_copy_init (type))
5797 if (complain & tf_error)
5798 error ("cannot bind packed field %qE to %qT",
5800 return error_mark_node;
5802 if (lvalue & clk_bitfield)
5804 expr = convert_bitfield_to_declared_type (expr);
5805 expr = fold_convert (type, expr);
5807 expr = build_target_expr_with_type (expr, type, complain);
5810 /* Take the address of the thing to which we will bind the
5812 expr = cp_build_addr_expr (expr, complain);
5813 if (expr == error_mark_node)
5814 return error_mark_node;
5816 /* Convert it to a pointer to the type referred to by the
5817 reference. This will adjust the pointer if a derived to
5818 base conversion is being performed. */
5819 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
5821 /* Convert the pointer to the desired reference type. */
5822 return build_nop (ref_type, expr);
5826 return decay_conversion (expr);
5829 /* Warn about deprecated conversion if appropriate. */
5830 string_conv_p (totype, expr, 1);
5835 expr = convert_to_base (expr, totype, !c_cast_p,
5836 /*nonnull=*/false, complain);
5837 return build_nop (totype, expr);
5840 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
5841 c_cast_p, complain);
5847 if (convs->check_narrowing)
5848 check_narrowing (totype, expr);
5850 if (issue_conversion_warnings && (complain & tf_warning))
5851 expr = convert_and_check (totype, expr);
5853 expr = convert (totype, expr);
5858 /* ARG is being passed to a varargs function. Perform any conversions
5859 required. Return the converted value. */
5862 convert_arg_to_ellipsis (tree arg)
5868 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5869 standard conversions are performed. */
5870 arg = decay_conversion (arg);
5871 arg_type = TREE_TYPE (arg);
5874 If the argument has integral or enumeration type that is subject
5875 to the integral promotions (_conv.prom_), or a floating point
5876 type that is subject to the floating point promotion
5877 (_conv.fpprom_), the value of the argument is converted to the
5878 promoted type before the call. */
5879 if (TREE_CODE (arg_type) == REAL_TYPE
5880 && (TYPE_PRECISION (arg_type)
5881 < TYPE_PRECISION (double_type_node))
5882 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type)))
5884 if (warn_double_promotion && !c_inhibit_evaluation_warnings)
5885 warning (OPT_Wdouble_promotion,
5886 "implicit conversion from %qT to %qT when passing "
5887 "argument to function",
5888 arg_type, double_type_node);
5889 arg = convert_to_real (double_type_node, arg);
5891 else if (NULLPTR_TYPE_P (arg_type))
5892 arg = null_pointer_node;
5893 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type))
5894 arg = perform_integral_promotions (arg);
5896 arg = require_complete_type (arg);
5897 arg_type = TREE_TYPE (arg);
5899 if (arg != error_mark_node
5900 /* In a template (or ill-formed code), we can have an incomplete type
5901 even after require_complete_type, in which case we don't know
5902 whether it has trivial copy or not. */
5903 && COMPLETE_TYPE_P (arg_type)
5904 && (type_has_nontrivial_copy_init (arg_type)
5905 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type)))
5907 /* [expr.call] 5.2.2/7:
5908 Passing a potentially-evaluated argument of class type (Clause 9)
5909 with a non-trivial copy constructor or a non-trivial destructor
5910 with no corresponding parameter is conditionally-supported, with
5911 implementation-defined semantics.
5913 We used to just warn here and do a bitwise copy, but now
5914 cp_expr_size will abort if we try to do that.
5916 If the call appears in the context of a sizeof expression,
5917 it is not potentially-evaluated. */
5918 if (cp_unevaluated_operand == 0)
5919 error ("cannot pass objects of non-trivially-copyable "
5920 "type %q#T through %<...%>", arg_type);
5926 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
5929 build_x_va_arg (tree expr, tree type)
5931 if (processing_template_decl)
5932 return build_min (VA_ARG_EXPR, type, expr);
5934 type = complete_type_or_else (type, NULL_TREE);
5936 if (expr == error_mark_node || !type)
5937 return error_mark_node;
5939 expr = mark_lvalue_use (expr);
5941 if (type_has_nontrivial_copy_init (type)
5942 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5943 || TREE_CODE (type) == REFERENCE_TYPE)
5945 /* Remove reference types so we don't ICE later on. */
5946 tree type1 = non_reference (type);
5947 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
5948 error ("cannot receive objects of non-trivially-copyable type %q#T "
5949 "through %<...%>; ", type);
5950 expr = convert (build_pointer_type (type1), null_node);
5951 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
5955 return build_va_arg (input_location, expr, type);
5958 /* TYPE has been given to va_arg. Apply the default conversions which
5959 would have happened when passed via ellipsis. Return the promoted
5960 type, or the passed type if there is no change. */
5963 cxx_type_promotes_to (tree type)
5967 /* Perform the array-to-pointer and function-to-pointer
5969 type = type_decays_to (type);
5971 promote = type_promotes_to (type);
5972 if (same_type_p (type, promote))
5978 /* ARG is a default argument expression being passed to a parameter of
5979 the indicated TYPE, which is a parameter to FN. PARMNUM is the
5980 zero-based argument number. Do any required conversions. Return
5981 the converted value. */
5983 static GTY(()) VEC(tree,gc) *default_arg_context;
5985 push_defarg_context (tree fn)
5986 { VEC_safe_push (tree, gc, default_arg_context, fn); }
5988 pop_defarg_context (void)
5989 { VEC_pop (tree, default_arg_context); }
5992 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
5997 /* See through clones. */
5998 fn = DECL_ORIGIN (fn);
6000 /* Detect recursion. */
6001 FOR_EACH_VEC_ELT (tree, default_arg_context, i, t)
6004 error ("recursive evaluation of default argument for %q#D", fn);
6005 return error_mark_node;
6008 /* If the ARG is an unparsed default argument expression, the
6009 conversion cannot be performed. */
6010 if (TREE_CODE (arg) == DEFAULT_ARG)
6012 error ("call to %qD uses the default argument for parameter %P, which "
6013 "is not yet defined", fn, parmnum);
6014 return error_mark_node;
6017 push_defarg_context (fn);
6019 if (fn && DECL_TEMPLATE_INFO (fn))
6020 arg = tsubst_default_argument (fn, type, arg);
6026 The names in the expression are bound, and the semantic
6027 constraints are checked, at the point where the default
6028 expressions appears.
6030 we must not perform access checks here. */
6031 push_deferring_access_checks (dk_no_check);
6032 arg = break_out_target_exprs (arg);
6033 if (TREE_CODE (arg) == CONSTRUCTOR)
6035 arg = digest_init (type, arg);
6036 arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT,
6037 ICR_DEFAULT_ARGUMENT, fn, parmnum,
6038 tf_warning_or_error);
6042 /* We must make a copy of ARG, in case subsequent processing
6043 alters any part of it. For example, during gimplification a
6044 cast of the form (T) &X::f (where "f" is a member function)
6045 will lead to replacing the PTRMEM_CST for &X::f with a
6046 VAR_DECL. We can avoid the copy for constants, since they
6047 are never modified in place. */
6048 if (!CONSTANT_CLASS_P (arg))
6049 arg = unshare_expr (arg);
6050 arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT,
6051 ICR_DEFAULT_ARGUMENT, fn, parmnum,
6052 tf_warning_or_error);
6053 arg = convert_for_arg_passing (type, arg);
6055 pop_deferring_access_checks();
6057 pop_defarg_context ();
6062 /* Returns the type which will really be used for passing an argument of
6066 type_passed_as (tree type)
6068 /* Pass classes with copy ctors by invisible reference. */
6069 if (TREE_ADDRESSABLE (type))
6071 type = build_reference_type (type);
6072 /* There are no other pointers to this temporary. */
6073 type = cp_build_qualified_type (type, TYPE_QUAL_RESTRICT);
6075 else if (targetm.calls.promote_prototypes (type)
6076 && INTEGRAL_TYPE_P (type)
6077 && COMPLETE_TYPE_P (type)
6078 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
6079 TYPE_SIZE (integer_type_node)))
6080 type = integer_type_node;
6085 /* Actually perform the appropriate conversion. */
6088 convert_for_arg_passing (tree type, tree val)
6092 /* If VAL is a bitfield, then -- since it has already been converted
6093 to TYPE -- it cannot have a precision greater than TYPE.
6095 If it has a smaller precision, we must widen it here. For
6096 example, passing "int f:3;" to a function expecting an "int" will
6097 not result in any conversion before this point.
6099 If the precision is the same we must not risk widening. For
6100 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6101 often have type "int", even though the C++ type for the field is
6102 "long long". If the value is being passed to a function
6103 expecting an "int", then no conversions will be required. But,
6104 if we call convert_bitfield_to_declared_type, the bitfield will
6105 be converted to "long long". */
6106 bitfield_type = is_bitfield_expr_with_lowered_type (val);
6108 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
6109 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
6111 if (val == error_mark_node)
6113 /* Pass classes with copy ctors by invisible reference. */
6114 else if (TREE_ADDRESSABLE (type))
6115 val = build1 (ADDR_EXPR, build_reference_type (type), val);
6116 else if (targetm.calls.promote_prototypes (type)
6117 && INTEGRAL_TYPE_P (type)
6118 && COMPLETE_TYPE_P (type)
6119 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
6120 TYPE_SIZE (integer_type_node)))
6121 val = perform_integral_promotions (val);
6122 if (warn_missing_format_attribute)
6124 tree rhstype = TREE_TYPE (val);
6125 const enum tree_code coder = TREE_CODE (rhstype);
6126 const enum tree_code codel = TREE_CODE (type);
6127 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6129 && check_missing_format_attribute (type, rhstype))
6130 warning (OPT_Wmissing_format_attribute,
6131 "argument of function call might be a candidate for a format attribute");
6136 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6137 which no conversions at all should be done. This is true for some
6138 builtins which don't act like normal functions. */
6141 magic_varargs_p (tree fn)
6143 if (DECL_BUILT_IN (fn))
6144 switch (DECL_FUNCTION_CODE (fn))
6146 case BUILT_IN_CLASSIFY_TYPE:
6147 case BUILT_IN_CONSTANT_P:
6148 case BUILT_IN_NEXT_ARG:
6149 case BUILT_IN_VA_START:
6153 return lookup_attribute ("type generic",
6154 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
6160 /* Subroutine of the various build_*_call functions. Overload resolution
6161 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
6162 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
6163 bitmask of various LOOKUP_* flags which apply to the call itself. */
6166 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
6169 const VEC(tree,gc) *args = cand->args;
6170 tree first_arg = cand->first_arg;
6171 conversion **convs = cand->convs;
6173 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
6178 unsigned int arg_index = 0;
6182 bool already_used = false;
6184 /* In a template, there is no need to perform all of the work that
6185 is normally done. We are only interested in the type of the call
6186 expression, i.e., the return type of the function. Any semantic
6187 errors will be deferred until the template is instantiated. */
6188 if (processing_template_decl)
6192 const tree *argarray;
6195 return_type = TREE_TYPE (TREE_TYPE (fn));
6196 nargs = VEC_length (tree, args);
6197 if (first_arg == NULL_TREE)
6198 argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
6206 alcarray = XALLOCAVEC (tree, nargs);
6207 alcarray[0] = first_arg;
6208 FOR_EACH_VEC_ELT (tree, args, ix, arg)
6209 alcarray[ix + 1] = arg;
6210 argarray = alcarray;
6212 expr = build_call_array_loc (input_location,
6213 return_type, build_addr_func (fn), nargs,
6215 if (TREE_THIS_VOLATILE (fn) && cfun)
6216 current_function_returns_abnormally = 1;
6217 return convert_from_reference (expr);
6220 /* Give any warnings we noticed during overload resolution. */
6221 if (cand->warnings && (complain & tf_warning))
6223 struct candidate_warning *w;
6224 for (w = cand->warnings; w; w = w->next)
6225 joust (cand, w->loser, 1);
6228 /* Make =delete work with SFINAE. */
6229 if (DECL_DELETED_FN (fn) && !(complain & tf_error))
6230 return error_mark_node;
6232 if (DECL_FUNCTION_MEMBER_P (fn))
6235 /* If FN is a template function, two cases must be considered.
6240 template <class T> void f();
6242 template <class T> struct B {
6246 struct C : A, B<int> {
6248 using B<int>::g; // #2
6251 In case #1 where `A::f' is a member template, DECL_ACCESS is
6252 recorded in the primary template but not in its specialization.
6253 We check access of FN using its primary template.
6255 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
6256 because it is a member of class template B, DECL_ACCESS is
6257 recorded in the specialization `B<int>::g'. We cannot use its
6258 primary template because `B<T>::g' and `B<int>::g' may have
6259 different access. */
6260 if (DECL_TEMPLATE_INFO (fn)
6261 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
6262 access_fn = DECL_TI_TEMPLATE (fn);
6265 if (flags & LOOKUP_SPECULATIVE)
6267 if (!speculative_access_check (cand->access_path, access_fn, fn,
6268 !!(flags & LOOKUP_COMPLAIN)))
6269 return error_mark_node;
6272 perform_or_defer_access_check (cand->access_path, access_fn, fn);
6275 /* If we're checking for implicit delete, don't bother with argument
6277 if (flags & LOOKUP_SPECULATIVE)
6279 if (DECL_DELETED_FN (fn))
6281 if (flags & LOOKUP_COMPLAIN)
6283 return error_mark_node;
6285 if (cand->viable == 1)
6287 else if (!(flags & LOOKUP_COMPLAIN))
6288 /* Reject bad conversions now. */
6289 return error_mark_node;
6290 /* else continue to get conversion error. */
6293 /* Find maximum size of vector to hold converted arguments. */
6294 parmlen = list_length (parm);
6295 nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
6296 if (parmlen > nargs)
6298 argarray = XALLOCAVEC (tree, nargs);
6300 /* The implicit parameters to a constructor are not considered by overload
6301 resolution, and must be of the proper type. */
6302 if (DECL_CONSTRUCTOR_P (fn))
6304 if (first_arg != NULL_TREE)
6306 argarray[j++] = first_arg;
6307 first_arg = NULL_TREE;
6311 argarray[j++] = VEC_index (tree, args, arg_index);
6314 parm = TREE_CHAIN (parm);
6315 /* We should never try to call the abstract constructor. */
6316 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
6318 if (DECL_HAS_VTT_PARM_P (fn))
6320 argarray[j++] = VEC_index (tree, args, arg_index);
6322 parm = TREE_CHAIN (parm);
6325 /* Bypass access control for 'this' parameter. */
6326 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6328 tree parmtype = TREE_VALUE (parm);
6329 tree arg = (first_arg != NULL_TREE
6331 : VEC_index (tree, args, arg_index));
6332 tree argtype = TREE_TYPE (arg);
6336 if (convs[i]->bad_p)
6338 if (complain & tf_error)
6339 permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
6340 TREE_TYPE (argtype), fn);
6342 return error_mark_node;
6345 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
6346 X is called for an object that is not of type X, or of a type
6347 derived from X, the behavior is undefined.
6349 So we can assume that anything passed as 'this' is non-null, and
6350 optimize accordingly. */
6351 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
6352 /* Convert to the base in which the function was declared. */
6353 gcc_assert (cand->conversion_path != NULL_TREE);
6354 converted_arg = build_base_path (PLUS_EXPR,
6356 cand->conversion_path,
6358 /* Check that the base class is accessible. */
6359 if (!accessible_base_p (TREE_TYPE (argtype),
6360 BINFO_TYPE (cand->conversion_path), true))
6361 error ("%qT is not an accessible base of %qT",
6362 BINFO_TYPE (cand->conversion_path),
6363 TREE_TYPE (argtype));
6364 /* If fn was found by a using declaration, the conversion path
6365 will be to the derived class, not the base declaring fn. We
6366 must convert from derived to base. */
6367 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
6368 TREE_TYPE (parmtype), ba_unique, NULL);
6369 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
6372 argarray[j++] = converted_arg;
6373 parm = TREE_CHAIN (parm);
6374 if (first_arg != NULL_TREE)
6375 first_arg = NULL_TREE;
6382 gcc_assert (first_arg == NULL_TREE);
6383 for (; arg_index < VEC_length (tree, args) && parm;
6384 parm = TREE_CHAIN (parm), ++arg_index, ++i)
6386 tree type = TREE_VALUE (parm);
6387 tree arg = VEC_index (tree, args, arg_index);
6388 bool conversion_warning = true;
6392 /* If the argument is NULL and used to (implicitly) instantiate a
6393 template function (and bind one of the template arguments to
6394 the type of 'long int'), we don't want to warn about passing NULL
6395 to non-pointer argument.
6396 For example, if we have this template function:
6398 template<typename T> void func(T x) {}
6400 we want to warn (when -Wconversion is enabled) in this case:
6406 but not in this case:
6412 if (arg == null_node
6413 && DECL_TEMPLATE_INFO (fn)
6414 && cand->template_decl
6415 && !(flags & LOOKUP_EXPLICIT_TMPL_ARGS))
6416 conversion_warning = false;
6418 /* Warn about initializer_list deduction that isn't currently in the
6420 if (cxx_dialect > cxx98
6421 && flag_deduce_init_list
6422 && cand->template_decl
6423 && is_std_init_list (non_reference (type))
6424 && BRACE_ENCLOSED_INITIALIZER_P (arg))
6426 tree tmpl = TI_TEMPLATE (cand->template_decl);
6427 tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
6428 tree patparm = get_pattern_parm (realparm, tmpl);
6429 tree pattype = TREE_TYPE (patparm);
6430 if (PACK_EXPANSION_P (pattype))
6431 pattype = PACK_EXPANSION_PATTERN (pattype);
6432 pattype = non_reference (pattype);
6434 if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM
6435 && (cand->explicit_targs == NULL_TREE
6436 || (TREE_VEC_LENGTH (cand->explicit_targs)
6437 <= TEMPLATE_TYPE_IDX (pattype))))
6439 pedwarn (input_location, 0, "deducing %qT as %qT",
6440 non_reference (TREE_TYPE (patparm)),
6441 non_reference (type));
6442 pedwarn (input_location, 0, " in call to %q+D", cand->fn);
6443 pedwarn (input_location, 0,
6444 " (you can disable this with -fno-deduce-init-list)");
6448 val = convert_like_with_context (conv, arg, fn, i-is_method,
6451 : complain & (~tf_warning));
6453 val = convert_for_arg_passing (type, val);
6454 if (val == error_mark_node)
6455 return error_mark_node;
6457 argarray[j++] = val;
6460 /* Default arguments */
6461 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
6462 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
6463 TREE_PURPOSE (parm),
6466 for (; arg_index < VEC_length (tree, args); ++arg_index)
6468 tree a = VEC_index (tree, args, arg_index);
6469 if (magic_varargs_p (fn))
6470 /* Do no conversions for magic varargs. */
6471 a = mark_type_use (a);
6473 a = convert_arg_to_ellipsis (a);
6477 gcc_assert (j <= nargs);
6480 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
6481 nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
6483 /* Avoid actually calling copy constructors and copy assignment operators,
6486 if (! flag_elide_constructors)
6487 /* Do things the hard way. */;
6488 else if (cand->num_convs == 1
6489 && (DECL_COPY_CONSTRUCTOR_P (fn)
6490 || DECL_MOVE_CONSTRUCTOR_P (fn)))
6493 tree arg = argarray[num_artificial_parms_for (fn)];
6495 bool trivial = trivial_fn_p (fn);
6497 /* Pull out the real argument, disregarding const-correctness. */
6499 while (CONVERT_EXPR_P (targ)
6500 || TREE_CODE (targ) == NON_LVALUE_EXPR)
6501 targ = TREE_OPERAND (targ, 0);
6502 if (TREE_CODE (targ) == ADDR_EXPR)
6504 targ = TREE_OPERAND (targ, 0);
6505 if (!same_type_ignoring_top_level_qualifiers_p
6506 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
6515 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
6517 /* [class.copy]: the copy constructor is implicitly defined even if
6518 the implementation elided its use. */
6519 if (!trivial || DECL_DELETED_FN (fn))
6522 already_used = true;
6525 /* If we're creating a temp and we already have one, don't create a
6526 new one. If we're not creating a temp but we get one, use
6527 INIT_EXPR to collapse the temp into our target. Otherwise, if the
6528 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
6529 temp or an INIT_EXPR otherwise. */
6531 if (integer_zerop (fa))
6533 if (TREE_CODE (arg) == TARGET_EXPR)
6536 return force_target_expr (DECL_CONTEXT (fn), arg, complain);
6538 else if (TREE_CODE (arg) == TARGET_EXPR || trivial)
6540 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
6543 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
6547 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
6548 && trivial_fn_p (fn)
6549 && !DECL_DELETED_FN (fn))
6551 tree to = stabilize_reference
6552 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
6553 tree type = TREE_TYPE (to);
6554 tree as_base = CLASSTYPE_AS_BASE (type);
6555 tree arg = argarray[1];
6557 if (is_really_empty_class (type))
6559 /* Avoid copying empty classes. */
6560 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
6561 TREE_NO_WARNING (val) = 1;
6562 val = build2 (COMPOUND_EXPR, type, val, to);
6563 TREE_NO_WARNING (val) = 1;
6565 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
6567 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
6568 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
6572 /* We must only copy the non-tail padding parts.
6573 Use __builtin_memcpy for the bitwise copy.
6574 FIXME fix 22488 so we can go back to using MODIFY_EXPR
6575 instead of an explicit call to memcpy. */
6577 tree arg0, arg1, arg2, t;
6578 tree test = NULL_TREE;
6580 arg2 = TYPE_SIZE_UNIT (as_base);
6582 arg0 = cp_build_addr_expr (to, complain);
6584 if (!can_trust_pointer_alignment ())
6586 /* If we can't be sure about pointer alignment, a call
6587 to __builtin_memcpy is expanded as a call to memcpy, which
6588 is invalid with identical args. Otherwise it is
6589 expanded as a block move, which should be safe. */
6590 arg0 = save_expr (arg0);
6591 arg1 = save_expr (arg1);
6592 test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
6594 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
6595 t = build_call_n (t, 3, arg0, arg1, arg2);
6597 t = convert (TREE_TYPE (arg0), t);
6599 t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
6600 val = cp_build_indirect_ref (t, RO_NULL, complain);
6601 TREE_NO_WARNING (val) = 1;
6606 else if (DECL_DESTRUCTOR_P (fn)
6607 && trivial_fn_p (fn)
6608 && !DECL_DELETED_FN (fn))
6609 return fold_convert (void_type_node, argarray[0]);
6610 /* FIXME handle trivial default constructor, too. */
6615 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
6618 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
6621 gcc_assert (binfo && binfo != error_mark_node);
6623 /* Warn about deprecated virtual functions now, since we're about
6624 to throw away the decl. */
6625 if (TREE_DEPRECATED (fn))
6626 warn_deprecated_use (fn, NULL_TREE);
6628 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
6629 if (TREE_SIDE_EFFECTS (argarray[0]))
6630 argarray[0] = save_expr (argarray[0]);
6631 t = build_pointer_type (TREE_TYPE (fn));
6632 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
6633 fn = build_java_interface_fn_ref (fn, argarray[0]);
6635 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
6639 fn = build_addr_func (fn);
6641 return build_cxx_call (fn, nargs, argarray);
6644 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
6645 This function performs no overload resolution, conversion, or other
6646 high-level operations. */
6649 build_cxx_call (tree fn, int nargs, tree *argarray)
6653 fn = build_call_a (fn, nargs, argarray);
6655 /* If this call might throw an exception, note that fact. */
6656 fndecl = get_callee_fndecl (fn);
6657 if ((!fndecl || !TREE_NOTHROW (fndecl))
6658 && at_function_scope_p ()
6660 && cp_function_chain)
6661 cp_function_chain->can_throw = 1;
6663 /* Check that arguments to builtin functions match the expectations. */
6665 && DECL_BUILT_IN (fndecl)
6666 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6667 && !check_builtin_function_arguments (fndecl, nargs, argarray))
6668 return error_mark_node;
6670 /* Some built-in function calls will be evaluated at compile-time in
6672 fn = fold_if_not_in_template (fn);
6674 if (VOID_TYPE_P (TREE_TYPE (fn)))
6677 fn = require_complete_type (fn);
6678 if (fn == error_mark_node)
6679 return error_mark_node;
6681 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
6682 fn = build_cplus_new (TREE_TYPE (fn), fn, tf_warning_or_error);
6683 return convert_from_reference (fn);
6686 static GTY(()) tree java_iface_lookup_fn;
6688 /* Make an expression which yields the address of the Java interface
6689 method FN. This is achieved by generating a call to libjava's
6690 _Jv_LookupInterfaceMethodIdx(). */
6693 build_java_interface_fn_ref (tree fn, tree instance)
6695 tree lookup_fn, method, idx;
6696 tree klass_ref, iface, iface_ref;
6699 if (!java_iface_lookup_fn)
6701 tree ftype = build_function_type_list (ptr_type_node,
6702 ptr_type_node, ptr_type_node,
6703 java_int_type_node, NULL_TREE);
6704 java_iface_lookup_fn
6705 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype,
6706 0, NOT_BUILT_IN, NULL, NULL_TREE);
6709 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
6710 This is the first entry in the vtable. */
6711 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
6712 tf_warning_or_error),
6715 /* Get the java.lang.Class pointer for the interface being called. */
6716 iface = DECL_CONTEXT (fn);
6717 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
6718 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
6719 || DECL_CONTEXT (iface_ref) != iface)
6721 error ("could not find class$ field in java interface type %qT",
6723 return error_mark_node;
6725 iface_ref = build_address (iface_ref);
6726 iface_ref = convert (build_pointer_type (iface), iface_ref);
6728 /* Determine the itable index of FN. */
6730 for (method = TYPE_METHODS (iface); method; method = DECL_CHAIN (method))
6732 if (!DECL_VIRTUAL_P (method))
6738 idx = build_int_cst (NULL_TREE, i);
6740 lookup_fn = build1 (ADDR_EXPR,
6741 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6742 java_iface_lookup_fn);
6743 return build_call_nary (ptr_type_node, lookup_fn,
6744 3, klass_ref, iface_ref, idx);
6747 /* Returns the value to use for the in-charge parameter when making a
6748 call to a function with the indicated NAME.
6750 FIXME:Can't we find a neater way to do this mapping? */
6753 in_charge_arg_for_name (tree name)
6755 if (name == base_ctor_identifier
6756 || name == base_dtor_identifier)
6757 return integer_zero_node;
6758 else if (name == complete_ctor_identifier)
6759 return integer_one_node;
6760 else if (name == complete_dtor_identifier)
6761 return integer_two_node;
6762 else if (name == deleting_dtor_identifier)
6763 return integer_three_node;
6765 /* This function should only be called with one of the names listed
6771 /* Build a call to a constructor, destructor, or an assignment
6772 operator for INSTANCE, an expression with class type. NAME
6773 indicates the special member function to call; *ARGS are the
6774 arguments. ARGS may be NULL. This may change ARGS. BINFO
6775 indicates the base of INSTANCE that is to be passed as the `this'
6776 parameter to the member function called.
6778 FLAGS are the LOOKUP_* flags to use when processing the call.
6780 If NAME indicates a complete object constructor, INSTANCE may be
6781 NULL_TREE. In this case, the caller will call build_cplus_new to
6782 store the newly constructed object into a VAR_DECL. */
6785 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6786 tree binfo, int flags, tsubst_flags_t complain)
6789 /* The type of the subobject to be constructed or destroyed. */
6791 VEC(tree,gc) *allocated = NULL;
6794 gcc_assert (name == complete_ctor_identifier
6795 || name == base_ctor_identifier
6796 || name == complete_dtor_identifier
6797 || name == base_dtor_identifier
6798 || name == deleting_dtor_identifier
6799 || name == ansi_assopname (NOP_EXPR));
6802 /* Resolve the name. */
6803 if (!complete_type_or_maybe_complain (binfo, NULL_TREE, complain))
6804 return error_mark_node;
6806 binfo = TYPE_BINFO (binfo);
6809 gcc_assert (binfo != NULL_TREE);
6811 class_type = BINFO_TYPE (binfo);
6813 /* Handle the special case where INSTANCE is NULL_TREE. */
6814 if (name == complete_ctor_identifier && !instance)
6816 instance = build_int_cst (build_pointer_type (class_type), 0);
6817 instance = build1 (INDIRECT_REF, class_type, instance);
6821 if (name == complete_dtor_identifier
6822 || name == base_dtor_identifier
6823 || name == deleting_dtor_identifier)
6824 gcc_assert (args == NULL || VEC_empty (tree, *args));
6826 /* Convert to the base class, if necessary. */
6827 if (!same_type_ignoring_top_level_qualifiers_p
6828 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6830 if (name != ansi_assopname (NOP_EXPR))
6831 /* For constructors and destructors, either the base is
6832 non-virtual, or it is virtual but we are doing the
6833 conversion from a constructor or destructor for the
6834 complete object. In either case, we can convert
6836 instance = convert_to_base_statically (instance, binfo);
6838 /* However, for assignment operators, we must convert
6839 dynamically if the base is virtual. */
6840 instance = build_base_path (PLUS_EXPR, instance,
6841 binfo, /*nonnull=*/1);
6845 gcc_assert (instance != NULL_TREE);
6847 fns = lookup_fnfields (binfo, name, 1);
6849 /* When making a call to a constructor or destructor for a subobject
6850 that uses virtual base classes, pass down a pointer to a VTT for
6852 if ((name == base_ctor_identifier
6853 || name == base_dtor_identifier)
6854 && CLASSTYPE_VBASECLASSES (class_type))
6859 /* If the current function is a complete object constructor
6860 or destructor, then we fetch the VTT directly.
6861 Otherwise, we look it up using the VTT we were given. */
6862 vtt = DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6863 vtt = decay_conversion (vtt);
6864 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6865 build2 (EQ_EXPR, boolean_type_node,
6866 current_in_charge_parm, integer_zero_node),
6869 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6870 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6871 BINFO_SUBVTT_INDEX (binfo));
6875 allocated = make_tree_vector ();
6879 VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6882 ret = build_new_method_call (instance, fns, args,
6883 TYPE_BINFO (BINFO_TYPE (binfo)),
6887 if (allocated != NULL)
6888 release_tree_vector (allocated);
6893 /* Return the NAME, as a C string. The NAME indicates a function that
6894 is a member of TYPE. *FREE_P is set to true if the caller must
6895 free the memory returned.
6897 Rather than go through all of this, we should simply set the names
6898 of constructors and destructors appropriately, and dispense with
6899 ctor_identifier, dtor_identifier, etc. */
6902 name_as_c_string (tree name, tree type, bool *free_p)
6906 /* Assume that we will not allocate memory. */
6908 /* Constructors and destructors are special. */
6909 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6912 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6913 /* For a destructor, add the '~'. */
6914 if (name == complete_dtor_identifier
6915 || name == base_dtor_identifier
6916 || name == deleting_dtor_identifier)
6918 pretty_name = concat ("~", pretty_name, NULL);
6919 /* Remember that we need to free the memory allocated. */
6923 else if (IDENTIFIER_TYPENAME_P (name))
6925 pretty_name = concat ("operator ",
6926 type_as_string_translate (TREE_TYPE (name),
6927 TFF_PLAIN_IDENTIFIER),
6929 /* Remember that we need to free the memory allocated. */
6933 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6938 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
6939 be set, upon return, to the function called. ARGS may be NULL.
6940 This may change ARGS. */
6943 build_new_method_call_1 (tree instance, tree fns, VEC(tree,gc) **args,
6944 tree conversion_path, int flags,
6945 tree *fn_p, tsubst_flags_t complain)
6947 struct z_candidate *candidates = 0, *cand;
6948 tree explicit_targs = NULL_TREE;
6949 tree basetype = NULL_TREE;
6952 tree first_mem_arg = NULL_TREE;
6955 bool skip_first_for_error;
6956 VEC(tree,gc) *user_args;
6959 int template_only = 0;
6963 VEC(tree,gc) *orig_args = NULL;
6966 gcc_assert (instance != NULL_TREE);
6968 /* We don't know what function we're going to call, yet. */
6972 if (error_operand_p (instance)
6973 || !fns || error_operand_p (fns))
6974 return error_mark_node;
6976 if (!BASELINK_P (fns))
6978 if (complain & tf_error)
6979 error ("call to non-function %qD", fns);
6980 return error_mark_node;
6983 orig_instance = instance;
6986 /* Dismantle the baselink to collect all the information we need. */
6987 if (!conversion_path)
6988 conversion_path = BASELINK_BINFO (fns);
6989 access_binfo = BASELINK_ACCESS_BINFO (fns);
6990 optype = BASELINK_OPTYPE (fns);
6991 fns = BASELINK_FUNCTIONS (fns);
6992 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6994 explicit_targs = TREE_OPERAND (fns, 1);
6995 fns = TREE_OPERAND (fns, 0);
6998 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6999 || TREE_CODE (fns) == TEMPLATE_DECL
7000 || TREE_CODE (fns) == OVERLOAD);
7001 fn = get_first_fn (fns);
7002 name = DECL_NAME (fn);
7004 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
7005 gcc_assert (CLASS_TYPE_P (basetype));
7007 if (processing_template_decl)
7009 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
7010 instance = build_non_dependent_expr (instance);
7012 make_args_non_dependent (*args);
7015 user_args = args == NULL ? NULL : *args;
7016 /* Under DR 147 A::A() is an invalid constructor call,
7017 not a functional cast. */
7018 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
7020 if (! (complain & tf_error))
7021 return error_mark_node;
7023 permerror (input_location,
7024 "cannot call constructor %<%T::%D%> directly",
7026 permerror (input_location, " for a function-style cast, remove the "
7027 "redundant %<::%D%>", name);
7028 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
7033 /* Figure out whether to skip the first argument for the error
7034 message we will display to users if an error occurs. We don't
7035 want to display any compiler-generated arguments. The "this"
7036 pointer hasn't been added yet. However, we must remove the VTT
7037 pointer if this is a call to a base-class constructor or
7039 skip_first_for_error = false;
7040 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
7042 /* Callers should explicitly indicate whether they want to construct
7043 the complete object or just the part without virtual bases. */
7044 gcc_assert (name != ctor_identifier);
7045 /* Similarly for destructors. */
7046 gcc_assert (name != dtor_identifier);
7047 /* Remove the VTT pointer, if present. */
7048 if ((name == base_ctor_identifier || name == base_dtor_identifier)
7049 && CLASSTYPE_VBASECLASSES (basetype))
7050 skip_first_for_error = true;
7053 /* Process the argument list. */
7054 if (args != NULL && *args != NULL)
7056 *args = resolve_args (*args, complain);
7058 return error_mark_node;
7061 instance_ptr = build_this (instance);
7063 /* It's OK to call destructors and constructors on cv-qualified objects.
7064 Therefore, convert the INSTANCE_PTR to the unqualified type, if
7066 if (DECL_DESTRUCTOR_P (fn)
7067 || DECL_CONSTRUCTOR_P (fn))
7069 tree type = build_pointer_type (basetype);
7070 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
7071 instance_ptr = build_nop (type, instance_ptr);
7073 if (DECL_DESTRUCTOR_P (fn))
7074 name = complete_dtor_identifier;
7076 first_mem_arg = instance_ptr;
7078 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7079 p = conversion_obstack_alloc (0);
7081 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
7082 initializer, not T({ }). */
7083 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
7084 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
7085 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
7087 gcc_assert (VEC_length (tree, *args) == 1
7088 && !(flags & LOOKUP_ONLYCONVERTING));
7090 add_list_candidates (fns, first_mem_arg, VEC_index (tree, *args, 0),
7091 basetype, explicit_targs, template_only,
7092 conversion_path, access_binfo, flags, &candidates);
7096 add_candidates (fns, first_mem_arg, user_args, optype,
7097 explicit_targs, template_only, conversion_path,
7098 access_binfo, flags, &candidates);
7100 any_viable_p = false;
7101 candidates = splice_viable (candidates, pedantic, &any_viable_p);
7105 if (complain & tf_error)
7107 if (!COMPLETE_OR_OPEN_TYPE_P (basetype))
7108 cxx_incomplete_type_error (instance_ptr, basetype);
7110 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
7111 basetype, optype, build_tree_list_vec (user_args),
7112 TREE_TYPE (TREE_TYPE (instance_ptr)));
7119 pretty_name = name_as_c_string (name, basetype, &free_p);
7120 arglist = build_tree_list_vec (user_args);
7121 if (skip_first_for_error)
7122 arglist = TREE_CHAIN (arglist);
7123 error ("no matching function for call to %<%T::%s(%A)%#V%>",
7124 basetype, pretty_name, arglist,
7125 TREE_TYPE (TREE_TYPE (instance_ptr)));
7129 print_z_candidates (location_of (name), candidates);
7131 call = error_mark_node;
7135 cand = tourney (candidates);
7142 if (complain & tf_error)
7144 pretty_name = name_as_c_string (name, basetype, &free_p);
7145 arglist = build_tree_list_vec (user_args);
7146 if (skip_first_for_error)
7147 arglist = TREE_CHAIN (arglist);
7148 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
7150 print_z_candidates (location_of (name), candidates);
7154 call = error_mark_node;
7160 if (!(flags & LOOKUP_NONVIRTUAL)
7161 && DECL_PURE_VIRTUAL_P (fn)
7162 && instance == current_class_ref
7163 && (DECL_CONSTRUCTOR_P (current_function_decl)
7164 || DECL_DESTRUCTOR_P (current_function_decl))
7165 && (complain & tf_warning))
7166 /* This is not an error, it is runtime undefined
7168 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
7169 "pure virtual %q#D called from constructor"
7170 : "pure virtual %q#D called from destructor"),
7173 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
7174 && is_dummy_object (instance_ptr))
7176 if (complain & tf_error)
7177 error ("cannot call member function %qD without object",
7179 call = error_mark_node;
7183 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
7184 && resolves_to_fixed_type_p (instance, 0))
7185 flags |= LOOKUP_NONVIRTUAL;
7187 flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
7188 /* Now we know what function is being called. */
7191 /* Build the actual CALL_EXPR. */
7192 call = build_over_call (cand, flags, complain);
7193 /* In an expression of the form `a->f()' where `f' turns
7194 out to be a static member function, `a' is
7195 none-the-less evaluated. */
7196 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
7197 && !is_dummy_object (instance_ptr)
7198 && TREE_SIDE_EFFECTS (instance_ptr))
7199 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
7200 instance_ptr, call);
7201 else if (call != error_mark_node
7202 && DECL_DESTRUCTOR_P (cand->fn)
7203 && !VOID_TYPE_P (TREE_TYPE (call)))
7204 /* An explicit call of the form "x->~X()" has type
7205 "void". However, on platforms where destructors
7206 return "this" (i.e., those where
7207 targetm.cxx.cdtor_returns_this is true), such calls
7208 will appear to have a return value of pointer type
7209 to the low-level call machinery. We do not want to
7210 change the low-level machinery, since we want to be
7211 able to optimize "delete f()" on such platforms as
7212 "operator delete(~X(f()))" (rather than generating
7213 "t = f(), ~X(t), operator delete (t)"). */
7214 call = build_nop (void_type_node, call);
7219 if (processing_template_decl && call != error_mark_node)
7221 bool cast_to_void = false;
7223 if (TREE_CODE (call) == COMPOUND_EXPR)
7224 call = TREE_OPERAND (call, 1);
7225 else if (TREE_CODE (call) == NOP_EXPR)
7227 cast_to_void = true;
7228 call = TREE_OPERAND (call, 0);
7230 if (TREE_CODE (call) == INDIRECT_REF)
7231 call = TREE_OPERAND (call, 0);
7232 call = (build_min_non_dep_call_vec
7234 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
7235 orig_instance, orig_fns, NULL_TREE),
7237 call = convert_from_reference (call);
7239 call = build_nop (void_type_node, call);
7242 /* Free all the conversions we allocated. */
7243 obstack_free (&conversion_obstack, p);
7245 if (orig_args != NULL)
7246 release_tree_vector (orig_args);
7251 /* Wrapper for above. */
7254 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
7255 tree conversion_path, int flags,
7256 tree *fn_p, tsubst_flags_t complain)
7259 bool subtime = timevar_cond_start (TV_OVERLOAD);
7260 ret = build_new_method_call_1 (instance, fns, args, conversion_path, flags,
7262 timevar_cond_stop (TV_OVERLOAD, subtime);
7266 /* Returns true iff standard conversion sequence ICS1 is a proper
7267 subsequence of ICS2. */
7270 is_subseq (conversion *ics1, conversion *ics2)
7272 /* We can assume that a conversion of the same code
7273 between the same types indicates a subsequence since we only get
7274 here if the types we are converting from are the same. */
7276 while (ics1->kind == ck_rvalue
7277 || ics1->kind == ck_lvalue)
7278 ics1 = ics1->u.next;
7282 while (ics2->kind == ck_rvalue
7283 || ics2->kind == ck_lvalue)
7284 ics2 = ics2->u.next;
7286 if (ics2->kind == ck_user
7287 || ics2->kind == ck_ambig
7288 || ics2->kind == ck_aggr
7289 || ics2->kind == ck_list
7290 || ics2->kind == ck_identity)
7291 /* At this point, ICS1 cannot be a proper subsequence of
7292 ICS2. We can get a USER_CONV when we are comparing the
7293 second standard conversion sequence of two user conversion
7297 ics2 = ics2->u.next;
7299 if (ics2->kind == ics1->kind
7300 && same_type_p (ics2->type, ics1->type)
7301 && same_type_p (ics2->u.next->type,
7302 ics1->u.next->type))
7307 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
7308 be any _TYPE nodes. */
7311 is_properly_derived_from (tree derived, tree base)
7313 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
7316 /* We only allow proper derivation here. The DERIVED_FROM_P macro
7317 considers every class derived from itself. */
7318 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
7319 && DERIVED_FROM_P (base, derived));
7322 /* We build the ICS for an implicit object parameter as a pointer
7323 conversion sequence. However, such a sequence should be compared
7324 as if it were a reference conversion sequence. If ICS is the
7325 implicit conversion sequence for an implicit object parameter,
7326 modify it accordingly. */
7329 maybe_handle_implicit_object (conversion **ics)
7333 /* [over.match.funcs]
7335 For non-static member functions, the type of the
7336 implicit object parameter is "reference to cv X"
7337 where X is the class of which the function is a
7338 member and cv is the cv-qualification on the member
7339 function declaration. */
7340 conversion *t = *ics;
7341 tree reference_type;
7343 /* The `this' parameter is a pointer to a class type. Make the
7344 implicit conversion talk about a reference to that same class
7346 reference_type = TREE_TYPE (t->type);
7347 reference_type = build_reference_type (reference_type);
7349 if (t->kind == ck_qual)
7351 if (t->kind == ck_ptr)
7353 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
7354 t = direct_reference_binding (reference_type, t);
7356 t->rvaluedness_matches_p = 0;
7361 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
7362 and return the initial reference binding conversion. Otherwise,
7363 leave *ICS unchanged and return NULL. */
7366 maybe_handle_ref_bind (conversion **ics)
7368 if ((*ics)->kind == ck_ref_bind)
7370 conversion *old_ics = *ics;
7371 *ics = old_ics->u.next;
7372 (*ics)->user_conv_p = old_ics->user_conv_p;
7379 /* Compare two implicit conversion sequences according to the rules set out in
7380 [over.ics.rank]. Return values:
7382 1: ics1 is better than ics2
7383 -1: ics2 is better than ics1
7384 0: ics1 and ics2 are indistinguishable */
7387 compare_ics (conversion *ics1, conversion *ics2)
7393 tree deref_from_type1 = NULL_TREE;
7394 tree deref_from_type2 = NULL_TREE;
7395 tree deref_to_type1 = NULL_TREE;
7396 tree deref_to_type2 = NULL_TREE;
7397 conversion_rank rank1, rank2;
7399 /* REF_BINDING is nonzero if the result of the conversion sequence
7400 is a reference type. In that case REF_CONV is the reference
7401 binding conversion. */
7402 conversion *ref_conv1;
7403 conversion *ref_conv2;
7405 /* Handle implicit object parameters. */
7406 maybe_handle_implicit_object (&ics1);
7407 maybe_handle_implicit_object (&ics2);
7409 /* Handle reference parameters. */
7410 ref_conv1 = maybe_handle_ref_bind (&ics1);
7411 ref_conv2 = maybe_handle_ref_bind (&ics2);
7413 /* List-initialization sequence L1 is a better conversion sequence than
7414 list-initialization sequence L2 if L1 converts to
7415 std::initializer_list<X> for some X and L2 does not. */
7416 if (ics1->kind == ck_list && ics2->kind != ck_list)
7418 if (ics2->kind == ck_list && ics1->kind != ck_list)
7423 When comparing the basic forms of implicit conversion sequences (as
7424 defined in _over.best.ics_)
7426 --a standard conversion sequence (_over.ics.scs_) is a better
7427 conversion sequence than a user-defined conversion sequence
7428 or an ellipsis conversion sequence, and
7430 --a user-defined conversion sequence (_over.ics.user_) is a
7431 better conversion sequence than an ellipsis conversion sequence
7432 (_over.ics.ellipsis_). */
7433 rank1 = CONVERSION_RANK (ics1);
7434 rank2 = CONVERSION_RANK (ics2);
7438 else if (rank1 < rank2)
7441 if (rank1 == cr_bad)
7443 /* Both ICS are bad. We try to make a decision based on what would
7444 have happened if they'd been good. This is not an extension,
7445 we'll still give an error when we build up the call; this just
7446 helps us give a more helpful error message. */
7447 rank1 = BAD_CONVERSION_RANK (ics1);
7448 rank2 = BAD_CONVERSION_RANK (ics2);
7452 else if (rank1 < rank2)
7455 /* We couldn't make up our minds; try to figure it out below. */
7458 if (ics1->ellipsis_p)
7459 /* Both conversions are ellipsis conversions. */
7462 /* User-defined conversion sequence U1 is a better conversion sequence
7463 than another user-defined conversion sequence U2 if they contain the
7464 same user-defined conversion operator or constructor and if the sec-
7465 ond standard conversion sequence of U1 is better than the second
7466 standard conversion sequence of U2. */
7468 /* Handle list-conversion with the same code even though it isn't always
7469 ranked as a user-defined conversion and it doesn't have a second
7470 standard conversion sequence; it will still have the desired effect.
7471 Specifically, we need to do the reference binding comparison at the
7472 end of this function. */
7474 if (ics1->user_conv_p || ics1->kind == ck_list)
7479 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
7480 if (t1->kind == ck_ambig || t1->kind == ck_aggr
7481 || t1->kind == ck_list)
7483 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
7484 if (t2->kind == ck_ambig || t2->kind == ck_aggr
7485 || t2->kind == ck_list)
7488 if (t1->kind != t2->kind)
7490 else if (t1->kind == ck_user)
7492 if (t1->cand->fn != t2->cand->fn)
7497 /* For ambiguous or aggregate conversions, use the target type as
7498 a proxy for the conversion function. */
7499 if (!same_type_ignoring_top_level_qualifiers_p (t1->type, t2->type))
7503 /* We can just fall through here, after setting up
7504 FROM_TYPE1 and FROM_TYPE2. */
7505 from_type1 = t1->type;
7506 from_type2 = t2->type;
7513 /* We're dealing with two standard conversion sequences.
7517 Standard conversion sequence S1 is a better conversion
7518 sequence than standard conversion sequence S2 if
7520 --S1 is a proper subsequence of S2 (comparing the conversion
7521 sequences in the canonical form defined by _over.ics.scs_,
7522 excluding any Lvalue Transformation; the identity
7523 conversion sequence is considered to be a subsequence of
7524 any non-identity conversion sequence */
7527 while (t1->kind != ck_identity)
7529 from_type1 = t1->type;
7532 while (t2->kind != ck_identity)
7534 from_type2 = t2->type;
7537 /* One sequence can only be a subsequence of the other if they start with
7538 the same type. They can start with different types when comparing the
7539 second standard conversion sequence in two user-defined conversion
7541 if (same_type_p (from_type1, from_type2))
7543 if (is_subseq (ics1, ics2))
7545 if (is_subseq (ics2, ics1))
7553 --the rank of S1 is better than the rank of S2 (by the rules
7556 Standard conversion sequences are ordered by their ranks: an Exact
7557 Match is a better conversion than a Promotion, which is a better
7558 conversion than a Conversion.
7560 Two conversion sequences with the same rank are indistinguishable
7561 unless one of the following rules applies:
7563 --A conversion that does not a convert a pointer, pointer to member,
7564 or std::nullptr_t to bool is better than one that does.
7566 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
7567 so that we do not have to check it explicitly. */
7568 if (ics1->rank < ics2->rank)
7570 else if (ics2->rank < ics1->rank)
7573 to_type1 = ics1->type;
7574 to_type2 = ics2->type;
7576 /* A conversion from scalar arithmetic type to complex is worse than a
7577 conversion between scalar arithmetic types. */
7578 if (same_type_p (from_type1, from_type2)
7579 && ARITHMETIC_TYPE_P (from_type1)
7580 && ARITHMETIC_TYPE_P (to_type1)
7581 && ARITHMETIC_TYPE_P (to_type2)
7582 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
7583 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
7585 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
7591 if (TYPE_PTR_P (from_type1)
7592 && TYPE_PTR_P (from_type2)
7593 && TYPE_PTR_P (to_type1)
7594 && TYPE_PTR_P (to_type2))
7596 deref_from_type1 = TREE_TYPE (from_type1);
7597 deref_from_type2 = TREE_TYPE (from_type2);
7598 deref_to_type1 = TREE_TYPE (to_type1);
7599 deref_to_type2 = TREE_TYPE (to_type2);
7601 /* The rules for pointers to members A::* are just like the rules
7602 for pointers A*, except opposite: if B is derived from A then
7603 A::* converts to B::*, not vice versa. For that reason, we
7604 switch the from_ and to_ variables here. */
7605 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
7606 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
7607 || (TYPE_PTRMEMFUNC_P (from_type1)
7608 && TYPE_PTRMEMFUNC_P (from_type2)
7609 && TYPE_PTRMEMFUNC_P (to_type1)
7610 && TYPE_PTRMEMFUNC_P (to_type2)))
7612 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
7613 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
7614 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
7615 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
7618 if (deref_from_type1 != NULL_TREE
7619 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
7620 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
7622 /* This was one of the pointer or pointer-like conversions.
7626 --If class B is derived directly or indirectly from class A,
7627 conversion of B* to A* is better than conversion of B* to
7628 void*, and conversion of A* to void* is better than
7629 conversion of B* to void*. */
7630 if (TREE_CODE (deref_to_type1) == VOID_TYPE
7631 && TREE_CODE (deref_to_type2) == VOID_TYPE)
7633 if (is_properly_derived_from (deref_from_type1,
7636 else if (is_properly_derived_from (deref_from_type2,
7640 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
7641 || TREE_CODE (deref_to_type2) == VOID_TYPE)
7643 if (same_type_p (deref_from_type1, deref_from_type2))
7645 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
7647 if (is_properly_derived_from (deref_from_type1,
7651 /* We know that DEREF_TO_TYPE1 is `void' here. */
7652 else if (is_properly_derived_from (deref_from_type1,
7657 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
7658 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
7662 --If class B is derived directly or indirectly from class A
7663 and class C is derived directly or indirectly from B,
7665 --conversion of C* to B* is better than conversion of C* to
7668 --conversion of B* to A* is better than conversion of C* to
7670 if (same_type_p (deref_from_type1, deref_from_type2))
7672 if (is_properly_derived_from (deref_to_type1,
7675 else if (is_properly_derived_from (deref_to_type2,
7679 else if (same_type_p (deref_to_type1, deref_to_type2))
7681 if (is_properly_derived_from (deref_from_type2,
7684 else if (is_properly_derived_from (deref_from_type1,
7690 else if (CLASS_TYPE_P (non_reference (from_type1))
7691 && same_type_p (from_type1, from_type2))
7693 tree from = non_reference (from_type1);
7697 --binding of an expression of type C to a reference of type
7698 B& is better than binding an expression of type C to a
7699 reference of type A&
7701 --conversion of C to B is better than conversion of C to A, */
7702 if (is_properly_derived_from (from, to_type1)
7703 && is_properly_derived_from (from, to_type2))
7705 if (is_properly_derived_from (to_type1, to_type2))
7707 else if (is_properly_derived_from (to_type2, to_type1))
7711 else if (CLASS_TYPE_P (non_reference (to_type1))
7712 && same_type_p (to_type1, to_type2))
7714 tree to = non_reference (to_type1);
7718 --binding of an expression of type B to a reference of type
7719 A& is better than binding an expression of type C to a
7720 reference of type A&,
7722 --conversion of B to A is better than conversion of C to A */
7723 if (is_properly_derived_from (from_type1, to)
7724 && is_properly_derived_from (from_type2, to))
7726 if (is_properly_derived_from (from_type2, from_type1))
7728 else if (is_properly_derived_from (from_type1, from_type2))
7735 --S1 and S2 differ only in their qualification conversion and yield
7736 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
7737 qualification signature of type T1 is a proper subset of the cv-
7738 qualification signature of type T2 */
7739 if (ics1->kind == ck_qual
7740 && ics2->kind == ck_qual
7741 && same_type_p (from_type1, from_type2))
7743 int result = comp_cv_qual_signature (to_type1, to_type2);
7750 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
7751 to an implicit object parameter, and either S1 binds an lvalue reference
7752 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
7753 reference to an rvalue and S2 binds an lvalue reference
7754 (C++0x draft standard, 13.3.3.2)
7756 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
7757 types to which the references refer are the same type except for
7758 top-level cv-qualifiers, and the type to which the reference
7759 initialized by S2 refers is more cv-qualified than the type to
7760 which the reference initialized by S1 refers */
7762 if (ref_conv1 && ref_conv2)
7764 if (!ref_conv1->this_p && !ref_conv2->this_p
7765 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7766 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7768 if (ref_conv1->rvaluedness_matches_p)
7770 if (ref_conv2->rvaluedness_matches_p)
7774 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7775 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7776 TREE_TYPE (ref_conv1->type));
7779 /* Neither conversion sequence is better than the other. */
7783 /* The source type for this standard conversion sequence. */
7786 source_type (conversion *t)
7788 for (;; t = t->u.next)
7790 if (t->kind == ck_user
7791 || t->kind == ck_ambig
7792 || t->kind == ck_identity)
7798 /* Note a warning about preferring WINNER to LOSER. We do this by storing
7799 a pointer to LOSER and re-running joust to produce the warning if WINNER
7800 is actually used. */
7803 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7805 candidate_warning *cw = (candidate_warning *)
7806 conversion_obstack_alloc (sizeof (candidate_warning));
7808 cw->next = winner->warnings;
7809 winner->warnings = cw;
7812 /* Compare two candidates for overloading as described in
7813 [over.match.best]. Return values:
7815 1: cand1 is better than cand2
7816 -1: cand2 is better than cand1
7817 0: cand1 and cand2 are indistinguishable */
7820 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7823 int off1 = 0, off2 = 0;
7827 /* Candidates that involve bad conversions are always worse than those
7829 if (cand1->viable > cand2->viable)
7831 if (cand1->viable < cand2->viable)
7834 /* If we have two pseudo-candidates for conversions to the same type,
7835 or two candidates for the same function, arbitrarily pick one. */
7836 if (cand1->fn == cand2->fn
7837 && (IS_TYPE_OR_DECL_P (cand1->fn)))
7840 /* a viable function F1
7841 is defined to be a better function than another viable function F2 if
7842 for all arguments i, ICSi(F1) is not a worse conversion sequence than
7843 ICSi(F2), and then */
7845 /* for some argument j, ICSj(F1) is a better conversion sequence than
7848 /* For comparing static and non-static member functions, we ignore
7849 the implicit object parameter of the non-static function. The
7850 standard says to pretend that the static function has an object
7851 parm, but that won't work with operator overloading. */
7852 len = cand1->num_convs;
7853 if (len != cand2->num_convs)
7855 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7856 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7858 gcc_assert (static_1 != static_2);
7869 for (i = 0; i < len; ++i)
7871 conversion *t1 = cand1->convs[i + off1];
7872 conversion *t2 = cand2->convs[i + off2];
7873 int comp = compare_ics (t1, t2);
7878 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7879 == cr_std + cr_promotion)
7880 && t1->kind == ck_std
7881 && t2->kind == ck_std
7882 && TREE_CODE (t1->type) == INTEGER_TYPE
7883 && TREE_CODE (t2->type) == INTEGER_TYPE
7884 && (TYPE_PRECISION (t1->type)
7885 == TYPE_PRECISION (t2->type))
7886 && (TYPE_UNSIGNED (t1->u.next->type)
7887 || (TREE_CODE (t1->u.next->type)
7890 tree type = t1->u.next->type;
7892 struct z_candidate *w, *l;
7894 type1 = t1->type, type2 = t2->type,
7895 w = cand1, l = cand2;
7897 type1 = t2->type, type2 = t1->type,
7898 w = cand2, l = cand1;
7902 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7903 type, type1, type2);
7904 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
7910 if (winner && comp != winner)
7919 /* warn about confusing overload resolution for user-defined conversions,
7920 either between a constructor and a conversion op, or between two
7922 if (winner && warn_conversion && cand1->second_conv
7923 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7924 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7926 struct z_candidate *w, *l;
7927 bool give_warning = false;
7930 w = cand1, l = cand2;
7932 w = cand2, l = cand1;
7934 /* We don't want to complain about `X::operator T1 ()'
7935 beating `X::operator T2 () const', when T2 is a no less
7936 cv-qualified version of T1. */
7937 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7938 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7940 tree t = TREE_TYPE (TREE_TYPE (l->fn));
7941 tree f = TREE_TYPE (TREE_TYPE (w->fn));
7943 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7948 if (!comp_ptr_ttypes (t, f))
7949 give_warning = true;
7952 give_warning = true;
7958 tree source = source_type (w->convs[0]);
7959 if (! DECL_CONSTRUCTOR_P (w->fn))
7960 source = TREE_TYPE (source);
7961 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7962 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
7963 source, w->second_conv->type))
7965 inform (input_location, " because conversion sequence for the argument is better");
7976 F1 is a non-template function and F2 is a template function
7979 if (!cand1->template_decl && cand2->template_decl)
7981 else if (cand1->template_decl && !cand2->template_decl)
7985 F1 and F2 are template functions and the function template for F1 is
7986 more specialized than the template for F2 according to the partial
7989 if (cand1->template_decl && cand2->template_decl)
7991 winner = more_specialized_fn
7992 (TI_TEMPLATE (cand1->template_decl),
7993 TI_TEMPLATE (cand2->template_decl),
7994 /* [temp.func.order]: The presence of unused ellipsis and default
7995 arguments has no effect on the partial ordering of function
7996 templates. add_function_candidate() will not have
7997 counted the "this" argument for constructors. */
7998 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
8004 the context is an initialization by user-defined conversion (see
8005 _dcl.init_ and _over.match.user_) and the standard conversion
8006 sequence from the return type of F1 to the destination type (i.e.,
8007 the type of the entity being initialized) is a better conversion
8008 sequence than the standard conversion sequence from the return type
8009 of F2 to the destination type. */
8011 if (cand1->second_conv)
8013 winner = compare_ics (cand1->second_conv, cand2->second_conv);
8018 /* Check whether we can discard a builtin candidate, either because we
8019 have two identical ones or matching builtin and non-builtin candidates.
8021 (Pedantically in the latter case the builtin which matched the user
8022 function should not be added to the overload set, but we spot it here.
8025 ... the builtin candidates include ...
8026 - do not have the same parameter type list as any non-template
8027 non-member candidate. */
8029 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
8030 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
8032 for (i = 0; i < len; ++i)
8033 if (!same_type_p (cand1->convs[i]->type,
8034 cand2->convs[i]->type))
8036 if (i == cand1->num_convs)
8038 if (cand1->fn == cand2->fn)
8039 /* Two built-in candidates; arbitrarily pick one. */
8041 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
8042 /* cand1 is built-in; prefer cand2. */
8045 /* cand2 is built-in; prefer cand1. */
8050 /* If the two function declarations represent the same function (this can
8051 happen with declarations in multiple scopes and arg-dependent lookup),
8052 arbitrarily choose one. But first make sure the default args we're
8054 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
8055 && equal_functions (cand1->fn, cand2->fn))
8057 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
8058 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
8060 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
8062 for (i = 0; i < len; ++i)
8064 /* Don't crash if the fn is variadic. */
8067 parms1 = TREE_CHAIN (parms1);
8068 parms2 = TREE_CHAIN (parms2);
8072 parms1 = TREE_CHAIN (parms1);
8074 parms2 = TREE_CHAIN (parms2);
8078 if (!cp_tree_equal (TREE_PURPOSE (parms1),
8079 TREE_PURPOSE (parms2)))
8083 permerror (input_location, "default argument mismatch in "
8084 "overload resolution");
8085 inform (input_location,
8086 " candidate 1: %q+#F", cand1->fn);
8087 inform (input_location,
8088 " candidate 2: %q+#F", cand2->fn);
8091 add_warning (cand1, cand2);
8094 parms1 = TREE_CHAIN (parms1);
8095 parms2 = TREE_CHAIN (parms2);
8103 /* Extension: If the worst conversion for one candidate is worse than the
8104 worst conversion for the other, take the first. */
8107 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
8108 struct z_candidate *w = 0, *l = 0;
8110 for (i = 0; i < len; ++i)
8112 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
8113 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
8114 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
8115 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
8118 winner = 1, w = cand1, l = cand2;
8120 winner = -1, w = cand2, l = cand1;
8123 /* Don't choose a deleted function over ambiguity. */
8124 if (DECL_P (w->fn) && DECL_DELETED_FN (w->fn))
8128 pedwarn (input_location, 0,
8129 "ISO C++ says that these are ambiguous, even "
8130 "though the worst conversion for the first is better than "
8131 "the worst conversion for the second:");
8132 print_z_candidate (_("candidate 1:"), w);
8133 print_z_candidate (_("candidate 2:"), l);
8141 gcc_assert (!winner);
8145 /* Given a list of candidates for overloading, find the best one, if any.
8146 This algorithm has a worst case of O(2n) (winner is last), and a best
8147 case of O(n/2) (totally ambiguous); much better than a sorting
8150 static struct z_candidate *
8151 tourney (struct z_candidate *candidates)
8153 struct z_candidate *champ = candidates, *challenger;
8155 int champ_compared_to_predecessor = 0;
8157 /* Walk through the list once, comparing each current champ to the next
8158 candidate, knocking out a candidate or two with each comparison. */
8160 for (challenger = champ->next; challenger; )
8162 fate = joust (champ, challenger, 0);
8164 challenger = challenger->next;
8169 champ = challenger->next;
8172 champ_compared_to_predecessor = 0;
8177 champ_compared_to_predecessor = 1;
8180 challenger = champ->next;
8184 /* Make sure the champ is better than all the candidates it hasn't yet
8185 been compared to. */
8187 for (challenger = candidates;
8189 && !(champ_compared_to_predecessor && challenger->next == champ);
8190 challenger = challenger->next)
8192 fate = joust (champ, challenger, 0);
8200 /* Returns nonzero if things of type FROM can be converted to TO. */
8203 can_convert (tree to, tree from)
8205 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
8208 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
8211 can_convert_arg (tree to, tree from, tree arg, int flags)
8217 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8218 p = conversion_obstack_alloc (0);
8220 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
8222 ok_p = (t && !t->bad_p);
8224 /* Free all the conversions we allocated. */
8225 obstack_free (&conversion_obstack, p);
8230 /* Like can_convert_arg, but allows dubious conversions as well. */
8233 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
8238 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8239 p = conversion_obstack_alloc (0);
8240 /* Try to perform the conversion. */
8241 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
8243 /* Free all the conversions we allocated. */
8244 obstack_free (&conversion_obstack, p);
8249 /* Convert EXPR to TYPE. Return the converted expression.
8251 Note that we allow bad conversions here because by the time we get to
8252 this point we are committed to doing the conversion. If we end up
8253 doing a bad conversion, convert_like will complain. */
8256 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
8261 if (error_operand_p (expr))
8262 return error_mark_node;
8264 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8265 p = conversion_obstack_alloc (0);
8267 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8273 if (complain & tf_error)
8275 /* If expr has unknown type, then it is an overloaded function.
8276 Call instantiate_type to get good error messages. */
8277 if (TREE_TYPE (expr) == unknown_type_node)
8278 instantiate_type (type, expr, complain);
8279 else if (invalid_nonstatic_memfn_p (expr, complain))
8280 /* We gave an error. */;
8282 error ("could not convert %qE to %qT", expr, type);
8284 expr = error_mark_node;
8286 else if (processing_template_decl)
8288 /* In a template, we are only concerned about determining the
8289 type of non-dependent expressions, so we do not have to
8290 perform the actual conversion. */
8291 if (TREE_TYPE (expr) != type)
8292 expr = build_nop (type, expr);
8295 expr = convert_like (conv, expr, complain);
8297 /* Free all the conversions we allocated. */
8298 obstack_free (&conversion_obstack, p);
8304 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
8306 return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
8309 /* Convert EXPR to TYPE (as a direct-initialization) if that is
8310 permitted. If the conversion is valid, the converted expression is
8311 returned. Otherwise, NULL_TREE is returned, except in the case
8312 that TYPE is a class type; in that case, an error is issued. If
8313 C_CAST_P is true, then this direction initialization is taking
8314 place as part of a static_cast being attempted as part of a C-style
8318 perform_direct_initialization_if_possible (tree type,
8321 tsubst_flags_t complain)
8326 if (type == error_mark_node || error_operand_p (expr))
8327 return error_mark_node;
8330 If the destination type is a (possibly cv-qualified) class type:
8332 -- If the initialization is direct-initialization ...,
8333 constructors are considered. ... If no constructor applies, or
8334 the overload resolution is ambiguous, the initialization is
8336 if (CLASS_TYPE_P (type))
8338 VEC(tree,gc) *args = make_tree_vector_single (expr);
8339 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
8340 &args, type, LOOKUP_NORMAL, complain);
8341 release_tree_vector (args);
8342 return build_cplus_new (type, expr, complain);
8345 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8346 p = conversion_obstack_alloc (0);
8348 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8351 if (!conv || conv->bad_p)
8354 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
8355 /*issue_conversion_warnings=*/false,
8359 /* Free all the conversions we allocated. */
8360 obstack_free (&conversion_obstack, p);
8365 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
8366 is being bound to a temporary. Create and return a new VAR_DECL
8367 with the indicated TYPE; this variable will store the value to
8368 which the reference is bound. */
8371 make_temporary_var_for_ref_to_temp (tree decl, tree type)
8375 /* Create the variable. */
8376 var = create_temporary_var (type);
8378 /* Register the variable. */
8379 if (TREE_STATIC (decl))
8381 /* Namespace-scope or local static; give it a mangled name. */
8384 TREE_STATIC (var) = 1;
8385 name = mangle_ref_init_variable (decl);
8386 DECL_NAME (var) = name;
8387 SET_DECL_ASSEMBLER_NAME (var, name);
8388 var = pushdecl_top_level (var);
8391 /* Create a new cleanup level if necessary. */
8392 maybe_push_cleanup_level (type);
8397 /* EXPR is the initializer for a variable DECL of reference or
8398 std::initializer_list type. Create, push and return a new VAR_DECL
8399 for the initializer so that it will live as long as DECL. Any
8400 cleanup for the new variable is returned through CLEANUP, and the
8401 code to initialize the new variable is returned through INITP. */
8404 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
8410 /* Create the temporary variable. */
8411 type = TREE_TYPE (expr);
8412 var = make_temporary_var_for_ref_to_temp (decl, type);
8413 layout_decl (var, 0);
8414 /* If the rvalue is the result of a function call it will be
8415 a TARGET_EXPR. If it is some other construct (such as a
8416 member access expression where the underlying object is
8417 itself the result of a function call), turn it into a
8418 TARGET_EXPR here. It is important that EXPR be a
8419 TARGET_EXPR below since otherwise the INIT_EXPR will
8420 attempt to make a bitwise copy of EXPR to initialize
8422 if (TREE_CODE (expr) != TARGET_EXPR)
8423 expr = get_target_expr (expr);
8425 /* If the initializer is constant, put it in DECL_INITIAL so we get
8426 static initialization and use in constant expressions. */
8427 init = maybe_constant_init (expr);
8428 if (TREE_CONSTANT (init))
8430 if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
8432 /* 5.19 says that a constant expression can include an
8433 lvalue-rvalue conversion applied to "a glvalue of literal type
8434 that refers to a non-volatile temporary object initialized
8435 with a constant expression". Rather than try to communicate
8436 that this VAR_DECL is a temporary, just mark it constexpr.
8438 Currently this is only useful for initializer_list temporaries,
8439 since reference vars can't appear in constant expressions. */
8440 DECL_DECLARED_CONSTEXPR_P (var) = true;
8441 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var) = true;
8442 TREE_CONSTANT (var) = true;
8444 DECL_INITIAL (var) = init;
8448 /* Create the INIT_EXPR that will initialize the temporary
8450 init = build2 (INIT_EXPR, type, var, expr);
8451 if (at_function_scope_p ())
8453 add_decl_expr (var);
8455 if (TREE_STATIC (var))
8456 init = add_stmt_to_compound (init, register_dtor_fn (var));
8458 *cleanup = cxx_maybe_build_cleanup (var, tf_warning_or_error);
8460 /* We must be careful to destroy the temporary only
8461 after its initialization has taken place. If the
8462 initialization throws an exception, then the
8463 destructor should not be run. We cannot simply
8464 transform INIT into something like:
8466 (INIT, ({ CLEANUP_STMT; }))
8468 because emit_local_var always treats the
8469 initializer as a full-expression. Thus, the
8470 destructor would run too early; it would run at the
8471 end of initializing the reference variable, rather
8472 than at the end of the block enclosing the
8475 The solution is to pass back a cleanup expression
8476 which the caller is responsible for attaching to
8477 the statement tree. */
8481 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
8482 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8483 static_aggregates = tree_cons (NULL_TREE, var,
8491 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
8492 initializing a variable of that TYPE. If DECL is non-NULL, it is
8493 the VAR_DECL being initialized with the EXPR. (In that case, the
8494 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
8495 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
8496 return, if *CLEANUP is no longer NULL, it will be an expression
8497 that should be pushed as a cleanup after the returned expression
8498 is used to initialize DECL.
8500 Return the converted expression. */
8503 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
8504 tsubst_flags_t complain)
8509 if (type == error_mark_node || error_operand_p (expr))
8510 return error_mark_node;
8512 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8513 p = conversion_obstack_alloc (0);
8515 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
8517 if (!conv || conv->bad_p)
8519 if (complain & tf_error)
8521 if (!CP_TYPE_CONST_P (TREE_TYPE (type))
8522 && !TYPE_REF_IS_RVALUE (type)
8523 && !real_lvalue_p (expr))
8524 error ("invalid initialization of non-const reference of "
8525 "type %qT from an rvalue of type %qT",
8526 type, TREE_TYPE (expr));
8528 error ("invalid initialization of reference of type "
8529 "%qT from expression of type %qT", type,
8532 return error_mark_node;
8535 /* If DECL is non-NULL, then this special rule applies:
8539 The temporary to which the reference is bound or the temporary
8540 that is the complete object to which the reference is bound
8541 persists for the lifetime of the reference.
8543 The temporaries created during the evaluation of the expression
8544 initializing the reference, except the temporary to which the
8545 reference is bound, are destroyed at the end of the
8546 full-expression in which they are created.
8548 In that case, we store the converted expression into a new
8549 VAR_DECL in a new scope.
8551 However, we want to be careful not to create temporaries when
8552 they are not required. For example, given:
8555 struct D : public B {};
8559 there is no need to copy the return value from "f"; we can just
8560 extend its lifetime. Similarly, given:
8563 struct T { operator S(); };
8567 we can extend the lifetime of the return value of the conversion
8569 gcc_assert (conv->kind == ck_ref_bind);
8573 tree base_conv_type;
8575 /* Skip over the REF_BIND. */
8576 conv = conv->u.next;
8577 /* If the next conversion is a BASE_CONV, skip that too -- but
8578 remember that the conversion was required. */
8579 if (conv->kind == ck_base)
8581 base_conv_type = conv->type;
8582 conv = conv->u.next;
8585 base_conv_type = NULL_TREE;
8586 /* Perform the remainder of the conversion. */
8587 expr = convert_like_real (conv, expr,
8588 /*fn=*/NULL_TREE, /*argnum=*/0,
8590 /*issue_conversion_warnings=*/true,
8592 tf_warning_or_error);
8593 if (error_operand_p (expr))
8594 expr = error_mark_node;
8597 if (!lvalue_or_rvalue_with_address_p (expr))
8600 var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
8601 /* Use its address to initialize the reference variable. */
8602 expr = build_address (var);
8604 expr = convert_to_base (expr,
8605 build_pointer_type (base_conv_type),
8606 /*check_access=*/true,
8607 /*nonnull=*/true, complain);
8609 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
8612 /* Take the address of EXPR. */
8613 expr = cp_build_addr_expr (expr, tf_warning_or_error);
8614 /* If a BASE_CONV was required, perform it now. */
8616 expr = (perform_implicit_conversion
8617 (build_pointer_type (base_conv_type), expr,
8618 tf_warning_or_error));
8619 expr = build_nop (type, expr);
8623 /* Perform the conversion. */
8624 expr = convert_like (conv, expr, tf_warning_or_error);
8626 /* Free all the conversions we allocated. */
8627 obstack_free (&conversion_obstack, p);
8632 /* Returns true iff TYPE is some variant of std::initializer_list. */
8635 is_std_init_list (tree type)
8637 /* Look through typedefs. */
8640 type = TYPE_MAIN_VARIANT (type);
8641 return (CLASS_TYPE_P (type)
8642 && CP_TYPE_CONTEXT (type) == std_node
8643 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
8646 /* Returns true iff DECL is a list constructor: i.e. a constructor which
8647 will accept an argument list of a single std::initializer_list<T>. */
8650 is_list_ctor (tree decl)
8652 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
8655 if (!args || args == void_list_node)
8658 arg = non_reference (TREE_VALUE (args));
8659 if (!is_std_init_list (arg))
8662 args = TREE_CHAIN (args);
8664 if (args && args != void_list_node && !TREE_PURPOSE (args))
8665 /* There are more non-defaulted parms. */
8671 #include "gt-cp-call.h"