1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 modified by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
33 #include "diagnostic-core.h"
37 #include "langhooks.h"
38 #include "c-family/c-objc.h"
42 /* The various kinds of conversion. */
44 typedef enum conversion_kind {
60 /* The rank of the conversion. Order of the enumerals matters; better
61 conversions should come earlier in the list. */
63 typedef enum conversion_rank {
74 /* An implicit conversion sequence, in the sense of [over.best.ics].
75 The first conversion to be performed is at the end of the chain.
76 That conversion is always a cr_identity conversion. */
78 typedef struct conversion conversion;
80 /* The kind of conversion represented by this step. */
82 /* The rank of this conversion. */
84 BOOL_BITFIELD user_conv_p : 1;
85 BOOL_BITFIELD ellipsis_p : 1;
86 BOOL_BITFIELD this_p : 1;
87 /* True if this conversion would be permitted with a bending of
88 language standards, e.g. disregarding pointer qualifiers or
89 converting integers to pointers. */
90 BOOL_BITFIELD bad_p : 1;
91 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
92 temporary should be created to hold the result of the
94 BOOL_BITFIELD need_temporary_p : 1;
95 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
96 from a pointer-to-derived to pointer-to-base is being performed. */
97 BOOL_BITFIELD base_p : 1;
98 /* If KIND is ck_ref_bind, true when either an lvalue reference is
99 being bound to an lvalue expression or an rvalue reference is
100 being bound to an rvalue expression. If KIND is ck_rvalue,
101 true when we should treat an lvalue as an rvalue (12.8p33). If
102 KIND is ck_base, always false. */
103 BOOL_BITFIELD rvaluedness_matches_p: 1;
104 BOOL_BITFIELD check_narrowing: 1;
105 /* The type of the expression resulting from the conversion. */
108 /* The next conversion in the chain. Since the conversions are
109 arranged from outermost to innermost, the NEXT conversion will
110 actually be performed before this conversion. This variant is
111 used only when KIND is neither ck_identity, ck_ambig nor
112 ck_list. Please use the next_conversion function instead
113 of using this field directly. */
115 /* The expression at the beginning of the conversion chain. This
116 variant is used only if KIND is ck_identity or ck_ambig. */
118 /* The array of conversions for an initializer_list, so this
119 variant is used only when KIN D is ck_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 *, tsubst_flags_t);
143 static int equal_functions (tree, tree);
144 static int joust (struct z_candidate *, struct z_candidate *, bool,
146 static int compare_ics (conversion *, conversion *);
147 static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
148 static tree build_java_interface_fn_ref (tree, tree);
149 #define convert_like(CONV, EXPR, COMPLAIN) \
150 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
151 /*issue_conversion_warnings=*/true, \
152 /*c_cast_p=*/false, (COMPLAIN))
153 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
154 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
155 /*issue_conversion_warnings=*/true, \
156 /*c_cast_p=*/false, (COMPLAIN))
157 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
158 bool, tsubst_flags_t);
159 static void op_error (location_t, enum tree_code, enum tree_code, tree,
161 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int,
163 static void print_z_candidate (location_t, const char *, struct z_candidate *);
164 static void print_z_candidates (location_t, struct z_candidate *);
165 static tree build_this (tree);
166 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
167 static bool any_strictly_viable (struct z_candidate *);
168 static struct z_candidate *add_template_candidate
169 (struct z_candidate **, tree, tree, tree, tree, const vec<tree, va_gc> *,
170 tree, tree, tree, int, unification_kind_t, tsubst_flags_t);
171 static struct z_candidate *add_template_candidate_real
172 (struct z_candidate **, tree, tree, tree, tree, const vec<tree, va_gc> *,
173 tree, tree, tree, int, tree, unification_kind_t, tsubst_flags_t);
174 static struct z_candidate *add_template_conv_candidate
175 (struct z_candidate **, tree, tree, tree, const vec<tree, va_gc> *,
176 tree, tree, tree, tsubst_flags_t);
177 static void add_builtin_candidates
178 (struct z_candidate **, enum tree_code, enum tree_code,
179 tree, tree *, int, tsubst_flags_t);
180 static void add_builtin_candidate
181 (struct z_candidate **, enum tree_code, enum tree_code,
182 tree, tree, tree, tree *, tree *, int, tsubst_flags_t);
183 static bool is_complete (tree);
184 static void build_builtin_candidate
185 (struct z_candidate **, tree, tree, tree, tree *, tree *,
186 int, tsubst_flags_t);
187 static struct z_candidate *add_conv_candidate
188 (struct z_candidate **, tree, tree, tree, const vec<tree, va_gc> *, tree,
189 tree, tsubst_flags_t);
190 static struct z_candidate *add_function_candidate
191 (struct z_candidate **, tree, tree, tree, const vec<tree, va_gc> *, tree,
192 tree, int, tsubst_flags_t);
193 static conversion *implicit_conversion (tree, tree, tree, bool, int,
195 static conversion *standard_conversion (tree, tree, tree, bool, int);
196 static conversion *reference_binding (tree, tree, tree, bool, int,
198 static conversion *build_conv (conversion_kind, tree, conversion *);
199 static conversion *build_list_conv (tree, tree, int, tsubst_flags_t);
200 static conversion *next_conversion (conversion *);
201 static bool is_subseq (conversion *, conversion *);
202 static conversion *maybe_handle_ref_bind (conversion **);
203 static void maybe_handle_implicit_object (conversion **);
204 static struct z_candidate *add_candidate
205 (struct z_candidate **, tree, tree, const vec<tree, va_gc> *, size_t,
206 conversion **, tree, tree, int, struct rejection_reason *);
207 static tree source_type (conversion *);
208 static void add_warning (struct z_candidate *, struct z_candidate *);
209 static bool reference_compatible_p (tree, tree);
210 static conversion *direct_reference_binding (tree, conversion *);
211 static bool promoted_arithmetic_type_p (tree);
212 static conversion *conditional_conversion (tree, tree, tsubst_flags_t);
213 static char *name_as_c_string (tree, tree, bool *);
214 static tree prep_operand (tree);
215 static void add_candidates (tree, tree, const vec<tree, va_gc> *, tree, tree,
216 bool, tree, tree, int, struct z_candidate **,
218 static conversion *merge_conversion_sequences (conversion *, conversion *);
219 static bool magic_varargs_p (tree);
220 static tree build_temp (tree, tree, int, diagnostic_t *, tsubst_flags_t);
222 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
223 NAME can take many forms... */
226 check_dtor_name (tree basetype, tree name)
228 /* Just accept something we've already complained about. */
229 if (name == error_mark_node)
232 if (TREE_CODE (name) == TYPE_DECL)
233 name = TREE_TYPE (name);
234 else if (TYPE_P (name))
236 else if (TREE_CODE (name) == IDENTIFIER_NODE)
238 if ((MAYBE_CLASS_TYPE_P (basetype)
239 && name == constructor_name (basetype))
240 || (TREE_CODE (basetype) == ENUMERAL_TYPE
241 && name == TYPE_IDENTIFIER (basetype)))
244 name = get_type_value (name);
250 template <class T> struct S { ~S(); };
254 NAME will be a class template. */
255 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
259 if (!name || name == error_mark_node)
261 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
264 /* We want the address of a function or method. We avoid creating a
265 pointer-to-member function. */
268 build_addr_func (tree function, tsubst_flags_t complain)
270 tree type = TREE_TYPE (function);
272 /* We have to do these by hand to avoid real pointer to member
274 if (TREE_CODE (type) == METHOD_TYPE)
276 if (TREE_CODE (function) == OFFSET_REF)
278 tree object = build_address (TREE_OPERAND (function, 0));
279 return get_member_function_from_ptrfunc (&object,
280 TREE_OPERAND (function, 1),
283 function = build_address (function);
286 function = decay_conversion (function, complain);
291 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
292 POINTER_TYPE to those. Note, pointer to member function types
293 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
294 two variants. build_call_a is the primitive taking an array of
295 arguments, while build_call_n is a wrapper that handles varargs. */
298 build_call_n (tree function, int n, ...)
301 return build_call_a (function, 0, NULL);
304 tree *argarray = XALLOCAVEC (tree, n);
309 for (i = 0; i < n; i++)
310 argarray[i] = va_arg (ap, tree);
312 return build_call_a (function, n, argarray);
316 /* Update various flags in cfun and the call itself based on what is being
317 called. Split out of build_call_a so that bot_manip can use it too. */
320 set_flags_from_callee (tree call)
323 tree decl = get_callee_fndecl (call);
325 /* We check both the decl and the type; a function may be known not to
326 throw without being declared throw(). */
327 nothrow = ((decl && TREE_NOTHROW (decl))
328 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call)))));
330 if (!nothrow && at_function_scope_p () && cfun && cp_function_chain)
331 cp_function_chain->can_throw = 1;
333 if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)
334 current_function_returns_abnormally = 1;
336 TREE_NOTHROW (call) = nothrow;
340 build_call_a (tree function, int n, tree *argarray)
347 function = build_addr_func (function, tf_warning_or_error);
349 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
350 fntype = TREE_TYPE (TREE_TYPE (function));
351 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
352 || TREE_CODE (fntype) == METHOD_TYPE);
353 result_type = TREE_TYPE (fntype);
354 /* An rvalue has no cv-qualifiers. */
355 if (SCALAR_TYPE_P (result_type) || VOID_TYPE_P (result_type))
356 result_type = cv_unqualified (result_type);
358 function = build_call_array_loc (input_location,
359 result_type, function, n, argarray);
360 set_flags_from_callee (function);
362 decl = get_callee_fndecl (function);
364 if (decl && !TREE_USED (decl))
366 /* We invoke build_call directly for several library
367 functions. These may have been declared normally if
368 we're building libgcc, so we can't just check
370 gcc_assert (DECL_ARTIFICIAL (decl)
371 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
376 if (decl && TREE_DEPRECATED (decl))
377 warn_deprecated_use (decl, NULL_TREE);
378 require_complete_eh_spec_types (fntype, decl);
380 TREE_HAS_CONSTRUCTOR (function) = (decl && DECL_CONSTRUCTOR_P (decl));
382 /* Don't pass empty class objects by value. This is useful
383 for tags in STL, which are used to control overload resolution.
384 We don't need to handle other cases of copying empty classes. */
385 if (! decl || ! DECL_BUILT_IN (decl))
386 for (i = 0; i < n; i++)
388 tree arg = CALL_EXPR_ARG (function, i);
389 if (is_empty_class (TREE_TYPE (arg))
390 && ! TREE_ADDRESSABLE (TREE_TYPE (arg)))
392 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (arg));
393 arg = build2 (COMPOUND_EXPR, TREE_TYPE (t), arg, t);
394 CALL_EXPR_ARG (function, i) = arg;
401 /* Build something of the form ptr->method (args)
402 or object.method (args). This can also build
403 calls to constructors, and find friends.
405 Member functions always take their class variable
408 INSTANCE is a class instance.
410 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
412 PARMS help to figure out what that NAME really refers to.
414 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
415 down to the real instance type to use for access checking. We need this
416 information to get protected accesses correct.
418 FLAGS is the logical disjunction of zero or more LOOKUP_
419 flags. See cp-tree.h for more info.
421 If this is all OK, calls build_function_call with the resolved
424 This function must also handle being called to perform
425 initialization, promotion/coercion of arguments, and
426 instantiation of default parameters.
428 Note that NAME may refer to an instance variable name. If
429 `operator()()' is defined for the type of that field, then we return
432 /* New overloading code. */
434 typedef struct z_candidate z_candidate;
436 typedef struct candidate_warning candidate_warning;
437 struct candidate_warning {
439 candidate_warning *next;
442 /* Information for providing diagnostics about why overloading failed. */
444 enum rejection_reason_code {
447 rr_explicit_conversion,
448 rr_template_conversion,
450 rr_bad_arg_conversion,
451 rr_template_unification,
455 struct conversion_info {
456 /* The index of the argument, 0-based. */
458 /* The type of the actual argument. */
460 /* The type of the formal argument. */
464 struct rejection_reason {
465 enum rejection_reason_code code;
467 /* Information about an arity mismatch. */
469 /* The expected number of arguments. */
471 /* The actual number of arguments in the call. */
473 /* Whether the call was a varargs call. */
476 /* Information about an argument conversion mismatch. */
477 struct conversion_info conversion;
478 /* Same, but for bad argument conversions. */
479 struct conversion_info bad_conversion;
480 /* Information about template unification failures. These are the
481 parameters passed to fn_type_unification. */
489 unification_kind_t strict;
491 } template_unification;
492 /* Information about template instantiation failures. These are the
493 parameters passed to instantiate_template. */
497 } template_instantiation;
502 /* The FUNCTION_DECL that will be called if this candidate is
503 selected by overload resolution. */
505 /* If not NULL_TREE, the first argument to use when calling this
508 /* The rest of the arguments to use when calling this function. If
509 there are no further arguments this may be NULL or it may be an
511 const vec<tree, va_gc> *args;
512 /* The implicit conversion sequences for each of the arguments to
515 /* The number of implicit conversion sequences. */
517 /* If FN is a user-defined conversion, the standard conversion
518 sequence from the type returned by FN to the desired destination
520 conversion *second_conv;
522 struct rejection_reason *reason;
523 /* If FN is a member function, the binfo indicating the path used to
524 qualify the name of FN at the call site. This path is used to
525 determine whether or not FN is accessible if it is selected by
526 overload resolution. The DECL_CONTEXT of FN will always be a
527 (possibly improper) base of this binfo. */
529 /* If FN is a non-static member function, the binfo indicating the
530 subobject to which the `this' pointer should be converted if FN
531 is selected by overload resolution. The type pointed to by
532 the `this' pointer must correspond to the most derived class
533 indicated by the CONVERSION_PATH. */
534 tree conversion_path;
537 candidate_warning *warnings;
541 /* Returns true iff T is a null pointer constant in the sense of
545 null_ptr_cst_p (tree t)
549 A null pointer constant is an integral constant expression
550 (_expr.const_) rvalue of integer type that evaluates to zero or
551 an rvalue of type std::nullptr_t. */
552 if (NULLPTR_TYPE_P (TREE_TYPE (t)))
554 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)))
556 /* Core issue 903 says only literal 0 is a null pointer constant. */
557 if (cxx_dialect < cxx0x)
558 t = maybe_constant_value (fold_non_dependent_expr_sfinae (t, tf_none));
560 if (integer_zerop (t) && !TREE_OVERFLOW (t))
566 /* Returns true iff T is a null member pointer value (4.11). */
569 null_member_pointer_value_p (tree t)
571 tree type = TREE_TYPE (t);
574 else if (TYPE_PTRMEMFUNC_P (type))
575 return (TREE_CODE (t) == CONSTRUCTOR
576 && integer_zerop (CONSTRUCTOR_ELT (t, 0)->value));
577 else if (TYPE_PTRDATAMEM_P (type))
578 return integer_all_onesp (t);
583 /* Returns nonzero if PARMLIST consists of only default parms,
584 ellipsis, and/or undeduced parameter packs. */
587 sufficient_parms_p (const_tree parmlist)
589 for (; parmlist && parmlist != void_list_node;
590 parmlist = TREE_CHAIN (parmlist))
591 if (!TREE_PURPOSE (parmlist)
592 && !PACK_EXPANSION_P (TREE_VALUE (parmlist)))
597 /* Allocate N bytes of memory from the conversion obstack. The memory
598 is zeroed before being returned. */
601 conversion_obstack_alloc (size_t n)
604 if (!conversion_obstack_initialized)
606 gcc_obstack_init (&conversion_obstack);
607 conversion_obstack_initialized = true;
609 p = obstack_alloc (&conversion_obstack, n);
614 /* Allocate rejection reasons. */
616 static struct rejection_reason *
617 alloc_rejection (enum rejection_reason_code code)
619 struct rejection_reason *p;
620 p = (struct rejection_reason *) conversion_obstack_alloc (sizeof *p);
625 static struct rejection_reason *
626 arity_rejection (tree first_arg, int expected, int actual)
628 struct rejection_reason *r = alloc_rejection (rr_arity);
629 int adjust = first_arg != NULL_TREE;
630 r->u.arity.expected = expected - adjust;
631 r->u.arity.actual = actual - adjust;
635 static struct rejection_reason *
636 arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to)
638 struct rejection_reason *r = alloc_rejection (rr_arg_conversion);
639 int adjust = first_arg != NULL_TREE;
640 r->u.conversion.n_arg = n_arg - adjust;
641 r->u.conversion.from_type = from;
642 r->u.conversion.to_type = to;
646 static struct rejection_reason *
647 bad_arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to)
649 struct rejection_reason *r = alloc_rejection (rr_bad_arg_conversion);
650 int adjust = first_arg != NULL_TREE;
651 r->u.bad_conversion.n_arg = n_arg - adjust;
652 r->u.bad_conversion.from_type = from;
653 r->u.bad_conversion.to_type = to;
657 static struct rejection_reason *
658 explicit_conversion_rejection (tree from, tree to)
660 struct rejection_reason *r = alloc_rejection (rr_explicit_conversion);
661 r->u.conversion.n_arg = 0;
662 r->u.conversion.from_type = from;
663 r->u.conversion.to_type = to;
667 static struct rejection_reason *
668 template_conversion_rejection (tree from, tree to)
670 struct rejection_reason *r = alloc_rejection (rr_template_conversion);
671 r->u.conversion.n_arg = 0;
672 r->u.conversion.from_type = from;
673 r->u.conversion.to_type = to;
677 static struct rejection_reason *
678 template_unification_rejection (tree tmpl, tree explicit_targs, tree targs,
679 const tree *args, unsigned int nargs,
680 tree return_type, unification_kind_t strict,
683 size_t args_n_bytes = sizeof (*args) * nargs;
684 tree *args1 = (tree *) conversion_obstack_alloc (args_n_bytes);
685 struct rejection_reason *r = alloc_rejection (rr_template_unification);
686 r->u.template_unification.tmpl = tmpl;
687 r->u.template_unification.explicit_targs = explicit_targs;
688 r->u.template_unification.num_targs = TREE_VEC_LENGTH (targs);
689 /* Copy args to our own storage. */
690 memcpy (args1, args, args_n_bytes);
691 r->u.template_unification.args = args1;
692 r->u.template_unification.nargs = nargs;
693 r->u.template_unification.return_type = return_type;
694 r->u.template_unification.strict = strict;
695 r->u.template_unification.flags = flags;
699 static struct rejection_reason *
700 template_unification_error_rejection (void)
702 return alloc_rejection (rr_template_unification);
705 static struct rejection_reason *
706 invalid_copy_with_fn_template_rejection (void)
708 struct rejection_reason *r = alloc_rejection (rr_invalid_copy);
712 /* Dynamically allocate a conversion. */
715 alloc_conversion (conversion_kind kind)
718 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
723 #ifdef ENABLE_CHECKING
725 /* Make sure that all memory on the conversion obstack has been
729 validate_conversion_obstack (void)
731 if (conversion_obstack_initialized)
732 gcc_assert ((obstack_next_free (&conversion_obstack)
733 == obstack_base (&conversion_obstack)));
736 #endif /* ENABLE_CHECKING */
738 /* Dynamically allocate an array of N conversions. */
741 alloc_conversions (size_t n)
743 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
747 build_conv (conversion_kind code, tree type, conversion *from)
750 conversion_rank rank = CONVERSION_RANK (from);
752 /* Note that the caller is responsible for filling in t->cand for
753 user-defined conversions. */
754 t = alloc_conversion (code);
777 t->user_conv_p = (code == ck_user || from->user_conv_p);
778 t->bad_p = from->bad_p;
783 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
784 specialization of std::initializer_list<T>, if such a conversion is
788 build_list_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
790 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
791 unsigned len = CONSTRUCTOR_NELTS (ctor);
792 conversion **subconvs = alloc_conversions (len);
797 /* Within a list-initialization we can have more user-defined
799 flags &= ~LOOKUP_NO_CONVERSION;
800 /* But no narrowing conversions. */
801 flags |= LOOKUP_NO_NARROWING;
803 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
806 = implicit_conversion (elttype, TREE_TYPE (val), val,
807 false, flags, complain);
814 t = alloc_conversion (ck_list);
816 t->u.list = subconvs;
819 for (i = 0; i < len; ++i)
821 conversion *sub = subconvs[i];
822 if (sub->rank > t->rank)
824 if (sub->user_conv_p)
825 t->user_conv_p = true;
833 /* Return the next conversion of the conversion chain (if applicable),
834 or NULL otherwise. Please use this function instead of directly
835 accessing fields of struct conversion. */
838 next_conversion (conversion *conv)
841 || conv->kind == ck_identity
842 || conv->kind == ck_ambig
843 || conv->kind == ck_list)
848 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
849 is a valid aggregate initializer for array type ATYPE. */
852 can_convert_array (tree atype, tree ctor, int flags, tsubst_flags_t complain)
855 tree elttype = TREE_TYPE (atype);
856 for (i = 0; i < CONSTRUCTOR_NELTS (ctor); ++i)
858 tree val = CONSTRUCTOR_ELT (ctor, i)->value;
860 if (TREE_CODE (elttype) == ARRAY_TYPE
861 && TREE_CODE (val) == CONSTRUCTOR)
862 ok = can_convert_array (elttype, val, flags, complain);
864 ok = can_convert_arg (elttype, TREE_TYPE (val), val, flags,
872 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
873 aggregate class, if such a conversion is possible. */
876 build_aggr_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
878 unsigned HOST_WIDE_INT i = 0;
880 tree field = next_initializable_field (TYPE_FIELDS (type));
881 tree empty_ctor = NULL_TREE;
883 ctor = reshape_init (type, ctor, tf_none);
884 if (ctor == error_mark_node)
887 for (; field; field = next_initializable_field (DECL_CHAIN (field)))
889 tree ftype = TREE_TYPE (field);
893 if (i < CONSTRUCTOR_NELTS (ctor))
894 val = CONSTRUCTOR_ELT (ctor, i)->value;
897 if (empty_ctor == NULL_TREE)
898 empty_ctor = build_constructor (init_list_type_node, NULL);
903 if (TREE_CODE (ftype) == ARRAY_TYPE
904 && TREE_CODE (val) == CONSTRUCTOR)
905 ok = can_convert_array (ftype, val, flags, complain);
907 ok = can_convert_arg (ftype, TREE_TYPE (val), val, flags,
913 if (TREE_CODE (type) == UNION_TYPE)
917 if (i < CONSTRUCTOR_NELTS (ctor))
920 c = alloc_conversion (ck_aggr);
923 c->user_conv_p = true;
928 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
929 array type, if such a conversion is possible. */
932 build_array_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
935 unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
936 tree elttype = TREE_TYPE (type);
941 enum conversion_rank rank = cr_exact;
943 if (TYPE_DOMAIN (type))
945 unsigned HOST_WIDE_INT alen = tree_low_cst (array_type_nelts_top (type), 1);
950 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
953 = implicit_conversion (elttype, TREE_TYPE (val), val,
954 false, flags, complain);
958 if (sub->rank > rank)
960 if (sub->user_conv_p)
966 c = alloc_conversion (ck_aggr);
969 c->user_conv_p = user;
975 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
976 complex type, if such a conversion is possible. */
979 build_complex_conv (tree type, tree ctor, int flags,
980 tsubst_flags_t complain)
983 unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
984 tree elttype = TREE_TYPE (type);
989 enum conversion_rank rank = cr_exact;
994 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
997 = implicit_conversion (elttype, TREE_TYPE (val), val,
998 false, flags, complain);
1002 if (sub->rank > rank)
1004 if (sub->user_conv_p)
1010 c = alloc_conversion (ck_aggr);
1013 c->user_conv_p = user;
1019 /* Build a representation of the identity conversion from EXPR to
1020 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1023 build_identity_conv (tree type, tree expr)
1027 c = alloc_conversion (ck_identity);
1034 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1035 were multiple user-defined conversions to accomplish the job.
1036 Build a conversion that indicates that ambiguity. */
1039 build_ambiguous_conv (tree type, tree expr)
1043 c = alloc_conversion (ck_ambig);
1051 strip_top_quals (tree t)
1053 if (TREE_CODE (t) == ARRAY_TYPE)
1055 return cp_build_qualified_type (t, 0);
1058 /* Returns the standard conversion path (see [conv]) from type FROM to type
1059 TO, if any. For proper handling of null pointer constants, you must
1060 also pass the expression EXPR to convert from. If C_CAST_P is true,
1061 this conversion is coming from a C-style cast. */
1064 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
1067 enum tree_code fcode, tcode;
1069 bool fromref = false;
1072 to = non_reference (to);
1073 if (TREE_CODE (from) == REFERENCE_TYPE)
1076 from = TREE_TYPE (from);
1079 to = strip_top_quals (to);
1080 from = strip_top_quals (from);
1082 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
1083 && expr && type_unknown_p (expr))
1085 tsubst_flags_t tflags = tf_conv;
1086 expr = instantiate_type (to, expr, tflags);
1087 if (expr == error_mark_node)
1089 from = TREE_TYPE (expr);
1092 fcode = TREE_CODE (from);
1093 tcode = TREE_CODE (to);
1095 conv = build_identity_conv (from, expr);
1096 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
1098 from = type_decays_to (from);
1099 fcode = TREE_CODE (from);
1100 conv = build_conv (ck_lvalue, from, conv);
1102 else if (fromref || (expr && lvalue_p (expr)))
1107 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
1110 from = strip_top_quals (bitfield_type);
1111 fcode = TREE_CODE (from);
1114 conv = build_conv (ck_rvalue, from, conv);
1115 if (flags & LOOKUP_PREFER_RVALUE)
1116 conv->rvaluedness_matches_p = true;
1119 /* Allow conversion between `__complex__' data types. */
1120 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
1122 /* The standard conversion sequence to convert FROM to TO is
1123 the standard conversion sequence to perform componentwise
1125 conversion *part_conv = standard_conversion
1126 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
1130 conv = build_conv (part_conv->kind, to, conv);
1131 conv->rank = part_conv->rank;
1139 if (same_type_p (from, to))
1141 if (CLASS_TYPE_P (to) && conv->kind == ck_rvalue)
1142 conv->type = qualified_to;
1147 A null pointer constant can be converted to a pointer type; ... A
1148 null pointer constant of integral type can be converted to an
1149 rvalue of type std::nullptr_t. */
1150 if ((tcode == POINTER_TYPE || TYPE_PTRMEM_P (to)
1151 || NULLPTR_TYPE_P (to))
1152 && expr && null_ptr_cst_p (expr))
1153 conv = build_conv (ck_std, to, conv);
1154 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
1155 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
1157 /* For backwards brain damage compatibility, allow interconversion of
1158 pointers and integers with a pedwarn. */
1159 conv = build_conv (ck_std, to, conv);
1162 else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
1164 /* For backwards brain damage compatibility, allow interconversion of
1165 enums and integers with a pedwarn. */
1166 conv = build_conv (ck_std, to, conv);
1169 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
1170 || (TYPE_PTRDATAMEM_P (to) && TYPE_PTRDATAMEM_P (from)))
1175 if (tcode == POINTER_TYPE
1176 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
1179 else if (VOID_TYPE_P (TREE_TYPE (to))
1180 && !TYPE_PTRDATAMEM_P (from)
1181 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
1183 tree nfrom = TREE_TYPE (from);
1184 from = build_pointer_type
1185 (cp_build_qualified_type (void_type_node,
1186 cp_type_quals (nfrom)));
1187 conv = build_conv (ck_ptr, from, conv);
1189 else if (TYPE_PTRDATAMEM_P (from))
1191 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
1192 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
1194 if (DERIVED_FROM_P (fbase, tbase)
1195 && (same_type_ignoring_top_level_qualifiers_p
1196 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
1197 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
1199 from = build_ptrmem_type (tbase,
1200 TYPE_PTRMEM_POINTED_TO_TYPE (from));
1201 conv = build_conv (ck_pmem, from, conv);
1203 else if (!same_type_p (fbase, tbase))
1206 else if (CLASS_TYPE_P (TREE_TYPE (from))
1207 && CLASS_TYPE_P (TREE_TYPE (to))
1210 An rvalue of type "pointer to cv D," where D is a
1211 class type, can be converted to an rvalue of type
1212 "pointer to cv B," where B is a base class (clause
1213 _class.derived_) of D. If B is an inaccessible
1214 (clause _class.access_) or ambiguous
1215 (_class.member.lookup_) base class of D, a program
1216 that necessitates this conversion is ill-formed.
1217 Therefore, we use DERIVED_FROM_P, and do not check
1218 access or uniqueness. */
1219 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
1222 cp_build_qualified_type (TREE_TYPE (to),
1223 cp_type_quals (TREE_TYPE (from)));
1224 from = build_pointer_type (from);
1225 conv = build_conv (ck_ptr, from, conv);
1226 conv->base_p = true;
1229 if (tcode == POINTER_TYPE)
1231 to_pointee = TREE_TYPE (to);
1232 from_pointee = TREE_TYPE (from);
1236 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
1237 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
1240 if (same_type_p (from, to))
1242 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
1243 /* In a C-style cast, we ignore CV-qualification because we
1244 are allowed to perform a static_cast followed by a
1246 conv = build_conv (ck_qual, to, conv);
1247 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
1248 conv = build_conv (ck_qual, to, conv);
1249 else if (expr && string_conv_p (to, expr, 0))
1250 /* converting from string constant to char *. */
1251 conv = build_conv (ck_qual, to, conv);
1252 /* Allow conversions among compatible ObjC pointer types (base
1253 conversions have been already handled above). */
1254 else if (c_dialect_objc ()
1255 && objc_compare_types (to, from, -4, NULL_TREE))
1256 conv = build_conv (ck_ptr, to, conv);
1257 else if (ptr_reasonably_similar (to_pointee, from_pointee))
1259 conv = build_conv (ck_ptr, to, conv);
1267 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
1269 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
1270 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
1271 tree fbase = class_of_this_parm (fromfn);
1272 tree tbase = class_of_this_parm (tofn);
1274 if (!DERIVED_FROM_P (fbase, tbase)
1275 || !same_type_p (static_fn_type (fromfn),
1276 static_fn_type (tofn)))
1279 from = build_memfn_type (fromfn,
1281 cp_type_quals (tbase),
1282 type_memfn_rqual (tofn));
1283 from = build_ptrmemfunc_type (build_pointer_type (from));
1284 conv = build_conv (ck_pmem, from, conv);
1285 conv->base_p = true;
1287 else if (tcode == BOOLEAN_TYPE)
1291 An rvalue of arithmetic, unscoped enumeration, pointer, or
1292 pointer to member type can be converted to an rvalue of type
1293 bool. ... An rvalue of type std::nullptr_t can be converted
1294 to an rvalue of type bool; */
1295 if (ARITHMETIC_TYPE_P (from)
1296 || UNSCOPED_ENUM_P (from)
1297 || fcode == POINTER_TYPE
1298 || TYPE_PTRMEM_P (from)
1299 || NULLPTR_TYPE_P (from))
1301 conv = build_conv (ck_std, to, conv);
1302 if (fcode == POINTER_TYPE
1303 || TYPE_PTRDATAMEM_P (from)
1304 || (TYPE_PTRMEMFUNC_P (from)
1305 && conv->rank < cr_pbool)
1306 || NULLPTR_TYPE_P (from))
1307 conv->rank = cr_pbool;
1313 /* We don't check for ENUMERAL_TYPE here because there are no standard
1314 conversions to enum type. */
1315 /* As an extension, allow conversion to complex type. */
1316 else if (ARITHMETIC_TYPE_P (to))
1318 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
1319 || SCOPED_ENUM_P (from))
1321 conv = build_conv (ck_std, to, conv);
1323 /* Give this a better rank if it's a promotion. */
1324 if (same_type_p (to, type_promotes_to (from))
1325 && next_conversion (conv)->rank <= cr_promotion)
1326 conv->rank = cr_promotion;
1328 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
1329 && vector_types_convertible_p (from, to, false))
1330 return build_conv (ck_std, to, conv);
1331 else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
1332 && is_properly_derived_from (from, to))
1334 if (conv->kind == ck_rvalue)
1335 conv = next_conversion (conv);
1336 conv = build_conv (ck_base, to, conv);
1337 /* The derived-to-base conversion indicates the initialization
1338 of a parameter with base type from an object of a derived
1339 type. A temporary object is created to hold the result of
1340 the conversion unless we're binding directly to a reference. */
1341 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
1346 if (flags & LOOKUP_NO_NARROWING)
1347 conv->check_narrowing = true;
1352 /* Returns nonzero if T1 is reference-related to T2. */
1355 reference_related_p (tree t1, tree t2)
1357 if (t1 == error_mark_node || t2 == error_mark_node)
1360 t1 = TYPE_MAIN_VARIANT (t1);
1361 t2 = TYPE_MAIN_VARIANT (t2);
1365 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1366 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1368 return (same_type_p (t1, t2)
1369 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
1370 && DERIVED_FROM_P (t1, t2)));
1373 /* Returns nonzero if T1 is reference-compatible with T2. */
1376 reference_compatible_p (tree t1, tree t2)
1380 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1381 reference-related to T2 and cv1 is the same cv-qualification as,
1382 or greater cv-qualification than, cv2. */
1383 return (reference_related_p (t1, t2)
1384 && at_least_as_qualified_p (t1, t2));
1387 /* A reference of the indicated TYPE is being bound directly to the
1388 expression represented by the implicit conversion sequence CONV.
1389 Return a conversion sequence for this binding. */
1392 direct_reference_binding (tree type, conversion *conv)
1396 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1397 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1399 t = TREE_TYPE (type);
1403 When a parameter of reference type binds directly
1404 (_dcl.init.ref_) to an argument expression, the implicit
1405 conversion sequence is the identity conversion, unless the
1406 argument expression has a type that is a derived class of the
1407 parameter type, in which case the implicit conversion sequence is
1408 a derived-to-base Conversion.
1410 If the parameter binds directly to the result of applying a
1411 conversion function to the argument expression, the implicit
1412 conversion sequence is a user-defined conversion sequence
1413 (_over.ics.user_), with the second standard conversion sequence
1414 either an identity conversion or, if the conversion function
1415 returns an entity of a type that is a derived class of the
1416 parameter type, a derived-to-base conversion. */
1417 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1419 /* Represent the derived-to-base conversion. */
1420 conv = build_conv (ck_base, t, conv);
1421 /* We will actually be binding to the base-class subobject in
1422 the derived class, so we mark this conversion appropriately.
1423 That way, convert_like knows not to generate a temporary. */
1424 conv->need_temporary_p = false;
1426 return build_conv (ck_ref_bind, type, conv);
1429 /* Returns the conversion path from type FROM to reference type TO for
1430 purposes of reference binding. For lvalue binding, either pass a
1431 reference type to FROM or an lvalue expression to EXPR. If the
1432 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1433 the conversion returned. If C_CAST_P is true, this
1434 conversion is coming from a C-style cast. */
1437 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags,
1438 tsubst_flags_t complain)
1440 conversion *conv = NULL;
1441 tree to = TREE_TYPE (rto);
1446 cp_lvalue_kind gl_kind;
1449 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1451 expr = instantiate_type (to, expr, tf_none);
1452 if (expr == error_mark_node)
1454 from = TREE_TYPE (expr);
1457 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1459 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1460 conv = implicit_conversion (to, from, expr, c_cast_p,
1462 if (!CLASS_TYPE_P (to)
1463 && CONSTRUCTOR_NELTS (expr) == 1)
1465 expr = CONSTRUCTOR_ELT (expr, 0)->value;
1466 if (error_operand_p (expr))
1468 from = TREE_TYPE (expr);
1472 if (TREE_CODE (from) == REFERENCE_TYPE)
1474 from = TREE_TYPE (from);
1475 if (!TYPE_REF_IS_RVALUE (rfrom)
1476 || TREE_CODE (from) == FUNCTION_TYPE)
1477 gl_kind = clk_ordinary;
1479 gl_kind = clk_rvalueref;
1483 gl_kind = lvalue_kind (expr);
1484 if (gl_kind & clk_class)
1485 /* A class prvalue is not a glvalue. */
1490 is_lvalue = gl_kind && !(gl_kind & clk_rvalueref);
1493 if ((gl_kind & clk_bitfield) != 0)
1494 tfrom = unlowered_expr_type (expr);
1496 /* Figure out whether or not the types are reference-related and
1497 reference compatible. We have do do this after stripping
1498 references from FROM. */
1499 related_p = reference_related_p (to, tfrom);
1500 /* If this is a C cast, first convert to an appropriately qualified
1501 type, so that we can later do a const_cast to the desired type. */
1502 if (related_p && c_cast_p
1503 && !at_least_as_qualified_p (to, tfrom))
1504 to = cp_build_qualified_type (to, cp_type_quals (tfrom));
1505 compatible_p = reference_compatible_p (to, tfrom);
1507 /* Directly bind reference when target expression's type is compatible with
1508 the reference and expression is an lvalue. In DR391, the wording in
1509 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1510 const and rvalue references to rvalues of compatible class type.
1511 We should also do direct bindings for non-class xvalues. */
1514 || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1515 && !(flags & LOOKUP_NO_RVAL_BIND))
1516 || TYPE_REF_IS_RVALUE (rto))
1518 || (!(flags & LOOKUP_NO_TEMP_BIND)
1519 && (CLASS_TYPE_P (from)
1520 || TREE_CODE (from) == ARRAY_TYPE))))))
1524 If the initializer expression
1526 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1527 is reference-compatible with "cv2 T2,"
1529 the reference is bound directly to the initializer expression
1533 If the initializer expression is an rvalue, with T2 a class type,
1534 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1535 is bound to the object represented by the rvalue or to a sub-object
1536 within that object. */
1538 conv = build_identity_conv (tfrom, expr);
1539 conv = direct_reference_binding (rto, conv);
1541 if (flags & LOOKUP_PREFER_RVALUE)
1542 /* The top-level caller requested that we pretend that the lvalue
1543 be treated as an rvalue. */
1544 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1545 else if (TREE_CODE (rfrom) == REFERENCE_TYPE)
1546 /* Handle rvalue reference to function properly. */
1547 conv->rvaluedness_matches_p
1548 = (TYPE_REF_IS_RVALUE (rto) == TYPE_REF_IS_RVALUE (rfrom));
1550 conv->rvaluedness_matches_p
1551 = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1553 if ((gl_kind & clk_bitfield) != 0
1554 || ((gl_kind & clk_packed) != 0 && !TYPE_PACKED (to)))
1555 /* For the purposes of overload resolution, we ignore the fact
1556 this expression is a bitfield or packed field. (In particular,
1557 [over.ics.ref] says specifically that a function with a
1558 non-const reference parameter is viable even if the
1559 argument is a bitfield.)
1561 However, when we actually call the function we must create
1562 a temporary to which to bind the reference. If the
1563 reference is volatile, or isn't const, then we cannot make
1564 a temporary, so we just issue an error when the conversion
1566 conv->need_temporary_p = true;
1568 /* Don't allow binding of lvalues (other than function lvalues) to
1569 rvalue references. */
1570 if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1571 && TREE_CODE (to) != FUNCTION_TYPE
1572 && !(flags & LOOKUP_PREFER_RVALUE))
1577 /* [class.conv.fct] A conversion function is never used to convert a
1578 (possibly cv-qualified) object to the (possibly cv-qualified) same
1579 object type (or a reference to it), to a (possibly cv-qualified) base
1580 class of that type (or a reference to it).... */
1581 else if (CLASS_TYPE_P (from) && !related_p
1582 && !(flags & LOOKUP_NO_CONVERSION))
1586 If the initializer expression
1588 -- has a class type (i.e., T2 is a class type) can be
1589 implicitly converted to an lvalue of type "cv3 T3," where
1590 "cv1 T1" is reference-compatible with "cv3 T3". (this
1591 conversion is selected by enumerating the applicable
1592 conversion functions (_over.match.ref_) and choosing the
1593 best one through overload resolution. (_over.match_).
1595 the reference is bound to the lvalue result of the conversion
1596 in the second case. */
1597 z_candidate *cand = build_user_type_conversion_1 (rto, expr, flags,
1600 return cand->second_conv;
1603 /* From this point on, we conceptually need temporaries, even if we
1604 elide them. Only the cases above are "direct bindings". */
1605 if (flags & LOOKUP_NO_TEMP_BIND)
1610 When a parameter of reference type is not bound directly to an
1611 argument expression, the conversion sequence is the one required
1612 to convert the argument expression to the underlying type of the
1613 reference according to _over.best.ics_. Conceptually, this
1614 conversion sequence corresponds to copy-initializing a temporary
1615 of the underlying type with the argument expression. Any
1616 difference in top-level cv-qualification is subsumed by the
1617 initialization itself and does not constitute a conversion. */
1621 Otherwise, the reference shall be to a non-volatile const type.
1623 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1624 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1629 Otherwise, a temporary of type "cv1 T1" is created and
1630 initialized from the initializer expression using the rules for a
1631 non-reference copy initialization. If T1 is reference-related to
1632 T2, cv1 must be the same cv-qualification as, or greater
1633 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1634 if (related_p && !at_least_as_qualified_p (to, from))
1637 /* We're generating a temporary now, but don't bind any more in the
1638 conversion (specifically, don't slice the temporary returned by a
1639 conversion operator). */
1640 flags |= LOOKUP_NO_TEMP_BIND;
1642 /* Core issue 899: When [copy-]initializing a temporary to be bound
1643 to the first parameter of a copy constructor (12.8) called with
1644 a single argument in the context of direct-initialization,
1645 explicit conversion functions are also considered.
1647 So don't set LOOKUP_ONLYCONVERTING in that case. */
1648 if (!(flags & LOOKUP_COPY_PARM))
1649 flags |= LOOKUP_ONLYCONVERTING;
1652 conv = implicit_conversion (to, from, expr, c_cast_p,
1657 conv = build_conv (ck_ref_bind, rto, conv);
1658 /* This reference binding, unlike those above, requires the
1659 creation of a temporary. */
1660 conv->need_temporary_p = true;
1661 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1666 /* Returns the implicit conversion sequence (see [over.ics]) from type
1667 FROM to type TO. The optional expression EXPR may affect the
1668 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1669 true, this conversion is coming from a C-style cast. */
1672 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1673 int flags, tsubst_flags_t complain)
1677 if (from == error_mark_node || to == error_mark_node
1678 || expr == error_mark_node)
1681 /* Other flags only apply to the primary function in overload
1682 resolution, or after we've chosen one. */
1683 flags &= (LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION|LOOKUP_COPY_PARM
1684 |LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND|LOOKUP_PREFER_RVALUE
1685 |LOOKUP_NO_NARROWING|LOOKUP_PROTECT);
1687 /* FIXME: actually we don't want warnings either, but we can't just
1688 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1689 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1690 We really ought not to issue that warning until we've committed
1691 to that conversion. */
1692 complain &= ~tf_error;
1694 if (TREE_CODE (to) == REFERENCE_TYPE)
1695 conv = reference_binding (to, from, expr, c_cast_p, flags, complain);
1697 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1702 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1704 if (is_std_init_list (to))
1705 return build_list_conv (to, expr, flags, complain);
1707 /* As an extension, allow list-initialization of _Complex. */
1708 if (TREE_CODE (to) == COMPLEX_TYPE)
1710 conv = build_complex_conv (to, expr, flags, complain);
1715 /* Allow conversion from an initializer-list with one element to a
1717 if (SCALAR_TYPE_P (to))
1719 int nelts = CONSTRUCTOR_NELTS (expr);
1723 elt = build_value_init (to, tf_none);
1724 else if (nelts == 1)
1725 elt = CONSTRUCTOR_ELT (expr, 0)->value;
1727 elt = error_mark_node;
1729 conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1730 c_cast_p, flags, complain);
1733 conv->check_narrowing = true;
1734 if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1735 /* Too many levels of braces, i.e. '{{1}}'. */
1740 else if (TREE_CODE (to) == ARRAY_TYPE)
1741 return build_array_conv (to, expr, flags, complain);
1744 if (expr != NULL_TREE
1745 && (MAYBE_CLASS_TYPE_P (from)
1746 || MAYBE_CLASS_TYPE_P (to))
1747 && (flags & LOOKUP_NO_CONVERSION) == 0)
1749 struct z_candidate *cand;
1751 if (CLASS_TYPE_P (to)
1752 && BRACE_ENCLOSED_INITIALIZER_P (expr)
1753 && !CLASSTYPE_NON_AGGREGATE (complete_type (to)))
1754 return build_aggr_conv (to, expr, flags, complain);
1756 cand = build_user_type_conversion_1 (to, expr, flags, complain);
1758 conv = cand->second_conv;
1760 /* We used to try to bind a reference to a temporary here, but that
1761 is now handled after the recursive call to this function at the end
1762 of reference_binding. */
1769 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1770 functions. ARGS will not be changed until a single candidate is
1773 static struct z_candidate *
1774 add_candidate (struct z_candidate **candidates,
1775 tree fn, tree first_arg, const vec<tree, va_gc> *args,
1776 size_t num_convs, conversion **convs,
1777 tree access_path, tree conversion_path,
1778 int viable, struct rejection_reason *reason)
1780 struct z_candidate *cand = (struct z_candidate *)
1781 conversion_obstack_alloc (sizeof (struct z_candidate));
1784 cand->first_arg = first_arg;
1786 cand->convs = convs;
1787 cand->num_convs = num_convs;
1788 cand->access_path = access_path;
1789 cand->conversion_path = conversion_path;
1790 cand->viable = viable;
1791 cand->reason = reason;
1792 cand->next = *candidates;
1798 /* Return the number of remaining arguments in the parameter list
1799 beginning with ARG. */
1802 remaining_arguments (tree arg)
1806 for (n = 0; arg != NULL_TREE && arg != void_list_node;
1807 arg = TREE_CHAIN (arg))
1813 /* Create an overload candidate for the function or method FN called
1814 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1815 FLAGS is passed on to implicit_conversion.
1817 This does not change ARGS.
1819 CTYPE, if non-NULL, is the type we want to pretend this function
1820 comes from for purposes of overload resolution. */
1822 static struct z_candidate *
1823 add_function_candidate (struct z_candidate **candidates,
1824 tree fn, tree ctype, tree first_arg,
1825 const vec<tree, va_gc> *args, tree access_path,
1826 tree conversion_path, int flags,
1827 tsubst_flags_t complain)
1829 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1833 tree orig_first_arg = first_arg;
1836 struct rejection_reason *reason = NULL;
1838 /* At this point we should not see any functions which haven't been
1839 explicitly declared, except for friend functions which will have
1840 been found using argument dependent lookup. */
1841 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1843 /* The `this', `in_chrg' and VTT arguments to constructors are not
1844 considered in overload resolution. */
1845 if (DECL_CONSTRUCTOR_P (fn))
1847 parmlist = skip_artificial_parms_for (fn, parmlist);
1848 skip = num_artificial_parms_for (fn);
1849 if (skip > 0 && first_arg != NULL_TREE)
1852 first_arg = NULL_TREE;
1858 len = vec_safe_length (args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1859 convs = alloc_conversions (len);
1861 /* 13.3.2 - Viable functions [over.match.viable]
1862 First, to be a viable function, a candidate function shall have enough
1863 parameters to agree in number with the arguments in the list.
1865 We need to check this first; otherwise, checking the ICSes might cause
1866 us to produce an ill-formed template instantiation. */
1868 parmnode = parmlist;
1869 for (i = 0; i < len; ++i)
1871 if (parmnode == NULL_TREE || parmnode == void_list_node)
1873 parmnode = TREE_CHAIN (parmnode);
1876 if ((i < len && parmnode)
1877 || !sufficient_parms_p (parmnode))
1879 int remaining = remaining_arguments (parmnode);
1881 reason = arity_rejection (first_arg, i + remaining, len);
1883 /* When looking for a function from a subobject from an implicit
1884 copy/move constructor/operator=, don't consider anything that takes (a
1885 reference to) an unrelated type. See c++/44909 and core 1092. */
1886 else if (parmlist && (flags & LOOKUP_DEFAULTED))
1888 if (DECL_CONSTRUCTOR_P (fn))
1890 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1891 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1897 parmnode = chain_index (i-1, parmlist);
1898 if (!reference_related_p (non_reference (TREE_VALUE (parmnode)),
1903 /* This only applies at the top level. */
1904 flags &= ~LOOKUP_DEFAULTED;
1910 /* Second, for F to be a viable function, there shall exist for each
1911 argument an implicit conversion sequence that converts that argument
1912 to the corresponding parameter of F. */
1914 parmnode = parmlist;
1916 for (i = 0; i < len; ++i)
1918 tree argtype, to_type;
1923 if (parmnode == void_list_node)
1926 if (i == 0 && first_arg != NULL_TREE)
1929 arg = CONST_CAST_TREE (
1930 (*args)[i + skip - (first_arg != NULL_TREE ? 1 : 0)]);
1931 argtype = lvalue_type (arg);
1933 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1934 && ! DECL_CONSTRUCTOR_P (fn));
1938 tree parmtype = TREE_VALUE (parmnode);
1941 parmnode = TREE_CHAIN (parmnode);
1943 /* The type of the implicit object parameter ('this') for
1944 overload resolution is not always the same as for the
1945 function itself; conversion functions are considered to
1946 be members of the class being converted, and functions
1947 introduced by a using-declaration are considered to be
1948 members of the class that uses them.
1950 Since build_over_call ignores the ICS for the `this'
1951 parameter, we can just change the parm type. */
1952 if (ctype && is_this)
1954 parmtype = cp_build_qualified_type
1955 (ctype, cp_type_quals (TREE_TYPE (parmtype)));
1956 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn)))
1958 /* If the function has a ref-qualifier, the implicit
1959 object parameter has reference type. */
1960 bool rv = FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn));
1961 parmtype = cp_build_reference_type (parmtype, rv);
1962 if (TREE_CODE (arg) == CONVERT_EXPR
1963 && TYPE_PTR_P (TREE_TYPE (arg)))
1964 /* Strip conversion from reference to pointer. */
1965 arg = TREE_OPERAND (arg, 0);
1966 arg = build_fold_indirect_ref (arg);
1967 argtype = lvalue_type (arg);
1970 parmtype = build_pointer_type (parmtype);
1973 /* Core issue 899: When [copy-]initializing a temporary to be bound
1974 to the first parameter of a copy constructor (12.8) called with
1975 a single argument in the context of direct-initialization,
1976 explicit conversion functions are also considered.
1978 So set LOOKUP_COPY_PARM to let reference_binding know that
1979 it's being called in that context. We generalize the above
1980 to handle move constructors and template constructors as well;
1981 the standardese should soon be updated similarly. */
1982 if (ctype && i == 0 && (len-skip == 1)
1983 && DECL_CONSTRUCTOR_P (fn)
1984 && parmtype != error_mark_node
1985 && (same_type_ignoring_top_level_qualifiers_p
1986 (non_reference (parmtype), ctype)))
1988 if (!(flags & LOOKUP_ONLYCONVERTING))
1989 lflags |= LOOKUP_COPY_PARM;
1990 /* We allow user-defined conversions within init-lists, but
1991 don't list-initialize the copy parm, as that would mean
1992 using two levels of braces for the same type. */
1993 if ((flags & LOOKUP_LIST_INIT_CTOR)
1994 && BRACE_ENCLOSED_INITIALIZER_P (arg))
1995 lflags |= LOOKUP_NO_CONVERSION;
1998 lflags |= LOOKUP_ONLYCONVERTING;
2000 t = implicit_conversion (parmtype, argtype, arg,
2001 /*c_cast_p=*/false, lflags, complain);
2006 t = build_identity_conv (argtype, arg);
2007 t->ellipsis_p = true;
2018 reason = arg_conversion_rejection (first_arg, i, argtype, to_type);
2025 reason = bad_arg_conversion_rejection (first_arg, i, argtype, to_type);
2030 return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
2031 access_path, conversion_path, viable, reason);
2034 /* Create an overload candidate for the conversion function FN which will
2035 be invoked for expression OBJ, producing a pointer-to-function which
2036 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2037 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2038 passed on to implicit_conversion.
2040 Actually, we don't really care about FN; we care about the type it
2041 converts to. There may be multiple conversion functions that will
2042 convert to that type, and we rely on build_user_type_conversion_1 to
2043 choose the best one; so when we create our candidate, we record the type
2044 instead of the function. */
2046 static struct z_candidate *
2047 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
2048 tree first_arg, const vec<tree, va_gc> *arglist,
2049 tree access_path, tree conversion_path,
2050 tsubst_flags_t complain)
2052 tree totype = TREE_TYPE (TREE_TYPE (fn));
2053 int i, len, viable, flags;
2054 tree parmlist, parmnode;
2056 struct rejection_reason *reason;
2058 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
2059 parmlist = TREE_TYPE (parmlist);
2060 parmlist = TYPE_ARG_TYPES (parmlist);
2062 len = vec_safe_length (arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
2063 convs = alloc_conversions (len);
2064 parmnode = parmlist;
2066 flags = LOOKUP_IMPLICIT;
2069 /* Don't bother looking up the same type twice. */
2070 if (*candidates && (*candidates)->fn == totype)
2073 for (i = 0; i < len; ++i)
2075 tree arg, argtype, convert_type = NULL_TREE;
2080 else if (i == 1 && first_arg != NULL_TREE)
2083 arg = (*arglist)[i - (first_arg != NULL_TREE ? 1 : 0) - 1];
2084 argtype = lvalue_type (arg);
2088 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
2090 convert_type = totype;
2092 else if (parmnode == void_list_node)
2096 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
2097 /*c_cast_p=*/false, flags, complain);
2098 convert_type = TREE_VALUE (parmnode);
2102 t = build_identity_conv (argtype, arg);
2103 t->ellipsis_p = true;
2104 convert_type = argtype;
2114 reason = bad_arg_conversion_rejection (NULL_TREE, i, argtype, convert_type);
2121 parmnode = TREE_CHAIN (parmnode);
2125 || ! sufficient_parms_p (parmnode))
2127 int remaining = remaining_arguments (parmnode);
2129 reason = arity_rejection (NULL_TREE, i + remaining, len);
2132 return add_candidate (candidates, totype, first_arg, arglist, len, convs,
2133 access_path, conversion_path, viable, reason);
2137 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
2138 tree type1, tree type2, tree *args, tree *argtypes,
2139 int flags, tsubst_flags_t complain)
2146 struct rejection_reason *reason = NULL;
2151 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
2152 convs = alloc_conversions (num_convs);
2154 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2155 conversion ops are allowed. We handle that here by just checking for
2156 boolean_type_node because other operators don't ask for it. COND_EXPR
2157 also does contextual conversion to bool for the first operand, but we
2158 handle that in build_conditional_expr, and type1 here is operand 2. */
2159 if (type1 != boolean_type_node)
2160 flags |= LOOKUP_ONLYCONVERTING;
2162 for (i = 0; i < 2; ++i)
2167 t = implicit_conversion (types[i], argtypes[i], args[i],
2168 /*c_cast_p=*/false, flags, complain);
2172 /* We need something for printing the candidate. */
2173 t = build_identity_conv (types[i], NULL_TREE);
2174 reason = arg_conversion_rejection (NULL_TREE, i, argtypes[i],
2180 reason = bad_arg_conversion_rejection (NULL_TREE, i, argtypes[i],
2186 /* For COND_EXPR we rearranged the arguments; undo that now. */
2189 convs[2] = convs[1];
2190 convs[1] = convs[0];
2191 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
2192 /*c_cast_p=*/false, flags,
2199 reason = arg_conversion_rejection (NULL_TREE, 0, argtypes[2],
2204 add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
2206 /*access_path=*/NULL_TREE,
2207 /*conversion_path=*/NULL_TREE,
2212 is_complete (tree t)
2214 return COMPLETE_TYPE_P (complete_type (t));
2217 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2220 promoted_arithmetic_type_p (tree type)
2224 In this section, the term promoted integral type is used to refer
2225 to those integral types which are preserved by integral promotion
2226 (including e.g. int and long but excluding e.g. char).
2227 Similarly, the term promoted arithmetic type refers to promoted
2228 integral types plus floating types. */
2229 return ((CP_INTEGRAL_TYPE_P (type)
2230 && same_type_p (type_promotes_to (type), type))
2231 || TREE_CODE (type) == REAL_TYPE);
2234 /* Create any builtin operator overload candidates for the operator in
2235 question given the converted operand types TYPE1 and TYPE2. The other
2236 args are passed through from add_builtin_candidates to
2237 build_builtin_candidate.
2239 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2240 If CODE is requires candidates operands of the same type of the kind
2241 of which TYPE1 and TYPE2 are, we add both candidates
2242 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2245 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
2246 enum tree_code code2, tree fnname, tree type1,
2247 tree type2, tree *args, tree *argtypes, int flags,
2248 tsubst_flags_t complain)
2252 case POSTINCREMENT_EXPR:
2253 case POSTDECREMENT_EXPR:
2254 args[1] = integer_zero_node;
2255 type2 = integer_type_node;
2264 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2265 and VQ is either volatile or empty, there exist candidate operator
2266 functions of the form
2267 VQ T& operator++(VQ T&);
2268 T operator++(VQ T&, int);
2269 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2270 type other than bool, and VQ is either volatile or empty, there exist
2271 candidate operator functions of the form
2272 VQ T& operator--(VQ T&);
2273 T operator--(VQ T&, int);
2274 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2275 complete object type, and VQ is either volatile or empty, there exist
2276 candidate operator functions of the form
2277 T*VQ& operator++(T*VQ&);
2278 T*VQ& operator--(T*VQ&);
2279 T* operator++(T*VQ&, int);
2280 T* operator--(T*VQ&, int); */
2282 case POSTDECREMENT_EXPR:
2283 case PREDECREMENT_EXPR:
2284 if (TREE_CODE (type1) == BOOLEAN_TYPE)
2286 case POSTINCREMENT_EXPR:
2287 case PREINCREMENT_EXPR:
2288 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
2290 type1 = build_reference_type (type1);
2295 /* 7 For every cv-qualified or cv-unqualified object type T, there
2296 exist candidate operator functions of the form
2300 8 For every function type T, there exist candidate operator functions of
2302 T& operator*(T*); */
2305 if (TREE_CODE (type1) == POINTER_TYPE
2306 && !uses_template_parms (TREE_TYPE (type1))
2307 && (TYPE_PTROB_P (type1)
2308 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
2312 /* 9 For every type T, there exist candidate operator functions of the form
2315 10For every promoted arithmetic type T, there exist candidate operator
2316 functions of the form
2320 case UNARY_PLUS_EXPR: /* unary + */
2321 if (TREE_CODE (type1) == POINTER_TYPE)
2324 if (ARITHMETIC_TYPE_P (type1))
2328 /* 11For every promoted integral type T, there exist candidate operator
2329 functions of the form
2333 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
2337 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2338 is the same type as C2 or is a derived class of C2, T is a complete
2339 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2340 there exist candidate operator functions of the form
2341 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2342 where CV12 is the union of CV1 and CV2. */
2345 if (TREE_CODE (type1) == POINTER_TYPE
2346 && TYPE_PTRMEM_P (type2))
2348 tree c1 = TREE_TYPE (type1);
2349 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
2351 if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
2352 && (TYPE_PTRMEMFUNC_P (type2)
2353 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
2358 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2359 didate operator functions of the form
2364 bool operator<(L, R);
2365 bool operator>(L, R);
2366 bool operator<=(L, R);
2367 bool operator>=(L, R);
2368 bool operator==(L, R);
2369 bool operator!=(L, R);
2370 where LR is the result of the usual arithmetic conversions between
2373 14For every pair of types T and I, where T is a cv-qualified or cv-
2374 unqualified complete object type and I is a promoted integral type,
2375 there exist candidate operator functions of the form
2376 T* operator+(T*, I);
2377 T& operator[](T*, I);
2378 T* operator-(T*, I);
2379 T* operator+(I, T*);
2380 T& operator[](I, T*);
2382 15For every T, where T is a pointer to complete object type, there exist
2383 candidate operator functions of the form112)
2384 ptrdiff_t operator-(T, T);
2386 16For every pointer or enumeration type T, there exist candidate operator
2387 functions of the form
2388 bool operator<(T, T);
2389 bool operator>(T, T);
2390 bool operator<=(T, T);
2391 bool operator>=(T, T);
2392 bool operator==(T, T);
2393 bool operator!=(T, T);
2395 17For every pointer to member type T, there exist candidate operator
2396 functions of the form
2397 bool operator==(T, T);
2398 bool operator!=(T, T); */
2401 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2403 if (TYPE_PTROB_P (type1)
2404 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2406 type2 = ptrdiff_type_node;
2410 case TRUNC_DIV_EXPR:
2411 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2417 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2418 || (TYPE_PTRDATAMEM_P (type1) && TYPE_PTRDATAMEM_P (type2)))
2420 if (TYPE_PTRMEM_P (type1) && null_ptr_cst_p (args[1]))
2425 if (TYPE_PTRMEM_P (type2) && null_ptr_cst_p (args[0]))
2437 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2439 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2441 if (TREE_CODE (type1) == ENUMERAL_TYPE
2442 && TREE_CODE (type2) == ENUMERAL_TYPE)
2444 if (TYPE_PTR_P (type1)
2445 && null_ptr_cst_p (args[1])
2446 && !uses_template_parms (type1))
2451 if (null_ptr_cst_p (args[0])
2452 && TYPE_PTR_P (type2)
2453 && !uses_template_parms (type2))
2461 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2464 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2466 type1 = ptrdiff_type_node;
2469 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2471 type2 = ptrdiff_type_node;
2476 /* 18For every pair of promoted integral types L and R, there exist candi-
2477 date operator functions of the form
2484 where LR is the result of the usual arithmetic conversions between
2487 case TRUNC_MOD_EXPR:
2493 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2497 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2498 type, VQ is either volatile or empty, and R is a promoted arithmetic
2499 type, there exist candidate operator functions of the form
2500 VQ L& operator=(VQ L&, R);
2501 VQ L& operator*=(VQ L&, R);
2502 VQ L& operator/=(VQ L&, R);
2503 VQ L& operator+=(VQ L&, R);
2504 VQ L& operator-=(VQ L&, R);
2506 20For every pair T, VQ), where T is any type and VQ is either volatile
2507 or empty, there exist candidate operator functions of the form
2508 T*VQ& operator=(T*VQ&, T*);
2510 21For every pair T, VQ), where T is a pointer to member type and VQ is
2511 either volatile or empty, there exist candidate operator functions of
2513 VQ T& operator=(VQ T&, T);
2515 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2516 unqualified complete object type, VQ is either volatile or empty, and
2517 I is a promoted integral type, there exist candidate operator func-
2519 T*VQ& operator+=(T*VQ&, I);
2520 T*VQ& operator-=(T*VQ&, I);
2522 23For every triple L, VQ, R), where L is an integral or enumeration
2523 type, VQ is either volatile or empty, and R is a promoted integral
2524 type, there exist candidate operator functions of the form
2526 VQ L& operator%=(VQ L&, R);
2527 VQ L& operator<<=(VQ L&, R);
2528 VQ L& operator>>=(VQ L&, R);
2529 VQ L& operator&=(VQ L&, R);
2530 VQ L& operator^=(VQ L&, R);
2531 VQ L& operator|=(VQ L&, R); */
2538 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2540 type2 = ptrdiff_type_node;
2544 case TRUNC_DIV_EXPR:
2545 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2549 case TRUNC_MOD_EXPR:
2555 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2560 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2562 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2563 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2564 || (TYPE_PTRDATAMEM_P (type1) && TYPE_PTRDATAMEM_P (type2))
2565 || ((TYPE_PTRMEMFUNC_P (type1)
2566 || TREE_CODE (type1) == POINTER_TYPE)
2567 && null_ptr_cst_p (args[1])))
2577 type1 = build_reference_type (type1);
2583 For every pair of promoted arithmetic types L and R, there
2584 exist candidate operator functions of the form
2586 LR operator?(bool, L, R);
2588 where LR is the result of the usual arithmetic conversions
2589 between types L and R.
2591 For every type T, where T is a pointer or pointer-to-member
2592 type, there exist candidate operator functions of the form T
2593 operator?(bool, T, T); */
2595 if (promoted_arithmetic_type_p (type1)
2596 && promoted_arithmetic_type_p (type2))
2600 /* Otherwise, the types should be pointers. */
2601 if (!TYPE_PTR_OR_PTRMEM_P (type1) || !TYPE_PTR_OR_PTRMEM_P (type2))
2604 /* We don't check that the two types are the same; the logic
2605 below will actually create two candidates; one in which both
2606 parameter types are TYPE1, and one in which both parameter
2612 if (ARITHMETIC_TYPE_P (type1))
2620 /* If we're dealing with two pointer types or two enumeral types,
2621 we need candidates for both of them. */
2622 if (type2 && !same_type_p (type1, type2)
2623 && TREE_CODE (type1) == TREE_CODE (type2)
2624 && (TREE_CODE (type1) == REFERENCE_TYPE
2625 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2626 || (TYPE_PTRDATAMEM_P (type1) && TYPE_PTRDATAMEM_P (type2))
2627 || TYPE_PTRMEMFUNC_P (type1)
2628 || MAYBE_CLASS_TYPE_P (type1)
2629 || TREE_CODE (type1) == ENUMERAL_TYPE))
2631 if (TYPE_PTR_OR_PTRMEM_P (type1))
2633 tree cptype = composite_pointer_type (type1, type2,
2638 if (cptype != error_mark_node)
2640 build_builtin_candidate
2641 (candidates, fnname, cptype, cptype, args, argtypes,
2647 build_builtin_candidate
2648 (candidates, fnname, type1, type1, args, argtypes, flags, complain);
2649 build_builtin_candidate
2650 (candidates, fnname, type2, type2, args, argtypes, flags, complain);
2654 build_builtin_candidate
2655 (candidates, fnname, type1, type2, args, argtypes, flags, complain);
2659 type_decays_to (tree type)
2661 if (TREE_CODE (type) == ARRAY_TYPE)
2662 return build_pointer_type (TREE_TYPE (type));
2663 if (TREE_CODE (type) == FUNCTION_TYPE)
2664 return build_pointer_type (type);
2668 /* There are three conditions of builtin candidates:
2670 1) bool-taking candidates. These are the same regardless of the input.
2671 2) pointer-pair taking candidates. These are generated for each type
2672 one of the input types converts to.
2673 3) arithmetic candidates. According to the standard, we should generate
2674 all of these, but I'm trying not to...
2676 Here we generate a superset of the possible candidates for this particular
2677 case. That is a subset of the full set the standard defines, plus some
2678 other cases which the standard disallows. add_builtin_candidate will
2679 filter out the invalid set. */
2682 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2683 enum tree_code code2, tree fnname, tree *args,
2684 int flags, tsubst_flags_t complain)
2688 tree type, argtypes[3], t;
2689 /* TYPES[i] is the set of possible builtin-operator parameter types
2690 we will consider for the Ith argument. */
2691 vec<tree, va_gc> *types[2];
2694 for (i = 0; i < 3; ++i)
2697 argtypes[i] = unlowered_expr_type (args[i]);
2699 argtypes[i] = NULL_TREE;
2704 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2705 and VQ is either volatile or empty, there exist candidate operator
2706 functions of the form
2707 VQ T& operator++(VQ T&); */
2709 case POSTINCREMENT_EXPR:
2710 case PREINCREMENT_EXPR:
2711 case POSTDECREMENT_EXPR:
2712 case PREDECREMENT_EXPR:
2717 /* 24There also exist candidate operator functions of the form
2718 bool operator!(bool);
2719 bool operator&&(bool, bool);
2720 bool operator||(bool, bool); */
2722 case TRUTH_NOT_EXPR:
2723 build_builtin_candidate
2724 (candidates, fnname, boolean_type_node,
2725 NULL_TREE, args, argtypes, flags, complain);
2728 case TRUTH_ORIF_EXPR:
2729 case TRUTH_ANDIF_EXPR:
2730 build_builtin_candidate
2731 (candidates, fnname, boolean_type_node,
2732 boolean_type_node, args, argtypes, flags, complain);
2754 types[0] = make_tree_vector ();
2755 types[1] = make_tree_vector ();
2757 for (i = 0; i < 2; ++i)
2761 else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2765 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2768 convs = lookup_conversions (argtypes[i]);
2770 if (code == COND_EXPR)
2772 if (real_lvalue_p (args[i]))
2773 vec_safe_push (types[i], build_reference_type (argtypes[i]));
2775 vec_safe_push (types[i], TYPE_MAIN_VARIANT (argtypes[i]));
2781 for (; convs; convs = TREE_CHAIN (convs))
2783 type = TREE_TYPE (convs);
2786 && (TREE_CODE (type) != REFERENCE_TYPE
2787 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2790 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2791 vec_safe_push (types[i], type);
2793 type = non_reference (type);
2794 if (i != 0 || ! ref1)
2796 type = cv_unqualified (type_decays_to (type));
2797 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2798 vec_safe_push (types[i], type);
2799 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2800 type = type_promotes_to (type);
2803 if (! vec_member (type, types[i]))
2804 vec_safe_push (types[i], type);
2809 if (code == COND_EXPR && real_lvalue_p (args[i]))
2810 vec_safe_push (types[i], build_reference_type (argtypes[i]));
2811 type = non_reference (argtypes[i]);
2812 if (i != 0 || ! ref1)
2814 type = cv_unqualified (type_decays_to (type));
2815 if (enum_p && UNSCOPED_ENUM_P (type))
2816 vec_safe_push (types[i], type);
2817 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2818 type = type_promotes_to (type);
2820 vec_safe_push (types[i], type);
2824 /* Run through the possible parameter types of both arguments,
2825 creating candidates with those parameter types. */
2826 FOR_EACH_VEC_ELT_REVERSE (*(types[0]), ix, t)
2831 if (!types[1]->is_empty ())
2832 FOR_EACH_VEC_ELT_REVERSE (*(types[1]), jx, u)
2833 add_builtin_candidate
2834 (candidates, code, code2, fnname, t,
2835 u, args, argtypes, flags, complain);
2837 add_builtin_candidate
2838 (candidates, code, code2, fnname, t,
2839 NULL_TREE, args, argtypes, flags, complain);
2842 release_tree_vector (types[0]);
2843 release_tree_vector (types[1]);
2847 /* If TMPL can be successfully instantiated as indicated by
2848 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2850 TMPL is the template. EXPLICIT_TARGS are any explicit template
2851 arguments. ARGLIST is the arguments provided at the call-site.
2852 This does not change ARGLIST. The RETURN_TYPE is the desired type
2853 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2854 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2855 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2857 static struct z_candidate*
2858 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2859 tree ctype, tree explicit_targs, tree first_arg,
2860 const vec<tree, va_gc> *arglist, tree return_type,
2861 tree access_path, tree conversion_path,
2862 int flags, tree obj, unification_kind_t strict,
2863 tsubst_flags_t complain)
2865 int ntparms = DECL_NTPARMS (tmpl);
2866 tree targs = make_tree_vec (ntparms);
2867 unsigned int len = vec_safe_length (arglist);
2868 unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2869 unsigned int skip_without_in_chrg = 0;
2870 tree first_arg_without_in_chrg = first_arg;
2871 tree *args_without_in_chrg;
2872 unsigned int nargs_without_in_chrg;
2873 unsigned int ia, ix;
2875 struct z_candidate *cand;
2877 struct rejection_reason *reason = NULL;
2880 /* We don't do deduction on the in-charge parameter, the VTT
2881 parameter or 'this'. */
2882 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2884 if (first_arg_without_in_chrg != NULL_TREE)
2885 first_arg_without_in_chrg = NULL_TREE;
2887 ++skip_without_in_chrg;
2890 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2891 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2892 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2894 if (first_arg_without_in_chrg != NULL_TREE)
2895 first_arg_without_in_chrg = NULL_TREE;
2897 ++skip_without_in_chrg;
2900 if (len < skip_without_in_chrg)
2903 nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2904 + (len - skip_without_in_chrg));
2905 args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2907 if (first_arg_without_in_chrg != NULL_TREE)
2909 args_without_in_chrg[ia] = first_arg_without_in_chrg;
2912 for (ix = skip_without_in_chrg;
2913 vec_safe_iterate (arglist, ix, &arg);
2916 args_without_in_chrg[ia] = arg;
2919 gcc_assert (ia == nargs_without_in_chrg);
2921 errs = errorcount+sorrycount;
2922 fn = fn_type_unification (tmpl, explicit_targs, targs,
2923 args_without_in_chrg,
2924 nargs_without_in_chrg,
2925 return_type, strict, flags, false);
2927 if (fn == error_mark_node)
2929 /* Don't repeat unification later if it already resulted in errors. */
2930 if (errorcount+sorrycount == errs)
2931 reason = template_unification_rejection (tmpl, explicit_targs,
2932 targs, args_without_in_chrg,
2933 nargs_without_in_chrg,
2934 return_type, strict, flags);
2936 reason = template_unification_error_rejection ();
2942 A member function template is never instantiated to perform the
2943 copy of a class object to an object of its class type.
2945 It's a little unclear what this means; the standard explicitly
2946 does allow a template to be used to copy a class. For example,
2951 template <class T> A(const T&);
2954 void g () { A a (f ()); }
2956 the member template will be used to make the copy. The section
2957 quoted above appears in the paragraph that forbids constructors
2958 whose only parameter is (a possibly cv-qualified variant of) the
2959 class type, and a logical interpretation is that the intent was
2960 to forbid the instantiation of member templates which would then
2962 if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2964 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2965 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2968 reason = invalid_copy_with_fn_template_rejection ();
2973 if (obj != NULL_TREE)
2974 /* Aha, this is a conversion function. */
2975 cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2976 access_path, conversion_path, complain);
2978 cand = add_function_candidate (candidates, fn, ctype,
2979 first_arg, arglist, access_path,
2980 conversion_path, flags, complain);
2981 if (DECL_TI_TEMPLATE (fn) != tmpl)
2982 /* This situation can occur if a member template of a template
2983 class is specialized. Then, instantiate_template might return
2984 an instantiation of the specialization, in which case the
2985 DECL_TI_TEMPLATE field will point at the original
2986 specialization. For example:
2988 template <class T> struct S { template <class U> void f(U);
2989 template <> void f(int) {}; };
2993 Here, TMPL will be template <class U> S<double>::f(U).
2994 And, instantiate template will give us the specialization
2995 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2996 for this will point at template <class T> template <> S<T>::f(int),
2997 so that we can find the definition. For the purposes of
2998 overload resolution, however, we want the original TMPL. */
2999 cand->template_decl = build_template_info (tmpl, targs);
3001 cand->template_decl = DECL_TEMPLATE_INFO (fn);
3002 cand->explicit_targs = explicit_targs;
3006 return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
3007 access_path, conversion_path, 0, reason);
3011 static struct z_candidate *
3012 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
3013 tree explicit_targs, tree first_arg,
3014 const vec<tree, va_gc> *arglist, tree return_type,
3015 tree access_path, tree conversion_path, int flags,
3016 unification_kind_t strict, tsubst_flags_t complain)
3019 add_template_candidate_real (candidates, tmpl, ctype,
3020 explicit_targs, first_arg, arglist,
3021 return_type, access_path, conversion_path,
3022 flags, NULL_TREE, strict, complain);
3026 static struct z_candidate *
3027 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
3028 tree obj, tree first_arg,
3029 const vec<tree, va_gc> *arglist,
3030 tree return_type, tree access_path,
3031 tree conversion_path, tsubst_flags_t complain)
3034 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
3035 first_arg, arglist, return_type, access_path,
3036 conversion_path, 0, obj, DEDUCE_CONV,
3040 /* The CANDS are the set of candidates that were considered for
3041 overload resolution. Return the set of viable candidates, or CANDS
3042 if none are viable. If any of the candidates were viable, set
3043 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3044 considered viable only if it is strictly viable. */
3046 static struct z_candidate*
3047 splice_viable (struct z_candidate *cands,
3051 struct z_candidate *viable;
3052 struct z_candidate **last_viable;
3053 struct z_candidate **cand;
3055 /* Be strict inside templates, since build_over_call won't actually
3056 do the conversions to get pedwarns. */
3057 if (processing_template_decl)
3061 last_viable = &viable;
3062 *any_viable_p = false;
3067 struct z_candidate *c = *cand;
3068 if (strict_p ? c->viable == 1 : c->viable)
3073 last_viable = &c->next;
3074 *any_viable_p = true;
3080 return viable ? viable : cands;
3084 any_strictly_viable (struct z_candidate *cands)
3086 for (; cands; cands = cands->next)
3087 if (cands->viable == 1)
3092 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3093 words, it is about to become the "this" pointer for a member
3094 function call. Take the address of the object. */
3097 build_this (tree obj)
3099 /* In a template, we are only concerned about the type of the
3100 expression, so we can take a shortcut. */
3101 if (processing_template_decl)
3102 return build_address (obj);
3104 return cp_build_addr_expr (obj, tf_warning_or_error);
3107 /* Returns true iff functions are equivalent. Equivalent functions are
3108 not '==' only if one is a function-local extern function or if
3109 both are extern "C". */
3112 equal_functions (tree fn1, tree fn2)
3114 if (TREE_CODE (fn1) != TREE_CODE (fn2))
3116 if (TREE_CODE (fn1) == TEMPLATE_DECL)
3118 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
3119 || DECL_EXTERN_C_FUNCTION_P (fn1))
3120 return decls_match (fn1, fn2);
3124 /* Print information about a candidate being rejected due to INFO. */
3127 print_conversion_rejection (location_t loc, struct conversion_info *info)
3129 if (info->n_arg == -1)
3130 /* Conversion of implicit `this' argument failed. */
3131 inform (loc, " no known conversion for implicit "
3132 "%<this%> parameter from %qT to %qT",
3133 info->from_type, info->to_type);
3135 inform (loc, " no known conversion for argument %d from %qT to %qT",
3136 info->n_arg+1, info->from_type, info->to_type);
3139 /* Print information about a candidate with WANT parameters and we found
3143 print_arity_information (location_t loc, unsigned int have, unsigned int want)
3145 inform_n (loc, want,
3146 " candidate expects %d argument, %d provided",
3147 " candidate expects %d arguments, %d provided",
3151 /* Print information about one overload candidate CANDIDATE. MSGSTR
3152 is the text to print before the candidate itself.
3154 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3155 to have been run through gettext by the caller. This wart makes
3156 life simpler in print_z_candidates and for the translators. */
3159 print_z_candidate (location_t loc, const char *msgstr,
3160 struct z_candidate *candidate)
3162 const char *msg = (msgstr == NULL
3164 : ACONCAT ((msgstr, " ", NULL)));
3165 location_t cloc = location_of (candidate->fn);
3167 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
3170 if (candidate->num_convs == 3)
3171 inform (cloc, "%s%D(%T, %T, %T) <built-in>", msg, candidate->fn,
3172 candidate->convs[0]->type,
3173 candidate->convs[1]->type,
3174 candidate->convs[2]->type);
3175 else if (candidate->num_convs == 2)
3176 inform (cloc, "%s%D(%T, %T) <built-in>", msg, candidate->fn,
3177 candidate->convs[0]->type,
3178 candidate->convs[1]->type);
3180 inform (cloc, "%s%D(%T) <built-in>", msg, candidate->fn,
3181 candidate->convs[0]->type);
3183 else if (TYPE_P (candidate->fn))
3184 inform (cloc, "%s%T <conversion>", msg, candidate->fn);
3185 else if (candidate->viable == -1)
3186 inform (cloc, "%s%#D <near match>", msg, candidate->fn);
3187 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
3188 inform (cloc, "%s%#D <deleted>", msg, candidate->fn);
3190 inform (cloc, "%s%#D", msg, candidate->fn);
3191 /* Give the user some information about why this candidate failed. */
3192 if (candidate->reason != NULL)
3194 struct rejection_reason *r = candidate->reason;
3199 print_arity_information (cloc, r->u.arity.actual,
3200 r->u.arity.expected);
3202 case rr_arg_conversion:
3203 print_conversion_rejection (cloc, &r->u.conversion);
3205 case rr_bad_arg_conversion:
3206 print_conversion_rejection (cloc, &r->u.bad_conversion);
3208 case rr_explicit_conversion:
3209 inform (cloc, " return type %qT of explicit conversion function "
3210 "cannot be converted to %qT with a qualification "
3211 "conversion", r->u.conversion.from_type,
3212 r->u.conversion.to_type);
3214 case rr_template_conversion:
3215 inform (cloc, " conversion from return type %qT of template "
3216 "conversion function specialization to %qT is not an "
3217 "exact match", r->u.conversion.from_type,
3218 r->u.conversion.to_type);
3220 case rr_template_unification:
3221 /* We use template_unification_error_rejection if unification caused
3222 actual non-SFINAE errors, in which case we don't need to repeat
3224 if (r->u.template_unification.tmpl == NULL_TREE)
3226 inform (cloc, " substitution of deduced template arguments "
3227 "resulted in errors seen above");
3230 /* Re-run template unification with diagnostics. */
3231 inform (cloc, " template argument deduction/substitution failed:");
3232 fn_type_unification (r->u.template_unification.tmpl,
3233 r->u.template_unification.explicit_targs,
3235 (r->u.template_unification.num_targs)),
3236 r->u.template_unification.args,
3237 r->u.template_unification.nargs,
3238 r->u.template_unification.return_type,
3239 r->u.template_unification.strict,
3240 r->u.template_unification.flags,
3243 case rr_invalid_copy:
3245 " a constructor taking a single argument of its own "
3246 "class type is invalid");
3250 /* This candidate didn't have any issues or we failed to
3251 handle a particular code. Either way... */
3258 print_z_candidates (location_t loc, struct z_candidate *candidates)
3260 struct z_candidate *cand1;
3261 struct z_candidate **cand2;
3267 /* Remove non-viable deleted candidates. */
3269 for (cand2 = &cand1; *cand2; )
3271 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
3272 && !(*cand2)->viable
3273 && DECL_DELETED_FN ((*cand2)->fn))
3274 *cand2 = (*cand2)->next;
3276 cand2 = &(*cand2)->next;
3278 /* ...if there are any non-deleted ones. */
3282 /* There may be duplicates in the set of candidates. We put off
3283 checking this condition as long as possible, since we have no way
3284 to eliminate duplicates from a set of functions in less than n^2
3285 time. Now we are about to emit an error message, so it is more
3286 permissible to go slowly. */
3287 for (cand1 = candidates; cand1; cand1 = cand1->next)
3289 tree fn = cand1->fn;
3290 /* Skip builtin candidates and conversion functions. */
3293 cand2 = &cand1->next;
3296 if (DECL_P ((*cand2)->fn)
3297 && equal_functions (fn, (*cand2)->fn))
3298 *cand2 = (*cand2)->next;
3300 cand2 = &(*cand2)->next;
3304 for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next)
3307 inform_n (loc, n_candidates, "candidate is:", "candidates are:");
3308 for (; candidates; candidates = candidates->next)
3309 print_z_candidate (loc, NULL, candidates);
3312 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3313 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3314 the result of the conversion function to convert it to the final
3315 desired type. Merge the two sequences into a single sequence,
3316 and return the merged sequence. */
3319 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
3322 bool bad = user_seq->bad_p;
3324 gcc_assert (user_seq->kind == ck_user);
3326 /* Find the end of the second conversion sequence. */
3327 for (t = &std_seq; (*t)->kind != ck_identity; t = &((*t)->u.next))
3329 /* The entire sequence is a user-conversion sequence. */
3330 (*t)->user_conv_p = true;
3335 /* Replace the identity conversion with the user conversion
3342 /* Handle overload resolution for initializing an object of class type from
3343 an initializer list. First we look for a suitable constructor that
3344 takes a std::initializer_list; if we don't find one, we then look for a
3345 non-list constructor.
3347 Parameters are as for add_candidates, except that the arguments are in
3348 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3349 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3352 add_list_candidates (tree fns, tree first_arg,
3353 tree init_list, tree totype,
3354 tree explicit_targs, bool template_only,
3355 tree conversion_path, tree access_path,
3357 struct z_candidate **candidates,
3358 tsubst_flags_t complain)
3360 vec<tree, va_gc> *args;
3362 gcc_assert (*candidates == NULL);
3364 /* We're looking for a ctor for list-initialization. */
3365 flags |= LOOKUP_LIST_INIT_CTOR;
3366 /* And we don't allow narrowing conversions. We also use this flag to
3367 avoid the copy constructor call for copy-list-initialization. */
3368 flags |= LOOKUP_NO_NARROWING;
3370 /* Always use the default constructor if the list is empty (DR 990). */
3371 if (CONSTRUCTOR_NELTS (init_list) == 0
3372 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
3374 /* If the class has a list ctor, try passing the list as a single
3375 argument first, but only consider list ctors. */
3376 else if (TYPE_HAS_LIST_CTOR (totype))
3378 flags |= LOOKUP_LIST_ONLY;
3379 args = make_tree_vector_single (init_list);
3380 add_candidates (fns, first_arg, args, NULL_TREE,
3381 explicit_targs, template_only, conversion_path,
3382 access_path, flags, candidates, complain);
3383 if (any_strictly_viable (*candidates))
3387 args = ctor_to_vec (init_list);
3389 /* We aren't looking for list-ctors anymore. */
3390 flags &= ~LOOKUP_LIST_ONLY;
3391 /* We allow more user-defined conversions within an init-list. */
3392 flags &= ~LOOKUP_NO_CONVERSION;
3394 add_candidates (fns, first_arg, args, NULL_TREE,
3395 explicit_targs, template_only, conversion_path,
3396 access_path, flags, candidates, complain);
3399 /* Returns the best overload candidate to perform the requested
3400 conversion. This function is used for three the overloading situations
3401 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3402 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3403 per [dcl.init.ref], so we ignore temporary bindings. */
3405 static struct z_candidate *
3406 build_user_type_conversion_1 (tree totype, tree expr, int flags,
3407 tsubst_flags_t complain)
3409 struct z_candidate *candidates, *cand;
3411 tree ctors = NULL_TREE;
3412 tree conv_fns = NULL_TREE;
3413 conversion *conv = NULL;
3414 tree first_arg = NULL_TREE;
3415 vec<tree, va_gc> *args = NULL;
3422 fromtype = TREE_TYPE (expr);
3424 /* We represent conversion within a hierarchy using RVALUE_CONV and
3425 BASE_CONV, as specified by [over.best.ics]; these become plain
3426 constructor calls, as specified in [dcl.init]. */
3427 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
3428 || !DERIVED_FROM_P (totype, fromtype));
3430 if (MAYBE_CLASS_TYPE_P (totype))
3431 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3432 creating a garbage BASELINK; constructors can't be inherited. */
3433 ctors = lookup_fnfields_slot (totype, complete_ctor_identifier);
3435 if (MAYBE_CLASS_TYPE_P (fromtype))
3437 tree to_nonref = non_reference (totype);
3438 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
3439 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
3440 && DERIVED_FROM_P (to_nonref, fromtype)))
3442 /* [class.conv.fct] A conversion function is never used to
3443 convert a (possibly cv-qualified) object to the (possibly
3444 cv-qualified) same object type (or a reference to it), to a
3445 (possibly cv-qualified) base class of that type (or a
3446 reference to it)... */
3449 conv_fns = lookup_conversions (fromtype);
3453 flags |= LOOKUP_NO_CONVERSION;
3454 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3455 flags |= LOOKUP_NO_NARROWING;
3457 /* It's OK to bind a temporary for converting constructor arguments, but
3458 not in converting the return value of a conversion operator. */
3459 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
3460 flags &= ~LOOKUP_NO_TEMP_BIND;
3464 int ctorflags = flags;
3466 first_arg = build_int_cst (build_pointer_type (totype), 0);
3468 /* We should never try to call the abstract or base constructor
3470 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
3471 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
3473 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3475 /* List-initialization. */
3476 add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
3477 false, TYPE_BINFO (totype), TYPE_BINFO (totype),
3478 ctorflags, &candidates, complain);
3482 args = make_tree_vector_single (expr);
3483 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
3484 TYPE_BINFO (totype), TYPE_BINFO (totype),
3485 ctorflags, &candidates, complain);
3488 for (cand = candidates; cand; cand = cand->next)
3490 cand->second_conv = build_identity_conv (totype, NULL_TREE);
3492 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3493 set, then this is copy-initialization. In that case, "The
3494 result of the call is then used to direct-initialize the
3495 object that is the destination of the copy-initialization."
3498 We represent this in the conversion sequence with an
3499 rvalue conversion, which means a constructor call. */
3500 if (TREE_CODE (totype) != REFERENCE_TYPE
3501 && !(convflags & LOOKUP_NO_TEMP_BIND))
3503 = build_conv (ck_rvalue, totype, cand->second_conv);
3508 first_arg = build_this (expr);
3510 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3512 tree conversion_path = TREE_PURPOSE (conv_fns);
3513 struct z_candidate *old_candidates;
3515 /* If we are called to convert to a reference type, we are trying to
3516 find a direct binding, so don't even consider temporaries. If
3517 we don't find a direct binding, the caller will try again to
3518 look for a temporary binding. */
3519 if (TREE_CODE (totype) == REFERENCE_TYPE)
3520 convflags |= LOOKUP_NO_TEMP_BIND;
3522 old_candidates = candidates;
3523 add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3525 conversion_path, TYPE_BINFO (fromtype),
3526 flags, &candidates, complain);
3528 for (cand = candidates; cand != old_candidates; cand = cand->next)
3530 tree rettype = TREE_TYPE (TREE_TYPE (cand->fn));
3532 = implicit_conversion (totype,
3535 /*c_cast_p=*/false, convflags,
3538 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3539 copy-initialization. In that case, "The result of the
3540 call is then used to direct-initialize the object that is
3541 the destination of the copy-initialization." [dcl.init]
3543 We represent this in the conversion sequence with an
3544 rvalue conversion, which means a constructor call. But
3545 don't add a second rvalue conversion if there's already
3546 one there. Which there really shouldn't be, but it's
3547 harmless since we'd add it here anyway. */
3548 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3549 && !(convflags & LOOKUP_NO_TEMP_BIND))
3550 ics = build_conv (ck_rvalue, totype, ics);
3552 cand->second_conv = ics;
3557 cand->reason = arg_conversion_rejection (NULL_TREE, -1,
3560 else if (DECL_NONCONVERTING_P (cand->fn)
3561 && ics->rank > cr_exact)
3563 /* 13.3.1.5: For direct-initialization, those explicit
3564 conversion functions that are not hidden within S and
3565 yield type T or a type that can be converted to type T
3566 with a qualification conversion (4.4) are also candidate
3568 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3569 I've raised this issue with the committee. --jason 9/2011 */
3571 cand->reason = explicit_conversion_rejection (rettype, totype);
3573 else if (cand->viable == 1 && ics->bad_p)
3577 = bad_arg_conversion_rejection (NULL_TREE, -1,
3580 else if (primary_template_instantiation_p (cand->fn)
3581 && ics->rank > cr_exact)
3583 /* 13.3.3.1.2: If the user-defined conversion is specified by
3584 a specialization of a conversion function template, the
3585 second standard conversion sequence shall have exact match
3588 cand->reason = template_conversion_rejection (rettype, totype);
3593 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3597 release_tree_vector (args);
3601 cand = tourney (candidates, complain);
3604 if (complain & tf_error)
3606 error ("conversion from %qT to %qT is ambiguous",
3608 print_z_candidates (location_of (expr), candidates);
3611 cand = candidates; /* any one will do */
3612 cand->second_conv = build_ambiguous_conv (totype, expr);
3613 cand->second_conv->user_conv_p = true;
3614 if (!any_strictly_viable (candidates))
3615 cand->second_conv->bad_p = true;
3616 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3617 ambiguous conversion is no worse than another user-defined
3623 /* Build the user conversion sequence. */
3626 (DECL_CONSTRUCTOR_P (cand->fn)
3627 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3628 build_identity_conv (TREE_TYPE (expr), expr));
3630 if (cand->viable == -1)
3633 /* Remember that this was a list-initialization. */
3634 if (flags & LOOKUP_NO_NARROWING)
3635 conv->check_narrowing = true;
3637 /* Combine it with the second conversion sequence. */
3638 cand->second_conv = merge_conversion_sequences (conv,
3644 /* Wrapper for above. */
3647 build_user_type_conversion (tree totype, tree expr, int flags,
3648 tsubst_flags_t complain)
3650 struct z_candidate *cand;
3653 bool subtime = timevar_cond_start (TV_OVERLOAD);
3654 cand = build_user_type_conversion_1 (totype, expr, flags, complain);
3658 if (cand->second_conv->kind == ck_ambig)
3659 ret = error_mark_node;
3662 expr = convert_like (cand->second_conv, expr, complain);
3663 ret = convert_from_reference (expr);
3669 timevar_cond_stop (TV_OVERLOAD, subtime);
3673 /* Subroutine of convert_nontype_argument.
3675 EXPR is an argument for a template non-type parameter of integral or
3676 enumeration type. Do any necessary conversions (that are permitted for
3677 non-type arguments) to convert it to the parameter type.
3679 If conversion is successful, returns the converted expression;
3680 otherwise, returns error_mark_node. */
3683 build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain)
3688 location_t loc = EXPR_LOC_OR_HERE (expr);
3690 if (error_operand_p (expr))
3691 return error_mark_node;
3693 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3695 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3696 p = conversion_obstack_alloc (0);
3698 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
3700 LOOKUP_IMPLICIT, complain);
3702 /* for a non-type template-parameter of integral or
3703 enumeration type, integral promotions (4.5) and integral
3704 conversions (4.7) are applied. */
3705 /* It should be sufficient to check the outermost conversion step, since
3706 there are no qualification conversions to integer type. */
3710 /* A conversion function is OK. If it isn't constexpr, we'll
3711 complain later that the argument isn't constant. */
3713 /* The lvalue-to-rvalue conversion is OK. */
3719 t = next_conversion (conv)->type;
3720 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
3723 if (complain & tf_error)
3724 error_at (loc, "conversion from %qT to %qT not considered for "
3725 "non-type template argument", t, type);
3726 /* and fall through. */
3734 expr = convert_like (conv, expr, complain);
3736 expr = error_mark_node;
3738 /* Free all the conversions we allocated. */
3739 obstack_free (&conversion_obstack, p);
3744 /* Do any initial processing on the arguments to a function call. */
3746 static vec<tree, va_gc> *
3747 resolve_args (vec<tree, va_gc> *args, tsubst_flags_t complain)
3752 FOR_EACH_VEC_SAFE_ELT (args, ix, arg)
3754 if (error_operand_p (arg))
3756 else if (VOID_TYPE_P (TREE_TYPE (arg)))
3758 if (complain & tf_error)
3759 error ("invalid use of void expression");
3762 else if (invalid_nonstatic_memfn_p (arg, complain))
3768 /* Perform overload resolution on FN, which is called with the ARGS.
3770 Return the candidate function selected by overload resolution, or
3771 NULL if the event that overload resolution failed. In the case
3772 that overload resolution fails, *CANDIDATES will be the set of
3773 candidates considered, and ANY_VIABLE_P will be set to true or
3774 false to indicate whether or not any of the candidates were
3777 The ARGS should already have gone through RESOLVE_ARGS before this
3778 function is called. */
3780 static struct z_candidate *
3781 perform_overload_resolution (tree fn,
3782 const vec<tree, va_gc> *args,
3783 struct z_candidate **candidates,
3784 bool *any_viable_p, tsubst_flags_t complain)
3786 struct z_candidate *cand;
3787 tree explicit_targs;
3790 bool subtime = timevar_cond_start (TV_OVERLOAD);
3792 explicit_targs = NULL_TREE;
3796 *any_viable_p = true;
3799 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3800 || TREE_CODE (fn) == TEMPLATE_DECL
3801 || TREE_CODE (fn) == OVERLOAD
3802 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3804 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3806 explicit_targs = TREE_OPERAND (fn, 1);
3807 fn = TREE_OPERAND (fn, 0);
3811 /* Add the various candidate functions. */
3812 add_candidates (fn, NULL_TREE, args, NULL_TREE,
3813 explicit_targs, template_only,
3814 /*conversion_path=*/NULL_TREE,
3815 /*access_path=*/NULL_TREE,
3817 candidates, complain);
3819 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3821 cand = tourney (*candidates, complain);
3825 timevar_cond_stop (TV_OVERLOAD, subtime);
3829 /* Print an error message about being unable to build a call to FN with
3830 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
3831 be located; CANDIDATES is a possibly empty list of such
3835 print_error_for_call_failure (tree fn, vec<tree, va_gc> *args, bool any_viable_p,
3836 struct z_candidate *candidates)
3838 tree name = DECL_NAME (OVL_CURRENT (fn));
3839 location_t loc = location_of (name);
3842 error_at (loc, "no matching function for call to %<%D(%A)%>",
3843 name, build_tree_list_vec (args));
3845 error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous",
3846 name, build_tree_list_vec (args));
3848 print_z_candidates (loc, candidates);
3851 /* Return an expression for a call to FN (a namespace-scope function,
3852 or a static member function) with the ARGS. This may change
3856 build_new_function_call (tree fn, vec<tree, va_gc> **args, bool koenig_p,
3857 tsubst_flags_t complain)
3859 struct z_candidate *candidates, *cand;
3864 if (args != NULL && *args != NULL)
3866 *args = resolve_args (*args, complain);
3868 return error_mark_node;
3872 tm_malloc_replacement (fn);
3874 /* If this function was found without using argument dependent
3875 lookup, then we want to ignore any undeclared friend
3881 fn = remove_hidden_names (fn);
3884 if (complain & tf_error)
3885 print_error_for_call_failure (orig_fn, *args, false, NULL);
3886 return error_mark_node;
3890 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3891 p = conversion_obstack_alloc (0);
3893 cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p,
3898 if (complain & tf_error)
3900 if (!any_viable_p && candidates && ! candidates->next
3901 && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3902 return cp_build_function_call_vec (candidates->fn, args, complain);
3903 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3904 fn = TREE_OPERAND (fn, 0);
3905 print_error_for_call_failure (fn, *args, any_viable_p, candidates);
3907 result = error_mark_node;
3911 int flags = LOOKUP_NORMAL;
3912 /* If fn is template_id_expr, the call has explicit template arguments
3913 (e.g. func<int>(5)), communicate this info to build_over_call
3914 through flags so that later we can use it to decide whether to warn
3915 about peculiar null pointer conversion. */
3916 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3917 flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
3918 result = build_over_call (cand, flags, complain);
3921 /* Free all the conversions we allocated. */
3922 obstack_free (&conversion_obstack, p);
3927 /* Build a call to a global operator new. FNNAME is the name of the
3928 operator (either "operator new" or "operator new[]") and ARGS are
3929 the arguments provided. This may change ARGS. *SIZE points to the
3930 total number of bytes required by the allocation, and is updated if
3931 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3932 be used. If this function determines that no cookie should be
3933 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
3934 is not NULL_TREE, it is evaluated before calculating the final
3935 array size, and if it fails, the array size is replaced with
3936 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
3937 is non-NULL, it will be set, upon return, to the allocation
3941 build_operator_new_call (tree fnname, vec<tree, va_gc> **args,
3942 tree *size, tree *cookie_size, tree size_check,
3943 tree *fn, tsubst_flags_t complain)
3945 tree original_size = *size;
3947 struct z_candidate *candidates;
3948 struct z_candidate *cand;
3953 /* Set to (size_t)-1 if the size check fails. */
3954 if (size_check != NULL_TREE)
3955 *size = fold_build3 (COND_EXPR, sizetype, size_check,
3956 original_size, TYPE_MAX_VALUE (sizetype));
3957 vec_safe_insert (*args, 0, *size);
3958 *args = resolve_args (*args, complain);
3960 return error_mark_node;
3966 If this lookup fails to find the name, or if the allocated type
3967 is not a class type, the allocation function's name is looked
3968 up in the global scope.
3970 we disregard block-scope declarations of "operator new". */
3971 fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3973 /* Figure out what function is being called. */
3974 cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p,
3977 /* If no suitable function could be found, issue an error message
3981 if (complain & tf_error)
3982 print_error_for_call_failure (fns, *args, any_viable_p, candidates);
3983 return error_mark_node;
3986 /* If a cookie is required, add some extra space. Whether
3987 or not a cookie is required cannot be determined until
3988 after we know which function was called. */
3991 bool use_cookie = true;
3992 if (!abi_version_at_least (2))
3994 /* In G++ 3.2, the check was implemented incorrectly; it
3995 looked at the placement expression, rather than the
3996 type of the function. */
3997 if ((*args)->length () == 2
3998 && same_type_p (TREE_TYPE ((**args)[1]), ptr_type_node))
4005 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
4006 /* Skip the size_t parameter. */
4007 arg_types = TREE_CHAIN (arg_types);
4008 /* Check the remaining parameters (if any). */
4010 && TREE_CHAIN (arg_types) == void_list_node
4011 && same_type_p (TREE_VALUE (arg_types),
4015 /* If we need a cookie, adjust the number of bytes allocated. */
4018 /* Update the total size. */
4019 *size = size_binop (PLUS_EXPR, original_size, *cookie_size);
4020 /* Set to (size_t)-1 if the size check fails. */
4021 gcc_assert (size_check != NULL_TREE);
4022 *size = fold_build3 (COND_EXPR, sizetype, size_check,
4023 *size, TYPE_MAX_VALUE (sizetype));
4024 /* Update the argument list to reflect the adjusted size. */
4025 (**args)[0] = *size;
4028 *cookie_size = NULL_TREE;
4031 /* Tell our caller which function we decided to call. */
4035 /* Build the CALL_EXPR. */
4036 return build_over_call (cand, LOOKUP_NORMAL, complain);
4039 /* Build a new call to operator(). This may change ARGS. */
4042 build_op_call_1 (tree obj, vec<tree, va_gc> **args, tsubst_flags_t complain)
4044 struct z_candidate *candidates = 0, *cand;
4045 tree fns, convs, first_mem_arg = NULL_TREE;
4046 tree type = TREE_TYPE (obj);
4048 tree result = NULL_TREE;
4051 if (error_operand_p (obj))
4052 return error_mark_node;
4054 obj = prep_operand (obj);
4056 if (TYPE_PTRMEMFUNC_P (type))
4058 if (complain & tf_error)
4059 /* It's no good looking for an overloaded operator() on a
4060 pointer-to-member-function. */
4061 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
4062 return error_mark_node;
4065 if (TYPE_BINFO (type))
4067 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
4068 if (fns == error_mark_node)
4069 return error_mark_node;
4074 if (args != NULL && *args != NULL)
4076 *args = resolve_args (*args, complain);
4078 return error_mark_node;
4081 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4082 p = conversion_obstack_alloc (0);
4086 first_mem_arg = build_this (obj);
4088 add_candidates (BASELINK_FUNCTIONS (fns),
4089 first_mem_arg, *args, NULL_TREE,
4091 BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
4092 LOOKUP_NORMAL, &candidates, complain);
4095 convs = lookup_conversions (type);
4097 for (; convs; convs = TREE_CHAIN (convs))
4099 tree fns = TREE_VALUE (convs);
4100 tree totype = TREE_TYPE (convs);
4102 if ((TREE_CODE (totype) == POINTER_TYPE
4103 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
4104 || (TREE_CODE (totype) == REFERENCE_TYPE
4105 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
4106 || (TREE_CODE (totype) == REFERENCE_TYPE
4107 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
4108 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
4109 for (; fns; fns = OVL_NEXT (fns))
4111 tree fn = OVL_CURRENT (fns);
4113 if (DECL_NONCONVERTING_P (fn))
4116 if (TREE_CODE (fn) == TEMPLATE_DECL)
4117 add_template_conv_candidate
4118 (&candidates, fn, obj, NULL_TREE, *args, totype,
4119 /*access_path=*/NULL_TREE,
4120 /*conversion_path=*/NULL_TREE, complain);
4122 add_conv_candidate (&candidates, fn, obj, NULL_TREE,
4123 *args, /*conversion_path=*/NULL_TREE,
4124 /*access_path=*/NULL_TREE, complain);
4128 candidates = splice_viable (candidates, pedantic, &any_viable_p);
4131 if (complain & tf_error)
4133 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
4134 build_tree_list_vec (*args));
4135 print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4137 result = error_mark_node;
4141 cand = tourney (candidates, complain);
4144 if (complain & tf_error)
4146 error ("call of %<(%T) (%A)%> is ambiguous",
4147 TREE_TYPE (obj), build_tree_list_vec (*args));
4148 print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4150 result = error_mark_node;
4152 /* Since cand->fn will be a type, not a function, for a conversion
4153 function, we must be careful not to unconditionally look at
4155 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
4156 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
4157 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4160 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
4162 obj = convert_from_reference (obj);
4163 result = cp_build_function_call_vec (obj, args, complain);
4167 /* Free all the conversions we allocated. */
4168 obstack_free (&conversion_obstack, p);
4173 /* Wrapper for above. */
4176 build_op_call (tree obj, vec<tree, va_gc> **args, tsubst_flags_t complain)
4179 bool subtime = timevar_cond_start (TV_OVERLOAD);
4180 ret = build_op_call_1 (obj, args, complain);
4181 timevar_cond_stop (TV_OVERLOAD, subtime);
4185 /* Called by op_error to prepare format strings suitable for the error
4186 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4187 and a suffix (controlled by NTYPES). */
4190 op_error_string (const char *errmsg, int ntypes, bool match)
4194 const char *msgp = concat (match ? G_("ambiguous overload for ")
4195 : G_("no match for "), errmsg, NULL);
4198 msg = concat (msgp, G_(" (operand types are %qT, %qT, and %qT)"), NULL);
4199 else if (ntypes == 2)
4200 msg = concat (msgp, G_(" (operand types are %qT and %qT)"), NULL);
4202 msg = concat (msgp, G_(" (operand type is %qT)"), NULL);
4208 op_error (location_t loc, enum tree_code code, enum tree_code code2,
4209 tree arg1, tree arg2, tree arg3, bool match)
4213 if (code == MODIFY_EXPR)
4214 opname = assignment_operator_name_info[code2].name;
4216 opname = operator_name_info[code].name;
4221 if (flag_diagnostics_show_caret)
4222 error_at (loc, op_error_string (G_("ternary %<operator?:%>"),
4224 TREE_TYPE (arg1), TREE_TYPE (arg2), TREE_TYPE (arg3));
4226 error_at (loc, op_error_string (G_("ternary %<operator?:%> "
4227 "in %<%E ? %E : %E%>"), 3, match),
4229 TREE_TYPE (arg1), TREE_TYPE (arg2), TREE_TYPE (arg3));
4232 case POSTINCREMENT_EXPR:
4233 case POSTDECREMENT_EXPR:
4234 if (flag_diagnostics_show_caret)
4235 error_at (loc, op_error_string (G_("%<operator%s%>"), 1, match),
4236 opname, TREE_TYPE (arg1));
4238 error_at (loc, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4240 opname, arg1, opname, TREE_TYPE (arg1));
4244 if (flag_diagnostics_show_caret)
4245 error_at (loc, op_error_string (G_("%<operator[]%>"), 2, match),
4246 TREE_TYPE (arg1), TREE_TYPE (arg2));
4248 error_at (loc, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4250 arg1, arg2, TREE_TYPE (arg1), TREE_TYPE (arg2));
4255 if (flag_diagnostics_show_caret)
4256 error_at (loc, op_error_string (G_("%qs"), 1, match),
4257 opname, TREE_TYPE (arg1));
4259 error_at (loc, op_error_string (G_("%qs in %<%s %E%>"), 1, match),
4260 opname, opname, arg1, TREE_TYPE (arg1));
4265 if (flag_diagnostics_show_caret)
4266 error_at (loc, op_error_string (G_("%<operator%s%>"), 2, match),
4267 opname, TREE_TYPE (arg1), TREE_TYPE (arg2));
4269 error_at (loc, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4271 opname, arg1, opname, arg2,
4272 TREE_TYPE (arg1), TREE_TYPE (arg2));
4274 if (flag_diagnostics_show_caret)
4275 error_at (loc, op_error_string (G_("%<operator%s%>"), 1, match),
4276 opname, TREE_TYPE (arg1));
4278 error_at (loc, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4280 opname, opname, arg1, TREE_TYPE (arg1));
4285 /* Return the implicit conversion sequence that could be used to
4286 convert E1 to E2 in [expr.cond]. */
4289 conditional_conversion (tree e1, tree e2, tsubst_flags_t complain)
4291 tree t1 = non_reference (TREE_TYPE (e1));
4292 tree t2 = non_reference (TREE_TYPE (e2));
4298 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4299 implicitly converted (clause _conv_) to the type "lvalue reference to
4300 T2", subject to the constraint that in the conversion the
4301 reference must bind directly (_dcl.init.ref_) to an lvalue. */
4302 if (real_lvalue_p (e2))
4304 conv = implicit_conversion (build_reference_type (t2),
4308 LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND
4309 |LOOKUP_ONLYCONVERTING,
4317 If E1 and E2 have class type, and the underlying class types are
4318 the same or one is a base class of the other: E1 can be converted
4319 to match E2 if the class of T2 is the same type as, or a base
4320 class of, the class of T1, and the cv-qualification of T2 is the
4321 same cv-qualification as, or a greater cv-qualification than, the
4322 cv-qualification of T1. If the conversion is applied, E1 is
4323 changed to an rvalue of type T2 that still refers to the original
4324 source class object (or the appropriate subobject thereof). */
4325 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
4326 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
4328 if (good_base && at_least_as_qualified_p (t2, t1))
4330 conv = build_identity_conv (t1, e1);
4331 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
4332 TYPE_MAIN_VARIANT (t2)))
4333 conv = build_conv (ck_base, t2, conv);
4335 conv = build_conv (ck_rvalue, t2, conv);
4344 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4345 converted to the type that expression E2 would have if E2 were
4346 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4347 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
4348 LOOKUP_IMPLICIT, complain);
4351 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4352 arguments to the conditional expression. */
4355 build_conditional_expr_1 (tree arg1, tree arg2, tree arg3,
4356 tsubst_flags_t complain)
4360 tree result = NULL_TREE;
4361 tree result_type = NULL_TREE;
4362 bool lvalue_p = true;
4363 struct z_candidate *candidates = 0;
4364 struct z_candidate *cand;
4366 tree orig_arg2, orig_arg3;
4368 /* As a G++ extension, the second argument to the conditional can be
4369 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4370 c'.) If the second operand is omitted, make sure it is
4371 calculated only once. */
4374 if (complain & tf_error)
4375 pedwarn (input_location, OPT_Wpedantic,
4376 "ISO C++ forbids omitting the middle term of a ?: expression");
4378 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4379 if (real_lvalue_p (arg1))
4380 arg2 = arg1 = stabilize_reference (arg1);
4382 arg2 = arg1 = save_expr (arg1);
4385 /* If something has already gone wrong, just pass that fact up the
4387 if (error_operand_p (arg1)
4388 || error_operand_p (arg2)
4389 || error_operand_p (arg3))
4390 return error_mark_node;
4395 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1)))
4397 arg1 = force_rvalue (arg1, complain);
4398 arg2 = force_rvalue (arg2, complain);
4399 arg3 = force_rvalue (arg3, complain);
4401 tree arg1_type = TREE_TYPE (arg1);
4402 arg2_type = TREE_TYPE (arg2);
4403 arg3_type = TREE_TYPE (arg3);
4405 if (TREE_CODE (arg2_type) != VECTOR_TYPE
4406 && TREE_CODE (arg3_type) != VECTOR_TYPE)
4408 if (complain & tf_error)
4409 error ("at least one operand of a vector conditional operator "
4410 "must be a vector");
4411 return error_mark_node;
4414 if ((TREE_CODE (arg2_type) == VECTOR_TYPE)
4415 != (TREE_CODE (arg3_type) == VECTOR_TYPE))
4417 enum stv_conv convert_flag =
4418 scalar_to_vector (input_location, VEC_COND_EXPR, arg2, arg3,
4419 complain & tf_error);
4421 switch (convert_flag)
4424 return error_mark_node;
4427 arg2 = convert (TREE_TYPE (arg3_type), arg2);
4428 arg2 = build_vector_from_val (arg3_type, arg2);
4429 arg2_type = TREE_TYPE (arg2);
4434 arg3 = convert (TREE_TYPE (arg2_type), arg3);
4435 arg3 = build_vector_from_val (arg2_type, arg3);
4436 arg3_type = TREE_TYPE (arg3);
4444 if (!same_type_p (arg2_type, arg3_type)
4445 || TYPE_VECTOR_SUBPARTS (arg1_type)
4446 != TYPE_VECTOR_SUBPARTS (arg2_type)
4447 || TYPE_SIZE (arg1_type) != TYPE_SIZE (arg2_type))
4449 if (complain & tf_error)
4450 error ("incompatible vector types in conditional expression: "
4451 "%qT, %qT and %qT", TREE_TYPE (arg1), TREE_TYPE (orig_arg2),
4452 TREE_TYPE (orig_arg3));
4453 return error_mark_node;
4456 if (!COMPARISON_CLASS_P (arg1))
4457 arg1 = build2 (NE_EXPR, signed_type_for (arg1_type), arg1,
4458 build_zero_cst (arg1_type));
4459 return build3 (VEC_COND_EXPR, arg2_type, arg1, arg2, arg3);
4464 The first expression is implicitly converted to bool (clause
4466 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
4468 if (error_operand_p (arg1))
4469 return error_mark_node;
4473 If either the second or the third operand has type (possibly
4474 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4475 array-to-pointer (_conv.array_), and function-to-pointer
4476 (_conv.func_) standard conversions are performed on the second
4477 and third operands. */
4478 arg2_type = unlowered_expr_type (arg2);
4479 arg3_type = unlowered_expr_type (arg3);
4480 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
4482 /* Do the conversions. We don't these for `void' type arguments
4483 since it can't have any effect and since decay_conversion
4484 does not handle that case gracefully. */
4485 if (!VOID_TYPE_P (arg2_type))
4486 arg2 = decay_conversion (arg2, complain);
4487 if (!VOID_TYPE_P (arg3_type))
4488 arg3 = decay_conversion (arg3, complain);
4489 arg2_type = TREE_TYPE (arg2);
4490 arg3_type = TREE_TYPE (arg3);
4494 One of the following shall hold:
4496 --The second or the third operand (but not both) is a
4497 throw-expression (_except.throw_); the result is of the
4498 type of the other and is an rvalue.
4500 --Both the second and the third operands have type void; the
4501 result is of type void and is an rvalue.
4503 We must avoid calling force_rvalue for expressions of type
4504 "void" because it will complain that their value is being
4506 if (TREE_CODE (arg2) == THROW_EXPR
4507 && TREE_CODE (arg3) != THROW_EXPR)
4509 if (!VOID_TYPE_P (arg3_type))
4511 arg3 = force_rvalue (arg3, complain);
4512 if (arg3 == error_mark_node)
4513 return error_mark_node;
4515 arg3_type = TREE_TYPE (arg3);
4516 result_type = arg3_type;
4518 else if (TREE_CODE (arg2) != THROW_EXPR
4519 && TREE_CODE (arg3) == THROW_EXPR)
4521 if (!VOID_TYPE_P (arg2_type))
4523 arg2 = force_rvalue (arg2, complain);
4524 if (arg2 == error_mark_node)
4525 return error_mark_node;
4527 arg2_type = TREE_TYPE (arg2);
4528 result_type = arg2_type;
4530 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
4531 result_type = void_type_node;
4534 if (complain & tf_error)
4536 if (VOID_TYPE_P (arg2_type))
4537 error ("second operand to the conditional operator "
4538 "is of type %<void%>, "
4539 "but the third operand is neither a throw-expression "
4540 "nor of type %<void%>");
4542 error ("third operand to the conditional operator "
4543 "is of type %<void%>, "
4544 "but the second operand is neither a throw-expression "
4545 "nor of type %<void%>");
4547 return error_mark_node;
4551 goto valid_operands;
4555 Otherwise, if the second and third operand have different types,
4556 and either has (possibly cv-qualified) class type, an attempt is
4557 made to convert each of those operands to the type of the other. */
4558 else if (!same_type_p (arg2_type, arg3_type)
4559 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
4564 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4565 p = conversion_obstack_alloc (0);
4567 conv2 = conditional_conversion (arg2, arg3, complain);
4568 conv3 = conditional_conversion (arg3, arg2, complain);
4572 If both can be converted, or one can be converted but the
4573 conversion is ambiguous, the program is ill-formed. If
4574 neither can be converted, the operands are left unchanged and
4575 further checking is performed as described below. If exactly
4576 one conversion is possible, that conversion is applied to the
4577 chosen operand and the converted operand is used in place of
4578 the original operand for the remainder of this section. */
4579 if ((conv2 && !conv2->bad_p
4580 && conv3 && !conv3->bad_p)
4581 || (conv2 && conv2->kind == ck_ambig)
4582 || (conv3 && conv3->kind == ck_ambig))
4584 error ("operands to ?: have different types %qT and %qT",
4585 arg2_type, arg3_type);
4586 result = error_mark_node;
4588 else if (conv2 && (!conv2->bad_p || !conv3))
4590 arg2 = convert_like (conv2, arg2, complain);
4591 arg2 = convert_from_reference (arg2);
4592 arg2_type = TREE_TYPE (arg2);
4593 /* Even if CONV2 is a valid conversion, the result of the
4594 conversion may be invalid. For example, if ARG3 has type
4595 "volatile X", and X does not have a copy constructor
4596 accepting a "volatile X&", then even if ARG2 can be
4597 converted to X, the conversion will fail. */
4598 if (error_operand_p (arg2))
4599 result = error_mark_node;
4601 else if (conv3 && (!conv3->bad_p || !conv2))
4603 arg3 = convert_like (conv3, arg3, complain);
4604 arg3 = convert_from_reference (arg3);
4605 arg3_type = TREE_TYPE (arg3);
4606 if (error_operand_p (arg3))
4607 result = error_mark_node;
4610 /* Free all the conversions we allocated. */
4611 obstack_free (&conversion_obstack, p);
4616 /* If, after the conversion, both operands have class type,
4617 treat the cv-qualification of both operands as if it were the
4618 union of the cv-qualification of the operands.
4620 The standard is not clear about what to do in this
4621 circumstance. For example, if the first operand has type
4622 "const X" and the second operand has a user-defined
4623 conversion to "volatile X", what is the type of the second
4624 operand after this step? Making it be "const X" (matching
4625 the first operand) seems wrong, as that discards the
4626 qualification without actually performing a copy. Leaving it
4627 as "volatile X" seems wrong as that will result in the
4628 conditional expression failing altogether, even though,
4629 according to this step, the one operand could be converted to
4630 the type of the other. */
4631 if ((conv2 || conv3)
4632 && CLASS_TYPE_P (arg2_type)
4633 && cp_type_quals (arg2_type) != cp_type_quals (arg3_type))
4634 arg2_type = arg3_type =
4635 cp_build_qualified_type (arg2_type,
4636 cp_type_quals (arg2_type)
4637 | cp_type_quals (arg3_type));
4642 If the second and third operands are lvalues and have the same
4643 type, the result is of that type and is an lvalue. */
4644 if (real_lvalue_p (arg2)
4645 && real_lvalue_p (arg3)
4646 && same_type_p (arg2_type, arg3_type))
4648 result_type = arg2_type;
4649 arg2 = mark_lvalue_use (arg2);
4650 arg3 = mark_lvalue_use (arg3);
4651 goto valid_operands;
4656 Otherwise, the result is an rvalue. If the second and third
4657 operand do not have the same type, and either has (possibly
4658 cv-qualified) class type, overload resolution is used to
4659 determine the conversions (if any) to be applied to the operands
4660 (_over.match.oper_, _over.built_). */
4662 if (!same_type_p (arg2_type, arg3_type)
4663 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
4669 /* Rearrange the arguments so that add_builtin_candidate only has
4670 to know about two args. In build_builtin_candidate, the
4671 arguments are unscrambled. */
4675 add_builtin_candidates (&candidates,
4678 ansi_opname (COND_EXPR),
4680 LOOKUP_NORMAL, complain);
4684 If the overload resolution fails, the program is
4686 candidates = splice_viable (candidates, pedantic, &any_viable_p);
4689 if (complain & tf_error)
4691 op_error (input_location, COND_EXPR, NOP_EXPR,
4692 arg1, arg2, arg3, FALSE);
4693 print_z_candidates (location_of (arg1), candidates);
4695 return error_mark_node;
4697 cand = tourney (candidates, complain);
4700 if (complain & tf_error)
4702 op_error (input_location, COND_EXPR, NOP_EXPR,
4703 arg1, arg2, arg3, FALSE);
4704 print_z_candidates (location_of (arg1), candidates);
4706 return error_mark_node;
4711 Otherwise, the conversions thus determined are applied, and
4712 the converted operands are used in place of the original
4713 operands for the remainder of this section. */
4714 conv = cand->convs[0];
4715 arg1 = convert_like (conv, arg1, complain);
4716 conv = cand->convs[1];
4717 arg2 = convert_like (conv, arg2, complain);
4718 arg2_type = TREE_TYPE (arg2);
4719 conv = cand->convs[2];
4720 arg3 = convert_like (conv, arg3, complain);
4721 arg3_type = TREE_TYPE (arg3);
4726 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
4727 and function-to-pointer (_conv.func_) standard conversions are
4728 performed on the second and third operands.
4730 We need to force the lvalue-to-rvalue conversion here for class types,
4731 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
4732 that isn't wrapped with a TARGET_EXPR plays havoc with exception
4735 arg2 = force_rvalue (arg2, complain);
4736 if (!CLASS_TYPE_P (arg2_type))
4737 arg2_type = TREE_TYPE (arg2);
4739 arg3 = force_rvalue (arg3, complain);
4740 if (!CLASS_TYPE_P (arg3_type))
4741 arg3_type = TREE_TYPE (arg3);
4743 if (arg2 == error_mark_node || arg3 == error_mark_node)
4744 return error_mark_node;
4748 After those conversions, one of the following shall hold:
4750 --The second and third operands have the same type; the result is of
4752 if (same_type_p (arg2_type, arg3_type))
4753 result_type = arg2_type;
4756 --The second and third operands have arithmetic or enumeration
4757 type; the usual arithmetic conversions are performed to bring
4758 them to a common type, and the result is of that type. */
4759 else if ((ARITHMETIC_TYPE_P (arg2_type)
4760 || UNSCOPED_ENUM_P (arg2_type))
4761 && (ARITHMETIC_TYPE_P (arg3_type)
4762 || UNSCOPED_ENUM_P (arg3_type)))
4764 /* In this case, there is always a common type. */
4765 result_type = type_after_usual_arithmetic_conversions (arg2_type,
4767 do_warn_double_promotion (result_type, arg2_type, arg3_type,
4768 "implicit conversion from %qT to %qT to "
4769 "match other result of conditional",
4772 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
4773 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
4775 if (TREE_CODE (orig_arg2) == CONST_DECL
4776 && TREE_CODE (orig_arg3) == CONST_DECL
4777 && DECL_CONTEXT (orig_arg2) == DECL_CONTEXT (orig_arg3))
4778 /* Two enumerators from the same enumeration can have different
4779 types when the enumeration is still being defined. */;
4780 else if (complain & tf_warning)
4781 warning (OPT_Wenum_compare,
4782 "enumeral mismatch in conditional expression: %qT vs %qT",
4783 arg2_type, arg3_type);
4785 else if (extra_warnings
4786 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
4787 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
4788 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
4789 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
4791 if (complain & tf_warning)
4793 "enumeral and non-enumeral type in conditional expression");
4796 arg2 = perform_implicit_conversion (result_type, arg2, complain);
4797 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4801 --The second and third operands have pointer type, or one has
4802 pointer type and the other is a null pointer constant; pointer
4803 conversions (_conv.ptr_) and qualification conversions
4804 (_conv.qual_) are performed to bring them to their composite
4805 pointer type (_expr.rel_). The result is of the composite
4808 --The second and third operands have pointer to member type, or
4809 one has pointer to member type and the other is a null pointer
4810 constant; pointer to member conversions (_conv.mem_) and
4811 qualification conversions (_conv.qual_) are performed to bring
4812 them to a common type, whose cv-qualification shall match the
4813 cv-qualification of either the second or the third operand.
4814 The result is of the common type. */
4815 else if ((null_ptr_cst_p (arg2)
4816 && TYPE_PTR_OR_PTRMEM_P (arg3_type))
4817 || (null_ptr_cst_p (arg3)
4818 && TYPE_PTR_OR_PTRMEM_P (arg2_type))
4819 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
4820 || (TYPE_PTRDATAMEM_P (arg2_type) && TYPE_PTRDATAMEM_P (arg3_type))
4821 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
4823 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
4824 arg3, CPO_CONDITIONAL_EXPR,
4826 if (result_type == error_mark_node)
4827 return error_mark_node;
4828 arg2 = perform_implicit_conversion (result_type, arg2, complain);
4829 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4834 if (complain & tf_error)
4835 error ("operands to ?: have different types %qT and %qT",
4836 arg2_type, arg3_type);
4837 return error_mark_node;
4840 if (arg2 == error_mark_node || arg3 == error_mark_node)
4841 return error_mark_node;
4844 result = build3 (COND_EXPR, result_type, arg1, arg2, arg3);
4845 if (!cp_unevaluated_operand)
4846 /* Avoid folding within decltype (c++/42013) and noexcept. */
4847 result = fold_if_not_in_template (result);
4849 /* We can't use result_type below, as fold might have returned a
4854 /* Expand both sides into the same slot, hopefully the target of
4855 the ?: expression. We used to check for TARGET_EXPRs here,
4856 but now we sometimes wrap them in NOP_EXPRs so the test would
4858 if (CLASS_TYPE_P (TREE_TYPE (result)))
4859 result = get_target_expr_sfinae (result, complain);
4860 /* If this expression is an rvalue, but might be mistaken for an
4861 lvalue, we must add a NON_LVALUE_EXPR. */
4862 result = rvalue (result);
4868 /* Wrapper for above. */
4871 build_conditional_expr (tree arg1, tree arg2, tree arg3,
4872 tsubst_flags_t complain)
4875 bool subtime = timevar_cond_start (TV_OVERLOAD);
4876 ret = build_conditional_expr_1 (arg1, arg2, arg3, complain);
4877 timevar_cond_stop (TV_OVERLOAD, subtime);
4881 /* OPERAND is an operand to an expression. Perform necessary steps
4882 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4886 prep_operand (tree operand)
4890 if (CLASS_TYPE_P (TREE_TYPE (operand))
4891 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
4892 /* Make sure the template type is instantiated now. */
4893 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
4899 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4900 OVERLOAD) to the CANDIDATES, returning an updated list of
4901 CANDIDATES. The ARGS are the arguments provided to the call;
4902 if FIRST_ARG is non-null it is the implicit object argument,
4903 otherwise the first element of ARGS is used if needed. The
4904 EXPLICIT_TARGS are explicit template arguments provided.
4905 TEMPLATE_ONLY is true if only template functions should be
4906 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4907 add_function_candidate. */
4910 add_candidates (tree fns, tree first_arg, const vec<tree, va_gc> *args,
4912 tree explicit_targs, bool template_only,
4913 tree conversion_path, tree access_path,
4915 struct z_candidate **candidates,
4916 tsubst_flags_t complain)
4919 const vec<tree, va_gc> *non_static_args;
4920 bool check_list_ctor;
4921 bool check_converting;
4922 unification_kind_t strict;
4928 /* Precalculate special handling of constructors and conversion ops. */
4929 fn = OVL_CURRENT (fns);
4930 if (DECL_CONV_FN_P (fn))
4932 check_list_ctor = false;
4933 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4934 if (flags & LOOKUP_NO_CONVERSION)
4935 /* We're doing return_type(x). */
4936 strict = DEDUCE_CONV;
4938 /* We're doing x.operator return_type(). */
4939 strict = DEDUCE_EXACT;
4940 /* [over.match.funcs] For conversion functions, the function
4941 is considered to be a member of the class of the implicit
4942 object argument for the purpose of defining the type of
4943 the implicit object parameter. */
4944 ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
4948 if (DECL_CONSTRUCTOR_P (fn))
4950 check_list_ctor = !!(flags & LOOKUP_LIST_ONLY);
4951 /* For list-initialization we consider explicit constructors
4952 and complain if one is chosen. */
4954 = ((flags & (LOOKUP_ONLYCONVERTING|LOOKUP_LIST_INIT_CTOR))
4955 == LOOKUP_ONLYCONVERTING);
4959 check_list_ctor = false;
4960 check_converting = false;
4962 strict = DEDUCE_CALL;
4963 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
4967 non_static_args = args;
4969 /* Delay creating the implicit this parameter until it is needed. */
4970 non_static_args = NULL;
4972 for (; fns; fns = OVL_NEXT (fns))
4975 const vec<tree, va_gc> *fn_args;
4977 fn = OVL_CURRENT (fns);
4979 if (check_converting && DECL_NONCONVERTING_P (fn))
4981 if (check_list_ctor && !is_list_ctor (fn))
4984 /* Figure out which set of arguments to use. */
4985 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
4987 /* If this function is a non-static member and we didn't get an
4988 implicit object argument, move it out of args. */
4989 if (first_arg == NULL_TREE)
4993 vec<tree, va_gc> *tempvec;
4994 vec_alloc (tempvec, args->length () - 1);
4995 for (ix = 1; args->iterate (ix, &arg); ++ix)
4996 tempvec->quick_push (arg);
4997 non_static_args = tempvec;
4998 first_arg = build_this ((*args)[0]);
5001 fn_first_arg = first_arg;
5002 fn_args = non_static_args;
5006 /* Otherwise, just use the list of arguments provided. */
5007 fn_first_arg = NULL_TREE;
5011 if (TREE_CODE (fn) == TEMPLATE_DECL)
5012 add_template_candidate (candidates,
5024 else if (!template_only)
5025 add_function_candidate (candidates,
5038 build_new_op_1 (location_t loc, enum tree_code code, int flags, tree arg1,
5039 tree arg2, tree arg3, tree *overload, tsubst_flags_t complain)
5041 struct z_candidate *candidates = 0, *cand;
5042 vec<tree, va_gc> *arglist;
5045 tree result = NULL_TREE;
5046 bool result_valid_p = false;
5047 enum tree_code code2 = NOP_EXPR;
5048 enum tree_code code_orig_arg1 = ERROR_MARK;
5049 enum tree_code code_orig_arg2 = ERROR_MARK;
5055 if (error_operand_p (arg1)
5056 || error_operand_p (arg2)
5057 || error_operand_p (arg3))
5058 return error_mark_node;
5060 if (code == MODIFY_EXPR)
5062 code2 = TREE_CODE (arg3);
5064 fnname = ansi_assopname (code2);
5067 fnname = ansi_opname (code);
5069 arg1 = prep_operand (arg1);
5075 case VEC_DELETE_EXPR:
5077 /* Use build_op_new_call and build_op_delete_call instead. */
5081 /* Use build_op_call instead. */
5084 case TRUTH_ORIF_EXPR:
5085 case TRUTH_ANDIF_EXPR:
5086 case TRUTH_AND_EXPR:
5088 /* These are saved for the sake of warn_logical_operator. */
5089 code_orig_arg1 = TREE_CODE (arg1);
5090 code_orig_arg2 = TREE_CODE (arg2);
5096 arg2 = prep_operand (arg2);
5097 arg3 = prep_operand (arg3);
5099 if (code == COND_EXPR)
5100 /* Use build_conditional_expr instead. */
5102 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
5103 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
5106 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
5107 arg2 = integer_zero_node;
5109 vec_alloc (arglist, 3);
5110 arglist->quick_push (arg1);
5111 if (arg2 != NULL_TREE)
5112 arglist->quick_push (arg2);
5113 if (arg3 != NULL_TREE)
5114 arglist->quick_push (arg3);
5116 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5117 p = conversion_obstack_alloc (0);
5119 /* Add namespace-scope operators to the list of functions to
5121 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
5122 NULL_TREE, arglist, NULL_TREE,
5123 NULL_TREE, false, NULL_TREE, NULL_TREE,
5124 flags, &candidates, complain);
5128 args[2] = NULL_TREE;
5130 /* Add class-member operators to the candidate set. */
5131 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
5135 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
5136 if (fns == error_mark_node)
5138 result = error_mark_node;
5139 goto user_defined_result_ready;
5142 add_candidates (BASELINK_FUNCTIONS (fns),
5143 NULL_TREE, arglist, NULL_TREE,
5145 BASELINK_BINFO (fns),
5146 BASELINK_ACCESS_BINFO (fns),
5147 flags, &candidates, complain);
5149 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5150 only non-member functions that have type T1 or reference to
5151 cv-qualified-opt T1 for the first argument, if the first argument
5152 has an enumeration type, or T2 or reference to cv-qualified-opt
5153 T2 for the second argument, if the the second argument has an
5154 enumeration type. Filter out those that don't match. */
5155 else if (! arg2 || ! CLASS_TYPE_P (TREE_TYPE (arg2)))
5157 struct z_candidate **candp, **next;
5159 for (candp = &candidates; *candp; candp = next)
5161 tree parmlist, parmtype;
5162 int i, nargs = (arg2 ? 2 : 1);
5167 parmlist = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
5169 for (i = 0; i < nargs; ++i)
5171 parmtype = TREE_VALUE (parmlist);
5173 if (TREE_CODE (parmtype) == REFERENCE_TYPE)
5174 parmtype = TREE_TYPE (parmtype);
5175 if (TREE_CODE (TREE_TYPE (args[i])) == ENUMERAL_TYPE
5176 && (same_type_ignoring_top_level_qualifiers_p
5177 (TREE_TYPE (args[i]), parmtype)))
5180 parmlist = TREE_CHAIN (parmlist);
5183 /* No argument has an appropriate type, so remove this
5184 candidate function from the list. */
5187 *candp = cand->next;
5193 add_builtin_candidates (&candidates, code, code2, fnname, args,
5200 /* For these, the built-in candidates set is empty
5201 [over.match.oper]/3. We don't want non-strict matches
5202 because exact matches are always possible with built-in
5203 operators. The built-in candidate set for COMPONENT_REF
5204 would be empty too, but since there are no such built-in
5205 operators, we accept non-strict matches for them. */
5210 strict_p = pedantic;
5214 candidates = splice_viable (candidates, strict_p, &any_viable_p);
5219 case POSTINCREMENT_EXPR:
5220 case POSTDECREMENT_EXPR:
5221 /* Don't try anything fancy if we're not allowed to produce
5223 if (!(complain & tf_error))
5224 return error_mark_node;
5226 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5227 distinguish between prefix and postfix ++ and
5228 operator++() was used for both, so we allow this with
5232 const char *msg = (flag_permissive)
5233 ? G_("no %<%D(int)%> declared for postfix %qs,"
5234 " trying prefix operator instead")
5235 : G_("no %<%D(int)%> declared for postfix %qs");
5236 permerror (loc, msg, fnname, operator_name_info[code].name);
5239 if (!flag_permissive)
5240 return error_mark_node;
5242 if (code == POSTINCREMENT_EXPR)
5243 code = PREINCREMENT_EXPR;
5245 code = PREDECREMENT_EXPR;
5246 result = build_new_op_1 (loc, code, flags, arg1, NULL_TREE,
5247 NULL_TREE, overload, complain);
5250 /* The caller will deal with these. */
5255 result_valid_p = true;
5259 if (complain & tf_error)
5261 /* If one of the arguments of the operator represents
5262 an invalid use of member function pointer, try to report
5263 a meaningful error ... */
5264 if (invalid_nonstatic_memfn_p (arg1, tf_error)
5265 || invalid_nonstatic_memfn_p (arg2, tf_error)
5266 || invalid_nonstatic_memfn_p (arg3, tf_error))
5267 /* We displayed the error message. */;
5270 /* ... Otherwise, report the more generic
5271 "no matching operator found" error */
5272 op_error (loc, code, code2, arg1, arg2, arg3, FALSE);
5273 print_z_candidates (loc, candidates);
5276 result = error_mark_node;
5282 cand = tourney (candidates, complain);
5285 if (complain & tf_error)
5287 op_error (loc, code, code2, arg1, arg2, arg3, TRUE);
5288 print_z_candidates (loc, candidates);
5290 result = error_mark_node;
5292 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
5295 *overload = cand->fn;
5297 if (resolve_args (arglist, complain) == NULL)
5298 result = error_mark_node;
5300 result = build_over_call (cand, LOOKUP_NORMAL, complain);
5304 /* Give any warnings we noticed during overload resolution. */
5305 if (cand->warnings && (complain & tf_warning))
5307 struct candidate_warning *w;
5308 for (w = cand->warnings; w; w = w->next)
5309 joust (cand, w->loser, 1, complain);
5312 /* Check for comparison of different enum types. */
5321 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
5322 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
5323 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
5324 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
5325 && (complain & tf_warning))
5327 warning (OPT_Wenum_compare,
5328 "comparison between %q#T and %q#T",
5329 TREE_TYPE (arg1), TREE_TYPE (arg2));
5336 /* We need to strip any leading REF_BIND so that bitfields
5337 don't cause errors. This should not remove any important
5338 conversions, because builtins don't apply to class
5339 objects directly. */
5340 conv = cand->convs[0];
5341 if (conv->kind == ck_ref_bind)
5342 conv = next_conversion (conv);
5343 arg1 = convert_like (conv, arg1, complain);
5347 conv = cand->convs[1];
5348 if (conv->kind == ck_ref_bind)
5349 conv = next_conversion (conv);
5351 arg2 = decay_conversion (arg2, complain);
5353 /* We need to call warn_logical_operator before
5354 converting arg2 to a boolean_type, but after
5355 decaying an enumerator to its value. */
5356 if (complain & tf_warning)
5357 warn_logical_operator (loc, code, boolean_type_node,
5358 code_orig_arg1, arg1,
5359 code_orig_arg2, arg2);
5361 arg2 = convert_like (conv, arg2, complain);
5365 conv = cand->convs[2];
5366 if (conv->kind == ck_ref_bind)
5367 conv = next_conversion (conv);
5368 arg3 = convert_like (conv, arg3, complain);
5374 user_defined_result_ready:
5376 /* Free all the conversions we allocated. */
5377 obstack_free (&conversion_obstack, p);
5379 if (result || result_valid_p)
5386 return cp_build_modify_expr (arg1, code2, arg2, complain);
5389 return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
5391 case TRUTH_ANDIF_EXPR:
5392 case TRUTH_ORIF_EXPR:
5393 case TRUTH_AND_EXPR:
5395 warn_logical_operator (loc, code, boolean_type_node,
5396 code_orig_arg1, arg1, code_orig_arg2, arg2);
5401 case TRUNC_DIV_EXPR:
5412 case TRUNC_MOD_EXPR:
5416 return cp_build_binary_op (input_location, code, arg1, arg2, complain);
5418 case UNARY_PLUS_EXPR:
5421 case TRUTH_NOT_EXPR:
5422 case PREINCREMENT_EXPR:
5423 case POSTINCREMENT_EXPR:
5424 case PREDECREMENT_EXPR:
5425 case POSTDECREMENT_EXPR:
5429 return cp_build_unary_op (code, arg1, candidates != 0, complain);
5432 return cp_build_array_ref (input_location, arg1, arg2, complain);
5435 return build_m_component_ref (cp_build_indirect_ref (arg1, RO_ARROW_STAR,
5439 /* The caller will deal with these. */
5451 /* Wrapper for above. */
5454 build_new_op (location_t loc, enum tree_code code, int flags,
5455 tree arg1, tree arg2, tree arg3,
5456 tree *overload, tsubst_flags_t complain)
5459 bool subtime = timevar_cond_start (TV_OVERLOAD);
5460 ret = build_new_op_1 (loc, code, flags, arg1, arg2, arg3,
5461 overload, complain);
5462 timevar_cond_stop (TV_OVERLOAD, subtime);
5466 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5467 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5470 non_placement_deallocation_fn_p (tree t)
5472 /* A template instance is never a usual deallocation function,
5473 regardless of its signature. */
5474 if (TREE_CODE (t) == TEMPLATE_DECL
5475 || primary_template_instantiation_p (t))
5478 /* If a class T has a member deallocation function named operator delete
5479 with exactly one parameter, then that function is a usual
5480 (non-placement) deallocation function. If class T does not declare
5481 such an operator delete but does declare a member deallocation
5482 function named operator delete with exactly two parameters, the second
5483 of which has type std::size_t (18.2), then this function is a usual
5484 deallocation function. */
5485 t = FUNCTION_ARG_CHAIN (t);
5486 if (t == void_list_node
5487 || (t && same_type_p (TREE_VALUE (t), size_type_node)
5488 && TREE_CHAIN (t) == void_list_node))
5493 /* Build a call to operator delete. This has to be handled very specially,
5494 because the restrictions on what signatures match are different from all
5495 other call instances. For a normal delete, only a delete taking (void *)
5496 or (void *, size_t) is accepted. For a placement delete, only an exact
5497 match with the placement new is accepted.
5499 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5500 ADDR is the pointer to be deleted.
5501 SIZE is the size of the memory block to be deleted.
5502 GLOBAL_P is true if the delete-expression should not consider
5503 class-specific delete operators.
5504 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5506 If this call to "operator delete" is being generated as part to
5507 deallocate memory allocated via a new-expression (as per [expr.new]
5508 which requires that if the initialization throws an exception then
5509 we call a deallocation function), then ALLOC_FN is the allocation
5513 build_op_delete_call (enum tree_code code, tree addr, tree size,
5514 bool global_p, tree placement,
5515 tree alloc_fn, tsubst_flags_t complain)
5517 tree fn = NULL_TREE;
5518 tree fns, fnname, type, t;
5520 if (addr == error_mark_node)
5521 return error_mark_node;
5523 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
5525 fnname = ansi_opname (code);
5527 if (CLASS_TYPE_P (type)
5528 && COMPLETE_TYPE_P (complete_type (type))
5532 If the result of the lookup is ambiguous or inaccessible, or if
5533 the lookup selects a placement deallocation function, the
5534 program is ill-formed.
5536 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5538 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
5539 if (fns == error_mark_node)
5540 return error_mark_node;
5545 if (fns == NULL_TREE)
5546 fns = lookup_name_nonclass (fnname);
5548 /* Strip const and volatile from addr. */
5549 addr = cp_convert (ptr_type_node, addr, complain);
5553 /* "A declaration of a placement deallocation function matches the
5554 declaration of a placement allocation function if it has the same
5555 number of parameters and, after parameter transformations (8.3.5),
5556 all parameter types except the first are identical."
5558 So we build up the function type we want and ask instantiate_type
5559 to get it for us. */
5560 t = FUNCTION_ARG_CHAIN (alloc_fn);
5561 t = tree_cons (NULL_TREE, ptr_type_node, t);
5562 t = build_function_type (void_type_node, t);
5564 fn = instantiate_type (t, fns, tf_none);
5565 if (fn == error_mark_node)
5568 if (BASELINK_P (fn))
5569 fn = BASELINK_FUNCTIONS (fn);
5571 /* "If the lookup finds the two-parameter form of a usual deallocation
5572 function (3.7.4.2) and that function, considered as a placement
5573 deallocation function, would have been selected as a match for the
5574 allocation function, the program is ill-formed." */
5575 if (non_placement_deallocation_fn_p (fn))
5577 /* But if the class has an operator delete (void *), then that is
5578 the usual deallocation function, so we shouldn't complain
5579 about using the operator delete (void *, size_t). */
5580 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
5581 t; t = OVL_NEXT (t))
5583 tree elt = OVL_CURRENT (t);
5584 if (non_placement_deallocation_fn_p (elt)
5585 && FUNCTION_ARG_CHAIN (elt) == void_list_node)
5588 if (complain & tf_error)
5590 permerror (0, "non-placement deallocation function %q+D", fn);
5591 permerror (input_location, "selected for placement delete");
5594 return error_mark_node;
5599 /* "Any non-placement deallocation function matches a non-placement
5600 allocation function. If the lookup finds a single matching
5601 deallocation function, that function will be called; otherwise, no
5602 deallocation function will be called." */
5603 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
5604 t; t = OVL_NEXT (t))
5606 tree elt = OVL_CURRENT (t);
5607 if (non_placement_deallocation_fn_p (elt))
5610 /* "If a class T has a member deallocation function named
5611 operator delete with exactly one parameter, then that
5612 function is a usual (non-placement) deallocation
5613 function. If class T does not declare such an operator
5614 delete but does declare a member deallocation function named
5615 operator delete with exactly two parameters, the second of
5616 which has type std::size_t (18.2), then this function is a
5617 usual deallocation function."
5619 So (void*) beats (void*, size_t). */
5620 if (FUNCTION_ARG_CHAIN (fn) == void_list_node)
5625 /* If we have a matching function, call it. */
5628 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
5630 /* If the FN is a member function, make sure that it is
5632 if (BASELINK_P (fns))
5633 perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn,
5636 /* Core issue 901: It's ok to new a type with deleted delete. */
5637 if (DECL_DELETED_FN (fn) && alloc_fn)
5642 /* The placement args might not be suitable for overload
5643 resolution at this point, so build the call directly. */
5644 int nargs = call_expr_nargs (placement);
5645 tree *argarray = XALLOCAVEC (tree, nargs);
5648 for (i = 1; i < nargs; i++)
5649 argarray[i] = CALL_EXPR_ARG (placement, i);
5651 return build_cxx_call (fn, nargs, argarray, complain);
5656 vec<tree, va_gc> *args;
5657 vec_alloc (args, 2);
5658 args->quick_push (addr);
5659 if (FUNCTION_ARG_CHAIN (fn) != void_list_node)
5660 args->quick_push (size);
5661 ret = cp_build_function_call_vec (fn, &args, complain);
5669 If no unambiguous matching deallocation function can be found,
5670 propagating the exception does not cause the object's memory to
5674 if ((complain & tf_warning)
5676 warning (0, "no corresponding deallocation function for %qD",
5681 if (complain & tf_error)
5682 error ("no suitable %<operator %s%> for %qT",
5683 operator_name_info[(int)code].name, type);
5684 return error_mark_node;
5687 /* If the current scope isn't allowed to access DECL along
5688 BASETYPE_PATH, give an error. The most derived class in
5689 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
5690 the declaration to use in the error diagnostic. */
5693 enforce_access (tree basetype_path, tree decl, tree diag_decl,
5694 tsubst_flags_t complain)
5696 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
5698 if (!accessible_p (basetype_path, decl, true))
5700 if (complain & tf_error)
5702 if (TREE_PRIVATE (decl))
5703 error ("%q+#D is private", diag_decl);
5704 else if (TREE_PROTECTED (decl))
5705 error ("%q+#D is protected", diag_decl);
5707 error ("%q+#D is inaccessible", diag_decl);
5708 error ("within this context");
5716 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
5717 bitwise or of LOOKUP_* values. If any errors are warnings are
5718 generated, set *DIAGNOSTIC_FN to "error" or "warning",
5719 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
5723 build_temp (tree expr, tree type, int flags,
5724 diagnostic_t *diagnostic_kind, tsubst_flags_t complain)
5727 vec<tree, va_gc> *args;
5729 savew = warningcount, savee = errorcount;
5730 args = make_tree_vector_single (expr);
5731 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
5732 &args, type, flags, complain);
5733 release_tree_vector (args);
5734 if (warningcount > savew)
5735 *diagnostic_kind = DK_WARNING;
5736 else if (errorcount > savee)
5737 *diagnostic_kind = DK_ERROR;
5739 *diagnostic_kind = DK_UNSPECIFIED;
5743 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
5744 EXPR is implicitly converted to type TOTYPE.
5745 FN and ARGNUM are used for diagnostics. */
5748 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
5750 /* Issue warnings about peculiar, but valid, uses of NULL. */
5751 if (expr == null_node && TREE_CODE (totype) != BOOLEAN_TYPE
5752 && ARITHMETIC_TYPE_P (totype))
5754 source_location loc =
5755 expansion_point_location_if_in_system_header (input_location);
5758 warning_at (loc, OPT_Wconversion_null,
5759 "passing NULL to non-pointer argument %P of %qD",
5762 warning_at (loc, OPT_Wconversion_null,
5763 "converting to non-pointer type %qT from NULL", totype);
5766 /* Issue warnings if "false" is converted to a NULL pointer */
5767 else if (TREE_CODE (TREE_TYPE (expr)) == BOOLEAN_TYPE
5768 && TYPE_PTR_P (totype))
5771 warning_at (input_location, OPT_Wconversion_null,
5772 "converting %<false%> to pointer type for argument %P "
5773 "of %qD", argnum, fn);
5775 warning_at (input_location, OPT_Wconversion_null,
5776 "converting %<false%> to pointer type %qT", totype);
5780 /* Perform the conversions in CONVS on the expression EXPR. FN and
5781 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
5782 indicates the `this' argument of a method. INNER is nonzero when
5783 being called to continue a conversion chain. It is negative when a
5784 reference binding will be applied, positive otherwise. If
5785 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
5786 conversions will be emitted if appropriate. If C_CAST_P is true,
5787 this conversion is coming from a C-style cast; in that case,
5788 conversions to inaccessible bases are permitted. */
5791 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
5792 int inner, bool issue_conversion_warnings,
5793 bool c_cast_p, tsubst_flags_t complain)
5795 tree totype = convs->type;
5796 diagnostic_t diag_kind;
5798 location_t loc = EXPR_LOC_OR_HERE (expr);
5800 if (convs->bad_p && !(complain & tf_error))
5801 return error_mark_node;
5804 && convs->kind != ck_user
5805 && convs->kind != ck_list
5806 && convs->kind != ck_ambig
5807 && (convs->kind != ck_ref_bind
5808 || convs->user_conv_p)
5809 && convs->kind != ck_rvalue
5810 && convs->kind != ck_base)
5812 conversion *t = convs;
5814 /* Give a helpful error if this is bad because of excess braces. */
5815 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
5816 && SCALAR_TYPE_P (totype)
5817 && CONSTRUCTOR_NELTS (expr) > 0
5818 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
5819 permerror (loc, "too many braces around initializer for %qT", totype);
5821 for (; t ; t = next_conversion (t))
5823 if (t->kind == ck_user && t->cand->reason)
5825 permerror (loc, "invalid user-defined conversion "
5826 "from %qT to %qT", TREE_TYPE (expr), totype);
5827 print_z_candidate (loc, "candidate is:", t->cand);
5828 expr = convert_like_real (t, expr, fn, argnum, 1,
5829 /*issue_conversion_warnings=*/false,
5832 if (convs->kind == ck_ref_bind)
5833 return convert_to_reference (totype, expr, CONV_IMPLICIT,
5834 LOOKUP_NORMAL, NULL_TREE,
5837 return cp_convert (totype, expr, complain);
5839 else if (t->kind == ck_user || !t->bad_p)
5841 expr = convert_like_real (t, expr, fn, argnum, 1,
5842 /*issue_conversion_warnings=*/false,
5847 else if (t->kind == ck_ambig)
5848 return convert_like_real (t, expr, fn, argnum, 1,
5849 /*issue_conversion_warnings=*/false,
5852 else if (t->kind == ck_identity)
5856 permerror (loc, "invalid conversion from %qT to %qT",
5857 TREE_TYPE (expr), totype);
5859 permerror (DECL_SOURCE_LOCATION (fn),
5860 " initializing argument %P of %qD", argnum, fn);
5862 return cp_convert (totype, expr, complain);
5865 if (issue_conversion_warnings && (complain & tf_warning))
5866 conversion_null_warnings (totype, expr, fn, argnum);
5868 switch (convs->kind)
5872 struct z_candidate *cand = convs->cand;
5873 tree convfn = cand->fn;
5876 /* If we're initializing from {}, it's value-initialization. */
5877 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
5878 && CONSTRUCTOR_NELTS (expr) == 0
5879 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
5881 bool direct = CONSTRUCTOR_IS_DIRECT_INIT (expr);
5882 expr = build_value_init (totype, complain);
5883 expr = get_target_expr_sfinae (expr, complain);
5884 if (expr != error_mark_node)
5886 TARGET_EXPR_LIST_INIT_P (expr) = true;
5887 TARGET_EXPR_DIRECT_INIT_P (expr) = direct;
5892 expr = mark_rvalue_use (expr);
5894 /* When converting from an init list we consider explicit
5895 constructors, but actually trying to call one is an error. */
5896 if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn)
5897 /* Unless this is for direct-list-initialization. */
5898 && !(BRACE_ENCLOSED_INITIALIZER_P (expr)
5899 && CONSTRUCTOR_IS_DIRECT_INIT (expr))
5900 /* Unless we're calling it for value-initialization from an
5901 empty list, since that is handled separately in 8.5.4. */
5902 && cand->num_convs > 0)
5904 error ("converting to %qT from initializer list would use "
5905 "explicit constructor %qD", totype, convfn);
5908 /* Set user_conv_p on the argument conversions, so rvalue/base
5909 handling knows not to allow any more UDCs. */
5910 for (i = 0; i < cand->num_convs; ++i)
5911 cand->convs[i]->user_conv_p = true;
5913 expr = build_over_call (cand, LOOKUP_NORMAL, complain);
5915 /* If this is a constructor or a function returning an aggr type,
5916 we need to build up a TARGET_EXPR. */
5917 if (DECL_CONSTRUCTOR_P (convfn))
5919 expr = build_cplus_new (totype, expr, complain);
5921 /* Remember that this was list-initialization. */
5922 if (convs->check_narrowing && expr != error_mark_node)
5923 TARGET_EXPR_LIST_INIT_P (expr) = true;
5929 expr = mark_rvalue_use (expr);
5930 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
5932 int nelts = CONSTRUCTOR_NELTS (expr);
5934 expr = build_value_init (totype, complain);
5935 else if (nelts == 1)
5936 expr = CONSTRUCTOR_ELT (expr, 0)->value;
5941 if (type_unknown_p (expr))
5942 expr = instantiate_type (totype, expr, complain);
5943 /* Convert a constant to its underlying value, unless we are
5944 about to bind it to a reference, in which case we need to
5945 leave it as an lvalue. */
5948 expr = decl_constant_value_safe (expr);
5949 if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
5950 /* If __null has been converted to an integer type, we do not
5951 want to warn about uses of EXPR as an integer, rather than
5953 expr = build_int_cst (totype, 0);
5957 /* We leave bad_p off ck_ambig because overload resolution considers
5958 it valid, it just fails when we try to perform it. So we need to
5959 check complain here, too. */
5960 if (complain & tf_error)
5962 /* Call build_user_type_conversion again for the error. */
5963 build_user_type_conversion (totype, convs->u.expr, LOOKUP_NORMAL,
5966 error (" initializing argument %P of %q+D", argnum, fn);
5968 return error_mark_node;
5972 /* Conversion to std::initializer_list<T>. */
5973 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
5974 tree new_ctor = build_constructor (init_list_type_node, NULL);
5975 unsigned len = CONSTRUCTOR_NELTS (expr);
5976 tree array, val, field;
5977 vec<constructor_elt, va_gc> *vec = NULL;
5980 /* Convert all the elements. */
5981 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
5983 tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
5984 1, false, false, complain);
5985 if (sub == error_mark_node)
5987 if (!BRACE_ENCLOSED_INITIALIZER_P (val))
5988 check_narrowing (TREE_TYPE (sub), val);
5989 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
5990 if (!TREE_CONSTANT (sub))
5991 TREE_CONSTANT (new_ctor) = false;
5993 /* Build up the array. */
5994 elttype = cp_build_qualified_type
5995 (elttype, cp_type_quals (elttype) | TYPE_QUAL_CONST);
5996 array = build_array_of_n_type (elttype, len);
5997 array = finish_compound_literal (array, new_ctor, complain);
5998 /* Take the address explicitly rather than via decay_conversion
5999 to avoid the error about taking the address of a temporary. */
6000 array = cp_build_addr_expr (array, complain);
6001 array = cp_convert (build_pointer_type (elttype), array, complain);
6003 /* Build up the initializer_list object. */
6004 totype = complete_type (totype);
6005 field = next_initializable_field (TYPE_FIELDS (totype));
6006 CONSTRUCTOR_APPEND_ELT (vec, field, array);
6007 field = next_initializable_field (DECL_CHAIN (field));
6008 CONSTRUCTOR_APPEND_ELT (vec, field, size_int (len));
6009 new_ctor = build_constructor (totype, vec);
6010 return get_target_expr_sfinae (new_ctor, complain);
6014 if (TREE_CODE (totype) == COMPLEX_TYPE)
6016 tree real = CONSTRUCTOR_ELT (expr, 0)->value;
6017 tree imag = CONSTRUCTOR_ELT (expr, 1)->value;
6018 real = perform_implicit_conversion (TREE_TYPE (totype),
6020 imag = perform_implicit_conversion (TREE_TYPE (totype),
6022 expr = build2 (COMPLEX_EXPR, totype, real, imag);
6023 return fold_if_not_in_template (expr);
6025 expr = reshape_init (totype, expr, complain);
6026 return get_target_expr_sfinae (digest_init (totype, expr, complain),
6033 expr = convert_like_real (next_conversion (convs), expr, fn, argnum,
6034 convs->kind == ck_ref_bind ? -1 : 1,
6035 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
6038 if (expr == error_mark_node)
6039 return error_mark_node;
6041 switch (convs->kind)
6044 expr = decay_conversion (expr, complain);
6045 if (expr == error_mark_node)
6046 return error_mark_node;
6048 if (! MAYBE_CLASS_TYPE_P (totype))
6050 /* Else fall through. */
6052 if (convs->kind == ck_base && !convs->need_temporary_p)
6054 /* We are going to bind a reference directly to a base-class
6055 subobject of EXPR. */
6056 /* Build an expression for `*((base*) &expr)'. */
6057 expr = cp_build_addr_expr (expr, complain);
6058 expr = convert_to_base (expr, build_pointer_type (totype),
6059 !c_cast_p, /*nonnull=*/true, complain);
6060 expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
6064 /* Copy-initialization where the cv-unqualified version of the source
6065 type is the same class as, or a derived class of, the class of the
6066 destination [is treated as direct-initialization]. [dcl.init] */
6067 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
6068 if (convs->user_conv_p)
6069 /* This conversion is being done in the context of a user-defined
6070 conversion (i.e. the second step of copy-initialization), so
6071 don't allow any more. */
6072 flags |= LOOKUP_NO_CONVERSION;
6073 if (convs->rvaluedness_matches_p)
6074 flags |= LOOKUP_PREFER_RVALUE;
6075 if (TREE_CODE (expr) == TARGET_EXPR
6076 && TARGET_EXPR_LIST_INIT_P (expr))
6077 /* Copy-list-initialization doesn't actually involve a copy. */
6079 expr = build_temp (expr, totype, flags, &diag_kind, complain);
6080 if (diag_kind && fn && complain)
6081 emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (fn), 0,
6082 " initializing argument %P of %qD", argnum, fn);
6083 return build_cplus_new (totype, expr, complain);
6087 tree ref_type = totype;
6089 if (convs->bad_p && !next_conversion (convs)->bad_p)
6091 gcc_assert (TYPE_REF_IS_RVALUE (ref_type)
6092 && real_lvalue_p (expr));
6094 error_at (loc, "cannot bind %qT lvalue to %qT",
6095 TREE_TYPE (expr), totype);
6097 error (" initializing argument %P of %q+D", argnum, fn);
6098 return error_mark_node;
6101 /* If necessary, create a temporary.
6103 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6104 that need temporaries, even when their types are reference
6105 compatible with the type of reference being bound, so the
6106 upcoming call to cp_build_addr_expr doesn't fail. */
6107 if (convs->need_temporary_p
6108 || TREE_CODE (expr) == CONSTRUCTOR
6109 || TREE_CODE (expr) == VA_ARG_EXPR)
6111 /* Otherwise, a temporary of type "cv1 T1" is created and
6112 initialized from the initializer expression using the rules
6113 for a non-reference copy-initialization (8.5). */
6115 tree type = TREE_TYPE (ref_type);
6116 cp_lvalue_kind lvalue = real_lvalue_p (expr);
6118 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6119 (type, next_conversion (convs)->type));
6120 if (!CP_TYPE_CONST_NON_VOLATILE_P (type)
6121 && !TYPE_REF_IS_RVALUE (ref_type))
6123 /* If the reference is volatile or non-const, we
6124 cannot create a temporary. */
6125 if (lvalue & clk_bitfield)
6126 error_at (loc, "cannot bind bitfield %qE to %qT",
6128 else if (lvalue & clk_packed)
6129 error_at (loc, "cannot bind packed field %qE to %qT",
6132 error_at (loc, "cannot bind rvalue %qE to %qT",
6134 return error_mark_node;
6136 /* If the source is a packed field, and we must use a copy
6137 constructor, then building the target expr will require
6138 binding the field to the reference parameter to the
6139 copy constructor, and we'll end up with an infinite
6140 loop. If we can use a bitwise copy, then we'll be
6142 if ((lvalue & clk_packed)
6143 && CLASS_TYPE_P (type)
6144 && type_has_nontrivial_copy_init (type))
6146 error_at (loc, "cannot bind packed field %qE to %qT",
6148 return error_mark_node;
6150 if (lvalue & clk_bitfield)
6152 expr = convert_bitfield_to_declared_type (expr);
6153 expr = fold_convert (type, expr);
6155 expr = build_target_expr_with_type (expr, type, complain);
6158 /* Take the address of the thing to which we will bind the
6160 expr = cp_build_addr_expr (expr, complain);
6161 if (expr == error_mark_node)
6162 return error_mark_node;
6164 /* Convert it to a pointer to the type referred to by the
6165 reference. This will adjust the pointer if a derived to
6166 base conversion is being performed. */
6167 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
6169 /* Convert the pointer to the desired reference type. */
6170 return build_nop (ref_type, expr);
6174 return decay_conversion (expr, complain);
6177 /* Warn about deprecated conversion if appropriate. */
6178 string_conv_p (totype, expr, 1);
6183 expr = convert_to_base (expr, totype, !c_cast_p,
6184 /*nonnull=*/false, complain);
6185 return build_nop (totype, expr);
6188 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
6189 c_cast_p, complain);
6195 if (convs->check_narrowing)
6196 check_narrowing (totype, expr);
6198 if (issue_conversion_warnings)
6199 expr = cp_convert_and_check (totype, expr, complain);
6201 expr = convert (totype, expr);
6206 /* ARG is being passed to a varargs function. Perform any conversions
6207 required. Return the converted value. */
6210 convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain)
6213 location_t loc = EXPR_LOC_OR_HERE (arg);
6217 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6218 standard conversions are performed. */
6219 arg = decay_conversion (arg, complain);
6220 arg_type = TREE_TYPE (arg);
6223 If the argument has integral or enumeration type that is subject
6224 to the integral promotions (_conv.prom_), or a floating point
6225 type that is subject to the floating point promotion
6226 (_conv.fpprom_), the value of the argument is converted to the
6227 promoted type before the call. */
6228 if (TREE_CODE (arg_type) == REAL_TYPE
6229 && (TYPE_PRECISION (arg_type)
6230 < TYPE_PRECISION (double_type_node))
6231 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type)))
6233 if ((complain & tf_warning)
6234 && warn_double_promotion && !c_inhibit_evaluation_warnings)
6235 warning_at (loc, OPT_Wdouble_promotion,
6236 "implicit conversion from %qT to %qT when passing "
6237 "argument to function",
6238 arg_type, double_type_node);
6239 arg = convert_to_real (double_type_node, arg);
6241 else if (NULLPTR_TYPE_P (arg_type))
6242 arg = null_pointer_node;
6243 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type))
6245 if (SCOPED_ENUM_P (arg_type) && !abi_version_at_least (6))
6247 if (complain & tf_warning)
6248 warning_at (loc, OPT_Wabi, "scoped enum %qT will not promote to an "
6249 "integral type in a future version of GCC", arg_type);
6250 arg = cp_convert (ENUM_UNDERLYING_TYPE (arg_type), arg, complain);
6252 arg = cp_perform_integral_promotions (arg, complain);
6255 arg = require_complete_type_sfinae (arg, complain);
6256 arg_type = TREE_TYPE (arg);
6258 if (arg != error_mark_node
6259 /* In a template (or ill-formed code), we can have an incomplete type
6260 even after require_complete_type_sfinae, in which case we don't know
6261 whether it has trivial copy or not. */
6262 && COMPLETE_TYPE_P (arg_type))
6264 /* Build up a real lvalue-to-rvalue conversion in case the
6265 copy constructor is trivial but not callable. */
6266 if (!cp_unevaluated_operand && CLASS_TYPE_P (arg_type))
6267 force_rvalue (arg, complain);
6269 /* [expr.call] 5.2.2/7:
6270 Passing a potentially-evaluated argument of class type (Clause 9)
6271 with a non-trivial copy constructor or a non-trivial destructor
6272 with no corresponding parameter is conditionally-supported, with
6273 implementation-defined semantics.
6275 We used to just warn here and do a bitwise copy, but now
6276 cp_expr_size will abort if we try to do that.
6278 If the call appears in the context of a sizeof expression,
6279 it is not potentially-evaluated. */
6280 if (cp_unevaluated_operand == 0
6281 && (type_has_nontrivial_copy_init (arg_type)
6282 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type)))
6284 if (complain & tf_error)
6285 error_at (loc, "cannot pass objects of non-trivially-copyable "
6286 "type %q#T through %<...%>", arg_type);
6288 return error_mark_node;
6295 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6298 build_x_va_arg (source_location loc, tree expr, tree type)
6300 if (processing_template_decl)
6301 return build_min (VA_ARG_EXPR, type, expr);
6303 type = complete_type_or_else (type, NULL_TREE);
6305 if (expr == error_mark_node || !type)
6306 return error_mark_node;
6308 expr = mark_lvalue_use (expr);
6310 if (type_has_nontrivial_copy_init (type)
6311 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6312 || TREE_CODE (type) == REFERENCE_TYPE)
6314 /* Remove reference types so we don't ICE later on. */
6315 tree type1 = non_reference (type);
6316 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
6317 error ("cannot receive objects of non-trivially-copyable type %q#T "
6318 "through %<...%>; ", type);
6319 expr = convert (build_pointer_type (type1), null_node);
6320 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
6324 return build_va_arg (loc, expr, type);
6327 /* TYPE has been given to va_arg. Apply the default conversions which
6328 would have happened when passed via ellipsis. Return the promoted
6329 type, or the passed type if there is no change. */
6332 cxx_type_promotes_to (tree type)
6336 /* Perform the array-to-pointer and function-to-pointer
6338 type = type_decays_to (type);
6340 promote = type_promotes_to (type);
6341 if (same_type_p (type, promote))
6347 /* ARG is a default argument expression being passed to a parameter of
6348 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6349 zero-based argument number. Do any required conversions. Return
6350 the converted value. */
6352 static GTY(()) vec<tree, va_gc> *default_arg_context;
6354 push_defarg_context (tree fn)
6355 { vec_safe_push (default_arg_context, fn); }
6358 pop_defarg_context (void)
6359 { default_arg_context->pop (); }
6362 convert_default_arg (tree type, tree arg, tree fn, int parmnum,
6363 tsubst_flags_t complain)
6368 /* See through clones. */
6369 fn = DECL_ORIGIN (fn);
6371 /* Detect recursion. */
6372 FOR_EACH_VEC_SAFE_ELT (default_arg_context, i, t)
6375 if (complain & tf_error)
6376 error ("recursive evaluation of default argument for %q#D", fn);
6377 return error_mark_node;
6380 /* If the ARG is an unparsed default argument expression, the
6381 conversion cannot be performed. */
6382 if (TREE_CODE (arg) == DEFAULT_ARG)
6384 if (complain & tf_error)
6385 error ("call to %qD uses the default argument for parameter %P, which "
6386 "is not yet defined", fn, parmnum);
6387 return error_mark_node;
6390 push_defarg_context (fn);
6392 if (fn && DECL_TEMPLATE_INFO (fn))
6393 arg = tsubst_default_argument (fn, type, arg, complain);
6399 The names in the expression are bound, and the semantic
6400 constraints are checked, at the point where the default
6401 expressions appears.
6403 we must not perform access checks here. */
6404 push_deferring_access_checks (dk_no_check);
6405 /* We must make a copy of ARG, in case subsequent processing
6406 alters any part of it. */
6407 arg = break_out_target_exprs (arg);
6408 if (TREE_CODE (arg) == CONSTRUCTOR)
6410 arg = digest_init (type, arg, complain);
6411 arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT,
6412 ICR_DEFAULT_ARGUMENT, fn, parmnum,
6417 arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT,
6418 ICR_DEFAULT_ARGUMENT, fn, parmnum,
6420 arg = convert_for_arg_passing (type, arg, complain);
6422 pop_deferring_access_checks();
6424 pop_defarg_context ();
6429 /* Returns the type which will really be used for passing an argument of
6433 type_passed_as (tree type)
6435 /* Pass classes with copy ctors by invisible reference. */
6436 if (TREE_ADDRESSABLE (type))
6438 type = build_reference_type (type);
6439 /* There are no other pointers to this temporary. */
6440 type = cp_build_qualified_type (type, TYPE_QUAL_RESTRICT);
6442 else if (targetm.calls.promote_prototypes (type)
6443 && INTEGRAL_TYPE_P (type)
6444 && COMPLETE_TYPE_P (type)
6445 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
6446 TYPE_SIZE (integer_type_node)))
6447 type = integer_type_node;
6452 /* Actually perform the appropriate conversion. */
6455 convert_for_arg_passing (tree type, tree val, tsubst_flags_t complain)
6459 /* If VAL is a bitfield, then -- since it has already been converted
6460 to TYPE -- it cannot have a precision greater than TYPE.
6462 If it has a smaller precision, we must widen it here. For
6463 example, passing "int f:3;" to a function expecting an "int" will
6464 not result in any conversion before this point.
6466 If the precision is the same we must not risk widening. For
6467 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6468 often have type "int", even though the C++ type for the field is
6469 "long long". If the value is being passed to a function
6470 expecting an "int", then no conversions will be required. But,
6471 if we call convert_bitfield_to_declared_type, the bitfield will
6472 be converted to "long long". */
6473 bitfield_type = is_bitfield_expr_with_lowered_type (val);
6475 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
6476 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
6478 if (val == error_mark_node)
6480 /* Pass classes with copy ctors by invisible reference. */
6481 else if (TREE_ADDRESSABLE (type))
6482 val = build1 (ADDR_EXPR, build_reference_type (type), val);
6483 else if (targetm.calls.promote_prototypes (type)
6484 && INTEGRAL_TYPE_P (type)
6485 && COMPLETE_TYPE_P (type)
6486 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
6487 TYPE_SIZE (integer_type_node)))
6488 val = cp_perform_integral_promotions (val, complain);
6489 if ((complain & tf_warning)
6490 && warn_suggest_attribute_format)
6492 tree rhstype = TREE_TYPE (val);
6493 const enum tree_code coder = TREE_CODE (rhstype);
6494 const enum tree_code codel = TREE_CODE (type);
6495 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6497 && check_missing_format_attribute (type, rhstype))
6498 warning (OPT_Wsuggest_attribute_format,
6499 "argument of function call might be a candidate for a format attribute");
6504 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6505 which no conversions at all should be done. This is true for some
6506 builtins which don't act like normal functions. */
6509 magic_varargs_p (tree fn)
6511 if (DECL_BUILT_IN (fn))
6512 switch (DECL_FUNCTION_CODE (fn))
6514 case BUILT_IN_CLASSIFY_TYPE:
6515 case BUILT_IN_CONSTANT_P:
6516 case BUILT_IN_NEXT_ARG:
6517 case BUILT_IN_VA_START:
6521 return lookup_attribute ("type generic",
6522 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
6528 /* Returns the decl of the dispatcher function if FN is a function version. */
6531 get_function_version_dispatcher (tree fn)
6533 tree dispatcher_decl = NULL;
6535 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
6536 && DECL_FUNCTION_VERSIONED (fn));
6538 gcc_assert (targetm.get_function_versions_dispatcher);
6539 dispatcher_decl = targetm.get_function_versions_dispatcher (fn);
6541 if (dispatcher_decl == NULL)
6543 error_at (input_location, "use of multiversioned function "
6544 "without a default");
6548 retrofit_lang_decl (dispatcher_decl);
6549 gcc_assert (dispatcher_decl != NULL);
6550 return dispatcher_decl;
6553 /* fn is a function version dispatcher that is marked used. Mark all the
6554 semantically identical function versions it will dispatch as used. */
6557 mark_versions_used (tree fn)
6559 struct cgraph_node *node;
6560 struct cgraph_function_version_info *node_v;
6561 struct cgraph_function_version_info *it_v;
6563 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
6565 node = cgraph_get_node (fn);
6569 gcc_assert (node->dispatcher_function);
6571 node_v = get_cgraph_node_version (node);
6575 /* All semantically identical versions are chained. Traverse and mark each
6576 one of them as used. */
6577 it_v = node_v->next;
6578 while (it_v != NULL)
6580 mark_used (it_v->this_node->symbol.decl);
6585 /* Subroutine of the various build_*_call functions. Overload resolution
6586 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
6587 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
6588 bitmask of various LOOKUP_* flags which apply to the call itself. */
6591 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
6594 const vec<tree, va_gc> *args = cand->args;
6595 tree first_arg = cand->first_arg;
6596 conversion **convs = cand->convs;
6598 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
6603 unsigned int arg_index = 0;
6607 bool already_used = false;
6609 /* In a template, there is no need to perform all of the work that
6610 is normally done. We are only interested in the type of the call
6611 expression, i.e., the return type of the function. Any semantic
6612 errors will be deferred until the template is instantiated. */
6613 if (processing_template_decl)
6617 const tree *argarray;
6620 return_type = TREE_TYPE (TREE_TYPE (fn));
6621 nargs = vec_safe_length (args);
6622 if (first_arg == NULL_TREE)
6623 argarray = args->address ();
6631 alcarray = XALLOCAVEC (tree, nargs);
6632 alcarray[0] = first_arg;
6633 FOR_EACH_VEC_SAFE_ELT (args, ix, arg)
6634 alcarray[ix + 1] = arg;
6635 argarray = alcarray;
6638 addr = build_addr_func (fn, complain);
6639 if (addr == error_mark_node)
6640 return error_mark_node;
6641 expr = build_call_array_loc (input_location, return_type,
6642 addr, nargs, argarray);
6643 if (TREE_THIS_VOLATILE (fn) && cfun)
6644 current_function_returns_abnormally = 1;
6645 return convert_from_reference (expr);
6648 /* Give any warnings we noticed during overload resolution. */
6649 if (cand->warnings && (complain & tf_warning))
6651 struct candidate_warning *w;
6652 for (w = cand->warnings; w; w = w->next)
6653 joust (cand, w->loser, 1, complain);
6656 /* Make =delete work with SFINAE. */
6657 if (DECL_DELETED_FN (fn) && !(complain & tf_error))
6658 return error_mark_node;
6660 if (DECL_FUNCTION_MEMBER_P (fn))
6663 /* If FN is a template function, two cases must be considered.
6668 template <class T> void f();
6670 template <class T> struct B {
6674 struct C : A, B<int> {
6676 using B<int>::g; // #2
6679 In case #1 where `A::f' is a member template, DECL_ACCESS is
6680 recorded in the primary template but not in its specialization.
6681 We check access of FN using its primary template.
6683 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
6684 because it is a member of class template B, DECL_ACCESS is
6685 recorded in the specialization `B<int>::g'. We cannot use its
6686 primary template because `B<T>::g' and `B<int>::g' may have
6687 different access. */
6688 if (DECL_TEMPLATE_INFO (fn)
6689 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
6690 access_fn = DECL_TI_TEMPLATE (fn);
6693 if (!perform_or_defer_access_check (cand->access_path, access_fn,
6695 return error_mark_node;
6698 /* If we're checking for implicit delete, don't bother with argument
6700 if (flags & LOOKUP_SPECULATIVE)
6702 if (DECL_DELETED_FN (fn))
6704 if (complain & tf_error)
6706 return error_mark_node;
6708 if (cand->viable == 1)
6710 else if (!(complain & tf_error))
6711 /* Reject bad conversions now. */
6712 return error_mark_node;
6713 /* else continue to get conversion error. */
6716 /* N3276 magic doesn't apply to nested calls. */
6717 int decltype_flag = (complain & tf_decltype);
6718 complain &= ~tf_decltype;
6720 /* Find maximum size of vector to hold converted arguments. */
6721 parmlen = list_length (parm);
6722 nargs = vec_safe_length (args) + (first_arg != NULL_TREE ? 1 : 0);
6723 if (parmlen > nargs)
6725 argarray = XALLOCAVEC (tree, nargs);
6727 /* The implicit parameters to a constructor are not considered by overload
6728 resolution, and must be of the proper type. */
6729 if (DECL_CONSTRUCTOR_P (fn))
6731 if (first_arg != NULL_TREE)
6733 argarray[j++] = first_arg;
6734 first_arg = NULL_TREE;
6738 argarray[j++] = (*args)[arg_index];
6741 parm = TREE_CHAIN (parm);
6742 /* We should never try to call the abstract constructor. */
6743 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
6745 if (DECL_HAS_VTT_PARM_P (fn))
6747 argarray[j++] = (*args)[arg_index];
6749 parm = TREE_CHAIN (parm);
6752 /* Bypass access control for 'this' parameter. */
6753 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6755 tree parmtype = TREE_VALUE (parm);
6756 tree arg = (first_arg != NULL_TREE
6758 : (*args)[arg_index]);
6759 tree argtype = TREE_TYPE (arg);
6763 if (convs[i]->bad_p)
6765 if (complain & tf_error)
6766 permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
6767 TREE_TYPE (argtype), fn);
6769 return error_mark_node;
6772 /* See if the function member or the whole class type is declared
6773 final and the call can be devirtualized. */
6774 if (DECL_FINAL_P (fn)
6775 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn))))
6776 flags |= LOOKUP_NONVIRTUAL;
6778 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
6779 X is called for an object that is not of type X, or of a type
6780 derived from X, the behavior is undefined.
6782 So we can assume that anything passed as 'this' is non-null, and
6783 optimize accordingly. */
6784 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
6785 /* Convert to the base in which the function was declared. */
6786 gcc_assert (cand->conversion_path != NULL_TREE);
6787 converted_arg = build_base_path (PLUS_EXPR,
6789 cand->conversion_path,
6791 /* Check that the base class is accessible. */
6792 if (!accessible_base_p (TREE_TYPE (argtype),
6793 BINFO_TYPE (cand->conversion_path), true))
6794 error ("%qT is not an accessible base of %qT",
6795 BINFO_TYPE (cand->conversion_path),
6796 TREE_TYPE (argtype));
6797 /* If fn was found by a using declaration, the conversion path
6798 will be to the derived class, not the base declaring fn. We
6799 must convert from derived to base. */
6800 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
6801 TREE_TYPE (parmtype), ba_unique,
6803 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
6804 base_binfo, 1, complain);
6806 argarray[j++] = converted_arg;
6807 parm = TREE_CHAIN (parm);
6808 if (first_arg != NULL_TREE)
6809 first_arg = NULL_TREE;
6816 gcc_assert (first_arg == NULL_TREE);
6817 for (; arg_index < vec_safe_length (args) && parm;
6818 parm = TREE_CHAIN (parm), ++arg_index, ++i)
6820 tree type = TREE_VALUE (parm);
6821 tree arg = (*args)[arg_index];
6822 bool conversion_warning = true;
6826 /* If the argument is NULL and used to (implicitly) instantiate a
6827 template function (and bind one of the template arguments to
6828 the type of 'long int'), we don't want to warn about passing NULL
6829 to non-pointer argument.
6830 For example, if we have this template function:
6832 template<typename T> void func(T x) {}
6834 we want to warn (when -Wconversion is enabled) in this case:
6840 but not in this case:
6846 if (arg == null_node
6847 && DECL_TEMPLATE_INFO (fn)
6848 && cand->template_decl
6849 && !(flags & LOOKUP_EXPLICIT_TMPL_ARGS))
6850 conversion_warning = false;
6852 /* Warn about initializer_list deduction that isn't currently in the
6854 if (cxx_dialect > cxx98
6855 && flag_deduce_init_list
6856 && cand->template_decl
6857 && is_std_init_list (non_reference (type))
6858 && BRACE_ENCLOSED_INITIALIZER_P (arg))
6860 tree tmpl = TI_TEMPLATE (cand->template_decl);
6861 tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
6862 tree patparm = get_pattern_parm (realparm, tmpl);
6863 tree pattype = TREE_TYPE (patparm);
6864 if (PACK_EXPANSION_P (pattype))
6865 pattype = PACK_EXPANSION_PATTERN (pattype);
6866 pattype = non_reference (pattype);
6868 if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM
6869 && (cand->explicit_targs == NULL_TREE
6870 || (TREE_VEC_LENGTH (cand->explicit_targs)
6871 <= TEMPLATE_TYPE_IDX (pattype))))
6873 pedwarn (input_location, 0, "deducing %qT as %qT",
6874 non_reference (TREE_TYPE (patparm)),
6875 non_reference (type));
6876 pedwarn (input_location, 0, " in call to %q+D", cand->fn);
6877 pedwarn (input_location, 0,
6878 " (you can disable this with -fno-deduce-init-list)");
6882 val = convert_like_with_context (conv, arg, fn, i-is_method,
6885 : complain & (~tf_warning));
6887 val = convert_for_arg_passing (type, val, complain);
6888 if (val == error_mark_node)
6889 return error_mark_node;
6891 argarray[j++] = val;
6894 /* Default arguments */
6895 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
6897 if (TREE_VALUE (parm) == error_mark_node)
6898 return error_mark_node;
6899 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
6900 TREE_PURPOSE (parm),
6906 for (; arg_index < vec_safe_length (args); ++arg_index)
6908 tree a = (*args)[arg_index];
6909 if (magic_varargs_p (fn))
6910 /* Do no conversions for magic varargs. */
6911 a = mark_type_use (a);
6913 a = convert_arg_to_ellipsis (a, complain);
6917 gcc_assert (j <= nargs);
6920 check_function_arguments (TREE_TYPE (fn), nargs, argarray);
6922 /* Avoid actually calling copy constructors and copy assignment operators,
6925 if (! flag_elide_constructors)
6926 /* Do things the hard way. */;
6927 else if (cand->num_convs == 1
6928 && (DECL_COPY_CONSTRUCTOR_P (fn)
6929 || DECL_MOVE_CONSTRUCTOR_P (fn)))
6932 tree arg = argarray[num_artificial_parms_for (fn)];
6934 bool trivial = trivial_fn_p (fn);
6936 /* Pull out the real argument, disregarding const-correctness. */
6938 while (CONVERT_EXPR_P (targ)
6939 || TREE_CODE (targ) == NON_LVALUE_EXPR)
6940 targ = TREE_OPERAND (targ, 0);
6941 if (TREE_CODE (targ) == ADDR_EXPR)
6943 targ = TREE_OPERAND (targ, 0);
6944 if (!same_type_ignoring_top_level_qualifiers_p
6945 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
6954 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
6956 /* [class.copy]: the copy constructor is implicitly defined even if
6957 the implementation elided its use. */
6958 if (!trivial || DECL_DELETED_FN (fn))
6961 already_used = true;
6964 /* If we're creating a temp and we already have one, don't create a
6965 new one. If we're not creating a temp but we get one, use
6966 INIT_EXPR to collapse the temp into our target. Otherwise, if the
6967 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
6968 temp or an INIT_EXPR otherwise. */
6970 if (integer_zerop (fa))
6972 if (TREE_CODE (arg) == TARGET_EXPR)
6975 return force_target_expr (DECL_CONTEXT (fn), arg, complain);
6977 else if (TREE_CODE (arg) == TARGET_EXPR || trivial)
6979 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
6982 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
6986 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
6987 && trivial_fn_p (fn)
6988 && !DECL_DELETED_FN (fn))
6990 tree to = stabilize_reference
6991 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
6992 tree type = TREE_TYPE (to);
6993 tree as_base = CLASSTYPE_AS_BASE (type);
6994 tree arg = argarray[1];
6996 if (is_really_empty_class (type))
6998 /* Avoid copying empty classes. */
6999 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
7000 TREE_NO_WARNING (val) = 1;
7001 val = build2 (COMPOUND_EXPR, type, val, to);
7002 TREE_NO_WARNING (val) = 1;
7004 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
7006 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
7007 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
7011 /* We must only copy the non-tail padding parts. */
7013 tree array_type, alias_set;
7015 arg2 = TYPE_SIZE_UNIT (as_base);
7016 arg0 = cp_build_addr_expr (to, complain);
7018 array_type = build_array_type (char_type_node,
7020 (size_binop (MINUS_EXPR,
7021 arg2, size_int (1))));
7022 alias_set = build_int_cst (build_pointer_type (type), 0);
7023 t = build2 (MODIFY_EXPR, void_type_node,
7024 build2 (MEM_REF, array_type, arg0, alias_set),
7025 build2 (MEM_REF, array_type, arg, alias_set));
7026 val = build2 (COMPOUND_EXPR, TREE_TYPE (to), t, to);
7027 TREE_NO_WARNING (val) = 1;
7032 else if (DECL_DESTRUCTOR_P (fn)
7033 && trivial_fn_p (fn)
7034 && !DECL_DELETED_FN (fn))
7035 return fold_convert (void_type_node, argarray[0]);
7036 /* FIXME handle trivial default constructor, too. */
7038 /* For calls to a multi-versioned function, overload resolution
7039 returns the function with the highest target priority, that is,
7040 the version that will checked for dispatching first. If this
7041 version is inlinable, a direct call to this version can be made
7042 otherwise the call should go through the dispatcher. */
7044 if (DECL_FUNCTION_VERSIONED (fn)
7045 && !targetm.target_option.can_inline_p (current_function_decl, fn))
7047 fn = get_function_version_dispatcher (fn);
7051 mark_versions_used (fn);
7057 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0
7058 /* Don't mess with virtual lookup in fold_non_dependent_expr; virtual
7059 functions can't be constexpr. */
7060 && !in_template_function ())
7063 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
7065 ba_any, NULL, complain);
7066 gcc_assert (binfo && binfo != error_mark_node);
7068 /* Warn about deprecated virtual functions now, since we're about
7069 to throw away the decl. */
7070 if (TREE_DEPRECATED (fn))
7071 warn_deprecated_use (fn, NULL_TREE);
7073 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1,
7075 if (TREE_SIDE_EFFECTS (argarray[0]))
7076 argarray[0] = save_expr (argarray[0]);
7077 t = build_pointer_type (TREE_TYPE (fn));
7078 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
7079 fn = build_java_interface_fn_ref (fn, argarray[0]);
7081 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
7086 fn = build_addr_func (fn, complain);
7087 if (fn == error_mark_node)
7088 return error_mark_node;
7091 return build_cxx_call (fn, nargs, argarray, complain|decltype_flag);
7094 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7095 This function performs no overload resolution, conversion, or other
7096 high-level operations. */
7099 build_cxx_call (tree fn, int nargs, tree *argarray,
7100 tsubst_flags_t complain)
7105 /* Remember roughly where this call is. */
7106 location_t loc = EXPR_LOC_OR_HERE (fn);
7107 fn = build_call_a (fn, nargs, argarray);
7108 SET_EXPR_LOCATION (fn, loc);
7110 fndecl = get_callee_fndecl (fn);
7112 /* Check that arguments to builtin functions match the expectations. */
7114 && DECL_BUILT_IN (fndecl)
7115 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
7116 && !check_builtin_function_arguments (fndecl, nargs, argarray))
7117 return error_mark_node;
7119 /* Some built-in function calls will be evaluated at compile-time in
7120 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7121 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7122 optimize_sav = optimize;
7123 if (!optimize && fndecl && DECL_IS_BUILTIN_CONSTANT_P (fndecl)
7124 && current_function_decl
7125 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
7127 fn = fold_if_not_in_template (fn);
7128 optimize = optimize_sav;
7130 if (VOID_TYPE_P (TREE_TYPE (fn)))
7133 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7134 function call is either the operand of a decltype-specifier or the
7135 right operand of a comma operator that is the operand of a
7136 decltype-specifier, a temporary object is not introduced for the
7137 prvalue. The type of the prvalue may be incomplete. */
7138 if (!(complain & tf_decltype))
7140 fn = require_complete_type_sfinae (fn, complain);
7141 if (fn == error_mark_node)
7142 return error_mark_node;
7144 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
7145 fn = build_cplus_new (TREE_TYPE (fn), fn, complain);
7147 return convert_from_reference (fn);
7150 static GTY(()) tree java_iface_lookup_fn;
7152 /* Make an expression which yields the address of the Java interface
7153 method FN. This is achieved by generating a call to libjava's
7154 _Jv_LookupInterfaceMethodIdx(). */
7157 build_java_interface_fn_ref (tree fn, tree instance)
7159 tree lookup_fn, method, idx;
7160 tree klass_ref, iface, iface_ref;
7163 if (!java_iface_lookup_fn)
7165 tree ftype = build_function_type_list (ptr_type_node,
7166 ptr_type_node, ptr_type_node,
7167 java_int_type_node, NULL_TREE);
7168 java_iface_lookup_fn
7169 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype,
7170 0, NOT_BUILT_IN, NULL, NULL_TREE);
7173 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7174 This is the first entry in the vtable. */
7175 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
7176 tf_warning_or_error),
7179 /* Get the java.lang.Class pointer for the interface being called. */
7180 iface = DECL_CONTEXT (fn);
7181 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
7182 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
7183 || DECL_CONTEXT (iface_ref) != iface)
7185 error ("could not find class$ field in java interface type %qT",
7187 return error_mark_node;
7189 iface_ref = build_address (iface_ref);
7190 iface_ref = convert (build_pointer_type (iface), iface_ref);
7192 /* Determine the itable index of FN. */
7194 for (method = TYPE_METHODS (iface); method; method = DECL_CHAIN (method))
7196 if (!DECL_VIRTUAL_P (method))
7202 idx = build_int_cst (NULL_TREE, i);
7204 lookup_fn = build1 (ADDR_EXPR,
7205 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
7206 java_iface_lookup_fn);
7207 return build_call_nary (ptr_type_node, lookup_fn,
7208 3, klass_ref, iface_ref, idx);
7211 /* Returns the value to use for the in-charge parameter when making a
7212 call to a function with the indicated NAME.
7214 FIXME:Can't we find a neater way to do this mapping? */
7217 in_charge_arg_for_name (tree name)
7219 if (name == base_ctor_identifier
7220 || name == base_dtor_identifier)
7221 return integer_zero_node;
7222 else if (name == complete_ctor_identifier)
7223 return integer_one_node;
7224 else if (name == complete_dtor_identifier)
7225 return integer_two_node;
7226 else if (name == deleting_dtor_identifier)
7227 return integer_three_node;
7229 /* This function should only be called with one of the names listed
7235 /* Build a call to a constructor, destructor, or an assignment
7236 operator for INSTANCE, an expression with class type. NAME
7237 indicates the special member function to call; *ARGS are the
7238 arguments. ARGS may be NULL. This may change ARGS. BINFO
7239 indicates the base of INSTANCE that is to be passed as the `this'
7240 parameter to the member function called.
7242 FLAGS are the LOOKUP_* flags to use when processing the call.
7244 If NAME indicates a complete object constructor, INSTANCE may be
7245 NULL_TREE. In this case, the caller will call build_cplus_new to
7246 store the newly constructed object into a VAR_DECL. */
7249 build_special_member_call (tree instance, tree name, vec<tree, va_gc> **args,
7250 tree binfo, int flags, tsubst_flags_t complain)
7253 /* The type of the subobject to be constructed or destroyed. */
7255 vec<tree, va_gc> *allocated = NULL;
7258 gcc_assert (name == complete_ctor_identifier
7259 || name == base_ctor_identifier
7260 || name == complete_dtor_identifier
7261 || name == base_dtor_identifier
7262 || name == deleting_dtor_identifier
7263 || name == ansi_assopname (NOP_EXPR));
7266 /* Resolve the name. */
7267 if (!complete_type_or_maybe_complain (binfo, NULL_TREE, complain))
7268 return error_mark_node;
7270 binfo = TYPE_BINFO (binfo);
7273 gcc_assert (binfo != NULL_TREE);
7275 class_type = BINFO_TYPE (binfo);
7277 /* Handle the special case where INSTANCE is NULL_TREE. */
7278 if (name == complete_ctor_identifier && !instance)
7280 instance = build_int_cst (build_pointer_type (class_type), 0);
7281 instance = build1 (INDIRECT_REF, class_type, instance);
7285 if (name == complete_dtor_identifier
7286 || name == base_dtor_identifier
7287 || name == deleting_dtor_identifier)
7288 gcc_assert (args == NULL || vec_safe_is_empty (*args));
7290 /* Convert to the base class, if necessary. */
7291 if (!same_type_ignoring_top_level_qualifiers_p
7292 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
7294 if (name != ansi_assopname (NOP_EXPR))
7295 /* For constructors and destructors, either the base is
7296 non-virtual, or it is virtual but we are doing the
7297 conversion from a constructor or destructor for the
7298 complete object. In either case, we can convert
7300 instance = convert_to_base_statically (instance, binfo);
7302 /* However, for assignment operators, we must convert
7303 dynamically if the base is virtual. */
7304 instance = build_base_path (PLUS_EXPR, instance,
7305 binfo, /*nonnull=*/1, complain);
7309 gcc_assert (instance != NULL_TREE);
7311 fns = lookup_fnfields (binfo, name, 1);
7313 /* When making a call to a constructor or destructor for a subobject
7314 that uses virtual base classes, pass down a pointer to a VTT for
7316 if ((name == base_ctor_identifier
7317 || name == base_dtor_identifier)
7318 && CLASSTYPE_VBASECLASSES (class_type))
7323 /* If the current function is a complete object constructor
7324 or destructor, then we fetch the VTT directly.
7325 Otherwise, we look it up using the VTT we were given. */
7326 vtt = DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type));
7327 vtt = decay_conversion (vtt, complain);
7328 if (vtt == error_mark_node)
7329 return error_mark_node;
7330 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
7331 build2 (EQ_EXPR, boolean_type_node,
7332 current_in_charge_parm, integer_zero_node),
7335 if (BINFO_SUBVTT_INDEX (binfo))
7336 sub_vtt = fold_build_pointer_plus (vtt, BINFO_SUBVTT_INDEX (binfo));
7342 allocated = make_tree_vector ();
7346 vec_safe_insert (*args, 0, sub_vtt);
7349 ret = build_new_method_call (instance, fns, args,
7350 TYPE_BINFO (BINFO_TYPE (binfo)),
7354 if (allocated != NULL)
7355 release_tree_vector (allocated);
7360 /* Return the NAME, as a C string. The NAME indicates a function that
7361 is a member of TYPE. *FREE_P is set to true if the caller must
7362 free the memory returned.
7364 Rather than go through all of this, we should simply set the names
7365 of constructors and destructors appropriately, and dispense with
7366 ctor_identifier, dtor_identifier, etc. */
7369 name_as_c_string (tree name, tree type, bool *free_p)
7373 /* Assume that we will not allocate memory. */
7375 /* Constructors and destructors are special. */
7376 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
7379 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
7380 /* For a destructor, add the '~'. */
7381 if (name == complete_dtor_identifier
7382 || name == base_dtor_identifier
7383 || name == deleting_dtor_identifier)
7385 pretty_name = concat ("~", pretty_name, NULL);
7386 /* Remember that we need to free the memory allocated. */
7390 else if (IDENTIFIER_TYPENAME_P (name))
7392 pretty_name = concat ("operator ",
7393 type_as_string_translate (TREE_TYPE (name),
7394 TFF_PLAIN_IDENTIFIER),
7396 /* Remember that we need to free the memory allocated. */
7400 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
7405 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
7406 be set, upon return, to the function called. ARGS may be NULL.
7407 This may change ARGS. */
7410 build_new_method_call_1 (tree instance, tree fns, vec<tree, va_gc> **args,
7411 tree conversion_path, int flags,
7412 tree *fn_p, tsubst_flags_t complain)
7414 struct z_candidate *candidates = 0, *cand;
7415 tree explicit_targs = NULL_TREE;
7416 tree basetype = NULL_TREE;
7419 tree first_mem_arg = NULL_TREE;
7422 bool skip_first_for_error;
7423 vec<tree, va_gc> *user_args;
7426 int template_only = 0;
7430 vec<tree, va_gc> *orig_args = NULL;
7433 gcc_assert (instance != NULL_TREE);
7435 /* We don't know what function we're going to call, yet. */
7439 if (error_operand_p (instance)
7440 || !fns || error_operand_p (fns))
7441 return error_mark_node;
7443 if (!BASELINK_P (fns))
7445 if (complain & tf_error)
7446 error ("call to non-function %qD", fns);
7447 return error_mark_node;
7450 orig_instance = instance;
7453 /* Dismantle the baselink to collect all the information we need. */
7454 if (!conversion_path)
7455 conversion_path = BASELINK_BINFO (fns);
7456 access_binfo = BASELINK_ACCESS_BINFO (fns);
7457 optype = BASELINK_OPTYPE (fns);
7458 fns = BASELINK_FUNCTIONS (fns);
7459 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7461 explicit_targs = TREE_OPERAND (fns, 1);
7462 fns = TREE_OPERAND (fns, 0);
7465 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
7466 || TREE_CODE (fns) == TEMPLATE_DECL
7467 || TREE_CODE (fns) == OVERLOAD);
7468 fn = get_first_fn (fns);
7469 name = DECL_NAME (fn);
7471 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
7472 gcc_assert (CLASS_TYPE_P (basetype));
7474 if (processing_template_decl)
7476 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
7477 instance = build_non_dependent_expr (instance);
7479 make_args_non_dependent (*args);
7482 user_args = args == NULL ? NULL : *args;
7483 /* Under DR 147 A::A() is an invalid constructor call,
7484 not a functional cast. */
7485 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
7487 if (! (complain & tf_error))
7488 return error_mark_node;
7490 permerror (input_location,
7491 "cannot call constructor %<%T::%D%> directly",
7493 permerror (input_location, " for a function-style cast, remove the "
7494 "redundant %<::%D%>", name);
7495 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
7500 /* Figure out whether to skip the first argument for the error
7501 message we will display to users if an error occurs. We don't
7502 want to display any compiler-generated arguments. The "this"
7503 pointer hasn't been added yet. However, we must remove the VTT
7504 pointer if this is a call to a base-class constructor or
7506 skip_first_for_error = false;
7507 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
7509 /* Callers should explicitly indicate whether they want to construct
7510 the complete object or just the part without virtual bases. */
7511 gcc_assert (name != ctor_identifier);
7512 /* Similarly for destructors. */
7513 gcc_assert (name != dtor_identifier);
7514 /* Remove the VTT pointer, if present. */
7515 if ((name == base_ctor_identifier || name == base_dtor_identifier)
7516 && CLASSTYPE_VBASECLASSES (basetype))
7517 skip_first_for_error = true;
7520 /* Process the argument list. */
7521 if (args != NULL && *args != NULL)
7523 *args = resolve_args (*args, complain);
7525 return error_mark_node;
7528 instance_ptr = build_this (instance);
7530 /* It's OK to call destructors and constructors on cv-qualified objects.
7531 Therefore, convert the INSTANCE_PTR to the unqualified type, if
7533 if (DECL_DESTRUCTOR_P (fn)
7534 || DECL_CONSTRUCTOR_P (fn))
7536 tree type = build_pointer_type (basetype);
7537 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
7538 instance_ptr = build_nop (type, instance_ptr);
7540 if (DECL_DESTRUCTOR_P (fn))
7541 name = complete_dtor_identifier;
7543 first_mem_arg = instance_ptr;
7545 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7546 p = conversion_obstack_alloc (0);
7548 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
7549 initializer, not T({ }). */
7550 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !vec_safe_is_empty (*args)
7551 && BRACE_ENCLOSED_INITIALIZER_P ((**args)[0])
7552 && CONSTRUCTOR_IS_DIRECT_INIT ((**args)[0]))
7554 tree init_list = (**args)[0];
7555 tree init = NULL_TREE;
7557 gcc_assert ((*args)->length () == 1
7558 && !(flags & LOOKUP_ONLYCONVERTING));
7560 /* If the initializer list has no elements and T is a class type with
7561 a default constructor, the object is value-initialized. Handle
7562 this here so we don't need to handle it wherever we use
7563 build_special_member_call. */
7564 if (CONSTRUCTOR_NELTS (init_list) == 0
7565 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype)
7566 /* For a user-provided default constructor, use the normal
7567 mechanisms so that protected access works. */
7568 && !type_has_user_provided_default_constructor (basetype)
7569 && !processing_template_decl)
7570 init = build_value_init (basetype, complain);
7572 /* If BASETYPE is an aggregate, we need to do aggregate
7574 else if (CP_AGGREGATE_TYPE_P (basetype))
7575 init = digest_init (basetype, init_list, complain);
7580 if (integer_zerop (instance_ptr))
7581 return get_target_expr_sfinae (init, complain);
7582 ob = build_fold_indirect_ref (instance_ptr);
7583 init = build2 (INIT_EXPR, TREE_TYPE (ob), ob, init);
7584 TREE_SIDE_EFFECTS (init) = true;
7588 /* Otherwise go ahead with overload resolution. */
7589 add_list_candidates (fns, first_mem_arg, init_list,
7590 basetype, explicit_targs, template_only,
7591 conversion_path, access_binfo, flags,
7592 &candidates, complain);
7596 add_candidates (fns, first_mem_arg, user_args, optype,
7597 explicit_targs, template_only, conversion_path,
7598 access_binfo, flags, &candidates, complain);
7600 any_viable_p = false;
7601 candidates = splice_viable (candidates, pedantic, &any_viable_p);
7605 if (complain & tf_error)
7607 if (!COMPLETE_OR_OPEN_TYPE_P (basetype))
7608 cxx_incomplete_type_error (instance_ptr, basetype);
7610 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
7611 basetype, optype, build_tree_list_vec (user_args),
7612 TREE_TYPE (TREE_TYPE (instance_ptr)));
7619 pretty_name = name_as_c_string (name, basetype, &free_p);
7620 arglist = build_tree_list_vec (user_args);
7621 if (skip_first_for_error)
7622 arglist = TREE_CHAIN (arglist);
7623 error ("no matching function for call to %<%T::%s(%A)%#V%>",
7624 basetype, pretty_name, arglist,
7625 TREE_TYPE (TREE_TYPE (instance_ptr)));
7629 print_z_candidates (location_of (name), candidates);
7631 call = error_mark_node;
7635 cand = tourney (candidates, complain);
7642 if (complain & tf_error)
7644 pretty_name = name_as_c_string (name, basetype, &free_p);
7645 arglist = build_tree_list_vec (user_args);
7646 if (skip_first_for_error)
7647 arglist = TREE_CHAIN (arglist);
7648 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
7650 print_z_candidates (location_of (name), candidates);
7654 call = error_mark_node;
7661 if (!(flags & LOOKUP_NONVIRTUAL)
7662 && DECL_PURE_VIRTUAL_P (fn)
7663 && instance == current_class_ref
7664 && (DECL_CONSTRUCTOR_P (current_function_decl)
7665 || DECL_DESTRUCTOR_P (current_function_decl))
7666 && (complain & tf_warning))
7667 /* This is not an error, it is runtime undefined
7669 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
7670 "pure virtual %q#D called from constructor"
7671 : "pure virtual %q#D called from destructor"),
7674 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
7675 && is_dummy_object (instance_ptr))
7677 instance = maybe_resolve_dummy (instance);
7678 if (instance == error_mark_node)
7679 call = error_mark_node;
7680 else if (!is_dummy_object (instance))
7682 /* We captured 'this' in the current lambda now that
7683 we know we really need it. */
7684 instance_ptr = build_this (instance);
7685 cand->first_arg = instance_ptr;
7689 if (complain & tf_error)
7690 error ("cannot call member function %qD without object",
7692 call = error_mark_node;
7696 if (call != error_mark_node)
7698 /* Optimize away vtable lookup if we know that this
7699 function can't be overridden. We need to check if
7700 the context and the instance type are the same,
7701 actually FN might be defined in a different class
7702 type because of a using-declaration. In this case, we
7703 do not want to perform a non-virtual call. */
7704 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
7705 && same_type_ignoring_top_level_qualifiers_p
7706 (DECL_CONTEXT (fn), TREE_TYPE (instance))
7707 && resolves_to_fixed_type_p (instance, 0))
7708 flags |= LOOKUP_NONVIRTUAL;
7710 flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
7711 /* Now we know what function is being called. */
7714 /* Build the actual CALL_EXPR. */
7715 call = build_over_call (cand, flags, complain);
7716 /* In an expression of the form `a->f()' where `f' turns
7717 out to be a static member function, `a' is
7718 none-the-less evaluated. */
7719 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
7720 && !is_dummy_object (instance_ptr)
7721 && TREE_SIDE_EFFECTS (instance_ptr))
7722 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
7723 instance_ptr, call);
7724 else if (call != error_mark_node
7725 && DECL_DESTRUCTOR_P (cand->fn)
7726 && !VOID_TYPE_P (TREE_TYPE (call)))
7727 /* An explicit call of the form "x->~X()" has type
7728 "void". However, on platforms where destructors
7729 return "this" (i.e., those where
7730 targetm.cxx.cdtor_returns_this is true), such calls
7731 will appear to have a return value of pointer type
7732 to the low-level call machinery. We do not want to
7733 change the low-level machinery, since we want to be
7734 able to optimize "delete f()" on such platforms as
7735 "operator delete(~X(f()))" (rather than generating
7736 "t = f(), ~X(t), operator delete (t)"). */
7737 call = build_nop (void_type_node, call);
7742 if (processing_template_decl && call != error_mark_node)
7744 bool cast_to_void = false;
7746 if (TREE_CODE (call) == COMPOUND_EXPR)
7747 call = TREE_OPERAND (call, 1);
7748 else if (TREE_CODE (call) == NOP_EXPR)
7750 cast_to_void = true;
7751 call = TREE_OPERAND (call, 0);
7753 if (TREE_CODE (call) == INDIRECT_REF)
7754 call = TREE_OPERAND (call, 0);
7755 call = (build_min_non_dep_call_vec
7757 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
7758 orig_instance, orig_fns, NULL_TREE),
7760 SET_EXPR_LOCATION (call, input_location);
7761 call = convert_from_reference (call);
7763 call = build_nop (void_type_node, call);
7766 /* Free all the conversions we allocated. */
7767 obstack_free (&conversion_obstack, p);
7769 if (orig_args != NULL)
7770 release_tree_vector (orig_args);
7775 /* Wrapper for above. */
7778 build_new_method_call (tree instance, tree fns, vec<tree, va_gc> **args,
7779 tree conversion_path, int flags,
7780 tree *fn_p, tsubst_flags_t complain)
7783 bool subtime = timevar_cond_start (TV_OVERLOAD);
7784 ret = build_new_method_call_1 (instance, fns, args, conversion_path, flags,
7786 timevar_cond_stop (TV_OVERLOAD, subtime);
7790 /* Returns true iff standard conversion sequence ICS1 is a proper
7791 subsequence of ICS2. */
7794 is_subseq (conversion *ics1, conversion *ics2)
7796 /* We can assume that a conversion of the same code
7797 between the same types indicates a subsequence since we only get
7798 here if the types we are converting from are the same. */
7800 while (ics1->kind == ck_rvalue
7801 || ics1->kind == ck_lvalue)
7802 ics1 = next_conversion (ics1);
7806 while (ics2->kind == ck_rvalue
7807 || ics2->kind == ck_lvalue)
7808 ics2 = next_conversion (ics2);
7810 if (ics2->kind == ck_user
7811 || ics2->kind == ck_ambig
7812 || ics2->kind == ck_aggr
7813 || ics2->kind == ck_list
7814 || ics2->kind == ck_identity)
7815 /* At this point, ICS1 cannot be a proper subsequence of
7816 ICS2. We can get a USER_CONV when we are comparing the
7817 second standard conversion sequence of two user conversion
7821 ics2 = next_conversion (ics2);
7823 if (ics2->kind == ics1->kind
7824 && same_type_p (ics2->type, ics1->type)
7825 && same_type_p (next_conversion (ics2)->type,
7826 next_conversion (ics1)->type))
7831 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
7832 be any _TYPE nodes. */
7835 is_properly_derived_from (tree derived, tree base)
7837 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
7840 /* We only allow proper derivation here. The DERIVED_FROM_P macro
7841 considers every class derived from itself. */
7842 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
7843 && DERIVED_FROM_P (base, derived));
7846 /* We build the ICS for an implicit object parameter as a pointer
7847 conversion sequence. However, such a sequence should be compared
7848 as if it were a reference conversion sequence. If ICS is the
7849 implicit conversion sequence for an implicit object parameter,
7850 modify it accordingly. */
7853 maybe_handle_implicit_object (conversion **ics)
7857 /* [over.match.funcs]
7859 For non-static member functions, the type of the
7860 implicit object parameter is "reference to cv X"
7861 where X is the class of which the function is a
7862 member and cv is the cv-qualification on the member
7863 function declaration. */
7864 conversion *t = *ics;
7865 tree reference_type;
7867 /* The `this' parameter is a pointer to a class type. Make the
7868 implicit conversion talk about a reference to that same class
7870 reference_type = TREE_TYPE (t->type);
7871 reference_type = build_reference_type (reference_type);
7873 if (t->kind == ck_qual)
7874 t = next_conversion (t);
7875 if (t->kind == ck_ptr)
7876 t = next_conversion (t);
7877 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
7878 t = direct_reference_binding (reference_type, t);
7880 t->rvaluedness_matches_p = 0;
7885 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
7886 and return the initial reference binding conversion. Otherwise,
7887 leave *ICS unchanged and return NULL. */
7890 maybe_handle_ref_bind (conversion **ics)
7892 if ((*ics)->kind == ck_ref_bind)
7894 conversion *old_ics = *ics;
7895 *ics = next_conversion (old_ics);
7896 (*ics)->user_conv_p = old_ics->user_conv_p;
7903 /* Compare two implicit conversion sequences according to the rules set out in
7904 [over.ics.rank]. Return values:
7906 1: ics1 is better than ics2
7907 -1: ics2 is better than ics1
7908 0: ics1 and ics2 are indistinguishable */
7911 compare_ics (conversion *ics1, conversion *ics2)
7917 tree deref_from_type1 = NULL_TREE;
7918 tree deref_from_type2 = NULL_TREE;
7919 tree deref_to_type1 = NULL_TREE;
7920 tree deref_to_type2 = NULL_TREE;
7921 conversion_rank rank1, rank2;
7923 /* REF_BINDING is nonzero if the result of the conversion sequence
7924 is a reference type. In that case REF_CONV is the reference
7925 binding conversion. */
7926 conversion *ref_conv1;
7927 conversion *ref_conv2;
7929 /* Handle implicit object parameters. */
7930 maybe_handle_implicit_object (&ics1);
7931 maybe_handle_implicit_object (&ics2);
7933 /* Handle reference parameters. */
7934 ref_conv1 = maybe_handle_ref_bind (&ics1);
7935 ref_conv2 = maybe_handle_ref_bind (&ics2);
7937 /* List-initialization sequence L1 is a better conversion sequence than
7938 list-initialization sequence L2 if L1 converts to
7939 std::initializer_list<X> for some X and L2 does not. */
7940 if (ics1->kind == ck_list && ics2->kind != ck_list)
7942 if (ics2->kind == ck_list && ics1->kind != ck_list)
7947 When comparing the basic forms of implicit conversion sequences (as
7948 defined in _over.best.ics_)
7950 --a standard conversion sequence (_over.ics.scs_) is a better
7951 conversion sequence than a user-defined conversion sequence
7952 or an ellipsis conversion sequence, and
7954 --a user-defined conversion sequence (_over.ics.user_) is a
7955 better conversion sequence than an ellipsis conversion sequence
7956 (_over.ics.ellipsis_). */
7957 rank1 = CONVERSION_RANK (ics1);
7958 rank2 = CONVERSION_RANK (ics2);
7962 else if (rank1 < rank2)
7965 if (rank1 == cr_bad)
7967 /* Both ICS are bad. We try to make a decision based on what would
7968 have happened if they'd been good. This is not an extension,
7969 we'll still give an error when we build up the call; this just
7970 helps us give a more helpful error message. */
7971 rank1 = BAD_CONVERSION_RANK (ics1);
7972 rank2 = BAD_CONVERSION_RANK (ics2);
7976 else if (rank1 < rank2)
7979 /* We couldn't make up our minds; try to figure it out below. */
7982 if (ics1->ellipsis_p)
7983 /* Both conversions are ellipsis conversions. */
7986 /* User-defined conversion sequence U1 is a better conversion sequence
7987 than another user-defined conversion sequence U2 if they contain the
7988 same user-defined conversion operator or constructor and if the sec-
7989 ond standard conversion sequence of U1 is better than the second
7990 standard conversion sequence of U2. */
7992 /* Handle list-conversion with the same code even though it isn't always
7993 ranked as a user-defined conversion and it doesn't have a second
7994 standard conversion sequence; it will still have the desired effect.
7995 Specifically, we need to do the reference binding comparison at the
7996 end of this function. */
7998 if (ics1->user_conv_p || ics1->kind == ck_list || ics1->kind == ck_aggr)
8003 for (t1 = ics1; t1->kind != ck_user; t1 = next_conversion (t1))
8004 if (t1->kind == ck_ambig || t1->kind == ck_aggr
8005 || t1->kind == ck_list)
8007 for (t2 = ics2; t2->kind != ck_user; t2 = next_conversion (t2))
8008 if (t2->kind == ck_ambig || t2->kind == ck_aggr
8009 || t2->kind == ck_list)
8012 if (t1->kind != t2->kind)
8014 else if (t1->kind == ck_user)
8016 if (t1->cand->fn != t2->cand->fn)
8021 /* For ambiguous or aggregate conversions, use the target type as
8022 a proxy for the conversion function. */
8023 if (!same_type_ignoring_top_level_qualifiers_p (t1->type, t2->type))
8027 /* We can just fall through here, after setting up
8028 FROM_TYPE1 and FROM_TYPE2. */
8029 from_type1 = t1->type;
8030 from_type2 = t2->type;
8037 /* We're dealing with two standard conversion sequences.
8041 Standard conversion sequence S1 is a better conversion
8042 sequence than standard conversion sequence S2 if
8044 --S1 is a proper subsequence of S2 (comparing the conversion
8045 sequences in the canonical form defined by _over.ics.scs_,
8046 excluding any Lvalue Transformation; the identity
8047 conversion sequence is considered to be a subsequence of
8048 any non-identity conversion sequence */
8051 while (t1->kind != ck_identity)
8052 t1 = next_conversion (t1);
8053 from_type1 = t1->type;
8056 while (t2->kind != ck_identity)
8057 t2 = next_conversion (t2);
8058 from_type2 = t2->type;
8061 /* One sequence can only be a subsequence of the other if they start with
8062 the same type. They can start with different types when comparing the
8063 second standard conversion sequence in two user-defined conversion
8065 if (same_type_p (from_type1, from_type2))
8067 if (is_subseq (ics1, ics2))
8069 if (is_subseq (ics2, ics1))
8077 --the rank of S1 is better than the rank of S2 (by the rules
8080 Standard conversion sequences are ordered by their ranks: an Exact
8081 Match is a better conversion than a Promotion, which is a better
8082 conversion than a Conversion.
8084 Two conversion sequences with the same rank are indistinguishable
8085 unless one of the following rules applies:
8087 --A conversion that does not a convert a pointer, pointer to member,
8088 or std::nullptr_t to bool is better than one that does.
8090 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8091 so that we do not have to check it explicitly. */
8092 if (ics1->rank < ics2->rank)
8094 else if (ics2->rank < ics1->rank)
8097 to_type1 = ics1->type;
8098 to_type2 = ics2->type;
8100 /* A conversion from scalar arithmetic type to complex is worse than a
8101 conversion between scalar arithmetic types. */
8102 if (same_type_p (from_type1, from_type2)
8103 && ARITHMETIC_TYPE_P (from_type1)
8104 && ARITHMETIC_TYPE_P (to_type1)
8105 && ARITHMETIC_TYPE_P (to_type2)
8106 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
8107 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
8109 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
8115 if (TYPE_PTR_P (from_type1)
8116 && TYPE_PTR_P (from_type2)
8117 && TYPE_PTR_P (to_type1)
8118 && TYPE_PTR_P (to_type2))
8120 deref_from_type1 = TREE_TYPE (from_type1);
8121 deref_from_type2 = TREE_TYPE (from_type2);
8122 deref_to_type1 = TREE_TYPE (to_type1);
8123 deref_to_type2 = TREE_TYPE (to_type2);
8125 /* The rules for pointers to members A::* are just like the rules
8126 for pointers A*, except opposite: if B is derived from A then
8127 A::* converts to B::*, not vice versa. For that reason, we
8128 switch the from_ and to_ variables here. */
8129 else if ((TYPE_PTRDATAMEM_P (from_type1) && TYPE_PTRDATAMEM_P (from_type2)
8130 && TYPE_PTRDATAMEM_P (to_type1) && TYPE_PTRDATAMEM_P (to_type2))
8131 || (TYPE_PTRMEMFUNC_P (from_type1)
8132 && TYPE_PTRMEMFUNC_P (from_type2)
8133 && TYPE_PTRMEMFUNC_P (to_type1)
8134 && TYPE_PTRMEMFUNC_P (to_type2)))
8136 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
8137 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
8138 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
8139 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
8142 if (deref_from_type1 != NULL_TREE
8143 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
8144 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
8146 /* This was one of the pointer or pointer-like conversions.
8150 --If class B is derived directly or indirectly from class A,
8151 conversion of B* to A* is better than conversion of B* to
8152 void*, and conversion of A* to void* is better than
8153 conversion of B* to void*. */
8154 if (TREE_CODE (deref_to_type1) == VOID_TYPE
8155 && TREE_CODE (deref_to_type2) == VOID_TYPE)
8157 if (is_properly_derived_from (deref_from_type1,
8160 else if (is_properly_derived_from (deref_from_type2,
8164 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
8165 || TREE_CODE (deref_to_type2) == VOID_TYPE)
8167 if (same_type_p (deref_from_type1, deref_from_type2))
8169 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
8171 if (is_properly_derived_from (deref_from_type1,
8175 /* We know that DEREF_TO_TYPE1 is `void' here. */
8176 else if (is_properly_derived_from (deref_from_type1,
8181 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
8182 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
8186 --If class B is derived directly or indirectly from class A
8187 and class C is derived directly or indirectly from B,
8189 --conversion of C* to B* is better than conversion of C* to
8192 --conversion of B* to A* is better than conversion of C* to
8194 if (same_type_p (deref_from_type1, deref_from_type2))
8196 if (is_properly_derived_from (deref_to_type1,
8199 else if (is_properly_derived_from (deref_to_type2,
8203 else if (same_type_p (deref_to_type1, deref_to_type2))
8205 if (is_properly_derived_from (deref_from_type2,
8208 else if (is_properly_derived_from (deref_from_type1,
8214 else if (CLASS_TYPE_P (non_reference (from_type1))
8215 && same_type_p (from_type1, from_type2))
8217 tree from = non_reference (from_type1);
8221 --binding of an expression of type C to a reference of type
8222 B& is better than binding an expression of type C to a
8223 reference of type A&
8225 --conversion of C to B is better than conversion of C to A, */
8226 if (is_properly_derived_from (from, to_type1)
8227 && is_properly_derived_from (from, to_type2))
8229 if (is_properly_derived_from (to_type1, to_type2))
8231 else if (is_properly_derived_from (to_type2, to_type1))
8235 else if (CLASS_TYPE_P (non_reference (to_type1))
8236 && same_type_p (to_type1, to_type2))
8238 tree to = non_reference (to_type1);
8242 --binding of an expression of type B to a reference of type
8243 A& is better than binding an expression of type C to a
8244 reference of type A&,
8246 --conversion of B to A is better than conversion of C to A */
8247 if (is_properly_derived_from (from_type1, to)
8248 && is_properly_derived_from (from_type2, to))
8250 if (is_properly_derived_from (from_type2, from_type1))
8252 else if (is_properly_derived_from (from_type1, from_type2))
8259 --S1 and S2 differ only in their qualification conversion and yield
8260 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8261 qualification signature of type T1 is a proper subset of the cv-
8262 qualification signature of type T2 */
8263 if (ics1->kind == ck_qual
8264 && ics2->kind == ck_qual
8265 && same_type_p (from_type1, from_type2))
8267 int result = comp_cv_qual_signature (to_type1, to_type2);
8274 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8275 to an implicit object parameter, and either S1 binds an lvalue reference
8276 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
8277 reference to an rvalue and S2 binds an lvalue reference
8278 (C++0x draft standard, 13.3.3.2)
8280 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8281 types to which the references refer are the same type except for
8282 top-level cv-qualifiers, and the type to which the reference
8283 initialized by S2 refers is more cv-qualified than the type to
8284 which the reference initialized by S1 refers.
8286 DR 1328 [over.match.best]: the context is an initialization by
8287 conversion function for direct reference binding (13.3.1.6) of a
8288 reference to function type, the return type of F1 is the same kind of
8289 reference (i.e. lvalue or rvalue) as the reference being initialized,
8290 and the return type of F2 is not. */
8292 if (ref_conv1 && ref_conv2)
8294 if (!ref_conv1->this_p && !ref_conv2->this_p
8295 && (ref_conv1->rvaluedness_matches_p
8296 != ref_conv2->rvaluedness_matches_p)
8297 && (same_type_p (ref_conv1->type, ref_conv2->type)
8298 || (TYPE_REF_IS_RVALUE (ref_conv1->type)
8299 != TYPE_REF_IS_RVALUE (ref_conv2->type))))
8301 return (ref_conv1->rvaluedness_matches_p
8302 - ref_conv2->rvaluedness_matches_p);
8305 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
8306 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
8307 TREE_TYPE (ref_conv1->type));
8310 /* Neither conversion sequence is better than the other. */
8314 /* The source type for this standard conversion sequence. */
8317 source_type (conversion *t)
8319 for (;; t = next_conversion (t))
8321 if (t->kind == ck_user
8322 || t->kind == ck_ambig
8323 || t->kind == ck_identity)
8329 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8330 a pointer to LOSER and re-running joust to produce the warning if WINNER
8331 is actually used. */
8334 add_warning (struct z_candidate *winner, struct z_candidate *loser)
8336 candidate_warning *cw = (candidate_warning *)
8337 conversion_obstack_alloc (sizeof (candidate_warning));
8339 cw->next = winner->warnings;
8340 winner->warnings = cw;
8343 /* Compare two candidates for overloading as described in
8344 [over.match.best]. Return values:
8346 1: cand1 is better than cand2
8347 -1: cand2 is better than cand1
8348 0: cand1 and cand2 are indistinguishable */
8351 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn,
8352 tsubst_flags_t complain)
8355 int off1 = 0, off2 = 0;
8359 /* Candidates that involve bad conversions are always worse than those
8361 if (cand1->viable > cand2->viable)
8363 if (cand1->viable < cand2->viable)
8366 /* If we have two pseudo-candidates for conversions to the same type,
8367 or two candidates for the same function, arbitrarily pick one. */
8368 if (cand1->fn == cand2->fn
8369 && (IS_TYPE_OR_DECL_P (cand1->fn)))
8372 /* Prefer a non-deleted function over an implicitly deleted move
8373 constructor or assignment operator. This differs slightly from the
8374 wording for issue 1402 (which says the move op is ignored by overload
8375 resolution), but this way produces better error messages. */
8376 if (TREE_CODE (cand1->fn) == FUNCTION_DECL
8377 && TREE_CODE (cand2->fn) == FUNCTION_DECL
8378 && DECL_DELETED_FN (cand1->fn) != DECL_DELETED_FN (cand2->fn))
8380 if (DECL_DELETED_FN (cand1->fn) && DECL_DEFAULTED_FN (cand1->fn)
8381 && move_fn_p (cand1->fn))
8383 if (DECL_DELETED_FN (cand2->fn) && DECL_DEFAULTED_FN (cand2->fn)
8384 && move_fn_p (cand2->fn))
8388 /* a viable function F1
8389 is defined to be a better function than another viable function F2 if
8390 for all arguments i, ICSi(F1) is not a worse conversion sequence than
8391 ICSi(F2), and then */
8393 /* for some argument j, ICSj(F1) is a better conversion sequence than
8396 /* For comparing static and non-static member functions, we ignore
8397 the implicit object parameter of the non-static function. The
8398 standard says to pretend that the static function has an object
8399 parm, but that won't work with operator overloading. */
8400 len = cand1->num_convs;
8401 if (len != cand2->num_convs)
8403 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
8404 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
8406 if (DECL_CONSTRUCTOR_P (cand1->fn)
8407 && is_list_ctor (cand1->fn) != is_list_ctor (cand2->fn))
8408 /* We're comparing a near-match list constructor and a near-match
8409 non-list constructor. Just treat them as unordered. */
8412 gcc_assert (static_1 != static_2);
8423 for (i = 0; i < len; ++i)
8425 conversion *t1 = cand1->convs[i + off1];
8426 conversion *t2 = cand2->convs[i + off2];
8427 int comp = compare_ics (t1, t2);
8431 if ((complain & tf_warning)
8433 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
8434 == cr_std + cr_promotion)
8435 && t1->kind == ck_std
8436 && t2->kind == ck_std
8437 && TREE_CODE (t1->type) == INTEGER_TYPE
8438 && TREE_CODE (t2->type) == INTEGER_TYPE
8439 && (TYPE_PRECISION (t1->type)
8440 == TYPE_PRECISION (t2->type))
8441 && (TYPE_UNSIGNED (next_conversion (t1)->type)
8442 || (TREE_CODE (next_conversion (t1)->type)
8445 tree type = next_conversion (t1)->type;
8447 struct z_candidate *w, *l;
8449 type1 = t1->type, type2 = t2->type,
8450 w = cand1, l = cand2;
8452 type1 = t2->type, type2 = t1->type,
8453 w = cand2, l = cand1;
8457 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
8458 type, type1, type2);
8459 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
8465 if (winner && comp != winner)
8474 /* warn about confusing overload resolution for user-defined conversions,
8475 either between a constructor and a conversion op, or between two
8477 if ((complain & tf_warning)
8478 && winner && warn_conversion && cand1->second_conv
8479 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
8480 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
8482 struct z_candidate *w, *l;
8483 bool give_warning = false;
8486 w = cand1, l = cand2;
8488 w = cand2, l = cand1;
8490 /* We don't want to complain about `X::operator T1 ()'
8491 beating `X::operator T2 () const', when T2 is a no less
8492 cv-qualified version of T1. */
8493 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
8494 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
8496 tree t = TREE_TYPE (TREE_TYPE (l->fn));
8497 tree f = TREE_TYPE (TREE_TYPE (w->fn));
8499 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
8504 if (!comp_ptr_ttypes (t, f))
8505 give_warning = true;
8508 give_warning = true;
8514 tree source = source_type (w->convs[0]);
8515 if (! DECL_CONSTRUCTOR_P (w->fn))
8516 source = TREE_TYPE (source);
8517 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
8518 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
8519 source, w->second_conv->type))
8521 inform (input_location, " because conversion sequence for the argument is better");
8531 /* DR 495 moved this tiebreaker above the template ones. */
8533 the context is an initialization by user-defined conversion (see
8534 _dcl.init_ and _over.match.user_) and the standard conversion
8535 sequence from the return type of F1 to the destination type (i.e.,
8536 the type of the entity being initialized) is a better conversion
8537 sequence than the standard conversion sequence from the return type
8538 of F2 to the destination type. */
8540 if (cand1->second_conv)
8542 winner = compare_ics (cand1->second_conv, cand2->second_conv);
8548 F1 is a non-template function and F2 is a template function
8551 if (!cand1->template_decl && cand2->template_decl)
8553 else if (cand1->template_decl && !cand2->template_decl)
8557 F1 and F2 are template functions and the function template for F1 is
8558 more specialized than the template for F2 according to the partial
8561 if (cand1->template_decl && cand2->template_decl)
8563 winner = more_specialized_fn
8564 (TI_TEMPLATE (cand1->template_decl),
8565 TI_TEMPLATE (cand2->template_decl),
8566 /* [temp.func.order]: The presence of unused ellipsis and default
8567 arguments has no effect on the partial ordering of function
8568 templates. add_function_candidate() will not have
8569 counted the "this" argument for constructors. */
8570 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
8575 /* Check whether we can discard a builtin candidate, either because we
8576 have two identical ones or matching builtin and non-builtin candidates.
8578 (Pedantically in the latter case the builtin which matched the user
8579 function should not be added to the overload set, but we spot it here.
8582 ... the builtin candidates include ...
8583 - do not have the same parameter type list as any non-template
8584 non-member candidate. */
8586 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
8587 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
8589 for (i = 0; i < len; ++i)
8590 if (!same_type_p (cand1->convs[i]->type,
8591 cand2->convs[i]->type))
8593 if (i == cand1->num_convs)
8595 if (cand1->fn == cand2->fn)
8596 /* Two built-in candidates; arbitrarily pick one. */
8598 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
8599 /* cand1 is built-in; prefer cand2. */
8602 /* cand2 is built-in; prefer cand1. */
8607 /* For candidates of a multi-versioned function, make the version with
8608 the highest priority win. This version will be checked for dispatching
8609 first. If this version can be inlined into the caller, the front-end
8610 will simply make a direct call to this function. */
8612 if (TREE_CODE (cand1->fn) == FUNCTION_DECL
8613 && DECL_FUNCTION_VERSIONED (cand1->fn)
8614 && TREE_CODE (cand2->fn) == FUNCTION_DECL
8615 && DECL_FUNCTION_VERSIONED (cand2->fn))
8617 tree f1 = TREE_TYPE (cand1->fn);
8618 tree f2 = TREE_TYPE (cand2->fn);
8619 tree p1 = TYPE_ARG_TYPES (f1);
8620 tree p2 = TYPE_ARG_TYPES (f2);
8622 /* Check if cand1->fn and cand2->fn are versions of the same function. It
8623 is possible that cand1->fn and cand2->fn are function versions but of
8624 different functions. Check types to see if they are versions of the same
8626 if (compparms (p1, p2)
8627 && same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
8629 /* Always make the version with the higher priority, more
8630 specialized, win. */
8631 gcc_assert (targetm.compare_version_priority);
8632 if (targetm.compare_version_priority (cand1->fn, cand2->fn) >= 0)
8639 /* If the two function declarations represent the same function (this can
8640 happen with declarations in multiple scopes and arg-dependent lookup),
8641 arbitrarily choose one. But first make sure the default args we're
8643 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
8644 && equal_functions (cand1->fn, cand2->fn))
8646 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
8647 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
8649 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
8651 for (i = 0; i < len; ++i)
8653 /* Don't crash if the fn is variadic. */
8656 parms1 = TREE_CHAIN (parms1);
8657 parms2 = TREE_CHAIN (parms2);
8661 parms1 = TREE_CHAIN (parms1);
8663 parms2 = TREE_CHAIN (parms2);
8667 if (!cp_tree_equal (TREE_PURPOSE (parms1),
8668 TREE_PURPOSE (parms2)))
8672 if (complain & tf_error)
8674 permerror (input_location,
8675 "default argument mismatch in "
8676 "overload resolution");
8677 inform (input_location,
8678 " candidate 1: %q+#F", cand1->fn);
8679 inform (input_location,
8680 " candidate 2: %q+#F", cand2->fn);
8686 add_warning (cand1, cand2);
8689 parms1 = TREE_CHAIN (parms1);
8690 parms2 = TREE_CHAIN (parms2);
8698 /* Extension: If the worst conversion for one candidate is worse than the
8699 worst conversion for the other, take the first. */
8700 if (!pedantic && (complain & tf_warning_or_error))
8702 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
8703 struct z_candidate *w = 0, *l = 0;
8705 for (i = 0; i < len; ++i)
8707 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
8708 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
8709 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
8710 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
8713 winner = 1, w = cand1, l = cand2;
8715 winner = -1, w = cand2, l = cand1;
8718 /* Don't choose a deleted function over ambiguity. */
8719 if (DECL_P (w->fn) && DECL_DELETED_FN (w->fn))
8723 pedwarn (input_location, 0,
8724 "ISO C++ says that these are ambiguous, even "
8725 "though the worst conversion for the first is better than "
8726 "the worst conversion for the second:");
8727 print_z_candidate (input_location, _("candidate 1:"), w);
8728 print_z_candidate (input_location, _("candidate 2:"), l);
8736 gcc_assert (!winner);
8740 /* Given a list of candidates for overloading, find the best one, if any.
8741 This algorithm has a worst case of O(2n) (winner is last), and a best
8742 case of O(n/2) (totally ambiguous); much better than a sorting
8745 static struct z_candidate *
8746 tourney (struct z_candidate *candidates, tsubst_flags_t complain)
8748 struct z_candidate *champ = candidates, *challenger;
8750 int champ_compared_to_predecessor = 0;
8752 /* Walk through the list once, comparing each current champ to the next
8753 candidate, knocking out a candidate or two with each comparison. */
8755 for (challenger = champ->next; challenger; )
8757 fate = joust (champ, challenger, 0, complain);
8759 challenger = challenger->next;
8764 champ = challenger->next;
8767 champ_compared_to_predecessor = 0;
8772 champ_compared_to_predecessor = 1;
8775 challenger = champ->next;
8779 /* Make sure the champ is better than all the candidates it hasn't yet
8780 been compared to. */
8782 for (challenger = candidates;
8784 && !(champ_compared_to_predecessor && challenger->next == champ);
8785 challenger = challenger->next)
8787 fate = joust (champ, challenger, 0, complain);
8795 /* Returns nonzero if things of type FROM can be converted to TO. */
8798 can_convert (tree to, tree from, tsubst_flags_t complain)
8800 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT, complain);
8803 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
8806 can_convert_arg (tree to, tree from, tree arg, int flags,
8807 tsubst_flags_t complain)
8813 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8814 p = conversion_obstack_alloc (0);
8815 /* We want to discard any access checks done for this test,
8816 as we might not be in the appropriate access context and
8817 we'll do the check again when we actually perform the
8819 push_deferring_access_checks (dk_deferred);
8821 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
8823 ok_p = (t && !t->bad_p);
8825 /* Discard the access checks now. */
8826 pop_deferring_access_checks ();
8827 /* Free all the conversions we allocated. */
8828 obstack_free (&conversion_obstack, p);
8833 /* Like can_convert_arg, but allows dubious conversions as well. */
8836 can_convert_arg_bad (tree to, tree from, tree arg, int flags,
8837 tsubst_flags_t complain)
8842 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8843 p = conversion_obstack_alloc (0);
8844 /* Try to perform the conversion. */
8845 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
8847 /* Free all the conversions we allocated. */
8848 obstack_free (&conversion_obstack, p);
8853 /* Convert EXPR to TYPE. Return the converted expression.
8855 Note that we allow bad conversions here because by the time we get to
8856 this point we are committed to doing the conversion. If we end up
8857 doing a bad conversion, convert_like will complain. */
8860 perform_implicit_conversion_flags (tree type, tree expr,
8861 tsubst_flags_t complain, int flags)
8865 location_t loc = EXPR_LOC_OR_HERE (expr);
8867 if (error_operand_p (expr))
8868 return error_mark_node;
8870 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8871 p = conversion_obstack_alloc (0);
8873 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8879 if (complain & tf_error)
8881 /* If expr has unknown type, then it is an overloaded function.
8882 Call instantiate_type to get good error messages. */
8883 if (TREE_TYPE (expr) == unknown_type_node)
8884 instantiate_type (type, expr, complain);
8885 else if (invalid_nonstatic_memfn_p (expr, complain))
8886 /* We gave an error. */;
8888 error_at (loc, "could not convert %qE from %qT to %qT", expr,
8889 TREE_TYPE (expr), type);
8891 expr = error_mark_node;
8893 else if (processing_template_decl && conv->kind != ck_identity)
8895 /* In a template, we are only concerned about determining the
8896 type of non-dependent expressions, so we do not have to
8897 perform the actual conversion. But for initializers, we
8898 need to be able to perform it at instantiation
8899 (or fold_non_dependent_expr) time. */
8900 expr = build1 (IMPLICIT_CONV_EXPR, type, expr);
8901 if (!(flags & LOOKUP_ONLYCONVERTING))
8902 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr) = true;
8905 expr = convert_like (conv, expr, complain);
8907 /* Free all the conversions we allocated. */
8908 obstack_free (&conversion_obstack, p);
8914 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
8916 return perform_implicit_conversion_flags (type, expr, complain,
8920 /* Convert EXPR to TYPE (as a direct-initialization) if that is
8921 permitted. If the conversion is valid, the converted expression is
8922 returned. Otherwise, NULL_TREE is returned, except in the case
8923 that TYPE is a class type; in that case, an error is issued. If
8924 C_CAST_P is true, then this direct-initialization is taking
8925 place as part of a static_cast being attempted as part of a C-style
8929 perform_direct_initialization_if_possible (tree type,
8932 tsubst_flags_t complain)
8937 if (type == error_mark_node || error_operand_p (expr))
8938 return error_mark_node;
8941 If the destination type is a (possibly cv-qualified) class type:
8943 -- If the initialization is direct-initialization ...,
8944 constructors are considered. ... If no constructor applies, or
8945 the overload resolution is ambiguous, the initialization is
8947 if (CLASS_TYPE_P (type))
8949 vec<tree, va_gc> *args = make_tree_vector_single (expr);
8950 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
8951 &args, type, LOOKUP_NORMAL, complain);
8952 release_tree_vector (args);
8953 return build_cplus_new (type, expr, complain);
8956 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8957 p = conversion_obstack_alloc (0);
8959 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8961 LOOKUP_NORMAL, complain);
8962 if (!conv || conv->bad_p)
8965 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
8966 /*issue_conversion_warnings=*/false,
8970 /* Free all the conversions we allocated. */
8971 obstack_free (&conversion_obstack, p);
8976 /* When initializing a reference that lasts longer than a full-expression,
8977 this special rule applies:
8981 The temporary to which the reference is bound or the temporary
8982 that is the complete object to which the reference is bound
8983 persists for the lifetime of the reference.
8985 The temporaries created during the evaluation of the expression
8986 initializing the reference, except the temporary to which the
8987 reference is bound, are destroyed at the end of the
8988 full-expression in which they are created.
8990 In that case, we store the converted expression into a new
8991 VAR_DECL in a new scope.
8993 However, we want to be careful not to create temporaries when
8994 they are not required. For example, given:
8997 struct D : public B {};
9001 there is no need to copy the return value from "f"; we can just
9002 extend its lifetime. Similarly, given:
9005 struct T { operator S(); };
9009 we can extend the lifetime of the return value of the conversion
9012 The next several functions are involved in this lifetime extension. */
9014 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9015 reference is being bound to a temporary. Create and return a new
9016 VAR_DECL with the indicated TYPE; this variable will store the value to
9017 which the reference is bound. */
9020 make_temporary_var_for_ref_to_temp (tree decl, tree type)
9024 /* Create the variable. */
9025 var = create_temporary_var (type);
9027 /* Register the variable. */
9028 if (TREE_CODE (decl) == VAR_DECL
9029 && (TREE_STATIC (decl) || DECL_THREAD_LOCAL_P (decl)))
9031 /* Namespace-scope or local static; give it a mangled name. */
9032 /* FIXME share comdat with decl? */
9035 TREE_STATIC (var) = TREE_STATIC (decl);
9036 DECL_TLS_MODEL (var) = DECL_TLS_MODEL (decl);
9037 name = mangle_ref_init_variable (decl);
9038 DECL_NAME (var) = name;
9039 SET_DECL_ASSEMBLER_NAME (var, name);
9040 var = pushdecl_top_level (var);
9043 /* Create a new cleanup level if necessary. */
9044 maybe_push_cleanup_level (type);
9049 /* EXPR is the initializer for a variable DECL of reference or
9050 std::initializer_list type. Create, push and return a new VAR_DECL
9051 for the initializer so that it will live as long as DECL. Any
9052 cleanup for the new variable is returned through CLEANUP, and the
9053 code to initialize the new variable is returned through INITP. */
9056 set_up_extended_ref_temp (tree decl, tree expr, vec<tree, va_gc> **cleanups,
9063 /* Create the temporary variable. */
9064 type = TREE_TYPE (expr);
9065 var = make_temporary_var_for_ref_to_temp (decl, type);
9066 layout_decl (var, 0);
9067 /* If the rvalue is the result of a function call it will be
9068 a TARGET_EXPR. If it is some other construct (such as a
9069 member access expression where the underlying object is
9070 itself the result of a function call), turn it into a
9071 TARGET_EXPR here. It is important that EXPR be a
9072 TARGET_EXPR below since otherwise the INIT_EXPR will
9073 attempt to make a bitwise copy of EXPR to initialize
9075 if (TREE_CODE (expr) != TARGET_EXPR)
9076 expr = get_target_expr (expr);
9078 if (TREE_CODE (decl) == FIELD_DECL
9079 && extra_warnings && !TREE_NO_WARNING (decl))
9081 warning (OPT_Wextra, "a temporary bound to %qD only persists "
9082 "until the constructor exits", decl);
9083 TREE_NO_WARNING (decl) = true;
9086 /* Recursively extend temps in this initializer. */
9087 TARGET_EXPR_INITIAL (expr)
9088 = extend_ref_init_temps (decl, TARGET_EXPR_INITIAL (expr), cleanups);
9090 /* Any reference temp has a non-trivial initializer. */
9091 DECL_NONTRIVIALLY_INITIALIZED_P (var) = true;
9093 /* If the initializer is constant, put it in DECL_INITIAL so we get
9094 static initialization and use in constant expressions. */
9095 init = maybe_constant_init (expr);
9096 if (TREE_CONSTANT (init))
9098 if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
9100 /* 5.19 says that a constant expression can include an
9101 lvalue-rvalue conversion applied to "a glvalue of literal type
9102 that refers to a non-volatile temporary object initialized
9103 with a constant expression". Rather than try to communicate
9104 that this VAR_DECL is a temporary, just mark it constexpr.
9106 Currently this is only useful for initializer_list temporaries,
9107 since reference vars can't appear in constant expressions. */
9108 DECL_DECLARED_CONSTEXPR_P (var) = true;
9109 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var) = true;
9110 TREE_CONSTANT (var) = true;
9112 DECL_INITIAL (var) = init;
9116 /* Create the INIT_EXPR that will initialize the temporary
9118 init = build2 (INIT_EXPR, type, var, expr);
9119 if (at_function_scope_p ())
9121 add_decl_expr (var);
9123 if (TREE_STATIC (var))
9124 init = add_stmt_to_compound (init, register_dtor_fn (var));
9127 tree cleanup = cxx_maybe_build_cleanup (var, tf_warning_or_error);
9129 vec_safe_push (*cleanups, cleanup);
9132 /* We must be careful to destroy the temporary only
9133 after its initialization has taken place. If the
9134 initialization throws an exception, then the
9135 destructor should not be run. We cannot simply
9136 transform INIT into something like:
9138 (INIT, ({ CLEANUP_STMT; }))
9140 because emit_local_var always treats the
9141 initializer as a full-expression. Thus, the
9142 destructor would run too early; it would run at the
9143 end of initializing the reference variable, rather
9144 than at the end of the block enclosing the
9147 The solution is to pass back a cleanup expression
9148 which the caller is responsible for attaching to
9149 the statement tree. */
9153 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
9154 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
9156 if (DECL_THREAD_LOCAL_P (var))
9157 tls_aggregates = tree_cons (NULL_TREE, var,
9160 static_aggregates = tree_cons (NULL_TREE, var,
9169 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9170 initializing a variable of that TYPE. */
9173 initialize_reference (tree type, tree expr,
9174 int flags, tsubst_flags_t complain)
9178 location_t loc = EXPR_LOC_OR_HERE (expr);
9180 if (type == error_mark_node || error_operand_p (expr))
9181 return error_mark_node;
9183 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9184 p = conversion_obstack_alloc (0);
9186 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
9188 if (!conv || conv->bad_p)
9190 if (complain & tf_error)
9193 convert_like (conv, expr, complain);
9194 else if (!CP_TYPE_CONST_P (TREE_TYPE (type))
9195 && !TYPE_REF_IS_RVALUE (type)
9196 && !real_lvalue_p (expr))
9197 error_at (loc, "invalid initialization of non-const reference of "
9198 "type %qT from an rvalue of type %qT",
9199 type, TREE_TYPE (expr));
9201 error_at (loc, "invalid initialization of reference of type "
9202 "%qT from expression of type %qT", type,
9205 return error_mark_node;
9208 gcc_assert (conv->kind == ck_ref_bind);
9210 /* Perform the conversion. */
9211 expr = convert_like (conv, expr, complain);
9213 /* Free all the conversions we allocated. */
9214 obstack_free (&conversion_obstack, p);
9219 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9220 which is bound either to a reference or a std::initializer_list. */
9223 extend_ref_init_temps_1 (tree decl, tree init, vec<tree, va_gc> **cleanups)
9228 if (TREE_CODE (sub) == COMPOUND_EXPR)
9230 TREE_OPERAND (sub, 1)
9231 = extend_ref_init_temps_1 (decl, TREE_OPERAND (sub, 1), cleanups);
9234 if (TREE_CODE (sub) != ADDR_EXPR)
9236 /* Deal with binding to a subobject. */
9237 for (p = &TREE_OPERAND (sub, 0); TREE_CODE (*p) == COMPONENT_REF; )
9238 p = &TREE_OPERAND (*p, 0);
9239 if (TREE_CODE (*p) == TARGET_EXPR)
9241 tree subinit = NULL_TREE;
9242 *p = set_up_extended_ref_temp (decl, *p, cleanups, &subinit);
9244 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), subinit, init);
9245 recompute_tree_invariant_for_addr_expr (sub);
9250 /* INIT is part of the initializer for DECL. If there are any
9251 reference or initializer lists being initialized, extend their
9252 lifetime to match that of DECL. */
9255 extend_ref_init_temps (tree decl, tree init, vec<tree, va_gc> **cleanups)
9257 tree type = TREE_TYPE (init);
9258 if (processing_template_decl)
9260 if (TREE_CODE (type) == REFERENCE_TYPE)
9261 init = extend_ref_init_temps_1 (decl, init, cleanups);
9262 else if (is_std_init_list (type))
9264 /* The temporary array underlying a std::initializer_list
9265 is handled like a reference temporary. */
9267 if (TREE_CODE (ctor) == TARGET_EXPR)
9268 ctor = TARGET_EXPR_INITIAL (ctor);
9269 if (TREE_CODE (ctor) == CONSTRUCTOR)
9271 tree array = CONSTRUCTOR_ELT (ctor, 0)->value;
9272 array = extend_ref_init_temps_1 (decl, array, cleanups);
9273 CONSTRUCTOR_ELT (ctor, 0)->value = array;
9276 else if (TREE_CODE (init) == CONSTRUCTOR)
9280 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (init);
9281 FOR_EACH_VEC_SAFE_ELT (elts, i, p)
9282 p->value = extend_ref_init_temps (decl, p->value, cleanups);
9288 /* Returns true iff an initializer for TYPE could contain temporaries that
9289 need to be extended because they are bound to references or
9290 std::initializer_list. */
9293 type_has_extended_temps (tree type)
9295 type = strip_array_types (type);
9296 if (TREE_CODE (type) == REFERENCE_TYPE)
9298 if (CLASS_TYPE_P (type))
9300 if (is_std_init_list (type))
9302 for (tree f = next_initializable_field (TYPE_FIELDS (type));
9303 f; f = next_initializable_field (DECL_CHAIN (f)))
9304 if (type_has_extended_temps (TREE_TYPE (f)))
9310 /* Returns true iff TYPE is some variant of std::initializer_list. */
9313 is_std_init_list (tree type)
9315 /* Look through typedefs. */
9318 type = TYPE_MAIN_VARIANT (type);
9319 return (CLASS_TYPE_P (type)
9320 && CP_TYPE_CONTEXT (type) == std_node
9321 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
9324 /* Returns true iff DECL is a list constructor: i.e. a constructor which
9325 will accept an argument list of a single std::initializer_list<T>. */
9328 is_list_ctor (tree decl)
9330 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
9333 if (!args || args == void_list_node)
9336 arg = non_reference (TREE_VALUE (args));
9337 if (!is_std_init_list (arg))
9340 args = TREE_CHAIN (args);
9342 if (args && args != void_list_node && !TREE_PURPOSE (args))
9343 /* There are more non-defaulted parms. */
9349 #include "gt-cp-call.h"