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 {
432 rr_explicit_conversion,
434 rr_bad_arg_conversion
437 struct conversion_info {
438 /* The index of the argument, 0-based. */
440 /* The type of the actual argument. */
442 /* The type of the formal argument. */
446 struct rejection_reason {
447 enum rejection_reason_code code;
449 /* Information about an arity mismatch. */
451 /* The expected number of arguments. */
453 /* The actual number of arguments in the call. */
455 /* Whether the call was a varargs call. */
458 /* Information about an argument conversion mismatch. */
459 struct conversion_info conversion;
460 /* Same, but for bad argument conversions. */
461 struct conversion_info bad_conversion;
466 /* The FUNCTION_DECL that will be called if this candidate is
467 selected by overload resolution. */
469 /* If not NULL_TREE, the first argument to use when calling this
472 /* The rest of the arguments to use when calling this function. If
473 there are no further arguments this may be NULL or it may be an
475 const VEC(tree,gc) *args;
476 /* The implicit conversion sequences for each of the arguments to
479 /* The number of implicit conversion sequences. */
481 /* If FN is a user-defined conversion, the standard conversion
482 sequence from the type returned by FN to the desired destination
484 conversion *second_conv;
486 struct rejection_reason *reason;
487 /* If FN is a member function, the binfo indicating the path used to
488 qualify the name of FN at the call site. This path is used to
489 determine whether or not FN is accessible if it is selected by
490 overload resolution. The DECL_CONTEXT of FN will always be a
491 (possibly improper) base of this binfo. */
493 /* If FN is a non-static member function, the binfo indicating the
494 subobject to which the `this' pointer should be converted if FN
495 is selected by overload resolution. The type pointed to the by
496 the `this' pointer must correspond to the most derived class
497 indicated by the CONVERSION_PATH. */
498 tree conversion_path;
501 candidate_warning *warnings;
505 /* Returns true iff T is a null pointer constant in the sense of
509 null_ptr_cst_p (tree t)
513 A null pointer constant is an integral constant expression
514 (_expr.const_) rvalue of integer type that evaluates to zero or
515 an rvalue of type std::nullptr_t. */
516 if (NULLPTR_TYPE_P (TREE_TYPE (t)))
518 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)))
520 if (cxx_dialect >= cxx0x)
522 t = fold_non_dependent_expr (t);
523 t = maybe_constant_value (t);
524 if (TREE_CONSTANT (t) && integer_zerop (t))
529 t = integral_constant_value (t);
531 if (integer_zerop (t) && !TREE_OVERFLOW (t))
538 /* Returns nonzero if PARMLIST consists of only default parms,
539 ellipsis, and/or undeduced parameter packs. */
542 sufficient_parms_p (const_tree parmlist)
544 for (; parmlist && parmlist != void_list_node;
545 parmlist = TREE_CHAIN (parmlist))
546 if (!TREE_PURPOSE (parmlist)
547 && !PACK_EXPANSION_P (TREE_VALUE (parmlist)))
552 /* Allocate N bytes of memory from the conversion obstack. The memory
553 is zeroed before being returned. */
556 conversion_obstack_alloc (size_t n)
559 if (!conversion_obstack_initialized)
561 gcc_obstack_init (&conversion_obstack);
562 conversion_obstack_initialized = true;
564 p = obstack_alloc (&conversion_obstack, n);
569 /* Allocate rejection reasons. */
571 static struct rejection_reason *
572 alloc_rejection (enum rejection_reason_code code)
574 struct rejection_reason *p;
575 p = (struct rejection_reason *) conversion_obstack_alloc (sizeof *p);
580 static struct rejection_reason *
581 arity_rejection (tree first_arg, int expected, int actual)
583 struct rejection_reason *r = alloc_rejection (rr_arity);
584 int adjust = first_arg != NULL_TREE;
585 r->u.arity.expected = expected - adjust;
586 r->u.arity.actual = actual - adjust;
590 static struct rejection_reason *
591 arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to)
593 struct rejection_reason *r = alloc_rejection (rr_arg_conversion);
594 int adjust = first_arg != NULL_TREE;
595 r->u.conversion.n_arg = n_arg - adjust;
596 r->u.conversion.from_type = from;
597 r->u.conversion.to_type = to;
601 static struct rejection_reason *
602 bad_arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to)
604 struct rejection_reason *r = alloc_rejection (rr_bad_arg_conversion);
605 int adjust = first_arg != NULL_TREE;
606 r->u.bad_conversion.n_arg = n_arg - adjust;
607 r->u.bad_conversion.from_type = from;
608 r->u.bad_conversion.to_type = to;
612 static struct rejection_reason *
613 explicit_conversion_rejection (tree from, tree to)
615 struct rejection_reason *r = alloc_rejection (rr_explicit_conversion);
616 r->u.conversion.n_arg = 0;
617 r->u.conversion.from_type = from;
618 r->u.conversion.to_type = to;
622 /* Dynamically allocate a conversion. */
625 alloc_conversion (conversion_kind kind)
628 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
633 #ifdef ENABLE_CHECKING
635 /* Make sure that all memory on the conversion obstack has been
639 validate_conversion_obstack (void)
641 if (conversion_obstack_initialized)
642 gcc_assert ((obstack_next_free (&conversion_obstack)
643 == obstack_base (&conversion_obstack)));
646 #endif /* ENABLE_CHECKING */
648 /* Dynamically allocate an array of N conversions. */
651 alloc_conversions (size_t n)
653 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
657 build_conv (conversion_kind code, tree type, conversion *from)
660 conversion_rank rank = CONVERSION_RANK (from);
662 /* Note that the caller is responsible for filling in t->cand for
663 user-defined conversions. */
664 t = alloc_conversion (code);
687 t->user_conv_p = (code == ck_user || from->user_conv_p);
688 t->bad_p = from->bad_p;
693 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
694 specialization of std::initializer_list<T>, if such a conversion is
698 build_list_conv (tree type, tree ctor, int flags)
700 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
701 unsigned len = CONSTRUCTOR_NELTS (ctor);
702 conversion **subconvs = alloc_conversions (len);
707 /* Within a list-initialization we can have more user-defined
709 flags &= ~LOOKUP_NO_CONVERSION;
710 /* But no narrowing conversions. */
711 flags |= LOOKUP_NO_NARROWING;
713 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
716 = implicit_conversion (elttype, TREE_TYPE (val), val,
724 t = alloc_conversion (ck_list);
726 t->u.list = subconvs;
729 for (i = 0; i < len; ++i)
731 conversion *sub = subconvs[i];
732 if (sub->rank > t->rank)
734 if (sub->user_conv_p)
735 t->user_conv_p = true;
743 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
744 is a valid aggregate initializer for array type ATYPE. */
747 can_convert_array (tree atype, tree ctor, int flags)
750 tree elttype = TREE_TYPE (atype);
751 for (i = 0; i < CONSTRUCTOR_NELTS (ctor); ++i)
753 tree val = CONSTRUCTOR_ELT (ctor, i)->value;
755 if (TREE_CODE (elttype) == ARRAY_TYPE
756 && TREE_CODE (val) == CONSTRUCTOR)
757 ok = can_convert_array (elttype, val, flags);
759 ok = can_convert_arg (elttype, TREE_TYPE (val), val, flags);
766 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
767 aggregate class, if such a conversion is possible. */
770 build_aggr_conv (tree type, tree ctor, int flags)
772 unsigned HOST_WIDE_INT i = 0;
774 tree field = next_initializable_field (TYPE_FIELDS (type));
775 tree empty_ctor = NULL_TREE;
777 for (; field; field = next_initializable_field (DECL_CHAIN (field)))
779 tree ftype = TREE_TYPE (field);
783 if (i < CONSTRUCTOR_NELTS (ctor))
784 val = CONSTRUCTOR_ELT (ctor, i)->value;
787 if (empty_ctor == NULL_TREE)
788 empty_ctor = build_constructor (init_list_type_node, NULL);
793 if (TREE_CODE (ftype) == ARRAY_TYPE
794 && TREE_CODE (val) == CONSTRUCTOR)
795 ok = can_convert_array (ftype, val, flags);
797 ok = can_convert_arg (ftype, TREE_TYPE (val), val, flags);
802 if (TREE_CODE (type) == UNION_TYPE)
806 if (i < CONSTRUCTOR_NELTS (ctor))
809 c = alloc_conversion (ck_aggr);
812 c->user_conv_p = true;
817 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
818 array type, if such a conversion is possible. */
821 build_array_conv (tree type, tree ctor, int flags)
824 unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
825 tree elttype = TREE_TYPE (type);
830 enum conversion_rank rank = cr_exact;
832 if (TYPE_DOMAIN (type))
834 unsigned HOST_WIDE_INT alen = tree_low_cst (array_type_nelts_top (type), 1);
839 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
842 = implicit_conversion (elttype, TREE_TYPE (val), val,
847 if (sub->rank > rank)
849 if (sub->user_conv_p)
855 c = alloc_conversion (ck_aggr);
858 c->user_conv_p = user;
864 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
865 complex type, if such a conversion is possible. */
868 build_complex_conv (tree type, tree ctor, int flags)
871 unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
872 tree elttype = TREE_TYPE (type);
877 enum conversion_rank rank = cr_exact;
882 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
885 = implicit_conversion (elttype, TREE_TYPE (val), val,
890 if (sub->rank > rank)
892 if (sub->user_conv_p)
898 c = alloc_conversion (ck_aggr);
901 c->user_conv_p = user;
907 /* Build a representation of the identity conversion from EXPR to
908 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
911 build_identity_conv (tree type, tree expr)
915 c = alloc_conversion (ck_identity);
922 /* Converting from EXPR to TYPE was ambiguous in the sense that there
923 were multiple user-defined conversions to accomplish the job.
924 Build a conversion that indicates that ambiguity. */
927 build_ambiguous_conv (tree type, tree expr)
931 c = alloc_conversion (ck_ambig);
939 strip_top_quals (tree t)
941 if (TREE_CODE (t) == ARRAY_TYPE)
943 return cp_build_qualified_type (t, 0);
946 /* Returns the standard conversion path (see [conv]) from type FROM to type
947 TO, if any. For proper handling of null pointer constants, you must
948 also pass the expression EXPR to convert from. If C_CAST_P is true,
949 this conversion is coming from a C-style cast. */
952 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
955 enum tree_code fcode, tcode;
957 bool fromref = false;
960 to = non_reference (to);
961 if (TREE_CODE (from) == REFERENCE_TYPE)
964 from = TREE_TYPE (from);
967 to = strip_top_quals (to);
968 from = strip_top_quals (from);
970 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
971 && expr && type_unknown_p (expr))
973 tsubst_flags_t tflags = tf_conv;
974 if (!(flags & LOOKUP_PROTECT))
975 tflags |= tf_no_access_control;
976 expr = instantiate_type (to, expr, tflags);
977 if (expr == error_mark_node)
979 from = TREE_TYPE (expr);
982 fcode = TREE_CODE (from);
983 tcode = TREE_CODE (to);
985 conv = build_identity_conv (from, expr);
986 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
988 from = type_decays_to (from);
989 fcode = TREE_CODE (from);
990 conv = build_conv (ck_lvalue, from, conv);
992 else if (fromref || (expr && lvalue_p (expr)))
997 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
1000 from = strip_top_quals (bitfield_type);
1001 fcode = TREE_CODE (from);
1004 conv = build_conv (ck_rvalue, from, conv);
1005 if (flags & LOOKUP_PREFER_RVALUE)
1006 conv->rvaluedness_matches_p = true;
1009 /* Allow conversion between `__complex__' data types. */
1010 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
1012 /* The standard conversion sequence to convert FROM to TO is
1013 the standard conversion sequence to perform componentwise
1015 conversion *part_conv = standard_conversion
1016 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
1020 conv = build_conv (part_conv->kind, to, conv);
1021 conv->rank = part_conv->rank;
1029 if (same_type_p (from, to))
1031 if (CLASS_TYPE_P (to) && conv->kind == ck_rvalue)
1032 conv->type = qualified_to;
1037 A null pointer constant can be converted to a pointer type; ... A
1038 null pointer constant of integral type can be converted to an
1039 rvalue of type std::nullptr_t. */
1040 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)
1041 || NULLPTR_TYPE_P (to))
1042 && expr && null_ptr_cst_p (expr))
1043 conv = build_conv (ck_std, to, conv);
1044 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
1045 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
1047 /* For backwards brain damage compatibility, allow interconversion of
1048 pointers and integers with a pedwarn. */
1049 conv = build_conv (ck_std, to, conv);
1052 else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
1054 /* For backwards brain damage compatibility, allow interconversion of
1055 enums and integers with a pedwarn. */
1056 conv = build_conv (ck_std, to, conv);
1059 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
1060 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
1065 if (tcode == POINTER_TYPE
1066 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
1069 else if (VOID_TYPE_P (TREE_TYPE (to))
1070 && !TYPE_PTRMEM_P (from)
1071 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
1073 tree nfrom = TREE_TYPE (from);
1074 from = build_pointer_type
1075 (cp_build_qualified_type (void_type_node,
1076 cp_type_quals (nfrom)));
1077 conv = build_conv (ck_ptr, from, conv);
1079 else if (TYPE_PTRMEM_P (from))
1081 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
1082 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
1084 if (DERIVED_FROM_P (fbase, tbase)
1085 && (same_type_ignoring_top_level_qualifiers_p
1086 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
1087 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
1089 from = build_ptrmem_type (tbase,
1090 TYPE_PTRMEM_POINTED_TO_TYPE (from));
1091 conv = build_conv (ck_pmem, from, conv);
1093 else if (!same_type_p (fbase, tbase))
1096 else if (CLASS_TYPE_P (TREE_TYPE (from))
1097 && CLASS_TYPE_P (TREE_TYPE (to))
1100 An rvalue of type "pointer to cv D," where D is a
1101 class type, can be converted to an rvalue of type
1102 "pointer to cv B," where B is a base class (clause
1103 _class.derived_) of D. If B is an inaccessible
1104 (clause _class.access_) or ambiguous
1105 (_class.member.lookup_) base class of D, a program
1106 that necessitates this conversion is ill-formed.
1107 Therefore, we use DERIVED_FROM_P, and do not check
1108 access or uniqueness. */
1109 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
1112 cp_build_qualified_type (TREE_TYPE (to),
1113 cp_type_quals (TREE_TYPE (from)));
1114 from = build_pointer_type (from);
1115 conv = build_conv (ck_ptr, from, conv);
1116 conv->base_p = true;
1119 if (tcode == POINTER_TYPE)
1121 to_pointee = TREE_TYPE (to);
1122 from_pointee = TREE_TYPE (from);
1126 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
1127 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
1130 if (same_type_p (from, to))
1132 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
1133 /* In a C-style cast, we ignore CV-qualification because we
1134 are allowed to perform a static_cast followed by a
1136 conv = build_conv (ck_qual, to, conv);
1137 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
1138 conv = build_conv (ck_qual, to, conv);
1139 else if (expr && string_conv_p (to, expr, 0))
1140 /* converting from string constant to char *. */
1141 conv = build_conv (ck_qual, to, conv);
1142 /* Allow conversions among compatible ObjC pointer types (base
1143 conversions have been already handled above). */
1144 else if (c_dialect_objc ()
1145 && objc_compare_types (to, from, -4, NULL_TREE))
1146 conv = build_conv (ck_ptr, to, conv);
1147 else if (ptr_reasonably_similar (to_pointee, from_pointee))
1149 conv = build_conv (ck_ptr, to, conv);
1157 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
1159 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
1160 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
1161 tree fbase = class_of_this_parm (fromfn);
1162 tree tbase = class_of_this_parm (tofn);
1164 if (!DERIVED_FROM_P (fbase, tbase)
1165 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
1166 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
1167 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
1168 || cp_type_quals (fbase) != cp_type_quals (tbase))
1171 from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
1172 from = build_ptrmemfunc_type (build_pointer_type (from));
1173 conv = build_conv (ck_pmem, from, conv);
1174 conv->base_p = true;
1176 else if (tcode == BOOLEAN_TYPE)
1180 An rvalue of arithmetic, unscoped enumeration, pointer, or
1181 pointer to member type can be converted to an rvalue of type
1182 bool. ... An rvalue of type std::nullptr_t can be converted
1183 to an rvalue of type bool; */
1184 if (ARITHMETIC_TYPE_P (from)
1185 || UNSCOPED_ENUM_P (from)
1186 || fcode == POINTER_TYPE
1187 || TYPE_PTR_TO_MEMBER_P (from)
1188 || NULLPTR_TYPE_P (from))
1190 conv = build_conv (ck_std, to, conv);
1191 if (fcode == POINTER_TYPE
1192 || TYPE_PTRMEM_P (from)
1193 || (TYPE_PTRMEMFUNC_P (from)
1194 && conv->rank < cr_pbool)
1195 || NULLPTR_TYPE_P (from))
1196 conv->rank = cr_pbool;
1202 /* We don't check for ENUMERAL_TYPE here because there are no standard
1203 conversions to enum type. */
1204 /* As an extension, allow conversion to complex type. */
1205 else if (ARITHMETIC_TYPE_P (to))
1207 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
1208 || SCOPED_ENUM_P (from))
1210 conv = build_conv (ck_std, to, conv);
1212 /* Give this a better rank if it's a promotion. */
1213 if (same_type_p (to, type_promotes_to (from))
1214 && conv->u.next->rank <= cr_promotion)
1215 conv->rank = cr_promotion;
1217 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
1218 && vector_types_convertible_p (from, to, false))
1219 return build_conv (ck_std, to, conv);
1220 else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
1221 && is_properly_derived_from (from, to))
1223 if (conv->kind == ck_rvalue)
1224 conv = conv->u.next;
1225 conv = build_conv (ck_base, to, conv);
1226 /* The derived-to-base conversion indicates the initialization
1227 of a parameter with base type from an object of a derived
1228 type. A temporary object is created to hold the result of
1229 the conversion unless we're binding directly to a reference. */
1230 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
1235 if (flags & LOOKUP_NO_NARROWING)
1236 conv->check_narrowing = true;
1241 /* Returns nonzero if T1 is reference-related to T2. */
1244 reference_related_p (tree t1, tree t2)
1246 if (t1 == error_mark_node || t2 == error_mark_node)
1249 t1 = TYPE_MAIN_VARIANT (t1);
1250 t2 = TYPE_MAIN_VARIANT (t2);
1254 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1255 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1257 return (same_type_p (t1, t2)
1258 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
1259 && DERIVED_FROM_P (t1, t2)));
1262 /* Returns nonzero if T1 is reference-compatible with T2. */
1265 reference_compatible_p (tree t1, tree t2)
1269 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1270 reference-related to T2 and cv1 is the same cv-qualification as,
1271 or greater cv-qualification than, cv2. */
1272 return (reference_related_p (t1, t2)
1273 && at_least_as_qualified_p (t1, t2));
1276 /* Determine whether or not the EXPR (of class type S) can be
1277 converted to T as in [over.match.ref]. */
1280 convert_class_to_reference_1 (tree reference_type, tree s, tree expr, int flags)
1286 struct z_candidate *candidates;
1287 struct z_candidate *cand;
1293 conversions = lookup_conversions (s);
1299 Assuming that "cv1 T" is the underlying type of the reference
1300 being initialized, and "cv S" is the type of the initializer
1301 expression, with S a class type, the candidate functions are
1302 selected as follows:
1304 --The conversion functions of S and its base classes are
1305 considered. Those that are not hidden within S and yield type
1306 "reference to cv2 T2", where "cv1 T" is reference-compatible
1307 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1309 The argument list has one argument, which is the initializer
1314 /* Conceptually, we should take the address of EXPR and put it in
1315 the argument list. Unfortunately, however, that can result in
1316 error messages, which we should not issue now because we are just
1317 trying to find a conversion operator. Therefore, we use NULL,
1318 cast to the appropriate type. */
1319 first_arg = build_int_cst (build_pointer_type (s), 0);
1321 t = TREE_TYPE (reference_type);
1323 /* We're performing a user-defined conversion to a desired type, so set
1324 this for the benefit of add_candidates. */
1325 flags |= LOOKUP_NO_CONVERSION;
1327 for (; conversions; conversions = TREE_CHAIN (conversions))
1329 tree fns = TREE_VALUE (conversions);
1330 tree binfo = TREE_PURPOSE (conversions);
1331 struct z_candidate *old_candidates = candidates;;
1333 add_candidates (fns, first_arg, NULL, reference_type,
1335 binfo, TYPE_BINFO (s),
1336 flags, &candidates);
1338 for (cand = candidates; cand != old_candidates; cand = cand->next)
1340 /* Now, see if the conversion function really returns
1341 an lvalue of the appropriate type. From the
1342 point of view of unification, simply returning an
1343 rvalue of the right type is good enough. */
1345 tree t2 = TREE_TYPE (TREE_TYPE (f));
1346 if (cand->viable == 0)
1347 /* Don't bother looking more closely. */;
1348 else if (TREE_CODE (t2) != REFERENCE_TYPE
1349 || !reference_compatible_p (t, TREE_TYPE (t2)))
1351 /* No need to set cand->reason here; this is most likely
1352 an ambiguous match. If it's not, either this candidate
1353 will win, or we will have identified a reason for it
1359 conversion *identity_conv;
1360 /* Build a standard conversion sequence indicating the
1361 binding from the reference type returned by the
1362 function to the desired REFERENCE_TYPE. */
1364 = build_identity_conv (TREE_TYPE (TREE_TYPE
1365 (TREE_TYPE (cand->fn))),
1368 = (direct_reference_binding
1369 (reference_type, identity_conv));
1370 cand->second_conv->rvaluedness_matches_p
1371 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1372 == TYPE_REF_IS_RVALUE (reference_type);
1373 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1375 /* Don't allow binding of lvalues to rvalue references. */
1376 if (TYPE_REF_IS_RVALUE (reference_type)
1377 /* Function lvalues are OK, though. */
1378 && TREE_CODE (TREE_TYPE (reference_type)) != FUNCTION_TYPE
1379 && !TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn))))
1380 cand->second_conv->bad_p = true;
1385 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1386 /* If none of the conversion functions worked out, let our caller
1391 cand = tourney (candidates);
1395 /* Now that we know that this is the function we're going to use fix
1396 the dummy first argument. */
1397 gcc_assert (cand->first_arg == NULL_TREE
1398 || integer_zerop (cand->first_arg));
1399 cand->first_arg = build_this (expr);
1401 /* Build a user-defined conversion sequence representing the
1403 conv = build_conv (ck_user,
1404 TREE_TYPE (TREE_TYPE (cand->fn)),
1405 build_identity_conv (TREE_TYPE (expr), expr));
1408 if (cand->viable == -1)
1411 /* Merge it with the standard conversion sequence from the
1412 conversion function's return type to the desired type. */
1413 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1415 return cand->second_conv;
1418 /* Wrapper for above. */
1421 convert_class_to_reference (tree reference_type, tree s, tree expr, int flags)
1424 bool subtime = timevar_cond_start (TV_OVERLOAD);
1425 ret = convert_class_to_reference_1 (reference_type, s, expr, flags);
1426 timevar_cond_stop (TV_OVERLOAD, subtime);
1430 /* A reference of the indicated TYPE is being bound directly to the
1431 expression represented by the implicit conversion sequence CONV.
1432 Return a conversion sequence for this binding. */
1435 direct_reference_binding (tree type, conversion *conv)
1439 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1440 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1442 t = TREE_TYPE (type);
1446 When a parameter of reference type binds directly
1447 (_dcl.init.ref_) to an argument expression, the implicit
1448 conversion sequence is the identity conversion, unless the
1449 argument expression has a type that is a derived class of the
1450 parameter type, in which case the implicit conversion sequence is
1451 a derived-to-base Conversion.
1453 If the parameter binds directly to the result of applying a
1454 conversion function to the argument expression, the implicit
1455 conversion sequence is a user-defined conversion sequence
1456 (_over.ics.user_), with the second standard conversion sequence
1457 either an identity conversion or, if the conversion function
1458 returns an entity of a type that is a derived class of the
1459 parameter type, a derived-to-base conversion. */
1460 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1462 /* Represent the derived-to-base conversion. */
1463 conv = build_conv (ck_base, t, conv);
1464 /* We will actually be binding to the base-class subobject in
1465 the derived class, so we mark this conversion appropriately.
1466 That way, convert_like knows not to generate a temporary. */
1467 conv->need_temporary_p = false;
1469 return build_conv (ck_ref_bind, type, conv);
1472 /* Returns the conversion path from type FROM to reference type TO for
1473 purposes of reference binding. For lvalue binding, either pass a
1474 reference type to FROM or an lvalue expression to EXPR. If the
1475 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1476 the conversion returned. If C_CAST_P is true, this
1477 conversion is coming from a C-style cast. */
1480 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1482 conversion *conv = NULL;
1483 tree to = TREE_TYPE (rto);
1488 cp_lvalue_kind is_lvalue = clk_none;
1490 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1492 expr = instantiate_type (to, expr, tf_none);
1493 if (expr == error_mark_node)
1495 from = TREE_TYPE (expr);
1498 if (TREE_CODE (from) == REFERENCE_TYPE)
1500 /* Anything with reference type is an lvalue. */
1501 is_lvalue = clk_ordinary;
1502 from = TREE_TYPE (from);
1505 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1507 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1508 conv = implicit_conversion (to, from, expr, c_cast_p,
1510 if (!CLASS_TYPE_P (to)
1511 && CONSTRUCTOR_NELTS (expr) == 1)
1513 expr = CONSTRUCTOR_ELT (expr, 0)->value;
1514 if (error_operand_p (expr))
1516 from = TREE_TYPE (expr);
1520 if (is_lvalue == clk_none && expr)
1521 is_lvalue = real_lvalue_p (expr);
1524 if ((is_lvalue & clk_bitfield) != 0)
1525 tfrom = unlowered_expr_type (expr);
1527 /* Figure out whether or not the types are reference-related and
1528 reference compatible. We have do do this after stripping
1529 references from FROM. */
1530 related_p = reference_related_p (to, tfrom);
1531 /* If this is a C cast, first convert to an appropriately qualified
1532 type, so that we can later do a const_cast to the desired type. */
1533 if (related_p && c_cast_p
1534 && !at_least_as_qualified_p (to, tfrom))
1535 to = cp_build_qualified_type (to, cp_type_quals (tfrom));
1536 compatible_p = reference_compatible_p (to, tfrom);
1538 /* Directly bind reference when target expression's type is compatible with
1539 the reference and expression is an lvalue. In DR391, the wording in
1540 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1541 const and rvalue references to rvalues of compatible class type.
1542 We should also do direct bindings for non-class "rvalues" derived from
1543 rvalue references. */
1546 || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1547 && !(flags & LOOKUP_NO_TEMP_BIND))
1548 || TYPE_REF_IS_RVALUE (rto))
1549 && (CLASS_TYPE_P (from)
1550 || TREE_CODE (from) == ARRAY_TYPE
1551 || (expr && lvalue_p (expr))))))
1555 If the initializer expression
1557 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1558 is reference-compatible with "cv2 T2,"
1560 the reference is bound directly to the initializer expression
1564 If the initializer expression is an rvalue, with T2 a class type,
1565 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1566 is bound to the object represented by the rvalue or to a sub-object
1567 within that object. */
1569 conv = build_identity_conv (tfrom, expr);
1570 conv = direct_reference_binding (rto, conv);
1572 if (flags & LOOKUP_PREFER_RVALUE)
1573 /* The top-level caller requested that we pretend that the lvalue
1574 be treated as an rvalue. */
1575 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1577 conv->rvaluedness_matches_p
1578 = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1580 if ((is_lvalue & clk_bitfield) != 0
1581 || ((is_lvalue & clk_packed) != 0 && !TYPE_PACKED (to)))
1582 /* For the purposes of overload resolution, we ignore the fact
1583 this expression is a bitfield or packed field. (In particular,
1584 [over.ics.ref] says specifically that a function with a
1585 non-const reference parameter is viable even if the
1586 argument is a bitfield.)
1588 However, when we actually call the function we must create
1589 a temporary to which to bind the reference. If the
1590 reference is volatile, or isn't const, then we cannot make
1591 a temporary, so we just issue an error when the conversion
1593 conv->need_temporary_p = true;
1595 /* Don't allow binding of lvalues (other than function lvalues) to
1596 rvalue references. */
1597 if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1598 && TREE_CODE (to) != FUNCTION_TYPE
1599 && !(flags & LOOKUP_PREFER_RVALUE))
1604 /* [class.conv.fct] A conversion function is never used to convert a
1605 (possibly cv-qualified) object to the (possibly cv-qualified) same
1606 object type (or a reference to it), to a (possibly cv-qualified) base
1607 class of that type (or a reference to it).... */
1608 else if (CLASS_TYPE_P (from) && !related_p
1609 && !(flags & LOOKUP_NO_CONVERSION))
1613 If the initializer expression
1615 -- has a class type (i.e., T2 is a class type) can be
1616 implicitly converted to an lvalue of type "cv3 T3," where
1617 "cv1 T1" is reference-compatible with "cv3 T3". (this
1618 conversion is selected by enumerating the applicable
1619 conversion functions (_over.match.ref_) and choosing the
1620 best one through overload resolution. (_over.match_).
1622 the reference is bound to the lvalue result of the conversion
1623 in the second case. */
1624 conv = convert_class_to_reference (rto, from, expr, flags);
1629 /* From this point on, we conceptually need temporaries, even if we
1630 elide them. Only the cases above are "direct bindings". */
1631 if (flags & LOOKUP_NO_TEMP_BIND)
1636 When a parameter of reference type is not bound directly to an
1637 argument expression, the conversion sequence is the one required
1638 to convert the argument expression to the underlying type of the
1639 reference according to _over.best.ics_. Conceptually, this
1640 conversion sequence corresponds to copy-initializing a temporary
1641 of the underlying type with the argument expression. Any
1642 difference in top-level cv-qualification is subsumed by the
1643 initialization itself and does not constitute a conversion. */
1647 Otherwise, the reference shall be to a non-volatile const type.
1649 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1650 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1655 Otherwise, a temporary of type "cv1 T1" is created and
1656 initialized from the initializer expression using the rules for a
1657 non-reference copy initialization. If T1 is reference-related to
1658 T2, cv1 must be the same cv-qualification as, or greater
1659 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1660 if (related_p && !at_least_as_qualified_p (to, from))
1663 /* We're generating a temporary now, but don't bind any more in the
1664 conversion (specifically, don't slice the temporary returned by a
1665 conversion operator). */
1666 flags |= LOOKUP_NO_TEMP_BIND;
1668 /* Core issue 899: When [copy-]initializing a temporary to be bound
1669 to the first parameter of a copy constructor (12.8) called with
1670 a single argument in the context of direct-initialization,
1671 explicit conversion functions are also considered.
1673 So don't set LOOKUP_ONLYCONVERTING in that case. */
1674 if (!(flags & LOOKUP_COPY_PARM))
1675 flags |= LOOKUP_ONLYCONVERTING;
1678 conv = implicit_conversion (to, from, expr, c_cast_p,
1683 conv = build_conv (ck_ref_bind, rto, conv);
1684 /* This reference binding, unlike those above, requires the
1685 creation of a temporary. */
1686 conv->need_temporary_p = true;
1687 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1692 /* Returns the implicit conversion sequence (see [over.ics]) from type
1693 FROM to type TO. The optional expression EXPR may affect the
1694 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1695 true, this conversion is coming from a C-style cast. */
1698 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1703 if (from == error_mark_node || to == error_mark_node
1704 || expr == error_mark_node)
1707 if (TREE_CODE (to) == REFERENCE_TYPE)
1708 conv = reference_binding (to, from, expr, c_cast_p, flags);
1710 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1715 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1717 if (is_std_init_list (to))
1718 return build_list_conv (to, expr, flags);
1720 /* As an extension, allow list-initialization of _Complex. */
1721 if (TREE_CODE (to) == COMPLEX_TYPE)
1723 conv = build_complex_conv (to, expr, flags);
1728 /* Allow conversion from an initializer-list with one element to a
1730 if (SCALAR_TYPE_P (to))
1732 int nelts = CONSTRUCTOR_NELTS (expr);
1736 elt = build_value_init (to, tf_none);
1737 else if (nelts == 1)
1738 elt = CONSTRUCTOR_ELT (expr, 0)->value;
1740 elt = error_mark_node;
1742 conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1746 conv->check_narrowing = true;
1747 if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1748 /* Too many levels of braces, i.e. '{{1}}'. */
1753 else if (TREE_CODE (to) == ARRAY_TYPE)
1754 return build_array_conv (to, expr, flags);
1757 if (expr != NULL_TREE
1758 && (MAYBE_CLASS_TYPE_P (from)
1759 || MAYBE_CLASS_TYPE_P (to))
1760 && (flags & LOOKUP_NO_CONVERSION) == 0)
1762 struct z_candidate *cand;
1763 int convflags = (flags & (LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING
1764 |LOOKUP_NO_NARROWING));
1766 if (CLASS_TYPE_P (to)
1767 && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1768 && BRACE_ENCLOSED_INITIALIZER_P (expr))
1769 return build_aggr_conv (to, expr, flags);
1771 cand = build_user_type_conversion_1 (to, expr, convflags);
1773 conv = cand->second_conv;
1775 /* We used to try to bind a reference to a temporary here, but that
1776 is now handled after the recursive call to this function at the end
1777 of reference_binding. */
1784 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1785 functions. ARGS will not be changed until a single candidate is
1788 static struct z_candidate *
1789 add_candidate (struct z_candidate **candidates,
1790 tree fn, tree first_arg, const VEC(tree,gc) *args,
1791 size_t num_convs, conversion **convs,
1792 tree access_path, tree conversion_path,
1793 int viable, struct rejection_reason *reason)
1795 struct z_candidate *cand = (struct z_candidate *)
1796 conversion_obstack_alloc (sizeof (struct z_candidate));
1799 cand->first_arg = first_arg;
1801 cand->convs = convs;
1802 cand->num_convs = num_convs;
1803 cand->access_path = access_path;
1804 cand->conversion_path = conversion_path;
1805 cand->viable = viable;
1806 cand->reason = reason;
1807 cand->next = *candidates;
1813 /* Return the number of remaining arguments in the parameter list
1814 beginning with ARG. */
1817 remaining_arguments (tree arg)
1821 for (n = 0; arg != NULL_TREE && arg != void_list_node;
1822 arg = TREE_CHAIN (arg))
1828 /* Create an overload candidate for the function or method FN called
1829 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1830 FLAGS is passed on to implicit_conversion.
1832 This does not change ARGS.
1834 CTYPE, if non-NULL, is the type we want to pretend this function
1835 comes from for purposes of overload resolution. */
1837 static struct z_candidate *
1838 add_function_candidate (struct z_candidate **candidates,
1839 tree fn, tree ctype, tree first_arg,
1840 const VEC(tree,gc) *args, tree access_path,
1841 tree conversion_path, int flags)
1843 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1847 tree orig_first_arg = first_arg;
1850 struct rejection_reason *reason = NULL;
1852 /* At this point we should not see any functions which haven't been
1853 explicitly declared, except for friend functions which will have
1854 been found using argument dependent lookup. */
1855 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1857 /* The `this', `in_chrg' and VTT arguments to constructors are not
1858 considered in overload resolution. */
1859 if (DECL_CONSTRUCTOR_P (fn))
1861 parmlist = skip_artificial_parms_for (fn, parmlist);
1862 skip = num_artificial_parms_for (fn);
1863 if (skip > 0 && first_arg != NULL_TREE)
1866 first_arg = NULL_TREE;
1872 len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1873 convs = alloc_conversions (len);
1875 /* 13.3.2 - Viable functions [over.match.viable]
1876 First, to be a viable function, a candidate function shall have enough
1877 parameters to agree in number with the arguments in the list.
1879 We need to check this first; otherwise, checking the ICSes might cause
1880 us to produce an ill-formed template instantiation. */
1882 parmnode = parmlist;
1883 for (i = 0; i < len; ++i)
1885 if (parmnode == NULL_TREE || parmnode == void_list_node)
1887 parmnode = TREE_CHAIN (parmnode);
1890 if ((i < len && parmnode)
1891 || !sufficient_parms_p (parmnode))
1893 int remaining = remaining_arguments (parmnode);
1895 reason = arity_rejection (first_arg, i + remaining, len);
1897 /* When looking for a function from a subobject from an implicit
1898 copy/move constructor/operator=, don't consider anything that takes (a
1899 reference to) an unrelated type. See c++/44909 and core 1092. */
1900 else if (parmlist && (flags & LOOKUP_DEFAULTED))
1902 if (DECL_CONSTRUCTOR_P (fn))
1904 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1905 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1911 parmnode = chain_index (i-1, parmlist);
1912 if (!reference_related_p (non_reference (TREE_VALUE (parmnode)),
1917 /* This only applies at the top level. */
1918 flags &= ~LOOKUP_DEFAULTED;
1924 /* Second, for F to be a viable function, there shall exist for each
1925 argument an implicit conversion sequence that converts that argument
1926 to the corresponding parameter of F. */
1928 parmnode = parmlist;
1930 for (i = 0; i < len; ++i)
1932 tree arg, argtype, to_type;
1936 if (parmnode == void_list_node)
1939 if (i == 0 && first_arg != NULL_TREE)
1942 arg = VEC_index (tree, args,
1943 i + skip - (first_arg != NULL_TREE ? 1 : 0));
1944 argtype = lvalue_type (arg);
1946 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1947 && ! DECL_CONSTRUCTOR_P (fn));
1951 tree parmtype = TREE_VALUE (parmnode);
1954 parmnode = TREE_CHAIN (parmnode);
1956 /* The type of the implicit object parameter ('this') for
1957 overload resolution is not always the same as for the
1958 function itself; conversion functions are considered to
1959 be members of the class being converted, and functions
1960 introduced by a using-declaration are considered to be
1961 members of the class that uses them.
1963 Since build_over_call ignores the ICS for the `this'
1964 parameter, we can just change the parm type. */
1965 if (ctype && is_this)
1967 parmtype = cp_build_qualified_type
1968 (ctype, cp_type_quals (TREE_TYPE (parmtype)));
1969 parmtype = build_pointer_type (parmtype);
1972 /* Core issue 899: When [copy-]initializing a temporary to be bound
1973 to the first parameter of a copy constructor (12.8) called with
1974 a single argument in the context of direct-initialization,
1975 explicit conversion functions are also considered.
1977 So set LOOKUP_COPY_PARM to let reference_binding know that
1978 it's being called in that context. We generalize the above
1979 to handle move constructors and template constructors as well;
1980 the standardese should soon be updated similarly. */
1981 if (ctype && i == 0 && (len-skip == 1)
1982 && !(flags & LOOKUP_ONLYCONVERTING)
1983 && DECL_CONSTRUCTOR_P (fn)
1984 && parmtype != error_mark_node
1985 && (same_type_ignoring_top_level_qualifiers_p
1986 (non_reference (parmtype), ctype)))
1988 lflags |= LOOKUP_COPY_PARM;
1989 /* We allow user-defined conversions within init-lists, but
1990 not for the copy constructor. */
1991 if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1992 lflags |= LOOKUP_NO_CONVERSION;
1995 lflags |= LOOKUP_ONLYCONVERTING;
1997 t = implicit_conversion (parmtype, argtype, arg,
1998 /*c_cast_p=*/false, lflags);
2003 t = build_identity_conv (argtype, arg);
2004 t->ellipsis_p = true;
2015 reason = arg_conversion_rejection (first_arg, i, argtype, to_type);
2022 reason = bad_arg_conversion_rejection (first_arg, i, argtype, to_type);
2027 return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
2028 access_path, conversion_path, viable, reason);
2031 /* Create an overload candidate for the conversion function FN which will
2032 be invoked for expression OBJ, producing a pointer-to-function which
2033 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2034 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2035 passed on to implicit_conversion.
2037 Actually, we don't really care about FN; we care about the type it
2038 converts to. There may be multiple conversion functions that will
2039 convert to that type, and we rely on build_user_type_conversion_1 to
2040 choose the best one; so when we create our candidate, we record the type
2041 instead of the function. */
2043 static struct z_candidate *
2044 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
2045 tree first_arg, const VEC(tree,gc) *arglist,
2046 tree access_path, tree conversion_path)
2048 tree totype = TREE_TYPE (TREE_TYPE (fn));
2049 int i, len, viable, flags;
2050 tree parmlist, parmnode;
2052 struct rejection_reason *reason;
2054 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
2055 parmlist = TREE_TYPE (parmlist);
2056 parmlist = TYPE_ARG_TYPES (parmlist);
2058 len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
2059 convs = alloc_conversions (len);
2060 parmnode = parmlist;
2062 flags = LOOKUP_IMPLICIT;
2065 /* Don't bother looking up the same type twice. */
2066 if (*candidates && (*candidates)->fn == totype)
2069 for (i = 0; i < len; ++i)
2071 tree arg, argtype, convert_type = NULL_TREE;
2076 else if (i == 1 && first_arg != NULL_TREE)
2079 arg = VEC_index (tree, arglist,
2080 i - (first_arg != NULL_TREE ? 1 : 0) - 1);
2081 argtype = lvalue_type (arg);
2085 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
2087 convert_type = totype;
2089 else if (parmnode == void_list_node)
2093 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
2094 /*c_cast_p=*/false, flags);
2095 convert_type = TREE_VALUE (parmnode);
2099 t = build_identity_conv (argtype, arg);
2100 t->ellipsis_p = true;
2101 convert_type = argtype;
2111 reason = bad_arg_conversion_rejection (NULL_TREE, i, argtype, convert_type);
2118 parmnode = TREE_CHAIN (parmnode);
2122 || ! sufficient_parms_p (parmnode))
2124 int remaining = remaining_arguments (parmnode);
2126 reason = arity_rejection (NULL_TREE, i + remaining, len);
2129 return add_candidate (candidates, totype, first_arg, arglist, len, convs,
2130 access_path, conversion_path, viable, reason);
2134 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
2135 tree type1, tree type2, tree *args, tree *argtypes,
2143 struct rejection_reason *reason = NULL;
2148 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
2149 convs = alloc_conversions (num_convs);
2151 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2152 conversion ops are allowed. We handle that here by just checking for
2153 boolean_type_node because other operators don't ask for it. COND_EXPR
2154 also does contextual conversion to bool for the first operand, but we
2155 handle that in build_conditional_expr, and type1 here is operand 2. */
2156 if (type1 != boolean_type_node)
2157 flags |= LOOKUP_ONLYCONVERTING;
2159 for (i = 0; i < 2; ++i)
2164 t = implicit_conversion (types[i], argtypes[i], args[i],
2165 /*c_cast_p=*/false, flags);
2169 /* We need something for printing the candidate. */
2170 t = build_identity_conv (types[i], NULL_TREE);
2171 reason = arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2176 reason = bad_arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2181 /* For COND_EXPR we rearranged the arguments; undo that now. */
2184 convs[2] = convs[1];
2185 convs[1] = convs[0];
2186 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
2187 /*c_cast_p=*/false, flags);
2193 reason = arg_conversion_rejection (NULL_TREE, 0, argtypes[2],
2198 add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
2200 /*access_path=*/NULL_TREE,
2201 /*conversion_path=*/NULL_TREE,
2206 is_complete (tree t)
2208 return COMPLETE_TYPE_P (complete_type (t));
2211 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2214 promoted_arithmetic_type_p (tree type)
2218 In this section, the term promoted integral type is used to refer
2219 to those integral types which are preserved by integral promotion
2220 (including e.g. int and long but excluding e.g. char).
2221 Similarly, the term promoted arithmetic type refers to promoted
2222 integral types plus floating types. */
2223 return ((CP_INTEGRAL_TYPE_P (type)
2224 && same_type_p (type_promotes_to (type), type))
2225 || TREE_CODE (type) == REAL_TYPE);
2228 /* Create any builtin operator overload candidates for the operator in
2229 question given the converted operand types TYPE1 and TYPE2. The other
2230 args are passed through from add_builtin_candidates to
2231 build_builtin_candidate.
2233 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2234 If CODE is requires candidates operands of the same type of the kind
2235 of which TYPE1 and TYPE2 are, we add both candidates
2236 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2239 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
2240 enum tree_code code2, tree fnname, tree type1,
2241 tree type2, tree *args, tree *argtypes, int flags)
2245 case POSTINCREMENT_EXPR:
2246 case POSTDECREMENT_EXPR:
2247 args[1] = integer_zero_node;
2248 type2 = integer_type_node;
2257 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2258 and VQ is either volatile or empty, there exist candidate operator
2259 functions of the form
2260 VQ T& operator++(VQ T&);
2261 T operator++(VQ T&, int);
2262 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2263 type other than bool, and VQ is either volatile or empty, there exist
2264 candidate operator functions of the form
2265 VQ T& operator--(VQ T&);
2266 T operator--(VQ T&, int);
2267 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2268 complete object type, and VQ is either volatile or empty, there exist
2269 candidate operator functions of the form
2270 T*VQ& operator++(T*VQ&);
2271 T*VQ& operator--(T*VQ&);
2272 T* operator++(T*VQ&, int);
2273 T* operator--(T*VQ&, int); */
2275 case POSTDECREMENT_EXPR:
2276 case PREDECREMENT_EXPR:
2277 if (TREE_CODE (type1) == BOOLEAN_TYPE)
2279 case POSTINCREMENT_EXPR:
2280 case PREINCREMENT_EXPR:
2281 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
2283 type1 = build_reference_type (type1);
2288 /* 7 For every cv-qualified or cv-unqualified object type T, there
2289 exist candidate operator functions of the form
2293 8 For every function type T, there exist candidate operator functions of
2295 T& operator*(T*); */
2298 if (TREE_CODE (type1) == POINTER_TYPE
2299 && !uses_template_parms (TREE_TYPE (type1))
2300 && (TYPE_PTROB_P (type1)
2301 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
2305 /* 9 For every type T, there exist candidate operator functions of the form
2308 10For every promoted arithmetic type T, there exist candidate operator
2309 functions of the form
2313 case UNARY_PLUS_EXPR: /* unary + */
2314 if (TREE_CODE (type1) == POINTER_TYPE)
2317 if (ARITHMETIC_TYPE_P (type1))
2321 /* 11For every promoted integral type T, there exist candidate operator
2322 functions of the form
2326 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
2330 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2331 is the same type as C2 or is a derived class of C2, T is a complete
2332 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2333 there exist candidate operator functions of the form
2334 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2335 where CV12 is the union of CV1 and CV2. */
2338 if (TREE_CODE (type1) == POINTER_TYPE
2339 && TYPE_PTR_TO_MEMBER_P (type2))
2341 tree c1 = TREE_TYPE (type1);
2342 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
2344 if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
2345 && (TYPE_PTRMEMFUNC_P (type2)
2346 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
2351 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2352 didate operator functions of the form
2357 bool operator<(L, R);
2358 bool operator>(L, R);
2359 bool operator<=(L, R);
2360 bool operator>=(L, R);
2361 bool operator==(L, R);
2362 bool operator!=(L, R);
2363 where LR is the result of the usual arithmetic conversions between
2366 14For every pair of types T and I, where T is a cv-qualified or cv-
2367 unqualified complete object type and I is a promoted integral type,
2368 there exist candidate operator functions of the form
2369 T* operator+(T*, I);
2370 T& operator[](T*, I);
2371 T* operator-(T*, I);
2372 T* operator+(I, T*);
2373 T& operator[](I, T*);
2375 15For every T, where T is a pointer to complete object type, there exist
2376 candidate operator functions of the form112)
2377 ptrdiff_t operator-(T, T);
2379 16For every pointer or enumeration type T, there exist candidate operator
2380 functions of the form
2381 bool operator<(T, T);
2382 bool operator>(T, T);
2383 bool operator<=(T, T);
2384 bool operator>=(T, T);
2385 bool operator==(T, T);
2386 bool operator!=(T, T);
2388 17For every pointer to member type T, there exist candidate operator
2389 functions of the form
2390 bool operator==(T, T);
2391 bool operator!=(T, T); */
2394 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2396 if (TYPE_PTROB_P (type1)
2397 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2399 type2 = ptrdiff_type_node;
2403 case TRUNC_DIV_EXPR:
2404 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2410 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2411 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2413 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2418 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2430 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2432 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2434 if (TREE_CODE (type1) == ENUMERAL_TYPE
2435 && TREE_CODE (type2) == ENUMERAL_TYPE)
2437 if (TYPE_PTR_P (type1)
2438 && null_ptr_cst_p (args[1])
2439 && !uses_template_parms (type1))
2444 if (null_ptr_cst_p (args[0])
2445 && TYPE_PTR_P (type2)
2446 && !uses_template_parms (type2))
2454 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2457 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2459 type1 = ptrdiff_type_node;
2462 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2464 type2 = ptrdiff_type_node;
2469 /* 18For every pair of promoted integral types L and R, there exist candi-
2470 date operator functions of the form
2477 where LR is the result of the usual arithmetic conversions between
2480 case TRUNC_MOD_EXPR:
2486 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2490 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2491 type, VQ is either volatile or empty, and R is a promoted arithmetic
2492 type, there exist candidate operator functions of the form
2493 VQ L& operator=(VQ L&, R);
2494 VQ L& operator*=(VQ L&, R);
2495 VQ L& operator/=(VQ L&, R);
2496 VQ L& operator+=(VQ L&, R);
2497 VQ L& operator-=(VQ L&, R);
2499 20For every pair T, VQ), where T is any type and VQ is either volatile
2500 or empty, there exist candidate operator functions of the form
2501 T*VQ& operator=(T*VQ&, T*);
2503 21For every pair T, VQ), where T is a pointer to member type and VQ is
2504 either volatile or empty, there exist candidate operator functions of
2506 VQ T& operator=(VQ T&, T);
2508 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2509 unqualified complete object type, VQ is either volatile or empty, and
2510 I is a promoted integral type, there exist candidate operator func-
2512 T*VQ& operator+=(T*VQ&, I);
2513 T*VQ& operator-=(T*VQ&, I);
2515 23For every triple L, VQ, R), where L is an integral or enumeration
2516 type, VQ is either volatile or empty, and R is a promoted integral
2517 type, there exist candidate operator functions of the form
2519 VQ L& operator%=(VQ L&, R);
2520 VQ L& operator<<=(VQ L&, R);
2521 VQ L& operator>>=(VQ L&, R);
2522 VQ L& operator&=(VQ L&, R);
2523 VQ L& operator^=(VQ L&, R);
2524 VQ L& operator|=(VQ L&, R); */
2531 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2533 type2 = ptrdiff_type_node;
2537 case TRUNC_DIV_EXPR:
2538 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2542 case TRUNC_MOD_EXPR:
2548 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2553 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2555 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2556 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2557 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2558 || ((TYPE_PTRMEMFUNC_P (type1)
2559 || TREE_CODE (type1) == POINTER_TYPE)
2560 && null_ptr_cst_p (args[1])))
2570 type1 = build_reference_type (type1);
2576 For every pair of promoted arithmetic types L and R, there
2577 exist candidate operator functions of the form
2579 LR operator?(bool, L, R);
2581 where LR is the result of the usual arithmetic conversions
2582 between types L and R.
2584 For every type T, where T is a pointer or pointer-to-member
2585 type, there exist candidate operator functions of the form T
2586 operator?(bool, T, T); */
2588 if (promoted_arithmetic_type_p (type1)
2589 && promoted_arithmetic_type_p (type2))
2593 /* Otherwise, the types should be pointers. */
2594 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2595 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2598 /* We don't check that the two types are the same; the logic
2599 below will actually create two candidates; one in which both
2600 parameter types are TYPE1, and one in which both parameter
2606 if (ARITHMETIC_TYPE_P (type1))
2614 /* If we're dealing with two pointer types or two enumeral types,
2615 we need candidates for both of them. */
2616 if (type2 && !same_type_p (type1, type2)
2617 && TREE_CODE (type1) == TREE_CODE (type2)
2618 && (TREE_CODE (type1) == REFERENCE_TYPE
2619 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2620 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2621 || TYPE_PTRMEMFUNC_P (type1)
2622 || MAYBE_CLASS_TYPE_P (type1)
2623 || TREE_CODE (type1) == ENUMERAL_TYPE))
2625 build_builtin_candidate
2626 (candidates, fnname, type1, type1, args, argtypes, flags);
2627 build_builtin_candidate
2628 (candidates, fnname, type2, type2, args, argtypes, flags);
2632 build_builtin_candidate
2633 (candidates, fnname, type1, type2, args, argtypes, flags);
2637 type_decays_to (tree type)
2639 if (TREE_CODE (type) == ARRAY_TYPE)
2640 return build_pointer_type (TREE_TYPE (type));
2641 if (TREE_CODE (type) == FUNCTION_TYPE)
2642 return build_pointer_type (type);
2646 /* There are three conditions of builtin candidates:
2648 1) bool-taking candidates. These are the same regardless of the input.
2649 2) pointer-pair taking candidates. These are generated for each type
2650 one of the input types converts to.
2651 3) arithmetic candidates. According to the standard, we should generate
2652 all of these, but I'm trying not to...
2654 Here we generate a superset of the possible candidates for this particular
2655 case. That is a subset of the full set the standard defines, plus some
2656 other cases which the standard disallows. add_builtin_candidate will
2657 filter out the invalid set. */
2660 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2661 enum tree_code code2, tree fnname, tree *args,
2666 tree type, argtypes[3], t;
2667 /* TYPES[i] is the set of possible builtin-operator parameter types
2668 we will consider for the Ith argument. */
2669 VEC(tree,gc) *types[2];
2672 for (i = 0; i < 3; ++i)
2675 argtypes[i] = unlowered_expr_type (args[i]);
2677 argtypes[i] = NULL_TREE;
2682 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2683 and VQ is either volatile or empty, there exist candidate operator
2684 functions of the form
2685 VQ T& operator++(VQ T&); */
2687 case POSTINCREMENT_EXPR:
2688 case PREINCREMENT_EXPR:
2689 case POSTDECREMENT_EXPR:
2690 case PREDECREMENT_EXPR:
2695 /* 24There also exist candidate operator functions of the form
2696 bool operator!(bool);
2697 bool operator&&(bool, bool);
2698 bool operator||(bool, bool); */
2700 case TRUTH_NOT_EXPR:
2701 build_builtin_candidate
2702 (candidates, fnname, boolean_type_node,
2703 NULL_TREE, args, argtypes, flags);
2706 case TRUTH_ORIF_EXPR:
2707 case TRUTH_ANDIF_EXPR:
2708 build_builtin_candidate
2709 (candidates, fnname, boolean_type_node,
2710 boolean_type_node, args, argtypes, flags);
2732 types[0] = make_tree_vector ();
2733 types[1] = make_tree_vector ();
2735 for (i = 0; i < 2; ++i)
2739 else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2743 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2746 convs = lookup_conversions (argtypes[i]);
2748 if (code == COND_EXPR)
2750 if (real_lvalue_p (args[i]))
2751 VEC_safe_push (tree, gc, types[i],
2752 build_reference_type (argtypes[i]));
2754 VEC_safe_push (tree, gc, types[i],
2755 TYPE_MAIN_VARIANT (argtypes[i]));
2761 for (; convs; convs = TREE_CHAIN (convs))
2763 type = TREE_TYPE (convs);
2766 && (TREE_CODE (type) != REFERENCE_TYPE
2767 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2770 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2771 VEC_safe_push (tree, gc, types[i], type);
2773 type = non_reference (type);
2774 if (i != 0 || ! ref1)
2776 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2777 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2778 VEC_safe_push (tree, gc, types[i], type);
2779 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2780 type = type_promotes_to (type);
2783 if (! vec_member (type, types[i]))
2784 VEC_safe_push (tree, gc, types[i], type);
2789 if (code == COND_EXPR && real_lvalue_p (args[i]))
2790 VEC_safe_push (tree, gc, types[i],
2791 build_reference_type (argtypes[i]));
2792 type = non_reference (argtypes[i]);
2793 if (i != 0 || ! ref1)
2795 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2796 if (enum_p && UNSCOPED_ENUM_P (type))
2797 VEC_safe_push (tree, gc, types[i], type);
2798 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2799 type = type_promotes_to (type);
2801 VEC_safe_push (tree, gc, types[i], type);
2805 /* Run through the possible parameter types of both arguments,
2806 creating candidates with those parameter types. */
2807 FOR_EACH_VEC_ELT_REVERSE (tree, types[0], ix, t)
2812 if (!VEC_empty (tree, types[1]))
2813 FOR_EACH_VEC_ELT_REVERSE (tree, types[1], jx, u)
2814 add_builtin_candidate
2815 (candidates, code, code2, fnname, t,
2816 u, args, argtypes, flags);
2818 add_builtin_candidate
2819 (candidates, code, code2, fnname, t,
2820 NULL_TREE, args, argtypes, flags);
2823 release_tree_vector (types[0]);
2824 release_tree_vector (types[1]);
2828 /* If TMPL can be successfully instantiated as indicated by
2829 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2831 TMPL is the template. EXPLICIT_TARGS are any explicit template
2832 arguments. ARGLIST is the arguments provided at the call-site.
2833 This does not change ARGLIST. The RETURN_TYPE is the desired type
2834 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2835 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2836 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2838 static struct z_candidate*
2839 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2840 tree ctype, tree explicit_targs, tree first_arg,
2841 const VEC(tree,gc) *arglist, tree return_type,
2842 tree access_path, tree conversion_path,
2843 int flags, tree obj, unification_kind_t strict)
2845 int ntparms = DECL_NTPARMS (tmpl);
2846 tree targs = make_tree_vec (ntparms);
2847 unsigned int len = VEC_length (tree, arglist);
2848 unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2849 unsigned int skip_without_in_chrg = 0;
2850 tree first_arg_without_in_chrg = first_arg;
2851 tree *args_without_in_chrg;
2852 unsigned int nargs_without_in_chrg;
2853 unsigned int ia, ix;
2855 struct z_candidate *cand;
2858 struct rejection_reason *reason = NULL;
2860 /* We don't do deduction on the in-charge parameter, the VTT
2861 parameter or 'this'. */
2862 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2864 if (first_arg_without_in_chrg != NULL_TREE)
2865 first_arg_without_in_chrg = NULL_TREE;
2867 ++skip_without_in_chrg;
2870 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2871 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2872 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2874 if (first_arg_without_in_chrg != NULL_TREE)
2875 first_arg_without_in_chrg = NULL_TREE;
2877 ++skip_without_in_chrg;
2880 if (len < skip_without_in_chrg)
2883 nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2884 + (len - skip_without_in_chrg));
2885 args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2887 if (first_arg_without_in_chrg != NULL_TREE)
2889 args_without_in_chrg[ia] = first_arg_without_in_chrg;
2892 for (ix = skip_without_in_chrg;
2893 VEC_iterate (tree, arglist, ix, arg);
2896 args_without_in_chrg[ia] = arg;
2899 gcc_assert (ia == nargs_without_in_chrg);
2901 i = fn_type_unification (tmpl, explicit_targs, targs,
2902 args_without_in_chrg,
2903 nargs_without_in_chrg,
2904 return_type, strict, flags);
2909 fn = instantiate_template (tmpl, targs, tf_none);
2910 if (fn == error_mark_node)
2915 A member function template is never instantiated to perform the
2916 copy of a class object to an object of its class type.
2918 It's a little unclear what this means; the standard explicitly
2919 does allow a template to be used to copy a class. For example,
2924 template <class T> A(const T&);
2927 void g () { A a (f ()); }
2929 the member template will be used to make the copy. The section
2930 quoted above appears in the paragraph that forbids constructors
2931 whose only parameter is (a possibly cv-qualified variant of) the
2932 class type, and a logical interpretation is that the intent was
2933 to forbid the instantiation of member templates which would then
2935 if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2937 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2938 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2943 if (obj != NULL_TREE)
2944 /* Aha, this is a conversion function. */
2945 cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2946 access_path, conversion_path);
2948 cand = add_function_candidate (candidates, fn, ctype,
2949 first_arg, arglist, access_path,
2950 conversion_path, flags);
2951 if (DECL_TI_TEMPLATE (fn) != tmpl)
2952 /* This situation can occur if a member template of a template
2953 class is specialized. Then, instantiate_template might return
2954 an instantiation of the specialization, in which case the
2955 DECL_TI_TEMPLATE field will point at the original
2956 specialization. For example:
2958 template <class T> struct S { template <class U> void f(U);
2959 template <> void f(int) {}; };
2963 Here, TMPL will be template <class U> S<double>::f(U).
2964 And, instantiate template will give us the specialization
2965 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2966 for this will point at template <class T> template <> S<T>::f(int),
2967 so that we can find the definition. For the purposes of
2968 overload resolution, however, we want the original TMPL. */
2969 cand->template_decl = build_template_info (tmpl, targs);
2971 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2972 cand->explicit_targs = explicit_targs;
2976 return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2977 access_path, conversion_path, 0, reason);
2981 static struct z_candidate *
2982 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2983 tree explicit_targs, tree first_arg,
2984 const VEC(tree,gc) *arglist, tree return_type,
2985 tree access_path, tree conversion_path, int flags,
2986 unification_kind_t strict)
2989 add_template_candidate_real (candidates, tmpl, ctype,
2990 explicit_targs, first_arg, arglist,
2991 return_type, access_path, conversion_path,
2992 flags, NULL_TREE, strict);
2996 static struct z_candidate *
2997 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2998 tree obj, tree first_arg,
2999 const VEC(tree,gc) *arglist,
3000 tree return_type, tree access_path,
3001 tree conversion_path)
3004 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
3005 first_arg, arglist, return_type, access_path,
3006 conversion_path, 0, obj, DEDUCE_CONV);
3009 /* The CANDS are the set of candidates that were considered for
3010 overload resolution. Return the set of viable candidates, or CANDS
3011 if none are viable. If any of the candidates were viable, set
3012 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3013 considered viable only if it is strictly viable. */
3015 static struct z_candidate*
3016 splice_viable (struct z_candidate *cands,
3020 struct z_candidate *viable;
3021 struct z_candidate **last_viable;
3022 struct z_candidate **cand;
3024 /* Be strict inside templates, since build_over_call won't actually
3025 do the conversions to get pedwarns. */
3026 if (processing_template_decl)
3030 last_viable = &viable;
3031 *any_viable_p = false;
3036 struct z_candidate *c = *cand;
3037 if (strict_p ? c->viable == 1 : c->viable)
3042 last_viable = &c->next;
3043 *any_viable_p = true;
3049 return viable ? viable : cands;
3053 any_strictly_viable (struct z_candidate *cands)
3055 for (; cands; cands = cands->next)
3056 if (cands->viable == 1)
3061 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3062 words, it is about to become the "this" pointer for a member
3063 function call. Take the address of the object. */
3066 build_this (tree obj)
3068 /* In a template, we are only concerned about the type of the
3069 expression, so we can take a shortcut. */
3070 if (processing_template_decl)
3071 return build_address (obj);
3073 return cp_build_addr_expr (obj, tf_warning_or_error);
3076 /* Returns true iff functions are equivalent. Equivalent functions are
3077 not '==' only if one is a function-local extern function or if
3078 both are extern "C". */
3081 equal_functions (tree fn1, tree fn2)
3083 if (TREE_CODE (fn1) != TREE_CODE (fn2))
3085 if (TREE_CODE (fn1) == TEMPLATE_DECL)
3087 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
3088 || DECL_EXTERN_C_FUNCTION_P (fn1))
3089 return decls_match (fn1, fn2);
3093 /* Print information about a candidate being rejected due to INFO. */
3096 print_conversion_rejection (location_t loc, struct conversion_info *info)
3098 if (info->n_arg == -1)
3099 /* Conversion of implicit `this' argument failed. */
3100 inform (loc, " no known conversion for implicit "
3101 "%<this%> parameter from %qT to %qT",
3102 info->from_type, info->to_type);
3104 inform (loc, " no known conversion for argument %d from %qT to %qT",
3105 info->n_arg+1, info->from_type, info->to_type);
3108 /* Print information about one overload candidate CANDIDATE. MSGSTR
3109 is the text to print before the candidate itself.
3111 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3112 to have been run through gettext by the caller. This wart makes
3113 life simpler in print_z_candidates and for the translators. */
3116 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
3118 const char *msg = (msgstr == NULL
3120 : ACONCAT ((msgstr, " ", NULL)));
3121 location_t loc = location_of (candidate->fn);
3123 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
3125 if (candidate->num_convs == 3)
3126 inform (input_location, "%s%D(%T, %T, %T) <built-in>", msg, candidate->fn,
3127 candidate->convs[0]->type,
3128 candidate->convs[1]->type,
3129 candidate->convs[2]->type);
3130 else if (candidate->num_convs == 2)
3131 inform (input_location, "%s%D(%T, %T) <built-in>", msg, candidate->fn,
3132 candidate->convs[0]->type,
3133 candidate->convs[1]->type);
3135 inform (input_location, "%s%D(%T) <built-in>", msg, candidate->fn,
3136 candidate->convs[0]->type);
3138 else if (TYPE_P (candidate->fn))
3139 inform (input_location, "%s%T <conversion>", msg, candidate->fn);
3140 else if (candidate->viable == -1)
3141 inform (loc, "%s%#D <near match>", msg, candidate->fn);
3142 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
3143 inform (loc, "%s%#D <deleted>", msg, candidate->fn);
3145 inform (loc, "%s%#D", msg, candidate->fn);
3146 /* Give the user some information about why this candidate failed. */
3147 if (candidate->reason != NULL)
3149 struct rejection_reason *r = candidate->reason;
3154 inform_n (loc, r->u.arity.expected,
3155 " candidate expects %d argument, %d provided",
3156 " candidate expects %d arguments, %d provided",
3157 r->u.arity.expected, r->u.arity.actual);
3159 case rr_arg_conversion:
3160 print_conversion_rejection (loc, &r->u.conversion);
3162 case rr_bad_arg_conversion:
3163 print_conversion_rejection (loc, &r->u.bad_conversion);
3165 case rr_explicit_conversion:
3166 inform (loc, " return type %qT of explicit conversion function "
3167 "cannot be converted to %qT with a qualification "
3168 "conversion", r->u.conversion.from_type,
3169 r->u.conversion.to_type);
3173 /* This candidate didn't have any issues or we failed to
3174 handle a particular code. Either way... */
3181 print_z_candidates (location_t loc, struct z_candidate *candidates)
3183 struct z_candidate *cand1;
3184 struct z_candidate **cand2;
3190 /* Remove non-viable deleted candidates. */
3192 for (cand2 = &cand1; *cand2; )
3194 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
3195 && !(*cand2)->viable
3196 && DECL_DELETED_FN ((*cand2)->fn))
3197 *cand2 = (*cand2)->next;
3199 cand2 = &(*cand2)->next;
3201 /* ...if there are any non-deleted ones. */
3205 /* There may be duplicates in the set of candidates. We put off
3206 checking this condition as long as possible, since we have no way
3207 to eliminate duplicates from a set of functions in less than n^2
3208 time. Now we are about to emit an error message, so it is more
3209 permissible to go slowly. */
3210 for (cand1 = candidates; cand1; cand1 = cand1->next)
3212 tree fn = cand1->fn;
3213 /* Skip builtin candidates and conversion functions. */
3216 cand2 = &cand1->next;
3219 if (DECL_P ((*cand2)->fn)
3220 && equal_functions (fn, (*cand2)->fn))
3221 *cand2 = (*cand2)->next;
3223 cand2 = &(*cand2)->next;
3227 for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next)
3230 inform_n (loc, n_candidates, "candidate is:", "candidates are:");
3231 for (; candidates; candidates = candidates->next)
3232 print_z_candidate (NULL, candidates);
3235 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3236 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3237 the result of the conversion function to convert it to the final
3238 desired type. Merge the two sequences into a single sequence,
3239 and return the merged sequence. */
3242 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
3246 gcc_assert (user_seq->kind == ck_user);
3248 /* Find the end of the second conversion sequence. */
3250 while ((*t)->kind != ck_identity)
3251 t = &((*t)->u.next);
3253 /* Replace the identity conversion with the user conversion
3257 /* The entire sequence is a user-conversion sequence. */
3258 std_seq->user_conv_p = true;
3263 /* Handle overload resolution for initializing an object of class type from
3264 an initializer list. First we look for a suitable constructor that
3265 takes a std::initializer_list; if we don't find one, we then look for a
3266 non-list constructor.
3268 Parameters are as for add_candidates, except that the arguments are in
3269 the form of a CONSTRUCTOR (the initializer list) rather than a VEC, and
3270 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3273 add_list_candidates (tree fns, tree first_arg,
3274 tree init_list, tree totype,
3275 tree explicit_targs, bool template_only,
3276 tree conversion_path, tree access_path,
3278 struct z_candidate **candidates)
3282 gcc_assert (*candidates == NULL);
3284 /* For list-initialization we consider explicit constructors, but
3285 give an error if one is selected. */
3286 flags &= ~LOOKUP_ONLYCONVERTING;
3287 /* And we don't allow narrowing conversions. We also use this flag to
3288 avoid the copy constructor call for copy-list-initialization. */
3289 flags |= LOOKUP_NO_NARROWING;
3291 /* Always use the default constructor if the list is empty (DR 990). */
3292 if (CONSTRUCTOR_NELTS (init_list) == 0
3293 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
3295 /* If the class has a list ctor, try passing the list as a single
3296 argument first, but only consider list ctors. */
3297 else if (TYPE_HAS_LIST_CTOR (totype))
3299 flags |= LOOKUP_LIST_ONLY;
3300 args = make_tree_vector_single (init_list);
3301 add_candidates (fns, first_arg, args, NULL_TREE,
3302 explicit_targs, template_only, conversion_path,
3303 access_path, flags, candidates);
3304 if (any_strictly_viable (*candidates))
3308 args = ctor_to_vec (init_list);
3310 /* We aren't looking for list-ctors anymore. */
3311 flags &= ~LOOKUP_LIST_ONLY;
3312 /* We allow more user-defined conversions within an init-list. */
3313 flags &= ~LOOKUP_NO_CONVERSION;
3314 /* But not for the copy ctor. */
3315 flags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
3317 add_candidates (fns, first_arg, args, NULL_TREE,
3318 explicit_targs, template_only, conversion_path,
3319 access_path, flags, candidates);
3322 /* Returns the best overload candidate to perform the requested
3323 conversion. This function is used for three the overloading situations
3324 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3325 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
3326 per [dcl.init.ref], so we ignore temporary bindings. */
3328 static struct z_candidate *
3329 build_user_type_conversion_1 (tree totype, tree expr, int flags)
3331 struct z_candidate *candidates, *cand;
3332 tree fromtype = TREE_TYPE (expr);
3333 tree ctors = NULL_TREE;
3334 tree conv_fns = NULL_TREE;
3335 conversion *conv = NULL;
3336 tree first_arg = NULL_TREE;
3337 VEC(tree,gc) *args = NULL;
3341 /* We represent conversion within a hierarchy using RVALUE_CONV and
3342 BASE_CONV, as specified by [over.best.ics]; these become plain
3343 constructor calls, as specified in [dcl.init]. */
3344 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
3345 || !DERIVED_FROM_P (totype, fromtype));
3347 if (MAYBE_CLASS_TYPE_P (totype))
3348 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3349 creating a garbage BASELINK; constructors can't be inherited. */
3350 ctors = lookup_fnfields_slot (totype, complete_ctor_identifier);
3352 if (MAYBE_CLASS_TYPE_P (fromtype))
3354 tree to_nonref = non_reference (totype);
3355 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
3356 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
3357 && DERIVED_FROM_P (to_nonref, fromtype)))
3359 /* [class.conv.fct] A conversion function is never used to
3360 convert a (possibly cv-qualified) object to the (possibly
3361 cv-qualified) same object type (or a reference to it), to a
3362 (possibly cv-qualified) base class of that type (or a
3363 reference to it)... */
3366 conv_fns = lookup_conversions (fromtype);
3370 flags |= LOOKUP_NO_CONVERSION;
3371 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3372 flags |= LOOKUP_NO_NARROWING;
3374 /* It's OK to bind a temporary for converting constructor arguments, but
3375 not in converting the return value of a conversion operator. */
3376 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
3377 flags &= ~LOOKUP_NO_TEMP_BIND;
3381 int ctorflags = flags;
3383 first_arg = build_int_cst (build_pointer_type (totype), 0);
3385 /* We should never try to call the abstract or base constructor
3387 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
3388 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
3390 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3392 /* List-initialization. */
3393 add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
3394 false, TYPE_BINFO (totype), TYPE_BINFO (totype),
3395 ctorflags, &candidates);
3399 args = make_tree_vector_single (expr);
3400 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
3401 TYPE_BINFO (totype), TYPE_BINFO (totype),
3402 ctorflags, &candidates);
3405 for (cand = candidates; cand; cand = cand->next)
3407 cand->second_conv = build_identity_conv (totype, NULL_TREE);
3409 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3410 set, then this is copy-initialization. In that case, "The
3411 result of the call is then used to direct-initialize the
3412 object that is the destination of the copy-initialization."
3415 We represent this in the conversion sequence with an
3416 rvalue conversion, which means a constructor call. */
3417 if (TREE_CODE (totype) != REFERENCE_TYPE
3418 && !(convflags & LOOKUP_NO_TEMP_BIND))
3420 = build_conv (ck_rvalue, totype, cand->second_conv);
3425 first_arg = build_this (expr);
3427 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3429 tree conversion_path = TREE_PURPOSE (conv_fns);
3430 struct z_candidate *old_candidates;
3432 /* If we are called to convert to a reference type, we are trying to
3433 find an lvalue binding, so don't even consider temporaries. If
3434 we don't find an lvalue binding, the caller will try again to
3435 look for a temporary binding. */
3436 if (TREE_CODE (totype) == REFERENCE_TYPE)
3437 convflags |= LOOKUP_NO_TEMP_BIND;
3439 old_candidates = candidates;
3440 add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3442 conversion_path, TYPE_BINFO (fromtype),
3443 flags, &candidates);
3445 for (cand = candidates; cand != old_candidates; cand = cand->next)
3447 tree rettype = TREE_TYPE (TREE_TYPE (cand->fn));
3449 = implicit_conversion (totype,
3452 /*c_cast_p=*/false, convflags);
3454 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3455 copy-initialization. In that case, "The result of the
3456 call is then used to direct-initialize the object that is
3457 the destination of the copy-initialization." [dcl.init]
3459 We represent this in the conversion sequence with an
3460 rvalue conversion, which means a constructor call. But
3461 don't add a second rvalue conversion if there's already
3462 one there. Which there really shouldn't be, but it's
3463 harmless since we'd add it here anyway. */
3464 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3465 && !(convflags & LOOKUP_NO_TEMP_BIND))
3466 ics = build_conv (ck_rvalue, totype, ics);
3468 cand->second_conv = ics;
3473 cand->reason = arg_conversion_rejection (NULL_TREE, -1,
3476 else if (DECL_NONCONVERTING_P (cand->fn)
3477 && ics->rank > cr_exact)
3479 /* 13.3.1.5: For direct-initialization, those explicit
3480 conversion functions that are not hidden within S and
3481 yield type T or a type that can be converted to type T
3482 with a qualification conversion (4.4) are also candidate
3485 cand->reason = explicit_conversion_rejection (rettype, totype);
3487 else if (cand->viable == 1 && ics->bad_p)
3491 = bad_arg_conversion_rejection (NULL_TREE, -1,
3497 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3501 release_tree_vector (args);
3505 cand = tourney (candidates);
3508 if (flags & LOOKUP_COMPLAIN)
3510 error ("conversion from %qT to %qT is ambiguous",
3512 print_z_candidates (location_of (expr), candidates);
3515 cand = candidates; /* any one will do */
3516 cand->second_conv = build_ambiguous_conv (totype, expr);
3517 cand->second_conv->user_conv_p = true;
3518 if (!any_strictly_viable (candidates))
3519 cand->second_conv->bad_p = true;
3520 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3521 ambiguous conversion is no worse than another user-defined
3527 /* Build the user conversion sequence. */
3530 (DECL_CONSTRUCTOR_P (cand->fn)
3531 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3532 build_identity_conv (TREE_TYPE (expr), expr));
3535 /* Remember that this was a list-initialization. */
3536 if (flags & LOOKUP_NO_NARROWING)
3537 conv->check_narrowing = true;
3539 /* Combine it with the second conversion sequence. */
3540 cand->second_conv = merge_conversion_sequences (conv,
3543 if (cand->viable == -1)
3544 cand->second_conv->bad_p = true;
3549 /* Wrapper for above. */
3552 build_user_type_conversion (tree totype, tree expr, int flags)
3554 struct z_candidate *cand;
3557 bool subtime = timevar_cond_start (TV_OVERLOAD);
3558 cand = build_user_type_conversion_1 (totype, expr, flags);
3562 if (cand->second_conv->kind == ck_ambig)
3563 ret = error_mark_node;
3566 expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3567 ret = convert_from_reference (expr);
3573 timevar_cond_stop (TV_OVERLOAD, subtime);
3577 /* Subroutine of convert_nontype_argument.
3579 EXPR is an argument for a template non-type parameter of integral or
3580 enumeration type. Do any necessary conversions (that are permitted for
3581 non-type arguments) to convert it to the parameter type.
3583 If conversion is successful, returns the converted expression;
3584 otherwise, returns error_mark_node. */
3587 build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain)
3593 if (error_operand_p (expr))
3594 return error_mark_node;
3596 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3598 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3599 p = conversion_obstack_alloc (0);
3601 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
3605 /* for a non-type template-parameter of integral or
3606 enumeration type, integral promotions (4.5) and integral
3607 conversions (4.7) are applied. */
3608 /* It should be sufficient to check the outermost conversion step, since
3609 there are no qualification conversions to integer type. */
3613 /* A conversion function is OK. If it isn't constexpr, we'll
3614 complain later that the argument isn't constant. */
3616 /* The lvalue-to-rvalue conversion is OK. */
3622 t = conv->u.next->type;
3623 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
3626 if (complain & tf_error)
3627 error ("conversion from %qT to %qT not considered for "
3628 "non-type template argument", t, type);
3629 /* and fall through. */
3637 expr = convert_like (conv, expr, complain);
3639 expr = error_mark_node;
3641 /* Free all the conversions we allocated. */
3642 obstack_free (&conversion_obstack, p);
3647 /* Do any initial processing on the arguments to a function call. */
3649 static VEC(tree,gc) *
3650 resolve_args (VEC(tree,gc) *args, tsubst_flags_t complain)
3655 FOR_EACH_VEC_ELT (tree, args, ix, arg)
3657 if (error_operand_p (arg))
3659 else if (VOID_TYPE_P (TREE_TYPE (arg)))
3661 if (complain & tf_error)
3662 error ("invalid use of void expression");
3665 else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3671 /* Perform overload resolution on FN, which is called with the ARGS.
3673 Return the candidate function selected by overload resolution, or
3674 NULL if the event that overload resolution failed. In the case
3675 that overload resolution fails, *CANDIDATES will be the set of
3676 candidates considered, and ANY_VIABLE_P will be set to true or
3677 false to indicate whether or not any of the candidates were
3680 The ARGS should already have gone through RESOLVE_ARGS before this
3681 function is called. */
3683 static struct z_candidate *
3684 perform_overload_resolution (tree fn,
3685 const VEC(tree,gc) *args,
3686 struct z_candidate **candidates,
3689 struct z_candidate *cand;
3690 tree explicit_targs;
3693 bool subtime = timevar_cond_start (TV_OVERLOAD);
3695 explicit_targs = NULL_TREE;
3699 *any_viable_p = true;
3702 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3703 || TREE_CODE (fn) == TEMPLATE_DECL
3704 || TREE_CODE (fn) == OVERLOAD
3705 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3707 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3709 explicit_targs = TREE_OPERAND (fn, 1);
3710 fn = TREE_OPERAND (fn, 0);
3714 /* Add the various candidate functions. */
3715 add_candidates (fn, NULL_TREE, args, NULL_TREE,
3716 explicit_targs, template_only,
3717 /*conversion_path=*/NULL_TREE,
3718 /*access_path=*/NULL_TREE,
3722 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3724 cand = tourney (*candidates);
3728 timevar_cond_stop (TV_OVERLOAD, subtime);
3732 /* Print an error message about being unable to build a call to FN with
3733 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
3734 be located; CANDIDATES is a possibly empty list of such
3738 print_error_for_call_failure (tree fn, VEC(tree,gc) *args, bool any_viable_p,
3739 struct z_candidate *candidates)
3741 tree name = DECL_NAME (OVL_CURRENT (fn));
3742 location_t loc = location_of (name);
3745 error_at (loc, "no matching function for call to %<%D(%A)%>",
3746 name, build_tree_list_vec (args));
3748 error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous",
3749 name, build_tree_list_vec (args));
3751 print_z_candidates (loc, candidates);
3754 /* Return an expression for a call to FN (a namespace-scope function,
3755 or a static member function) with the ARGS. This may change
3759 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3760 tsubst_flags_t complain)
3762 struct z_candidate *candidates, *cand;
3767 if (args != NULL && *args != NULL)
3769 *args = resolve_args (*args, complain);
3771 return error_mark_node;
3774 /* If this function was found without using argument dependent
3775 lookup, then we want to ignore any undeclared friend
3781 fn = remove_hidden_names (fn);
3784 if (complain & tf_error)
3785 print_error_for_call_failure (orig_fn, *args, false, NULL);
3786 return error_mark_node;
3790 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3791 p = conversion_obstack_alloc (0);
3793 cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3797 if (complain & tf_error)
3799 if (!any_viable_p && candidates && ! candidates->next
3800 && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3801 return cp_build_function_call_vec (candidates->fn, args, complain);
3802 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3803 fn = TREE_OPERAND (fn, 0);
3804 print_error_for_call_failure (fn, *args, any_viable_p, candidates);
3806 result = error_mark_node;
3810 int flags = LOOKUP_NORMAL;
3811 /* If fn is template_id_expr, the call has explicit template arguments
3812 (e.g. func<int>(5)), communicate this info to build_over_call
3813 through flags so that later we can use it to decide whether to warn
3814 about peculiar null pointer conversion. */
3815 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3816 flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
3817 result = build_over_call (cand, flags, complain);
3820 /* Free all the conversions we allocated. */
3821 obstack_free (&conversion_obstack, p);
3826 /* Build a call to a global operator new. FNNAME is the name of the
3827 operator (either "operator new" or "operator new[]") and ARGS are
3828 the arguments provided. This may change ARGS. *SIZE points to the
3829 total number of bytes required by the allocation, and is updated if
3830 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3831 be used. If this function determines that no cookie should be
3832 used, after all, *COOKIE_SIZE is set to NULL_TREE. If FN is
3833 non-NULL, it will be set, upon return, to the allocation function
3837 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3838 tree *size, tree *cookie_size,
3842 struct z_candidate *candidates;
3843 struct z_candidate *cand;
3848 VEC_safe_insert (tree, gc, *args, 0, *size);
3849 *args = resolve_args (*args, tf_warning_or_error);
3851 return error_mark_node;
3857 If this lookup fails to find the name, or if the allocated type
3858 is not a class type, the allocation function's name is looked
3859 up in the global scope.
3861 we disregard block-scope declarations of "operator new". */
3862 fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3864 /* Figure out what function is being called. */
3865 cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3867 /* If no suitable function could be found, issue an error message
3871 print_error_for_call_failure (fns, *args, any_viable_p, candidates);
3872 return error_mark_node;
3875 /* If a cookie is required, add some extra space. Whether
3876 or not a cookie is required cannot be determined until
3877 after we know which function was called. */
3880 bool use_cookie = true;
3881 if (!abi_version_at_least (2))
3883 /* In G++ 3.2, the check was implemented incorrectly; it
3884 looked at the placement expression, rather than the
3885 type of the function. */
3886 if (VEC_length (tree, *args) == 2
3887 && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3895 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3896 /* Skip the size_t parameter. */
3897 arg_types = TREE_CHAIN (arg_types);
3898 /* Check the remaining parameters (if any). */
3900 && TREE_CHAIN (arg_types) == void_list_node
3901 && same_type_p (TREE_VALUE (arg_types),
3905 /* If we need a cookie, adjust the number of bytes allocated. */
3908 /* Update the total size. */
3909 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3910 /* Update the argument list to reflect the adjusted size. */
3911 VEC_replace (tree, *args, 0, *size);
3914 *cookie_size = NULL_TREE;
3917 /* Tell our caller which function we decided to call. */
3921 /* Build the CALL_EXPR. */
3922 return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3925 /* Build a new call to operator(). This may change ARGS. */
3928 build_op_call_1 (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3930 struct z_candidate *candidates = 0, *cand;
3931 tree fns, convs, first_mem_arg = NULL_TREE;
3932 tree type = TREE_TYPE (obj);
3934 tree result = NULL_TREE;
3937 if (error_operand_p (obj))
3938 return error_mark_node;
3940 obj = prep_operand (obj);
3942 if (TYPE_PTRMEMFUNC_P (type))
3944 if (complain & tf_error)
3945 /* It's no good looking for an overloaded operator() on a
3946 pointer-to-member-function. */
3947 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3948 return error_mark_node;
3951 if (TYPE_BINFO (type))
3953 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3954 if (fns == error_mark_node)
3955 return error_mark_node;
3960 if (args != NULL && *args != NULL)
3962 *args = resolve_args (*args, complain);
3964 return error_mark_node;
3967 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3968 p = conversion_obstack_alloc (0);
3972 first_mem_arg = build_this (obj);
3974 add_candidates (BASELINK_FUNCTIONS (fns),
3975 first_mem_arg, *args, NULL_TREE,
3977 BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
3978 LOOKUP_NORMAL, &candidates);
3981 convs = lookup_conversions (type);
3983 for (; convs; convs = TREE_CHAIN (convs))
3985 tree fns = TREE_VALUE (convs);
3986 tree totype = TREE_TYPE (convs);
3988 if ((TREE_CODE (totype) == POINTER_TYPE
3989 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3990 || (TREE_CODE (totype) == REFERENCE_TYPE
3991 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3992 || (TREE_CODE (totype) == REFERENCE_TYPE
3993 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3994 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3995 for (; fns; fns = OVL_NEXT (fns))
3997 tree fn = OVL_CURRENT (fns);
3999 if (DECL_NONCONVERTING_P (fn))
4002 if (TREE_CODE (fn) == TEMPLATE_DECL)
4003 add_template_conv_candidate
4004 (&candidates, fn, obj, NULL_TREE, *args, totype,
4005 /*access_path=*/NULL_TREE,
4006 /*conversion_path=*/NULL_TREE);
4008 add_conv_candidate (&candidates, fn, obj, NULL_TREE,
4009 *args, /*conversion_path=*/NULL_TREE,
4010 /*access_path=*/NULL_TREE);
4014 candidates = splice_viable (candidates, pedantic, &any_viable_p);
4017 if (complain & tf_error)
4019 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
4020 build_tree_list_vec (*args));
4021 print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4023 result = error_mark_node;
4027 cand = tourney (candidates);
4030 if (complain & tf_error)
4032 error ("call of %<(%T) (%A)%> is ambiguous",
4033 TREE_TYPE (obj), build_tree_list_vec (*args));
4034 print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4036 result = error_mark_node;
4038 /* Since cand->fn will be a type, not a function, for a conversion
4039 function, we must be careful not to unconditionally look at
4041 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
4042 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
4043 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4046 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
4048 obj = convert_from_reference (obj);
4049 result = cp_build_function_call_vec (obj, args, complain);
4053 /* Free all the conversions we allocated. */
4054 obstack_free (&conversion_obstack, p);
4059 /* Wrapper for above. */
4062 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
4065 bool subtime = timevar_cond_start (TV_OVERLOAD);
4066 ret = build_op_call_1 (obj, args, complain);
4067 timevar_cond_stop (TV_OVERLOAD, subtime);
4072 op_error (enum tree_code code, enum tree_code code2,
4073 tree arg1, tree arg2, tree arg3, bool match)
4077 if (code == MODIFY_EXPR)
4078 opname = assignment_operator_name_info[code2].name;
4080 opname = operator_name_info[code].name;
4086 error ("ambiguous overload for ternary %<operator?:%> "
4087 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
4089 error ("no match for ternary %<operator?:%> "
4090 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
4093 case POSTINCREMENT_EXPR:
4094 case POSTDECREMENT_EXPR:
4096 error ("ambiguous overload for %<operator%s%> in %<%E%s%>",
4097 opname, arg1, opname);
4099 error ("no match for %<operator%s%> in %<%E%s%>",
4100 opname, arg1, opname);
4105 error ("ambiguous overload for %<operator[]%> in %<%E[%E]%>",
4108 error ("no match for %<operator[]%> in %<%E[%E]%>",
4115 error ("ambiguous overload for %qs in %<%s %E%>",
4116 opname, opname, arg1);
4118 error ("no match for %qs in %<%s %E%>",
4119 opname, opname, arg1);
4125 error ("ambiguous overload for %<operator%s%> in %<%E %s %E%>",
4126 opname, arg1, opname, arg2);
4128 error ("no match for %<operator%s%> in %<%E %s %E%>",
4129 opname, arg1, opname, arg2);
4132 error ("ambiguous overload for %<operator%s%> in %<%s%E%>",
4133 opname, opname, arg1);
4135 error ("no match for %<operator%s%> in %<%s%E%>",
4136 opname, opname, arg1);
4141 /* Return the implicit conversion sequence that could be used to
4142 convert E1 to E2 in [expr.cond]. */
4145 conditional_conversion (tree e1, tree e2)
4147 tree t1 = non_reference (TREE_TYPE (e1));
4148 tree t2 = non_reference (TREE_TYPE (e2));
4154 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4155 implicitly converted (clause _conv_) to the type "reference to
4156 T2", subject to the constraint that in the conversion the
4157 reference must bind directly (_dcl.init.ref_) to E1. */
4158 if (real_lvalue_p (e2))
4160 conv = implicit_conversion (build_reference_type (t2),
4164 LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING);
4171 If E1 and E2 have class type, and the underlying class types are
4172 the same or one is a base class of the other: E1 can be converted
4173 to match E2 if the class of T2 is the same type as, or a base
4174 class of, the class of T1, and the cv-qualification of T2 is the
4175 same cv-qualification as, or a greater cv-qualification than, the
4176 cv-qualification of T1. If the conversion is applied, E1 is
4177 changed to an rvalue of type T2 that still refers to the original
4178 source class object (or the appropriate subobject thereof). */
4179 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
4180 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
4182 if (good_base && at_least_as_qualified_p (t2, t1))
4184 conv = build_identity_conv (t1, e1);
4185 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
4186 TYPE_MAIN_VARIANT (t2)))
4187 conv = build_conv (ck_base, t2, conv);
4189 conv = build_conv (ck_rvalue, t2, conv);
4198 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4199 converted to the type that expression E2 would have if E2 were
4200 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4201 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
4205 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4206 arguments to the conditional expression. */
4209 build_conditional_expr_1 (tree arg1, tree arg2, tree arg3,
4210 tsubst_flags_t complain)
4214 tree result = NULL_TREE;
4215 tree result_type = NULL_TREE;
4216 bool lvalue_p = true;
4217 struct z_candidate *candidates = 0;
4218 struct z_candidate *cand;
4221 /* As a G++ extension, the second argument to the conditional can be
4222 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4223 c'.) If the second operand is omitted, make sure it is
4224 calculated only once. */
4227 if (complain & tf_error)
4228 pedwarn (input_location, OPT_pedantic,
4229 "ISO C++ forbids omitting the middle term of a ?: expression");
4231 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4232 if (real_lvalue_p (arg1))
4233 arg2 = arg1 = stabilize_reference (arg1);
4235 arg2 = arg1 = save_expr (arg1);
4240 The first expression is implicitly converted to bool (clause
4242 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
4245 /* If something has already gone wrong, just pass that fact up the
4247 if (error_operand_p (arg1)
4248 || error_operand_p (arg2)
4249 || error_operand_p (arg3))
4250 return error_mark_node;
4254 If either the second or the third operand has type (possibly
4255 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4256 array-to-pointer (_conv.array_), and function-to-pointer
4257 (_conv.func_) standard conversions are performed on the second
4258 and third operands. */
4259 arg2_type = unlowered_expr_type (arg2);
4260 arg3_type = unlowered_expr_type (arg3);
4261 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
4263 /* Do the conversions. We don't these for `void' type arguments
4264 since it can't have any effect and since decay_conversion
4265 does not handle that case gracefully. */
4266 if (!VOID_TYPE_P (arg2_type))
4267 arg2 = decay_conversion (arg2);
4268 if (!VOID_TYPE_P (arg3_type))
4269 arg3 = decay_conversion (arg3);
4270 arg2_type = TREE_TYPE (arg2);
4271 arg3_type = TREE_TYPE (arg3);
4275 One of the following shall hold:
4277 --The second or the third operand (but not both) is a
4278 throw-expression (_except.throw_); the result is of the
4279 type of the other and is an rvalue.
4281 --Both the second and the third operands have type void; the
4282 result is of type void and is an rvalue.
4284 We must avoid calling force_rvalue for expressions of type
4285 "void" because it will complain that their value is being
4287 if (TREE_CODE (arg2) == THROW_EXPR
4288 && TREE_CODE (arg3) != THROW_EXPR)
4290 if (!VOID_TYPE_P (arg3_type))
4292 arg3 = force_rvalue (arg3, complain);
4293 if (arg3 == error_mark_node)
4294 return error_mark_node;
4296 arg3_type = TREE_TYPE (arg3);
4297 result_type = arg3_type;
4299 else if (TREE_CODE (arg2) != THROW_EXPR
4300 && TREE_CODE (arg3) == THROW_EXPR)
4302 if (!VOID_TYPE_P (arg2_type))
4304 arg2 = force_rvalue (arg2, complain);
4305 if (arg2 == error_mark_node)
4306 return error_mark_node;
4308 arg2_type = TREE_TYPE (arg2);
4309 result_type = arg2_type;
4311 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
4312 result_type = void_type_node;
4315 if (complain & tf_error)
4317 if (VOID_TYPE_P (arg2_type))
4318 error ("second operand to the conditional operator "
4319 "is of type %<void%>, "
4320 "but the third operand is neither a throw-expression "
4321 "nor of type %<void%>");
4323 error ("third operand to the conditional operator "
4324 "is of type %<void%>, "
4325 "but the second operand is neither a throw-expression "
4326 "nor of type %<void%>");
4328 return error_mark_node;
4332 goto valid_operands;
4336 Otherwise, if the second and third operand have different types,
4337 and either has (possibly cv-qualified) class type, an attempt is
4338 made to convert each of those operands to the type of the other. */
4339 else if (!same_type_p (arg2_type, arg3_type)
4340 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
4345 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4346 p = conversion_obstack_alloc (0);
4348 conv2 = conditional_conversion (arg2, arg3);
4349 conv3 = conditional_conversion (arg3, arg2);
4353 If both can be converted, or one can be converted but the
4354 conversion is ambiguous, the program is ill-formed. If
4355 neither can be converted, the operands are left unchanged and
4356 further checking is performed as described below. If exactly
4357 one conversion is possible, that conversion is applied to the
4358 chosen operand and the converted operand is used in place of
4359 the original operand for the remainder of this section. */
4360 if ((conv2 && !conv2->bad_p
4361 && conv3 && !conv3->bad_p)
4362 || (conv2 && conv2->kind == ck_ambig)
4363 || (conv3 && conv3->kind == ck_ambig))
4365 error ("operands to ?: have different types %qT and %qT",
4366 arg2_type, arg3_type);
4367 result = error_mark_node;
4369 else if (conv2 && (!conv2->bad_p || !conv3))
4371 arg2 = convert_like (conv2, arg2, complain);
4372 arg2 = convert_from_reference (arg2);
4373 arg2_type = TREE_TYPE (arg2);
4374 /* Even if CONV2 is a valid conversion, the result of the
4375 conversion may be invalid. For example, if ARG3 has type
4376 "volatile X", and X does not have a copy constructor
4377 accepting a "volatile X&", then even if ARG2 can be
4378 converted to X, the conversion will fail. */
4379 if (error_operand_p (arg2))
4380 result = error_mark_node;
4382 else if (conv3 && (!conv3->bad_p || !conv2))
4384 arg3 = convert_like (conv3, arg3, complain);
4385 arg3 = convert_from_reference (arg3);
4386 arg3_type = TREE_TYPE (arg3);
4387 if (error_operand_p (arg3))
4388 result = error_mark_node;
4391 /* Free all the conversions we allocated. */
4392 obstack_free (&conversion_obstack, p);
4397 /* If, after the conversion, both operands have class type,
4398 treat the cv-qualification of both operands as if it were the
4399 union of the cv-qualification of the operands.
4401 The standard is not clear about what to do in this
4402 circumstance. For example, if the first operand has type
4403 "const X" and the second operand has a user-defined
4404 conversion to "volatile X", what is the type of the second
4405 operand after this step? Making it be "const X" (matching
4406 the first operand) seems wrong, as that discards the
4407 qualification without actually performing a copy. Leaving it
4408 as "volatile X" seems wrong as that will result in the
4409 conditional expression failing altogether, even though,
4410 according to this step, the one operand could be converted to
4411 the type of the other. */
4412 if ((conv2 || conv3)
4413 && CLASS_TYPE_P (arg2_type)
4414 && cp_type_quals (arg2_type) != cp_type_quals (arg3_type))
4415 arg2_type = arg3_type =
4416 cp_build_qualified_type (arg2_type,
4417 cp_type_quals (arg2_type)
4418 | cp_type_quals (arg3_type));
4423 If the second and third operands are lvalues and have the same
4424 type, the result is of that type and is an lvalue. */
4425 if (real_lvalue_p (arg2)
4426 && real_lvalue_p (arg3)
4427 && same_type_p (arg2_type, arg3_type))
4429 result_type = arg2_type;
4430 arg2 = mark_lvalue_use (arg2);
4431 arg3 = mark_lvalue_use (arg3);
4432 goto valid_operands;
4437 Otherwise, the result is an rvalue. If the second and third
4438 operand do not have the same type, and either has (possibly
4439 cv-qualified) class type, overload resolution is used to
4440 determine the conversions (if any) to be applied to the operands
4441 (_over.match.oper_, _over.built_). */
4443 if (!same_type_p (arg2_type, arg3_type)
4444 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
4450 /* Rearrange the arguments so that add_builtin_candidate only has
4451 to know about two args. In build_builtin_candidate, the
4452 arguments are unscrambled. */
4456 add_builtin_candidates (&candidates,
4459 ansi_opname (COND_EXPR),
4465 If the overload resolution fails, the program is
4467 candidates = splice_viable (candidates, pedantic, &any_viable_p);
4470 if (complain & tf_error)
4472 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
4473 print_z_candidates (location_of (arg1), candidates);
4475 return error_mark_node;
4477 cand = tourney (candidates);
4480 if (complain & tf_error)
4482 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
4483 print_z_candidates (location_of (arg1), candidates);
4485 return error_mark_node;
4490 Otherwise, the conversions thus determined are applied, and
4491 the converted operands are used in place of the original
4492 operands for the remainder of this section. */
4493 conv = cand->convs[0];
4494 arg1 = convert_like (conv, arg1, complain);
4495 conv = cand->convs[1];
4496 arg2 = convert_like (conv, arg2, complain);
4497 arg2_type = TREE_TYPE (arg2);
4498 conv = cand->convs[2];
4499 arg3 = convert_like (conv, arg3, complain);
4500 arg3_type = TREE_TYPE (arg3);
4505 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
4506 and function-to-pointer (_conv.func_) standard conversions are
4507 performed on the second and third operands.
4509 We need to force the lvalue-to-rvalue conversion here for class types,
4510 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
4511 that isn't wrapped with a TARGET_EXPR plays havoc with exception
4514 arg2 = force_rvalue (arg2, complain);
4515 if (!CLASS_TYPE_P (arg2_type))
4516 arg2_type = TREE_TYPE (arg2);
4518 arg3 = force_rvalue (arg3, complain);
4519 if (!CLASS_TYPE_P (arg3_type))
4520 arg3_type = TREE_TYPE (arg3);
4522 if (arg2 == error_mark_node || arg3 == error_mark_node)
4523 return error_mark_node;
4527 After those conversions, one of the following shall hold:
4529 --The second and third operands have the same type; the result is of
4531 if (same_type_p (arg2_type, arg3_type))
4532 result_type = arg2_type;
4535 --The second and third operands have arithmetic or enumeration
4536 type; the usual arithmetic conversions are performed to bring
4537 them to a common type, and the result is of that type. */
4538 else if ((ARITHMETIC_TYPE_P (arg2_type)
4539 || UNSCOPED_ENUM_P (arg2_type))
4540 && (ARITHMETIC_TYPE_P (arg3_type)
4541 || UNSCOPED_ENUM_P (arg3_type)))
4543 /* In this case, there is always a common type. */
4544 result_type = type_after_usual_arithmetic_conversions (arg2_type,
4546 do_warn_double_promotion (result_type, arg2_type, arg3_type,
4547 "implicit conversion from %qT to %qT to "
4548 "match other result of conditional",
4551 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
4552 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
4554 if (complain & tf_warning)
4556 "enumeral mismatch in conditional expression: %qT vs %qT",
4557 arg2_type, arg3_type);
4559 else if (extra_warnings
4560 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
4561 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
4562 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
4563 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
4565 if (complain & tf_warning)
4567 "enumeral and non-enumeral type in conditional expression");
4570 arg2 = perform_implicit_conversion (result_type, arg2, complain);
4571 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4575 --The second and third operands have pointer type, or one has
4576 pointer type and the other is a null pointer constant; pointer
4577 conversions (_conv.ptr_) and qualification conversions
4578 (_conv.qual_) are performed to bring them to their composite
4579 pointer type (_expr.rel_). The result is of the composite
4582 --The second and third operands have pointer to member type, or
4583 one has pointer to member type and the other is a null pointer
4584 constant; pointer to member conversions (_conv.mem_) and
4585 qualification conversions (_conv.qual_) are performed to bring
4586 them to a common type, whose cv-qualification shall match the
4587 cv-qualification of either the second or the third operand.
4588 The result is of the common type. */
4589 else if ((null_ptr_cst_p (arg2)
4590 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
4591 || (null_ptr_cst_p (arg3)
4592 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
4593 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
4594 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
4595 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
4597 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
4598 arg3, CPO_CONDITIONAL_EXPR,
4600 if (result_type == error_mark_node)
4601 return error_mark_node;
4602 arg2 = perform_implicit_conversion (result_type, arg2, complain);
4603 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4608 if (complain & tf_error)
4609 error ("operands to ?: have different types %qT and %qT",
4610 arg2_type, arg3_type);
4611 return error_mark_node;
4615 result = build3 (COND_EXPR, result_type, arg1, arg2, arg3);
4616 if (!cp_unevaluated_operand)
4617 /* Avoid folding within decltype (c++/42013) and noexcept. */
4618 result = fold_if_not_in_template (result);
4620 /* We can't use result_type below, as fold might have returned a
4625 /* Expand both sides into the same slot, hopefully the target of
4626 the ?: expression. We used to check for TARGET_EXPRs here,
4627 but now we sometimes wrap them in NOP_EXPRs so the test would
4629 if (CLASS_TYPE_P (TREE_TYPE (result)))
4630 result = get_target_expr (result);
4631 /* If this expression is an rvalue, but might be mistaken for an
4632 lvalue, we must add a NON_LVALUE_EXPR. */
4633 result = rvalue (result);
4639 /* Wrapper for above. */
4642 build_conditional_expr (tree arg1, tree arg2, tree arg3,
4643 tsubst_flags_t complain)
4646 bool subtime = timevar_cond_start (TV_OVERLOAD);
4647 ret = build_conditional_expr_1 (arg1, arg2, arg3, complain);
4648 timevar_cond_stop (TV_OVERLOAD, subtime);
4652 /* OPERAND is an operand to an expression. Perform necessary steps
4653 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4657 prep_operand (tree operand)
4661 if (CLASS_TYPE_P (TREE_TYPE (operand))
4662 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
4663 /* Make sure the template type is instantiated now. */
4664 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
4670 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4671 OVERLOAD) to the CANDIDATES, returning an updated list of
4672 CANDIDATES. The ARGS are the arguments provided to the call;
4673 if FIRST_ARG is non-null it is the implicit object argument,
4674 otherwise the first element of ARGS is used if needed. The
4675 EXPLICIT_TARGS are explicit template arguments provided.
4676 TEMPLATE_ONLY is true if only template functions should be
4677 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4678 add_function_candidate. */
4681 add_candidates (tree fns, tree first_arg, const VEC(tree,gc) *args,
4683 tree explicit_targs, bool template_only,
4684 tree conversion_path, tree access_path,
4686 struct z_candidate **candidates)
4689 const VEC(tree,gc) *non_static_args;
4690 bool check_list_ctor;
4691 bool check_converting;
4692 unification_kind_t strict;
4698 /* Precalculate special handling of constructors and conversion ops. */
4699 fn = OVL_CURRENT (fns);
4700 if (DECL_CONV_FN_P (fn))
4702 check_list_ctor = false;
4703 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4704 if (flags & LOOKUP_NO_CONVERSION)
4705 /* We're doing return_type(x). */
4706 strict = DEDUCE_CONV;
4708 /* We're doing x.operator return_type(). */
4709 strict = DEDUCE_EXACT;
4710 /* [over.match.funcs] For conversion functions, the function
4711 is considered to be a member of the class of the implicit
4712 object argument for the purpose of defining the type of
4713 the implicit object parameter. */
4714 ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
4718 if (DECL_CONSTRUCTOR_P (fn))
4720 check_list_ctor = !!(flags & LOOKUP_LIST_ONLY);
4721 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4725 check_list_ctor = false;
4726 check_converting = false;
4728 strict = DEDUCE_CALL;
4729 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
4733 non_static_args = args;
4735 /* Delay creating the implicit this parameter until it is needed. */
4736 non_static_args = NULL;
4738 for (; fns; fns = OVL_NEXT (fns))
4741 const VEC(tree,gc) *fn_args;
4743 fn = OVL_CURRENT (fns);
4745 if (check_converting && DECL_NONCONVERTING_P (fn))
4747 if (check_list_ctor && !is_list_ctor (fn))
4750 /* Figure out which set of arguments to use. */
4751 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
4753 /* If this function is a non-static member and we didn't get an
4754 implicit object argument, move it out of args. */
4755 if (first_arg == NULL_TREE)
4759 VEC(tree,gc) *tempvec
4760 = VEC_alloc (tree, gc, VEC_length (tree, args) - 1);
4761 for (ix = 1; VEC_iterate (tree, args, ix, arg); ++ix)
4762 VEC_quick_push (tree, tempvec, arg);
4763 non_static_args = tempvec;
4764 first_arg = build_this (VEC_index (tree, args, 0));
4767 fn_first_arg = first_arg;
4768 fn_args = non_static_args;
4772 /* Otherwise, just use the list of arguments provided. */
4773 fn_first_arg = NULL_TREE;
4777 if (TREE_CODE (fn) == TEMPLATE_DECL)
4778 add_template_candidate (candidates,
4789 else if (!template_only)
4790 add_function_candidate (candidates,
4801 /* Even unsigned enum types promote to signed int. We don't want to
4802 issue -Wsign-compare warnings for this case. Here ORIG_ARG is the
4803 original argument and ARG is the argument after any conversions
4804 have been applied. We set TREE_NO_WARNING if we have added a cast
4805 from an unsigned enum type to a signed integer type. */
4808 avoid_sign_compare_warnings (tree orig_arg, tree arg)
4810 if (orig_arg != NULL_TREE
4813 && TREE_CODE (TREE_TYPE (orig_arg)) == ENUMERAL_TYPE
4814 && TYPE_UNSIGNED (TREE_TYPE (orig_arg))
4815 && INTEGRAL_TYPE_P (TREE_TYPE (arg))
4816 && !TYPE_UNSIGNED (TREE_TYPE (arg)))
4817 TREE_NO_WARNING (arg) = 1;
4821 build_new_op_1 (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
4822 tree *overload, tsubst_flags_t complain)
4824 tree orig_arg1 = arg1;
4825 tree orig_arg2 = arg2;
4826 tree orig_arg3 = arg3;
4827 struct z_candidate *candidates = 0, *cand;
4828 VEC(tree,gc) *arglist;
4831 tree result = NULL_TREE;
4832 bool result_valid_p = false;
4833 enum tree_code code2 = NOP_EXPR;
4834 enum tree_code code_orig_arg1 = ERROR_MARK;
4835 enum tree_code code_orig_arg2 = ERROR_MARK;
4841 if (error_operand_p (arg1)
4842 || error_operand_p (arg2)
4843 || error_operand_p (arg3))
4844 return error_mark_node;
4846 if (code == MODIFY_EXPR)
4848 code2 = TREE_CODE (arg3);
4850 fnname = ansi_assopname (code2);
4853 fnname = ansi_opname (code);
4855 arg1 = prep_operand (arg1);
4861 case VEC_DELETE_EXPR:
4863 /* Use build_op_new_call and build_op_delete_call instead. */
4867 /* Use build_op_call instead. */
4870 case TRUTH_ORIF_EXPR:
4871 case TRUTH_ANDIF_EXPR:
4872 case TRUTH_AND_EXPR:
4874 /* These are saved for the sake of warn_logical_operator. */
4875 code_orig_arg1 = TREE_CODE (arg1);
4876 code_orig_arg2 = TREE_CODE (arg2);
4882 arg2 = prep_operand (arg2);
4883 arg3 = prep_operand (arg3);
4885 if (code == COND_EXPR)
4886 /* Use build_conditional_expr instead. */
4888 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4889 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4892 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4893 arg2 = integer_zero_node;
4895 arglist = VEC_alloc (tree, gc, 3);
4896 VEC_quick_push (tree, arglist, arg1);
4897 if (arg2 != NULL_TREE)
4898 VEC_quick_push (tree, arglist, arg2);
4899 if (arg3 != NULL_TREE)
4900 VEC_quick_push (tree, arglist, arg3);
4902 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4903 p = conversion_obstack_alloc (0);
4905 /* Add namespace-scope operators to the list of functions to
4907 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
4908 NULL_TREE, arglist, NULL_TREE,
4909 NULL_TREE, false, NULL_TREE, NULL_TREE,
4910 flags, &candidates);
4911 /* Add class-member operators to the candidate set. */
4912 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
4916 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
4917 if (fns == error_mark_node)
4919 result = error_mark_node;
4920 goto user_defined_result_ready;
4923 add_candidates (BASELINK_FUNCTIONS (fns),
4924 NULL_TREE, arglist, NULL_TREE,
4926 BASELINK_BINFO (fns),
4927 BASELINK_ACCESS_BINFO (fns),
4928 flags, &candidates);
4933 args[2] = NULL_TREE;
4935 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
4941 /* For these, the built-in candidates set is empty
4942 [over.match.oper]/3. We don't want non-strict matches
4943 because exact matches are always possible with built-in
4944 operators. The built-in candidate set for COMPONENT_REF
4945 would be empty too, but since there are no such built-in
4946 operators, we accept non-strict matches for them. */
4951 strict_p = pedantic;
4955 candidates = splice_viable (candidates, strict_p, &any_viable_p);
4960 case POSTINCREMENT_EXPR:
4961 case POSTDECREMENT_EXPR:
4962 /* Don't try anything fancy if we're not allowed to produce
4964 if (!(complain & tf_error))
4965 return error_mark_node;
4967 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
4968 distinguish between prefix and postfix ++ and
4969 operator++() was used for both, so we allow this with
4971 if (flags & LOOKUP_COMPLAIN)
4973 const char *msg = (flag_permissive)
4974 ? G_("no %<%D(int)%> declared for postfix %qs,"
4975 " trying prefix operator instead")
4976 : G_("no %<%D(int)%> declared for postfix %qs");
4977 permerror (input_location, msg, fnname,
4978 operator_name_info[code].name);
4981 if (!flag_permissive)
4982 return error_mark_node;
4984 if (code == POSTINCREMENT_EXPR)
4985 code = PREINCREMENT_EXPR;
4987 code = PREDECREMENT_EXPR;
4988 result = build_new_op_1 (code, flags, arg1, NULL_TREE, NULL_TREE,
4989 overload, complain);
4992 /* The caller will deal with these. */
4997 result_valid_p = true;
5001 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
5003 /* If one of the arguments of the operator represents
5004 an invalid use of member function pointer, try to report
5005 a meaningful error ... */
5006 if (invalid_nonstatic_memfn_p (arg1, tf_error)
5007 || invalid_nonstatic_memfn_p (arg2, tf_error)
5008 || invalid_nonstatic_memfn_p (arg3, tf_error))
5009 /* We displayed the error message. */;
5012 /* ... Otherwise, report the more generic
5013 "no matching operator found" error */
5014 op_error (code, code2, arg1, arg2, arg3, FALSE);
5015 print_z_candidates (input_location, candidates);
5018 result = error_mark_node;
5024 cand = tourney (candidates);
5027 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
5029 op_error (code, code2, arg1, arg2, arg3, TRUE);
5030 print_z_candidates (input_location, candidates);
5032 result = error_mark_node;
5034 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
5037 *overload = cand->fn;
5039 if (resolve_args (arglist, complain) == NULL)
5040 result = error_mark_node;
5042 result = build_over_call (cand, LOOKUP_NORMAL, complain);
5046 /* Give any warnings we noticed during overload resolution. */
5047 if (cand->warnings && (complain & tf_warning))
5049 struct candidate_warning *w;
5050 for (w = cand->warnings; w; w = w->next)
5051 joust (cand, w->loser, 1);
5054 /* Check for comparison of different enum types. */
5063 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
5064 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
5065 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
5066 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
5067 && (complain & tf_warning))
5069 warning (OPT_Wenum_compare,
5070 "comparison between %q#T and %q#T",
5071 TREE_TYPE (arg1), TREE_TYPE (arg2));
5078 /* We need to strip any leading REF_BIND so that bitfields
5079 don't cause errors. This should not remove any important
5080 conversions, because builtins don't apply to class
5081 objects directly. */
5082 conv = cand->convs[0];
5083 if (conv->kind == ck_ref_bind)
5084 conv = conv->u.next;
5085 arg1 = convert_like (conv, arg1, complain);
5089 /* We need to call warn_logical_operator before
5090 converting arg2 to a boolean_type. */
5091 if (complain & tf_warning)
5092 warn_logical_operator (input_location, code, boolean_type_node,
5093 code_orig_arg1, arg1,
5094 code_orig_arg2, arg2);
5096 conv = cand->convs[1];
5097 if (conv->kind == ck_ref_bind)
5098 conv = conv->u.next;
5099 arg2 = convert_like (conv, arg2, complain);
5103 conv = cand->convs[2];
5104 if (conv->kind == ck_ref_bind)
5105 conv = conv->u.next;
5106 arg3 = convert_like (conv, arg3, complain);
5112 user_defined_result_ready:
5114 /* Free all the conversions we allocated. */
5115 obstack_free (&conversion_obstack, p);
5117 if (result || result_valid_p)
5121 avoid_sign_compare_warnings (orig_arg1, arg1);
5122 avoid_sign_compare_warnings (orig_arg2, arg2);
5123 avoid_sign_compare_warnings (orig_arg3, arg3);
5128 return cp_build_modify_expr (arg1, code2, arg2, complain);
5131 return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
5133 case TRUTH_ANDIF_EXPR:
5134 case TRUTH_ORIF_EXPR:
5135 case TRUTH_AND_EXPR:
5137 warn_logical_operator (input_location, code, boolean_type_node,
5138 code_orig_arg1, arg1, code_orig_arg2, arg2);
5143 case TRUNC_DIV_EXPR:
5154 case TRUNC_MOD_EXPR:
5158 return cp_build_binary_op (input_location, code, arg1, arg2, complain);
5160 case UNARY_PLUS_EXPR:
5163 case TRUTH_NOT_EXPR:
5164 case PREINCREMENT_EXPR:
5165 case POSTINCREMENT_EXPR:
5166 case PREDECREMENT_EXPR:
5167 case POSTDECREMENT_EXPR:
5170 return cp_build_unary_op (code, arg1, candidates != 0, complain);
5173 return cp_build_array_ref (input_location, arg1, arg2, complain);
5176 return build_m_component_ref (cp_build_indirect_ref (arg1, RO_NULL,
5180 /* The caller will deal with these. */
5192 /* Wrapper for above. */
5195 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
5196 tree *overload, tsubst_flags_t complain)
5199 bool subtime = timevar_cond_start (TV_OVERLOAD);
5200 ret = build_new_op_1 (code, flags, arg1, arg2, arg3, overload, complain);
5201 timevar_cond_stop (TV_OVERLOAD, subtime);
5205 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5206 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5209 non_placement_deallocation_fn_p (tree t)
5211 /* A template instance is never a usual deallocation function,
5212 regardless of its signature. */
5213 if (TREE_CODE (t) == TEMPLATE_DECL
5214 || primary_template_instantiation_p (t))
5217 /* If a class T has a member deallocation function named operator delete
5218 with exactly one parameter, then that function is a usual
5219 (non-placement) deallocation function. If class T does not declare
5220 such an operator delete but does declare a member deallocation
5221 function named operator delete with exactly two parameters, the second
5222 of which has type std::size_t (18.2), then this function is a usual
5223 deallocation function. */
5224 t = FUNCTION_ARG_CHAIN (t);
5225 if (t == void_list_node
5226 || (t && same_type_p (TREE_VALUE (t), size_type_node)
5227 && TREE_CHAIN (t) == void_list_node))
5232 /* Build a call to operator delete. This has to be handled very specially,
5233 because the restrictions on what signatures match are different from all
5234 other call instances. For a normal delete, only a delete taking (void *)
5235 or (void *, size_t) is accepted. For a placement delete, only an exact
5236 match with the placement new is accepted.
5238 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5239 ADDR is the pointer to be deleted.
5240 SIZE is the size of the memory block to be deleted.
5241 GLOBAL_P is true if the delete-expression should not consider
5242 class-specific delete operators.
5243 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5245 If this call to "operator delete" is being generated as part to
5246 deallocate memory allocated via a new-expression (as per [expr.new]
5247 which requires that if the initialization throws an exception then
5248 we call a deallocation function), then ALLOC_FN is the allocation
5252 build_op_delete_call (enum tree_code code, tree addr, tree size,
5253 bool global_p, tree placement,
5256 tree fn = NULL_TREE;
5257 tree fns, fnname, type, t;
5259 if (addr == error_mark_node)
5260 return error_mark_node;
5262 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
5264 fnname = ansi_opname (code);
5266 if (CLASS_TYPE_P (type)
5267 && COMPLETE_TYPE_P (complete_type (type))
5271 If the result of the lookup is ambiguous or inaccessible, or if
5272 the lookup selects a placement deallocation function, the
5273 program is ill-formed.
5275 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5277 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
5278 if (fns == error_mark_node)
5279 return error_mark_node;
5284 if (fns == NULL_TREE)
5285 fns = lookup_name_nonclass (fnname);
5287 /* Strip const and volatile from addr. */
5288 addr = cp_convert (ptr_type_node, addr);
5292 /* "A declaration of a placement deallocation function matches the
5293 declaration of a placement allocation function if it has the same
5294 number of parameters and, after parameter transformations (8.3.5),
5295 all parameter types except the first are identical."
5297 So we build up the function type we want and ask instantiate_type
5298 to get it for us. */
5299 t = FUNCTION_ARG_CHAIN (alloc_fn);
5300 t = tree_cons (NULL_TREE, ptr_type_node, t);
5301 t = build_function_type (void_type_node, t);
5303 fn = instantiate_type (t, fns, tf_none);
5304 if (fn == error_mark_node)
5307 if (BASELINK_P (fn))
5308 fn = BASELINK_FUNCTIONS (fn);
5310 /* "If the lookup finds the two-parameter form of a usual deallocation
5311 function (3.7.4.2) and that function, considered as a placement
5312 deallocation function, would have been selected as a match for the
5313 allocation function, the program is ill-formed." */
5314 if (non_placement_deallocation_fn_p (fn))
5316 /* But if the class has an operator delete (void *), then that is
5317 the usual deallocation function, so we shouldn't complain
5318 about using the operator delete (void *, size_t). */
5319 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
5320 t; t = OVL_NEXT (t))
5322 tree elt = OVL_CURRENT (t);
5323 if (non_placement_deallocation_fn_p (elt)
5324 && FUNCTION_ARG_CHAIN (elt) == void_list_node)
5327 permerror (0, "non-placement deallocation function %q+D", fn);
5328 permerror (input_location, "selected for placement delete");
5333 /* "Any non-placement deallocation function matches a non-placement
5334 allocation function. If the lookup finds a single matching
5335 deallocation function, that function will be called; otherwise, no
5336 deallocation function will be called." */
5337 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
5338 t; t = OVL_NEXT (t))
5340 tree elt = OVL_CURRENT (t);
5341 if (non_placement_deallocation_fn_p (elt))
5344 /* "If a class T has a member deallocation function named
5345 operator delete with exactly one parameter, then that
5346 function is a usual (non-placement) deallocation
5347 function. If class T does not declare such an operator
5348 delete but does declare a member deallocation function named
5349 operator delete with exactly two parameters, the second of
5350 which has type std::size_t (18.2), then this function is a
5351 usual deallocation function."
5353 So (void*) beats (void*, size_t). */
5354 if (FUNCTION_ARG_CHAIN (fn) == void_list_node)
5359 /* If we have a matching function, call it. */
5362 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
5364 /* If the FN is a member function, make sure that it is
5366 if (BASELINK_P (fns))
5367 perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn);
5369 /* Core issue 901: It's ok to new a type with deleted delete. */
5370 if (DECL_DELETED_FN (fn) && alloc_fn)
5375 /* The placement args might not be suitable for overload
5376 resolution at this point, so build the call directly. */
5377 int nargs = call_expr_nargs (placement);
5378 tree *argarray = XALLOCAVEC (tree, nargs);
5381 for (i = 1; i < nargs; i++)
5382 argarray[i] = CALL_EXPR_ARG (placement, i);
5384 return build_cxx_call (fn, nargs, argarray);
5389 VEC(tree,gc) *args = VEC_alloc (tree, gc, 2);
5390 VEC_quick_push (tree, args, addr);
5391 if (FUNCTION_ARG_CHAIN (fn) != void_list_node)
5392 VEC_quick_push (tree, args, size);
5393 ret = cp_build_function_call_vec (fn, &args, tf_warning_or_error);
5394 VEC_free (tree, gc, args);
5401 If no unambiguous matching deallocation function can be found,
5402 propagating the exception does not cause the object's memory to
5407 warning (0, "no corresponding deallocation function for %qD",
5412 error ("no suitable %<operator %s%> for %qT",
5413 operator_name_info[(int)code].name, type);
5414 return error_mark_node;
5417 /* If the current scope isn't allowed to access DECL along
5418 BASETYPE_PATH, give an error. The most derived class in
5419 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
5420 the declaration to use in the error diagnostic. */
5423 enforce_access (tree basetype_path, tree decl, tree diag_decl)
5425 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
5427 if (!accessible_p (basetype_path, decl, true))
5429 if (TREE_PRIVATE (decl))
5430 error ("%q+#D is private", diag_decl);
5431 else if (TREE_PROTECTED (decl))
5432 error ("%q+#D is protected", diag_decl);
5434 error ("%q+#D is inaccessible", diag_decl);
5435 error ("within this context");
5442 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
5443 bitwise or of LOOKUP_* values. If any errors are warnings are
5444 generated, set *DIAGNOSTIC_FN to "error" or "warning",
5445 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
5449 build_temp (tree expr, tree type, int flags,
5450 diagnostic_t *diagnostic_kind, tsubst_flags_t complain)
5455 savew = warningcount, savee = errorcount;
5456 args = make_tree_vector_single (expr);
5457 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
5458 &args, type, flags, complain);
5459 release_tree_vector (args);
5460 if (warningcount > savew)
5461 *diagnostic_kind = DK_WARNING;
5462 else if (errorcount > savee)
5463 *diagnostic_kind = DK_ERROR;
5465 *diagnostic_kind = DK_UNSPECIFIED;
5469 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
5470 EXPR is implicitly converted to type TOTYPE.
5471 FN and ARGNUM are used for diagnostics. */
5474 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
5476 tree t = non_reference (totype);
5478 /* Issue warnings about peculiar, but valid, uses of NULL. */
5479 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
5482 warning_at (input_location, OPT_Wconversion_null,
5483 "passing NULL to non-pointer argument %P of %qD",
5486 warning_at (input_location, OPT_Wconversion_null,
5487 "converting to non-pointer type %qT from NULL", t);
5490 /* Issue warnings if "false" is converted to a NULL pointer */
5491 else if (expr == boolean_false_node && POINTER_TYPE_P (t))
5494 warning_at (input_location, OPT_Wconversion_null,
5495 "converting %<false%> to pointer type for argument %P "
5496 "of %qD", argnum, fn);
5498 warning_at (input_location, OPT_Wconversion_null,
5499 "converting %<false%> to pointer type %qT", t);
5503 /* Perform the conversions in CONVS on the expression EXPR. FN and
5504 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
5505 indicates the `this' argument of a method. INNER is nonzero when
5506 being called to continue a conversion chain. It is negative when a
5507 reference binding will be applied, positive otherwise. If
5508 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
5509 conversions will be emitted if appropriate. If C_CAST_P is true,
5510 this conversion is coming from a C-style cast; in that case,
5511 conversions to inaccessible bases are permitted. */
5514 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
5515 int inner, bool issue_conversion_warnings,
5516 bool c_cast_p, tsubst_flags_t complain)
5518 tree totype = convs->type;
5519 diagnostic_t diag_kind;
5523 && convs->kind != ck_user
5524 && convs->kind != ck_list
5525 && convs->kind != ck_ambig
5526 && convs->kind != ck_ref_bind
5527 && convs->kind != ck_rvalue
5528 && convs->kind != ck_base)
5530 conversion *t = convs;
5532 /* Give a helpful error if this is bad because of excess braces. */
5533 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
5534 && SCALAR_TYPE_P (totype)
5535 && CONSTRUCTOR_NELTS (expr) > 0
5536 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
5537 permerror (input_location, "too many braces around initializer for %qT", totype);
5539 for (; t; t = convs->u.next)
5541 if (t->kind == ck_user && t->cand->reason)
5543 permerror (input_location, "invalid user-defined conversion "
5544 "from %qT to %qT", TREE_TYPE (expr), totype);
5545 print_z_candidate ("candidate is:", t->cand);
5546 expr = convert_like_real (t, expr, fn, argnum, 1,
5547 /*issue_conversion_warnings=*/false,
5550 return cp_convert (totype, expr);
5552 else if (t->kind == ck_user || !t->bad_p)
5554 expr = convert_like_real (t, expr, fn, argnum, 1,
5555 /*issue_conversion_warnings=*/false,
5560 else if (t->kind == ck_ambig)
5561 return convert_like_real (t, expr, fn, argnum, 1,
5562 /*issue_conversion_warnings=*/false,
5565 else if (t->kind == ck_identity)
5568 if (complain & tf_error)
5570 permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
5572 permerror (DECL_SOURCE_LOCATION (fn),
5573 " initializing argument %P of %qD", argnum, fn);
5576 return error_mark_node;
5578 return cp_convert (totype, expr);
5581 if (issue_conversion_warnings && (complain & tf_warning))
5582 conversion_null_warnings (totype, expr, fn, argnum);
5584 switch (convs->kind)
5588 struct z_candidate *cand = convs->cand;
5589 tree convfn = cand->fn;
5592 expr = mark_rvalue_use (expr);
5594 /* When converting from an init list we consider explicit
5595 constructors, but actually trying to call one is an error. */
5596 if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn)
5597 /* Unless we're calling it for value-initialization from an
5598 empty list, since that is handled separately in 8.5.4. */
5599 && cand->num_convs > 0)
5601 if (complain & tf_error)
5602 error ("converting to %qT from initializer list would use "
5603 "explicit constructor %qD", totype, convfn);
5605 return error_mark_node;
5608 /* Set user_conv_p on the argument conversions, so rvalue/base
5609 handling knows not to allow any more UDCs. */
5610 for (i = 0; i < cand->num_convs; ++i)
5611 cand->convs[i]->user_conv_p = true;
5613 expr = build_over_call (cand, LOOKUP_NORMAL, complain);
5615 /* If this is a constructor or a function returning an aggr type,
5616 we need to build up a TARGET_EXPR. */
5617 if (DECL_CONSTRUCTOR_P (convfn))
5619 expr = build_cplus_new (totype, expr, complain);
5621 /* Remember that this was list-initialization. */
5622 if (convs->check_narrowing && expr != error_mark_node)
5623 TARGET_EXPR_LIST_INIT_P (expr) = true;
5629 expr = mark_rvalue_use (expr);
5630 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
5632 int nelts = CONSTRUCTOR_NELTS (expr);
5634 expr = build_value_init (totype, tf_warning_or_error);
5635 else if (nelts == 1)
5636 expr = CONSTRUCTOR_ELT (expr, 0)->value;
5641 if (type_unknown_p (expr))
5642 expr = instantiate_type (totype, expr, complain);
5643 /* Convert a constant to its underlying value, unless we are
5644 about to bind it to a reference, in which case we need to
5645 leave it as an lvalue. */
5648 expr = decl_constant_value (expr);
5649 if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
5650 /* If __null has been converted to an integer type, we do not
5651 want to warn about uses of EXPR as an integer, rather than
5653 expr = build_int_cst (totype, 0);
5657 if (complain & tf_error)
5659 /* Call build_user_type_conversion again for the error. */
5660 build_user_type_conversion (totype, convs->u.expr, LOOKUP_NORMAL);
5662 error (" initializing argument %P of %q+D", argnum, fn);
5664 return error_mark_node;
5668 /* Conversion to std::initializer_list<T>. */
5669 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
5670 tree new_ctor = build_constructor (init_list_type_node, NULL);
5671 unsigned len = CONSTRUCTOR_NELTS (expr);
5672 tree array, val, field;
5673 VEC(constructor_elt,gc) *vec = NULL;
5676 /* Convert all the elements. */
5677 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
5679 tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
5680 1, false, false, complain);
5681 if (sub == error_mark_node)
5683 if (!BRACE_ENCLOSED_INITIALIZER_P (val))
5684 check_narrowing (TREE_TYPE (sub), val);
5685 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
5686 if (!TREE_CONSTANT (sub))
5687 TREE_CONSTANT (new_ctor) = false;
5689 /* Build up the array. */
5690 elttype = cp_build_qualified_type
5691 (elttype, cp_type_quals (elttype) | TYPE_QUAL_CONST);
5692 array = build_array_of_n_type (elttype, len);
5693 array = finish_compound_literal (array, new_ctor, complain);
5695 /* Build up the initializer_list object. */
5696 totype = complete_type (totype);
5697 field = next_initializable_field (TYPE_FIELDS (totype));
5698 CONSTRUCTOR_APPEND_ELT (vec, field, decay_conversion (array));
5699 field = next_initializable_field (DECL_CHAIN (field));
5700 CONSTRUCTOR_APPEND_ELT (vec, field, size_int (len));
5701 new_ctor = build_constructor (totype, vec);
5702 return get_target_expr (new_ctor);
5706 if (TREE_CODE (totype) == COMPLEX_TYPE)
5708 tree real = CONSTRUCTOR_ELT (expr, 0)->value;
5709 tree imag = CONSTRUCTOR_ELT (expr, 1)->value;
5710 real = perform_implicit_conversion (TREE_TYPE (totype),
5712 imag = perform_implicit_conversion (TREE_TYPE (totype),
5714 expr = build2 (COMPLEX_EXPR, totype, real, imag);
5715 return fold_if_not_in_template (expr);
5717 return get_target_expr (digest_init (totype, expr, complain));
5723 expr = convert_like_real (convs->u.next, expr, fn, argnum,
5724 convs->kind == ck_ref_bind ? -1 : 1,
5725 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
5728 if (expr == error_mark_node)
5729 return error_mark_node;
5731 switch (convs->kind)
5734 expr = decay_conversion (expr);
5735 if (! MAYBE_CLASS_TYPE_P (totype))
5737 /* Else fall through. */
5739 if (convs->kind == ck_base && !convs->need_temporary_p)
5741 /* We are going to bind a reference directly to a base-class
5742 subobject of EXPR. */
5743 /* Build an expression for `*((base*) &expr)'. */
5744 expr = cp_build_addr_expr (expr, complain);
5745 expr = convert_to_base (expr, build_pointer_type (totype),
5746 !c_cast_p, /*nonnull=*/true, complain);
5747 expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
5751 /* Copy-initialization where the cv-unqualified version of the source
5752 type is the same class as, or a derived class of, the class of the
5753 destination [is treated as direct-initialization]. [dcl.init] */
5754 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
5755 if (convs->user_conv_p)
5756 /* This conversion is being done in the context of a user-defined
5757 conversion (i.e. the second step of copy-initialization), so
5758 don't allow any more. */
5759 flags |= LOOKUP_NO_CONVERSION;
5760 if (convs->rvaluedness_matches_p)
5761 flags |= LOOKUP_PREFER_RVALUE;
5762 if (TREE_CODE (expr) == TARGET_EXPR
5763 && TARGET_EXPR_LIST_INIT_P (expr))
5764 /* Copy-list-initialization doesn't actually involve a copy. */
5766 expr = build_temp (expr, totype, flags, &diag_kind, complain);
5767 if (diag_kind && fn)
5769 if ((complain & tf_error))
5770 emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (fn), 0,
5771 " initializing argument %P of %qD", argnum, fn);
5772 else if (diag_kind == DK_ERROR)
5773 return error_mark_node;
5775 return build_cplus_new (totype, expr, complain);
5779 tree ref_type = totype;
5781 if (convs->bad_p && TYPE_REF_IS_RVALUE (ref_type)
5782 && real_lvalue_p (expr))
5784 if (complain & tf_error)
5786 error ("cannot bind %qT lvalue to %qT",
5787 TREE_TYPE (expr), totype);
5789 error (" initializing argument %P of %q+D", argnum, fn);
5791 return error_mark_node;
5794 /* If necessary, create a temporary.
5796 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
5797 that need temporaries, even when their types are reference
5798 compatible with the type of reference being bound, so the
5799 upcoming call to cp_build_addr_expr doesn't fail. */
5800 if (convs->need_temporary_p
5801 || TREE_CODE (expr) == CONSTRUCTOR
5802 || TREE_CODE (expr) == VA_ARG_EXPR)
5804 /* Otherwise, a temporary of type "cv1 T1" is created and
5805 initialized from the initializer expression using the rules
5806 for a non-reference copy-initialization (8.5). */
5808 tree type = TREE_TYPE (ref_type);
5809 cp_lvalue_kind lvalue = real_lvalue_p (expr);
5811 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5812 (type, convs->u.next->type));
5813 if (!CP_TYPE_CONST_NON_VOLATILE_P (type)
5814 && !TYPE_REF_IS_RVALUE (ref_type))
5816 if (complain & tf_error)
5818 /* If the reference is volatile or non-const, we
5819 cannot create a temporary. */
5820 if (lvalue & clk_bitfield)
5821 error ("cannot bind bitfield %qE to %qT",
5823 else if (lvalue & clk_packed)
5824 error ("cannot bind packed field %qE to %qT",
5827 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
5829 return error_mark_node;
5831 /* If the source is a packed field, and we must use a copy
5832 constructor, then building the target expr will require
5833 binding the field to the reference parameter to the
5834 copy constructor, and we'll end up with an infinite
5835 loop. If we can use a bitwise copy, then we'll be
5837 if ((lvalue & clk_packed)
5838 && CLASS_TYPE_P (type)
5839 && type_has_nontrivial_copy_init (type))
5841 if (complain & tf_error)
5842 error ("cannot bind packed field %qE to %qT",
5844 return error_mark_node;
5846 if (lvalue & clk_bitfield)
5848 expr = convert_bitfield_to_declared_type (expr);
5849 expr = fold_convert (type, expr);
5851 expr = build_target_expr_with_type (expr, type, complain);
5854 /* Take the address of the thing to which we will bind the
5856 expr = cp_build_addr_expr (expr, complain);
5857 if (expr == error_mark_node)
5858 return error_mark_node;
5860 /* Convert it to a pointer to the type referred to by the
5861 reference. This will adjust the pointer if a derived to
5862 base conversion is being performed. */
5863 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
5865 /* Convert the pointer to the desired reference type. */
5866 return build_nop (ref_type, expr);
5870 return decay_conversion (expr);
5873 /* Warn about deprecated conversion if appropriate. */
5874 string_conv_p (totype, expr, 1);
5879 expr = convert_to_base (expr, totype, !c_cast_p,
5880 /*nonnull=*/false, complain);
5881 return build_nop (totype, expr);
5884 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
5885 c_cast_p, complain);
5891 if (convs->check_narrowing)
5892 check_narrowing (totype, expr);
5894 if (issue_conversion_warnings && (complain & tf_warning))
5895 expr = convert_and_check (totype, expr);
5897 expr = convert (totype, expr);
5902 /* ARG is being passed to a varargs function. Perform any conversions
5903 required. Return the converted value. */
5906 convert_arg_to_ellipsis (tree arg)
5912 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5913 standard conversions are performed. */
5914 arg = decay_conversion (arg);
5915 arg_type = TREE_TYPE (arg);
5918 If the argument has integral or enumeration type that is subject
5919 to the integral promotions (_conv.prom_), or a floating point
5920 type that is subject to the floating point promotion
5921 (_conv.fpprom_), the value of the argument is converted to the
5922 promoted type before the call. */
5923 if (TREE_CODE (arg_type) == REAL_TYPE
5924 && (TYPE_PRECISION (arg_type)
5925 < TYPE_PRECISION (double_type_node))
5926 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type)))
5928 if (warn_double_promotion && !c_inhibit_evaluation_warnings)
5929 warning (OPT_Wdouble_promotion,
5930 "implicit conversion from %qT to %qT when passing "
5931 "argument to function",
5932 arg_type, double_type_node);
5933 arg = convert_to_real (double_type_node, arg);
5935 else if (NULLPTR_TYPE_P (arg_type))
5936 arg = null_pointer_node;
5937 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type))
5939 if (SCOPED_ENUM_P (arg_type) && !abi_version_at_least (6))
5941 warning (OPT_Wabi, "scoped enum %qT will not promote to an "
5942 "integral type in a future version of GCC", arg_type);
5943 arg = cp_convert (ENUM_UNDERLYING_TYPE (arg_type), arg);
5945 arg = perform_integral_promotions (arg);
5948 arg = require_complete_type (arg);
5949 arg_type = TREE_TYPE (arg);
5951 if (arg != error_mark_node
5952 /* In a template (or ill-formed code), we can have an incomplete type
5953 even after require_complete_type, in which case we don't know
5954 whether it has trivial copy or not. */
5955 && COMPLETE_TYPE_P (arg_type))
5957 /* Build up a real lvalue-to-rvalue conversion in case the
5958 copy constructor is trivial but not callable. */
5959 if (CLASS_TYPE_P (arg_type))
5960 force_rvalue (arg, tf_warning_or_error);
5962 /* [expr.call] 5.2.2/7:
5963 Passing a potentially-evaluated argument of class type (Clause 9)
5964 with a non-trivial copy constructor or a non-trivial destructor
5965 with no corresponding parameter is conditionally-supported, with
5966 implementation-defined semantics.
5968 We used to just warn here and do a bitwise copy, but now
5969 cp_expr_size will abort if we try to do that.
5971 If the call appears in the context of a sizeof expression,
5972 it is not potentially-evaluated. */
5973 if (cp_unevaluated_operand == 0
5974 && (type_has_nontrivial_copy_init (arg_type)
5975 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type)))
5976 error ("cannot pass objects of non-trivially-copyable "
5977 "type %q#T through %<...%>", arg_type);
5983 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
5986 build_x_va_arg (tree expr, tree type)
5988 if (processing_template_decl)
5989 return build_min (VA_ARG_EXPR, type, expr);
5991 type = complete_type_or_else (type, NULL_TREE);
5993 if (expr == error_mark_node || !type)
5994 return error_mark_node;
5996 expr = mark_lvalue_use (expr);
5998 if (type_has_nontrivial_copy_init (type)
5999 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6000 || TREE_CODE (type) == REFERENCE_TYPE)
6002 /* Remove reference types so we don't ICE later on. */
6003 tree type1 = non_reference (type);
6004 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
6005 error ("cannot receive objects of non-trivially-copyable type %q#T "
6006 "through %<...%>; ", type);
6007 expr = convert (build_pointer_type (type1), null_node);
6008 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
6012 return build_va_arg (input_location, expr, type);
6015 /* TYPE has been given to va_arg. Apply the default conversions which
6016 would have happened when passed via ellipsis. Return the promoted
6017 type, or the passed type if there is no change. */
6020 cxx_type_promotes_to (tree type)
6024 /* Perform the array-to-pointer and function-to-pointer
6026 type = type_decays_to (type);
6028 promote = type_promotes_to (type);
6029 if (same_type_p (type, promote))
6035 /* ARG is a default argument expression being passed to a parameter of
6036 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6037 zero-based argument number. Do any required conversions. Return
6038 the converted value. */
6040 static GTY(()) VEC(tree,gc) *default_arg_context;
6042 push_defarg_context (tree fn)
6043 { VEC_safe_push (tree, gc, default_arg_context, fn); }
6045 pop_defarg_context (void)
6046 { VEC_pop (tree, default_arg_context); }
6049 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
6054 /* See through clones. */
6055 fn = DECL_ORIGIN (fn);
6057 /* Detect recursion. */
6058 FOR_EACH_VEC_ELT (tree, default_arg_context, i, t)
6061 error ("recursive evaluation of default argument for %q#D", fn);
6062 return error_mark_node;
6065 /* If the ARG is an unparsed default argument expression, the
6066 conversion cannot be performed. */
6067 if (TREE_CODE (arg) == DEFAULT_ARG)
6069 error ("call to %qD uses the default argument for parameter %P, which "
6070 "is not yet defined", fn, parmnum);
6071 return error_mark_node;
6074 push_defarg_context (fn);
6076 if (fn && DECL_TEMPLATE_INFO (fn))
6077 arg = tsubst_default_argument (fn, type, arg);
6083 The names in the expression are bound, and the semantic
6084 constraints are checked, at the point where the default
6085 expressions appears.
6087 we must not perform access checks here. */
6088 push_deferring_access_checks (dk_no_check);
6089 arg = break_out_target_exprs (arg);
6090 if (TREE_CODE (arg) == CONSTRUCTOR)
6092 arg = digest_init (type, arg, tf_warning_or_error);
6093 arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT,
6094 ICR_DEFAULT_ARGUMENT, fn, parmnum,
6095 tf_warning_or_error);
6099 /* We must make a copy of ARG, in case subsequent processing
6100 alters any part of it. For example, during gimplification a
6101 cast of the form (T) &X::f (where "f" is a member function)
6102 will lead to replacing the PTRMEM_CST for &X::f with a
6103 VAR_DECL. We can avoid the copy for constants, since they
6104 are never modified in place. */
6105 if (!CONSTANT_CLASS_P (arg))
6106 arg = unshare_expr (arg);
6107 arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT,
6108 ICR_DEFAULT_ARGUMENT, fn, parmnum,
6109 tf_warning_or_error);
6110 arg = convert_for_arg_passing (type, arg);
6112 pop_deferring_access_checks();
6114 pop_defarg_context ();
6119 /* Returns the type which will really be used for passing an argument of
6123 type_passed_as (tree type)
6125 /* Pass classes with copy ctors by invisible reference. */
6126 if (TREE_ADDRESSABLE (type))
6128 type = build_reference_type (type);
6129 /* There are no other pointers to this temporary. */
6130 type = cp_build_qualified_type (type, TYPE_QUAL_RESTRICT);
6132 else if (targetm.calls.promote_prototypes (type)
6133 && INTEGRAL_TYPE_P (type)
6134 && COMPLETE_TYPE_P (type)
6135 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
6136 TYPE_SIZE (integer_type_node)))
6137 type = integer_type_node;
6142 /* Actually perform the appropriate conversion. */
6145 convert_for_arg_passing (tree type, tree val)
6149 /* If VAL is a bitfield, then -- since it has already been converted
6150 to TYPE -- it cannot have a precision greater than TYPE.
6152 If it has a smaller precision, we must widen it here. For
6153 example, passing "int f:3;" to a function expecting an "int" will
6154 not result in any conversion before this point.
6156 If the precision is the same we must not risk widening. For
6157 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6158 often have type "int", even though the C++ type for the field is
6159 "long long". If the value is being passed to a function
6160 expecting an "int", then no conversions will be required. But,
6161 if we call convert_bitfield_to_declared_type, the bitfield will
6162 be converted to "long long". */
6163 bitfield_type = is_bitfield_expr_with_lowered_type (val);
6165 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
6166 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
6168 if (val == error_mark_node)
6170 /* Pass classes with copy ctors by invisible reference. */
6171 else if (TREE_ADDRESSABLE (type))
6172 val = build1 (ADDR_EXPR, build_reference_type (type), val);
6173 else if (targetm.calls.promote_prototypes (type)
6174 && INTEGRAL_TYPE_P (type)
6175 && COMPLETE_TYPE_P (type)
6176 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
6177 TYPE_SIZE (integer_type_node)))
6178 val = perform_integral_promotions (val);
6179 if (warn_missing_format_attribute)
6181 tree rhstype = TREE_TYPE (val);
6182 const enum tree_code coder = TREE_CODE (rhstype);
6183 const enum tree_code codel = TREE_CODE (type);
6184 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6186 && check_missing_format_attribute (type, rhstype))
6187 warning (OPT_Wmissing_format_attribute,
6188 "argument of function call might be a candidate for a format attribute");
6193 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6194 which no conversions at all should be done. This is true for some
6195 builtins which don't act like normal functions. */
6198 magic_varargs_p (tree fn)
6200 if (DECL_BUILT_IN (fn))
6201 switch (DECL_FUNCTION_CODE (fn))
6203 case BUILT_IN_CLASSIFY_TYPE:
6204 case BUILT_IN_CONSTANT_P:
6205 case BUILT_IN_NEXT_ARG:
6206 case BUILT_IN_VA_START:
6210 return lookup_attribute ("type generic",
6211 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
6217 /* Subroutine of the various build_*_call functions. Overload resolution
6218 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
6219 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
6220 bitmask of various LOOKUP_* flags which apply to the call itself. */
6223 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
6226 const VEC(tree,gc) *args = cand->args;
6227 tree first_arg = cand->first_arg;
6228 conversion **convs = cand->convs;
6230 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
6235 unsigned int arg_index = 0;
6239 bool already_used = false;
6241 /* In a template, there is no need to perform all of the work that
6242 is normally done. We are only interested in the type of the call
6243 expression, i.e., the return type of the function. Any semantic
6244 errors will be deferred until the template is instantiated. */
6245 if (processing_template_decl)
6249 const tree *argarray;
6252 return_type = TREE_TYPE (TREE_TYPE (fn));
6253 nargs = VEC_length (tree, args);
6254 if (first_arg == NULL_TREE)
6255 argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
6263 alcarray = XALLOCAVEC (tree, nargs);
6264 alcarray[0] = first_arg;
6265 FOR_EACH_VEC_ELT (tree, args, ix, arg)
6266 alcarray[ix + 1] = arg;
6267 argarray = alcarray;
6269 expr = build_call_array_loc (input_location,
6270 return_type, build_addr_func (fn), nargs,
6272 if (TREE_THIS_VOLATILE (fn) && cfun)
6273 current_function_returns_abnormally = 1;
6274 return convert_from_reference (expr);
6277 /* Give any warnings we noticed during overload resolution. */
6278 if (cand->warnings && (complain & tf_warning))
6280 struct candidate_warning *w;
6281 for (w = cand->warnings; w; w = w->next)
6282 joust (cand, w->loser, 1);
6285 /* Make =delete work with SFINAE. */
6286 if (DECL_DELETED_FN (fn) && !(complain & tf_error))
6287 return error_mark_node;
6289 if (DECL_FUNCTION_MEMBER_P (fn))
6292 /* If FN is a template function, two cases must be considered.
6297 template <class T> void f();
6299 template <class T> struct B {
6303 struct C : A, B<int> {
6305 using B<int>::g; // #2
6308 In case #1 where `A::f' is a member template, DECL_ACCESS is
6309 recorded in the primary template but not in its specialization.
6310 We check access of FN using its primary template.
6312 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
6313 because it is a member of class template B, DECL_ACCESS is
6314 recorded in the specialization `B<int>::g'. We cannot use its
6315 primary template because `B<T>::g' and `B<int>::g' may have
6316 different access. */
6317 if (DECL_TEMPLATE_INFO (fn)
6318 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
6319 access_fn = DECL_TI_TEMPLATE (fn);
6322 if (flags & LOOKUP_SPECULATIVE)
6324 if (!speculative_access_check (cand->access_path, access_fn, fn,
6325 !!(flags & LOOKUP_COMPLAIN)))
6326 return error_mark_node;
6329 perform_or_defer_access_check (cand->access_path, access_fn, fn);
6332 /* If we're checking for implicit delete, don't bother with argument
6334 if (flags & LOOKUP_SPECULATIVE)
6336 if (DECL_DELETED_FN (fn))
6338 if (flags & LOOKUP_COMPLAIN)
6340 return error_mark_node;
6342 if (cand->viable == 1)
6344 else if (!(flags & LOOKUP_COMPLAIN))
6345 /* Reject bad conversions now. */
6346 return error_mark_node;
6347 /* else continue to get conversion error. */
6350 /* Find maximum size of vector to hold converted arguments. */
6351 parmlen = list_length (parm);
6352 nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
6353 if (parmlen > nargs)
6355 argarray = XALLOCAVEC (tree, nargs);
6357 /* The implicit parameters to a constructor are not considered by overload
6358 resolution, and must be of the proper type. */
6359 if (DECL_CONSTRUCTOR_P (fn))
6361 if (first_arg != NULL_TREE)
6363 argarray[j++] = first_arg;
6364 first_arg = NULL_TREE;
6368 argarray[j++] = VEC_index (tree, args, arg_index);
6371 parm = TREE_CHAIN (parm);
6372 /* We should never try to call the abstract constructor. */
6373 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
6375 if (DECL_HAS_VTT_PARM_P (fn))
6377 argarray[j++] = VEC_index (tree, args, arg_index);
6379 parm = TREE_CHAIN (parm);
6382 /* Bypass access control for 'this' parameter. */
6383 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6385 tree parmtype = TREE_VALUE (parm);
6386 tree arg = (first_arg != NULL_TREE
6388 : VEC_index (tree, args, arg_index));
6389 tree argtype = TREE_TYPE (arg);
6393 if (convs[i]->bad_p)
6395 if (complain & tf_error)
6396 permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
6397 TREE_TYPE (argtype), fn);
6399 return error_mark_node;
6402 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
6403 X is called for an object that is not of type X, or of a type
6404 derived from X, the behavior is undefined.
6406 So we can assume that anything passed as 'this' is non-null, and
6407 optimize accordingly. */
6408 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
6409 /* Convert to the base in which the function was declared. */
6410 gcc_assert (cand->conversion_path != NULL_TREE);
6411 converted_arg = build_base_path (PLUS_EXPR,
6413 cand->conversion_path,
6415 /* Check that the base class is accessible. */
6416 if (!accessible_base_p (TREE_TYPE (argtype),
6417 BINFO_TYPE (cand->conversion_path), true))
6418 error ("%qT is not an accessible base of %qT",
6419 BINFO_TYPE (cand->conversion_path),
6420 TREE_TYPE (argtype));
6421 /* If fn was found by a using declaration, the conversion path
6422 will be to the derived class, not the base declaring fn. We
6423 must convert from derived to base. */
6424 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
6425 TREE_TYPE (parmtype), ba_unique, NULL);
6426 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
6429 argarray[j++] = converted_arg;
6430 parm = TREE_CHAIN (parm);
6431 if (first_arg != NULL_TREE)
6432 first_arg = NULL_TREE;
6439 gcc_assert (first_arg == NULL_TREE);
6440 for (; arg_index < VEC_length (tree, args) && parm;
6441 parm = TREE_CHAIN (parm), ++arg_index, ++i)
6443 tree type = TREE_VALUE (parm);
6444 tree arg = VEC_index (tree, args, arg_index);
6445 bool conversion_warning = true;
6449 /* If the argument is NULL and used to (implicitly) instantiate a
6450 template function (and bind one of the template arguments to
6451 the type of 'long int'), we don't want to warn about passing NULL
6452 to non-pointer argument.
6453 For example, if we have this template function:
6455 template<typename T> void func(T x) {}
6457 we want to warn (when -Wconversion is enabled) in this case:
6463 but not in this case:
6469 if (arg == null_node
6470 && DECL_TEMPLATE_INFO (fn)
6471 && cand->template_decl
6472 && !(flags & LOOKUP_EXPLICIT_TMPL_ARGS))
6473 conversion_warning = false;
6475 /* Warn about initializer_list deduction that isn't currently in the
6477 if (cxx_dialect > cxx98
6478 && flag_deduce_init_list
6479 && cand->template_decl
6480 && is_std_init_list (non_reference (type))
6481 && BRACE_ENCLOSED_INITIALIZER_P (arg))
6483 tree tmpl = TI_TEMPLATE (cand->template_decl);
6484 tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
6485 tree patparm = get_pattern_parm (realparm, tmpl);
6486 tree pattype = TREE_TYPE (patparm);
6487 if (PACK_EXPANSION_P (pattype))
6488 pattype = PACK_EXPANSION_PATTERN (pattype);
6489 pattype = non_reference (pattype);
6491 if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM
6492 && (cand->explicit_targs == NULL_TREE
6493 || (TREE_VEC_LENGTH (cand->explicit_targs)
6494 <= TEMPLATE_TYPE_IDX (pattype))))
6496 pedwarn (input_location, 0, "deducing %qT as %qT",
6497 non_reference (TREE_TYPE (patparm)),
6498 non_reference (type));
6499 pedwarn (input_location, 0, " in call to %q+D", cand->fn);
6500 pedwarn (input_location, 0,
6501 " (you can disable this with -fno-deduce-init-list)");
6505 val = convert_like_with_context (conv, arg, fn, i-is_method,
6508 : complain & (~tf_warning));
6510 val = convert_for_arg_passing (type, val);
6511 if (val == error_mark_node)
6512 return error_mark_node;
6514 argarray[j++] = val;
6517 /* Default arguments */
6518 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
6519 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
6520 TREE_PURPOSE (parm),
6523 for (; arg_index < VEC_length (tree, args); ++arg_index)
6525 tree a = VEC_index (tree, args, arg_index);
6526 if (magic_varargs_p (fn))
6527 /* Do no conversions for magic varargs. */
6528 a = mark_type_use (a);
6530 a = convert_arg_to_ellipsis (a);
6534 gcc_assert (j <= nargs);
6537 check_function_arguments (TREE_TYPE (fn), nargs, argarray);
6539 /* Avoid actually calling copy constructors and copy assignment operators,
6542 if (! flag_elide_constructors)
6543 /* Do things the hard way. */;
6544 else if (cand->num_convs == 1
6545 && (DECL_COPY_CONSTRUCTOR_P (fn)
6546 || DECL_MOVE_CONSTRUCTOR_P (fn)))
6549 tree arg = argarray[num_artificial_parms_for (fn)];
6551 bool trivial = trivial_fn_p (fn);
6553 /* Pull out the real argument, disregarding const-correctness. */
6555 while (CONVERT_EXPR_P (targ)
6556 || TREE_CODE (targ) == NON_LVALUE_EXPR)
6557 targ = TREE_OPERAND (targ, 0);
6558 if (TREE_CODE (targ) == ADDR_EXPR)
6560 targ = TREE_OPERAND (targ, 0);
6561 if (!same_type_ignoring_top_level_qualifiers_p
6562 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
6571 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
6573 /* [class.copy]: the copy constructor is implicitly defined even if
6574 the implementation elided its use. */
6575 if (!trivial || DECL_DELETED_FN (fn))
6578 already_used = true;
6581 /* If we're creating a temp and we already have one, don't create a
6582 new one. If we're not creating a temp but we get one, use
6583 INIT_EXPR to collapse the temp into our target. Otherwise, if the
6584 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
6585 temp or an INIT_EXPR otherwise. */
6587 if (integer_zerop (fa))
6589 if (TREE_CODE (arg) == TARGET_EXPR)
6592 return force_target_expr (DECL_CONTEXT (fn), arg, complain);
6594 else if (TREE_CODE (arg) == TARGET_EXPR || trivial)
6596 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
6599 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
6603 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
6604 && trivial_fn_p (fn)
6605 && !DECL_DELETED_FN (fn))
6607 tree to = stabilize_reference
6608 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
6609 tree type = TREE_TYPE (to);
6610 tree as_base = CLASSTYPE_AS_BASE (type);
6611 tree arg = argarray[1];
6613 if (is_really_empty_class (type))
6615 /* Avoid copying empty classes. */
6616 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
6617 TREE_NO_WARNING (val) = 1;
6618 val = build2 (COMPOUND_EXPR, type, val, to);
6619 TREE_NO_WARNING (val) = 1;
6621 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
6623 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
6624 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
6628 /* We must only copy the non-tail padding parts.
6629 Use __builtin_memcpy for the bitwise copy.
6630 FIXME fix 22488 so we can go back to using MODIFY_EXPR
6631 instead of an explicit call to memcpy. */
6633 tree arg0, arg1, arg2, t;
6634 tree test = NULL_TREE;
6636 arg2 = TYPE_SIZE_UNIT (as_base);
6638 arg0 = cp_build_addr_expr (to, complain);
6640 if (!can_trust_pointer_alignment ())
6642 /* If we can't be sure about pointer alignment, a call
6643 to __builtin_memcpy is expanded as a call to memcpy, which
6644 is invalid with identical args. Otherwise it is
6645 expanded as a block move, which should be safe. */
6646 arg0 = save_expr (arg0);
6647 arg1 = save_expr (arg1);
6648 test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
6650 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
6651 t = build_call_n (t, 3, arg0, arg1, arg2);
6653 t = convert (TREE_TYPE (arg0), t);
6655 t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
6656 val = cp_build_indirect_ref (t, RO_NULL, complain);
6657 TREE_NO_WARNING (val) = 1;
6662 else if (DECL_DESTRUCTOR_P (fn)
6663 && trivial_fn_p (fn)
6664 && !DECL_DELETED_FN (fn))
6665 return fold_convert (void_type_node, argarray[0]);
6666 /* FIXME handle trivial default constructor, too. */
6671 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
6674 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
6677 gcc_assert (binfo && binfo != error_mark_node);
6679 /* Warn about deprecated virtual functions now, since we're about
6680 to throw away the decl. */
6681 if (TREE_DEPRECATED (fn))
6682 warn_deprecated_use (fn, NULL_TREE);
6684 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
6685 if (TREE_SIDE_EFFECTS (argarray[0]))
6686 argarray[0] = save_expr (argarray[0]);
6687 t = build_pointer_type (TREE_TYPE (fn));
6688 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
6689 fn = build_java_interface_fn_ref (fn, argarray[0]);
6691 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
6695 fn = build_addr_func (fn);
6697 return build_cxx_call (fn, nargs, argarray);
6700 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
6701 This function performs no overload resolution, conversion, or other
6702 high-level operations. */
6705 build_cxx_call (tree fn, int nargs, tree *argarray)
6709 fn = build_call_a (fn, nargs, argarray);
6711 /* If this call might throw an exception, note that fact. */
6712 fndecl = get_callee_fndecl (fn);
6713 if ((!fndecl || !TREE_NOTHROW (fndecl))
6714 && at_function_scope_p ()
6716 && cp_function_chain)
6717 cp_function_chain->can_throw = 1;
6719 /* Check that arguments to builtin functions match the expectations. */
6721 && DECL_BUILT_IN (fndecl)
6722 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6723 && !check_builtin_function_arguments (fndecl, nargs, argarray))
6724 return error_mark_node;
6726 /* Some built-in function calls will be evaluated at compile-time in
6728 fn = fold_if_not_in_template (fn);
6730 if (VOID_TYPE_P (TREE_TYPE (fn)))
6733 fn = require_complete_type (fn);
6734 if (fn == error_mark_node)
6735 return error_mark_node;
6737 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
6738 fn = build_cplus_new (TREE_TYPE (fn), fn, tf_warning_or_error);
6739 return convert_from_reference (fn);
6742 static GTY(()) tree java_iface_lookup_fn;
6744 /* Make an expression which yields the address of the Java interface
6745 method FN. This is achieved by generating a call to libjava's
6746 _Jv_LookupInterfaceMethodIdx(). */
6749 build_java_interface_fn_ref (tree fn, tree instance)
6751 tree lookup_fn, method, idx;
6752 tree klass_ref, iface, iface_ref;
6755 if (!java_iface_lookup_fn)
6757 tree ftype = build_function_type_list (ptr_type_node,
6758 ptr_type_node, ptr_type_node,
6759 java_int_type_node, NULL_TREE);
6760 java_iface_lookup_fn
6761 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype,
6762 0, NOT_BUILT_IN, NULL, NULL_TREE);
6765 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
6766 This is the first entry in the vtable. */
6767 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
6768 tf_warning_or_error),
6771 /* Get the java.lang.Class pointer for the interface being called. */
6772 iface = DECL_CONTEXT (fn);
6773 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
6774 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
6775 || DECL_CONTEXT (iface_ref) != iface)
6777 error ("could not find class$ field in java interface type %qT",
6779 return error_mark_node;
6781 iface_ref = build_address (iface_ref);
6782 iface_ref = convert (build_pointer_type (iface), iface_ref);
6784 /* Determine the itable index of FN. */
6786 for (method = TYPE_METHODS (iface); method; method = DECL_CHAIN (method))
6788 if (!DECL_VIRTUAL_P (method))
6794 idx = build_int_cst (NULL_TREE, i);
6796 lookup_fn = build1 (ADDR_EXPR,
6797 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6798 java_iface_lookup_fn);
6799 return build_call_nary (ptr_type_node, lookup_fn,
6800 3, klass_ref, iface_ref, idx);
6803 /* Returns the value to use for the in-charge parameter when making a
6804 call to a function with the indicated NAME.
6806 FIXME:Can't we find a neater way to do this mapping? */
6809 in_charge_arg_for_name (tree name)
6811 if (name == base_ctor_identifier
6812 || name == base_dtor_identifier)
6813 return integer_zero_node;
6814 else if (name == complete_ctor_identifier)
6815 return integer_one_node;
6816 else if (name == complete_dtor_identifier)
6817 return integer_two_node;
6818 else if (name == deleting_dtor_identifier)
6819 return integer_three_node;
6821 /* This function should only be called with one of the names listed
6827 /* Build a call to a constructor, destructor, or an assignment
6828 operator for INSTANCE, an expression with class type. NAME
6829 indicates the special member function to call; *ARGS are the
6830 arguments. ARGS may be NULL. This may change ARGS. BINFO
6831 indicates the base of INSTANCE that is to be passed as the `this'
6832 parameter to the member function called.
6834 FLAGS are the LOOKUP_* flags to use when processing the call.
6836 If NAME indicates a complete object constructor, INSTANCE may be
6837 NULL_TREE. In this case, the caller will call build_cplus_new to
6838 store the newly constructed object into a VAR_DECL. */
6841 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6842 tree binfo, int flags, tsubst_flags_t complain)
6845 /* The type of the subobject to be constructed or destroyed. */
6847 VEC(tree,gc) *allocated = NULL;
6850 gcc_assert (name == complete_ctor_identifier
6851 || name == base_ctor_identifier
6852 || name == complete_dtor_identifier
6853 || name == base_dtor_identifier
6854 || name == deleting_dtor_identifier
6855 || name == ansi_assopname (NOP_EXPR));
6858 /* Resolve the name. */
6859 if (!complete_type_or_maybe_complain (binfo, NULL_TREE, complain))
6860 return error_mark_node;
6862 binfo = TYPE_BINFO (binfo);
6865 gcc_assert (binfo != NULL_TREE);
6867 class_type = BINFO_TYPE (binfo);
6869 /* Handle the special case where INSTANCE is NULL_TREE. */
6870 if (name == complete_ctor_identifier && !instance)
6872 instance = build_int_cst (build_pointer_type (class_type), 0);
6873 instance = build1 (INDIRECT_REF, class_type, instance);
6877 if (name == complete_dtor_identifier
6878 || name == base_dtor_identifier
6879 || name == deleting_dtor_identifier)
6880 gcc_assert (args == NULL || VEC_empty (tree, *args));
6882 /* Convert to the base class, if necessary. */
6883 if (!same_type_ignoring_top_level_qualifiers_p
6884 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6886 if (name != ansi_assopname (NOP_EXPR))
6887 /* For constructors and destructors, either the base is
6888 non-virtual, or it is virtual but we are doing the
6889 conversion from a constructor or destructor for the
6890 complete object. In either case, we can convert
6892 instance = convert_to_base_statically (instance, binfo);
6894 /* However, for assignment operators, we must convert
6895 dynamically if the base is virtual. */
6896 instance = build_base_path (PLUS_EXPR, instance,
6897 binfo, /*nonnull=*/1);
6901 gcc_assert (instance != NULL_TREE);
6903 fns = lookup_fnfields (binfo, name, 1);
6905 /* When making a call to a constructor or destructor for a subobject
6906 that uses virtual base classes, pass down a pointer to a VTT for
6908 if ((name == base_ctor_identifier
6909 || name == base_dtor_identifier)
6910 && CLASSTYPE_VBASECLASSES (class_type))
6915 /* If the current function is a complete object constructor
6916 or destructor, then we fetch the VTT directly.
6917 Otherwise, we look it up using the VTT we were given. */
6918 vtt = DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6919 vtt = decay_conversion (vtt);
6920 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6921 build2 (EQ_EXPR, boolean_type_node,
6922 current_in_charge_parm, integer_zero_node),
6925 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6926 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6927 BINFO_SUBVTT_INDEX (binfo));
6931 allocated = make_tree_vector ();
6935 VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6938 ret = build_new_method_call (instance, fns, args,
6939 TYPE_BINFO (BINFO_TYPE (binfo)),
6943 if (allocated != NULL)
6944 release_tree_vector (allocated);
6949 /* Return the NAME, as a C string. The NAME indicates a function that
6950 is a member of TYPE. *FREE_P is set to true if the caller must
6951 free the memory returned.
6953 Rather than go through all of this, we should simply set the names
6954 of constructors and destructors appropriately, and dispense with
6955 ctor_identifier, dtor_identifier, etc. */
6958 name_as_c_string (tree name, tree type, bool *free_p)
6962 /* Assume that we will not allocate memory. */
6964 /* Constructors and destructors are special. */
6965 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6968 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6969 /* For a destructor, add the '~'. */
6970 if (name == complete_dtor_identifier
6971 || name == base_dtor_identifier
6972 || name == deleting_dtor_identifier)
6974 pretty_name = concat ("~", pretty_name, NULL);
6975 /* Remember that we need to free the memory allocated. */
6979 else if (IDENTIFIER_TYPENAME_P (name))
6981 pretty_name = concat ("operator ",
6982 type_as_string_translate (TREE_TYPE (name),
6983 TFF_PLAIN_IDENTIFIER),
6985 /* Remember that we need to free the memory allocated. */
6989 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6994 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
6995 be set, upon return, to the function called. ARGS may be NULL.
6996 This may change ARGS. */
6999 build_new_method_call_1 (tree instance, tree fns, VEC(tree,gc) **args,
7000 tree conversion_path, int flags,
7001 tree *fn_p, tsubst_flags_t complain)
7003 struct z_candidate *candidates = 0, *cand;
7004 tree explicit_targs = NULL_TREE;
7005 tree basetype = NULL_TREE;
7008 tree first_mem_arg = NULL_TREE;
7011 bool skip_first_for_error;
7012 VEC(tree,gc) *user_args;
7015 int template_only = 0;
7019 VEC(tree,gc) *orig_args = NULL;
7022 gcc_assert (instance != NULL_TREE);
7024 /* We don't know what function we're going to call, yet. */
7028 if (error_operand_p (instance)
7029 || !fns || error_operand_p (fns))
7030 return error_mark_node;
7032 if (!BASELINK_P (fns))
7034 if (complain & tf_error)
7035 error ("call to non-function %qD", fns);
7036 return error_mark_node;
7039 orig_instance = instance;
7042 /* Dismantle the baselink to collect all the information we need. */
7043 if (!conversion_path)
7044 conversion_path = BASELINK_BINFO (fns);
7045 access_binfo = BASELINK_ACCESS_BINFO (fns);
7046 optype = BASELINK_OPTYPE (fns);
7047 fns = BASELINK_FUNCTIONS (fns);
7048 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7050 explicit_targs = TREE_OPERAND (fns, 1);
7051 fns = TREE_OPERAND (fns, 0);
7054 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
7055 || TREE_CODE (fns) == TEMPLATE_DECL
7056 || TREE_CODE (fns) == OVERLOAD);
7057 fn = get_first_fn (fns);
7058 name = DECL_NAME (fn);
7060 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
7061 gcc_assert (CLASS_TYPE_P (basetype));
7063 if (processing_template_decl)
7065 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
7066 instance = build_non_dependent_expr (instance);
7068 make_args_non_dependent (*args);
7071 user_args = args == NULL ? NULL : *args;
7072 /* Under DR 147 A::A() is an invalid constructor call,
7073 not a functional cast. */
7074 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
7076 if (! (complain & tf_error))
7077 return error_mark_node;
7079 permerror (input_location,
7080 "cannot call constructor %<%T::%D%> directly",
7082 permerror (input_location, " for a function-style cast, remove the "
7083 "redundant %<::%D%>", name);
7084 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
7089 /* Figure out whether to skip the first argument for the error
7090 message we will display to users if an error occurs. We don't
7091 want to display any compiler-generated arguments. The "this"
7092 pointer hasn't been added yet. However, we must remove the VTT
7093 pointer if this is a call to a base-class constructor or
7095 skip_first_for_error = false;
7096 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
7098 /* Callers should explicitly indicate whether they want to construct
7099 the complete object or just the part without virtual bases. */
7100 gcc_assert (name != ctor_identifier);
7101 /* Similarly for destructors. */
7102 gcc_assert (name != dtor_identifier);
7103 /* Remove the VTT pointer, if present. */
7104 if ((name == base_ctor_identifier || name == base_dtor_identifier)
7105 && CLASSTYPE_VBASECLASSES (basetype))
7106 skip_first_for_error = true;
7109 /* Process the argument list. */
7110 if (args != NULL && *args != NULL)
7112 *args = resolve_args (*args, complain);
7114 return error_mark_node;
7117 instance_ptr = build_this (instance);
7119 /* It's OK to call destructors and constructors on cv-qualified objects.
7120 Therefore, convert the INSTANCE_PTR to the unqualified type, if
7122 if (DECL_DESTRUCTOR_P (fn)
7123 || DECL_CONSTRUCTOR_P (fn))
7125 tree type = build_pointer_type (basetype);
7126 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
7127 instance_ptr = build_nop (type, instance_ptr);
7129 if (DECL_DESTRUCTOR_P (fn))
7130 name = complete_dtor_identifier;
7132 first_mem_arg = instance_ptr;
7134 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7135 p = conversion_obstack_alloc (0);
7137 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
7138 initializer, not T({ }). */
7139 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
7140 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
7141 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
7143 gcc_assert (VEC_length (tree, *args) == 1
7144 && !(flags & LOOKUP_ONLYCONVERTING));
7146 add_list_candidates (fns, first_mem_arg, VEC_index (tree, *args, 0),
7147 basetype, explicit_targs, template_only,
7148 conversion_path, access_binfo, flags, &candidates);
7152 add_candidates (fns, first_mem_arg, user_args, optype,
7153 explicit_targs, template_only, conversion_path,
7154 access_binfo, flags, &candidates);
7156 any_viable_p = false;
7157 candidates = splice_viable (candidates, pedantic, &any_viable_p);
7161 if (complain & tf_error)
7163 if (!COMPLETE_OR_OPEN_TYPE_P (basetype))
7164 cxx_incomplete_type_error (instance_ptr, basetype);
7166 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
7167 basetype, optype, build_tree_list_vec (user_args),
7168 TREE_TYPE (TREE_TYPE (instance_ptr)));
7175 pretty_name = name_as_c_string (name, basetype, &free_p);
7176 arglist = build_tree_list_vec (user_args);
7177 if (skip_first_for_error)
7178 arglist = TREE_CHAIN (arglist);
7179 error ("no matching function for call to %<%T::%s(%A)%#V%>",
7180 basetype, pretty_name, arglist,
7181 TREE_TYPE (TREE_TYPE (instance_ptr)));
7185 print_z_candidates (location_of (name), candidates);
7187 call = error_mark_node;
7191 cand = tourney (candidates);
7198 if (complain & tf_error)
7200 pretty_name = name_as_c_string (name, basetype, &free_p);
7201 arglist = build_tree_list_vec (user_args);
7202 if (skip_first_for_error)
7203 arglist = TREE_CHAIN (arglist);
7204 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
7206 print_z_candidates (location_of (name), candidates);
7210 call = error_mark_node;
7216 if (!(flags & LOOKUP_NONVIRTUAL)
7217 && DECL_PURE_VIRTUAL_P (fn)
7218 && instance == current_class_ref
7219 && (DECL_CONSTRUCTOR_P (current_function_decl)
7220 || DECL_DESTRUCTOR_P (current_function_decl))
7221 && (complain & tf_warning))
7222 /* This is not an error, it is runtime undefined
7224 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
7225 "pure virtual %q#D called from constructor"
7226 : "pure virtual %q#D called from destructor"),
7229 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
7230 && is_dummy_object (instance_ptr))
7232 if (complain & tf_error)
7233 error ("cannot call member function %qD without object",
7235 call = error_mark_node;
7239 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
7240 && resolves_to_fixed_type_p (instance, 0))
7241 flags |= LOOKUP_NONVIRTUAL;
7243 flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
7244 /* Now we know what function is being called. */
7247 /* Build the actual CALL_EXPR. */
7248 call = build_over_call (cand, flags, complain);
7249 /* In an expression of the form `a->f()' where `f' turns
7250 out to be a static member function, `a' is
7251 none-the-less evaluated. */
7252 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
7253 && !is_dummy_object (instance_ptr)
7254 && TREE_SIDE_EFFECTS (instance_ptr))
7255 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
7256 instance_ptr, call);
7257 else if (call != error_mark_node
7258 && DECL_DESTRUCTOR_P (cand->fn)
7259 && !VOID_TYPE_P (TREE_TYPE (call)))
7260 /* An explicit call of the form "x->~X()" has type
7261 "void". However, on platforms where destructors
7262 return "this" (i.e., those where
7263 targetm.cxx.cdtor_returns_this is true), such calls
7264 will appear to have a return value of pointer type
7265 to the low-level call machinery. We do not want to
7266 change the low-level machinery, since we want to be
7267 able to optimize "delete f()" on such platforms as
7268 "operator delete(~X(f()))" (rather than generating
7269 "t = f(), ~X(t), operator delete (t)"). */
7270 call = build_nop (void_type_node, call);
7275 if (processing_template_decl && call != error_mark_node)
7277 bool cast_to_void = false;
7279 if (TREE_CODE (call) == COMPOUND_EXPR)
7280 call = TREE_OPERAND (call, 1);
7281 else if (TREE_CODE (call) == NOP_EXPR)
7283 cast_to_void = true;
7284 call = TREE_OPERAND (call, 0);
7286 if (TREE_CODE (call) == INDIRECT_REF)
7287 call = TREE_OPERAND (call, 0);
7288 call = (build_min_non_dep_call_vec
7290 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
7291 orig_instance, orig_fns, NULL_TREE),
7293 call = convert_from_reference (call);
7295 call = build_nop (void_type_node, call);
7298 /* Free all the conversions we allocated. */
7299 obstack_free (&conversion_obstack, p);
7301 if (orig_args != NULL)
7302 release_tree_vector (orig_args);
7307 /* Wrapper for above. */
7310 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
7311 tree conversion_path, int flags,
7312 tree *fn_p, tsubst_flags_t complain)
7315 bool subtime = timevar_cond_start (TV_OVERLOAD);
7316 ret = build_new_method_call_1 (instance, fns, args, conversion_path, flags,
7318 timevar_cond_stop (TV_OVERLOAD, subtime);
7322 /* Returns true iff standard conversion sequence ICS1 is a proper
7323 subsequence of ICS2. */
7326 is_subseq (conversion *ics1, conversion *ics2)
7328 /* We can assume that a conversion of the same code
7329 between the same types indicates a subsequence since we only get
7330 here if the types we are converting from are the same. */
7332 while (ics1->kind == ck_rvalue
7333 || ics1->kind == ck_lvalue)
7334 ics1 = ics1->u.next;
7338 while (ics2->kind == ck_rvalue
7339 || ics2->kind == ck_lvalue)
7340 ics2 = ics2->u.next;
7342 if (ics2->kind == ck_user
7343 || ics2->kind == ck_ambig
7344 || ics2->kind == ck_aggr
7345 || ics2->kind == ck_list
7346 || ics2->kind == ck_identity)
7347 /* At this point, ICS1 cannot be a proper subsequence of
7348 ICS2. We can get a USER_CONV when we are comparing the
7349 second standard conversion sequence of two user conversion
7353 ics2 = ics2->u.next;
7355 if (ics2->kind == ics1->kind
7356 && same_type_p (ics2->type, ics1->type)
7357 && same_type_p (ics2->u.next->type,
7358 ics1->u.next->type))
7363 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
7364 be any _TYPE nodes. */
7367 is_properly_derived_from (tree derived, tree base)
7369 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
7372 /* We only allow proper derivation here. The DERIVED_FROM_P macro
7373 considers every class derived from itself. */
7374 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
7375 && DERIVED_FROM_P (base, derived));
7378 /* We build the ICS for an implicit object parameter as a pointer
7379 conversion sequence. However, such a sequence should be compared
7380 as if it were a reference conversion sequence. If ICS is the
7381 implicit conversion sequence for an implicit object parameter,
7382 modify it accordingly. */
7385 maybe_handle_implicit_object (conversion **ics)
7389 /* [over.match.funcs]
7391 For non-static member functions, the type of the
7392 implicit object parameter is "reference to cv X"
7393 where X is the class of which the function is a
7394 member and cv is the cv-qualification on the member
7395 function declaration. */
7396 conversion *t = *ics;
7397 tree reference_type;
7399 /* The `this' parameter is a pointer to a class type. Make the
7400 implicit conversion talk about a reference to that same class
7402 reference_type = TREE_TYPE (t->type);
7403 reference_type = build_reference_type (reference_type);
7405 if (t->kind == ck_qual)
7407 if (t->kind == ck_ptr)
7409 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
7410 t = direct_reference_binding (reference_type, t);
7412 t->rvaluedness_matches_p = 0;
7417 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
7418 and return the initial reference binding conversion. Otherwise,
7419 leave *ICS unchanged and return NULL. */
7422 maybe_handle_ref_bind (conversion **ics)
7424 if ((*ics)->kind == ck_ref_bind)
7426 conversion *old_ics = *ics;
7427 *ics = old_ics->u.next;
7428 (*ics)->user_conv_p = old_ics->user_conv_p;
7435 /* Compare two implicit conversion sequences according to the rules set out in
7436 [over.ics.rank]. Return values:
7438 1: ics1 is better than ics2
7439 -1: ics2 is better than ics1
7440 0: ics1 and ics2 are indistinguishable */
7443 compare_ics (conversion *ics1, conversion *ics2)
7449 tree deref_from_type1 = NULL_TREE;
7450 tree deref_from_type2 = NULL_TREE;
7451 tree deref_to_type1 = NULL_TREE;
7452 tree deref_to_type2 = NULL_TREE;
7453 conversion_rank rank1, rank2;
7455 /* REF_BINDING is nonzero if the result of the conversion sequence
7456 is a reference type. In that case REF_CONV is the reference
7457 binding conversion. */
7458 conversion *ref_conv1;
7459 conversion *ref_conv2;
7461 /* Handle implicit object parameters. */
7462 maybe_handle_implicit_object (&ics1);
7463 maybe_handle_implicit_object (&ics2);
7465 /* Handle reference parameters. */
7466 ref_conv1 = maybe_handle_ref_bind (&ics1);
7467 ref_conv2 = maybe_handle_ref_bind (&ics2);
7469 /* List-initialization sequence L1 is a better conversion sequence than
7470 list-initialization sequence L2 if L1 converts to
7471 std::initializer_list<X> for some X and L2 does not. */
7472 if (ics1->kind == ck_list && ics2->kind != ck_list)
7474 if (ics2->kind == ck_list && ics1->kind != ck_list)
7479 When comparing the basic forms of implicit conversion sequences (as
7480 defined in _over.best.ics_)
7482 --a standard conversion sequence (_over.ics.scs_) is a better
7483 conversion sequence than a user-defined conversion sequence
7484 or an ellipsis conversion sequence, and
7486 --a user-defined conversion sequence (_over.ics.user_) is a
7487 better conversion sequence than an ellipsis conversion sequence
7488 (_over.ics.ellipsis_). */
7489 rank1 = CONVERSION_RANK (ics1);
7490 rank2 = CONVERSION_RANK (ics2);
7494 else if (rank1 < rank2)
7497 if (rank1 == cr_bad)
7499 /* Both ICS are bad. We try to make a decision based on what would
7500 have happened if they'd been good. This is not an extension,
7501 we'll still give an error when we build up the call; this just
7502 helps us give a more helpful error message. */
7503 rank1 = BAD_CONVERSION_RANK (ics1);
7504 rank2 = BAD_CONVERSION_RANK (ics2);
7508 else if (rank1 < rank2)
7511 /* We couldn't make up our minds; try to figure it out below. */
7514 if (ics1->ellipsis_p)
7515 /* Both conversions are ellipsis conversions. */
7518 /* User-defined conversion sequence U1 is a better conversion sequence
7519 than another user-defined conversion sequence U2 if they contain the
7520 same user-defined conversion operator or constructor and if the sec-
7521 ond standard conversion sequence of U1 is better than the second
7522 standard conversion sequence of U2. */
7524 /* Handle list-conversion with the same code even though it isn't always
7525 ranked as a user-defined conversion and it doesn't have a second
7526 standard conversion sequence; it will still have the desired effect.
7527 Specifically, we need to do the reference binding comparison at the
7528 end of this function. */
7530 if (ics1->user_conv_p || ics1->kind == ck_list)
7535 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
7536 if (t1->kind == ck_ambig || t1->kind == ck_aggr
7537 || t1->kind == ck_list)
7539 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
7540 if (t2->kind == ck_ambig || t2->kind == ck_aggr
7541 || t2->kind == ck_list)
7544 if (t1->kind != t2->kind)
7546 else if (t1->kind == ck_user)
7548 if (t1->cand->fn != t2->cand->fn)
7553 /* For ambiguous or aggregate conversions, use the target type as
7554 a proxy for the conversion function. */
7555 if (!same_type_ignoring_top_level_qualifiers_p (t1->type, t2->type))
7559 /* We can just fall through here, after setting up
7560 FROM_TYPE1 and FROM_TYPE2. */
7561 from_type1 = t1->type;
7562 from_type2 = t2->type;
7569 /* We're dealing with two standard conversion sequences.
7573 Standard conversion sequence S1 is a better conversion
7574 sequence than standard conversion sequence S2 if
7576 --S1 is a proper subsequence of S2 (comparing the conversion
7577 sequences in the canonical form defined by _over.ics.scs_,
7578 excluding any Lvalue Transformation; the identity
7579 conversion sequence is considered to be a subsequence of
7580 any non-identity conversion sequence */
7583 while (t1->kind != ck_identity)
7585 from_type1 = t1->type;
7588 while (t2->kind != ck_identity)
7590 from_type2 = t2->type;
7593 /* One sequence can only be a subsequence of the other if they start with
7594 the same type. They can start with different types when comparing the
7595 second standard conversion sequence in two user-defined conversion
7597 if (same_type_p (from_type1, from_type2))
7599 if (is_subseq (ics1, ics2))
7601 if (is_subseq (ics2, ics1))
7609 --the rank of S1 is better than the rank of S2 (by the rules
7612 Standard conversion sequences are ordered by their ranks: an Exact
7613 Match is a better conversion than a Promotion, which is a better
7614 conversion than a Conversion.
7616 Two conversion sequences with the same rank are indistinguishable
7617 unless one of the following rules applies:
7619 --A conversion that does not a convert a pointer, pointer to member,
7620 or std::nullptr_t to bool is better than one that does.
7622 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
7623 so that we do not have to check it explicitly. */
7624 if (ics1->rank < ics2->rank)
7626 else if (ics2->rank < ics1->rank)
7629 to_type1 = ics1->type;
7630 to_type2 = ics2->type;
7632 /* A conversion from scalar arithmetic type to complex is worse than a
7633 conversion between scalar arithmetic types. */
7634 if (same_type_p (from_type1, from_type2)
7635 && ARITHMETIC_TYPE_P (from_type1)
7636 && ARITHMETIC_TYPE_P (to_type1)
7637 && ARITHMETIC_TYPE_P (to_type2)
7638 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
7639 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
7641 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
7647 if (TYPE_PTR_P (from_type1)
7648 && TYPE_PTR_P (from_type2)
7649 && TYPE_PTR_P (to_type1)
7650 && TYPE_PTR_P (to_type2))
7652 deref_from_type1 = TREE_TYPE (from_type1);
7653 deref_from_type2 = TREE_TYPE (from_type2);
7654 deref_to_type1 = TREE_TYPE (to_type1);
7655 deref_to_type2 = TREE_TYPE (to_type2);
7657 /* The rules for pointers to members A::* are just like the rules
7658 for pointers A*, except opposite: if B is derived from A then
7659 A::* converts to B::*, not vice versa. For that reason, we
7660 switch the from_ and to_ variables here. */
7661 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
7662 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
7663 || (TYPE_PTRMEMFUNC_P (from_type1)
7664 && TYPE_PTRMEMFUNC_P (from_type2)
7665 && TYPE_PTRMEMFUNC_P (to_type1)
7666 && TYPE_PTRMEMFUNC_P (to_type2)))
7668 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
7669 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
7670 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
7671 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
7674 if (deref_from_type1 != NULL_TREE
7675 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
7676 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
7678 /* This was one of the pointer or pointer-like conversions.
7682 --If class B is derived directly or indirectly from class A,
7683 conversion of B* to A* is better than conversion of B* to
7684 void*, and conversion of A* to void* is better than
7685 conversion of B* to void*. */
7686 if (TREE_CODE (deref_to_type1) == VOID_TYPE
7687 && TREE_CODE (deref_to_type2) == VOID_TYPE)
7689 if (is_properly_derived_from (deref_from_type1,
7692 else if (is_properly_derived_from (deref_from_type2,
7696 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
7697 || TREE_CODE (deref_to_type2) == VOID_TYPE)
7699 if (same_type_p (deref_from_type1, deref_from_type2))
7701 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
7703 if (is_properly_derived_from (deref_from_type1,
7707 /* We know that DEREF_TO_TYPE1 is `void' here. */
7708 else if (is_properly_derived_from (deref_from_type1,
7713 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
7714 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
7718 --If class B is derived directly or indirectly from class A
7719 and class C is derived directly or indirectly from B,
7721 --conversion of C* to B* is better than conversion of C* to
7724 --conversion of B* to A* is better than conversion of C* to
7726 if (same_type_p (deref_from_type1, deref_from_type2))
7728 if (is_properly_derived_from (deref_to_type1,
7731 else if (is_properly_derived_from (deref_to_type2,
7735 else if (same_type_p (deref_to_type1, deref_to_type2))
7737 if (is_properly_derived_from (deref_from_type2,
7740 else if (is_properly_derived_from (deref_from_type1,
7746 else if (CLASS_TYPE_P (non_reference (from_type1))
7747 && same_type_p (from_type1, from_type2))
7749 tree from = non_reference (from_type1);
7753 --binding of an expression of type C to a reference of type
7754 B& is better than binding an expression of type C to a
7755 reference of type A&
7757 --conversion of C to B is better than conversion of C to A, */
7758 if (is_properly_derived_from (from, to_type1)
7759 && is_properly_derived_from (from, to_type2))
7761 if (is_properly_derived_from (to_type1, to_type2))
7763 else if (is_properly_derived_from (to_type2, to_type1))
7767 else if (CLASS_TYPE_P (non_reference (to_type1))
7768 && same_type_p (to_type1, to_type2))
7770 tree to = non_reference (to_type1);
7774 --binding of an expression of type B to a reference of type
7775 A& is better than binding an expression of type C to a
7776 reference of type A&,
7778 --conversion of B to A is better than conversion of C to A */
7779 if (is_properly_derived_from (from_type1, to)
7780 && is_properly_derived_from (from_type2, to))
7782 if (is_properly_derived_from (from_type2, from_type1))
7784 else if (is_properly_derived_from (from_type1, from_type2))
7791 --S1 and S2 differ only in their qualification conversion and yield
7792 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
7793 qualification signature of type T1 is a proper subset of the cv-
7794 qualification signature of type T2 */
7795 if (ics1->kind == ck_qual
7796 && ics2->kind == ck_qual
7797 && same_type_p (from_type1, from_type2))
7799 int result = comp_cv_qual_signature (to_type1, to_type2);
7806 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
7807 to an implicit object parameter, and either S1 binds an lvalue reference
7808 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
7809 reference to an rvalue and S2 binds an lvalue reference
7810 (C++0x draft standard, 13.3.3.2)
7812 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
7813 types to which the references refer are the same type except for
7814 top-level cv-qualifiers, and the type to which the reference
7815 initialized by S2 refers is more cv-qualified than the type to
7816 which the reference initialized by S1 refers */
7818 if (ref_conv1 && ref_conv2)
7820 if (!ref_conv1->this_p && !ref_conv2->this_p
7821 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7822 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7824 if (ref_conv1->rvaluedness_matches_p)
7826 if (ref_conv2->rvaluedness_matches_p)
7830 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7831 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7832 TREE_TYPE (ref_conv1->type));
7835 /* Neither conversion sequence is better than the other. */
7839 /* The source type for this standard conversion sequence. */
7842 source_type (conversion *t)
7844 for (;; t = t->u.next)
7846 if (t->kind == ck_user
7847 || t->kind == ck_ambig
7848 || t->kind == ck_identity)
7854 /* Note a warning about preferring WINNER to LOSER. We do this by storing
7855 a pointer to LOSER and re-running joust to produce the warning if WINNER
7856 is actually used. */
7859 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7861 candidate_warning *cw = (candidate_warning *)
7862 conversion_obstack_alloc (sizeof (candidate_warning));
7864 cw->next = winner->warnings;
7865 winner->warnings = cw;
7868 /* Compare two candidates for overloading as described in
7869 [over.match.best]. Return values:
7871 1: cand1 is better than cand2
7872 -1: cand2 is better than cand1
7873 0: cand1 and cand2 are indistinguishable */
7876 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7879 int off1 = 0, off2 = 0;
7883 /* Candidates that involve bad conversions are always worse than those
7885 if (cand1->viable > cand2->viable)
7887 if (cand1->viable < cand2->viable)
7890 /* If we have two pseudo-candidates for conversions to the same type,
7891 or two candidates for the same function, arbitrarily pick one. */
7892 if (cand1->fn == cand2->fn
7893 && (IS_TYPE_OR_DECL_P (cand1->fn)))
7896 /* a viable function F1
7897 is defined to be a better function than another viable function F2 if
7898 for all arguments i, ICSi(F1) is not a worse conversion sequence than
7899 ICSi(F2), and then */
7901 /* for some argument j, ICSj(F1) is a better conversion sequence than
7904 /* For comparing static and non-static member functions, we ignore
7905 the implicit object parameter of the non-static function. The
7906 standard says to pretend that the static function has an object
7907 parm, but that won't work with operator overloading. */
7908 len = cand1->num_convs;
7909 if (len != cand2->num_convs)
7911 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7912 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7914 gcc_assert (static_1 != static_2);
7925 for (i = 0; i < len; ++i)
7927 conversion *t1 = cand1->convs[i + off1];
7928 conversion *t2 = cand2->convs[i + off2];
7929 int comp = compare_ics (t1, t2);
7934 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7935 == cr_std + cr_promotion)
7936 && t1->kind == ck_std
7937 && t2->kind == ck_std
7938 && TREE_CODE (t1->type) == INTEGER_TYPE
7939 && TREE_CODE (t2->type) == INTEGER_TYPE
7940 && (TYPE_PRECISION (t1->type)
7941 == TYPE_PRECISION (t2->type))
7942 && (TYPE_UNSIGNED (t1->u.next->type)
7943 || (TREE_CODE (t1->u.next->type)
7946 tree type = t1->u.next->type;
7948 struct z_candidate *w, *l;
7950 type1 = t1->type, type2 = t2->type,
7951 w = cand1, l = cand2;
7953 type1 = t2->type, type2 = t1->type,
7954 w = cand2, l = cand1;
7958 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7959 type, type1, type2);
7960 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
7966 if (winner && comp != winner)
7975 /* warn about confusing overload resolution for user-defined conversions,
7976 either between a constructor and a conversion op, or between two
7978 if (winner && warn_conversion && cand1->second_conv
7979 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7980 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7982 struct z_candidate *w, *l;
7983 bool give_warning = false;
7986 w = cand1, l = cand2;
7988 w = cand2, l = cand1;
7990 /* We don't want to complain about `X::operator T1 ()'
7991 beating `X::operator T2 () const', when T2 is a no less
7992 cv-qualified version of T1. */
7993 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7994 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7996 tree t = TREE_TYPE (TREE_TYPE (l->fn));
7997 tree f = TREE_TYPE (TREE_TYPE (w->fn));
7999 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
8004 if (!comp_ptr_ttypes (t, f))
8005 give_warning = true;
8008 give_warning = true;
8014 tree source = source_type (w->convs[0]);
8015 if (! DECL_CONSTRUCTOR_P (w->fn))
8016 source = TREE_TYPE (source);
8017 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
8018 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
8019 source, w->second_conv->type))
8021 inform (input_location, " because conversion sequence for the argument is better");
8032 F1 is a non-template function and F2 is a template function
8035 if (!cand1->template_decl && cand2->template_decl)
8037 else if (cand1->template_decl && !cand2->template_decl)
8041 F1 and F2 are template functions and the function template for F1 is
8042 more specialized than the template for F2 according to the partial
8045 if (cand1->template_decl && cand2->template_decl)
8047 winner = more_specialized_fn
8048 (TI_TEMPLATE (cand1->template_decl),
8049 TI_TEMPLATE (cand2->template_decl),
8050 /* [temp.func.order]: The presence of unused ellipsis and default
8051 arguments has no effect on the partial ordering of function
8052 templates. add_function_candidate() will not have
8053 counted the "this" argument for constructors. */
8054 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
8060 the context is an initialization by user-defined conversion (see
8061 _dcl.init_ and _over.match.user_) and the standard conversion
8062 sequence from the return type of F1 to the destination type (i.e.,
8063 the type of the entity being initialized) is a better conversion
8064 sequence than the standard conversion sequence from the return type
8065 of F2 to the destination type. */
8067 if (cand1->second_conv)
8069 winner = compare_ics (cand1->second_conv, cand2->second_conv);
8074 /* Check whether we can discard a builtin candidate, either because we
8075 have two identical ones or matching builtin and non-builtin candidates.
8077 (Pedantically in the latter case the builtin which matched the user
8078 function should not be added to the overload set, but we spot it here.
8081 ... the builtin candidates include ...
8082 - do not have the same parameter type list as any non-template
8083 non-member candidate. */
8085 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
8086 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
8088 for (i = 0; i < len; ++i)
8089 if (!same_type_p (cand1->convs[i]->type,
8090 cand2->convs[i]->type))
8092 if (i == cand1->num_convs)
8094 if (cand1->fn == cand2->fn)
8095 /* Two built-in candidates; arbitrarily pick one. */
8097 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
8098 /* cand1 is built-in; prefer cand2. */
8101 /* cand2 is built-in; prefer cand1. */
8106 /* If the two function declarations represent the same function (this can
8107 happen with declarations in multiple scopes and arg-dependent lookup),
8108 arbitrarily choose one. But first make sure the default args we're
8110 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
8111 && equal_functions (cand1->fn, cand2->fn))
8113 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
8114 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
8116 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
8118 for (i = 0; i < len; ++i)
8120 /* Don't crash if the fn is variadic. */
8123 parms1 = TREE_CHAIN (parms1);
8124 parms2 = TREE_CHAIN (parms2);
8128 parms1 = TREE_CHAIN (parms1);
8130 parms2 = TREE_CHAIN (parms2);
8134 if (!cp_tree_equal (TREE_PURPOSE (parms1),
8135 TREE_PURPOSE (parms2)))
8139 permerror (input_location, "default argument mismatch in "
8140 "overload resolution");
8141 inform (input_location,
8142 " candidate 1: %q+#F", cand1->fn);
8143 inform (input_location,
8144 " candidate 2: %q+#F", cand2->fn);
8147 add_warning (cand1, cand2);
8150 parms1 = TREE_CHAIN (parms1);
8151 parms2 = TREE_CHAIN (parms2);
8159 /* Extension: If the worst conversion for one candidate is worse than the
8160 worst conversion for the other, take the first. */
8163 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
8164 struct z_candidate *w = 0, *l = 0;
8166 for (i = 0; i < len; ++i)
8168 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
8169 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
8170 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
8171 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
8174 winner = 1, w = cand1, l = cand2;
8176 winner = -1, w = cand2, l = cand1;
8179 /* Don't choose a deleted function over ambiguity. */
8180 if (DECL_P (w->fn) && DECL_DELETED_FN (w->fn))
8184 pedwarn (input_location, 0,
8185 "ISO C++ says that these are ambiguous, even "
8186 "though the worst conversion for the first is better than "
8187 "the worst conversion for the second:");
8188 print_z_candidate (_("candidate 1:"), w);
8189 print_z_candidate (_("candidate 2:"), l);
8197 gcc_assert (!winner);
8201 /* Given a list of candidates for overloading, find the best one, if any.
8202 This algorithm has a worst case of O(2n) (winner is last), and a best
8203 case of O(n/2) (totally ambiguous); much better than a sorting
8206 static struct z_candidate *
8207 tourney (struct z_candidate *candidates)
8209 struct z_candidate *champ = candidates, *challenger;
8211 int champ_compared_to_predecessor = 0;
8213 /* Walk through the list once, comparing each current champ to the next
8214 candidate, knocking out a candidate or two with each comparison. */
8216 for (challenger = champ->next; challenger; )
8218 fate = joust (champ, challenger, 0);
8220 challenger = challenger->next;
8225 champ = challenger->next;
8228 champ_compared_to_predecessor = 0;
8233 champ_compared_to_predecessor = 1;
8236 challenger = champ->next;
8240 /* Make sure the champ is better than all the candidates it hasn't yet
8241 been compared to. */
8243 for (challenger = candidates;
8245 && !(champ_compared_to_predecessor && challenger->next == champ);
8246 challenger = challenger->next)
8248 fate = joust (champ, challenger, 0);
8256 /* Returns nonzero if things of type FROM can be converted to TO. */
8259 can_convert (tree to, tree from)
8261 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
8264 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
8267 can_convert_arg (tree to, tree from, tree arg, int flags)
8273 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8274 p = conversion_obstack_alloc (0);
8276 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
8278 ok_p = (t && !t->bad_p);
8280 /* Free all the conversions we allocated. */
8281 obstack_free (&conversion_obstack, p);
8286 /* Like can_convert_arg, but allows dubious conversions as well. */
8289 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
8294 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8295 p = conversion_obstack_alloc (0);
8296 /* Try to perform the conversion. */
8297 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
8299 /* Free all the conversions we allocated. */
8300 obstack_free (&conversion_obstack, p);
8305 /* Convert EXPR to TYPE. Return the converted expression.
8307 Note that we allow bad conversions here because by the time we get to
8308 this point we are committed to doing the conversion. If we end up
8309 doing a bad conversion, convert_like will complain. */
8312 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
8317 if (error_operand_p (expr))
8318 return error_mark_node;
8320 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8321 p = conversion_obstack_alloc (0);
8323 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8329 if (complain & tf_error)
8331 /* If expr has unknown type, then it is an overloaded function.
8332 Call instantiate_type to get good error messages. */
8333 if (TREE_TYPE (expr) == unknown_type_node)
8334 instantiate_type (type, expr, complain);
8335 else if (invalid_nonstatic_memfn_p (expr, complain))
8336 /* We gave an error. */;
8338 error ("could not convert %qE from %qT to %qT", expr,
8339 TREE_TYPE (expr), type);
8341 expr = error_mark_node;
8343 else if (processing_template_decl)
8345 /* In a template, we are only concerned about determining the
8346 type of non-dependent expressions, so we do not have to
8347 perform the actual conversion. */
8348 if (TREE_TYPE (expr) != type)
8349 expr = build_nop (type, expr);
8352 expr = convert_like (conv, expr, complain);
8354 /* Free all the conversions we allocated. */
8355 obstack_free (&conversion_obstack, p);
8361 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
8363 return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
8366 /* Convert EXPR to TYPE (as a direct-initialization) if that is
8367 permitted. If the conversion is valid, the converted expression is
8368 returned. Otherwise, NULL_TREE is returned, except in the case
8369 that TYPE is a class type; in that case, an error is issued. If
8370 C_CAST_P is true, then this direction initialization is taking
8371 place as part of a static_cast being attempted as part of a C-style
8375 perform_direct_initialization_if_possible (tree type,
8378 tsubst_flags_t complain)
8383 if (type == error_mark_node || error_operand_p (expr))
8384 return error_mark_node;
8387 If the destination type is a (possibly cv-qualified) class type:
8389 -- If the initialization is direct-initialization ...,
8390 constructors are considered. ... If no constructor applies, or
8391 the overload resolution is ambiguous, the initialization is
8393 if (CLASS_TYPE_P (type))
8395 VEC(tree,gc) *args = make_tree_vector_single (expr);
8396 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
8397 &args, type, LOOKUP_NORMAL, complain);
8398 release_tree_vector (args);
8399 return build_cplus_new (type, expr, complain);
8402 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8403 p = conversion_obstack_alloc (0);
8405 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8408 if (!conv || conv->bad_p)
8411 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
8412 /*issue_conversion_warnings=*/false,
8416 /* Free all the conversions we allocated. */
8417 obstack_free (&conversion_obstack, p);
8422 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
8423 is being bound to a temporary. Create and return a new VAR_DECL
8424 with the indicated TYPE; this variable will store the value to
8425 which the reference is bound. */
8428 make_temporary_var_for_ref_to_temp (tree decl, tree type)
8432 /* Create the variable. */
8433 var = create_temporary_var (type);
8435 /* Register the variable. */
8436 if (TREE_STATIC (decl))
8438 /* Namespace-scope or local static; give it a mangled name. */
8441 TREE_STATIC (var) = 1;
8442 name = mangle_ref_init_variable (decl);
8443 DECL_NAME (var) = name;
8444 SET_DECL_ASSEMBLER_NAME (var, name);
8445 var = pushdecl_top_level (var);
8448 /* Create a new cleanup level if necessary. */
8449 maybe_push_cleanup_level (type);
8454 /* EXPR is the initializer for a variable DECL of reference or
8455 std::initializer_list type. Create, push and return a new VAR_DECL
8456 for the initializer so that it will live as long as DECL. Any
8457 cleanup for the new variable is returned through CLEANUP, and the
8458 code to initialize the new variable is returned through INITP. */
8461 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
8467 /* Create the temporary variable. */
8468 type = TREE_TYPE (expr);
8469 var = make_temporary_var_for_ref_to_temp (decl, type);
8470 layout_decl (var, 0);
8471 /* If the rvalue is the result of a function call it will be
8472 a TARGET_EXPR. If it is some other construct (such as a
8473 member access expression where the underlying object is
8474 itself the result of a function call), turn it into a
8475 TARGET_EXPR here. It is important that EXPR be a
8476 TARGET_EXPR below since otherwise the INIT_EXPR will
8477 attempt to make a bitwise copy of EXPR to initialize
8479 if (TREE_CODE (expr) != TARGET_EXPR)
8480 expr = get_target_expr (expr);
8482 /* If the initializer is constant, put it in DECL_INITIAL so we get
8483 static initialization and use in constant expressions. */
8484 init = maybe_constant_init (expr);
8485 if (TREE_CONSTANT (init))
8487 if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
8489 /* 5.19 says that a constant expression can include an
8490 lvalue-rvalue conversion applied to "a glvalue of literal type
8491 that refers to a non-volatile temporary object initialized
8492 with a constant expression". Rather than try to communicate
8493 that this VAR_DECL is a temporary, just mark it constexpr.
8495 Currently this is only useful for initializer_list temporaries,
8496 since reference vars can't appear in constant expressions. */
8497 DECL_DECLARED_CONSTEXPR_P (var) = true;
8498 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var) = true;
8499 TREE_CONSTANT (var) = true;
8501 DECL_INITIAL (var) = init;
8505 /* Create the INIT_EXPR that will initialize the temporary
8507 init = build2 (INIT_EXPR, type, var, expr);
8508 if (at_function_scope_p ())
8510 add_decl_expr (var);
8512 if (TREE_STATIC (var))
8513 init = add_stmt_to_compound (init, register_dtor_fn (var));
8515 *cleanup = cxx_maybe_build_cleanup (var, tf_warning_or_error);
8517 /* We must be careful to destroy the temporary only
8518 after its initialization has taken place. If the
8519 initialization throws an exception, then the
8520 destructor should not be run. We cannot simply
8521 transform INIT into something like:
8523 (INIT, ({ CLEANUP_STMT; }))
8525 because emit_local_var always treats the
8526 initializer as a full-expression. Thus, the
8527 destructor would run too early; it would run at the
8528 end of initializing the reference variable, rather
8529 than at the end of the block enclosing the
8532 The solution is to pass back a cleanup expression
8533 which the caller is responsible for attaching to
8534 the statement tree. */
8538 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
8539 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8540 static_aggregates = tree_cons (NULL_TREE, var,
8548 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
8549 initializing a variable of that TYPE. If DECL is non-NULL, it is
8550 the VAR_DECL being initialized with the EXPR. (In that case, the
8551 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
8552 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
8553 return, if *CLEANUP is no longer NULL, it will be an expression
8554 that should be pushed as a cleanup after the returned expression
8555 is used to initialize DECL.
8557 Return the converted expression. */
8560 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
8561 tsubst_flags_t complain)
8566 if (type == error_mark_node || error_operand_p (expr))
8567 return error_mark_node;
8569 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8570 p = conversion_obstack_alloc (0);
8572 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
8574 if (!conv || conv->bad_p)
8576 if (complain & tf_error)
8578 if (!CP_TYPE_CONST_P (TREE_TYPE (type))
8579 && !TYPE_REF_IS_RVALUE (type)
8580 && !real_lvalue_p (expr))
8581 error ("invalid initialization of non-const reference of "
8582 "type %qT from an rvalue of type %qT",
8583 type, TREE_TYPE (expr));
8585 error ("invalid initialization of reference of type "
8586 "%qT from expression of type %qT", type,
8589 return error_mark_node;
8592 /* If DECL is non-NULL, then this special rule applies:
8596 The temporary to which the reference is bound or the temporary
8597 that is the complete object to which the reference is bound
8598 persists for the lifetime of the reference.
8600 The temporaries created during the evaluation of the expression
8601 initializing the reference, except the temporary to which the
8602 reference is bound, are destroyed at the end of the
8603 full-expression in which they are created.
8605 In that case, we store the converted expression into a new
8606 VAR_DECL in a new scope.
8608 However, we want to be careful not to create temporaries when
8609 they are not required. For example, given:
8612 struct D : public B {};
8616 there is no need to copy the return value from "f"; we can just
8617 extend its lifetime. Similarly, given:
8620 struct T { operator S(); };
8624 we can extend the lifetime of the return value of the conversion
8626 gcc_assert (conv->kind == ck_ref_bind);
8630 tree base_conv_type;
8632 /* Skip over the REF_BIND. */
8633 conv = conv->u.next;
8634 /* If the next conversion is a BASE_CONV, skip that too -- but
8635 remember that the conversion was required. */
8636 if (conv->kind == ck_base)
8638 base_conv_type = conv->type;
8639 conv = conv->u.next;
8642 base_conv_type = NULL_TREE;
8643 /* Perform the remainder of the conversion. */
8644 expr = convert_like_real (conv, expr,
8645 /*fn=*/NULL_TREE, /*argnum=*/0,
8647 /*issue_conversion_warnings=*/true,
8649 tf_warning_or_error);
8650 if (error_operand_p (expr))
8651 expr = error_mark_node;
8654 if (!lvalue_or_rvalue_with_address_p (expr))
8657 var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
8658 /* Use its address to initialize the reference variable. */
8659 expr = build_address (var);
8661 expr = convert_to_base (expr,
8662 build_pointer_type (base_conv_type),
8663 /*check_access=*/true,
8664 /*nonnull=*/true, complain);
8666 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
8669 /* Take the address of EXPR. */
8670 expr = cp_build_addr_expr (expr, tf_warning_or_error);
8671 /* If a BASE_CONV was required, perform it now. */
8673 expr = (perform_implicit_conversion
8674 (build_pointer_type (base_conv_type), expr,
8675 tf_warning_or_error));
8676 expr = build_nop (type, expr);
8680 /* Perform the conversion. */
8681 expr = convert_like (conv, expr, tf_warning_or_error);
8683 /* Free all the conversions we allocated. */
8684 obstack_free (&conversion_obstack, p);
8689 /* Returns true iff TYPE is some variant of std::initializer_list. */
8692 is_std_init_list (tree type)
8694 /* Look through typedefs. */
8697 type = TYPE_MAIN_VARIANT (type);
8698 return (CLASS_TYPE_P (type)
8699 && CP_TYPE_CONTEXT (type) == std_node
8700 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
8703 /* Returns true iff DECL is a list constructor: i.e. a constructor which
8704 will accept an argument list of a single std::initializer_list<T>. */
8707 is_list_ctor (tree decl)
8709 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
8712 if (!args || args == void_list_node)
8715 arg = non_reference (TREE_VALUE (args));
8716 if (!is_std_init_list (arg))
8719 args = TREE_CHAIN (args);
8721 if (args && args != void_list_node && !TREE_PURPOSE (args))
8722 /* There are more non-defaulted parms. */
8728 #include "gt-cp-call.h"