1 /* Functions related to invoking -*- C++ -*- methods and overloaded functions.
2 Copyright (C) 1987-2019 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"
31 #include "stringpool.h"
33 #include "stor-layout.h"
34 #include "trans-mem.h"
39 #include "langhooks.h"
40 #include "c-family/c-objc.h"
41 #include "internal-fn.h"
42 #include "stringpool.h"
44 #include "gcc-rich-location.h"
46 /* The various kinds of conversion. */
48 enum conversion_kind
{
65 /* The rank of the conversion. Order of the enumerals matters; better
66 conversions should come earlier in the list. */
68 enum conversion_rank
{
79 /* An implicit conversion sequence, in the sense of [over.best.ics].
80 The first conversion to be performed is at the end of the chain.
81 That conversion is always a cr_identity conversion. */
84 /* The kind of conversion represented by this step. */
86 /* The rank of this conversion. */
88 BOOL_BITFIELD user_conv_p
: 1;
89 BOOL_BITFIELD ellipsis_p
: 1;
90 BOOL_BITFIELD this_p
: 1;
91 /* True if this conversion would be permitted with a bending of
92 language standards, e.g. disregarding pointer qualifiers or
93 converting integers to pointers. */
94 BOOL_BITFIELD bad_p
: 1;
95 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
96 temporary should be created to hold the result of the
97 conversion. If KIND is ck_ambig or ck_user, true means force
98 copy-initialization. */
99 BOOL_BITFIELD need_temporary_p
: 1;
100 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
101 from a pointer-to-derived to pointer-to-base is being performed. */
102 BOOL_BITFIELD base_p
: 1;
103 /* If KIND is ck_ref_bind, true when either an lvalue reference is
104 being bound to an lvalue expression or an rvalue reference is
105 being bound to an rvalue expression. If KIND is ck_rvalue or ck_base,
106 true when we are treating an lvalue as an rvalue (12.8p33). If
107 ck_identity, we will be binding a reference directly or decaying to
109 BOOL_BITFIELD rvaluedness_matches_p
: 1;
110 BOOL_BITFIELD check_narrowing
: 1;
111 /* Whether check_narrowing should only check TREE_CONSTANTs; used
112 in build_converted_constant_expr. */
113 BOOL_BITFIELD check_narrowing_const_only
: 1;
114 /* The type of the expression resulting from the conversion. */
117 /* The next conversion in the chain. Since the conversions are
118 arranged from outermost to innermost, the NEXT conversion will
119 actually be performed before this conversion. This variant is
120 used only when KIND is neither ck_identity, ck_ambig nor
121 ck_list. Please use the next_conversion function instead
122 of using this field directly. */
124 /* The expression at the beginning of the conversion chain. This
125 variant is used only if KIND is ck_identity or ck_ambig. */
127 /* The array of conversions for an initializer_list, so this
128 variant is used only when KIN D is ck_list. */
131 /* The function candidate corresponding to this conversion
132 sequence. This field is only used if KIND is ck_user. */
133 struct z_candidate
*cand
;
136 #define CONVERSION_RANK(NODE) \
137 ((NODE)->bad_p ? cr_bad \
138 : (NODE)->ellipsis_p ? cr_ellipsis \
139 : (NODE)->user_conv_p ? cr_user \
142 #define BAD_CONVERSION_RANK(NODE) \
143 ((NODE)->ellipsis_p ? cr_ellipsis \
144 : (NODE)->user_conv_p ? cr_user \
147 static struct obstack conversion_obstack
;
148 static bool conversion_obstack_initialized
;
149 struct rejection_reason
;
151 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
152 static int equal_functions (tree
, tree
);
153 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
155 static int compare_ics (conversion
*, conversion
*);
156 static void maybe_warn_class_memaccess (location_t
, tree
,
157 const vec
<tree
, va_gc
> *);
158 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
159 #define convert_like(CONV, EXPR, COMPLAIN) \
160 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, \
161 /*issue_conversion_warnings=*/true, \
162 /*c_cast_p=*/false, (COMPLAIN))
163 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
164 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), \
165 /*issue_conversion_warnings=*/true, \
166 /*c_cast_p=*/false, (COMPLAIN))
167 static tree
convert_like_real (conversion
*, tree
, tree
, int, bool,
168 bool, tsubst_flags_t
);
169 static void op_error (const op_location_t
&, enum tree_code
, enum tree_code
,
170 tree
, tree
, tree
, bool);
171 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
173 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
174 static void print_z_candidates (location_t
, struct z_candidate
*);
175 static tree
build_this (tree
);
176 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
177 static bool any_strictly_viable (struct z_candidate
*);
178 static struct z_candidate
*add_template_candidate
179 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
180 tree
, tree
, tree
, int, unification_kind_t
, tsubst_flags_t
);
181 static struct z_candidate
*add_template_candidate_real
182 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
183 tree
, tree
, tree
, int, tree
, unification_kind_t
, tsubst_flags_t
);
184 static void add_builtin_candidates
185 (struct z_candidate
**, enum tree_code
, enum tree_code
,
186 tree
, tree
*, int, tsubst_flags_t
);
187 static void add_builtin_candidate
188 (struct z_candidate
**, enum tree_code
, enum tree_code
,
189 tree
, tree
, tree
, tree
*, tree
*, int, tsubst_flags_t
);
190 static bool is_complete (tree
);
191 static void build_builtin_candidate
192 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
193 int, tsubst_flags_t
);
194 static struct z_candidate
*add_conv_candidate
195 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
196 tree
, tsubst_flags_t
);
197 static struct z_candidate
*add_function_candidate
198 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
199 tree
, int, conversion
**, tsubst_flags_t
);
200 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
202 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
204 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
205 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
206 static conversion
*next_conversion (conversion
*);
207 static bool is_subseq (conversion
*, conversion
*);
208 static conversion
*maybe_handle_ref_bind (conversion
**);
209 static void maybe_handle_implicit_object (conversion
**);
210 static struct z_candidate
*add_candidate
211 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
212 conversion
**, tree
, tree
, int, struct rejection_reason
*, int);
213 static tree
source_type (conversion
*);
214 static void add_warning (struct z_candidate
*, struct z_candidate
*);
215 static bool reference_compatible_p (tree
, tree
);
216 static conversion
*direct_reference_binding (tree
, conversion
*);
217 static bool promoted_arithmetic_type_p (tree
);
218 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
219 static char *name_as_c_string (tree
, tree
, bool *);
220 static tree
prep_operand (tree
);
221 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
222 bool, tree
, tree
, int, struct z_candidate
**,
224 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
225 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
227 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
228 NAME can take many forms... */
231 check_dtor_name (tree basetype
, tree name
)
233 /* Just accept something we've already complained about. */
234 if (name
== error_mark_node
)
237 if (TREE_CODE (name
) == TYPE_DECL
)
238 name
= TREE_TYPE (name
);
239 else if (TYPE_P (name
))
241 else if (identifier_p (name
))
243 if ((MAYBE_CLASS_TYPE_P (basetype
)
244 || TREE_CODE (basetype
) == ENUMERAL_TYPE
)
245 && name
== constructor_name (basetype
))
248 name
= get_type_value (name
);
254 template <class T> struct S { ~S(); };
258 NAME will be a class template. */
259 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
263 if (!name
|| name
== error_mark_node
)
265 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
268 /* We want the address of a function or method. We avoid creating a
269 pointer-to-member function. */
272 build_addr_func (tree function
, tsubst_flags_t complain
)
274 tree type
= TREE_TYPE (function
);
276 /* We have to do these by hand to avoid real pointer to member
278 if (TREE_CODE (type
) == METHOD_TYPE
)
280 if (TREE_CODE (function
) == OFFSET_REF
)
282 tree object
= build_address (TREE_OPERAND (function
, 0));
283 return get_member_function_from_ptrfunc (&object
,
284 TREE_OPERAND (function
, 1),
287 function
= build_address (function
);
290 function
= decay_conversion (function
, complain
, /*reject_builtin=*/false);
295 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
296 POINTER_TYPE to those. Note, pointer to member function types
297 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
298 two variants. build_call_a is the primitive taking an array of
299 arguments, while build_call_n is a wrapper that handles varargs. */
302 build_call_n (tree function
, int n
, ...)
305 return build_call_a (function
, 0, NULL
);
308 tree
*argarray
= XALLOCAVEC (tree
, n
);
313 for (i
= 0; i
< n
; i
++)
314 argarray
[i
] = va_arg (ap
, tree
);
316 return build_call_a (function
, n
, argarray
);
320 /* Update various flags in cfun and the call itself based on what is being
321 called. Split out of build_call_a so that bot_manip can use it too. */
324 set_flags_from_callee (tree call
)
326 /* Handle both CALL_EXPRs and AGGR_INIT_EXPRs. */
327 tree decl
= cp_get_callee_fndecl_nofold (call
);
329 /* We check both the decl and the type; a function may be known not to
330 throw without being declared throw(). */
331 bool nothrow
= decl
&& TREE_NOTHROW (decl
);
332 tree callee
= cp_get_callee (call
);
334 nothrow
|= TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (callee
)));
335 else if (TREE_CODE (call
) == CALL_EXPR
336 && internal_fn_flags (CALL_EXPR_IFN (call
)) & ECF_NOTHROW
)
339 if (!nothrow
&& at_function_scope_p () && cfun
&& cp_function_chain
)
340 cp_function_chain
->can_throw
= 1;
342 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
&& cp_function_chain
)
343 current_function_returns_abnormally
= 1;
345 TREE_NOTHROW (call
) = nothrow
;
349 build_call_a (tree function
, int n
, tree
*argarray
)
356 function
= build_addr_func (function
, tf_warning_or_error
);
358 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
359 fntype
= TREE_TYPE (TREE_TYPE (function
));
360 gcc_assert (FUNC_OR_METHOD_TYPE_P (fntype
));
361 result_type
= TREE_TYPE (fntype
);
362 /* An rvalue has no cv-qualifiers. */
363 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
364 result_type
= cv_unqualified (result_type
);
366 function
= build_call_array_loc (input_location
,
367 result_type
, function
, n
, argarray
);
368 set_flags_from_callee (function
);
370 decl
= get_callee_fndecl (function
);
372 if (decl
&& !TREE_USED (decl
))
374 /* We invoke build_call directly for several library
375 functions. These may have been declared normally if
376 we're building libgcc, so we can't just check
378 gcc_assert (DECL_ARTIFICIAL (decl
)
379 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
384 require_complete_eh_spec_types (fntype
, decl
);
386 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
388 /* Don't pass empty class objects by value. This is useful
389 for tags in STL, which are used to control overload resolution.
390 We don't need to handle other cases of copying empty classes. */
391 if (!decl
|| !fndecl_built_in_p (decl
))
392 for (i
= 0; i
< n
; i
++)
394 tree arg
= CALL_EXPR_ARG (function
, i
);
395 if (is_empty_class (TREE_TYPE (arg
))
396 && simple_empty_class_p (TREE_TYPE (arg
), arg
, INIT_EXPR
))
398 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (arg
));
399 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (t
), arg
, t
);
400 CALL_EXPR_ARG (function
, i
) = arg
;
407 /* New overloading code. */
411 struct candidate_warning
{
413 candidate_warning
*next
;
416 /* Information for providing diagnostics about why overloading failed. */
418 enum rejection_reason_code
{
421 rr_explicit_conversion
,
422 rr_template_conversion
,
424 rr_bad_arg_conversion
,
425 rr_template_unification
,
428 rr_constraint_failure
431 struct conversion_info
{
432 /* The index of the argument, 0-based. */
434 /* The actual argument or its type. */
436 /* The type of the parameter. */
438 /* The location of the argument. */
442 struct rejection_reason
{
443 enum rejection_reason_code code
;
445 /* Information about an arity mismatch. */
447 /* The expected number of arguments. */
449 /* The actual number of arguments in the call. */
451 /* Whether the call was a varargs call. */
454 /* Information about an argument conversion mismatch. */
455 struct conversion_info conversion
;
456 /* Same, but for bad argument conversions. */
457 struct conversion_info bad_conversion
;
458 /* Information about template unification failures. These are the
459 parameters passed to fn_type_unification. */
467 unification_kind_t strict
;
469 } template_unification
;
470 /* Information about template instantiation failures. These are the
471 parameters passed to instantiate_template. */
475 } template_instantiation
;
480 /* The FUNCTION_DECL that will be called if this candidate is
481 selected by overload resolution. */
483 /* If not NULL_TREE, the first argument to use when calling this
486 /* The rest of the arguments to use when calling this function. If
487 there are no further arguments this may be NULL or it may be an
489 const vec
<tree
, va_gc
> *args
;
490 /* The implicit conversion sequences for each of the arguments to
493 /* The number of implicit conversion sequences. */
495 /* If FN is a user-defined conversion, the standard conversion
496 sequence from the type returned by FN to the desired destination
498 conversion
*second_conv
;
499 struct rejection_reason
*reason
;
500 /* If FN is a member function, the binfo indicating the path used to
501 qualify the name of FN at the call site. This path is used to
502 determine whether or not FN is accessible if it is selected by
503 overload resolution. The DECL_CONTEXT of FN will always be a
504 (possibly improper) base of this binfo. */
506 /* If FN is a non-static member function, the binfo indicating the
507 subobject to which the `this' pointer should be converted if FN
508 is selected by overload resolution. The type pointed to by
509 the `this' pointer must correspond to the most derived class
510 indicated by the CONVERSION_PATH. */
511 tree conversion_path
;
514 candidate_warning
*warnings
;
518 /* The flags active in add_candidate. */
522 /* Returns true iff T is a null pointer constant in the sense of
526 null_ptr_cst_p (tree t
)
528 tree type
= TREE_TYPE (t
);
532 A null pointer constant is an integer literal ([lex.icon]) with value
533 zero or a prvalue of type std::nullptr_t. */
534 if (NULLPTR_TYPE_P (type
))
537 if (cxx_dialect
>= cxx11
)
539 STRIP_ANY_LOCATION_WRAPPER (t
);
541 /* Core issue 903 says only literal 0 is a null pointer constant. */
542 if (TREE_CODE (t
) == INTEGER_CST
543 && !TREE_OVERFLOW (t
)
544 && TREE_CODE (type
) == INTEGER_TYPE
546 && !char_type_p (type
))
549 else if (CP_INTEGRAL_TYPE_P (type
))
551 t
= fold_non_dependent_expr (t
, tf_none
);
553 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
560 /* Returns true iff T is a null member pointer value (4.11). */
563 null_member_pointer_value_p (tree t
)
565 tree type
= TREE_TYPE (t
);
568 else if (TYPE_PTRMEMFUNC_P (type
))
569 return (TREE_CODE (t
) == CONSTRUCTOR
570 && CONSTRUCTOR_NELTS (t
)
571 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
572 else if (TYPE_PTRDATAMEM_P (type
))
573 return integer_all_onesp (t
);
578 /* Returns nonzero if PARMLIST consists of only default parms,
579 ellipsis, and/or undeduced parameter packs. */
582 sufficient_parms_p (const_tree parmlist
)
584 for (; parmlist
&& parmlist
!= void_list_node
;
585 parmlist
= TREE_CHAIN (parmlist
))
586 if (!TREE_PURPOSE (parmlist
)
587 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
592 /* Allocate N bytes of memory from the conversion obstack. The memory
593 is zeroed before being returned. */
596 conversion_obstack_alloc (size_t n
)
599 if (!conversion_obstack_initialized
)
601 gcc_obstack_init (&conversion_obstack
);
602 conversion_obstack_initialized
= true;
604 p
= obstack_alloc (&conversion_obstack
, n
);
609 /* Allocate rejection reasons. */
611 static struct rejection_reason
*
612 alloc_rejection (enum rejection_reason_code code
)
614 struct rejection_reason
*p
;
615 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
620 static struct rejection_reason
*
621 arity_rejection (tree first_arg
, int expected
, int actual
)
623 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
624 int adjust
= first_arg
!= NULL_TREE
;
625 r
->u
.arity
.expected
= expected
- adjust
;
626 r
->u
.arity
.actual
= actual
- adjust
;
630 static struct rejection_reason
*
631 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
,
634 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
635 int adjust
= first_arg
!= NULL_TREE
;
636 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
637 r
->u
.conversion
.from
= from
;
638 r
->u
.conversion
.to_type
= to
;
639 r
->u
.conversion
.loc
= loc
;
643 static struct rejection_reason
*
644 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
,
647 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
648 int adjust
= first_arg
!= NULL_TREE
;
649 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
650 r
->u
.bad_conversion
.from
= from
;
651 r
->u
.bad_conversion
.to_type
= to
;
652 r
->u
.bad_conversion
.loc
= loc
;
656 static struct rejection_reason
*
657 explicit_conversion_rejection (tree from
, tree to
)
659 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
660 r
->u
.conversion
.n_arg
= 0;
661 r
->u
.conversion
.from
= from
;
662 r
->u
.conversion
.to_type
= to
;
663 r
->u
.conversion
.loc
= UNKNOWN_LOCATION
;
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
= from
;
673 r
->u
.conversion
.to_type
= to
;
674 r
->u
.conversion
.loc
= UNKNOWN_LOCATION
;
678 static struct rejection_reason
*
679 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
680 const tree
*args
, unsigned int nargs
,
681 tree return_type
, unification_kind_t strict
,
684 size_t args_n_bytes
= sizeof (*args
) * nargs
;
685 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
686 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
687 r
->u
.template_unification
.tmpl
= tmpl
;
688 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
689 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
690 /* Copy args to our own storage. */
691 memcpy (args1
, args
, args_n_bytes
);
692 r
->u
.template_unification
.args
= args1
;
693 r
->u
.template_unification
.nargs
= nargs
;
694 r
->u
.template_unification
.return_type
= return_type
;
695 r
->u
.template_unification
.strict
= strict
;
696 r
->u
.template_unification
.flags
= flags
;
700 static struct rejection_reason
*
701 template_unification_error_rejection (void)
703 return alloc_rejection (rr_template_unification
);
706 static struct rejection_reason
*
707 invalid_copy_with_fn_template_rejection (void)
709 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
713 static struct rejection_reason
*
714 inherited_ctor_rejection (void)
716 struct rejection_reason
*r
= alloc_rejection (rr_inherited_ctor
);
720 // Build a constraint failure record, saving information into the
721 // template_instantiation field of the rejection. If FN is not a template
722 // declaration, the TMPL member is the FN declaration and TARGS is empty.
724 static struct rejection_reason
*
725 constraint_failure (tree fn
)
727 struct rejection_reason
*r
= alloc_rejection (rr_constraint_failure
);
728 if (tree ti
= DECL_TEMPLATE_INFO (fn
))
730 r
->u
.template_instantiation
.tmpl
= TI_TEMPLATE (ti
);
731 r
->u
.template_instantiation
.targs
= TI_ARGS (ti
);
735 r
->u
.template_instantiation
.tmpl
= fn
;
736 r
->u
.template_instantiation
.targs
= NULL_TREE
;
741 /* Dynamically allocate a conversion. */
744 alloc_conversion (conversion_kind kind
)
747 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
752 /* Make sure that all memory on the conversion obstack has been
756 validate_conversion_obstack (void)
758 if (conversion_obstack_initialized
)
759 gcc_assert ((obstack_next_free (&conversion_obstack
)
760 == obstack_base (&conversion_obstack
)));
763 /* Dynamically allocate an array of N conversions. */
766 alloc_conversions (size_t n
)
768 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
772 build_conv (conversion_kind code
, tree type
, conversion
*from
)
775 conversion_rank rank
= CONVERSION_RANK (from
);
777 /* Note that the caller is responsible for filling in t->cand for
778 user-defined conversions. */
779 t
= alloc_conversion (code
);
803 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
804 t
->bad_p
= from
->bad_p
;
809 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
810 specialization of std::initializer_list<T>, if such a conversion is
814 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
816 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
817 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
818 conversion
**subconvs
= alloc_conversions (len
);
823 /* Within a list-initialization we can have more user-defined
825 flags
&= ~LOOKUP_NO_CONVERSION
;
826 /* But no narrowing conversions. */
827 flags
|= LOOKUP_NO_NARROWING
;
829 /* Can't make an array of these types. */
830 if (TYPE_REF_P (elttype
)
831 || TREE_CODE (elttype
) == FUNCTION_TYPE
832 || VOID_TYPE_P (elttype
))
835 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
838 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
839 false, flags
, complain
);
846 t
= alloc_conversion (ck_list
);
848 t
->u
.list
= subconvs
;
851 for (i
= 0; i
< len
; ++i
)
853 conversion
*sub
= subconvs
[i
];
854 if (sub
->rank
> t
->rank
)
856 if (sub
->user_conv_p
)
857 t
->user_conv_p
= true;
865 /* Return the next conversion of the conversion chain (if applicable),
866 or NULL otherwise. Please use this function instead of directly
867 accessing fields of struct conversion. */
870 next_conversion (conversion
*conv
)
873 || conv
->kind
== ck_identity
874 || conv
->kind
== ck_ambig
875 || conv
->kind
== ck_list
)
880 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
881 is a valid aggregate initializer for array type ATYPE. */
884 can_convert_array (tree atype
, tree ctor
, int flags
, tsubst_flags_t complain
)
887 tree elttype
= TREE_TYPE (atype
);
888 for (i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
890 tree val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
892 if (TREE_CODE (elttype
) == ARRAY_TYPE
893 && TREE_CODE (val
) == CONSTRUCTOR
)
894 ok
= can_convert_array (elttype
, val
, flags
, complain
);
896 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
904 /* Helper for build_aggr_conv. Return true if FIELD is in PSET, or if
905 FIELD has ANON_AGGR_TYPE_P and any initializable field in there recursively
909 field_in_pset (hash_set
<tree
, true> &pset
, tree field
)
911 if (pset
.contains (field
))
913 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
914 for (field
= TYPE_FIELDS (TREE_TYPE (field
));
915 field
; field
= DECL_CHAIN (field
))
917 field
= next_initializable_field (field
);
918 if (field
== NULL_TREE
)
920 if (field_in_pset (pset
, field
))
926 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
927 aggregate class, if such a conversion is possible. */
930 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
932 unsigned HOST_WIDE_INT i
= 0;
934 tree field
= next_initializable_field (TYPE_FIELDS (type
));
935 tree empty_ctor
= NULL_TREE
;
936 hash_set
<tree
, true> pset
;
938 /* We already called reshape_init in implicit_conversion. */
940 /* The conversions within the init-list aren't affected by the enclosing
941 context; they're always simple copy-initialization. */
942 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
944 /* For designated initializers, verify that each initializer is convertible
945 to corresponding TREE_TYPE (ce->index) and mark those FIELD_DECLs as
946 visited. In the following loop then ignore already visited
948 if (CONSTRUCTOR_IS_DESIGNATED_INIT (ctor
))
951 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), i
, idx
, val
)
953 if (idx
&& TREE_CODE (idx
) == FIELD_DECL
)
955 tree ftype
= TREE_TYPE (idx
);
958 if (TREE_CODE (ftype
) == ARRAY_TYPE
959 && TREE_CODE (val
) == CONSTRUCTOR
)
960 ok
= can_convert_array (ftype
, val
, flags
, complain
);
962 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
967 /* For unions, there should be just one initializer. */
968 if (TREE_CODE (type
) == UNION_TYPE
)
981 for (; field
; field
= next_initializable_field (DECL_CHAIN (field
)))
983 tree ftype
= TREE_TYPE (field
);
987 if (!pset
.is_empty () && field_in_pset (pset
, field
))
989 if (i
< CONSTRUCTOR_NELTS (ctor
))
991 val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
994 else if (DECL_INITIAL (field
))
995 val
= get_nsdmi (field
, /*ctor*/false, complain
);
996 else if (TYPE_REF_P (ftype
))
997 /* Value-initialization of reference is ill-formed. */
1001 if (empty_ctor
== NULL_TREE
)
1002 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
1006 if (TREE_CODE (ftype
) == ARRAY_TYPE
1007 && TREE_CODE (val
) == CONSTRUCTOR
)
1008 ok
= can_convert_array (ftype
, val
, flags
, complain
);
1010 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
1016 if (TREE_CODE (type
) == UNION_TYPE
)
1020 if (i
< CONSTRUCTOR_NELTS (ctor
))
1023 c
= alloc_conversion (ck_aggr
);
1026 c
->user_conv_p
= true;
1027 c
->check_narrowing
= true;
1032 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
1033 array type, if such a conversion is possible. */
1036 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
1039 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1040 tree elttype
= TREE_TYPE (type
);
1045 enum conversion_rank rank
= cr_exact
;
1047 /* We might need to propagate the size from the element to the array. */
1048 complete_type (type
);
1050 if (TYPE_DOMAIN (type
)
1051 && !variably_modified_type_p (TYPE_DOMAIN (type
), NULL_TREE
))
1053 unsigned HOST_WIDE_INT alen
= tree_to_uhwi (array_type_nelts_top (type
));
1058 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1060 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
1063 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
1064 false, flags
, complain
);
1068 if (sub
->rank
> rank
)
1070 if (sub
->user_conv_p
)
1076 c
= alloc_conversion (ck_aggr
);
1079 c
->user_conv_p
= user
;
1085 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
1086 complex type, if such a conversion is possible. */
1089 build_complex_conv (tree type
, tree ctor
, int flags
,
1090 tsubst_flags_t complain
)
1093 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1094 tree elttype
= TREE_TYPE (type
);
1099 enum conversion_rank rank
= cr_exact
;
1104 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1106 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
1109 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
1110 false, flags
, complain
);
1114 if (sub
->rank
> rank
)
1116 if (sub
->user_conv_p
)
1122 c
= alloc_conversion (ck_aggr
);
1125 c
->user_conv_p
= user
;
1131 /* Build a representation of the identity conversion from EXPR to
1132 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1135 build_identity_conv (tree type
, tree expr
)
1139 c
= alloc_conversion (ck_identity
);
1146 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1147 were multiple user-defined conversions to accomplish the job.
1148 Build a conversion that indicates that ambiguity. */
1151 build_ambiguous_conv (tree type
, tree expr
)
1155 c
= alloc_conversion (ck_ambig
);
1163 strip_top_quals (tree t
)
1165 if (TREE_CODE (t
) == ARRAY_TYPE
)
1167 return cp_build_qualified_type (t
, 0);
1170 /* Returns the standard conversion path (see [conv]) from type FROM to type
1171 TO, if any. For proper handling of null pointer constants, you must
1172 also pass the expression EXPR to convert from. If C_CAST_P is true,
1173 this conversion is coming from a C-style cast. */
1176 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1177 int flags
, tsubst_flags_t complain
)
1179 enum tree_code fcode
, tcode
;
1181 bool fromref
= false;
1184 to
= non_reference (to
);
1185 if (TYPE_REF_P (from
))
1188 from
= TREE_TYPE (from
);
1191 to
= strip_top_quals (to
);
1192 from
= strip_top_quals (from
);
1194 if (expr
&& type_unknown_p (expr
))
1196 if (TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1198 tsubst_flags_t tflags
= tf_conv
;
1199 expr
= instantiate_type (to
, expr
, tflags
);
1200 if (expr
== error_mark_node
)
1202 from
= TREE_TYPE (expr
);
1204 else if (TREE_CODE (to
) == BOOLEAN_TYPE
)
1206 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1207 expr
= resolve_nondeduced_context (expr
, complain
);
1208 from
= TREE_TYPE (expr
);
1212 fcode
= TREE_CODE (from
);
1213 tcode
= TREE_CODE (to
);
1215 conv
= build_identity_conv (from
, expr
);
1216 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1218 from
= type_decays_to (from
);
1219 fcode
= TREE_CODE (from
);
1220 /* Tell convert_like_real that we're using the address. */
1221 conv
->rvaluedness_matches_p
= true;
1222 conv
= build_conv (ck_lvalue
, from
, conv
);
1224 /* Wrapping a ck_rvalue around a class prvalue (as a result of using
1225 obvalue_p) seems odd, since it's already a prvalue, but that's how we
1226 express the copy constructor call required by copy-initialization. */
1227 else if (fromref
|| (expr
&& obvalue_p (expr
)))
1232 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1235 from
= strip_top_quals (bitfield_type
);
1236 fcode
= TREE_CODE (from
);
1239 conv
= build_conv (ck_rvalue
, from
, conv
);
1240 if (flags
& LOOKUP_PREFER_RVALUE
)
1241 /* Tell convert_like_real to set LOOKUP_PREFER_RVALUE. */
1242 conv
->rvaluedness_matches_p
= true;
1245 /* Allow conversion between `__complex__' data types. */
1246 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1248 /* The standard conversion sequence to convert FROM to TO is
1249 the standard conversion sequence to perform componentwise
1251 conversion
*part_conv
= standard_conversion
1252 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
,
1257 conv
= build_conv (part_conv
->kind
, to
, conv
);
1258 conv
->rank
= part_conv
->rank
;
1266 if (same_type_p (from
, to
))
1268 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1269 conv
->type
= qualified_to
;
1274 A null pointer constant can be converted to a pointer type; ... A
1275 null pointer constant of integral type can be converted to an
1276 rvalue of type std::nullptr_t. */
1277 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1278 || NULLPTR_TYPE_P (to
))
1279 && ((expr
&& null_ptr_cst_p (expr
))
1280 || NULLPTR_TYPE_P (from
)))
1281 conv
= build_conv (ck_std
, to
, conv
);
1282 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1283 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1285 /* For backwards brain damage compatibility, allow interconversion of
1286 pointers and integers with a pedwarn. */
1287 conv
= build_conv (ck_std
, to
, conv
);
1290 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1292 /* For backwards brain damage compatibility, allow interconversion of
1293 enums and integers with a pedwarn. */
1294 conv
= build_conv (ck_std
, to
, conv
);
1297 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1298 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1303 if (tcode
== POINTER_TYPE
)
1305 to_pointee
= TREE_TYPE (to
);
1306 from_pointee
= TREE_TYPE (from
);
1308 /* Since this is the target of a pointer, it can't have function
1309 qualifiers, so any TYPE_QUALS must be for attributes const or
1310 noreturn. Strip them. */
1311 if (TREE_CODE (to_pointee
) == FUNCTION_TYPE
1312 && TYPE_QUALS (to_pointee
))
1313 to_pointee
= build_qualified_type (to_pointee
, TYPE_UNQUALIFIED
);
1314 if (TREE_CODE (from_pointee
) == FUNCTION_TYPE
1315 && TYPE_QUALS (from_pointee
))
1316 from_pointee
= build_qualified_type (from_pointee
, TYPE_UNQUALIFIED
);
1320 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1321 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1324 if (tcode
== POINTER_TYPE
1325 && same_type_ignoring_top_level_qualifiers_p (from_pointee
,
1328 else if (VOID_TYPE_P (to_pointee
)
1329 && !TYPE_PTRDATAMEM_P (from
)
1330 && TREE_CODE (from_pointee
) != FUNCTION_TYPE
)
1332 tree nfrom
= TREE_TYPE (from
);
1333 /* Don't try to apply restrict to void. */
1334 int quals
= cp_type_quals (nfrom
) & ~TYPE_QUAL_RESTRICT
;
1335 from_pointee
= cp_build_qualified_type (void_type_node
, quals
);
1336 from
= build_pointer_type (from_pointee
);
1337 conv
= build_conv (ck_ptr
, from
, conv
);
1339 else if (TYPE_PTRDATAMEM_P (from
))
1341 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1342 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1344 if (same_type_p (fbase
, tbase
))
1345 /* No base conversion needed. */;
1346 else if (DERIVED_FROM_P (fbase
, tbase
)
1347 && (same_type_ignoring_top_level_qualifiers_p
1348 (from_pointee
, to_pointee
)))
1350 from
= build_ptrmem_type (tbase
, from_pointee
);
1351 conv
= build_conv (ck_pmem
, from
, conv
);
1356 else if (CLASS_TYPE_P (from_pointee
)
1357 && CLASS_TYPE_P (to_pointee
)
1360 An rvalue of type "pointer to cv D," where D is a
1361 class type, can be converted to an rvalue of type
1362 "pointer to cv B," where B is a base class (clause
1363 _class.derived_) of D. If B is an inaccessible
1364 (clause _class.access_) or ambiguous
1365 (_class.member.lookup_) base class of D, a program
1366 that necessitates this conversion is ill-formed.
1367 Therefore, we use DERIVED_FROM_P, and do not check
1368 access or uniqueness. */
1369 && DERIVED_FROM_P (to_pointee
, from_pointee
))
1372 = cp_build_qualified_type (to_pointee
,
1373 cp_type_quals (from_pointee
));
1374 from
= build_pointer_type (from_pointee
);
1375 conv
= build_conv (ck_ptr
, from
, conv
);
1376 conv
->base_p
= true;
1379 if (same_type_p (from
, to
))
1381 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
1382 /* In a C-style cast, we ignore CV-qualification because we
1383 are allowed to perform a static_cast followed by a
1385 conv
= build_conv (ck_qual
, to
, conv
);
1386 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1387 conv
= build_conv (ck_qual
, to
, conv
);
1388 else if (expr
&& string_conv_p (to
, expr
, 0))
1389 /* converting from string constant to char *. */
1390 conv
= build_conv (ck_qual
, to
, conv
);
1391 else if (fnptr_conv_p (to
, from
))
1392 conv
= build_conv (ck_fnptr
, to
, conv
);
1393 /* Allow conversions among compatible ObjC pointer types (base
1394 conversions have been already handled above). */
1395 else if (c_dialect_objc ()
1396 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1397 conv
= build_conv (ck_ptr
, to
, conv
);
1398 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1400 conv
= build_conv (ck_ptr
, to
, conv
);
1408 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1410 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1411 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1412 tree fbase
= class_of_this_parm (fromfn
);
1413 tree tbase
= class_of_this_parm (tofn
);
1415 if (!DERIVED_FROM_P (fbase
, tbase
))
1418 tree fstat
= static_fn_type (fromfn
);
1419 tree tstat
= static_fn_type (tofn
);
1420 if (same_type_p (tstat
, fstat
)
1421 || fnptr_conv_p (tstat
, fstat
))
1426 if (!same_type_p (fbase
, tbase
))
1428 from
= build_memfn_type (fstat
,
1430 cp_type_quals (tbase
),
1431 type_memfn_rqual (tofn
));
1432 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1433 conv
= build_conv (ck_pmem
, from
, conv
);
1434 conv
->base_p
= true;
1436 if (fnptr_conv_p (tstat
, fstat
))
1437 conv
= build_conv (ck_fnptr
, to
, conv
);
1439 else if (tcode
== BOOLEAN_TYPE
)
1443 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1444 to member type can be converted to a prvalue of type bool. ...
1445 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1446 std::nullptr_t can be converted to a prvalue of type bool; */
1447 if (ARITHMETIC_TYPE_P (from
)
1448 || UNSCOPED_ENUM_P (from
)
1449 || fcode
== POINTER_TYPE
1450 || TYPE_PTRMEM_P (from
)
1451 || NULLPTR_TYPE_P (from
))
1453 conv
= build_conv (ck_std
, to
, conv
);
1454 if (fcode
== POINTER_TYPE
1455 || TYPE_PTRDATAMEM_P (from
)
1456 || (TYPE_PTRMEMFUNC_P (from
)
1457 && conv
->rank
< cr_pbool
)
1458 || NULLPTR_TYPE_P (from
))
1459 conv
->rank
= cr_pbool
;
1460 if (NULLPTR_TYPE_P (from
) && (flags
& LOOKUP_ONLYCONVERTING
))
1462 if (flags
& LOOKUP_NO_NARROWING
)
1463 conv
->check_narrowing
= true;
1469 /* We don't check for ENUMERAL_TYPE here because there are no standard
1470 conversions to enum type. */
1471 /* As an extension, allow conversion to complex type. */
1472 else if (ARITHMETIC_TYPE_P (to
))
1474 if (! (INTEGRAL_CODE_P (fcode
)
1475 || (fcode
== REAL_TYPE
&& !(flags
& LOOKUP_NO_NON_INTEGRAL
)))
1476 || SCOPED_ENUM_P (from
))
1479 /* If we're parsing an enum with no fixed underlying type, we're
1480 dealing with an incomplete type, which renders the conversion
1482 if (!COMPLETE_TYPE_P (from
))
1485 conv
= build_conv (ck_std
, to
, conv
);
1487 /* Give this a better rank if it's a promotion. */
1488 if (same_type_p (to
, type_promotes_to (from
))
1489 && next_conversion (conv
)->rank
<= cr_promotion
)
1490 conv
->rank
= cr_promotion
;
1492 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1493 && vector_types_convertible_p (from
, to
, false))
1494 return build_conv (ck_std
, to
, conv
);
1495 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1496 && is_properly_derived_from (from
, to
))
1498 if (conv
->kind
== ck_rvalue
)
1499 conv
= next_conversion (conv
);
1500 conv
= build_conv (ck_base
, to
, conv
);
1501 /* The derived-to-base conversion indicates the initialization
1502 of a parameter with base type from an object of a derived
1503 type. A temporary object is created to hold the result of
1504 the conversion unless we're binding directly to a reference. */
1505 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1506 if (flags
& LOOKUP_PREFER_RVALUE
)
1507 /* Tell convert_like_real to set LOOKUP_PREFER_RVALUE. */
1508 conv
->rvaluedness_matches_p
= true;
1513 if (flags
& LOOKUP_NO_NARROWING
)
1514 conv
->check_narrowing
= true;
1519 /* Returns nonzero if T1 is reference-related to T2. */
1522 reference_related_p (tree t1
, tree t2
)
1524 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1527 t1
= TYPE_MAIN_VARIANT (t1
);
1528 t2
= TYPE_MAIN_VARIANT (t2
);
1532 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1533 to "cv2 T2" if T1 is similar to T2, or T1 is a base class of T2. */
1534 return (similar_type_p (t1
, t2
)
1535 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1536 && DERIVED_FROM_P (t1
, t2
)));
1539 /* Returns nonzero if T1 is reference-compatible with T2. */
1542 reference_compatible_p (tree t1
, tree t2
)
1546 "cv1 T1" is reference compatible with "cv2 T2" if
1547 a prvalue of type "pointer to cv2 T2" can be converted to the type
1548 "pointer to cv1 T1" via a standard conversion sequence. */
1549 tree ptype1
= build_pointer_type (t1
);
1550 tree ptype2
= build_pointer_type (t2
);
1551 conversion
*conv
= standard_conversion (ptype1
, ptype2
, NULL_TREE
,
1552 /*c_cast_p=*/false, 0, tf_none
);
1553 if (!conv
|| conv
->bad_p
)
1558 /* Return true if converting FROM to TO would involve a qualification
1562 involves_qualification_conversion_p (tree to
, tree from
)
1564 /* If we're not convering a pointer to another one, we won't get
1565 a qualification conversion. */
1566 if (!((TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
1567 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
))))
1570 conversion
*conv
= standard_conversion (to
, from
, NULL_TREE
,
1571 /*c_cast_p=*/false, 0, tf_none
);
1572 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1573 if (t
->kind
== ck_qual
)
1579 /* A reference of the indicated TYPE is being bound directly to the
1580 expression represented by the implicit conversion sequence CONV.
1581 Return a conversion sequence for this binding. */
1584 direct_reference_binding (tree type
, conversion
*conv
)
1588 gcc_assert (TYPE_REF_P (type
));
1589 gcc_assert (!TYPE_REF_P (conv
->type
));
1591 t
= TREE_TYPE (type
);
1593 if (conv
->kind
== ck_identity
)
1594 /* Mark the identity conv as to not decay to rvalue. */
1595 conv
->rvaluedness_matches_p
= true;
1599 When a parameter of reference type binds directly
1600 (_dcl.init.ref_) to an argument expression, the implicit
1601 conversion sequence is the identity conversion, unless the
1602 argument expression has a type that is a derived class of the
1603 parameter type, in which case the implicit conversion sequence is
1604 a derived-to-base Conversion.
1606 If the parameter binds directly to the result of applying a
1607 conversion function to the argument expression, the implicit
1608 conversion sequence is a user-defined conversion sequence
1609 (_over.ics.user_), with the second standard conversion sequence
1610 either an identity conversion or, if the conversion function
1611 returns an entity of a type that is a derived class of the
1612 parameter type, a derived-to-base conversion. */
1613 if (is_properly_derived_from (conv
->type
, t
))
1615 /* Represent the derived-to-base conversion. */
1616 conv
= build_conv (ck_base
, t
, conv
);
1617 /* We will actually be binding to the base-class subobject in
1618 the derived class, so we mark this conversion appropriately.
1619 That way, convert_like knows not to generate a temporary. */
1620 conv
->need_temporary_p
= false;
1622 else if (involves_qualification_conversion_p (t
, conv
->type
))
1623 /* Represent the qualification conversion. After DR 2352
1624 #1 and #2 were indistinguishable conversion sequences:
1627 void f(const int* const &); // #2
1628 void g(int* p) { f(p); }
1630 because the types "int *" and "const int *const" are
1631 reference-related and we were binding both directly and they
1632 had the same rank. To break it up, we add a ck_qual under the
1633 ck_ref_bind so that conversion sequence ranking chooses #1. */
1634 conv
= build_conv (ck_qual
, t
, conv
);
1636 return build_conv (ck_ref_bind
, type
, conv
);
1639 /* Returns the conversion path from type FROM to reference type TO for
1640 purposes of reference binding. For lvalue binding, either pass a
1641 reference type to FROM or an lvalue expression to EXPR. If the
1642 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1643 the conversion returned. If C_CAST_P is true, this
1644 conversion is coming from a C-style cast. */
1647 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1648 tsubst_flags_t complain
)
1650 conversion
*conv
= NULL
;
1651 tree to
= TREE_TYPE (rto
);
1656 cp_lvalue_kind gl_kind
;
1659 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1661 expr
= instantiate_type (to
, expr
, tf_none
);
1662 if (expr
== error_mark_node
)
1664 from
= TREE_TYPE (expr
);
1667 bool copy_list_init
= false;
1668 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1670 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1671 /* DR 1288: Otherwise, if the initializer list has a single element
1672 of type E and ... [T's] referenced type is reference-related to E,
1673 the object or reference is initialized from that element... */
1674 if (CONSTRUCTOR_NELTS (expr
) == 1)
1676 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1677 if (error_operand_p (elt
))
1679 tree etype
= TREE_TYPE (elt
);
1680 if (reference_related_p (to
, etype
))
1687 /* Otherwise, if T is a reference type, a prvalue temporary of the type
1688 referenced by T is copy-list-initialized, and the reference is bound
1689 to that temporary. */
1690 copy_list_init
= true;
1694 if (TYPE_REF_P (from
))
1696 from
= TREE_TYPE (from
);
1697 if (!TYPE_REF_IS_RVALUE (rfrom
)
1698 || TREE_CODE (from
) == FUNCTION_TYPE
)
1699 gl_kind
= clk_ordinary
;
1701 gl_kind
= clk_rvalueref
;
1704 gl_kind
= lvalue_kind (expr
);
1705 else if (CLASS_TYPE_P (from
)
1706 || TREE_CODE (from
) == ARRAY_TYPE
)
1707 gl_kind
= clk_class
;
1711 /* Don't allow a class prvalue when LOOKUP_NO_TEMP_BIND. */
1712 if ((flags
& LOOKUP_NO_TEMP_BIND
)
1713 && (gl_kind
& clk_class
))
1716 /* Same mask as real_lvalue_p. */
1717 is_lvalue
= gl_kind
&& !(gl_kind
& (clk_rvalueref
|clk_class
));
1720 if ((gl_kind
& clk_bitfield
) != 0)
1721 tfrom
= unlowered_expr_type (expr
);
1723 /* Figure out whether or not the types are reference-related and
1724 reference compatible. We have to do this after stripping
1725 references from FROM. */
1726 related_p
= reference_related_p (to
, tfrom
);
1727 /* If this is a C cast, first convert to an appropriately qualified
1728 type, so that we can later do a const_cast to the desired type. */
1729 if (related_p
&& c_cast_p
1730 && !at_least_as_qualified_p (to
, tfrom
))
1731 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1732 compatible_p
= reference_compatible_p (to
, tfrom
);
1734 /* Directly bind reference when target expression's type is compatible with
1735 the reference and expression is an lvalue. In DR391, the wording in
1736 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1737 const and rvalue references to rvalues of compatible class type.
1738 We should also do direct bindings for non-class xvalues. */
1739 if ((related_p
|| compatible_p
) && gl_kind
)
1743 If the initializer expression
1745 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1746 is reference-compatible with "cv2 T2,"
1748 the reference is bound directly to the initializer expression
1752 If the initializer expression is an rvalue, with T2 a class type,
1753 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1754 is bound to the object represented by the rvalue or to a sub-object
1755 within that object. */
1757 conv
= build_identity_conv (tfrom
, expr
);
1758 conv
= direct_reference_binding (rto
, conv
);
1760 if (TYPE_REF_P (rfrom
))
1761 /* Handle rvalue reference to function properly. */
1762 conv
->rvaluedness_matches_p
1763 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1765 conv
->rvaluedness_matches_p
1766 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1768 if ((gl_kind
& clk_bitfield
) != 0
1769 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1770 /* For the purposes of overload resolution, we ignore the fact
1771 this expression is a bitfield or packed field. (In particular,
1772 [over.ics.ref] says specifically that a function with a
1773 non-const reference parameter is viable even if the
1774 argument is a bitfield.)
1776 However, when we actually call the function we must create
1777 a temporary to which to bind the reference. If the
1778 reference is volatile, or isn't const, then we cannot make
1779 a temporary, so we just issue an error when the conversion
1781 conv
->need_temporary_p
= true;
1783 /* Don't allow binding of lvalues (other than function lvalues) to
1784 rvalue references. */
1785 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1786 && TREE_CODE (to
) != FUNCTION_TYPE
)
1789 /* Nor the reverse. */
1790 if (!is_lvalue
&& !TYPE_REF_IS_RVALUE (rto
)
1791 && (!CP_TYPE_CONST_NON_VOLATILE_P (to
)
1792 || (flags
& LOOKUP_NO_RVAL_BIND
))
1793 && TREE_CODE (to
) != FUNCTION_TYPE
)
1801 /* [class.conv.fct] A conversion function is never used to convert a
1802 (possibly cv-qualified) object to the (possibly cv-qualified) same
1803 object type (or a reference to it), to a (possibly cv-qualified) base
1804 class of that type (or a reference to it).... */
1805 else if (CLASS_TYPE_P (from
) && !related_p
1806 && !(flags
& LOOKUP_NO_CONVERSION
))
1810 If the initializer expression
1812 -- has a class type (i.e., T2 is a class type) can be
1813 implicitly converted to an lvalue of type "cv3 T3," where
1814 "cv1 T1" is reference-compatible with "cv3 T3". (this
1815 conversion is selected by enumerating the applicable
1816 conversion functions (_over.match.ref_) and choosing the
1817 best one through overload resolution. (_over.match_).
1819 the reference is bound to the lvalue result of the conversion
1820 in the second case. */
1821 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1824 return cand
->second_conv
;
1827 /* From this point on, we conceptually need temporaries, even if we
1828 elide them. Only the cases above are "direct bindings". */
1829 if (flags
& LOOKUP_NO_TEMP_BIND
)
1834 When a parameter of reference type is not bound directly to an
1835 argument expression, the conversion sequence is the one required
1836 to convert the argument expression to the underlying type of the
1837 reference according to _over.best.ics_. Conceptually, this
1838 conversion sequence corresponds to copy-initializing a temporary
1839 of the underlying type with the argument expression. Any
1840 difference in top-level cv-qualification is subsumed by the
1841 initialization itself and does not constitute a conversion. */
1845 Otherwise, the reference shall be an lvalue reference to a
1846 non-volatile const type, or the reference shall be an rvalue
1849 We try below to treat this as a bad conversion to improve diagnostics,
1850 but if TO is an incomplete class, we need to reject this conversion
1851 now to avoid unnecessary instantiation. */
1852 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
)
1853 && !COMPLETE_TYPE_P (to
))
1856 /* We're generating a temporary now, but don't bind any more in the
1857 conversion (specifically, don't slice the temporary returned by a
1858 conversion operator). */
1859 flags
|= LOOKUP_NO_TEMP_BIND
;
1861 /* Core issue 899: When [copy-]initializing a temporary to be bound
1862 to the first parameter of a copy constructor (12.8) called with
1863 a single argument in the context of direct-initialization,
1864 explicit conversion functions are also considered.
1866 So don't set LOOKUP_ONLYCONVERTING in that case. */
1867 if (!(flags
& LOOKUP_COPY_PARM
))
1868 flags
|= LOOKUP_ONLYCONVERTING
;
1871 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1876 if (conv
->user_conv_p
)
1879 /* Remember this was copy-list-initialization. */
1880 conv
->need_temporary_p
= true;
1882 /* If initializing the temporary used a conversion function,
1883 recalculate the second conversion sequence. */
1884 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1885 if (t
->kind
== ck_user
1886 && DECL_CONV_FN_P (t
->cand
->fn
))
1888 tree ftype
= TREE_TYPE (TREE_TYPE (t
->cand
->fn
));
1889 /* A prvalue of non-class type is cv-unqualified. */
1890 if (!TYPE_REF_P (ftype
) && !CLASS_TYPE_P (ftype
))
1891 ftype
= cv_unqualified (ftype
);
1892 int sflags
= (flags
|LOOKUP_NO_CONVERSION
)&~LOOKUP_NO_TEMP_BIND
;
1893 conversion
*new_second
1894 = reference_binding (rto
, ftype
, NULL_TREE
, c_cast_p
,
1898 return merge_conversion_sequences (t
, new_second
);
1902 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1903 /* This reference binding, unlike those above, requires the
1904 creation of a temporary. */
1905 conv
->need_temporary_p
= true;
1906 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1910 Otherwise, the reference shall be an lvalue reference to a
1911 non-volatile const type, or the reference shall be an rvalue
1913 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1918 Otherwise, a temporary of type "cv1 T1" is created and
1919 initialized from the initializer expression using the rules for a
1920 non-reference copy initialization. If T1 is reference-related to
1921 T2, cv1 must be the same cv-qualification as, or greater
1922 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1923 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1929 /* Returns the implicit conversion sequence (see [over.ics]) from type
1930 FROM to type TO. The optional expression EXPR may affect the
1931 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1932 true, this conversion is coming from a C-style cast. */
1935 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1936 int flags
, tsubst_flags_t complain
)
1940 if (from
== error_mark_node
|| to
== error_mark_node
1941 || expr
== error_mark_node
)
1944 /* Other flags only apply to the primary function in overload
1945 resolution, or after we've chosen one. */
1946 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
1947 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_PREFER_RVALUE
1948 |LOOKUP_NO_NARROWING
|LOOKUP_PROTECT
|LOOKUP_NO_NON_INTEGRAL
);
1950 /* FIXME: actually we don't want warnings either, but we can't just
1951 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1952 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1953 We really ought not to issue that warning until we've committed
1954 to that conversion. */
1955 complain
&= ~tf_error
;
1957 /* Call reshape_init early to remove redundant braces. */
1958 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
)
1959 && CLASS_TYPE_P (to
)
1960 && COMPLETE_TYPE_P (complete_type (to
))
1961 && !CLASSTYPE_NON_AGGREGATE (to
))
1963 expr
= reshape_init (to
, expr
, complain
);
1964 if (expr
== error_mark_node
)
1966 from
= TREE_TYPE (expr
);
1969 if (TYPE_REF_P (to
))
1970 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
1972 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
, complain
);
1977 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1979 if (is_std_init_list (to
) && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
))
1980 return build_list_conv (to
, expr
, flags
, complain
);
1982 /* As an extension, allow list-initialization of _Complex. */
1983 if (TREE_CODE (to
) == COMPLEX_TYPE
1984 && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
))
1986 conv
= build_complex_conv (to
, expr
, flags
, complain
);
1991 /* Allow conversion from an initializer-list with one element to a
1993 if (SCALAR_TYPE_P (to
))
1995 int nelts
= CONSTRUCTOR_NELTS (expr
);
1999 elt
= build_value_init (to
, tf_none
);
2000 else if (nelts
== 1 && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
))
2001 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
2003 elt
= error_mark_node
;
2005 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
2006 c_cast_p
, flags
, complain
);
2009 conv
->check_narrowing
= true;
2010 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
2011 /* Too many levels of braces, i.e. '{{1}}'. */
2016 else if (TREE_CODE (to
) == ARRAY_TYPE
)
2017 return build_array_conv (to
, expr
, flags
, complain
);
2020 if (expr
!= NULL_TREE
2021 && (MAYBE_CLASS_TYPE_P (from
)
2022 || MAYBE_CLASS_TYPE_P (to
))
2023 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
2025 struct z_candidate
*cand
;
2027 if (CLASS_TYPE_P (to
)
2028 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
2029 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
2030 return build_aggr_conv (to
, expr
, flags
, complain
);
2032 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
2035 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
2036 && CONSTRUCTOR_NELTS (expr
) == 1
2037 && !is_list_ctor (cand
->fn
))
2039 /* "If C is not an initializer-list constructor and the
2040 initializer list has a single element of type cv U, where U is
2041 X or a class derived from X, the implicit conversion sequence
2042 has Exact Match rank if U is X, or Conversion rank if U is
2044 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
2045 tree elttype
= TREE_TYPE (elt
);
2046 if (reference_related_p (to
, elttype
))
2047 return implicit_conversion (to
, elttype
, elt
,
2048 c_cast_p
, flags
, complain
);
2050 conv
= cand
->second_conv
;
2053 /* We used to try to bind a reference to a temporary here, but that
2054 is now handled after the recursive call to this function at the end
2055 of reference_binding. */
2062 /* Like implicit_conversion, but return NULL if the conversion is bad.
2064 This is not static so that check_non_deducible_conversion can call it within
2065 add_template_candidate_real as part of overload resolution; it should not be
2066 called outside of overload resolution. */
2069 good_conversion (tree to
, tree from
, tree expr
,
2070 int flags
, tsubst_flags_t complain
)
2072 conversion
*c
= implicit_conversion (to
, from
, expr
, /*cast*/false,
2079 /* Add a new entry to the list of candidates. Used by the add_*_candidate
2080 functions. ARGS will not be changed until a single candidate is
2083 static struct z_candidate
*
2084 add_candidate (struct z_candidate
**candidates
,
2085 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
2086 size_t num_convs
, conversion
**convs
,
2087 tree access_path
, tree conversion_path
,
2088 int viable
, struct rejection_reason
*reason
,
2091 struct z_candidate
*cand
= (struct z_candidate
*)
2092 conversion_obstack_alloc (sizeof (struct z_candidate
));
2095 cand
->first_arg
= first_arg
;
2097 cand
->convs
= convs
;
2098 cand
->num_convs
= num_convs
;
2099 cand
->access_path
= access_path
;
2100 cand
->conversion_path
= conversion_path
;
2101 cand
->viable
= viable
;
2102 cand
->reason
= reason
;
2103 cand
->next
= *candidates
;
2104 cand
->flags
= flags
;
2110 /* Return the number of remaining arguments in the parameter list
2111 beginning with ARG. */
2114 remaining_arguments (tree arg
)
2118 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
2119 arg
= TREE_CHAIN (arg
))
2125 /* [over.match.copy]: When initializing a temporary object (12.2) to be bound
2126 to the first parameter of a constructor where the parameter is of type
2127 "reference to possibly cv-qualified T" and the constructor is called with a
2128 single argument in the context of direct-initialization of an object of type
2129 "cv2 T", explicit conversion functions are also considered.
2131 So set LOOKUP_COPY_PARM to let reference_binding know that
2132 it's being called in that context. */
2135 conv_flags (int i
, int nargs
, tree fn
, tree arg
, int flags
)
2139 if (i
== 0 && nargs
== 1 && DECL_CONSTRUCTOR_P (fn
)
2140 && (t
= FUNCTION_FIRST_USER_PARMTYPE (fn
))
2141 && (same_type_ignoring_top_level_qualifiers_p
2142 (non_reference (TREE_VALUE (t
)), DECL_CONTEXT (fn
))))
2144 if (!(flags
& LOOKUP_ONLYCONVERTING
))
2145 lflags
|= LOOKUP_COPY_PARM
;
2146 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
2147 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
2148 lflags
|= LOOKUP_NO_CONVERSION
;
2151 lflags
|= LOOKUP_ONLYCONVERTING
;
2156 /* Create an overload candidate for the function or method FN called
2157 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
2158 FLAGS is passed on to implicit_conversion.
2160 This does not change ARGS.
2162 CTYPE, if non-NULL, is the type we want to pretend this function
2163 comes from for purposes of overload resolution. */
2165 static struct z_candidate
*
2166 add_function_candidate (struct z_candidate
**candidates
,
2167 tree fn
, tree ctype
, tree first_arg
,
2168 const vec
<tree
, va_gc
> *args
, tree access_path
,
2169 tree conversion_path
, int flags
,
2171 tsubst_flags_t complain
)
2173 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2176 tree orig_first_arg
= first_arg
;
2179 struct rejection_reason
*reason
= NULL
;
2181 /* At this point we should not see any functions which haven't been
2182 explicitly declared, except for friend functions which will have
2183 been found using argument dependent lookup. */
2184 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
2186 /* The `this', `in_chrg' and VTT arguments to constructors are not
2187 considered in overload resolution. */
2188 if (DECL_CONSTRUCTOR_P (fn
))
2190 if (ctor_omit_inherited_parms (fn
))
2191 /* Bring back parameters omitted from an inherited ctor. */
2192 parmlist
= FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn
));
2194 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
2195 skip
= num_artificial_parms_for (fn
);
2196 if (skip
> 0 && first_arg
!= NULL_TREE
)
2199 first_arg
= NULL_TREE
;
2205 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
2207 convs
= alloc_conversions (len
);
2209 /* 13.3.2 - Viable functions [over.match.viable]
2210 First, to be a viable function, a candidate function shall have enough
2211 parameters to agree in number with the arguments in the list.
2213 We need to check this first; otherwise, checking the ICSes might cause
2214 us to produce an ill-formed template instantiation. */
2216 parmnode
= parmlist
;
2217 for (i
= 0; i
< len
; ++i
)
2219 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
2221 parmnode
= TREE_CHAIN (parmnode
);
2224 if ((i
< len
&& parmnode
)
2225 || !sufficient_parms_p (parmnode
))
2227 int remaining
= remaining_arguments (parmnode
);
2229 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
2232 /* An inherited constructor (12.6.3 [class.inhctor.init]) that has a first
2233 parameter of type "reference to cv C" (including such a constructor
2234 instantiated from a template) is excluded from the set of candidate
2235 functions when used to construct an object of type D with an argument list
2236 containing a single argument if C is reference-related to D. */
2237 if (viable
&& len
== 1 && parmlist
&& DECL_CONSTRUCTOR_P (fn
)
2238 && flag_new_inheriting_ctors
2239 && DECL_INHERITED_CTOR (fn
))
2241 tree ptype
= non_reference (TREE_VALUE (parmlist
));
2242 tree dtype
= DECL_CONTEXT (fn
);
2243 tree btype
= DECL_INHERITED_CTOR_BASE (fn
);
2244 if (reference_related_p (ptype
, dtype
)
2245 && reference_related_p (btype
, ptype
))
2248 reason
= inherited_ctor_rejection ();
2252 /* Second, for a function to be viable, its constraints must be
2254 if (flag_concepts
&& viable
2255 && !constraints_satisfied_p (fn
))
2257 reason
= constraint_failure (fn
);
2261 /* When looking for a function from a subobject from an implicit
2262 copy/move constructor/operator=, don't consider anything that takes (a
2263 reference to) an unrelated type. See c++/44909 and core 1092. */
2264 if (viable
&& parmlist
&& (flags
& LOOKUP_DEFAULTED
))
2266 if (DECL_CONSTRUCTOR_P (fn
))
2268 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
2269 && DECL_OVERLOADED_OPERATOR_IS (fn
, NOP_EXPR
))
2275 parmnode
= chain_index (i
-1, parmlist
);
2276 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
2281 /* This only applies at the top level. */
2282 flags
&= ~LOOKUP_DEFAULTED
;
2288 /* Third, for F to be a viable function, there shall exist for each
2289 argument an implicit conversion sequence that converts that argument
2290 to the corresponding parameter of F. */
2292 parmnode
= parmlist
;
2294 for (i
= 0; i
< len
; ++i
)
2296 tree argtype
, to_type
;
2301 if (parmnode
== void_list_node
)
2306 /* Already set during deduction. */
2307 parmnode
= TREE_CHAIN (parmnode
);
2311 if (i
== 0 && first_arg
!= NULL_TREE
)
2314 arg
= CONST_CAST_TREE (
2315 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
2316 argtype
= lvalue_type (arg
);
2318 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2319 && ! DECL_CONSTRUCTOR_P (fn
));
2323 tree parmtype
= TREE_VALUE (parmnode
);
2325 parmnode
= TREE_CHAIN (parmnode
);
2327 /* The type of the implicit object parameter ('this') for
2328 overload resolution is not always the same as for the
2329 function itself; conversion functions are considered to
2330 be members of the class being converted, and functions
2331 introduced by a using-declaration are considered to be
2332 members of the class that uses them.
2334 Since build_over_call ignores the ICS for the `this'
2335 parameter, we can just change the parm type. */
2336 if (ctype
&& is_this
)
2338 parmtype
= cp_build_qualified_type
2339 (ctype
, cp_type_quals (TREE_TYPE (parmtype
)));
2340 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
2342 /* If the function has a ref-qualifier, the implicit
2343 object parameter has reference type. */
2344 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
2345 parmtype
= cp_build_reference_type (parmtype
, rv
);
2346 /* The special handling of 'this' conversions in compare_ics
2347 does not apply if there is a ref-qualifier. */
2352 parmtype
= build_pointer_type (parmtype
);
2353 /* We don't use build_this here because we don't want to
2354 capture the object argument until we've chosen a
2355 non-static member function. */
2356 arg
= build_address (arg
);
2357 argtype
= lvalue_type (arg
);
2361 int lflags
= conv_flags (i
, len
-skip
, fn
, arg
, flags
);
2363 t
= implicit_conversion (parmtype
, argtype
, arg
,
2364 /*c_cast_p=*/false, lflags
, complain
);
2369 t
= build_identity_conv (argtype
, arg
);
2370 t
->ellipsis_p
= true;
2381 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
,
2382 EXPR_LOCATION (arg
));
2389 reason
= bad_arg_conversion_rejection (first_arg
, i
, arg
, to_type
,
2390 EXPR_LOCATION (arg
));
2396 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2397 access_path
, conversion_path
, viable
, reason
, flags
);
2400 /* Create an overload candidate for the conversion function FN which will
2401 be invoked for expression OBJ, producing a pointer-to-function which
2402 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2403 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2404 passed on to implicit_conversion.
2406 Actually, we don't really care about FN; we care about the type it
2407 converts to. There may be multiple conversion functions that will
2408 convert to that type, and we rely on build_user_type_conversion_1 to
2409 choose the best one; so when we create our candidate, we record the type
2410 instead of the function. */
2412 static struct z_candidate
*
2413 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2414 const vec
<tree
, va_gc
> *arglist
,
2415 tree access_path
, tree conversion_path
,
2416 tsubst_flags_t complain
)
2418 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2419 int i
, len
, viable
, flags
;
2420 tree parmlist
, parmnode
;
2422 struct rejection_reason
*reason
;
2424 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2425 parmlist
= TREE_TYPE (parmlist
);
2426 parmlist
= TYPE_ARG_TYPES (parmlist
);
2428 len
= vec_safe_length (arglist
) + 1;
2429 convs
= alloc_conversions (len
);
2430 parmnode
= parmlist
;
2432 flags
= LOOKUP_IMPLICIT
;
2435 /* Don't bother looking up the same type twice. */
2436 if (*candidates
&& (*candidates
)->fn
== totype
)
2439 for (i
= 0; i
< len
; ++i
)
2441 tree arg
, argtype
, convert_type
= NULL_TREE
;
2447 arg
= (*arglist
)[i
- 1];
2448 argtype
= lvalue_type (arg
);
2452 t
= build_identity_conv (argtype
, NULL_TREE
);
2453 t
= build_conv (ck_user
, totype
, t
);
2454 /* Leave the 'cand' field null; we'll figure out the conversion in
2455 convert_like_real if this candidate is chosen. */
2456 convert_type
= totype
;
2458 else if (parmnode
== void_list_node
)
2462 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2463 /*c_cast_p=*/false, flags
, complain
);
2464 convert_type
= TREE_VALUE (parmnode
);
2468 t
= build_identity_conv (argtype
, arg
);
2469 t
->ellipsis_p
= true;
2470 convert_type
= argtype
;
2480 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, arg
, convert_type
,
2481 EXPR_LOCATION (arg
));
2488 parmnode
= TREE_CHAIN (parmnode
);
2492 || ! sufficient_parms_p (parmnode
))
2494 int remaining
= remaining_arguments (parmnode
);
2496 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2499 return add_candidate (candidates
, totype
, obj
, arglist
, len
, convs
,
2500 access_path
, conversion_path
, viable
, reason
, flags
);
2504 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2505 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
2506 int flags
, tsubst_flags_t complain
)
2513 struct rejection_reason
*reason
= NULL
;
2518 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
2519 convs
= alloc_conversions (num_convs
);
2521 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2522 conversion ops are allowed. We handle that here by just checking for
2523 boolean_type_node because other operators don't ask for it. COND_EXPR
2524 also does contextual conversion to bool for the first operand, but we
2525 handle that in build_conditional_expr, and type1 here is operand 2. */
2526 if (type1
!= boolean_type_node
)
2527 flags
|= LOOKUP_ONLYCONVERTING
;
2529 for (i
= 0; i
< 2; ++i
)
2534 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2535 /*c_cast_p=*/false, flags
, complain
);
2539 /* We need something for printing the candidate. */
2540 t
= build_identity_conv (types
[i
], NULL_TREE
);
2541 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2542 types
[i
], EXPR_LOCATION (args
[i
]));
2547 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, args
[i
],
2549 EXPR_LOCATION (args
[i
]));
2554 /* For COND_EXPR we rearranged the arguments; undo that now. */
2557 convs
[2] = convs
[1];
2558 convs
[1] = convs
[0];
2559 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2560 /*c_cast_p=*/false, flags
,
2567 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2569 EXPR_LOCATION (args
[2]));
2573 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2575 /*access_path=*/NULL_TREE
,
2576 /*conversion_path=*/NULL_TREE
,
2577 viable
, reason
, flags
);
2581 is_complete (tree t
)
2583 return COMPLETE_TYPE_P (complete_type (t
));
2586 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2589 promoted_arithmetic_type_p (tree type
)
2593 In this section, the term promoted integral type is used to refer
2594 to those integral types which are preserved by integral promotion
2595 (including e.g. int and long but excluding e.g. char).
2596 Similarly, the term promoted arithmetic type refers to promoted
2597 integral types plus floating types. */
2598 return ((CP_INTEGRAL_TYPE_P (type
)
2599 && same_type_p (type_promotes_to (type
), type
))
2600 || TREE_CODE (type
) == REAL_TYPE
);
2603 /* Create any builtin operator overload candidates for the operator in
2604 question given the converted operand types TYPE1 and TYPE2. The other
2605 args are passed through from add_builtin_candidates to
2606 build_builtin_candidate.
2608 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2609 If CODE is requires candidates operands of the same type of the kind
2610 of which TYPE1 and TYPE2 are, we add both candidates
2611 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2614 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2615 enum tree_code code2
, tree fnname
, tree type1
,
2616 tree type2
, tree
*args
, tree
*argtypes
, int flags
,
2617 tsubst_flags_t complain
)
2621 case POSTINCREMENT_EXPR
:
2622 case POSTDECREMENT_EXPR
:
2623 args
[1] = integer_zero_node
;
2624 type2
= integer_type_node
;
2633 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2634 and VQ is either volatile or empty, there exist candidate operator
2635 functions of the form
2636 VQ T& operator++(VQ T&);
2637 T operator++(VQ T&, int);
2638 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2639 type other than bool, and VQ is either volatile or empty, there exist
2640 candidate operator functions of the form
2641 VQ T& operator--(VQ T&);
2642 T operator--(VQ T&, int);
2643 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2644 complete object type, and VQ is either volatile or empty, there exist
2645 candidate operator functions of the form
2646 T*VQ& operator++(T*VQ&);
2647 T*VQ& operator--(T*VQ&);
2648 T* operator++(T*VQ&, int);
2649 T* operator--(T*VQ&, int); */
2651 case POSTDECREMENT_EXPR
:
2652 case PREDECREMENT_EXPR
:
2653 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2656 case POSTINCREMENT_EXPR
:
2657 case PREINCREMENT_EXPR
:
2658 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2660 type1
= build_reference_type (type1
);
2665 /* 7 For every cv-qualified or cv-unqualified object type T, there
2666 exist candidate operator functions of the form
2670 8 For every function type T, there exist candidate operator functions of
2672 T& operator*(T*); */
2675 if (TYPE_PTR_P (type1
)
2676 && (TYPE_PTROB_P (type1
)
2677 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2681 /* 9 For every type T, there exist candidate operator functions of the form
2684 10For every promoted arithmetic type T, there exist candidate operator
2685 functions of the form
2689 case UNARY_PLUS_EXPR
: /* unary + */
2690 if (TYPE_PTR_P (type1
))
2694 if (ARITHMETIC_TYPE_P (type1
))
2698 /* 11For every promoted integral type T, there exist candidate operator
2699 functions of the form
2703 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2707 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2708 is the same type as C2 or is a derived class of C2, T is a complete
2709 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2710 there exist candidate operator functions of the form
2711 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2712 where CV12 is the union of CV1 and CV2. */
2715 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2717 tree c1
= TREE_TYPE (type1
);
2718 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2720 if (MAYBE_CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2721 && (TYPE_PTRMEMFUNC_P (type2
)
2722 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2727 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2728 didate operator functions of the form
2733 bool operator<(L, R);
2734 bool operator>(L, R);
2735 bool operator<=(L, R);
2736 bool operator>=(L, R);
2737 bool operator==(L, R);
2738 bool operator!=(L, R);
2739 where LR is the result of the usual arithmetic conversions between
2742 14For every pair of types T and I, where T is a cv-qualified or cv-
2743 unqualified complete object type and I is a promoted integral type,
2744 there exist candidate operator functions of the form
2745 T* operator+(T*, I);
2746 T& operator[](T*, I);
2747 T* operator-(T*, I);
2748 T* operator+(I, T*);
2749 T& operator[](I, T*);
2751 15For every T, where T is a pointer to complete object type, there exist
2752 candidate operator functions of the form112)
2753 ptrdiff_t operator-(T, T);
2755 16For every pointer or enumeration type T, there exist candidate operator
2756 functions of the form
2757 bool operator<(T, T);
2758 bool operator>(T, T);
2759 bool operator<=(T, T);
2760 bool operator>=(T, T);
2761 bool operator==(T, T);
2762 bool operator!=(T, T);
2764 17For every pointer to member type T, there exist candidate operator
2765 functions of the form
2766 bool operator==(T, T);
2767 bool operator!=(T, T); */
2770 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2772 if (TYPE_PTROB_P (type1
)
2773 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2775 type2
= ptrdiff_type_node
;
2780 case TRUNC_DIV_EXPR
:
2781 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2787 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2788 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
2790 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
2795 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
2807 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2809 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2811 if (TREE_CODE (type1
) == ENUMERAL_TYPE
2812 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
2814 if (TYPE_PTR_P (type1
)
2815 && null_ptr_cst_p (args
[1]))
2820 if (null_ptr_cst_p (args
[0])
2821 && TYPE_PTR_P (type2
))
2829 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2833 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
2835 type1
= ptrdiff_type_node
;
2838 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2840 type2
= ptrdiff_type_node
;
2845 /* 18For every pair of promoted integral types L and R, there exist candi-
2846 date operator functions of the form
2853 where LR is the result of the usual arithmetic conversions between
2856 case TRUNC_MOD_EXPR
:
2862 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2866 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2867 type, VQ is either volatile or empty, and R is a promoted arithmetic
2868 type, there exist candidate operator functions of the form
2869 VQ L& operator=(VQ L&, R);
2870 VQ L& operator*=(VQ L&, R);
2871 VQ L& operator/=(VQ L&, R);
2872 VQ L& operator+=(VQ L&, R);
2873 VQ L& operator-=(VQ L&, R);
2875 20For every pair T, VQ), where T is any type and VQ is either volatile
2876 or empty, there exist candidate operator functions of the form
2877 T*VQ& operator=(T*VQ&, T*);
2879 21For every pair T, VQ), where T is a pointer to member type and VQ is
2880 either volatile or empty, there exist candidate operator functions of
2882 VQ T& operator=(VQ T&, T);
2884 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2885 unqualified complete object type, VQ is either volatile or empty, and
2886 I is a promoted integral type, there exist candidate operator func-
2888 T*VQ& operator+=(T*VQ&, I);
2889 T*VQ& operator-=(T*VQ&, I);
2891 23For every triple L, VQ, R), where L is an integral or enumeration
2892 type, VQ is either volatile or empty, and R is a promoted integral
2893 type, there exist candidate operator functions of the form
2895 VQ L& operator%=(VQ L&, R);
2896 VQ L& operator<<=(VQ L&, R);
2897 VQ L& operator>>=(VQ L&, R);
2898 VQ L& operator&=(VQ L&, R);
2899 VQ L& operator^=(VQ L&, R);
2900 VQ L& operator|=(VQ L&, R); */
2907 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2909 type2
= ptrdiff_type_node
;
2914 case TRUNC_DIV_EXPR
:
2915 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2919 case TRUNC_MOD_EXPR
:
2925 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2930 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2932 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2933 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2934 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2935 || ((TYPE_PTRMEMFUNC_P (type1
)
2936 || TYPE_PTR_P (type1
))
2937 && null_ptr_cst_p (args
[1])))
2947 type1
= build_reference_type (type1
);
2953 For every pair of promoted arithmetic types L and R, there
2954 exist candidate operator functions of the form
2956 LR operator?(bool, L, R);
2958 where LR is the result of the usual arithmetic conversions
2959 between types L and R.
2961 For every type T, where T is a pointer or pointer-to-member
2962 type, there exist candidate operator functions of the form T
2963 operator?(bool, T, T); */
2965 if (promoted_arithmetic_type_p (type1
)
2966 && promoted_arithmetic_type_p (type2
))
2970 /* Otherwise, the types should be pointers. */
2971 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
2974 /* We don't check that the two types are the same; the logic
2975 below will actually create two candidates; one in which both
2976 parameter types are TYPE1, and one in which both parameter
2982 if (ARITHMETIC_TYPE_P (type1
))
2990 /* Make sure we don't create builtin candidates with dependent types. */
2991 bool u1
= uses_template_parms (type1
);
2992 bool u2
= type2
? uses_template_parms (type2
) : false;
2995 /* Try to recover if one of the types is non-dependent. But if
2996 there's only one type, there's nothing we can do. */
2999 /* And we lose if both are dependent. */
3002 /* Or if they have different forms. */
3003 if (TREE_CODE (type1
) != TREE_CODE (type2
))
3012 /* If we're dealing with two pointer types or two enumeral types,
3013 we need candidates for both of them. */
3014 if (type2
&& !same_type_p (type1
, type2
)
3015 && TREE_CODE (type1
) == TREE_CODE (type2
)
3016 && (TYPE_REF_P (type1
)
3017 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3018 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
3019 || TYPE_PTRMEMFUNC_P (type1
)
3020 || MAYBE_CLASS_TYPE_P (type1
)
3021 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
3023 if (TYPE_PTR_OR_PTRMEM_P (type1
))
3025 tree cptype
= composite_pointer_type (type1
, type2
,
3030 if (cptype
!= error_mark_node
)
3032 build_builtin_candidate
3033 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
3039 build_builtin_candidate
3040 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
3041 build_builtin_candidate
3042 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
3046 build_builtin_candidate
3047 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
3051 type_decays_to (tree type
)
3053 if (TREE_CODE (type
) == ARRAY_TYPE
)
3054 return build_pointer_type (TREE_TYPE (type
));
3055 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3056 return build_pointer_type (type
);
3060 /* There are three conditions of builtin candidates:
3062 1) bool-taking candidates. These are the same regardless of the input.
3063 2) pointer-pair taking candidates. These are generated for each type
3064 one of the input types converts to.
3065 3) arithmetic candidates. According to the standard, we should generate
3066 all of these, but I'm trying not to...
3068 Here we generate a superset of the possible candidates for this particular
3069 case. That is a subset of the full set the standard defines, plus some
3070 other cases which the standard disallows. add_builtin_candidate will
3071 filter out the invalid set. */
3074 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
3075 enum tree_code code2
, tree fnname
, tree
*args
,
3076 int flags
, tsubst_flags_t complain
)
3080 tree type
, argtypes
[3], t
;
3081 /* TYPES[i] is the set of possible builtin-operator parameter types
3082 we will consider for the Ith argument. */
3083 vec
<tree
, va_gc
> *types
[2];
3086 for (i
= 0; i
< 3; ++i
)
3089 argtypes
[i
] = unlowered_expr_type (args
[i
]);
3091 argtypes
[i
] = NULL_TREE
;
3096 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3097 and VQ is either volatile or empty, there exist candidate operator
3098 functions of the form
3099 VQ T& operator++(VQ T&); */
3101 case POSTINCREMENT_EXPR
:
3102 case PREINCREMENT_EXPR
:
3103 case POSTDECREMENT_EXPR
:
3104 case PREDECREMENT_EXPR
:
3109 /* 24There also exist candidate operator functions of the form
3110 bool operator!(bool);
3111 bool operator&&(bool, bool);
3112 bool operator||(bool, bool); */
3114 case TRUTH_NOT_EXPR
:
3115 build_builtin_candidate
3116 (candidates
, fnname
, boolean_type_node
,
3117 NULL_TREE
, args
, argtypes
, flags
, complain
);
3120 case TRUTH_ORIF_EXPR
:
3121 case TRUTH_ANDIF_EXPR
:
3122 build_builtin_candidate
3123 (candidates
, fnname
, boolean_type_node
,
3124 boolean_type_node
, args
, argtypes
, flags
, complain
);
3146 types
[0] = make_tree_vector ();
3147 types
[1] = make_tree_vector ();
3149 for (i
= 0; i
< 2; ++i
)
3153 else if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
3157 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
3160 convs
= lookup_conversions (argtypes
[i
]);
3162 if (code
== COND_EXPR
)
3164 if (lvalue_p (args
[i
]))
3165 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
3167 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
3173 for (; convs
; convs
= TREE_CHAIN (convs
))
3175 type
= TREE_TYPE (convs
);
3178 && (!TYPE_REF_P (type
)
3179 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
3182 if (code
== COND_EXPR
&& TYPE_REF_P (type
))
3183 vec_safe_push (types
[i
], type
);
3185 type
= non_reference (type
);
3186 if (i
!= 0 || ! ref1
)
3188 type
= cv_unqualified (type_decays_to (type
));
3189 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
3190 vec_safe_push (types
[i
], type
);
3191 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3192 type
= type_promotes_to (type
);
3195 if (! vec_member (type
, types
[i
]))
3196 vec_safe_push (types
[i
], type
);
3201 if (code
== COND_EXPR
&& lvalue_p (args
[i
]))
3202 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
3203 type
= non_reference (argtypes
[i
]);
3204 if (i
!= 0 || ! ref1
)
3206 type
= cv_unqualified (type_decays_to (type
));
3207 if (enum_p
&& UNSCOPED_ENUM_P (type
))
3208 vec_safe_push (types
[i
], type
);
3209 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3210 type
= type_promotes_to (type
);
3212 vec_safe_push (types
[i
], type
);
3216 /* Run through the possible parameter types of both arguments,
3217 creating candidates with those parameter types. */
3218 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
3223 if (!types
[1]->is_empty ())
3224 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
3225 add_builtin_candidate
3226 (candidates
, code
, code2
, fnname
, t
,
3227 u
, args
, argtypes
, flags
, complain
);
3229 add_builtin_candidate
3230 (candidates
, code
, code2
, fnname
, t
,
3231 NULL_TREE
, args
, argtypes
, flags
, complain
);
3234 release_tree_vector (types
[0]);
3235 release_tree_vector (types
[1]);
3239 /* If TMPL can be successfully instantiated as indicated by
3240 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
3242 TMPL is the template. EXPLICIT_TARGS are any explicit template
3243 arguments. ARGLIST is the arguments provided at the call-site.
3244 This does not change ARGLIST. The RETURN_TYPE is the desired type
3245 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
3246 as for add_function_candidate. If an OBJ is supplied, FLAGS and
3247 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
3249 static struct z_candidate
*
3250 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
3251 tree ctype
, tree explicit_targs
, tree first_arg
,
3252 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3253 tree access_path
, tree conversion_path
,
3254 int flags
, tree obj
, unification_kind_t strict
,
3255 tsubst_flags_t complain
)
3257 int ntparms
= DECL_NTPARMS (tmpl
);
3258 tree targs
= make_tree_vec (ntparms
);
3259 unsigned int len
= vec_safe_length (arglist
);
3260 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
3261 unsigned int skip_without_in_chrg
= 0;
3262 tree first_arg_without_in_chrg
= first_arg
;
3263 tree
*args_without_in_chrg
;
3264 unsigned int nargs_without_in_chrg
;
3265 unsigned int ia
, ix
;
3267 struct z_candidate
*cand
;
3269 struct rejection_reason
*reason
= NULL
;
3271 conversion
**convs
= NULL
;
3273 /* We don't do deduction on the in-charge parameter, the VTT
3274 parameter or 'this'. */
3275 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
3277 if (first_arg_without_in_chrg
!= NULL_TREE
)
3278 first_arg_without_in_chrg
= NULL_TREE
;
3279 else if (return_type
&& strict
== DEDUCE_CALL
)
3280 /* We're deducing for a call to the result of a template conversion
3281 function, so the args don't contain 'this'; leave them alone. */;
3283 ++skip_without_in_chrg
;
3286 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
3287 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
3288 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
3290 if (first_arg_without_in_chrg
!= NULL_TREE
)
3291 first_arg_without_in_chrg
= NULL_TREE
;
3293 ++skip_without_in_chrg
;
3296 if (len
< skip_without_in_chrg
)
3299 if (DECL_CONSTRUCTOR_P (tmpl
) && nargs
== 2
3300 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (first_arg
),
3301 TREE_TYPE ((*arglist
)[0])))
3303 /* 12.8/6 says, "A declaration of a constructor for a class X is
3304 ill-formed if its first parameter is of type (optionally cv-qualified)
3305 X and either there are no other parameters or else all other
3306 parameters have default arguments. A member function template is never
3307 instantiated to produce such a constructor signature."
3309 So if we're trying to copy an object of the containing class, don't
3310 consider a template constructor that has a first parameter type that
3311 is just a template parameter, as we would deduce a signature that we
3312 would then reject in the code below. */
3313 if (tree firstparm
= FUNCTION_FIRST_USER_PARMTYPE (tmpl
))
3315 firstparm
= TREE_VALUE (firstparm
);
3316 if (PACK_EXPANSION_P (firstparm
))
3317 firstparm
= PACK_EXPANSION_PATTERN (firstparm
);
3318 if (TREE_CODE (firstparm
) == TEMPLATE_TYPE_PARM
)
3320 gcc_assert (!explicit_targs
);
3321 reason
= invalid_copy_with_fn_template_rejection ();
3327 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
3328 + (len
- skip_without_in_chrg
));
3329 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
3331 if (first_arg_without_in_chrg
!= NULL_TREE
)
3333 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
3336 for (ix
= skip_without_in_chrg
;
3337 vec_safe_iterate (arglist
, ix
, &arg
);
3340 args_without_in_chrg
[ia
] = arg
;
3343 gcc_assert (ia
== nargs_without_in_chrg
);
3345 errs
= errorcount
+sorrycount
;
3347 convs
= alloc_conversions (nargs
);
3348 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
3349 args_without_in_chrg
,
3350 nargs_without_in_chrg
,
3351 return_type
, strict
, flags
, convs
,
3352 false, complain
& tf_decltype
);
3354 if (fn
== error_mark_node
)
3356 /* Don't repeat unification later if it already resulted in errors. */
3357 if (errorcount
+sorrycount
== errs
)
3358 reason
= template_unification_rejection (tmpl
, explicit_targs
,
3359 targs
, args_without_in_chrg
,
3360 nargs_without_in_chrg
,
3361 return_type
, strict
, flags
);
3363 reason
= template_unification_error_rejection ();
3367 /* Now the explicit specifier might have been deduced; check if this
3368 declaration is explicit. If it is and we're ignoring non-converting
3369 constructors, don't add this function to the set of candidates. */
3370 if ((flags
& LOOKUP_ONLYCONVERTING
) && DECL_NONCONVERTING_P (fn
))
3373 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
3375 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3376 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
3379 /* We're trying to produce a constructor with a prohibited signature,
3380 as discussed above; handle here any cases we didn't catch then,
3382 reason
= invalid_copy_with_fn_template_rejection ();
3387 if (obj
!= NULL_TREE
)
3388 /* Aha, this is a conversion function. */
3389 cand
= add_conv_candidate (candidates
, fn
, obj
, arglist
,
3390 access_path
, conversion_path
, complain
);
3392 cand
= add_function_candidate (candidates
, fn
, ctype
,
3393 first_arg
, arglist
, access_path
,
3394 conversion_path
, flags
, convs
, complain
);
3395 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
3396 /* This situation can occur if a member template of a template
3397 class is specialized. Then, instantiate_template might return
3398 an instantiation of the specialization, in which case the
3399 DECL_TI_TEMPLATE field will point at the original
3400 specialization. For example:
3402 template <class T> struct S { template <class U> void f(U);
3403 template <> void f(int) {}; };
3407 Here, TMPL will be template <class U> S<double>::f(U).
3408 And, instantiate template will give us the specialization
3409 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3410 for this will point at template <class T> template <> S<T>::f(int),
3411 so that we can find the definition. For the purposes of
3412 overload resolution, however, we want the original TMPL. */
3413 cand
->template_decl
= build_template_info (tmpl
, targs
);
3415 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3416 cand
->explicit_targs
= explicit_targs
;
3420 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, NULL
,
3421 access_path
, conversion_path
, 0, reason
, flags
);
3425 static struct z_candidate
*
3426 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3427 tree explicit_targs
, tree first_arg
,
3428 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3429 tree access_path
, tree conversion_path
, int flags
,
3430 unification_kind_t strict
, tsubst_flags_t complain
)
3433 add_template_candidate_real (candidates
, tmpl
, ctype
,
3434 explicit_targs
, first_arg
, arglist
,
3435 return_type
, access_path
, conversion_path
,
3436 flags
, NULL_TREE
, strict
, complain
);
3439 /* Create an overload candidate for the conversion function template TMPL,
3440 returning RETURN_TYPE, which will be invoked for expression OBJ to produce a
3441 pointer-to-function which will in turn be called with the argument list
3442 ARGLIST, and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
3443 passed on to implicit_conversion. */
3445 static struct z_candidate
*
3446 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3448 const vec
<tree
, va_gc
> *arglist
,
3449 tree return_type
, tree access_path
,
3450 tree conversion_path
, tsubst_flags_t complain
)
3452 /* Making this work broke PR 71117 and 85118, so until the committee resolves
3453 core issue 2189, let's disable this candidate if there are any call
3459 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3460 NULL_TREE
, arglist
, return_type
, access_path
,
3461 conversion_path
, 0, obj
, DEDUCE_CALL
,
3465 /* The CANDS are the set of candidates that were considered for
3466 overload resolution. Return the set of viable candidates, or CANDS
3467 if none are viable. If any of the candidates were viable, set
3468 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3469 considered viable only if it is strictly viable. */
3471 static struct z_candidate
*
3472 splice_viable (struct z_candidate
*cands
,
3476 struct z_candidate
*viable
;
3477 struct z_candidate
**last_viable
;
3478 struct z_candidate
**cand
;
3479 bool found_strictly_viable
= false;
3481 /* Be strict inside templates, since build_over_call won't actually
3482 do the conversions to get pedwarns. */
3483 if (processing_template_decl
)
3487 last_viable
= &viable
;
3488 *any_viable_p
= false;
3493 struct z_candidate
*c
= *cand
;
3495 && (c
->viable
== 1 || TREE_CODE (c
->fn
) == TEMPLATE_DECL
))
3497 /* Be strict in the presence of a viable candidate. Also if
3498 there are template candidates, so that we get deduction errors
3499 for them instead of silently preferring a bad conversion. */
3501 if (viable
&& !found_strictly_viable
)
3503 /* Put any spliced near matches back onto the main list so
3504 that we see them if there is no strict match. */
3505 *any_viable_p
= false;
3506 *last_viable
= cands
;
3509 last_viable
= &viable
;
3513 if (strict_p
? c
->viable
== 1 : c
->viable
)
3518 last_viable
= &c
->next
;
3519 *any_viable_p
= true;
3521 found_strictly_viable
= true;
3527 return viable
? viable
: cands
;
3531 any_strictly_viable (struct z_candidate
*cands
)
3533 for (; cands
; cands
= cands
->next
)
3534 if (cands
->viable
== 1)
3539 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3540 words, it is about to become the "this" pointer for a member
3541 function call. Take the address of the object. */
3544 build_this (tree obj
)
3546 /* In a template, we are only concerned about the type of the
3547 expression, so we can take a shortcut. */
3548 if (processing_template_decl
)
3549 return build_address (obj
);
3551 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3554 /* Returns true iff functions are equivalent. Equivalent functions are
3555 not '==' only if one is a function-local extern function or if
3556 both are extern "C". */
3559 equal_functions (tree fn1
, tree fn2
)
3561 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3563 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3565 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
3566 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3567 return decls_match (fn1
, fn2
);
3571 /* Print information about a candidate FN being rejected due to INFO. */
3574 print_conversion_rejection (location_t loc
, struct conversion_info
*info
,
3577 tree from
= info
->from
;
3579 from
= lvalue_type (from
);
3580 if (info
->n_arg
== -1)
3582 /* Conversion of implicit `this' argument failed. */
3583 if (!TYPE_P (info
->from
))
3584 /* A bad conversion for 'this' must be discarding cv-quals. */
3585 inform (loc
, " passing %qT as %<this%> "
3586 "argument discards qualifiers",
3589 inform (loc
, " no known conversion for implicit "
3590 "%<this%> parameter from %qH to %qI",
3591 from
, info
->to_type
);
3593 else if (!TYPE_P (info
->from
))
3595 if (info
->n_arg
>= 0)
3596 inform (loc
, " conversion of argument %d would be ill-formed:",
3598 perform_implicit_conversion (info
->to_type
, info
->from
,
3599 tf_warning_or_error
);
3601 else if (info
->n_arg
== -2)
3602 /* Conversion of conversion function return value failed. */
3603 inform (loc
, " no known conversion from %qH to %qI",
3604 from
, info
->to_type
);
3607 if (TREE_CODE (fn
) == FUNCTION_DECL
)
3608 loc
= get_fndecl_argument_location (fn
, info
->n_arg
);
3609 inform (loc
, " no known conversion for argument %d from %qH to %qI",
3610 info
->n_arg
+ 1, from
, info
->to_type
);
3614 /* Print information about a candidate with WANT parameters and we found
3618 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
)
3620 inform_n (loc
, want
,
3621 " candidate expects %d argument, %d provided",
3622 " candidate expects %d arguments, %d provided",
3626 /* Print information about one overload candidate CANDIDATE. MSGSTR
3627 is the text to print before the candidate itself.
3629 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3630 to have been run through gettext by the caller. This wart makes
3631 life simpler in print_z_candidates and for the translators. */
3634 print_z_candidate (location_t loc
, const char *msgstr
,
3635 struct z_candidate
*candidate
)
3637 const char *msg
= (msgstr
== NULL
3639 : ACONCAT ((_(msgstr
), " ", NULL
)));
3640 tree fn
= candidate
->fn
;
3641 if (flag_new_inheriting_ctors
)
3642 fn
= strip_inheriting_ctors (fn
);
3643 location_t cloc
= location_of (fn
);
3645 if (identifier_p (fn
))
3648 if (candidate
->num_convs
== 3)
3649 inform (cloc
, "%s%<%D(%T, %T, %T)%> (built-in)", msg
, fn
,
3650 candidate
->convs
[0]->type
,
3651 candidate
->convs
[1]->type
,
3652 candidate
->convs
[2]->type
);
3653 else if (candidate
->num_convs
== 2)
3654 inform (cloc
, "%s%<%D(%T, %T)%> (built-in)", msg
, fn
,
3655 candidate
->convs
[0]->type
,
3656 candidate
->convs
[1]->type
);
3658 inform (cloc
, "%s%<%D(%T)%> (built-in)", msg
, fn
,
3659 candidate
->convs
[0]->type
);
3661 else if (TYPE_P (fn
))
3662 inform (cloc
, "%s%qT (conversion)", msg
, fn
);
3663 else if (candidate
->viable
== -1)
3664 inform (cloc
, "%s%#qD (near match)", msg
, fn
);
3665 else if (DECL_DELETED_FN (fn
))
3666 inform (cloc
, "%s%#qD (deleted)", msg
, fn
);
3668 inform (cloc
, "%s%#qD", msg
, fn
);
3669 if (fn
!= candidate
->fn
)
3671 cloc
= location_of (candidate
->fn
);
3672 inform (cloc
, " inherited here");
3674 /* Give the user some information about why this candidate failed. */
3675 if (candidate
->reason
!= NULL
)
3677 struct rejection_reason
*r
= candidate
->reason
;
3682 print_arity_information (cloc
, r
->u
.arity
.actual
,
3683 r
->u
.arity
.expected
);
3685 case rr_arg_conversion
:
3686 print_conversion_rejection (cloc
, &r
->u
.conversion
, fn
);
3688 case rr_bad_arg_conversion
:
3689 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
, fn
);
3691 case rr_explicit_conversion
:
3692 inform (cloc
, " return type %qT of explicit conversion function "
3693 "cannot be converted to %qT with a qualification "
3694 "conversion", r
->u
.conversion
.from
,
3695 r
->u
.conversion
.to_type
);
3697 case rr_template_conversion
:
3698 inform (cloc
, " conversion from return type %qT of template "
3699 "conversion function specialization to %qT is not an "
3700 "exact match", r
->u
.conversion
.from
,
3701 r
->u
.conversion
.to_type
);
3703 case rr_template_unification
:
3704 /* We use template_unification_error_rejection if unification caused
3705 actual non-SFINAE errors, in which case we don't need to repeat
3707 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
3709 inform (cloc
, " substitution of deduced template arguments "
3710 "resulted in errors seen above");
3713 /* Re-run template unification with diagnostics. */
3714 inform (cloc
, " template argument deduction/substitution failed:");
3715 fn_type_unification (r
->u
.template_unification
.tmpl
,
3716 r
->u
.template_unification
.explicit_targs
,
3718 (r
->u
.template_unification
.num_targs
)),
3719 r
->u
.template_unification
.args
,
3720 r
->u
.template_unification
.nargs
,
3721 r
->u
.template_unification
.return_type
,
3722 r
->u
.template_unification
.strict
,
3723 r
->u
.template_unification
.flags
,
3726 case rr_invalid_copy
:
3728 " a constructor taking a single argument of its own "
3729 "class type is invalid");
3731 case rr_constraint_failure
:
3733 tree tmpl
= r
->u
.template_instantiation
.tmpl
;
3734 tree args
= r
->u
.template_instantiation
.targs
;
3735 diagnose_constraints (cloc
, tmpl
, args
);
3738 case rr_inherited_ctor
:
3739 inform (cloc
, " an inherited constructor is not a candidate for "
3740 "initialization from an expression of the same or derived "
3745 /* This candidate didn't have any issues or we failed to
3746 handle a particular code. Either way... */
3753 print_z_candidates (location_t loc
, struct z_candidate
*candidates
)
3755 struct z_candidate
*cand1
;
3756 struct z_candidate
**cand2
;
3761 /* Remove non-viable deleted candidates. */
3763 for (cand2
= &cand1
; *cand2
; )
3765 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
3766 && !(*cand2
)->viable
3767 && DECL_DELETED_FN ((*cand2
)->fn
))
3768 *cand2
= (*cand2
)->next
;
3770 cand2
= &(*cand2
)->next
;
3772 /* ...if there are any non-deleted ones. */
3776 /* There may be duplicates in the set of candidates. We put off
3777 checking this condition as long as possible, since we have no way
3778 to eliminate duplicates from a set of functions in less than n^2
3779 time. Now we are about to emit an error message, so it is more
3780 permissible to go slowly. */
3781 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3783 tree fn
= cand1
->fn
;
3784 /* Skip builtin candidates and conversion functions. */
3787 cand2
= &cand1
->next
;
3790 if (DECL_P ((*cand2
)->fn
)
3791 && equal_functions (fn
, (*cand2
)->fn
))
3792 *cand2
= (*cand2
)->next
;
3794 cand2
= &(*cand2
)->next
;
3798 for (; candidates
; candidates
= candidates
->next
)
3799 print_z_candidate (loc
, N_("candidate:"), candidates
);
3802 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3803 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3804 the result of the conversion function to convert it to the final
3805 desired type. Merge the two sequences into a single sequence,
3806 and return the merged sequence. */
3809 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
3812 bool bad
= user_seq
->bad_p
;
3814 gcc_assert (user_seq
->kind
== ck_user
);
3816 /* Find the end of the second conversion sequence. */
3817 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
3819 /* The entire sequence is a user-conversion sequence. */
3820 (*t
)->user_conv_p
= true;
3825 if ((*t
)->rvaluedness_matches_p
)
3826 /* We're binding a reference directly to the result of the conversion.
3827 build_user_type_conversion_1 stripped the REFERENCE_TYPE from the return
3828 type, but we want it back. */
3829 user_seq
->type
= TREE_TYPE (TREE_TYPE (user_seq
->cand
->fn
));
3831 /* Replace the identity conversion with the user conversion
3838 /* Handle overload resolution for initializing an object of class type from
3839 an initializer list. First we look for a suitable constructor that
3840 takes a std::initializer_list; if we don't find one, we then look for a
3841 non-list constructor.
3843 Parameters are as for add_candidates, except that the arguments are in
3844 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3845 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3848 add_list_candidates (tree fns
, tree first_arg
,
3849 const vec
<tree
, va_gc
> *args
, tree totype
,
3850 tree explicit_targs
, bool template_only
,
3851 tree conversion_path
, tree access_path
,
3853 struct z_candidate
**candidates
,
3854 tsubst_flags_t complain
)
3856 gcc_assert (*candidates
== NULL
);
3858 /* We're looking for a ctor for list-initialization. */
3859 flags
|= LOOKUP_LIST_INIT_CTOR
;
3860 /* And we don't allow narrowing conversions. We also use this flag to
3861 avoid the copy constructor call for copy-list-initialization. */
3862 flags
|= LOOKUP_NO_NARROWING
;
3864 unsigned nart
= num_artificial_parms_for (OVL_FIRST (fns
)) - 1;
3865 tree init_list
= (*args
)[nart
];
3867 /* Always use the default constructor if the list is empty (DR 990). */
3868 if (CONSTRUCTOR_NELTS (init_list
) == 0
3869 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
3871 /* If the class has a list ctor, try passing the list as a single
3872 argument first, but only consider list ctors. */
3873 else if (TYPE_HAS_LIST_CTOR (totype
))
3875 flags
|= LOOKUP_LIST_ONLY
;
3876 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3877 explicit_targs
, template_only
, conversion_path
,
3878 access_path
, flags
, candidates
, complain
);
3879 if (any_strictly_viable (*candidates
))
3883 /* Expand the CONSTRUCTOR into a new argument vec. */
3884 vec
<tree
, va_gc
> *new_args
;
3885 vec_alloc (new_args
, nart
+ CONSTRUCTOR_NELTS (init_list
));
3886 for (unsigned i
= 0; i
< nart
; ++i
)
3887 new_args
->quick_push ((*args
)[i
]);
3888 for (unsigned i
= 0; i
< CONSTRUCTOR_NELTS (init_list
); ++i
)
3889 new_args
->quick_push (CONSTRUCTOR_ELT (init_list
, i
)->value
);
3891 /* We aren't looking for list-ctors anymore. */
3892 flags
&= ~LOOKUP_LIST_ONLY
;
3893 /* We allow more user-defined conversions within an init-list. */
3894 flags
&= ~LOOKUP_NO_CONVERSION
;
3896 add_candidates (fns
, first_arg
, new_args
, NULL_TREE
,
3897 explicit_targs
, template_only
, conversion_path
,
3898 access_path
, flags
, candidates
, complain
);
3901 /* Returns the best overload candidate to perform the requested
3902 conversion. This function is used for three the overloading situations
3903 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3904 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3905 per [dcl.init.ref], so we ignore temporary bindings. */
3907 static struct z_candidate
*
3908 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
3909 tsubst_flags_t complain
)
3911 struct z_candidate
*candidates
, *cand
;
3913 tree ctors
= NULL_TREE
;
3914 tree conv_fns
= NULL_TREE
;
3915 conversion
*conv
= NULL
;
3916 tree first_arg
= NULL_TREE
;
3917 vec
<tree
, va_gc
> *args
= NULL
;
3924 fromtype
= TREE_TYPE (expr
);
3926 /* We represent conversion within a hierarchy using RVALUE_CONV and
3927 BASE_CONV, as specified by [over.best.ics]; these become plain
3928 constructor calls, as specified in [dcl.init]. */
3929 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
3930 || !DERIVED_FROM_P (totype
, fromtype
));
3932 if (CLASS_TYPE_P (totype
))
3933 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3934 creating a garbage BASELINK; constructors can't be inherited. */
3935 ctors
= get_class_binding (totype
, complete_ctor_identifier
);
3937 if (MAYBE_CLASS_TYPE_P (fromtype
))
3939 tree to_nonref
= non_reference (totype
);
3940 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
3941 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
3942 && DERIVED_FROM_P (to_nonref
, fromtype
)))
3944 /* [class.conv.fct] A conversion function is never used to
3945 convert a (possibly cv-qualified) object to the (possibly
3946 cv-qualified) same object type (or a reference to it), to a
3947 (possibly cv-qualified) base class of that type (or a
3948 reference to it)... */
3951 conv_fns
= lookup_conversions (fromtype
);
3955 flags
|= LOOKUP_NO_CONVERSION
;
3956 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3957 flags
|= LOOKUP_NO_NARROWING
;
3959 /* It's OK to bind a temporary for converting constructor arguments, but
3960 not in converting the return value of a conversion operator. */
3961 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
3962 | (flags
& LOOKUP_NO_NARROWING
));
3963 flags
&= ~LOOKUP_NO_TEMP_BIND
;
3967 int ctorflags
= flags
;
3969 first_arg
= build_dummy_object (totype
);
3971 /* We should never try to call the abstract or base constructor
3973 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_FIRST (ctors
))
3974 && !DECL_HAS_VTT_PARM_P (OVL_FIRST (ctors
)));
3976 args
= make_tree_vector_single (expr
);
3977 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3979 /* List-initialization. */
3980 add_list_candidates (ctors
, first_arg
, args
, totype
, NULL_TREE
,
3981 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3982 ctorflags
, &candidates
, complain
);
3986 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
3987 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3988 ctorflags
, &candidates
, complain
);
3991 for (cand
= candidates
; cand
; cand
= cand
->next
)
3993 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
3995 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3996 set, then this is copy-initialization. In that case, "The
3997 result of the call is then used to direct-initialize the
3998 object that is the destination of the copy-initialization."
4001 We represent this in the conversion sequence with an
4002 rvalue conversion, which means a constructor call. */
4003 if (!TYPE_REF_P (totype
)
4004 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
4006 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
4012 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
4013 first_arg
= CONSTRUCTOR_ELT (expr
, 0)->value
;
4018 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
4020 tree conversion_path
= TREE_PURPOSE (conv_fns
);
4021 struct z_candidate
*old_candidates
;
4023 /* If we are called to convert to a reference type, we are trying to
4024 find a direct binding, so don't even consider temporaries. If
4025 we don't find a direct binding, the caller will try again to
4026 look for a temporary binding. */
4027 if (TYPE_REF_P (totype
))
4028 convflags
|= LOOKUP_NO_TEMP_BIND
;
4030 old_candidates
= candidates
;
4031 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
4033 conversion_path
, TYPE_BINFO (fromtype
),
4034 flags
, &candidates
, complain
);
4036 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
4038 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
4040 = implicit_conversion (totype
,
4043 /*c_cast_p=*/false, convflags
,
4046 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
4047 copy-initialization. In that case, "The result of the
4048 call is then used to direct-initialize the object that is
4049 the destination of the copy-initialization." [dcl.init]
4051 We represent this in the conversion sequence with an
4052 rvalue conversion, which means a constructor call. But
4053 don't add a second rvalue conversion if there's already
4054 one there. Which there really shouldn't be, but it's
4055 harmless since we'd add it here anyway. */
4056 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
4057 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
4058 ics
= build_conv (ck_rvalue
, totype
, ics
);
4060 cand
->second_conv
= ics
;
4065 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -2,
4067 EXPR_LOCATION (expr
));
4069 else if (TYPE_REF_P (totype
) && !ics
->rvaluedness_matches_p
4070 && TREE_CODE (TREE_TYPE (totype
)) != FUNCTION_TYPE
)
4072 /* If we are called to convert to a reference type, we are trying
4073 to find a direct binding per [over.match.ref], so rvaluedness
4074 must match for non-functions. */
4077 else if (DECL_NONCONVERTING_P (cand
->fn
)
4078 && ics
->rank
> cr_exact
)
4080 /* 13.3.1.5: For direct-initialization, those explicit
4081 conversion functions that are not hidden within S and
4082 yield type T or a type that can be converted to type T
4083 with a qualification conversion (4.4) are also candidate
4085 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
4086 I've raised this issue with the committee. --jason 9/2011 */
4088 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
4090 else if (cand
->viable
== 1 && ics
->bad_p
)
4094 = bad_arg_conversion_rejection (NULL_TREE
, -2,
4096 EXPR_LOCATION (expr
));
4098 else if (primary_template_specialization_p (cand
->fn
)
4099 && ics
->rank
> cr_exact
)
4101 /* 13.3.3.1.2: If the user-defined conversion is specified by
4102 a specialization of a conversion function template, the
4103 second standard conversion sequence shall have exact match
4106 cand
->reason
= template_conversion_rejection (rettype
, totype
);
4111 candidates
= splice_viable (candidates
, false, &any_viable_p
);
4115 release_tree_vector (args
);
4119 cand
= tourney (candidates
, complain
);
4122 if (complain
& tf_error
)
4124 auto_diagnostic_group d
;
4125 error ("conversion from %qH to %qI is ambiguous",
4127 print_z_candidates (location_of (expr
), candidates
);
4130 cand
= candidates
; /* any one will do */
4131 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
4132 cand
->second_conv
->user_conv_p
= true;
4133 if (!any_strictly_viable (candidates
))
4134 cand
->second_conv
->bad_p
= true;
4135 if (flags
& LOOKUP_ONLYCONVERTING
)
4136 cand
->second_conv
->need_temporary_p
= true;
4137 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
4138 ambiguous conversion is no worse than another user-defined
4145 if (!DECL_CONSTRUCTOR_P (cand
->fn
))
4146 convtype
= non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)));
4147 else if (cand
->second_conv
->kind
== ck_rvalue
)
4148 /* DR 5: [in the first step of copy-initialization]...if the function
4149 is a constructor, the call initializes a temporary of the
4150 cv-unqualified version of the destination type. */
4151 convtype
= cv_unqualified (totype
);
4154 /* Build the user conversion sequence. */
4158 build_identity_conv (TREE_TYPE (expr
), expr
));
4160 if (cand
->viable
== -1)
4163 /* We're performing the maybe-rvalue overload resolution and
4164 a conversion function is in play. Reject converting the return
4165 value of the conversion function to a base class. */
4166 if ((flags
& LOOKUP_PREFER_RVALUE
) && !DECL_CONSTRUCTOR_P (cand
->fn
))
4167 for (conversion
*t
= cand
->second_conv
; t
; t
= next_conversion (t
))
4168 if (t
->kind
== ck_base
)
4171 /* Remember that this was a list-initialization. */
4172 if (flags
& LOOKUP_NO_NARROWING
)
4173 conv
->check_narrowing
= true;
4175 /* Combine it with the second conversion sequence. */
4176 cand
->second_conv
= merge_conversion_sequences (conv
,
4182 /* Wrapper for above. */
4185 build_user_type_conversion (tree totype
, tree expr
, int flags
,
4186 tsubst_flags_t complain
)
4188 struct z_candidate
*cand
;
4191 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4192 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
4196 if (cand
->second_conv
->kind
== ck_ambig
)
4197 ret
= error_mark_node
;
4200 expr
= convert_like (cand
->second_conv
, expr
, complain
);
4201 ret
= convert_from_reference (expr
);
4207 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4211 /* Worker for build_converted_constant_expr. */
4214 build_converted_constant_expr_internal (tree type
, tree expr
,
4215 int flags
, tsubst_flags_t complain
)
4220 location_t loc
= cp_expr_loc_or_input_loc (expr
);
4222 if (error_operand_p (expr
))
4223 return error_mark_node
;
4225 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4226 p
= conversion_obstack_alloc (0);
4228 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
4229 /*c_cast_p=*/false, flags
, complain
);
4231 /* A converted constant expression of type T is an expression, implicitly
4232 converted to type T, where the converted expression is a constant
4233 expression and the implicit conversion sequence contains only
4235 * user-defined conversions,
4236 * lvalue-to-rvalue conversions (7.1),
4237 * array-to-pointer conversions (7.2),
4238 * function-to-pointer conversions (7.3),
4239 * qualification conversions (7.5),
4240 * integral promotions (7.6),
4241 * integral conversions (7.8) other than narrowing conversions (11.6.4),
4242 * null pointer conversions (7.11) from std::nullptr_t,
4243 * null member pointer conversions (7.12) from std::nullptr_t, and
4244 * function pointer conversions (7.13),
4246 and where the reference binding (if any) binds directly. */
4248 for (conversion
*c
= conv
;
4249 conv
&& c
->kind
!= ck_identity
;
4250 c
= next_conversion (c
))
4254 /* A conversion function is OK. If it isn't constexpr, we'll
4255 complain later that the argument isn't constant. */
4257 /* The lvalue-to-rvalue conversion is OK. */
4259 /* Array-to-pointer and function-to-pointer. */
4261 /* Function pointer conversions. */
4263 /* Qualification conversions. */
4268 if (c
->need_temporary_p
)
4270 if (complain
& tf_error
)
4271 error_at (loc
, "initializing %qH with %qI in converted "
4272 "constant expression does not bind directly",
4273 type
, next_conversion (c
)->type
);
4282 t
= next_conversion (c
)->type
;
4283 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
)
4284 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
4285 /* Integral promotion or conversion. */
4287 if (NULLPTR_TYPE_P (t
))
4288 /* Conversion from nullptr to pointer or pointer-to-member. */
4291 if (complain
& tf_error
)
4292 error_at (loc
, "conversion from %qH to %qI in a "
4293 "converted constant expression", t
, type
);
4302 /* Avoid confusing convert_nontype_argument by introducing
4303 a redundant conversion to the same reference type. */
4304 if (conv
&& conv
->kind
== ck_ref_bind
4305 && REFERENCE_REF_P (expr
))
4307 tree ref
= TREE_OPERAND (expr
, 0);
4308 if (same_type_p (type
, TREE_TYPE (ref
)))
4314 /* Don't copy a class in a template. */
4315 if (CLASS_TYPE_P (type
) && conv
->kind
== ck_rvalue
4316 && processing_template_decl
)
4317 conv
= next_conversion (conv
);
4319 conv
->check_narrowing
= true;
4320 conv
->check_narrowing_const_only
= true;
4321 expr
= convert_like (conv
, expr
, complain
);
4325 if (complain
& tf_error
)
4326 error_at (loc
, "could not convert %qE from %qH to %qI", expr
,
4327 TREE_TYPE (expr
), type
);
4328 expr
= error_mark_node
;
4331 /* Free all the conversions we allocated. */
4332 obstack_free (&conversion_obstack
, p
);
4337 /* Subroutine of convert_nontype_argument.
4339 EXPR is an expression used in a context that requires a converted
4340 constant-expression, such as a template non-type parameter. Do any
4341 necessary conversions (that are permitted for converted
4342 constant-expressions) to convert it to the desired type.
4344 This function doesn't consider explicit conversion functions. If
4345 you mean to use "a contextually converted constant expression of type
4346 bool", use build_converted_constant_bool_expr.
4348 If conversion is successful, returns the converted expression;
4349 otherwise, returns error_mark_node. */
4352 build_converted_constant_expr (tree type
, tree expr
, tsubst_flags_t complain
)
4354 return build_converted_constant_expr_internal (type
, expr
, LOOKUP_IMPLICIT
,
4358 /* Used to create "a contextually converted constant expression of type
4359 bool". This differs from build_converted_constant_expr in that it
4360 also considers explicit conversion functions. */
4363 build_converted_constant_bool_expr (tree expr
, tsubst_flags_t complain
)
4365 return build_converted_constant_expr_internal (boolean_type_node
, expr
,
4366 LOOKUP_NORMAL
, complain
);
4369 /* Do any initial processing on the arguments to a function call. */
4371 static vec
<tree
, va_gc
> *
4372 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
4377 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
4379 if (error_operand_p (arg
))
4381 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
4383 if (complain
& tf_error
)
4384 error_at (cp_expr_loc_or_input_loc (arg
),
4385 "invalid use of void expression");
4388 else if (invalid_nonstatic_memfn_p (EXPR_LOCATION (arg
), arg
, complain
))
4394 /* Perform overload resolution on FN, which is called with the ARGS.
4396 Return the candidate function selected by overload resolution, or
4397 NULL if the event that overload resolution failed. In the case
4398 that overload resolution fails, *CANDIDATES will be the set of
4399 candidates considered, and ANY_VIABLE_P will be set to true or
4400 false to indicate whether or not any of the candidates were
4403 The ARGS should already have gone through RESOLVE_ARGS before this
4404 function is called. */
4406 static struct z_candidate
*
4407 perform_overload_resolution (tree fn
,
4408 const vec
<tree
, va_gc
> *args
,
4409 struct z_candidate
**candidates
,
4410 bool *any_viable_p
, tsubst_flags_t complain
)
4412 struct z_candidate
*cand
;
4413 tree explicit_targs
;
4416 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4418 explicit_targs
= NULL_TREE
;
4422 *any_viable_p
= true;
4425 gcc_assert (OVL_P (fn
) || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
4427 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4429 explicit_targs
= TREE_OPERAND (fn
, 1);
4430 fn
= TREE_OPERAND (fn
, 0);
4434 /* Add the various candidate functions. */
4435 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
4436 explicit_targs
, template_only
,
4437 /*conversion_path=*/NULL_TREE
,
4438 /*access_path=*/NULL_TREE
,
4440 candidates
, complain
);
4442 *candidates
= splice_viable (*candidates
, false, any_viable_p
);
4444 cand
= tourney (*candidates
, complain
);
4448 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4452 /* Print an error message about being unable to build a call to FN with
4453 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
4454 be located; CANDIDATES is a possibly empty list of such
4458 print_error_for_call_failure (tree fn
, vec
<tree
, va_gc
> *args
,
4459 struct z_candidate
*candidates
)
4461 tree targs
= NULL_TREE
;
4462 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4464 targs
= TREE_OPERAND (fn
, 1);
4465 fn
= TREE_OPERAND (fn
, 0);
4467 tree name
= OVL_NAME (fn
);
4468 location_t loc
= location_of (name
);
4470 name
= lookup_template_function (name
, targs
);
4472 auto_diagnostic_group d
;
4473 if (!any_strictly_viable (candidates
))
4474 error_at (loc
, "no matching function for call to %<%D(%A)%>",
4475 name
, build_tree_list_vec (args
));
4477 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
4478 name
, build_tree_list_vec (args
));
4480 print_z_candidates (loc
, candidates
);
4483 /* Return an expression for a call to FN (a namespace-scope function,
4484 or a static member function) with the ARGS. This may change
4488 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
,
4489 tsubst_flags_t complain
)
4491 struct z_candidate
*candidates
, *cand
;
4496 if (args
!= NULL
&& *args
!= NULL
)
4498 *args
= resolve_args (*args
, complain
);
4500 return error_mark_node
;
4504 tm_malloc_replacement (fn
);
4506 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4507 p
= conversion_obstack_alloc (0);
4509 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
4514 if (complain
& tf_error
)
4516 // If there is a single (non-viable) function candidate,
4517 // let the error be diagnosed by cp_build_function_call_vec.
4518 if (!any_viable_p
&& candidates
&& ! candidates
->next
4519 && (TREE_CODE (candidates
->fn
) == FUNCTION_DECL
))
4520 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
4522 // Otherwise, emit notes for non-viable candidates.
4523 print_error_for_call_failure (fn
, *args
, candidates
);
4525 result
= error_mark_node
;
4529 int flags
= LOOKUP_NORMAL
;
4530 /* If fn is template_id_expr, the call has explicit template arguments
4531 (e.g. func<int>(5)), communicate this info to build_over_call
4532 through flags so that later we can use it to decide whether to warn
4533 about peculiar null pointer conversion. */
4534 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4536 /* If overload resolution selects a specialization of a
4537 function concept for non-dependent template arguments,
4538 the expression is true if the constraints are satisfied
4539 and false otherwise.
4541 NOTE: This is an extension of Concepts Lite TS that
4542 allows constraints to be used in expressions. */
4543 if (flag_concepts
&& !processing_template_decl
)
4545 tree tmpl
= DECL_TI_TEMPLATE (cand
->fn
);
4546 tree targs
= DECL_TI_ARGS (cand
->fn
);
4547 tree decl
= DECL_TEMPLATE_RESULT (tmpl
);
4548 if (DECL_DECLARED_CONCEPT_P (decl
))
4549 return evaluate_function_concept (decl
, targs
);
4552 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
4555 result
= build_over_call (cand
, flags
, complain
);
4558 /* Free all the conversions we allocated. */
4559 obstack_free (&conversion_obstack
, p
);
4564 /* Build a call to a global operator new. FNNAME is the name of the
4565 operator (either "operator new" or "operator new[]") and ARGS are
4566 the arguments provided. This may change ARGS. *SIZE points to the
4567 total number of bytes required by the allocation, and is updated if
4568 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
4569 be used. If this function determines that no cookie should be
4570 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
4571 is not NULL_TREE, it is evaluated before calculating the final
4572 array size, and if it fails, the array size is replaced with
4573 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
4574 is non-NULL, it will be set, upon return, to the allocation
4578 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
4579 tree
*size
, tree
*cookie_size
,
4580 tree align_arg
, tree size_check
,
4581 tree
*fn
, tsubst_flags_t complain
)
4583 tree original_size
= *size
;
4585 struct z_candidate
*candidates
;
4586 struct z_candidate
*cand
= NULL
;
4591 /* Set to (size_t)-1 if the size check fails. */
4592 if (size_check
!= NULL_TREE
)
4594 tree errval
= TYPE_MAX_VALUE (sizetype
);
4595 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
4596 errval
= throw_bad_array_new_length ();
4597 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4598 original_size
, errval
);
4600 vec_safe_insert (*args
, 0, *size
);
4601 *args
= resolve_args (*args
, complain
);
4603 return error_mark_node
;
4609 If this lookup fails to find the name, or if the allocated type
4610 is not a class type, the allocation function's name is looked
4611 up in the global scope.
4613 we disregard block-scope declarations of "operator new". */
4614 fns
= lookup_name_real (fnname
, 0, 1, /*block_p=*/false, 0, 0);
4615 fns
= lookup_arg_dependent (fnname
, fns
, *args
);
4619 vec
<tree
, va_gc
>* align_args
4620 = vec_copy_and_insert (*args
, align_arg
, 1);
4621 cand
= perform_overload_resolution (fns
, align_args
, &candidates
,
4622 &any_viable_p
, tf_none
);
4625 /* If no aligned allocation function matches, try again without the
4629 /* Figure out what function is being called. */
4631 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
4634 /* If no suitable function could be found, issue an error message
4638 if (complain
& tf_error
)
4639 print_error_for_call_failure (fns
, *args
, candidates
);
4640 return error_mark_node
;
4643 /* If a cookie is required, add some extra space. Whether
4644 or not a cookie is required cannot be determined until
4645 after we know which function was called. */
4648 bool use_cookie
= true;
4651 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
4652 /* Skip the size_t parameter. */
4653 arg_types
= TREE_CHAIN (arg_types
);
4654 /* Check the remaining parameters (if any). */
4656 && TREE_CHAIN (arg_types
) == void_list_node
4657 && same_type_p (TREE_VALUE (arg_types
),
4660 /* If we need a cookie, adjust the number of bytes allocated. */
4663 /* Update the total size. */
4664 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
4667 /* Set to (size_t)-1 if the size check fails. */
4668 gcc_assert (size_check
!= NULL_TREE
);
4669 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4670 *size
, TYPE_MAX_VALUE (sizetype
));
4672 /* Update the argument list to reflect the adjusted size. */
4673 (**args
)[0] = *size
;
4676 *cookie_size
= NULL_TREE
;
4679 /* Tell our caller which function we decided to call. */
4683 /* Build the CALL_EXPR. */
4684 return build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4687 /* Build a new call to operator(). This may change ARGS. */
4690 build_op_call_1 (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4692 struct z_candidate
*candidates
= 0, *cand
;
4693 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
4695 tree result
= NULL_TREE
;
4698 obj
= mark_lvalue_use (obj
);
4700 if (error_operand_p (obj
))
4701 return error_mark_node
;
4703 tree type
= TREE_TYPE (obj
);
4705 obj
= prep_operand (obj
);
4707 if (TYPE_PTRMEMFUNC_P (type
))
4709 if (complain
& tf_error
)
4710 /* It's no good looking for an overloaded operator() on a
4711 pointer-to-member-function. */
4712 error ("pointer-to-member function %qE cannot be called without "
4713 "an object; consider using %<.*%> or %<->*%>", obj
);
4714 return error_mark_node
;
4717 if (TYPE_BINFO (type
))
4719 fns
= lookup_fnfields (TYPE_BINFO (type
), call_op_identifier
, 1);
4720 if (fns
== error_mark_node
)
4721 return error_mark_node
;
4726 if (args
!= NULL
&& *args
!= NULL
)
4728 *args
= resolve_args (*args
, complain
);
4730 return error_mark_node
;
4733 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4734 p
= conversion_obstack_alloc (0);
4738 first_mem_arg
= obj
;
4740 add_candidates (BASELINK_FUNCTIONS (fns
),
4741 first_mem_arg
, *args
, NULL_TREE
,
4743 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
4744 LOOKUP_NORMAL
, &candidates
, complain
);
4747 convs
= lookup_conversions (type
);
4749 for (; convs
; convs
= TREE_CHAIN (convs
))
4751 tree totype
= TREE_TYPE (convs
);
4753 if (TYPE_PTRFN_P (totype
)
4754 || TYPE_REFFN_P (totype
)
4755 || (TYPE_REF_P (totype
)
4756 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
4757 for (ovl_iterator
iter (TREE_VALUE (convs
)); iter
; ++iter
)
4761 if (DECL_NONCONVERTING_P (fn
))
4764 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4765 add_template_conv_candidate
4766 (&candidates
, fn
, obj
, *args
, totype
,
4767 /*access_path=*/NULL_TREE
,
4768 /*conversion_path=*/NULL_TREE
, complain
);
4770 add_conv_candidate (&candidates
, fn
, obj
,
4771 *args
, /*conversion_path=*/NULL_TREE
,
4772 /*access_path=*/NULL_TREE
, complain
);
4776 /* Be strict here because if we choose a bad conversion candidate, the
4777 errors we get won't mention the call context. */
4778 candidates
= splice_viable (candidates
, true, &any_viable_p
);
4781 if (complain
& tf_error
)
4783 auto_diagnostic_group d
;
4784 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
4785 build_tree_list_vec (*args
));
4786 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4788 result
= error_mark_node
;
4792 cand
= tourney (candidates
, complain
);
4795 if (complain
& tf_error
)
4797 auto_diagnostic_group d
;
4798 error ("call of %<(%T) (%A)%> is ambiguous",
4799 TREE_TYPE (obj
), build_tree_list_vec (*args
));
4800 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4802 result
= error_mark_node
;
4804 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
4805 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
)
4806 && DECL_OVERLOADED_OPERATOR_IS (cand
->fn
, CALL_EXPR
))
4807 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4810 if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
4811 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
,
4815 gcc_checking_assert (TYPE_P (cand
->fn
));
4816 obj
= convert_like (cand
->convs
[0], obj
, complain
);
4818 obj
= convert_from_reference (obj
);
4819 result
= cp_build_function_call_vec (obj
, args
, complain
);
4823 /* Free all the conversions we allocated. */
4824 obstack_free (&conversion_obstack
, p
);
4829 /* Wrapper for above. */
4832 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4835 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4836 ret
= build_op_call_1 (obj
, args
, complain
);
4837 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4841 /* Called by op_error to prepare format strings suitable for the error
4842 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4843 and a suffix (controlled by NTYPES). */
4846 op_error_string (const char *errmsg
, int ntypes
, bool match
)
4850 const char *msgp
= concat (match
? G_("ambiguous overload for ")
4851 : G_("no match for "), errmsg
, NULL
);
4854 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
4855 else if (ntypes
== 2)
4856 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
4858 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
4864 op_error (const op_location_t
&loc
,
4865 enum tree_code code
, enum tree_code code2
,
4866 tree arg1
, tree arg2
, tree arg3
, bool match
)
4868 bool assop
= code
== MODIFY_EXPR
;
4869 const char *opname
= OVL_OP_INFO (assop
, assop
? code2
: code
)->name
;
4874 if (flag_diagnostics_show_caret
)
4875 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
4877 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4879 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
4880 "in %<%E ? %E : %E%>"), 3, match
),
4882 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4885 case POSTINCREMENT_EXPR
:
4886 case POSTDECREMENT_EXPR
:
4887 if (flag_diagnostics_show_caret
)
4888 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4889 opname
, TREE_TYPE (arg1
));
4891 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4893 opname
, arg1
, opname
, TREE_TYPE (arg1
));
4897 if (flag_diagnostics_show_caret
)
4898 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
4899 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4901 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4903 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4908 if (flag_diagnostics_show_caret
)
4909 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
4910 opname
, TREE_TYPE (arg1
));
4912 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
4913 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4918 if (flag_diagnostics_show_caret
)
4920 binary_op_rich_location
richloc (loc
, arg1
, arg2
, true);
4922 op_error_string (G_("%<operator%s%>"), 2, match
),
4923 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4926 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4928 opname
, arg1
, opname
, arg2
,
4929 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4931 if (flag_diagnostics_show_caret
)
4932 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4933 opname
, TREE_TYPE (arg1
));
4935 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4937 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4942 /* Return the implicit conversion sequence that could be used to
4943 convert E1 to E2 in [expr.cond]. */
4946 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
4948 tree t1
= non_reference (TREE_TYPE (e1
));
4949 tree t2
= non_reference (TREE_TYPE (e2
));
4955 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4956 implicitly converted (clause _conv_) to the type "lvalue reference to
4957 T2", subject to the constraint that in the conversion the
4958 reference must bind directly (_dcl.init.ref_) to an lvalue.
4960 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
4961 implicitly converted to the type "rvalue reference to T2", subject to
4962 the constraint that the reference must bind directly. */
4965 tree rtype
= cp_build_reference_type (t2
, !lvalue_p (e2
));
4966 conv
= implicit_conversion (rtype
,
4970 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
4971 |LOOKUP_ONLYCONVERTING
,
4973 if (conv
&& !conv
->bad_p
)
4977 /* If E2 is a prvalue or if neither of the conversions above can be done
4978 and at least one of the operands has (possibly cv-qualified) class
4980 if (!CLASS_TYPE_P (t1
) && !CLASS_TYPE_P (t2
))
4985 If E1 and E2 have class type, and the underlying class types are
4986 the same or one is a base class of the other: E1 can be converted
4987 to match E2 if the class of T2 is the same type as, or a base
4988 class of, the class of T1, and the cv-qualification of T2 is the
4989 same cv-qualification as, or a greater cv-qualification than, the
4990 cv-qualification of T1. If the conversion is applied, E1 is
4991 changed to an rvalue of type T2 that still refers to the original
4992 source class object (or the appropriate subobject thereof). */
4993 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
4994 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
4996 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
4998 conv
= build_identity_conv (t1
, e1
);
4999 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
5000 TYPE_MAIN_VARIANT (t2
)))
5001 conv
= build_conv (ck_base
, t2
, conv
);
5003 conv
= build_conv (ck_rvalue
, t2
, conv
);
5012 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
5013 converted to the type that expression E2 would have if E2 were
5014 converted to an rvalue (or the type it has, if E2 is an rvalue). */
5015 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
5016 LOOKUP_IMPLICIT
, complain
);
5019 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
5020 arguments to the conditional expression. */
5023 build_conditional_expr_1 (const op_location_t
&loc
,
5024 tree arg1
, tree arg2
, tree arg3
,
5025 tsubst_flags_t complain
)
5029 tree result
= NULL_TREE
;
5030 tree result_type
= NULL_TREE
;
5031 bool is_glvalue
= true;
5032 struct z_candidate
*candidates
= 0;
5033 struct z_candidate
*cand
;
5035 tree orig_arg2
, orig_arg3
;
5037 /* As a G++ extension, the second argument to the conditional can be
5038 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
5039 c'.) If the second operand is omitted, make sure it is
5040 calculated only once. */
5043 if (complain
& tf_error
)
5044 pedwarn (loc
, OPT_Wpedantic
,
5045 "ISO C++ forbids omitting the middle term of "
5046 "a %<?:%> expression");
5048 if ((complain
& tf_warning
) && !truth_value_p (TREE_CODE (arg1
)))
5049 warn_for_omitted_condop (loc
, arg1
);
5051 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
5052 if (lvalue_p (arg1
))
5053 arg2
= arg1
= cp_stabilize_reference (arg1
);
5055 arg2
= arg1
= cp_save_expr (arg1
);
5058 /* If something has already gone wrong, just pass that fact up the
5060 if (error_operand_p (arg1
)
5061 || error_operand_p (arg2
)
5062 || error_operand_p (arg3
))
5063 return error_mark_node
;
5068 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
5070 tree arg1_type
= TREE_TYPE (arg1
);
5072 /* If arg1 is another cond_expr choosing between -1 and 0,
5073 then we can use its comparison. It may help to avoid
5074 additional comparison, produce more accurate diagnostics
5075 and enables folding. */
5076 if (TREE_CODE (arg1
) == VEC_COND_EXPR
5077 && integer_minus_onep (TREE_OPERAND (arg1
, 1))
5078 && integer_zerop (TREE_OPERAND (arg1
, 2)))
5079 arg1
= TREE_OPERAND (arg1
, 0);
5081 arg1
= force_rvalue (arg1
, complain
);
5082 arg2
= force_rvalue (arg2
, complain
);
5083 arg3
= force_rvalue (arg3
, complain
);
5085 /* force_rvalue can return error_mark on valid arguments. */
5086 if (error_operand_p (arg1
)
5087 || error_operand_p (arg2
)
5088 || error_operand_p (arg3
))
5089 return error_mark_node
;
5091 arg2_type
= TREE_TYPE (arg2
);
5092 arg3_type
= TREE_TYPE (arg3
);
5094 if (!VECTOR_TYPE_P (arg2_type
)
5095 && !VECTOR_TYPE_P (arg3_type
))
5097 /* Rely on the error messages of the scalar version. */
5098 tree scal
= build_conditional_expr_1 (loc
, integer_one_node
,
5099 orig_arg2
, orig_arg3
, complain
);
5100 if (scal
== error_mark_node
)
5101 return error_mark_node
;
5102 tree stype
= TREE_TYPE (scal
);
5103 tree ctype
= TREE_TYPE (arg1_type
);
5104 if (TYPE_SIZE (stype
) != TYPE_SIZE (ctype
)
5105 || (!INTEGRAL_TYPE_P (stype
) && !SCALAR_FLOAT_TYPE_P (stype
)))
5107 if (complain
& tf_error
)
5108 error_at (loc
, "inferred scalar type %qT is not an integer or "
5109 "floating-point type of the same size as %qT", stype
,
5110 COMPARISON_CLASS_P (arg1
)
5111 ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
5113 return error_mark_node
;
5116 tree vtype
= build_opaque_vector_type (stype
,
5117 TYPE_VECTOR_SUBPARTS (arg1_type
));
5118 /* We could pass complain & tf_warning to unsafe_conversion_p,
5119 but the warnings (like Wsign-conversion) have already been
5120 given by the scalar build_conditional_expr_1. We still check
5121 unsafe_conversion_p to forbid truncating long long -> float. */
5122 if (unsafe_conversion_p (loc
, stype
, arg2
, NULL_TREE
, false))
5124 if (complain
& tf_error
)
5125 error_at (loc
, "conversion of scalar %qH to vector %qI "
5126 "involves truncation", arg2_type
, vtype
);
5127 return error_mark_node
;
5129 if (unsafe_conversion_p (loc
, stype
, arg3
, NULL_TREE
, false))
5131 if (complain
& tf_error
)
5132 error_at (loc
, "conversion of scalar %qH to vector %qI "
5133 "involves truncation", arg3_type
, vtype
);
5134 return error_mark_node
;
5137 arg2
= cp_convert (stype
, arg2
, complain
);
5138 arg2
= save_expr (arg2
);
5139 arg2
= build_vector_from_val (vtype
, arg2
);
5141 arg3
= cp_convert (stype
, arg3
, complain
);
5142 arg3
= save_expr (arg3
);
5143 arg3
= build_vector_from_val (vtype
, arg3
);
5147 if (VECTOR_TYPE_P (arg2_type
) != VECTOR_TYPE_P (arg3_type
))
5149 enum stv_conv convert_flag
=
5150 scalar_to_vector (loc
, VEC_COND_EXPR
, arg2
, arg3
,
5151 complain
& tf_error
);
5153 switch (convert_flag
)
5156 return error_mark_node
;
5159 arg2
= save_expr (arg2
);
5160 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
5161 arg2
= build_vector_from_val (arg3_type
, arg2
);
5162 arg2_type
= TREE_TYPE (arg2
);
5167 arg3
= save_expr (arg3
);
5168 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
5169 arg3
= build_vector_from_val (arg2_type
, arg3
);
5170 arg3_type
= TREE_TYPE (arg3
);
5178 if (!same_type_p (arg2_type
, arg3_type
)
5179 || maybe_ne (TYPE_VECTOR_SUBPARTS (arg1_type
),
5180 TYPE_VECTOR_SUBPARTS (arg2_type
))
5181 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
5183 if (complain
& tf_error
)
5185 "incompatible vector types in conditional expression: "
5186 "%qT, %qT and %qT", TREE_TYPE (arg1
),
5187 TREE_TYPE (orig_arg2
), TREE_TYPE (orig_arg3
));
5188 return error_mark_node
;
5191 if (!COMPARISON_CLASS_P (arg1
))
5193 tree cmp_type
= build_same_sized_truth_vector_type (arg1_type
);
5194 arg1
= build2 (NE_EXPR
, cmp_type
, arg1
, build_zero_cst (arg1_type
));
5196 return build3_loc (loc
, VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
5201 The first expression is implicitly converted to bool (clause
5203 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
5205 if (error_operand_p (arg1
))
5206 return error_mark_node
;
5210 If either the second or the third operand has type (possibly
5211 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
5212 array-to-pointer (_conv.array_), and function-to-pointer
5213 (_conv.func_) standard conversions are performed on the second
5214 and third operands. */
5215 arg2_type
= unlowered_expr_type (arg2
);
5216 arg3_type
= unlowered_expr_type (arg3
);
5217 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
5219 /* 'void' won't help in resolving an overloaded expression on the
5220 other side, so require it to resolve by itself. */
5221 if (arg2_type
== unknown_type_node
)
5223 arg2
= resolve_nondeduced_context_or_error (arg2
, complain
);
5224 arg2_type
= TREE_TYPE (arg2
);
5226 if (arg3_type
== unknown_type_node
)
5228 arg3
= resolve_nondeduced_context_or_error (arg3
, complain
);
5229 arg3_type
= TREE_TYPE (arg3
);
5234 One of the following shall hold:
5236 --The second or the third operand (but not both) is a
5237 throw-expression (_except.throw_); the result is of the type
5238 and value category of the other.
5240 --Both the second and the third operands have type void; the
5241 result is of type void and is a prvalue. */
5242 if (TREE_CODE (arg2
) == THROW_EXPR
5243 && TREE_CODE (arg3
) != THROW_EXPR
)
5245 result_type
= arg3_type
;
5246 is_glvalue
= glvalue_p (arg3
);
5248 else if (TREE_CODE (arg2
) != THROW_EXPR
5249 && TREE_CODE (arg3
) == THROW_EXPR
)
5251 result_type
= arg2_type
;
5252 is_glvalue
= glvalue_p (arg2
);
5254 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
5256 result_type
= void_type_node
;
5261 if (complain
& tf_error
)
5263 if (VOID_TYPE_P (arg2_type
))
5264 error_at (cp_expr_loc_or_loc (arg3
, loc
),
5265 "second operand to the conditional operator "
5266 "is of type %<void%>, but the third operand is "
5267 "neither a throw-expression nor of type %<void%>");
5269 error_at (cp_expr_loc_or_loc (arg2
, loc
),
5270 "third operand to the conditional operator "
5271 "is of type %<void%>, but the second operand is "
5272 "neither a throw-expression nor of type %<void%>");
5274 return error_mark_node
;
5277 goto valid_operands
;
5281 Otherwise, if the second and third operand have different types,
5282 and either has (possibly cv-qualified) class type, or if both are
5283 glvalues of the same value category and the same type except for
5284 cv-qualification, an attempt is made to convert each of those operands
5285 to the type of the other. */
5286 else if (!same_type_p (arg2_type
, arg3_type
)
5287 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)
5288 || (same_type_ignoring_top_level_qualifiers_p (arg2_type
,
5290 && glvalue_p (arg2
) && glvalue_p (arg3
)
5291 && lvalue_p (arg2
) == lvalue_p (arg3
))))
5295 bool converted
= false;
5297 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5298 p
= conversion_obstack_alloc (0);
5300 conv2
= conditional_conversion (arg2
, arg3
, complain
);
5301 conv3
= conditional_conversion (arg3
, arg2
, complain
);
5305 If both can be converted, or one can be converted but the
5306 conversion is ambiguous, the program is ill-formed. If
5307 neither can be converted, the operands are left unchanged and
5308 further checking is performed as described below. If exactly
5309 one conversion is possible, that conversion is applied to the
5310 chosen operand and the converted operand is used in place of
5311 the original operand for the remainder of this section. */
5312 if ((conv2
&& !conv2
->bad_p
5313 && conv3
&& !conv3
->bad_p
)
5314 || (conv2
&& conv2
->kind
== ck_ambig
)
5315 || (conv3
&& conv3
->kind
== ck_ambig
))
5317 if (complain
& tf_error
)
5319 error_at (loc
, "operands to %<?:%> have different types "
5321 arg2_type
, arg3_type
);
5322 if (conv2
&& !conv2
->bad_p
&& conv3
&& !conv3
->bad_p
)
5323 inform (loc
, " and each type can be converted to the other");
5324 else if (conv2
&& conv2
->kind
== ck_ambig
)
5325 convert_like (conv2
, arg2
, complain
);
5327 convert_like (conv3
, arg3
, complain
);
5329 result
= error_mark_node
;
5331 else if (conv2
&& !conv2
->bad_p
)
5333 arg2
= convert_like (conv2
, arg2
, complain
);
5334 arg2
= convert_from_reference (arg2
);
5335 arg2_type
= TREE_TYPE (arg2
);
5336 /* Even if CONV2 is a valid conversion, the result of the
5337 conversion may be invalid. For example, if ARG3 has type
5338 "volatile X", and X does not have a copy constructor
5339 accepting a "volatile X&", then even if ARG2 can be
5340 converted to X, the conversion will fail. */
5341 if (error_operand_p (arg2
))
5342 result
= error_mark_node
;
5345 else if (conv3
&& !conv3
->bad_p
)
5347 arg3
= convert_like (conv3
, arg3
, complain
);
5348 arg3
= convert_from_reference (arg3
);
5349 arg3_type
= TREE_TYPE (arg3
);
5350 if (error_operand_p (arg3
))
5351 result
= error_mark_node
;
5355 /* Free all the conversions we allocated. */
5356 obstack_free (&conversion_obstack
, p
);
5361 /* If, after the conversion, both operands have class type,
5362 treat the cv-qualification of both operands as if it were the
5363 union of the cv-qualification of the operands.
5365 The standard is not clear about what to do in this
5366 circumstance. For example, if the first operand has type
5367 "const X" and the second operand has a user-defined
5368 conversion to "volatile X", what is the type of the second
5369 operand after this step? Making it be "const X" (matching
5370 the first operand) seems wrong, as that discards the
5371 qualification without actually performing a copy. Leaving it
5372 as "volatile X" seems wrong as that will result in the
5373 conditional expression failing altogether, even though,
5374 according to this step, the one operand could be converted to
5375 the type of the other. */
5377 && CLASS_TYPE_P (arg2_type
)
5378 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
5379 arg2_type
= arg3_type
=
5380 cp_build_qualified_type (arg2_type
,
5381 cp_type_quals (arg2_type
)
5382 | cp_type_quals (arg3_type
));
5387 If the second and third operands are glvalues of the same value
5388 category and have the same type, the result is of that type and
5390 if (((lvalue_p (arg2
) && lvalue_p (arg3
))
5391 || (xvalue_p (arg2
) && xvalue_p (arg3
)))
5392 && same_type_p (arg2_type
, arg3_type
))
5394 result_type
= arg2_type
;
5395 arg2
= mark_lvalue_use (arg2
);
5396 arg3
= mark_lvalue_use (arg3
);
5397 goto valid_operands
;
5402 Otherwise, the result is an rvalue. If the second and third
5403 operand do not have the same type, and either has (possibly
5404 cv-qualified) class type, overload resolution is used to
5405 determine the conversions (if any) to be applied to the operands
5406 (_over.match.oper_, _over.built_). */
5408 if (!same_type_p (arg2_type
, arg3_type
)
5409 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
5415 /* Rearrange the arguments so that add_builtin_candidate only has
5416 to know about two args. In build_builtin_candidate, the
5417 arguments are unscrambled. */
5421 add_builtin_candidates (&candidates
,
5424 ovl_op_identifier (false, COND_EXPR
),
5426 LOOKUP_NORMAL
, complain
);
5430 If the overload resolution fails, the program is
5432 candidates
= splice_viable (candidates
, false, &any_viable_p
);
5435 if (complain
& tf_error
)
5436 error_at (loc
, "operands to %<?:%> have different types %qT and %qT",
5437 arg2_type
, arg3_type
);
5438 return error_mark_node
;
5440 cand
= tourney (candidates
, complain
);
5443 if (complain
& tf_error
)
5445 auto_diagnostic_group d
;
5446 op_error (loc
, COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, FALSE
);
5447 print_z_candidates (loc
, candidates
);
5449 return error_mark_node
;
5454 Otherwise, the conversions thus determined are applied, and
5455 the converted operands are used in place of the original
5456 operands for the remainder of this section. */
5457 conv
= cand
->convs
[0];
5458 arg1
= convert_like (conv
, arg1
, complain
);
5459 conv
= cand
->convs
[1];
5460 arg2
= convert_like (conv
, arg2
, complain
);
5461 arg2_type
= TREE_TYPE (arg2
);
5462 conv
= cand
->convs
[2];
5463 arg3
= convert_like (conv
, arg3
, complain
);
5464 arg3_type
= TREE_TYPE (arg3
);
5469 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
5470 and function-to-pointer (_conv.func_) standard conversions are
5471 performed on the second and third operands.
5473 We need to force the lvalue-to-rvalue conversion here for class types,
5474 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
5475 that isn't wrapped with a TARGET_EXPR plays havoc with exception
5478 arg2
= force_rvalue (arg2
, complain
);
5479 if (!CLASS_TYPE_P (arg2_type
))
5480 arg2_type
= TREE_TYPE (arg2
);
5482 arg3
= force_rvalue (arg3
, complain
);
5483 if (!CLASS_TYPE_P (arg3_type
))
5484 arg3_type
= TREE_TYPE (arg3
);
5486 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5487 return error_mark_node
;
5491 After those conversions, one of the following shall hold:
5493 --The second and third operands have the same type; the result is of
5495 if (same_type_p (arg2_type
, arg3_type
))
5496 result_type
= arg2_type
;
5499 --The second and third operands have arithmetic or enumeration
5500 type; the usual arithmetic conversions are performed to bring
5501 them to a common type, and the result is of that type. */
5502 else if ((ARITHMETIC_TYPE_P (arg2_type
)
5503 || UNSCOPED_ENUM_P (arg2_type
))
5504 && (ARITHMETIC_TYPE_P (arg3_type
)
5505 || UNSCOPED_ENUM_P (arg3_type
)))
5507 /* In this case, there is always a common type. */
5508 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
5510 if (complain
& tf_warning
)
5511 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
5512 "implicit conversion from %qH to %qI to "
5513 "match other result of conditional",
5516 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5517 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
5519 tree stripped_orig_arg2
= tree_strip_any_location_wrapper (orig_arg2
);
5520 tree stripped_orig_arg3
= tree_strip_any_location_wrapper (orig_arg3
);
5521 if (TREE_CODE (stripped_orig_arg2
) == CONST_DECL
5522 && TREE_CODE (stripped_orig_arg3
) == CONST_DECL
5523 && (DECL_CONTEXT (stripped_orig_arg2
)
5524 == DECL_CONTEXT (stripped_orig_arg3
)))
5525 /* Two enumerators from the same enumeration can have different
5526 types when the enumeration is still being defined. */;
5527 else if (complain
& tf_warning
)
5528 warning_at (loc
, OPT_Wenum_compare
, "enumerated mismatch "
5529 "in conditional expression: %qT vs %qT",
5530 arg2_type
, arg3_type
);
5532 else if (extra_warnings
5533 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5534 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
5535 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
5536 && !same_type_p (arg2_type
,
5537 type_promotes_to (arg3_type
)))))
5539 if (complain
& tf_warning
)
5540 warning_at (loc
, OPT_Wextra
, "enumerated and non-enumerated "
5541 "type in conditional expression");
5544 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5545 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5549 --The second and third operands have pointer type, or one has
5550 pointer type and the other is a null pointer constant; pointer
5551 conversions (_conv.ptr_) and qualification conversions
5552 (_conv.qual_) are performed to bring them to their composite
5553 pointer type (_expr.rel_). The result is of the composite
5556 --The second and third operands have pointer to member type, or
5557 one has pointer to member type and the other is a null pointer
5558 constant; pointer to member conversions (_conv.mem_) and
5559 qualification conversions (_conv.qual_) are performed to bring
5560 them to a common type, whose cv-qualification shall match the
5561 cv-qualification of either the second or the third operand.
5562 The result is of the common type. */
5563 else if ((null_ptr_cst_p (arg2
)
5564 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
5565 || (null_ptr_cst_p (arg3
)
5566 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
5567 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
5568 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
5569 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
5571 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
5572 arg3
, CPO_CONDITIONAL_EXPR
,
5574 if (result_type
== error_mark_node
)
5575 return error_mark_node
;
5576 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5577 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5582 if (complain
& tf_error
)
5583 error_at (loc
, "operands to %<?:%> have different types %qT and %qT",
5584 arg2_type
, arg3_type
);
5585 return error_mark_node
;
5588 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5589 return error_mark_node
;
5592 if (processing_template_decl
&& is_glvalue
)
5594 /* Let lvalue_kind know this was a glvalue. */
5595 tree arg
= (result_type
== arg2_type
? arg2
: arg3
);
5596 result_type
= cp_build_reference_type (result_type
, xvalue_p (arg
));
5599 result
= build3_loc (loc
, COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
5601 /* If the ARG2 and ARG3 are the same and don't have side-effects,
5602 warn here, because the COND_EXPR will be turned into ARG2. */
5603 if (warn_duplicated_branches
5604 && (complain
& tf_warning
)
5605 && (arg2
== arg3
|| operand_equal_p (arg2
, arg3
, 0)))
5606 warning_at (EXPR_LOCATION (result
), OPT_Wduplicated_branches
,
5607 "this condition has identical branches");
5609 /* We can't use result_type below, as fold might have returned a
5614 /* Expand both sides into the same slot, hopefully the target of
5615 the ?: expression. We used to check for TARGET_EXPRs here,
5616 but now we sometimes wrap them in NOP_EXPRs so the test would
5618 if (CLASS_TYPE_P (TREE_TYPE (result
)))
5619 result
= get_target_expr_sfinae (result
, complain
);
5620 /* If this expression is an rvalue, but might be mistaken for an
5621 lvalue, we must add a NON_LVALUE_EXPR. */
5622 result
= rvalue (result
);
5625 result
= force_paren_expr (result
);
5630 /* Wrapper for above. */
5633 build_conditional_expr (const op_location_t
&loc
,
5634 tree arg1
, tree arg2
, tree arg3
,
5635 tsubst_flags_t complain
)
5638 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5639 ret
= build_conditional_expr_1 (loc
, arg1
, arg2
, arg3
, complain
);
5640 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5644 /* OPERAND is an operand to an expression. Perform necessary steps
5645 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
5649 prep_operand (tree operand
)
5653 if (CLASS_TYPE_P (TREE_TYPE (operand
))
5654 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
5655 /* Make sure the template type is instantiated now. */
5656 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
5662 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
5663 OVERLOAD) to the CANDIDATES, returning an updated list of
5664 CANDIDATES. The ARGS are the arguments provided to the call;
5665 if FIRST_ARG is non-null it is the implicit object argument,
5666 otherwise the first element of ARGS is used if needed. The
5667 EXPLICIT_TARGS are explicit template arguments provided.
5668 TEMPLATE_ONLY is true if only template functions should be
5669 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
5670 add_function_candidate. */
5673 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
5675 tree explicit_targs
, bool template_only
,
5676 tree conversion_path
, tree access_path
,
5678 struct z_candidate
**candidates
,
5679 tsubst_flags_t complain
)
5682 const vec
<tree
, va_gc
> *non_static_args
;
5683 bool check_list_ctor
= false;
5684 bool check_converting
= false;
5685 unification_kind_t strict
;
5690 /* Precalculate special handling of constructors and conversion ops. */
5691 tree fn
= OVL_FIRST (fns
);
5692 if (DECL_CONV_FN_P (fn
))
5694 check_list_ctor
= false;
5695 check_converting
= (flags
& LOOKUP_ONLYCONVERTING
) != 0;
5696 if (flags
& LOOKUP_NO_CONVERSION
)
5697 /* We're doing return_type(x). */
5698 strict
= DEDUCE_CONV
;
5700 /* We're doing x.operator return_type(). */
5701 strict
= DEDUCE_EXACT
;
5702 /* [over.match.funcs] For conversion functions, the function
5703 is considered to be a member of the class of the implicit
5704 object argument for the purpose of defining the type of
5705 the implicit object parameter. */
5706 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
5710 if (DECL_CONSTRUCTOR_P (fn
))
5712 check_list_ctor
= (flags
& LOOKUP_LIST_ONLY
) != 0;
5713 /* For list-initialization we consider explicit constructors
5714 and complain if one is chosen. */
5716 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
5717 == LOOKUP_ONLYCONVERTING
);
5719 strict
= DEDUCE_CALL
;
5720 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
5724 non_static_args
= args
;
5726 /* Delay creating the implicit this parameter until it is needed. */
5727 non_static_args
= NULL
;
5729 for (lkp_iterator
iter (fns
); iter
; ++iter
)
5733 if (check_converting
&& DECL_NONCONVERTING_P (fn
))
5735 if (check_list_ctor
&& !is_list_ctor (fn
))
5738 tree fn_first_arg
= NULL_TREE
;
5739 const vec
<tree
, va_gc
> *fn_args
= args
;
5741 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
5743 /* Figure out where the object arg comes from. If this
5744 function is a non-static member and we didn't get an
5745 implicit object argument, move it out of args. */
5746 if (first_arg
== NULL_TREE
)
5750 vec
<tree
, va_gc
> *tempvec
;
5751 vec_alloc (tempvec
, args
->length () - 1);
5752 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
5753 tempvec
->quick_push (arg
);
5754 non_static_args
= tempvec
;
5755 first_arg
= (*args
)[0];
5758 fn_first_arg
= first_arg
;
5759 fn_args
= non_static_args
;
5762 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5763 add_template_candidate (candidates
,
5775 else if (!template_only
)
5776 add_function_candidate (candidates
,
5789 /* Returns 1 if P0145R2 says that the LHS of operator CODE is evaluated first,
5790 -1 if the RHS is evaluated first, or 0 if the order is unspecified. */
5793 op_is_ordered (tree_code code
)
5799 return (flag_strong_eval_order
> 1 ? -1 : 0);
5803 return (flag_strong_eval_order
> 1 ? 1 : 0);
5806 // Not overloadable (yet).
5808 // Only one argument.
5815 return (flag_strong_eval_order
? 1 : 0);
5823 build_new_op_1 (const op_location_t
&loc
, enum tree_code code
, int flags
,
5824 tree arg1
, tree arg2
, tree arg3
, tree
*overload
,
5825 tsubst_flags_t complain
)
5827 struct z_candidate
*candidates
= 0, *cand
;
5828 vec
<tree
, va_gc
> *arglist
;
5830 tree result
= NULL_TREE
;
5831 bool result_valid_p
= false;
5832 enum tree_code code2
= NOP_EXPR
;
5833 enum tree_code code_orig_arg1
= ERROR_MARK
;
5834 enum tree_code code_orig_arg2
= ERROR_MARK
;
5840 if (error_operand_p (arg1
)
5841 || error_operand_p (arg2
)
5842 || error_operand_p (arg3
))
5843 return error_mark_node
;
5845 bool ismodop
= code
== MODIFY_EXPR
;
5848 code2
= TREE_CODE (arg3
);
5851 tree fnname
= ovl_op_identifier (ismodop
, ismodop
? code2
: code
);
5853 tree arg1_type
= unlowered_expr_type (arg1
);
5854 tree arg2_type
= arg2
? unlowered_expr_type (arg2
) : NULL_TREE
;
5856 arg1
= prep_operand (arg1
);
5858 bool memonly
= false;
5863 case VEC_DELETE_EXPR
:
5865 /* Use build_op_new_call and build_op_delete_call instead. */
5869 /* Use build_op_call instead. */
5872 case TRUTH_ORIF_EXPR
:
5873 case TRUTH_ANDIF_EXPR
:
5874 case TRUTH_AND_EXPR
:
5876 /* These are saved for the sake of warn_logical_operator. */
5877 code_orig_arg1
= TREE_CODE (arg1
);
5878 code_orig_arg2
= TREE_CODE (arg2
);
5886 /* These are saved for the sake of maybe_warn_bool_compare. */
5887 code_orig_arg1
= TREE_CODE (arg1_type
);
5888 code_orig_arg2
= TREE_CODE (arg2_type
);
5891 /* =, ->, [], () must be non-static member functions. */
5893 if (code2
!= NOP_EXPR
)
5905 arg2
= prep_operand (arg2
);
5906 arg3
= prep_operand (arg3
);
5908 if (code
== COND_EXPR
)
5909 /* Use build_conditional_expr instead. */
5911 else if (! OVERLOAD_TYPE_P (arg1_type
)
5912 && (! arg2
|| ! OVERLOAD_TYPE_P (arg2_type
)))
5915 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5917 arg2
= integer_zero_node
;
5918 arg2_type
= integer_type_node
;
5921 vec_alloc (arglist
, 3);
5922 arglist
->quick_push (arg1
);
5923 if (arg2
!= NULL_TREE
)
5924 arglist
->quick_push (arg2
);
5925 if (arg3
!= NULL_TREE
)
5926 arglist
->quick_push (arg3
);
5928 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5929 p
= conversion_obstack_alloc (0);
5931 /* Add namespace-scope operators to the list of functions to
5935 tree fns
= lookup_name_real (fnname
, 0, 1, /*block_p=*/true, 0, 0);
5936 fns
= lookup_arg_dependent (fnname
, fns
, arglist
);
5937 add_candidates (fns
, NULL_TREE
, arglist
, NULL_TREE
,
5938 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5939 flags
, &candidates
, complain
);
5944 args
[2] = NULL_TREE
;
5946 /* Add class-member operators to the candidate set. */
5947 if (CLASS_TYPE_P (arg1_type
))
5951 fns
= lookup_fnfields (arg1_type
, fnname
, 1);
5952 if (fns
== error_mark_node
)
5954 result
= error_mark_node
;
5955 goto user_defined_result_ready
;
5958 add_candidates (BASELINK_FUNCTIONS (fns
),
5959 NULL_TREE
, arglist
, NULL_TREE
,
5961 BASELINK_BINFO (fns
),
5962 BASELINK_ACCESS_BINFO (fns
),
5963 flags
, &candidates
, complain
);
5965 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5966 only non-member functions that have type T1 or reference to
5967 cv-qualified-opt T1 for the first argument, if the first argument
5968 has an enumeration type, or T2 or reference to cv-qualified-opt
5969 T2 for the second argument, if the second argument has an
5970 enumeration type. Filter out those that don't match. */
5971 else if (! arg2
|| ! CLASS_TYPE_P (arg2_type
))
5973 struct z_candidate
**candp
, **next
;
5975 for (candp
= &candidates
; *candp
; candp
= next
)
5977 tree parmlist
, parmtype
;
5978 int i
, nargs
= (arg2
? 2 : 1);
5983 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5985 for (i
= 0; i
< nargs
; ++i
)
5987 parmtype
= TREE_VALUE (parmlist
);
5989 if (TYPE_REF_P (parmtype
))
5990 parmtype
= TREE_TYPE (parmtype
);
5991 if (TREE_CODE (unlowered_expr_type (args
[i
])) == ENUMERAL_TYPE
5992 && (same_type_ignoring_top_level_qualifiers_p
5993 (unlowered_expr_type (args
[i
]), parmtype
)))
5996 parmlist
= TREE_CHAIN (parmlist
);
5999 /* No argument has an appropriate type, so remove this
6000 candidate function from the list. */
6003 *candp
= cand
->next
;
6009 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
6016 /* For these, the built-in candidates set is empty
6017 [over.match.oper]/3. We don't want non-strict matches
6018 because exact matches are always possible with built-in
6019 operators. The built-in candidate set for COMPONENT_REF
6020 would be empty too, but since there are no such built-in
6021 operators, we accept non-strict matches for them. */
6030 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
6035 case POSTINCREMENT_EXPR
:
6036 case POSTDECREMENT_EXPR
:
6037 /* Don't try anything fancy if we're not allowed to produce
6039 if (!(complain
& tf_error
))
6040 return error_mark_node
;
6042 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
6043 distinguish between prefix and postfix ++ and
6044 operator++() was used for both, so we allow this with
6048 const char *msg
= (flag_permissive
)
6049 ? G_("no %<%D(int)%> declared for postfix %qs,"
6050 " trying prefix operator instead")
6051 : G_("no %<%D(int)%> declared for postfix %qs");
6052 permerror (loc
, msg
, fnname
, OVL_OP_INFO (false, code
)->name
);
6055 if (!flag_permissive
)
6056 return error_mark_node
;
6058 if (code
== POSTINCREMENT_EXPR
)
6059 code
= PREINCREMENT_EXPR
;
6061 code
= PREDECREMENT_EXPR
;
6062 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
6063 NULL_TREE
, overload
, complain
);
6066 /* The caller will deal with these. */
6071 result_valid_p
= true;
6075 if (complain
& tf_error
)
6077 /* If one of the arguments of the operator represents
6078 an invalid use of member function pointer, try to report
6079 a meaningful error ... */
6080 if (invalid_nonstatic_memfn_p (loc
, arg1
, tf_error
)
6081 || invalid_nonstatic_memfn_p (loc
, arg2
, tf_error
)
6082 || invalid_nonstatic_memfn_p (loc
, arg3
, tf_error
))
6083 /* We displayed the error message. */;
6086 /* ... Otherwise, report the more generic
6087 "no matching operator found" error */
6088 auto_diagnostic_group d
;
6089 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
6090 print_z_candidates (loc
, candidates
);
6093 result
= error_mark_node
;
6099 cand
= tourney (candidates
, complain
);
6102 if (complain
& tf_error
)
6104 auto_diagnostic_group d
;
6105 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
6106 print_z_candidates (loc
, candidates
);
6108 result
= error_mark_node
;
6110 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
6113 *overload
= cand
->fn
;
6115 if (resolve_args (arglist
, complain
) == NULL
)
6116 result
= error_mark_node
;
6118 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
6120 if (trivial_fn_p (cand
->fn
))
6121 /* There won't be a CALL_EXPR. */;
6122 else if (result
&& result
!= error_mark_node
)
6124 tree call
= extract_call_expr (result
);
6125 CALL_EXPR_OPERATOR_SYNTAX (call
) = true;
6127 if (processing_template_decl
&& DECL_HIDDEN_FRIEND_P (cand
->fn
))
6128 /* This prevents build_new_function_call from discarding this
6129 function during instantiation of the enclosing template. */
6130 KOENIG_LOOKUP_P (call
) = 1;
6132 /* Specify evaluation order as per P0145R2. */
6133 CALL_EXPR_ORDERED_ARGS (call
) = false;
6134 switch (op_is_ordered (code
))
6137 CALL_EXPR_REVERSE_ARGS (call
) = true;
6141 CALL_EXPR_ORDERED_ARGS (call
) = true;
6151 /* Give any warnings we noticed during overload resolution. */
6152 if (cand
->warnings
&& (complain
& tf_warning
))
6154 struct candidate_warning
*w
;
6155 for (w
= cand
->warnings
; w
; w
= w
->next
)
6156 joust (cand
, w
->loser
, 1, complain
);
6159 /* Check for comparison of different enum types. */
6168 if (TREE_CODE (arg1_type
) == ENUMERAL_TYPE
6169 && TREE_CODE (arg2_type
) == ENUMERAL_TYPE
6170 && (TYPE_MAIN_VARIANT (arg1_type
)
6171 != TYPE_MAIN_VARIANT (arg2_type
))
6172 && (complain
& tf_warning
))
6174 warning (OPT_Wenum_compare
,
6175 "comparison between %q#T and %q#T",
6176 arg1_type
, arg2_type
);
6183 /* We need to strip any leading REF_BIND so that bitfields
6184 don't cause errors. This should not remove any important
6185 conversions, because builtins don't apply to class
6186 objects directly. */
6187 conv
= cand
->convs
[0];
6188 if (conv
->kind
== ck_ref_bind
)
6189 conv
= next_conversion (conv
);
6190 arg1
= convert_like (conv
, arg1
, complain
);
6194 conv
= cand
->convs
[1];
6195 if (conv
->kind
== ck_ref_bind
)
6196 conv
= next_conversion (conv
);
6198 arg2
= decay_conversion (arg2
, complain
);
6200 /* We need to call warn_logical_operator before
6201 converting arg2 to a boolean_type, but after
6202 decaying an enumerator to its value. */
6203 if (complain
& tf_warning
)
6204 warn_logical_operator (loc
, code
, boolean_type_node
,
6205 code_orig_arg1
, arg1
,
6206 code_orig_arg2
, arg2
);
6208 arg2
= convert_like (conv
, arg2
, complain
);
6212 conv
= cand
->convs
[2];
6213 if (conv
->kind
== ck_ref_bind
)
6214 conv
= next_conversion (conv
);
6215 convert_like (conv
, arg3
, complain
);
6221 user_defined_result_ready
:
6223 /* Free all the conversions we allocated. */
6224 obstack_free (&conversion_obstack
, p
);
6226 if (result
|| result_valid_p
)
6233 return cp_build_modify_expr (loc
, arg1
, code2
, arg2
, complain
);
6236 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
6238 case TRUTH_ANDIF_EXPR
:
6239 case TRUTH_ORIF_EXPR
:
6240 case TRUTH_AND_EXPR
:
6242 if (complain
& tf_warning
)
6243 warn_logical_operator (loc
, code
, boolean_type_node
,
6244 code_orig_arg1
, arg1
,
6245 code_orig_arg2
, arg2
);
6253 if ((complain
& tf_warning
)
6254 && ((code_orig_arg1
== BOOLEAN_TYPE
)
6255 ^ (code_orig_arg2
== BOOLEAN_TYPE
)))
6256 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
6257 if (complain
& tf_warning
&& warn_tautological_compare
)
6258 warn_tautological_cmp (loc
, code
, arg1
, arg2
);
6263 case TRUNC_DIV_EXPR
:
6268 case TRUNC_MOD_EXPR
:
6272 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
6274 case UNARY_PLUS_EXPR
:
6277 case TRUTH_NOT_EXPR
:
6278 case PREINCREMENT_EXPR
:
6279 case POSTINCREMENT_EXPR
:
6280 case PREDECREMENT_EXPR
:
6281 case POSTDECREMENT_EXPR
:
6285 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
6288 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
6291 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
6295 /* The caller will deal with these. */
6307 /* Wrapper for above. */
6310 build_new_op (const op_location_t
&loc
, enum tree_code code
, int flags
,
6311 tree arg1
, tree arg2
, tree arg3
,
6312 tree
*overload
, tsubst_flags_t complain
)
6315 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
6316 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
6317 overload
, complain
);
6318 timevar_cond_stop (TV_OVERLOAD
, subtime
);
6322 /* CALL was returned by some call-building function; extract the actual
6323 CALL_EXPR from any bits that have been tacked on, e.g. by
6324 convert_from_reference. */
6327 extract_call_expr (tree call
)
6329 while (TREE_CODE (call
) == COMPOUND_EXPR
)
6330 call
= TREE_OPERAND (call
, 1);
6331 if (REFERENCE_REF_P (call
))
6332 call
= TREE_OPERAND (call
, 0);
6333 if (TREE_CODE (call
) == TARGET_EXPR
)
6334 call
= TARGET_EXPR_INITIAL (call
);
6335 gcc_assert (TREE_CODE (call
) == CALL_EXPR
6336 || TREE_CODE (call
) == AGGR_INIT_EXPR
6337 || call
== error_mark_node
);
6341 /* Returns true if FN has two parameters, of which the second has type
6345 second_parm_is_size_t (tree fn
)
6347 tree t
= FUNCTION_ARG_CHAIN (fn
);
6348 if (!t
|| !same_type_p (TREE_VALUE (t
), size_type_node
))
6351 if (t
== void_list_node
)
6356 /* True if T, an allocation function, has std::align_val_t as its second
6360 aligned_allocation_fn_p (tree t
)
6362 if (!aligned_new_threshold
)
6365 tree a
= FUNCTION_ARG_CHAIN (t
);
6366 return (a
&& same_type_p (TREE_VALUE (a
), align_type_node
));
6369 /* True if T is std::destroying_delete_t. */
6372 std_destroying_delete_t_p (tree t
)
6374 return (TYPE_CONTEXT (t
) == std_node
6375 && id_equal (TYPE_IDENTIFIER (t
), "destroying_delete_t"));
6378 /* A deallocation function with at least two parameters whose second parameter
6379 type is of type std::destroying_delete_t is a destroying operator delete. A
6380 destroying operator delete shall be a class member function named operator
6381 delete. [ Note: Array deletion cannot use a destroying operator
6382 delete. --end note ] */
6385 destroying_delete_p (tree t
)
6387 tree a
= TYPE_ARG_TYPES (TREE_TYPE (t
));
6388 if (!a
|| !TREE_CHAIN (a
))
6390 tree type
= TREE_VALUE (TREE_CHAIN (a
));
6391 return std_destroying_delete_t_p (type
) ? type
: NULL_TREE
;
6401 /* Returns true iff T, an element of an OVERLOAD chain, is a usual deallocation
6402 function (3.7.4.2 [basic.stc.dynamic.deallocation]). If so, and DI is
6403 non-null, also set *DI. */
6406 usual_deallocation_fn_p (tree t
, dealloc_info
*di
)
6408 if (di
) *di
= dealloc_info();
6410 /* A template instance is never a usual deallocation function,
6411 regardless of its signature. */
6412 if (TREE_CODE (t
) == TEMPLATE_DECL
6413 || primary_template_specialization_p (t
))
6416 /* A usual deallocation function is a deallocation function whose parameters
6418 - optionally, a parameter of type std::destroying_delete_t, then
6419 - optionally, a parameter of type std::size_t, then
6420 - optionally, a parameter of type std::align_val_t. */
6421 bool global
= DECL_NAMESPACE_SCOPE_P (t
);
6422 tree chain
= FUNCTION_ARG_CHAIN (t
);
6423 if (chain
&& destroying_delete_p (t
))
6425 if (di
) di
->destroying
= TREE_VALUE (chain
);
6426 chain
= TREE_CHAIN (chain
);
6429 && (!global
|| flag_sized_deallocation
)
6430 && same_type_p (TREE_VALUE (chain
), size_type_node
))
6432 if (di
) di
->sized
= true;
6433 chain
= TREE_CHAIN (chain
);
6435 if (chain
&& aligned_new_threshold
6436 && same_type_p (TREE_VALUE (chain
), align_type_node
))
6438 if (di
) di
->aligned
= true;
6439 chain
= TREE_CHAIN (chain
);
6441 return (chain
== void_list_node
);
6444 /* Just return whether FN is a usual deallocation function. */
6447 usual_deallocation_fn_p (tree fn
)
6449 return usual_deallocation_fn_p (fn
, NULL
);
6452 /* Build a call to operator delete. This has to be handled very specially,
6453 because the restrictions on what signatures match are different from all
6454 other call instances. For a normal delete, only a delete taking (void *)
6455 or (void *, size_t) is accepted. For a placement delete, only an exact
6456 match with the placement new is accepted.
6458 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
6459 ADDR is the pointer to be deleted.
6460 SIZE is the size of the memory block to be deleted.
6461 GLOBAL_P is true if the delete-expression should not consider
6462 class-specific delete operators.
6463 PLACEMENT is the corresponding placement new call, or NULL_TREE.
6465 If this call to "operator delete" is being generated as part to
6466 deallocate memory allocated via a new-expression (as per [expr.new]
6467 which requires that if the initialization throws an exception then
6468 we call a deallocation function), then ALLOC_FN is the allocation
6472 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
6473 bool global_p
, tree placement
,
6474 tree alloc_fn
, tsubst_flags_t complain
)
6476 tree fn
= NULL_TREE
;
6477 tree fns
, fnname
, type
, t
;
6478 dealloc_info di_fn
= { };
6480 if (addr
== error_mark_node
)
6481 return error_mark_node
;
6483 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
6485 fnname
= ovl_op_identifier (false, code
);
6487 if (CLASS_TYPE_P (type
)
6488 && COMPLETE_TYPE_P (complete_type (type
))
6492 If the result of the lookup is ambiguous or inaccessible, or if
6493 the lookup selects a placement deallocation function, the
6494 program is ill-formed.
6496 Therefore, we ask lookup_fnfields to complain about ambiguity. */
6498 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
6499 if (fns
== error_mark_node
)
6500 return error_mark_node
;
6505 if (fns
== NULL_TREE
)
6506 fns
= lookup_name_nonclass (fnname
);
6508 /* Strip const and volatile from addr. */
6510 addr
= cp_convert (ptr_type_node
, addr
, complain
);
6514 /* "A declaration of a placement deallocation function matches the
6515 declaration of a placement allocation function if it has the same
6516 number of parameters and, after parameter transformations (8.3.5),
6517 all parameter types except the first are identical."
6519 So we build up the function type we want and ask instantiate_type
6520 to get it for us. */
6521 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
6522 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
6523 t
= build_function_type (void_type_node
, t
);
6525 fn
= instantiate_type (t
, fns
, tf_none
);
6526 if (fn
== error_mark_node
)
6529 fn
= MAYBE_BASELINK_FUNCTIONS (fn
);
6531 /* "If the lookup finds the two-parameter form of a usual deallocation
6532 function (3.7.4.2) and that function, considered as a placement
6533 deallocation function, would have been selected as a match for the
6534 allocation function, the program is ill-formed." */
6535 if (second_parm_is_size_t (fn
))
6537 const char *const msg1
6538 = G_("exception cleanup for this placement new selects "
6539 "non-placement %<operator delete%>");
6540 const char *const msg2
6541 = G_("%qD is a usual (non-placement) deallocation "
6542 "function in C++14 (or with %<-fsized-deallocation%>)");
6544 /* But if the class has an operator delete (void *), then that is
6545 the usual deallocation function, so we shouldn't complain
6546 about using the operator delete (void *, size_t). */
6547 if (DECL_CLASS_SCOPE_P (fn
))
6548 for (lkp_iterator
iter (MAYBE_BASELINK_FUNCTIONS (fns
));
6552 if (usual_deallocation_fn_p (elt
)
6553 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
6556 /* Before C++14 a two-parameter global deallocation function is
6557 always a placement deallocation function, but warn if
6559 else if (!flag_sized_deallocation
)
6561 if (complain
& tf_warning
)
6563 auto_diagnostic_group d
;
6564 if (warning (OPT_Wc__14_compat
, msg1
))
6565 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
6570 if (complain
& tf_warning_or_error
)
6572 auto_diagnostic_group d
;
6573 if (permerror (input_location
, msg1
))
6575 /* Only mention C++14 for namespace-scope delete. */
6576 if (DECL_NAMESPACE_SCOPE_P (fn
))
6577 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
6579 inform (DECL_SOURCE_LOCATION (fn
),
6580 "%qD is a usual (non-placement) deallocation "
6585 return error_mark_node
;
6590 /* "Any non-placement deallocation function matches a non-placement
6591 allocation function. If the lookup finds a single matching
6592 deallocation function, that function will be called; otherwise, no
6593 deallocation function will be called." */
6594 for (lkp_iterator
iter (MAYBE_BASELINK_FUNCTIONS (fns
)); iter
; ++iter
)
6597 dealloc_info di_elt
;
6598 if (usual_deallocation_fn_p (elt
, &di_elt
))
6607 /* -- If any of the deallocation functions is a destroying
6608 operator delete, all deallocation functions that are not
6609 destroying operator deletes are eliminated from further
6611 if (di_elt
.destroying
!= di_fn
.destroying
)
6613 if (di_elt
.destroying
)
6621 /* -- If the type has new-extended alignment, a function with a
6622 parameter of type std::align_val_t is preferred; otherwise a
6623 function without such a parameter is preferred. If exactly one
6624 preferred function is found, that function is selected and the
6625 selection process terminates. If more than one preferred
6626 function is found, all non-preferred functions are eliminated
6627 from further consideration. */
6628 if (aligned_new_threshold
)
6630 bool want_align
= type_has_new_extended_alignment (type
);
6631 if (di_elt
.aligned
!= di_fn
.aligned
)
6633 if (want_align
== di_elt
.aligned
)
6642 /* -- If the deallocation functions have class scope, the one
6643 without a parameter of type std::size_t is selected. */
6645 if (DECL_CLASS_SCOPE_P (fn
))
6648 /* -- If the type is complete and if, for the second alternative
6649 (delete array) only, the operand is a pointer to a class type
6650 with a non-trivial destructor or a (possibly multi-dimensional)
6651 array thereof, the function with a parameter of type std::size_t
6654 -- Otherwise, it is unspecified whether a deallocation function
6655 with a parameter of type std::size_t is selected. */
6658 want_size
= COMPLETE_TYPE_P (type
);
6659 if (code
== VEC_DELETE_EXPR
6660 && !TYPE_VEC_NEW_USES_COOKIE (type
))
6661 /* We need a cookie to determine the array size. */
6664 gcc_assert (di_fn
.sized
!= di_elt
.sized
);
6665 if (want_size
== di_elt
.sized
)
6673 /* If we have a matching function, call it. */
6676 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6678 /* If the FN is a member function, make sure that it is
6680 if (BASELINK_P (fns
))
6681 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
6684 /* Core issue 901: It's ok to new a type with deleted delete. */
6685 if (DECL_DELETED_FN (fn
) && alloc_fn
)
6690 /* The placement args might not be suitable for overload
6691 resolution at this point, so build the call directly. */
6692 int nargs
= call_expr_nargs (placement
);
6693 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
6696 for (i
= 1; i
< nargs
; i
++)
6697 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
6698 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6699 return error_mark_node
;
6700 return build_cxx_call (fn
, nargs
, argarray
, complain
);
6704 tree destroying
= di_fn
.destroying
;
6707 /* Strip const and volatile from addr but retain the type of the
6709 tree rtype
= TREE_TYPE (TREE_TYPE (oaddr
));
6710 rtype
= cv_unqualified (rtype
);
6711 rtype
= TYPE_POINTER_TO (rtype
);
6712 addr
= cp_convert (rtype
, oaddr
, complain
);
6713 destroying
= build_functional_cast (destroying
, NULL_TREE
,
6719 args
->quick_push (addr
);
6721 args
->quick_push (destroying
);
6723 args
->quick_push (size
);
6726 tree al
= build_int_cst (align_type_node
, TYPE_ALIGN_UNIT (type
));
6727 args
->quick_push (al
);
6729 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
6736 If no unambiguous matching deallocation function can be found,
6737 propagating the exception does not cause the object's memory to
6741 if ((complain
& tf_warning
)
6743 warning (0, "no corresponding deallocation function for %qD",
6748 if (complain
& tf_error
)
6749 error ("no suitable %<operator %s%> for %qT",
6750 OVL_OP_INFO (false, code
)->name
, type
);
6751 return error_mark_node
;
6754 /* Issue diagnostics about a disallowed access of DECL, using DIAG_DECL
6757 If ISSUE_ERROR is true, then issue an error about the
6758 access, followed by a note showing the declaration.
6759 Otherwise, just show the note. */
6762 complain_about_access (tree decl
, tree diag_decl
, bool issue_error
)
6764 if (TREE_PRIVATE (decl
))
6767 error ("%q#D is private within this context", diag_decl
);
6768 inform (DECL_SOURCE_LOCATION (diag_decl
),
6769 "declared private here");
6771 else if (TREE_PROTECTED (decl
))
6774 error ("%q#D is protected within this context", diag_decl
);
6775 inform (DECL_SOURCE_LOCATION (diag_decl
),
6776 "declared protected here");
6781 error ("%q#D is inaccessible within this context", diag_decl
);
6782 inform (DECL_SOURCE_LOCATION (diag_decl
), "declared here");
6786 /* If the current scope isn't allowed to access DECL along
6787 BASETYPE_PATH, give an error. The most derived class in
6788 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
6789 the declaration to use in the error diagnostic. */
6792 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
6793 tsubst_flags_t complain
, access_failure_info
*afi
)
6795 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
6797 if (flag_new_inheriting_ctors
6798 && DECL_INHERITED_CTOR (decl
))
6800 /* 7.3.3/18: The additional constructors are accessible if they would be
6801 accessible when used to construct an object of the corresponding base
6803 decl
= strip_inheriting_ctors (decl
);
6804 basetype_path
= lookup_base (basetype_path
, DECL_CONTEXT (decl
),
6805 ba_any
, NULL
, complain
);
6808 if (!accessible_p (basetype_path
, decl
, true))
6810 if (flag_new_inheriting_ctors
)
6811 diag_decl
= strip_inheriting_ctors (diag_decl
);
6812 if (complain
& tf_error
)
6813 complain_about_access (decl
, diag_decl
, true);
6815 afi
->record_access_failure (basetype_path
, decl
, diag_decl
);
6822 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
6823 bitwise or of LOOKUP_* values. If any errors are warnings are
6824 generated, set *DIAGNOSTIC_FN to "error" or "warning",
6825 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
6829 build_temp (tree expr
, tree type
, int flags
,
6830 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
6834 *diagnostic_kind
= DK_UNSPECIFIED
;
6836 /* If the source is a packed field, calling the copy constructor will require
6837 binding the field to the reference parameter to the copy constructor, and
6838 we'll end up with an infinite loop. If we can use a bitwise copy, then
6840 if ((lvalue_kind (expr
) & clk_packed
)
6841 && CLASS_TYPE_P (TREE_TYPE (expr
))
6842 && !type_has_nontrivial_copy_init (TREE_TYPE (expr
)))
6843 return get_target_expr_sfinae (expr
, complain
);
6845 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
6846 releasing_vec
args (make_tree_vector_single (expr
));
6847 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6848 &args
, type
, flags
, complain
);
6849 if (warningcount
+ werrorcount
> savew
)
6850 *diagnostic_kind
= DK_WARNING
;
6851 else if (errorcount
> savee
)
6852 *diagnostic_kind
= DK_ERROR
;
6856 /* Get any location for EXPR, falling back to input_location.
6858 If the result is in a system header and is the virtual location for
6859 a token coming from the expansion of a macro, unwind it to the
6860 location of the expansion point of the macro (e.g. to avoid the
6861 diagnostic being suppressed for expansions of NULL where "NULL" is
6862 in a system header). */
6865 get_location_for_expr_unwinding_for_system_header (tree expr
)
6867 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6868 loc
= expansion_point_location_if_in_system_header (loc
);
6872 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
6873 Also handle a subset of zero as null warnings.
6874 EXPR is implicitly converted to type TOTYPE.
6875 FN and ARGNUM are used for diagnostics. */
6878 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6880 /* Issue warnings about peculiar, but valid, uses of NULL. */
6881 if (TREE_CODE (totype
) != BOOLEAN_TYPE
6882 && ARITHMETIC_TYPE_P (totype
)
6883 && null_node_p (expr
))
6885 location_t loc
= get_location_for_expr_unwinding_for_system_header (expr
);
6888 auto_diagnostic_group d
;
6889 if (warning_at (loc
, OPT_Wconversion_null
,
6890 "passing NULL to non-pointer argument %P of %qD",
6892 inform (get_fndecl_argument_location (fn
, argnum
),
6896 warning_at (loc
, OPT_Wconversion_null
,
6897 "converting to non-pointer type %qT from NULL", totype
);
6900 /* Issue warnings if "false" is converted to a NULL pointer */
6901 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6902 && TYPE_PTR_P (totype
))
6904 location_t loc
= get_location_for_expr_unwinding_for_system_header (expr
);
6907 auto_diagnostic_group d
;
6908 if (warning_at (loc
, OPT_Wconversion_null
,
6909 "converting %<false%> to pointer type for argument "
6910 "%P of %qD", argnum
, fn
))
6911 inform (get_fndecl_argument_location (fn
, argnum
),
6915 warning_at (loc
, OPT_Wconversion_null
,
6916 "converting %<false%> to pointer type %qT", totype
);
6918 /* Handle zero as null pointer warnings for cases other
6919 than EQ_EXPR and NE_EXPR */
6920 else if ((TYPE_PTR_OR_PTRMEM_P (totype
) || NULLPTR_TYPE_P (totype
))
6921 && null_ptr_cst_p (expr
))
6923 location_t loc
= get_location_for_expr_unwinding_for_system_header (expr
);
6924 maybe_warn_zero_as_null_pointer_constant (expr
, loc
);
6928 /* We gave a diagnostic during a conversion. If this was in the second
6929 standard conversion sequence of a user-defined conversion sequence, say
6930 which user-defined conversion. */
6933 maybe_print_user_conv_context (conversion
*convs
)
6935 if (convs
->user_conv_p
)
6936 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6937 if (t
->kind
== ck_user
)
6939 print_z_candidate (0, N_(" after user-defined conversion:"),
6945 /* Locate the parameter with the given index within FNDECL.
6946 ARGNUM is zero based, -1 indicates the `this' argument of a method.
6947 Return the location of the FNDECL itself if there are problems. */
6950 get_fndecl_argument_location (tree fndecl
, int argnum
)
6952 /* The locations of implicitly-declared functions are likely to be
6953 more meaningful than those of their parameters. */
6954 if (DECL_ARTIFICIAL (fndecl
))
6955 return DECL_SOURCE_LOCATION (fndecl
);
6960 /* Locate param by index within DECL_ARGUMENTS (fndecl). */
6961 for (i
= 0, param
= FUNCTION_FIRST_USER_PARM (fndecl
);
6962 i
< argnum
&& param
;
6963 i
++, param
= TREE_CHAIN (param
))
6966 /* If something went wrong (e.g. if we have a builtin and thus no arguments),
6967 return the location of FNDECL. */
6969 return DECL_SOURCE_LOCATION (fndecl
);
6971 return DECL_SOURCE_LOCATION (param
);
6974 /* If FNDECL is non-NULL, issue a note highlighting ARGNUM
6975 within its declaration (or the fndecl itself if something went
6979 maybe_inform_about_fndecl_for_bogus_argument_init (tree fn
, int argnum
)
6982 inform (get_fndecl_argument_location (fn
, argnum
),
6983 " initializing argument %P of %qD", argnum
, fn
);
6986 /* Perform the conversions in CONVS on the expression EXPR. FN and
6987 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6988 indicates the `this' argument of a method. INNER is nonzero when
6989 being called to continue a conversion chain. It is negative when a
6990 reference binding will be applied, positive otherwise. If
6991 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6992 conversions will be emitted if appropriate. If C_CAST_P is true,
6993 this conversion is coming from a C-style cast; in that case,
6994 conversions to inaccessible bases are permitted. */
6997 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6998 bool issue_conversion_warnings
,
6999 bool c_cast_p
, tsubst_flags_t complain
)
7001 tree totype
= convs
->type
;
7002 diagnostic_t diag_kind
;
7004 location_t loc
= cp_expr_loc_or_input_loc (expr
);
7006 if (convs
->bad_p
&& !(complain
& tf_error
))
7007 return error_mark_node
;
7010 && convs
->kind
!= ck_user
7011 && convs
->kind
!= ck_list
7012 && convs
->kind
!= ck_ambig
7013 && (convs
->kind
!= ck_ref_bind
7014 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
7015 && (convs
->kind
!= ck_rvalue
7016 || SCALAR_TYPE_P (totype
))
7017 && convs
->kind
!= ck_base
)
7019 bool complained
= false;
7020 conversion
*t
= convs
;
7022 /* Give a helpful error if this is bad because of excess braces. */
7023 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
7024 && SCALAR_TYPE_P (totype
)
7025 && CONSTRUCTOR_NELTS (expr
) > 0
7026 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
7028 complained
= permerror (loc
, "too many braces around initializer "
7030 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
7031 && CONSTRUCTOR_NELTS (expr
) == 1)
7032 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
7035 /* Give a helpful error if this is bad because a conversion to bool
7036 from std::nullptr_t requires direct-initialization. */
7037 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
7038 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
7039 complained
= permerror (loc
, "converting to %qH from %qI requires "
7040 "direct-initialization",
7041 totype
, TREE_TYPE (expr
));
7043 for (; t
; t
= next_conversion (t
))
7045 if (t
->kind
== ck_user
&& t
->cand
->reason
)
7047 auto_diagnostic_group d
;
7048 complained
= permerror (loc
, "invalid user-defined conversion "
7049 "from %qH to %qI", TREE_TYPE (expr
),
7052 print_z_candidate (loc
, N_("candidate is:"), t
->cand
);
7053 expr
= convert_like_real (t
, expr
, fn
, argnum
,
7054 /*issue_conversion_warnings=*/false,
7057 if (convs
->kind
== ck_ref_bind
)
7058 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
7059 LOOKUP_NORMAL
, NULL_TREE
,
7062 expr
= cp_convert (totype
, expr
, complain
);
7064 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
7067 else if (t
->kind
== ck_user
|| !t
->bad_p
)
7069 expr
= convert_like_real (t
, expr
, fn
, argnum
,
7070 /*issue_conversion_warnings=*/false,
7075 else if (t
->kind
== ck_ambig
)
7076 return convert_like_real (t
, expr
, fn
, argnum
,
7077 /*issue_conversion_warnings=*/false,
7080 else if (t
->kind
== ck_identity
)
7085 range_label_for_type_mismatch
label (TREE_TYPE (expr
), totype
);
7086 gcc_rich_location
richloc (loc
, &label
);
7087 complained
= permerror (&richloc
,
7088 "invalid conversion from %qH to %qI",
7089 TREE_TYPE (expr
), totype
);
7092 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
7094 return cp_convert (totype
, expr
, complain
);
7097 if (issue_conversion_warnings
&& (complain
& tf_warning
))
7098 conversion_null_warnings (totype
, expr
, fn
, argnum
);
7100 switch (convs
->kind
)
7104 struct z_candidate
*cand
= convs
->cand
;
7107 /* We chose the surrogate function from add_conv_candidate, now we
7108 actually need to build the conversion. */
7109 cand
= build_user_type_conversion_1 (totype
, expr
,
7110 LOOKUP_NO_CONVERSION
, complain
);
7112 tree convfn
= cand
->fn
;
7114 /* When converting from an init list we consider explicit
7115 constructors, but actually trying to call one is an error. */
7116 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
7117 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
7118 /* Unless this is for direct-list-initialization. */
7119 && (!CONSTRUCTOR_IS_DIRECT_INIT (expr
) || convs
->need_temporary_p
)
7120 /* And in C++98 a default constructor can't be explicit. */
7121 && cxx_dialect
>= cxx11
)
7123 if (!(complain
& tf_error
))
7124 return error_mark_node
;
7125 location_t loc
= location_of (expr
);
7126 if (CONSTRUCTOR_NELTS (expr
) == 0
7127 && FUNCTION_FIRST_USER_PARMTYPE (convfn
) != void_list_node
)
7129 auto_diagnostic_group d
;
7130 if (pedwarn (loc
, 0, "converting to %qT from initializer list "
7131 "would use explicit constructor %qD",
7133 inform (loc
, "in C++11 and above a default constructor "
7137 error ("converting to %qT from initializer list would use "
7138 "explicit constructor %qD", totype
, convfn
);
7141 /* If we're initializing from {}, it's value-initialization. */
7142 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
7143 && CONSTRUCTOR_NELTS (expr
) == 0
7144 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
)
7145 && !processing_template_decl
)
7147 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
7148 if (abstract_virtuals_error_sfinae (NULL_TREE
, totype
, complain
))
7149 return error_mark_node
;
7150 expr
= build_value_init (totype
, complain
);
7151 expr
= get_target_expr_sfinae (expr
, complain
);
7152 if (expr
!= error_mark_node
)
7154 TARGET_EXPR_LIST_INIT_P (expr
) = true;
7155 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
7160 /* We don't know here whether EXPR is being used as an lvalue or
7161 rvalue, but we know it's read. */
7162 mark_exp_read (expr
);
7164 /* Pass LOOKUP_NO_CONVERSION so rvalue/base handling knows not to allow
7166 expr
= build_over_call (cand
, LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
7169 /* If this is a constructor or a function returning an aggr type,
7170 we need to build up a TARGET_EXPR. */
7171 if (DECL_CONSTRUCTOR_P (convfn
))
7173 expr
= build_cplus_new (totype
, expr
, complain
);
7175 /* Remember that this was list-initialization. */
7176 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
7177 TARGET_EXPR_LIST_INIT_P (expr
) = true;
7183 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
7185 int nelts
= CONSTRUCTOR_NELTS (expr
);
7187 expr
= build_value_init (totype
, complain
);
7188 else if (nelts
== 1)
7189 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
7193 expr
= mark_use (expr
, /*rvalue_p=*/!convs
->rvaluedness_matches_p
,
7194 /*read_p=*/true, UNKNOWN_LOCATION
,
7195 /*reject_builtin=*/true);
7197 if (type_unknown_p (expr
))
7198 expr
= instantiate_type (totype
, expr
, complain
);
7199 if (expr
== null_node
7200 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
7201 /* If __null has been converted to an integer type, we do not want to
7202 continue to warn about uses of EXPR as an integer, rather than as a
7204 expr
= build_int_cst (totype
, 0);
7207 /* We leave bad_p off ck_ambig because overload resolution considers
7208 it valid, it just fails when we try to perform it. So we need to
7209 check complain here, too. */
7210 if (complain
& tf_error
)
7212 /* Call build_user_type_conversion again for the error. */
7213 int flags
= (convs
->need_temporary_p
7214 ? LOOKUP_IMPLICIT
: LOOKUP_NORMAL
);
7215 build_user_type_conversion (totype
, convs
->u
.expr
, flags
, complain
);
7216 gcc_assert (seen_error ());
7217 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
7219 return error_mark_node
;
7223 /* Conversion to std::initializer_list<T>. */
7224 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
7225 unsigned len
= CONSTRUCTOR_NELTS (expr
);
7230 tree val
; unsigned ix
;
7232 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
7234 /* Convert all the elements. */
7235 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
7237 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
,
7238 argnum
, false, false, complain
);
7239 if (sub
== error_mark_node
)
7241 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
7242 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
7243 return error_mark_node
;
7244 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
),
7246 if (!TREE_CONSTANT (sub
))
7247 TREE_CONSTANT (new_ctor
) = false;
7249 /* Build up the array. */
7250 elttype
= cp_build_qualified_type
7251 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
7252 array
= build_array_of_n_type (elttype
, len
);
7253 array
= finish_compound_literal (array
, new_ctor
, complain
);
7254 /* Take the address explicitly rather than via decay_conversion
7255 to avoid the error about taking the address of a temporary. */
7256 array
= cp_build_addr_expr (array
, complain
);
7259 array
= nullptr_node
;
7261 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
7262 if (array
== error_mark_node
)
7263 return error_mark_node
;
7265 /* Build up the initializer_list object. Note: fail gracefully
7266 if the object cannot be completed because, for example, no
7267 definition is provided (c++/80956). */
7268 totype
= complete_type_or_maybe_complain (totype
, NULL_TREE
, complain
);
7270 return error_mark_node
;
7271 tree field
= next_initializable_field (TYPE_FIELDS (totype
));
7272 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
7273 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
7274 field
= next_initializable_field (DECL_CHAIN (field
));
7275 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
7276 tree new_ctor
= build_constructor (totype
, vec
);
7277 return get_target_expr_sfinae (new_ctor
, complain
);
7281 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
7283 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
7284 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
7285 real
= perform_implicit_conversion (TREE_TYPE (totype
),
7287 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
7289 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
7292 expr
= reshape_init (totype
, expr
, complain
);
7293 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
7295 if (expr
!= error_mark_node
)
7296 TARGET_EXPR_LIST_INIT_P (expr
) = true;
7303 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
7304 convs
->kind
== ck_ref_bind
7305 ? issue_conversion_warnings
: false,
7306 c_cast_p
, complain
);
7307 if (expr
== error_mark_node
)
7308 return error_mark_node
;
7310 switch (convs
->kind
)
7313 expr
= decay_conversion (expr
, complain
);
7314 if (expr
== error_mark_node
)
7316 if (complain
& tf_error
)
7318 auto_diagnostic_group d
;
7319 maybe_print_user_conv_context (convs
);
7320 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
7322 return error_mark_node
;
7325 if (! MAYBE_CLASS_TYPE_P (totype
))
7328 /* Don't introduce copies when passing arguments along to the inherited
7330 if (current_function_decl
7331 && flag_new_inheriting_ctors
7332 && DECL_INHERITED_CTOR (current_function_decl
))
7335 if (TREE_CODE (expr
) == TARGET_EXPR
7336 && TARGET_EXPR_LIST_INIT_P (expr
))
7337 /* Copy-list-initialization doesn't actually involve a copy. */
7342 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
7344 /* We are going to bind a reference directly to a base-class
7345 subobject of EXPR. */
7346 /* Build an expression for `*((base*) &expr)'. */
7347 expr
= convert_to_base (expr
, totype
,
7348 !c_cast_p
, /*nonnull=*/true, complain
);
7352 /* Copy-initialization where the cv-unqualified version of the source
7353 type is the same class as, or a derived class of, the class of the
7354 destination [is treated as direct-initialization]. [dcl.init] */
7355 flags
= LOOKUP_NORMAL
;
7356 if (convs
->user_conv_p
)
7357 /* This conversion is being done in the context of a user-defined
7358 conversion (i.e. the second step of copy-initialization), so
7359 don't allow any more. */
7360 flags
|= LOOKUP_NO_CONVERSION
;
7362 flags
|= LOOKUP_ONLYCONVERTING
;
7363 if (convs
->rvaluedness_matches_p
)
7364 /* standard_conversion got LOOKUP_PREFER_RVALUE. */
7365 flags
|= LOOKUP_PREFER_RVALUE
;
7366 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
7367 if (diag_kind
&& complain
)
7369 auto_diagnostic_group d
;
7370 maybe_print_user_conv_context (convs
);
7371 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
7374 return build_cplus_new (totype
, expr
, complain
);
7378 tree ref_type
= totype
;
7380 /* direct_reference_binding might have inserted a ck_qual under
7381 this ck_ref_bind for the benefit of conversion sequence ranking.
7382 Ignore the conversion; we'll create our own below. */
7383 if (next_conversion (convs
)->kind
== ck_qual
)
7385 gcc_assert (same_type_p (TREE_TYPE (expr
),
7386 next_conversion (convs
)->type
));
7387 /* Strip the cast created by the ck_qual; cp_build_addr_expr
7388 below expects an lvalue. */
7392 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
7394 tree extype
= TREE_TYPE (expr
);
7395 auto_diagnostic_group d
;
7396 if (TYPE_REF_IS_RVALUE (ref_type
)
7398 error_at (loc
, "cannot bind rvalue reference of type %qH to "
7399 "lvalue of type %qI", totype
, extype
);
7400 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !lvalue_p (expr
)
7401 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
7402 error_at (loc
, "cannot bind non-const lvalue reference of "
7403 "type %qH to an rvalue of type %qI", totype
, extype
);
7404 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
7405 error_at (loc
, "binding reference of type %qH to %qI "
7406 "discards qualifiers", totype
, extype
);
7409 maybe_print_user_conv_context (convs
);
7410 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
7412 return error_mark_node
;
7415 /* If necessary, create a temporary.
7417 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
7418 that need temporaries, even when their types are reference
7419 compatible with the type of reference being bound, so the
7420 upcoming call to cp_build_addr_expr doesn't fail. */
7421 if (convs
->need_temporary_p
7422 || TREE_CODE (expr
) == CONSTRUCTOR
7423 || TREE_CODE (expr
) == VA_ARG_EXPR
)
7425 /* Otherwise, a temporary of type "cv1 T1" is created and
7426 initialized from the initializer expression using the rules
7427 for a non-reference copy-initialization (8.5). */
7429 tree type
= TREE_TYPE (ref_type
);
7430 cp_lvalue_kind lvalue
= lvalue_kind (expr
);
7432 gcc_assert (similar_type_p (type
, next_conversion (convs
)->type
));
7433 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
7434 && !TYPE_REF_IS_RVALUE (ref_type
))
7436 /* If the reference is volatile or non-const, we
7437 cannot create a temporary. */
7438 if (lvalue
& clk_bitfield
)
7439 error_at (loc
, "cannot bind bit-field %qE to %qT",
7441 else if (lvalue
& clk_packed
)
7442 error_at (loc
, "cannot bind packed field %qE to %qT",
7445 error_at (loc
, "cannot bind rvalue %qE to %qT",
7447 return error_mark_node
;
7449 /* If the source is a packed field, and we must use a copy
7450 constructor, then building the target expr will require
7451 binding the field to the reference parameter to the
7452 copy constructor, and we'll end up with an infinite
7453 loop. If we can use a bitwise copy, then we'll be
7455 if ((lvalue
& clk_packed
)
7456 && CLASS_TYPE_P (type
)
7457 && type_has_nontrivial_copy_init (type
))
7459 error_at (loc
, "cannot bind packed field %qE to %qT",
7461 return error_mark_node
;
7463 if (lvalue
& clk_bitfield
)
7465 expr
= convert_bitfield_to_declared_type (expr
);
7466 expr
= fold_convert (type
, expr
);
7468 expr
= build_target_expr_with_type (expr
, type
, complain
);
7471 /* Take the address of the thing to which we will bind the
7473 expr
= cp_build_addr_expr (expr
, complain
);
7474 if (expr
== error_mark_node
)
7475 return error_mark_node
;
7477 /* Convert it to a pointer to the type referred to by the
7478 reference. This will adjust the pointer if a derived to
7479 base conversion is being performed. */
7480 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
7482 /* Convert the pointer to the desired reference type. */
7483 return build_nop (ref_type
, expr
);
7487 return decay_conversion (expr
, complain
);
7490 /* ??? Should the address of a transaction-safe pointer point to the TM
7491 clone, and this conversion look up the primary function? */
7492 return build_nop (totype
, expr
);
7495 /* Warn about deprecated conversion if appropriate. */
7496 if (complain
& tf_warning
)
7497 string_conv_p (totype
, expr
, 1);
7502 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
7503 /*nonnull=*/false, complain
);
7504 return build_nop (totype
, expr
);
7507 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
7508 c_cast_p
, complain
);
7514 if (convs
->check_narrowing
7515 && !check_narrowing (totype
, expr
, complain
,
7516 convs
->check_narrowing_const_only
))
7517 return error_mark_node
;
7519 warning_sentinel
w (warn_zero_as_null_pointer_constant
);
7520 if (issue_conversion_warnings
)
7521 expr
= cp_convert_and_check (totype
, expr
, complain
);
7523 expr
= cp_convert (totype
, expr
, complain
);
7528 /* ARG is being passed to a varargs function. Perform any conversions
7529 required. Return the converted value. */
7532 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
7534 tree arg_type
= TREE_TYPE (arg
);
7535 location_t loc
= cp_expr_loc_or_input_loc (arg
);
7539 If the argument has integral or enumeration type that is subject
7540 to the integral promotions (_conv.prom_), or a floating-point
7541 type that is subject to the floating-point promotion
7542 (_conv.fpprom_), the value of the argument is converted to the
7543 promoted type before the call. */
7544 if (TREE_CODE (arg_type
) == REAL_TYPE
7545 && (TYPE_PRECISION (arg_type
)
7546 < TYPE_PRECISION (double_type_node
))
7547 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
7549 if ((complain
& tf_warning
)
7550 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
7551 warning_at (loc
, OPT_Wdouble_promotion
,
7552 "implicit conversion from %qH to %qI when passing "
7553 "argument to function",
7554 arg_type
, double_type_node
);
7555 arg
= convert_to_real_nofold (double_type_node
, arg
);
7557 else if (NULLPTR_TYPE_P (arg_type
))
7558 arg
= null_pointer_node
;
7559 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
7561 if (SCOPED_ENUM_P (arg_type
))
7563 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
7565 prom
= cp_perform_integral_promotions (prom
, complain
);
7566 if (abi_version_crosses (6)
7567 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
7568 && (complain
& tf_warning
))
7569 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through %<...%>"
7570 "as %qT before %<-fabi-version=6%>, %qT after",
7572 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
7573 if (!abi_version_at_least (6))
7577 arg
= cp_perform_integral_promotions (arg
, complain
);
7582 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
7583 standard conversions are performed. */
7584 arg
= decay_conversion (arg
, complain
);
7586 arg
= require_complete_type_sfinae (arg
, complain
);
7587 arg_type
= TREE_TYPE (arg
);
7589 if (arg
!= error_mark_node
7590 /* In a template (or ill-formed code), we can have an incomplete type
7591 even after require_complete_type_sfinae, in which case we don't know
7592 whether it has trivial copy or not. */
7593 && COMPLETE_TYPE_P (arg_type
)
7594 && !cp_unevaluated_operand
)
7596 /* [expr.call] 5.2.2/7:
7597 Passing a potentially-evaluated argument of class type (Clause 9)
7598 with a non-trivial copy constructor or a non-trivial destructor
7599 with no corresponding parameter is conditionally-supported, with
7600 implementation-defined semantics.
7602 We support it as pass-by-invisible-reference, just like a normal
7605 If the call appears in the context of a sizeof expression,
7606 it is not potentially-evaluated. */
7607 if (type_has_nontrivial_copy_init (arg_type
)
7608 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
))
7610 arg
= force_rvalue (arg
, complain
);
7611 if (complain
& tf_warning
)
7612 warning (OPT_Wconditionally_supported
,
7613 "passing objects of non-trivially-copyable "
7614 "type %q#T through %<...%> is conditionally supported",
7616 return build1 (ADDR_EXPR
, build_reference_type (arg_type
), arg
);
7618 /* Build up a real lvalue-to-rvalue conversion in case the
7619 copy constructor is trivial but not callable. */
7620 else if (CLASS_TYPE_P (arg_type
))
7621 force_rvalue (arg
, complain
);
7628 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
7631 build_x_va_arg (location_t loc
, tree expr
, tree type
)
7633 if (processing_template_decl
)
7635 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
7636 SET_EXPR_LOCATION (r
, loc
);
7640 type
= complete_type_or_else (type
, NULL_TREE
);
7642 if (expr
== error_mark_node
|| !type
)
7643 return error_mark_node
;
7645 expr
= mark_lvalue_use (expr
);
7647 if (TYPE_REF_P (type
))
7649 error ("cannot receive reference type %qT through %<...%>", type
);
7650 return error_mark_node
;
7653 if (type_has_nontrivial_copy_init (type
)
7654 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7656 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
7657 it as pass by invisible reference. */
7658 warning_at (loc
, OPT_Wconditionally_supported
,
7659 "receiving objects of non-trivially-copyable type %q#T "
7660 "through %<...%> is conditionally-supported", type
);
7662 tree ref
= cp_build_reference_type (type
, false);
7663 expr
= build_va_arg (loc
, expr
, ref
);
7664 return convert_from_reference (expr
);
7667 tree ret
= build_va_arg (loc
, expr
, type
);
7668 if (CLASS_TYPE_P (type
))
7669 /* Wrap the VA_ARG_EXPR in a TARGET_EXPR now so other code doesn't need to
7670 know how to handle it. */
7671 ret
= get_target_expr (ret
);
7675 /* TYPE has been given to va_arg. Apply the default conversions which
7676 would have happened when passed via ellipsis. Return the promoted
7677 type, or the passed type if there is no change. */
7680 cxx_type_promotes_to (tree type
)
7684 /* Perform the array-to-pointer and function-to-pointer
7686 type
= type_decays_to (type
);
7688 promote
= type_promotes_to (type
);
7689 if (same_type_p (type
, promote
))
7695 /* ARG is a default argument expression being passed to a parameter of
7696 the indicated TYPE, which is a parameter to FN. PARMNUM is the
7697 zero-based argument number. Do any required conversions. Return
7698 the converted value. */
7700 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
7702 push_defarg_context (tree fn
)
7703 { vec_safe_push (default_arg_context
, fn
); }
7706 pop_defarg_context (void)
7707 { default_arg_context
->pop (); }
7710 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
7711 tsubst_flags_t complain
)
7716 /* See through clones. */
7717 fn
= DECL_ORIGIN (fn
);
7718 /* And inheriting ctors. */
7719 if (flag_new_inheriting_ctors
)
7720 fn
= strip_inheriting_ctors (fn
);
7722 /* Detect recursion. */
7723 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
7726 if (complain
& tf_error
)
7727 error ("recursive evaluation of default argument for %q#D", fn
);
7728 return error_mark_node
;
7731 /* If the ARG is an unparsed default argument expression, the
7732 conversion cannot be performed. */
7733 if (TREE_CODE (arg
) == DEFERRED_PARSE
)
7735 if (complain
& tf_error
)
7736 error ("call to %qD uses the default argument for parameter %P, which "
7737 "is not yet defined", fn
, parmnum
);
7738 return error_mark_node
;
7741 push_defarg_context (fn
);
7743 if (fn
&& DECL_TEMPLATE_INFO (fn
))
7744 arg
= tsubst_default_argument (fn
, parmnum
, type
, arg
, complain
);
7750 The names in the expression are bound, and the semantic
7751 constraints are checked, at the point where the default
7752 expressions appears.
7754 we must not perform access checks here. */
7755 push_deferring_access_checks (dk_no_check
);
7756 /* We must make a copy of ARG, in case subsequent processing
7757 alters any part of it. */
7758 arg
= break_out_target_exprs (arg
, /*clear location*/true);
7760 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
7761 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
7763 arg
= convert_for_arg_passing (type
, arg
, complain
);
7764 pop_deferring_access_checks();
7766 pop_defarg_context ();
7771 /* Returns the type which will really be used for passing an argument of
7775 type_passed_as (tree type
)
7777 /* Pass classes with copy ctors by invisible reference. */
7778 if (TREE_ADDRESSABLE (type
))
7780 type
= build_reference_type (type
);
7781 /* There are no other pointers to this temporary. */
7782 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
7784 else if (targetm
.calls
.promote_prototypes (NULL_TREE
)
7785 && INTEGRAL_TYPE_P (type
)
7786 && COMPLETE_TYPE_P (type
)
7787 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
7788 type
= integer_type_node
;
7793 /* Actually perform the appropriate conversion. */
7796 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
7800 /* If VAL is a bitfield, then -- since it has already been converted
7801 to TYPE -- it cannot have a precision greater than TYPE.
7803 If it has a smaller precision, we must widen it here. For
7804 example, passing "int f:3;" to a function expecting an "int" will
7805 not result in any conversion before this point.
7807 If the precision is the same we must not risk widening. For
7808 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
7809 often have type "int", even though the C++ type for the field is
7810 "long long". If the value is being passed to a function
7811 expecting an "int", then no conversions will be required. But,
7812 if we call convert_bitfield_to_declared_type, the bitfield will
7813 be converted to "long long". */
7814 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
7816 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
7817 val
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
), val
);
7819 if (val
== error_mark_node
)
7821 /* Pass classes with copy ctors by invisible reference. */
7822 else if (TREE_ADDRESSABLE (type
))
7823 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
7824 else if (targetm
.calls
.promote_prototypes (NULL_TREE
)
7825 && INTEGRAL_TYPE_P (type
)
7826 && COMPLETE_TYPE_P (type
)
7827 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
7828 val
= cp_perform_integral_promotions (val
, complain
);
7829 if (complain
& tf_warning
)
7831 if (warn_suggest_attribute_format
)
7833 tree rhstype
= TREE_TYPE (val
);
7834 const enum tree_code coder
= TREE_CODE (rhstype
);
7835 const enum tree_code codel
= TREE_CODE (type
);
7836 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
7838 && check_missing_format_attribute (type
, rhstype
))
7839 warning (OPT_Wsuggest_attribute_format
,
7840 "argument of function call might be a candidate "
7841 "for a format attribute");
7843 maybe_warn_parm_abi (type
, cp_expr_loc_or_input_loc (val
));
7846 if (complain
& tf_warning
)
7847 warn_for_address_or_pointer_of_packed_member (type
, val
);
7852 /* Returns non-zero iff FN is a function with magic varargs, i.e. ones for
7853 which just decay_conversion or no conversions at all should be done.
7854 This is true for some builtins which don't act like normal functions.
7855 Return 2 if no conversions at all should be done, 1 if just
7856 decay_conversion. Return 3 for special treatment of the 3rd argument
7857 for __builtin_*_overflow_p. */
7860 magic_varargs_p (tree fn
)
7862 if (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
7863 switch (DECL_FUNCTION_CODE (fn
))
7865 case BUILT_IN_CLASSIFY_TYPE
:
7866 case BUILT_IN_CONSTANT_P
:
7867 case BUILT_IN_NEXT_ARG
:
7868 case BUILT_IN_VA_START
:
7871 case BUILT_IN_ADD_OVERFLOW_P
:
7872 case BUILT_IN_SUB_OVERFLOW_P
:
7873 case BUILT_IN_MUL_OVERFLOW_P
:
7877 return lookup_attribute ("type generic",
7878 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
7884 /* Returns the decl of the dispatcher function if FN is a function version. */
7887 get_function_version_dispatcher (tree fn
)
7889 tree dispatcher_decl
= NULL
;
7891 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
7892 && DECL_FUNCTION_VERSIONED (fn
));
7894 gcc_assert (targetm
.get_function_versions_dispatcher
);
7895 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
7897 if (dispatcher_decl
== NULL
)
7899 error_at (input_location
, "use of multiversioned function "
7900 "without a default");
7904 retrofit_lang_decl (dispatcher_decl
);
7905 gcc_assert (dispatcher_decl
!= NULL
);
7906 return dispatcher_decl
;
7909 /* fn is a function version dispatcher that is marked used. Mark all the
7910 semantically identical function versions it will dispatch as used. */
7913 mark_versions_used (tree fn
)
7915 struct cgraph_node
*node
;
7916 struct cgraph_function_version_info
*node_v
;
7917 struct cgraph_function_version_info
*it_v
;
7919 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
7921 node
= cgraph_node::get (fn
);
7925 gcc_assert (node
->dispatcher_function
);
7927 node_v
= node
->function_version ();
7931 /* All semantically identical versions are chained. Traverse and mark each
7932 one of them as used. */
7933 it_v
= node_v
->next
;
7934 while (it_v
!= NULL
)
7936 mark_used (it_v
->this_node
->decl
);
7941 /* Build a call to "the copy constructor" for the type of A, even if it
7942 wouldn't be selected by normal overload resolution. Used for
7946 call_copy_ctor (tree a
, tsubst_flags_t complain
)
7948 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
7949 tree binfo
= TYPE_BINFO (ctype
);
7950 tree copy
= get_copy_ctor (ctype
, complain
);
7951 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
7952 tree ob
= build_dummy_object (ctype
);
7953 releasing_vec
args (make_tree_vector_single (a
));
7954 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
7955 LOOKUP_NORMAL
, NULL
, complain
);
7959 /* Return true iff T refers to a base field. */
7962 is_base_field_ref (tree t
)
7965 if (TREE_CODE (t
) == ADDR_EXPR
)
7966 t
= TREE_OPERAND (t
, 0);
7967 if (TREE_CODE (t
) == COMPONENT_REF
)
7968 t
= TREE_OPERAND (t
, 1);
7969 if (TREE_CODE (t
) == FIELD_DECL
)
7970 return DECL_FIELD_IS_BASE (t
);
7974 /* We can't elide a copy from a function returning by value to a base
7975 subobject, as the callee might clobber tail padding. Return true iff this
7976 could be that case. */
7979 unsafe_copy_elision_p (tree target
, tree exp
)
7981 /* Copy elision only happens with a TARGET_EXPR. */
7982 if (TREE_CODE (exp
) != TARGET_EXPR
)
7984 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
7985 /* It's safe to elide the copy for a class with no tail padding. */
7986 if (tree_int_cst_equal (TYPE_SIZE (type
), CLASSTYPE_SIZE (type
)))
7988 /* It's safe to elide the copy if we aren't initializing a base object. */
7989 if (!is_base_field_ref (target
))
7991 tree init
= TARGET_EXPR_INITIAL (exp
);
7992 /* build_compound_expr pushes COMPOUND_EXPR inside TARGET_EXPR. */
7993 while (TREE_CODE (init
) == COMPOUND_EXPR
)
7994 init
= TREE_OPERAND (init
, 1);
7995 if (TREE_CODE (init
) == COND_EXPR
)
7997 /* We'll end up copying from each of the arms of the COND_EXPR directly
7998 into the target, so look at them. */
7999 if (tree op
= TREE_OPERAND (init
, 1))
8000 if (unsafe_copy_elision_p (target
, op
))
8002 return unsafe_copy_elision_p (target
, TREE_OPERAND (init
, 2));
8004 return (TREE_CODE (init
) == AGGR_INIT_EXPR
8005 && !AGGR_INIT_VIA_CTOR_P (init
));
8008 /* True iff C is a conversion that binds a reference to a prvalue. */
8011 conv_binds_ref_to_prvalue (conversion
*c
)
8013 if (c
->kind
!= ck_ref_bind
)
8015 if (c
->need_temporary_p
)
8018 c
= next_conversion (c
);
8020 if (c
->kind
== ck_rvalue
)
8022 if (c
->kind
== ck_user
&& !TYPE_REF_P (c
->type
))
8024 if (c
->kind
== ck_identity
&& c
->u
.expr
8025 && TREE_CODE (c
->u
.expr
) == TARGET_EXPR
)
8031 /* Call the trivial destructor for INSTANCE, which can be either an lvalue of
8032 class type or a pointer to class type. */
8035 build_trivial_dtor_call (tree instance
)
8037 gcc_assert (!is_dummy_object (instance
));
8039 if (!flag_lifetime_dse
)
8042 return fold_convert (void_type_node
, instance
);
8045 if (INDIRECT_TYPE_P (TREE_TYPE (instance
)))
8047 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (instance
))))
8049 instance
= cp_build_fold_indirect_ref (instance
);
8052 /* A trivial destructor should still clobber the object. */
8053 tree clobber
= build_clobber (TREE_TYPE (instance
));
8054 return build2 (MODIFY_EXPR
, void_type_node
,
8058 /* Subroutine of the various build_*_call functions. Overload resolution
8059 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
8060 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
8061 bitmask of various LOOKUP_* flags which apply to the call itself. */
8064 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
8067 const vec
<tree
, va_gc
> *args
= cand
->args
;
8068 tree first_arg
= cand
->first_arg
;
8069 conversion
**convs
= cand
->convs
;
8071 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
8076 unsigned int arg_index
= 0;
8080 bool already_used
= false;
8082 /* In a template, there is no need to perform all of the work that
8083 is normally done. We are only interested in the type of the call
8084 expression, i.e., the return type of the function. Any semantic
8085 errors will be deferred until the template is instantiated. */
8086 if (processing_template_decl
)
8090 const tree
*argarray
;
8093 if (undeduced_auto_decl (fn
))
8094 mark_used (fn
, complain
);
8096 /* Otherwise set TREE_USED for the benefit of -Wunused-function.
8100 return_type
= TREE_TYPE (TREE_TYPE (fn
));
8101 nargs
= vec_safe_length (args
);
8102 if (first_arg
== NULL_TREE
)
8103 argarray
= args
->address ();
8111 alcarray
= XALLOCAVEC (tree
, nargs
);
8112 alcarray
[0] = build_this (first_arg
);
8113 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
8114 alcarray
[ix
+ 1] = arg
;
8115 argarray
= alcarray
;
8118 addr
= build_addr_func (fn
, complain
);
8119 if (addr
== error_mark_node
)
8120 return error_mark_node
;
8121 expr
= build_call_array_loc (input_location
, return_type
,
8122 addr
, nargs
, argarray
);
8123 if (TREE_THIS_VOLATILE (fn
) && cfun
)
8124 current_function_returns_abnormally
= 1;
8125 return convert_from_reference (expr
);
8128 /* Give any warnings we noticed during overload resolution. */
8129 if (cand
->warnings
&& (complain
& tf_warning
))
8131 struct candidate_warning
*w
;
8132 for (w
= cand
->warnings
; w
; w
= w
->next
)
8133 joust (cand
, w
->loser
, 1, complain
);
8136 /* Core issue 2327: P0135 doesn't say how to handle the case where the
8137 argument to the copy constructor ends up being a prvalue after
8138 conversion. Let's do the normal processing, but pretend we aren't
8139 actually using the copy constructor. */
8140 bool force_elide
= false;
8141 if (cxx_dialect
>= cxx17
8142 && cand
->num_convs
== 1
8143 && DECL_COMPLETE_CONSTRUCTOR_P (fn
)
8144 && (DECL_COPY_CONSTRUCTOR_P (fn
)
8145 || DECL_MOVE_CONSTRUCTOR_P (fn
))
8146 && conv_binds_ref_to_prvalue (convs
[0]))
8149 goto not_really_used
;
8152 /* OK, we're actually calling this inherited constructor; set its deletedness
8153 appropriately. We can get away with doing this here because calling is
8154 the only way to refer to a constructor. */
8155 if (DECL_INHERITED_CTOR (fn
))
8156 deduce_inheriting_ctor (fn
);
8158 /* Make =delete work with SFINAE. */
8159 if (DECL_DELETED_FN (fn
))
8161 if (complain
& tf_error
)
8163 return error_mark_node
;
8166 if (DECL_FUNCTION_MEMBER_P (fn
))
8169 /* If FN is a template function, two cases must be considered.
8174 template <class T> void f();
8176 template <class T> struct B {
8180 struct C : A, B<int> {
8182 using B<int>::g; // #2
8185 In case #1 where `A::f' is a member template, DECL_ACCESS is
8186 recorded in the primary template but not in its specialization.
8187 We check access of FN using its primary template.
8189 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
8190 because it is a member of class template B, DECL_ACCESS is
8191 recorded in the specialization `B<int>::g'. We cannot use its
8192 primary template because `B<T>::g' and `B<int>::g' may have
8193 different access. */
8194 if (DECL_TEMPLATE_INFO (fn
)
8195 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
8196 access_fn
= DECL_TI_TEMPLATE (fn
);
8199 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
8201 return error_mark_node
;
8204 /* If we're checking for implicit delete, don't bother with argument
8206 if (flags
& LOOKUP_SPECULATIVE
)
8208 if (cand
->viable
== 1)
8210 else if (!(complain
& tf_error
))
8211 /* Reject bad conversions now. */
8212 return error_mark_node
;
8213 /* else continue to get conversion error. */
8218 /* N3276 magic doesn't apply to nested calls. */
8219 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
8220 complain
&= ~tf_decltype
;
8221 /* No-Cleanup doesn't apply to nested calls either. */
8222 tsubst_flags_t no_cleanup_complain
= complain
;
8223 complain
&= ~tf_no_cleanup
;
8225 /* Find maximum size of vector to hold converted arguments. */
8226 parmlen
= list_length (parm
);
8227 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
8228 if (parmlen
> nargs
)
8230 argarray
= XALLOCAVEC (tree
, nargs
);
8232 /* The implicit parameters to a constructor are not considered by overload
8233 resolution, and must be of the proper type. */
8234 if (DECL_CONSTRUCTOR_P (fn
))
8237 if (first_arg
!= NULL_TREE
)
8239 object_arg
= first_arg
;
8240 first_arg
= NULL_TREE
;
8244 object_arg
= (*args
)[arg_index
];
8247 argarray
[j
++] = build_this (object_arg
);
8248 parm
= TREE_CHAIN (parm
);
8249 /* We should never try to call the abstract constructor. */
8250 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
8252 if (DECL_HAS_VTT_PARM_P (fn
))
8254 argarray
[j
++] = (*args
)[arg_index
];
8256 parm
= TREE_CHAIN (parm
);
8259 if (flags
& LOOKUP_PREFER_RVALUE
)
8261 /* The implicit move specified in 15.8.3/3 fails "...if the type of
8262 the first parameter of the selected constructor is not an rvalue
8263 reference to the object's type (possibly cv-qualified)...." */
8264 gcc_assert (!(complain
& tf_error
));
8265 tree ptype
= convs
[0]->type
;
8266 if (!TYPE_REF_P (ptype
)
8267 || !TYPE_REF_IS_RVALUE (ptype
)
8268 || CONVERSION_RANK (convs
[0]) > cr_exact
)
8269 return error_mark_node
;
8272 /* Bypass access control for 'this' parameter. */
8273 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
8275 tree parmtype
= TREE_VALUE (parm
);
8276 tree arg
= build_this (first_arg
!= NULL_TREE
8278 : (*args
)[arg_index
]);
8279 tree argtype
= TREE_TYPE (arg
);
8283 if (arg
== error_mark_node
)
8284 return error_mark_node
;
8286 if (convs
[i
]->bad_p
)
8288 if (complain
& tf_error
)
8290 auto_diagnostic_group d
;
8291 if (permerror (input_location
, "passing %qT as %<this%> "
8292 "argument discards qualifiers",
8293 TREE_TYPE (argtype
)))
8294 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
8297 return error_mark_node
;
8300 /* Optimize away vtable lookup if we know that this
8301 function can't be overridden. We need to check if
8302 the context and the type where we found fn are the same,
8303 actually FN might be defined in a different class
8304 type because of a using-declaration. In this case, we
8305 do not want to perform a non-virtual call. Note that
8306 resolves_to_fixed_type_p checks CLASSTYPE_FINAL too. */
8307 if (DECL_FINAL_P (fn
)
8308 || (resolves_to_fixed_type_p (arg
, 0)
8309 && same_type_ignoring_top_level_qualifiers_p
8310 (DECL_CONTEXT (fn
), BINFO_TYPE (cand
->conversion_path
))))
8311 flags
|= LOOKUP_NONVIRTUAL
;
8313 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
8314 X is called for an object that is not of type X, or of a type
8315 derived from X, the behavior is undefined.
8317 So we can assume that anything passed as 'this' is non-null, and
8318 optimize accordingly. */
8319 gcc_assert (TYPE_PTR_P (parmtype
));
8320 /* Convert to the base in which the function was declared. */
8321 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
8322 converted_arg
= build_base_path (PLUS_EXPR
,
8324 cand
->conversion_path
,
8326 /* Check that the base class is accessible. */
8327 if (!accessible_base_p (TREE_TYPE (argtype
),
8328 BINFO_TYPE (cand
->conversion_path
), true))
8330 if (complain
& tf_error
)
8331 error ("%qT is not an accessible base of %qT",
8332 BINFO_TYPE (cand
->conversion_path
),
8333 TREE_TYPE (argtype
));
8335 return error_mark_node
;
8337 /* If fn was found by a using declaration, the conversion path
8338 will be to the derived class, not the base declaring fn. We
8339 must convert from derived to base. */
8340 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
8341 TREE_TYPE (parmtype
), ba_unique
,
8343 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
8344 base_binfo
, 1, complain
);
8346 argarray
[j
++] = converted_arg
;
8347 parm
= TREE_CHAIN (parm
);
8348 if (first_arg
!= NULL_TREE
)
8349 first_arg
= NULL_TREE
;
8356 gcc_assert (first_arg
== NULL_TREE
);
8357 for (; arg_index
< vec_safe_length (args
) && parm
;
8358 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
8360 tree type
= TREE_VALUE (parm
);
8361 tree arg
= (*args
)[arg_index
];
8362 bool conversion_warning
= true;
8366 /* If the argument is NULL and used to (implicitly) instantiate a
8367 template function (and bind one of the template arguments to
8368 the type of 'long int'), we don't want to warn about passing NULL
8369 to non-pointer argument.
8370 For example, if we have this template function:
8372 template<typename T> void func(T x) {}
8374 we want to warn (when -Wconversion is enabled) in this case:
8380 but not in this case:
8386 if (null_node_p (arg
)
8387 && DECL_TEMPLATE_INFO (fn
)
8388 && cand
->template_decl
8389 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
8390 conversion_warning
= false;
8392 /* Set user_conv_p on the argument conversions, so rvalue/base handling
8393 knows not to allow any more UDCs. This needs to happen after we
8394 process cand->warnings. */
8395 if (flags
& LOOKUP_NO_CONVERSION
)
8396 conv
->user_conv_p
= true;
8398 tsubst_flags_t arg_complain
= complain
;
8399 if (!conversion_warning
)
8400 arg_complain
&= ~tf_warning
;
8402 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
8404 val
= convert_for_arg_passing (type
, val
, arg_complain
);
8406 if (val
== error_mark_node
)
8407 return error_mark_node
;
8409 argarray
[j
++] = val
;
8412 /* Default arguments */
8413 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
8415 if (TREE_VALUE (parm
) == error_mark_node
)
8416 return error_mark_node
;
8417 val
= convert_default_arg (TREE_VALUE (parm
),
8418 TREE_PURPOSE (parm
),
8421 if (val
== error_mark_node
)
8422 return error_mark_node
;
8423 argarray
[j
++] = val
;
8427 int magic
= magic_varargs_p (fn
);
8428 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
8430 tree a
= (*args
)[arg_index
];
8431 if ((magic
== 3 && arg_index
== 2) || magic
== 2)
8433 /* Do no conversions for certain magic varargs. */
8434 a
= mark_type_use (a
);
8435 if (TREE_CODE (a
) == FUNCTION_DECL
&& reject_gcc_builtin (a
))
8436 return error_mark_node
;
8438 else if (magic
!= 0)
8439 /* For other magic varargs only do decay_conversion. */
8440 a
= decay_conversion (a
, complain
);
8441 else if (DECL_CONSTRUCTOR_P (fn
)
8442 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
8445 /* Avoid infinite recursion trying to call A(...). */
8446 if (complain
& tf_error
)
8447 /* Try to call the actual copy constructor for a good error. */
8448 call_copy_ctor (a
, complain
);
8449 return error_mark_node
;
8452 a
= convert_arg_to_ellipsis (a
, complain
);
8453 if (a
== error_mark_node
)
8454 return error_mark_node
;
8458 gcc_assert (j
<= nargs
);
8461 /* Avoid to do argument-transformation, if warnings for format, and for
8462 nonnull are disabled. Just in case that at least one of them is active
8463 the check_function_arguments function might warn about something. */
8465 bool warned_p
= false;
8468 || warn_suggest_attribute_format
8471 tree
*fargs
= (!nargs
? argarray
8472 : (tree
*) alloca (nargs
* sizeof (tree
)));
8473 for (j
= 0; j
< nargs
; j
++)
8475 /* For -Wformat undo the implicit passing by hidden reference
8476 done by convert_arg_to_ellipsis. */
8477 if (TREE_CODE (argarray
[j
]) == ADDR_EXPR
8478 && TYPE_REF_P (TREE_TYPE (argarray
[j
])))
8479 fargs
[j
] = TREE_OPERAND (argarray
[j
], 0);
8481 fargs
[j
] = argarray
[j
];
8484 warned_p
= check_function_arguments (input_location
, fn
, TREE_TYPE (fn
),
8485 nargs
, fargs
, NULL
);
8488 if (DECL_INHERITED_CTOR (fn
))
8490 /* Check for passing ellipsis arguments to an inherited constructor. We
8491 could handle this by open-coding the inherited constructor rather than
8492 defining it, but let's not bother now. */
8493 if (!cp_unevaluated_operand
8495 && cand
->convs
[cand
->num_convs
-1]->ellipsis_p
)
8497 if (complain
& tf_error
)
8499 sorry ("passing arguments to ellipsis of inherited constructor "
8501 inform (DECL_SOURCE_LOCATION (cand
->fn
), "declared here");
8503 return error_mark_node
;
8506 /* A base constructor inheriting from a virtual base doesn't get the
8507 inherited arguments, just this and __vtt. */
8508 if (ctor_omit_inherited_parms (fn
))
8512 /* Avoid actually calling copy constructors and copy assignment operators,
8515 if (! flag_elide_constructors
&& !force_elide
)
8516 /* Do things the hard way. */;
8517 else if (cand
->num_convs
== 1
8518 && (DECL_COPY_CONSTRUCTOR_P (fn
)
8519 || DECL_MOVE_CONSTRUCTOR_P (fn
))
8520 /* It's unsafe to elide the constructor when handling
8521 a noexcept-expression, it may evaluate to the wrong
8522 value (c++/53025). */
8523 && (force_elide
|| cp_noexcept_operand
== 0))
8526 tree arg
= argarray
[num_artificial_parms_for (fn
)];
8528 bool trivial
= trivial_fn_p (fn
);
8530 /* Pull out the real argument, disregarding const-correctness. */
8532 /* Strip the reference binding for the constructor parameter. */
8533 if (CONVERT_EXPR_P (targ
)
8534 && TYPE_REF_P (TREE_TYPE (targ
)))
8535 targ
= TREE_OPERAND (targ
, 0);
8536 /* But don't strip any other reference bindings; binding a temporary to a
8537 reference prevents copy elision. */
8538 while ((CONVERT_EXPR_P (targ
)
8539 && !TYPE_REF_P (TREE_TYPE (targ
)))
8540 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
8541 targ
= TREE_OPERAND (targ
, 0);
8542 if (TREE_CODE (targ
) == ADDR_EXPR
)
8544 targ
= TREE_OPERAND (targ
, 0);
8545 if (!same_type_ignoring_top_level_qualifiers_p
8546 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
8555 arg
= cp_build_fold_indirect_ref (arg
);
8557 /* In C++17 we shouldn't be copying a TARGET_EXPR except into a base
8559 if (CHECKING_P
&& cxx_dialect
>= cxx17
)
8560 gcc_assert (TREE_CODE (arg
) != TARGET_EXPR
8562 /* It's from binding the ref parm to a packed field. */
8563 || convs
[0]->need_temporary_p
8565 /* See unsafe_copy_elision_p. */
8566 || DECL_BASE_CONSTRUCTOR_P (fn
));
8569 bool unsafe
= unsafe_copy_elision_p (fa
, arg
);
8570 bool eliding_temp
= (TREE_CODE (arg
) == TARGET_EXPR
&& !unsafe
);
8572 /* [class.copy]: the copy constructor is implicitly defined even if the
8573 implementation elided its use. But don't warn about deprecation when
8574 eliding a temporary, as then no copy is actually performed. */
8575 warning_sentinel
s (warn_deprecated_copy
, eliding_temp
);
8577 /* The language says this isn't called. */;
8580 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
8581 return error_mark_node
;
8582 already_used
= true;
8585 cp_warn_deprecated_use (fn
, complain
);
8587 /* If we're creating a temp and we already have one, don't create a
8588 new one. If we're not creating a temp but we get one, use
8589 INIT_EXPR to collapse the temp into our target. Otherwise, if the
8590 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
8591 temp or an INIT_EXPR otherwise. */
8592 if (is_dummy_object (fa
))
8594 if (TREE_CODE (arg
) == TARGET_EXPR
)
8597 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
8599 else if ((trivial
|| TREE_CODE (arg
) == TARGET_EXPR
)
8602 tree to
= cp_stabilize_reference (cp_build_fold_indirect_ref (fa
));
8604 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
8608 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
8609 && DECL_OVERLOADED_OPERATOR_IS (fn
, NOP_EXPR
)
8610 && trivial_fn_p (fn
))
8612 tree to
= cp_stabilize_reference
8613 (cp_build_fold_indirect_ref (argarray
[0]));
8614 tree type
= TREE_TYPE (to
);
8615 tree as_base
= CLASSTYPE_AS_BASE (type
);
8616 tree arg
= argarray
[1];
8617 location_t loc
= cp_expr_loc_or_input_loc (arg
);
8619 if (is_really_empty_class (type
, /*ignore_vptr*/true))
8621 /* Avoid copying empty classes. */
8622 val
= build2 (COMPOUND_EXPR
, type
, arg
, to
);
8623 TREE_NO_WARNING (val
) = 1;
8625 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
8627 if (is_std_init_list (type
)
8628 && conv_binds_ref_to_prvalue (convs
[1]))
8629 warning_at (loc
, OPT_Winit_list_lifetime
,
8630 "assignment from temporary %<initializer_list%> does "
8631 "not extend the lifetime of the underlying array");
8632 arg
= cp_build_fold_indirect_ref (arg
);
8633 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
8637 /* We must only copy the non-tail padding parts. */
8639 tree array_type
, alias_set
;
8641 arg2
= TYPE_SIZE_UNIT (as_base
);
8642 arg0
= cp_build_addr_expr (to
, complain
);
8644 array_type
= build_array_type (unsigned_char_type_node
,
8646 (size_binop (MINUS_EXPR
,
8647 arg2
, size_int (1))));
8648 alias_set
= build_int_cst (build_pointer_type (type
), 0);
8649 t
= build2 (MODIFY_EXPR
, void_type_node
,
8650 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
8651 build2 (MEM_REF
, array_type
, arg
, alias_set
));
8652 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
8653 TREE_NO_WARNING (val
) = 1;
8656 cp_warn_deprecated_use (fn
, complain
);
8660 else if (trivial_fn_p (fn
))
8662 if (DECL_DESTRUCTOR_P (fn
))
8663 return build_trivial_dtor_call (argarray
[0]);
8664 else if (default_ctor_p (fn
))
8666 if (is_dummy_object (argarray
[0]))
8667 return force_target_expr (DECL_CONTEXT (fn
), void_node
,
8668 no_cleanup_complain
);
8670 return cp_build_fold_indirect_ref (argarray
[0]);
8674 gcc_assert (!force_elide
);
8677 && !mark_used (fn
, complain
))
8678 return error_mark_node
;
8680 /* Warn if the built-in writes to an object of a non-trivial type. */
8681 if (warn_class_memaccess
8682 && vec_safe_length (args
) >= 2
8683 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
8684 maybe_warn_class_memaccess (input_location
, fn
, args
);
8686 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
8689 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
8691 ba_any
, NULL
, complain
);
8692 gcc_assert (binfo
&& binfo
!= error_mark_node
);
8694 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
8696 if (TREE_SIDE_EFFECTS (argarray
[0]))
8697 argarray
[0] = save_expr (argarray
[0]);
8698 t
= build_pointer_type (TREE_TYPE (fn
));
8699 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
8704 fn
= build_addr_func (fn
, complain
);
8705 if (fn
== error_mark_node
)
8706 return error_mark_node
;
8709 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
8710 if (call
== error_mark_node
)
8712 if (cand
->flags
& LOOKUP_LIST_INIT_CTOR
)
8714 tree c
= extract_call_expr (call
);
8715 /* build_new_op_1 will clear this when appropriate. */
8716 CALL_EXPR_ORDERED_ARGS (c
) = true;
8720 tree c
= extract_call_expr (call
);
8721 if (TREE_CODE (c
) == CALL_EXPR
)
8722 TREE_NO_WARNING (c
) = 1;
8730 /* Return the DECL of the first non-static subobject of class TYPE
8731 that satisfies the predicate PRED or null if none can be found. */
8733 template <class Predicate
>
8735 first_non_static_field (tree type
, Predicate pred
)
8737 if (!type
|| !CLASS_TYPE_P (type
))
8740 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8742 if (TREE_CODE (field
) != FIELD_DECL
)
8744 if (TREE_STATIC (field
))
8752 for (tree base_binfo
, binfo
= TYPE_BINFO (type
);
8753 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
8755 tree base
= TREE_TYPE (base_binfo
);
8758 if (tree field
= first_non_static_field (base
, pred
))
8765 struct NonPublicField
8767 bool operator() (const_tree t
)
8769 return DECL_P (t
) && (TREE_PRIVATE (t
) || TREE_PROTECTED (t
));
8773 /* Return the DECL of the first non-public subobject of class TYPE
8774 or null if none can be found. */
8777 first_non_public_field (tree type
)
8779 return first_non_static_field (type
, NonPublicField ());
8782 struct NonTrivialField
8784 bool operator() (const_tree t
)
8786 return !trivial_type_p (DECL_P (t
) ? TREE_TYPE (t
) : t
);
8790 /* Return the DECL of the first non-trivial subobject of class TYPE
8791 or null if none can be found. */
8794 first_non_trivial_field (tree type
)
8796 return first_non_static_field (type
, NonTrivialField ());
8799 } /* unnamed namespace */
8801 /* Return true if all copy and move assignment operator overloads for
8802 class TYPE are trivial and at least one of them is not deleted and,
8803 when ACCESS is set, accessible. Return false otherwise. Set
8804 HASASSIGN to true when the TYPE has a (not necessarily trivial)
8805 copy or move assignment. */
8808 has_trivial_copy_assign_p (tree type
, bool access
, bool *hasassign
)
8810 tree fns
= get_class_binding (type
, assign_op_identifier
);
8811 bool all_trivial
= true;
8813 /* Iterate over overloads of the assignment operator, checking
8814 accessible copy assignments for triviality. */
8816 for (ovl_iterator
oi (fns
); oi
; ++oi
)
8820 /* Skip operators that aren't copy assignments. */
8824 bool accessible
= (!access
|| !(TREE_PRIVATE (f
) || TREE_PROTECTED (f
))
8825 || accessible_p (TYPE_BINFO (type
), f
, true));
8827 /* Skip template assignment operators and deleted functions. */
8828 if (TREE_CODE (f
) != FUNCTION_DECL
|| DECL_DELETED_FN (f
))
8834 if (!accessible
|| !trivial_fn_p (f
))
8835 all_trivial
= false;
8837 /* Break early when both properties have been determined. */
8838 if (*hasassign
&& !all_trivial
)
8842 /* Return true if they're all trivial and one of the expressions
8843 TYPE() = TYPE() or TYPE() = (TYPE&)() is valid. */
8844 tree ref
= cp_build_reference_type (type
, false);
8846 && (is_trivially_xible (MODIFY_EXPR
, type
, type
)
8847 || is_trivially_xible (MODIFY_EXPR
, type
, ref
)));
8850 /* Return true if all copy and move ctor overloads for class TYPE are
8851 trivial and at least one of them is not deleted and, when ACCESS is
8852 set, accessible. Return false otherwise. Set each element of HASCTOR[]
8853 to true when the TYPE has a (not necessarily trivial) default and copy
8854 (or move) ctor, respectively. */
8857 has_trivial_copy_p (tree type
, bool access
, bool hasctor
[2])
8859 tree fns
= get_class_binding (type
, complete_ctor_identifier
);
8860 bool all_trivial
= true;
8862 for (ovl_iterator
oi (fns
); oi
; ++oi
)
8866 /* Skip template constructors. */
8867 if (TREE_CODE (f
) != FUNCTION_DECL
)
8870 bool cpy_or_move_ctor_p
= copy_fn_p (f
);
8872 /* Skip ctors other than default, copy, and move. */
8873 if (!cpy_or_move_ctor_p
&& !default_ctor_p (f
))
8876 if (DECL_DELETED_FN (f
))
8879 bool accessible
= (!access
|| !(TREE_PRIVATE (f
) || TREE_PROTECTED (f
))
8880 || accessible_p (TYPE_BINFO (type
), f
, true));
8883 hasctor
[cpy_or_move_ctor_p
] = true;
8885 if (cpy_or_move_ctor_p
&& (!accessible
|| !trivial_fn_p (f
)))
8886 all_trivial
= false;
8888 /* Break early when both properties have been determined. */
8889 if (hasctor
[0] && hasctor
[1] && !all_trivial
)
8896 /* Issue a warning on a call to the built-in function FNDECL if it is
8897 a raw memory write whose destination is not an object of (something
8898 like) trivial or standard layout type with a non-deleted assignment
8899 and copy ctor. Detects const correctness violations, corrupting
8900 references, virtual table pointers, and bypassing non-trivial
8904 maybe_warn_class_memaccess (location_t loc
, tree fndecl
,
8905 const vec
<tree
, va_gc
> *args
)
8907 /* Except for bcopy where it's second, the destination pointer is
8908 the first argument for all functions handled here. Compute
8909 the index of the destination and source arguments. */
8910 unsigned dstidx
= DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_BCOPY
;
8911 unsigned srcidx
= !dstidx
;
8913 tree dest
= (*args
)[dstidx
];
8914 if (!TREE_TYPE (dest
) || !INDIRECT_TYPE_P (TREE_TYPE (dest
)))
8917 tree srctype
= NULL_TREE
;
8919 /* Determine the type of the pointed-to object and whether it's
8920 a complete class type. */
8921 tree desttype
= TREE_TYPE (TREE_TYPE (dest
));
8923 if (!desttype
|| !COMPLETE_TYPE_P (desttype
) || !CLASS_TYPE_P (desttype
))
8926 /* Check to see if the raw memory call is made by a non-static member
8927 function with THIS as the destination argument for the destination
8928 type. If so, and if the class has no non-trivial bases or members,
8929 be more permissive. */
8930 if (current_function_decl
8931 && DECL_NONSTATIC_MEMBER_FUNCTION_P (current_function_decl
)
8932 && is_this_parameter (tree_strip_nop_conversions (dest
)))
8934 tree ctx
= DECL_CONTEXT (current_function_decl
);
8935 bool special
= same_type_ignoring_top_level_qualifiers_p (ctx
, desttype
);
8936 tree binfo
= TYPE_BINFO (ctx
);
8939 && !BINFO_VTABLE (binfo
)
8940 && !first_non_trivial_field (desttype
))
8944 /* True if the class is trivial. */
8945 bool trivial
= trivial_type_p (desttype
);
8947 /* Set to true if DESTYPE has an accessible copy assignment. */
8948 bool hasassign
= false;
8949 /* True if all of the class' overloaded copy assignment operators
8950 are all trivial (and not deleted) and at least one of them is
8952 bool trivassign
= has_trivial_copy_assign_p (desttype
, true, &hasassign
);
8954 /* Set to true if DESTTYPE has an accessible default and copy ctor,
8956 bool hasctors
[2] = { false, false };
8958 /* True if all of the class' overloaded copy constructors are all
8959 trivial (and not deleted) and at least one of them is accessible. */
8960 bool trivcopy
= has_trivial_copy_p (desttype
, true, hasctors
);
8962 /* Set FLD to the first private/protected member of the class. */
8963 tree fld
= trivial
? first_non_public_field (desttype
) : NULL_TREE
;
8965 /* The warning format string. */
8966 const char *warnfmt
= NULL
;
8967 /* A suggested alternative to offer instead of the raw memory call.
8968 Empty string when none can be come up with. */
8969 const char *suggest
= "";
8970 bool warned
= false;
8972 switch (DECL_FUNCTION_CODE (fndecl
))
8974 case BUILT_IN_MEMSET
:
8975 if (!integer_zerop (maybe_constant_value ((*args
)[1])))
8977 /* Diagnose setting non-copy-assignable or non-trivial types,
8978 or types with a private member, to (potentially) non-zero
8979 bytes. Since the value of the bytes being written is unknown,
8980 suggest using assignment instead (if one exists). Also warn
8981 for writes into objects for which zero-initialization doesn't
8982 mean all bits clear (pointer-to-member data, where null is all
8983 bits set). Since the value being written is (most likely)
8984 non-zero, simply suggest assignment (but not copy assignment). */
8985 suggest
= "; use assignment instead";
8987 warnfmt
= G_("%qD writing to an object of type %#qT with "
8988 "no trivial copy-assignment");
8990 warnfmt
= G_("%qD writing to an object of non-trivial type %#qT%s");
8993 const char *access
= TREE_PRIVATE (fld
) ? "private" : "protected";
8994 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
8995 "%qD writing to an object of type %#qT with "
8997 fndecl
, desttype
, access
, fld
);
8999 else if (!zero_init_p (desttype
))
9000 warnfmt
= G_("%qD writing to an object of type %#qT containing "
9001 "a pointer to data member%s");
9007 case BUILT_IN_BZERO
:
9008 /* Similarly to the above, diagnose clearing non-trivial or non-
9009 standard layout objects, or objects of types with no assignmenmt.
9010 Since the value being written is known to be zero, suggest either
9011 copy assignment, copy ctor, or default ctor as an alternative,
9012 depending on what's available. */
9014 if (hasassign
&& hasctors
[0])
9015 suggest
= G_("; use assignment or value-initialization instead");
9017 suggest
= G_("; use assignment instead");
9018 else if (hasctors
[0])
9019 suggest
= G_("; use value-initialization instead");
9022 warnfmt
= G_("%qD clearing an object of type %#qT with "
9023 "no trivial copy-assignment%s");
9025 warnfmt
= G_("%qD clearing an object of non-trivial type %#qT%s");
9026 else if (!zero_init_p (desttype
))
9027 warnfmt
= G_("%qD clearing an object of type %#qT containing "
9028 "a pointer-to-member%s");
9031 case BUILT_IN_BCOPY
:
9032 case BUILT_IN_MEMCPY
:
9033 case BUILT_IN_MEMMOVE
:
9034 case BUILT_IN_MEMPCPY
:
9035 /* Determine the type of the source object. */
9036 srctype
= TREE_TYPE ((*args
)[srcidx
]);
9037 if (!srctype
|| !INDIRECT_TYPE_P (srctype
))
9038 srctype
= void_type_node
;
9040 srctype
= TREE_TYPE (srctype
);
9042 /* Since it's impossible to determine wheter the byte copy is
9043 being used in place of assignment to an existing object or
9044 as a substitute for initialization, assume it's the former.
9045 Determine the best alternative to use instead depending on
9046 what's not deleted. */
9047 if (hasassign
&& hasctors
[1])
9048 suggest
= G_("; use copy-assignment or copy-initialization instead");
9050 suggest
= G_("; use copy-assignment instead");
9051 else if (hasctors
[1])
9052 suggest
= G_("; use copy-initialization instead");
9055 warnfmt
= G_("%qD writing to an object of type %#qT with no trivial "
9056 "copy-assignment%s");
9057 else if (!trivially_copyable_p (desttype
))
9058 warnfmt
= G_("%qD writing to an object of non-trivially copyable "
9061 warnfmt
= G_("%qD writing to an object with a deleted copy constructor");
9064 && !VOID_TYPE_P (srctype
)
9065 && !char_type_p (TYPE_MAIN_VARIANT (srctype
))
9066 && !same_type_ignoring_top_level_qualifiers_p (desttype
,
9069 /* Warn when copying into a non-trivial object from an object
9070 of a different type other than void or char. */
9071 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
9072 "%qD copying an object of non-trivial type "
9073 "%#qT from an array of %#qT",
9074 fndecl
, desttype
, srctype
);
9077 && !VOID_TYPE_P (srctype
)
9078 && !char_type_p (TYPE_MAIN_VARIANT (srctype
))
9079 && !same_type_ignoring_top_level_qualifiers_p (desttype
,
9082 const char *access
= TREE_PRIVATE (fld
) ? "private" : "protected";
9083 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
9084 "%qD copying an object of type %#qT with "
9085 "%qs member %qD from an array of %#qT; use "
9086 "assignment or copy-initialization instead",
9087 fndecl
, desttype
, access
, fld
, srctype
);
9089 else if (!trivial
&& vec_safe_length (args
) > 2)
9091 tree sz
= maybe_constant_value ((*args
)[2]);
9092 if (!tree_fits_uhwi_p (sz
))
9095 /* Finally, warn on partial copies. */
9096 unsigned HOST_WIDE_INT typesize
9097 = tree_to_uhwi (TYPE_SIZE_UNIT (desttype
));
9098 if (unsigned HOST_WIDE_INT partial
= tree_to_uhwi (sz
) % typesize
)
9099 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
9100 (typesize
- partial
> 1
9101 ? G_("%qD writing to an object of "
9102 "a non-trivial type %#qT leaves %wu "
9104 : G_("%qD writing to an object of "
9105 "a non-trivial type %#qT leaves %wu "
9107 fndecl
, desttype
, typesize
- partial
);
9111 case BUILT_IN_REALLOC
:
9113 if (!trivially_copyable_p (desttype
))
9114 warnfmt
= G_("%qD moving an object of non-trivially copyable type "
9115 "%#qT; use %<new%> and %<delete%> instead");
9117 warnfmt
= G_("%qD moving an object of type %#qT with deleted copy "
9118 "constructor; use %<new%> and %<delete%> instead");
9119 else if (!get_dtor (desttype
, tf_none
))
9120 warnfmt
= G_("%qD moving an object of type %#qT with deleted "
9124 tree sz
= maybe_constant_value ((*args
)[1]);
9125 if (TREE_CODE (sz
) == INTEGER_CST
9126 && tree_int_cst_lt (sz
, TYPE_SIZE_UNIT (desttype
)))
9127 /* Finally, warn on reallocation into insufficient space. */
9128 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
9129 "%qD moving an object of non-trivial type "
9130 "%#qT and size %E into a region of size %E",
9131 fndecl
, desttype
, TYPE_SIZE_UNIT (desttype
),
9143 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
9144 warnfmt
, fndecl
, desttype
, suggest
);
9146 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
9147 warnfmt
, fndecl
, desttype
);
9151 inform (location_of (desttype
), "%#qT declared here", desttype
);
9154 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
9155 If FN is the result of resolving an overloaded target built-in,
9156 ORIG_FNDECL is the original function decl, otherwise it is null.
9157 This function performs no overload resolution, conversion, or other
9158 high-level operations. */
9161 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
9162 tsubst_flags_t complain
, tree orig_fndecl
)
9166 /* Remember roughly where this call is. */
9167 location_t loc
= cp_expr_loc_or_input_loc (fn
);
9168 fn
= build_call_a (fn
, nargs
, argarray
);
9169 SET_EXPR_LOCATION (fn
, loc
);
9171 fndecl
= get_callee_fndecl (fn
);
9173 orig_fndecl
= fndecl
;
9175 /* Check that arguments to builtin functions match the expectations. */
9177 && !processing_template_decl
9178 && fndecl_built_in_p (fndecl
))
9182 /* We need to take care that values to BUILT_IN_NORMAL
9184 for (i
= 0; i
< nargs
; i
++)
9185 argarray
[i
] = maybe_constant_value (argarray
[i
]);
9187 if (!check_builtin_function_arguments (EXPR_LOCATION (fn
), vNULL
, fndecl
,
9188 orig_fndecl
, nargs
, argarray
))
9189 return error_mark_node
;
9192 if (VOID_TYPE_P (TREE_TYPE (fn
)))
9195 /* 5.2.2/11: If a function call is a prvalue of object type: if the
9196 function call is either the operand of a decltype-specifier or the
9197 right operand of a comma operator that is the operand of a
9198 decltype-specifier, a temporary object is not introduced for the
9199 prvalue. The type of the prvalue may be incomplete. */
9200 if (!(complain
& tf_decltype
))
9202 fn
= require_complete_type_sfinae (fn
, complain
);
9203 if (fn
== error_mark_node
)
9204 return error_mark_node
;
9206 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
9208 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
9209 maybe_warn_parm_abi (TREE_TYPE (fn
), loc
);
9212 return convert_from_reference (fn
);
9215 /* Returns the value to use for the in-charge parameter when making a
9216 call to a function with the indicated NAME.
9218 FIXME:Can't we find a neater way to do this mapping? */
9221 in_charge_arg_for_name (tree name
)
9223 if (IDENTIFIER_CTOR_P (name
))
9225 if (name
== complete_ctor_identifier
)
9226 return integer_one_node
;
9227 gcc_checking_assert (name
== base_ctor_identifier
);
9231 if (name
== complete_dtor_identifier
)
9232 return integer_two_node
;
9233 else if (name
== deleting_dtor_identifier
)
9234 return integer_three_node
;
9235 gcc_checking_assert (name
== base_dtor_identifier
);
9238 return integer_zero_node
;
9241 /* We've built up a constructor call RET. Complain if it delegates to the
9242 constructor we're currently compiling. */
9245 check_self_delegation (tree ret
)
9247 if (TREE_CODE (ret
) == TARGET_EXPR
)
9248 ret
= TARGET_EXPR_INITIAL (ret
);
9249 tree fn
= cp_get_callee_fndecl_nofold (ret
);
9250 if (fn
&& DECL_ABSTRACT_ORIGIN (fn
) == current_function_decl
)
9251 error ("constructor delegates to itself");
9254 /* Build a call to a constructor, destructor, or an assignment
9255 operator for INSTANCE, an expression with class type. NAME
9256 indicates the special member function to call; *ARGS are the
9257 arguments. ARGS may be NULL. This may change ARGS. BINFO
9258 indicates the base of INSTANCE that is to be passed as the `this'
9259 parameter to the member function called.
9261 FLAGS are the LOOKUP_* flags to use when processing the call.
9263 If NAME indicates a complete object constructor, INSTANCE may be
9264 NULL_TREE. In this case, the caller will call build_cplus_new to
9265 store the newly constructed object into a VAR_DECL. */
9268 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
9269 tree binfo
, int flags
, tsubst_flags_t complain
)
9272 /* The type of the subobject to be constructed or destroyed. */
9274 vec
<tree
, va_gc
> *allocated
= NULL
;
9277 gcc_assert (IDENTIFIER_CDTOR_P (name
) || name
== assign_op_identifier
);
9279 if (error_operand_p (instance
))
9280 return error_mark_node
;
9282 if (IDENTIFIER_DTOR_P (name
))
9284 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
9285 if (!type_build_dtor_call (TREE_TYPE (instance
)))
9286 /* Shortcut to avoid lazy destructor declaration. */
9287 return build_trivial_dtor_call (instance
);
9292 /* Resolve the name. */
9293 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
9294 return error_mark_node
;
9296 binfo
= TYPE_BINFO (binfo
);
9299 gcc_assert (binfo
!= NULL_TREE
);
9301 class_type
= BINFO_TYPE (binfo
);
9303 /* Handle the special case where INSTANCE is NULL_TREE. */
9304 if (name
== complete_ctor_identifier
&& !instance
)
9305 instance
= build_dummy_object (class_type
);
9308 /* Convert to the base class, if necessary. */
9309 if (!same_type_ignoring_top_level_qualifiers_p
9310 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
9312 if (IDENTIFIER_CDTOR_P (name
))
9313 /* For constructors and destructors, either the base is
9314 non-virtual, or it is virtual but we are doing the
9315 conversion from a constructor or destructor for the
9316 complete object. In either case, we can convert
9318 instance
= convert_to_base_statically (instance
, binfo
);
9321 /* However, for assignment operators, we must convert
9322 dynamically if the base is virtual. */
9323 gcc_checking_assert (name
== assign_op_identifier
);
9324 instance
= build_base_path (PLUS_EXPR
, instance
,
9325 binfo
, /*nonnull=*/1, complain
);
9330 gcc_assert (instance
!= NULL_TREE
);
9332 /* In C++17, "If the initializer expression is a prvalue and the
9333 cv-unqualified version of the source type is the same class as the class
9334 of the destination, the initializer expression is used to initialize the
9335 destination object." Handle that here to avoid doing overload
9337 if (cxx_dialect
>= cxx17
9338 && args
&& vec_safe_length (*args
) == 1
9339 && name
== complete_ctor_identifier
)
9341 tree arg
= (**args
)[0];
9343 if (BRACE_ENCLOSED_INITIALIZER_P (arg
)
9344 && !TYPE_HAS_LIST_CTOR (class_type
)
9345 && CONSTRUCTOR_NELTS (arg
) == 1)
9346 arg
= CONSTRUCTOR_ELT (arg
, 0)->value
;
9348 if ((TREE_CODE (arg
) == TARGET_EXPR
9349 || TREE_CODE (arg
) == CONSTRUCTOR
)
9350 && (same_type_ignoring_top_level_qualifiers_p
9351 (class_type
, TREE_TYPE (arg
))))
9353 if (is_dummy_object (instance
))
9355 else if (TREE_CODE (arg
) == TARGET_EXPR
)
9356 TARGET_EXPR_DIRECT_INIT_P (arg
) = true;
9358 if ((complain
& tf_error
)
9359 && (flags
& LOOKUP_DELEGATING_CONS
))
9360 check_self_delegation (arg
);
9361 /* Avoid change of behavior on Wunused-var-2.C. */
9362 instance
= mark_lvalue_use (instance
);
9363 return build2 (INIT_EXPR
, class_type
, instance
, arg
);
9367 fns
= lookup_fnfields (binfo
, name
, 1);
9369 /* When making a call to a constructor or destructor for a subobject
9370 that uses virtual base classes, pass down a pointer to a VTT for
9372 if ((name
== base_ctor_identifier
9373 || name
== base_dtor_identifier
)
9374 && CLASSTYPE_VBASECLASSES (class_type
))
9379 /* If the current function is a complete object constructor
9380 or destructor, then we fetch the VTT directly.
9381 Otherwise, we look it up using the VTT we were given. */
9382 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
9383 vtt
= decay_conversion (vtt
, complain
);
9384 if (vtt
== error_mark_node
)
9385 return error_mark_node
;
9386 vtt
= build_if_in_charge (vtt
, current_vtt_parm
);
9387 if (BINFO_SUBVTT_INDEX (binfo
))
9388 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
9394 allocated
= make_tree_vector ();
9398 vec_safe_insert (*args
, 0, sub_vtt
);
9401 ret
= build_new_method_call (instance
, fns
, args
,
9402 TYPE_BINFO (BINFO_TYPE (binfo
)),
9406 if (allocated
!= NULL
)
9407 release_tree_vector (allocated
);
9409 if ((complain
& tf_error
)
9410 && (flags
& LOOKUP_DELEGATING_CONS
)
9411 && name
== complete_ctor_identifier
)
9412 check_self_delegation (ret
);
9417 /* Return the NAME, as a C string. The NAME indicates a function that
9418 is a member of TYPE. *FREE_P is set to true if the caller must
9419 free the memory returned.
9421 Rather than go through all of this, we should simply set the names
9422 of constructors and destructors appropriately, and dispense with
9423 ctor_identifier, dtor_identifier, etc. */
9426 name_as_c_string (tree name
, tree type
, bool *free_p
)
9428 const char *pretty_name
;
9430 /* Assume that we will not allocate memory. */
9432 /* Constructors and destructors are special. */
9433 if (IDENTIFIER_CDTOR_P (name
))
9436 = identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
)));
9437 /* For a destructor, add the '~'. */
9438 if (IDENTIFIER_DTOR_P (name
))
9440 pretty_name
= concat ("~", pretty_name
, NULL
);
9441 /* Remember that we need to free the memory allocated. */
9445 else if (IDENTIFIER_CONV_OP_P (name
))
9447 pretty_name
= concat ("operator ",
9448 type_as_string_translate (TREE_TYPE (name
),
9449 TFF_PLAIN_IDENTIFIER
),
9451 /* Remember that we need to free the memory allocated. */
9455 pretty_name
= identifier_to_locale (IDENTIFIER_POINTER (name
));
9457 return CONST_CAST (char *, pretty_name
);
9460 /* If CANDIDATES contains exactly one candidate, return it, otherwise
9463 static z_candidate
*
9464 single_z_candidate (z_candidate
*candidates
)
9466 if (candidates
== NULL
)
9469 if (candidates
->next
)
9475 /* If CANDIDATE is invalid due to a bad argument type, return the
9476 pertinent conversion_info.
9478 Otherwise, return NULL. */
9480 static const conversion_info
*
9481 maybe_get_bad_conversion_for_unmatched_call (const z_candidate
*candidate
)
9483 /* Must be an rr_arg_conversion or rr_bad_arg_conversion. */
9484 rejection_reason
*r
= candidate
->reason
;
9494 case rr_arg_conversion
:
9495 return &r
->u
.conversion
;
9497 case rr_bad_arg_conversion
:
9498 return &r
->u
.bad_conversion
;
9502 /* Issue an error and note complaining about a bad argument type at a
9503 callsite with a single candidate FNDECL.
9505 ARG_LOC is the location of the argument (or UNKNOWN_LOCATION, in which
9506 case input_location is used).
9507 FROM_TYPE is the type of the actual argument; TO_TYPE is the type of
9508 the formal parameter. */
9511 complain_about_bad_argument (location_t arg_loc
,
9512 tree from_type
, tree to_type
,
9513 tree fndecl
, int parmnum
)
9515 auto_diagnostic_group d
;
9516 range_label_for_type_mismatch
rhs_label (from_type
, to_type
);
9517 range_label
*label
= &rhs_label
;
9518 if (arg_loc
== UNKNOWN_LOCATION
)
9520 arg_loc
= input_location
;
9523 gcc_rich_location
richloc (arg_loc
, label
);
9525 "cannot convert %qH to %qI",
9526 from_type
, to_type
);
9527 maybe_inform_about_fndecl_for_bogus_argument_init (fndecl
,
9531 /* Subroutine of build_new_method_call_1, for where there are no viable
9532 candidates for the call. */
9535 complain_about_no_candidates_for_method_call (tree instance
,
9536 z_candidate
*candidates
,
9537 tree explicit_targs
,
9539 tree optype
, tree name
,
9540 bool skip_first_for_error
,
9541 vec
<tree
, va_gc
> *user_args
)
9543 auto_diagnostic_group d
;
9544 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
9545 cxx_incomplete_type_error (instance
, basetype
);
9547 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
9548 basetype
, optype
, build_tree_list_vec (user_args
),
9549 TREE_TYPE (instance
));
9552 /* Special-case for when there's a single candidate that's failing
9553 due to a bad argument type. */
9554 if (z_candidate
*candidate
= single_z_candidate (candidates
))
9555 if (const conversion_info
*conv
9556 = maybe_get_bad_conversion_for_unmatched_call (candidate
))
9558 complain_about_bad_argument (conv
->loc
,
9559 conv
->from
, conv
->to_type
,
9560 candidate
->fn
, conv
->n_arg
);
9564 tree arglist
= build_tree_list_vec (user_args
);
9565 tree errname
= name
;
9566 bool twiddle
= false;
9567 if (IDENTIFIER_CDTOR_P (errname
))
9569 twiddle
= IDENTIFIER_DTOR_P (errname
);
9570 errname
= constructor_name (basetype
);
9573 errname
= lookup_template_function (errname
, explicit_targs
);
9574 if (skip_first_for_error
)
9575 arglist
= TREE_CHAIN (arglist
);
9576 error ("no matching function for call to %<%T::%s%E(%A)%#V%>",
9577 basetype
, &"~"[!twiddle
], errname
, arglist
,
9578 TREE_TYPE (instance
));
9580 print_z_candidates (location_of (name
), candidates
);
9583 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
9584 be set, upon return, to the function called. ARGS may be NULL.
9585 This may change ARGS. */
9588 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
9589 tree conversion_path
, int flags
,
9590 tree
*fn_p
, tsubst_flags_t complain
)
9592 struct z_candidate
*candidates
= 0, *cand
;
9593 tree explicit_targs
= NULL_TREE
;
9594 tree basetype
= NULL_TREE
;
9597 tree first_mem_arg
= NULL_TREE
;
9599 bool skip_first_for_error
;
9600 vec
<tree
, va_gc
> *user_args
;
9603 int template_only
= 0;
9607 vec
<tree
, va_gc
> *orig_args
= NULL
;
9610 gcc_assert (instance
!= NULL_TREE
);
9612 /* We don't know what function we're going to call, yet. */
9616 if (error_operand_p (instance
)
9617 || !fns
|| error_operand_p (fns
))
9618 return error_mark_node
;
9620 if (!BASELINK_P (fns
))
9622 if (complain
& tf_error
)
9623 error ("call to non-function %qD", fns
);
9624 return error_mark_node
;
9627 orig_instance
= instance
;
9630 /* Dismantle the baselink to collect all the information we need. */
9631 if (!conversion_path
)
9632 conversion_path
= BASELINK_BINFO (fns
);
9633 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
9634 optype
= BASELINK_OPTYPE (fns
);
9635 fns
= BASELINK_FUNCTIONS (fns
);
9636 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
9638 explicit_targs
= TREE_OPERAND (fns
, 1);
9639 fns
= TREE_OPERAND (fns
, 0);
9642 gcc_assert (OVL_P (fns
));
9643 fn
= OVL_FIRST (fns
);
9644 name
= DECL_NAME (fn
);
9646 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
9647 gcc_assert (CLASS_TYPE_P (basetype
));
9649 user_args
= args
== NULL
? NULL
: *args
;
9650 /* Under DR 147 A::A() is an invalid constructor call,
9651 not a functional cast. */
9652 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
9654 if (! (complain
& tf_error
))
9655 return error_mark_node
;
9657 basetype
= DECL_CONTEXT (fn
);
9658 name
= constructor_name (basetype
);
9659 auto_diagnostic_group d
;
9660 if (permerror (input_location
,
9661 "cannot call constructor %<%T::%D%> directly",
9663 inform (input_location
, "for a function-style cast, remove the "
9664 "redundant %<::%D%>", name
);
9665 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
9670 if (processing_template_decl
)
9672 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
9673 instance
= build_non_dependent_expr (instance
);
9675 make_args_non_dependent (*args
);
9678 /* Process the argument list. */
9679 if (args
!= NULL
&& *args
!= NULL
)
9681 *args
= resolve_args (*args
, complain
);
9683 return error_mark_node
;
9687 /* Consider the object argument to be used even if we end up selecting a
9688 static member function. */
9689 instance
= mark_type_use (instance
);
9691 /* Figure out whether to skip the first argument for the error
9692 message we will display to users if an error occurs. We don't
9693 want to display any compiler-generated arguments. The "this"
9694 pointer hasn't been added yet. However, we must remove the VTT
9695 pointer if this is a call to a base-class constructor or
9697 skip_first_for_error
= false;
9698 if (IDENTIFIER_CDTOR_P (name
))
9700 /* Callers should explicitly indicate whether they want to ctor
9701 the complete object or just the part without virtual bases. */
9702 gcc_assert (name
!= ctor_identifier
);
9704 /* Remove the VTT pointer, if present. */
9705 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
9706 && CLASSTYPE_VBASECLASSES (basetype
))
9707 skip_first_for_error
= true;
9709 /* It's OK to call destructors and constructors on cv-qualified
9710 objects. Therefore, convert the INSTANCE to the unqualified
9711 type, if necessary. */
9712 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
9714 instance
= build_this (instance
);
9715 instance
= build_nop (build_pointer_type (basetype
), instance
);
9716 instance
= build_fold_indirect_ref (instance
);
9720 gcc_assert (!DECL_DESTRUCTOR_P (fn
) && !DECL_CONSTRUCTOR_P (fn
));
9722 /* For the overload resolution we need to find the actual `this`
9723 that would be captured if the call turns out to be to a
9724 non-static member function. Do not actually capture it at this
9726 if (DECL_CONSTRUCTOR_P (fn
))
9727 /* Constructors don't use the enclosing 'this'. */
9728 first_mem_arg
= instance
;
9730 first_mem_arg
= maybe_resolve_dummy (instance
, false);
9732 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9733 p
= conversion_obstack_alloc (0);
9735 /* The number of arguments artificial parms in ARGS; we subtract one because
9736 there's no 'this' in ARGS. */
9737 unsigned skip
= num_artificial_parms_for (fn
) - 1;
9739 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
9740 initializer, not T({ }). */
9741 if (DECL_CONSTRUCTOR_P (fn
)
9742 && vec_safe_length (user_args
) > skip
9743 && DIRECT_LIST_INIT_P ((*user_args
)[skip
]))
9745 tree init_list
= (*user_args
)[skip
];
9746 tree init
= NULL_TREE
;
9748 gcc_assert (user_args
->length () == skip
+ 1
9749 && !(flags
& LOOKUP_ONLYCONVERTING
));
9751 /* If the initializer list has no elements and T is a class type with
9752 a default constructor, the object is value-initialized. Handle
9753 this here so we don't need to handle it wherever we use
9754 build_special_member_call. */
9755 if (CONSTRUCTOR_NELTS (init_list
) == 0
9756 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
9757 /* For a user-provided default constructor, use the normal
9758 mechanisms so that protected access works. */
9759 && type_has_non_user_provided_default_constructor (basetype
)
9760 && !processing_template_decl
)
9761 init
= build_value_init (basetype
, complain
);
9763 /* If BASETYPE is an aggregate, we need to do aggregate
9765 else if (CP_AGGREGATE_TYPE_P (basetype
))
9767 init
= reshape_init (basetype
, init_list
, complain
);
9768 init
= digest_init (basetype
, init
, complain
);
9773 if (is_dummy_object (instance
))
9774 return get_target_expr_sfinae (init
, complain
);
9775 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
9776 TREE_SIDE_EFFECTS (init
) = true;
9780 /* Otherwise go ahead with overload resolution. */
9781 add_list_candidates (fns
, first_mem_arg
, user_args
,
9782 basetype
, explicit_targs
, template_only
,
9783 conversion_path
, access_binfo
, flags
,
9784 &candidates
, complain
);
9787 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
9788 explicit_targs
, template_only
, conversion_path
,
9789 access_binfo
, flags
, &candidates
, complain
);
9791 any_viable_p
= false;
9792 candidates
= splice_viable (candidates
, false, &any_viable_p
);
9796 if (complain
& tf_error
)
9797 complain_about_no_candidates_for_method_call (instance
, candidates
,
9798 explicit_targs
, basetype
,
9800 skip_first_for_error
,
9802 call
= error_mark_node
;
9806 cand
= tourney (candidates
, complain
);
9813 if (complain
& tf_error
)
9815 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
9816 arglist
= build_tree_list_vec (user_args
);
9817 if (skip_first_for_error
)
9818 arglist
= TREE_CHAIN (arglist
);
9819 auto_diagnostic_group d
;
9820 if (!any_strictly_viable (candidates
))
9821 error ("no matching function for call to %<%s(%A)%>",
9822 pretty_name
, arglist
);
9824 error ("call of overloaded %<%s(%A)%> is ambiguous",
9825 pretty_name
, arglist
);
9826 print_z_candidates (location_of (name
), candidates
);
9830 call
= error_mark_node
;
9837 if (!(flags
& LOOKUP_NONVIRTUAL
)
9838 && DECL_PURE_VIRTUAL_P (fn
)
9839 && instance
== current_class_ref
9840 && (complain
& tf_warning
))
9842 /* This is not an error, it is runtime undefined
9844 if (!current_function_decl
)
9845 warning (0, "pure virtual %q#D called from "
9846 "non-static data member initializer", fn
);
9847 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
9848 || DECL_DESTRUCTOR_P (current_function_decl
))
9849 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
9850 ? G_("pure virtual %q#D called from constructor")
9851 : G_("pure virtual %q#D called from destructor")),
9855 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
9856 && !DECL_CONSTRUCTOR_P (fn
)
9857 && is_dummy_object (instance
))
9859 instance
= maybe_resolve_dummy (instance
, true);
9860 if (instance
== error_mark_node
)
9861 call
= error_mark_node
;
9862 else if (!is_dummy_object (instance
))
9864 /* We captured 'this' in the current lambda now that
9865 we know we really need it. */
9866 cand
->first_arg
= instance
;
9868 else if (any_dependent_bases_p ())
9869 /* We can't tell until instantiation time whether we can use
9870 *this as the implicit object argument. */;
9873 if (complain
& tf_error
)
9874 error ("cannot call member function %qD without object",
9876 call
= error_mark_node
;
9880 if (call
!= error_mark_node
)
9883 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
9884 /* Now we know what function is being called. */
9887 /* Build the actual CALL_EXPR. */
9888 call
= build_over_call (cand
, flags
, complain
);
9889 /* In an expression of the form `a->f()' where `f' turns
9890 out to be a static member function, `a' is
9891 none-the-less evaluated. */
9892 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
9893 && !is_dummy_object (instance
)
9894 && TREE_SIDE_EFFECTS (instance
))
9896 /* But avoid the implicit lvalue-rvalue conversion when 'a'
9899 if (TREE_THIS_VOLATILE (a
))
9901 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
), a
, call
);
9903 else if (call
!= error_mark_node
9904 && DECL_DESTRUCTOR_P (cand
->fn
)
9905 && !VOID_TYPE_P (TREE_TYPE (call
)))
9906 /* An explicit call of the form "x->~X()" has type
9907 "void". However, on platforms where destructors
9908 return "this" (i.e., those where
9909 targetm.cxx.cdtor_returns_this is true), such calls
9910 will appear to have a return value of pointer type
9911 to the low-level call machinery. We do not want to
9912 change the low-level machinery, since we want to be
9913 able to optimize "delete f()" on such platforms as
9914 "operator delete(~X(f()))" (rather than generating
9915 "t = f(), ~X(t), operator delete (t)"). */
9916 call
= build_nop (void_type_node
, call
);
9921 if (processing_template_decl
&& call
!= error_mark_node
)
9923 bool cast_to_void
= false;
9925 if (TREE_CODE (call
) == COMPOUND_EXPR
)
9926 call
= TREE_OPERAND (call
, 1);
9927 else if (TREE_CODE (call
) == NOP_EXPR
)
9929 cast_to_void
= true;
9930 call
= TREE_OPERAND (call
, 0);
9932 if (INDIRECT_REF_P (call
))
9933 call
= TREE_OPERAND (call
, 0);
9934 call
= (build_min_non_dep_call_vec
9936 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
9937 orig_instance
, orig_fns
, NULL_TREE
),
9939 SET_EXPR_LOCATION (call
, input_location
);
9940 call
= convert_from_reference (call
);
9942 call
= build_nop (void_type_node
, call
);
9945 /* Free all the conversions we allocated. */
9946 obstack_free (&conversion_obstack
, p
);
9948 if (orig_args
!= NULL
)
9949 release_tree_vector (orig_args
);
9954 /* Wrapper for above. */
9957 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
9958 tree conversion_path
, int flags
,
9959 tree
*fn_p
, tsubst_flags_t complain
)
9962 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
9963 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
9965 timevar_cond_stop (TV_OVERLOAD
, subtime
);
9969 /* Returns true iff standard conversion sequence ICS1 is a proper
9970 subsequence of ICS2. */
9973 is_subseq (conversion
*ics1
, conversion
*ics2
)
9975 /* We can assume that a conversion of the same code
9976 between the same types indicates a subsequence since we only get
9977 here if the types we are converting from are the same. */
9979 while (ics1
->kind
== ck_rvalue
9980 || ics1
->kind
== ck_lvalue
)
9981 ics1
= next_conversion (ics1
);
9985 while (ics2
->kind
== ck_rvalue
9986 || ics2
->kind
== ck_lvalue
)
9987 ics2
= next_conversion (ics2
);
9989 if (ics2
->kind
== ck_user
9990 || ics2
->kind
== ck_ambig
9991 || ics2
->kind
== ck_aggr
9992 || ics2
->kind
== ck_list
9993 || ics2
->kind
== ck_identity
)
9994 /* At this point, ICS1 cannot be a proper subsequence of
9995 ICS2. We can get a USER_CONV when we are comparing the
9996 second standard conversion sequence of two user conversion
10000 ics2
= next_conversion (ics2
);
10002 while (ics2
->kind
== ck_rvalue
10003 || ics2
->kind
== ck_lvalue
)
10004 ics2
= next_conversion (ics2
);
10006 if (ics2
->kind
== ics1
->kind
10007 && same_type_p (ics2
->type
, ics1
->type
)
10008 && (ics1
->kind
== ck_identity
10009 || same_type_p (next_conversion (ics2
)->type
,
10010 next_conversion (ics1
)->type
)))
10015 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
10016 be any _TYPE nodes. */
10019 is_properly_derived_from (tree derived
, tree base
)
10021 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
10024 /* We only allow proper derivation here. The DERIVED_FROM_P macro
10025 considers every class derived from itself. */
10026 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
10027 && DERIVED_FROM_P (base
, derived
));
10030 /* We build the ICS for an implicit object parameter as a pointer
10031 conversion sequence. However, such a sequence should be compared
10032 as if it were a reference conversion sequence. If ICS is the
10033 implicit conversion sequence for an implicit object parameter,
10034 modify it accordingly. */
10037 maybe_handle_implicit_object (conversion
**ics
)
10039 if ((*ics
)->this_p
)
10041 /* [over.match.funcs]
10043 For non-static member functions, the type of the
10044 implicit object parameter is "reference to cv X"
10045 where X is the class of which the function is a
10046 member and cv is the cv-qualification on the member
10047 function declaration. */
10048 conversion
*t
= *ics
;
10049 tree reference_type
;
10051 /* The `this' parameter is a pointer to a class type. Make the
10052 implicit conversion talk about a reference to that same class
10054 reference_type
= TREE_TYPE (t
->type
);
10055 reference_type
= build_reference_type (reference_type
);
10057 if (t
->kind
== ck_qual
)
10058 t
= next_conversion (t
);
10059 if (t
->kind
== ck_ptr
)
10060 t
= next_conversion (t
);
10061 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
10062 t
= direct_reference_binding (reference_type
, t
);
10064 t
->rvaluedness_matches_p
= 0;
10069 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
10070 and return the initial reference binding conversion. Otherwise,
10071 leave *ICS unchanged and return NULL. */
10073 static conversion
*
10074 maybe_handle_ref_bind (conversion
**ics
)
10076 if ((*ics
)->kind
== ck_ref_bind
)
10078 conversion
*old_ics
= *ics
;
10079 *ics
= next_conversion (old_ics
);
10080 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
10087 /* Compare two implicit conversion sequences according to the rules set out in
10088 [over.ics.rank]. Return values:
10090 1: ics1 is better than ics2
10091 -1: ics2 is better than ics1
10092 0: ics1 and ics2 are indistinguishable */
10095 compare_ics (conversion
*ics1
, conversion
*ics2
)
10101 tree deref_from_type1
= NULL_TREE
;
10102 tree deref_from_type2
= NULL_TREE
;
10103 tree deref_to_type1
= NULL_TREE
;
10104 tree deref_to_type2
= NULL_TREE
;
10105 conversion_rank rank1
, rank2
;
10107 /* REF_BINDING is nonzero if the result of the conversion sequence
10108 is a reference type. In that case REF_CONV is the reference
10109 binding conversion. */
10110 conversion
*ref_conv1
;
10111 conversion
*ref_conv2
;
10113 /* Compare badness before stripping the reference conversion. */
10114 if (ics1
->bad_p
> ics2
->bad_p
)
10116 else if (ics1
->bad_p
< ics2
->bad_p
)
10119 /* Handle implicit object parameters. */
10120 maybe_handle_implicit_object (&ics1
);
10121 maybe_handle_implicit_object (&ics2
);
10123 /* Handle reference parameters. */
10124 ref_conv1
= maybe_handle_ref_bind (&ics1
);
10125 ref_conv2
= maybe_handle_ref_bind (&ics2
);
10127 /* List-initialization sequence L1 is a better conversion sequence than
10128 list-initialization sequence L2 if L1 converts to
10129 std::initializer_list<X> for some X and L2 does not. */
10130 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
10132 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
10137 When comparing the basic forms of implicit conversion sequences (as
10138 defined in _over.best.ics_)
10140 --a standard conversion sequence (_over.ics.scs_) is a better
10141 conversion sequence than a user-defined conversion sequence
10142 or an ellipsis conversion sequence, and
10144 --a user-defined conversion sequence (_over.ics.user_) is a
10145 better conversion sequence than an ellipsis conversion sequence
10146 (_over.ics.ellipsis_). */
10147 /* Use BAD_CONVERSION_RANK because we already checked for a badness
10148 mismatch. If both ICS are bad, we try to make a decision based on
10149 what would have happened if they'd been good. This is not an
10150 extension, we'll still give an error when we build up the call; this
10151 just helps us give a more helpful error message. */
10152 rank1
= BAD_CONVERSION_RANK (ics1
);
10153 rank2
= BAD_CONVERSION_RANK (ics2
);
10157 else if (rank1
< rank2
)
10160 if (ics1
->ellipsis_p
)
10161 /* Both conversions are ellipsis conversions. */
10164 /* User-defined conversion sequence U1 is a better conversion sequence
10165 than another user-defined conversion sequence U2 if they contain the
10166 same user-defined conversion operator or constructor and if the sec-
10167 ond standard conversion sequence of U1 is better than the second
10168 standard conversion sequence of U2. */
10170 /* Handle list-conversion with the same code even though it isn't always
10171 ranked as a user-defined conversion and it doesn't have a second
10172 standard conversion sequence; it will still have the desired effect.
10173 Specifically, we need to do the reference binding comparison at the
10174 end of this function. */
10176 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
10177 || ics1
->kind
== ck_aggr
|| ics2
->kind
== ck_aggr
)
10182 for (t1
= ics1
; t1
&& t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
10183 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
10184 || t1
->kind
== ck_list
)
10186 for (t2
= ics2
; t2
&& t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
10187 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
10188 || t2
->kind
== ck_list
)
10191 if (!t1
|| !t2
|| t1
->kind
!= t2
->kind
)
10193 else if (t1
->kind
== ck_user
)
10195 tree f1
= t1
->cand
? t1
->cand
->fn
: t1
->type
;
10196 tree f2
= t2
->cand
? t2
->cand
->fn
: t2
->type
;
10202 /* For ambiguous or aggregate conversions, use the target type as
10203 a proxy for the conversion function. */
10204 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
10208 /* We can just fall through here, after setting up
10209 FROM_TYPE1 and FROM_TYPE2. */
10210 from_type1
= t1
->type
;
10211 from_type2
= t2
->type
;
10218 /* We're dealing with two standard conversion sequences.
10222 Standard conversion sequence S1 is a better conversion
10223 sequence than standard conversion sequence S2 if
10225 --S1 is a proper subsequence of S2 (comparing the conversion
10226 sequences in the canonical form defined by _over.ics.scs_,
10227 excluding any Lvalue Transformation; the identity
10228 conversion sequence is considered to be a subsequence of
10229 any non-identity conversion sequence */
10232 while (t1
->kind
!= ck_identity
)
10233 t1
= next_conversion (t1
);
10234 from_type1
= t1
->type
;
10237 while (t2
->kind
!= ck_identity
)
10238 t2
= next_conversion (t2
);
10239 from_type2
= t2
->type
;
10242 /* One sequence can only be a subsequence of the other if they start with
10243 the same type. They can start with different types when comparing the
10244 second standard conversion sequence in two user-defined conversion
10246 if (same_type_p (from_type1
, from_type2
))
10248 if (is_subseq (ics1
, ics2
))
10250 if (is_subseq (ics2
, ics1
))
10258 --the rank of S1 is better than the rank of S2 (by the rules
10261 Standard conversion sequences are ordered by their ranks: an Exact
10262 Match is a better conversion than a Promotion, which is a better
10263 conversion than a Conversion.
10265 Two conversion sequences with the same rank are indistinguishable
10266 unless one of the following rules applies:
10268 --A conversion that does not a convert a pointer, pointer to member,
10269 or std::nullptr_t to bool is better than one that does.
10271 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
10272 so that we do not have to check it explicitly. */
10273 if (ics1
->rank
< ics2
->rank
)
10275 else if (ics2
->rank
< ics1
->rank
)
10278 to_type1
= ics1
->type
;
10279 to_type2
= ics2
->type
;
10281 /* A conversion from scalar arithmetic type to complex is worse than a
10282 conversion between scalar arithmetic types. */
10283 if (same_type_p (from_type1
, from_type2
)
10284 && ARITHMETIC_TYPE_P (from_type1
)
10285 && ARITHMETIC_TYPE_P (to_type1
)
10286 && ARITHMETIC_TYPE_P (to_type2
)
10287 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
10288 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
10290 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
10296 if (TYPE_PTR_P (from_type1
)
10297 && TYPE_PTR_P (from_type2
)
10298 && TYPE_PTR_P (to_type1
)
10299 && TYPE_PTR_P (to_type2
))
10301 deref_from_type1
= TREE_TYPE (from_type1
);
10302 deref_from_type2
= TREE_TYPE (from_type2
);
10303 deref_to_type1
= TREE_TYPE (to_type1
);
10304 deref_to_type2
= TREE_TYPE (to_type2
);
10306 /* The rules for pointers to members A::* are just like the rules
10307 for pointers A*, except opposite: if B is derived from A then
10308 A::* converts to B::*, not vice versa. For that reason, we
10309 switch the from_ and to_ variables here. */
10310 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
10311 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
10312 || (TYPE_PTRMEMFUNC_P (from_type1
)
10313 && TYPE_PTRMEMFUNC_P (from_type2
)
10314 && TYPE_PTRMEMFUNC_P (to_type1
)
10315 && TYPE_PTRMEMFUNC_P (to_type2
)))
10317 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
10318 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
10319 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
10320 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
10323 if (deref_from_type1
!= NULL_TREE
10324 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
10325 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
10327 /* This was one of the pointer or pointer-like conversions.
10331 --If class B is derived directly or indirectly from class A,
10332 conversion of B* to A* is better than conversion of B* to
10333 void*, and conversion of A* to void* is better than
10334 conversion of B* to void*. */
10335 if (VOID_TYPE_P (deref_to_type1
)
10336 && VOID_TYPE_P (deref_to_type2
))
10338 if (is_properly_derived_from (deref_from_type1
,
10341 else if (is_properly_derived_from (deref_from_type2
,
10345 else if (VOID_TYPE_P (deref_to_type1
)
10346 || VOID_TYPE_P (deref_to_type2
))
10348 if (same_type_p (deref_from_type1
, deref_from_type2
))
10350 if (VOID_TYPE_P (deref_to_type2
))
10352 if (is_properly_derived_from (deref_from_type1
,
10356 /* We know that DEREF_TO_TYPE1 is `void' here. */
10357 else if (is_properly_derived_from (deref_from_type1
,
10362 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
10363 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
10367 --If class B is derived directly or indirectly from class A
10368 and class C is derived directly or indirectly from B,
10370 --conversion of C* to B* is better than conversion of C* to
10373 --conversion of B* to A* is better than conversion of C* to
10375 if (same_type_p (deref_from_type1
, deref_from_type2
))
10377 if (is_properly_derived_from (deref_to_type1
,
10380 else if (is_properly_derived_from (deref_to_type2
,
10384 else if (same_type_p (deref_to_type1
, deref_to_type2
))
10386 if (is_properly_derived_from (deref_from_type2
,
10389 else if (is_properly_derived_from (deref_from_type1
,
10395 else if (CLASS_TYPE_P (non_reference (from_type1
))
10396 && same_type_p (from_type1
, from_type2
))
10398 tree from
= non_reference (from_type1
);
10402 --binding of an expression of type C to a reference of type
10403 B& is better than binding an expression of type C to a
10404 reference of type A&
10406 --conversion of C to B is better than conversion of C to A, */
10407 if (is_properly_derived_from (from
, to_type1
)
10408 && is_properly_derived_from (from
, to_type2
))
10410 if (is_properly_derived_from (to_type1
, to_type2
))
10412 else if (is_properly_derived_from (to_type2
, to_type1
))
10416 else if (CLASS_TYPE_P (non_reference (to_type1
))
10417 && same_type_p (to_type1
, to_type2
))
10419 tree to
= non_reference (to_type1
);
10423 --binding of an expression of type B to a reference of type
10424 A& is better than binding an expression of type C to a
10425 reference of type A&,
10427 --conversion of B to A is better than conversion of C to A */
10428 if (is_properly_derived_from (from_type1
, to
)
10429 && is_properly_derived_from (from_type2
, to
))
10431 if (is_properly_derived_from (from_type2
, from_type1
))
10433 else if (is_properly_derived_from (from_type1
, from_type2
))
10440 --S1 and S2 differ only in their qualification conversion and yield
10441 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
10442 qualification signature of type T1 is a proper subset of the cv-
10443 qualification signature of type T2 */
10444 if (ics1
->kind
== ck_qual
10445 && ics2
->kind
== ck_qual
10446 && same_type_p (from_type1
, from_type2
))
10448 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
10455 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
10456 to an implicit object parameter of a non-static member function
10457 declared without a ref-qualifier, and either S1 binds an lvalue
10458 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
10459 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
10460 draft standard, 13.3.3.2)
10462 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
10463 types to which the references refer are the same type except for
10464 top-level cv-qualifiers, and the type to which the reference
10465 initialized by S2 refers is more cv-qualified than the type to
10466 which the reference initialized by S1 refers.
10468 DR 1328 [over.match.best]: the context is an initialization by
10469 conversion function for direct reference binding (13.3.1.6) of a
10470 reference to function type, the return type of F1 is the same kind of
10471 reference (i.e. lvalue or rvalue) as the reference being initialized,
10472 and the return type of F2 is not. */
10474 if (ref_conv1
&& ref_conv2
)
10476 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
10477 && (ref_conv1
->rvaluedness_matches_p
10478 != ref_conv2
->rvaluedness_matches_p
)
10479 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
10480 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
10481 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
10483 if (ref_conv1
->bad_p
10484 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
10485 TREE_TYPE (ref_conv2
->type
)))
10486 /* Don't prefer a bad conversion that drops cv-quals to a bad
10487 conversion with the wrong rvalueness. */
10489 return (ref_conv1
->rvaluedness_matches_p
10490 - ref_conv2
->rvaluedness_matches_p
);
10493 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
10495 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
10496 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
10497 if (ref_conv1
->bad_p
)
10499 /* Prefer the one that drops fewer cv-quals. */
10500 tree ftype
= next_conversion (ref_conv1
)->type
;
10501 int fquals
= cp_type_quals (ftype
);
10505 return comp_cv_qualification (q2
, q1
);
10509 /* Neither conversion sequence is better than the other. */
10513 /* The source type for this standard conversion sequence. */
10516 source_type (conversion
*t
)
10518 for (;; t
= next_conversion (t
))
10520 if (t
->kind
== ck_user
10521 || t
->kind
== ck_ambig
10522 || t
->kind
== ck_identity
)
10525 gcc_unreachable ();
10528 /* Note a warning about preferring WINNER to LOSER. We do this by storing
10529 a pointer to LOSER and re-running joust to produce the warning if WINNER
10530 is actually used. */
10533 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
10535 candidate_warning
*cw
= (candidate_warning
*)
10536 conversion_obstack_alloc (sizeof (candidate_warning
));
10538 cw
->next
= winner
->warnings
;
10539 winner
->warnings
= cw
;
10542 /* CAND is a constructor candidate in joust in C++17 and up. If it copies a
10543 prvalue returned from a conversion function, replace CAND with the candidate
10544 for the conversion and return true. Otherwise, return false. */
10547 joust_maybe_elide_copy (z_candidate
*&cand
)
10549 tree fn
= cand
->fn
;
10550 if (!DECL_COPY_CONSTRUCTOR_P (fn
) && !DECL_MOVE_CONSTRUCTOR_P (fn
))
10552 conversion
*conv
= cand
->convs
[0];
10553 gcc_checking_assert (conv
->kind
== ck_ref_bind
);
10554 conv
= next_conversion (conv
);
10555 if (conv
->kind
== ck_user
&& !TYPE_REF_P (conv
->type
))
10557 gcc_checking_assert (same_type_ignoring_top_level_qualifiers_p
10558 (conv
->type
, DECL_CONTEXT (fn
)));
10559 z_candidate
*uc
= conv
->cand
;
10560 if (DECL_CONV_FN_P (uc
->fn
))
10569 /* Compare two candidates for overloading as described in
10570 [over.match.best]. Return values:
10572 1: cand1 is better than cand2
10573 -1: cand2 is better than cand1
10574 0: cand1 and cand2 are indistinguishable */
10577 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
10578 tsubst_flags_t complain
)
10581 int off1
= 0, off2
= 0;
10585 /* Candidates that involve bad conversions are always worse than those
10587 if (cand1
->viable
> cand2
->viable
)
10589 if (cand1
->viable
< cand2
->viable
)
10592 /* If we have two pseudo-candidates for conversions to the same type,
10593 or two candidates for the same function, arbitrarily pick one. */
10594 if (cand1
->fn
== cand2
->fn
10595 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
10598 /* Prefer a non-deleted function over an implicitly deleted move
10599 constructor or assignment operator. This differs slightly from the
10600 wording for issue 1402 (which says the move op is ignored by overload
10601 resolution), but this way produces better error messages. */
10602 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
10603 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
10604 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
10606 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
10607 && move_fn_p (cand1
->fn
))
10609 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
10610 && move_fn_p (cand2
->fn
))
10614 /* a viable function F1
10615 is defined to be a better function than another viable function F2 if
10616 for all arguments i, ICSi(F1) is not a worse conversion sequence than
10617 ICSi(F2), and then */
10619 /* for some argument j, ICSj(F1) is a better conversion sequence than
10622 /* For comparing static and non-static member functions, we ignore
10623 the implicit object parameter of the non-static function. The
10624 standard says to pretend that the static function has an object
10625 parm, but that won't work with operator overloading. */
10626 len
= cand1
->num_convs
;
10627 if (len
!= cand2
->num_convs
)
10629 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
10630 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
10632 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
10633 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
10634 /* We're comparing a near-match list constructor and a near-match
10635 non-list constructor. Just treat them as unordered. */
10638 gcc_assert (static_1
!= static_2
);
10649 /* Handle C++17 copy elision in [over.match.ctor] (direct-init) context. The
10650 standard currently says that only constructors are candidates, but if one
10651 copies a prvalue returned by a conversion function we want to treat the
10652 conversion as the candidate instead.
10654 Clang does something similar, as discussed at
10655 http://lists.isocpp.org/core/2017/10/3166.php
10656 http://lists.isocpp.org/core/2019/03/5721.php */
10657 int elided_tiebreaker
= 0;
10658 if (len
== 1 && cxx_dialect
>= cxx17
10659 && DECL_P (cand1
->fn
)
10660 && DECL_COMPLETE_CONSTRUCTOR_P (cand1
->fn
)
10661 && !(cand1
->flags
& LOOKUP_ONLYCONVERTING
))
10663 bool elided1
= joust_maybe_elide_copy (cand1
);
10664 bool elided2
= joust_maybe_elide_copy (cand2
);
10665 /* As a tiebreaker below we will prefer a constructor to a conversion
10666 operator exposed this way. */
10667 elided_tiebreaker
= elided2
- elided1
;
10670 for (i
= 0; i
< len
; ++i
)
10672 conversion
*t1
= cand1
->convs
[i
+ off1
];
10673 conversion
*t2
= cand2
->convs
[i
+ off2
];
10674 int comp
= compare_ics (t1
, t2
);
10678 if ((complain
& tf_warning
)
10680 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
10681 == cr_std
+ cr_promotion
)
10682 && t1
->kind
== ck_std
10683 && t2
->kind
== ck_std
10684 && TREE_CODE (t1
->type
) == INTEGER_TYPE
10685 && TREE_CODE (t2
->type
) == INTEGER_TYPE
10686 && (TYPE_PRECISION (t1
->type
)
10687 == TYPE_PRECISION (t2
->type
))
10688 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
10689 || (TREE_CODE (next_conversion (t1
)->type
)
10690 == ENUMERAL_TYPE
)))
10692 tree type
= next_conversion (t1
)->type
;
10694 struct z_candidate
*w
, *l
;
10696 type1
= t1
->type
, type2
= t2
->type
,
10697 w
= cand1
, l
= cand2
;
10699 type1
= t2
->type
, type2
= t1
->type
,
10700 w
= cand2
, l
= cand1
;
10704 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
10705 type
, type1
, type2
);
10706 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
10709 add_warning (w
, l
);
10712 if (winner
&& comp
!= winner
)
10721 /* warn about confusing overload resolution for user-defined conversions,
10722 either between a constructor and a conversion op, or between two
10724 if ((complain
& tf_warning
)
10725 && winner
&& warn_conversion
&& cand1
->second_conv
10726 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
10727 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
10729 struct z_candidate
*w
, *l
;
10730 bool give_warning
= false;
10733 w
= cand1
, l
= cand2
;
10735 w
= cand2
, l
= cand1
;
10737 /* We don't want to complain about `X::operator T1 ()'
10738 beating `X::operator T2 () const', when T2 is a no less
10739 cv-qualified version of T1. */
10740 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
10741 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
10743 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
10744 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
10746 if (TREE_CODE (t
) == TREE_CODE (f
) && INDIRECT_TYPE_P (t
))
10751 if (!comp_ptr_ttypes (t
, f
))
10752 give_warning
= true;
10755 give_warning
= true;
10761 tree source
= source_type (w
->convs
[0]);
10762 if (INDIRECT_TYPE_P (source
))
10763 source
= TREE_TYPE (source
);
10764 auto_diagnostic_group d
;
10765 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
10766 && warning (OPT_Wconversion
, " for conversion from %qH to %qI",
10767 source
, w
->second_conv
->type
))
10769 inform (input_location
, " because conversion sequence "
10770 "for the argument is better");
10774 add_warning (w
, l
);
10780 /* Put this tiebreaker first, so that we don't try to look at second_conv of
10781 a constructor candidate that doesn't have one. */
10782 if (elided_tiebreaker
)
10783 return elided_tiebreaker
;
10785 /* DR 495 moved this tiebreaker above the template ones. */
10786 /* or, if not that,
10787 the context is an initialization by user-defined conversion (see
10788 _dcl.init_ and _over.match.user_) and the standard conversion
10789 sequence from the return type of F1 to the destination type (i.e.,
10790 the type of the entity being initialized) is a better conversion
10791 sequence than the standard conversion sequence from the return type
10792 of F2 to the destination type. */
10794 if (cand1
->second_conv
)
10796 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
10801 /* or, if not that,
10802 F1 is a non-template function and F2 is a template function
10805 if (!cand1
->template_decl
&& cand2
->template_decl
)
10807 else if (cand1
->template_decl
&& !cand2
->template_decl
)
10810 /* or, if not that,
10811 F1 and F2 are template functions and the function template for F1 is
10812 more specialized than the template for F2 according to the partial
10815 if (cand1
->template_decl
&& cand2
->template_decl
)
10817 winner
= more_specialized_fn
10818 (TI_TEMPLATE (cand1
->template_decl
),
10819 TI_TEMPLATE (cand2
->template_decl
),
10820 /* [temp.func.order]: The presence of unused ellipsis and default
10821 arguments has no effect on the partial ordering of function
10822 templates. add_function_candidate() will not have
10823 counted the "this" argument for constructors. */
10824 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
10830 // or, if not that, F1 is more constrained than F2.
10831 if (flag_concepts
&& DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
))
10833 winner
= more_constrained (cand1
->fn
, cand2
->fn
);
10838 /* F1 is generated from a deduction-guide (13.3.1.8) and F2 is not */
10839 if (deduction_guide_p (cand1
->fn
))
10841 gcc_assert (deduction_guide_p (cand2
->fn
));
10842 /* We distinguish between candidates from an explicit deduction guide and
10843 candidates built from a constructor based on DECL_ARTIFICIAL. */
10844 int art1
= DECL_ARTIFICIAL (cand1
->fn
);
10845 int art2
= DECL_ARTIFICIAL (cand2
->fn
);
10847 return art2
- art1
;
10851 /* Prefer the special copy guide over a declared copy/move
10853 if (copy_guide_p (cand1
->fn
))
10855 if (copy_guide_p (cand2
->fn
))
10858 /* Prefer a candidate generated from a non-template constructor. */
10859 int tg1
= template_guide_p (cand1
->fn
);
10860 int tg2
= template_guide_p (cand2
->fn
);
10866 /* F1 is a member of a class D, F2 is a member of a base class B of D, and
10867 for all arguments the corresponding parameters of F1 and F2 have the same
10868 type (CWG 2273/2277). */
10869 if (DECL_P (cand1
->fn
) && DECL_CLASS_SCOPE_P (cand1
->fn
)
10870 && !DECL_CONV_FN_P (cand1
->fn
)
10871 && DECL_P (cand2
->fn
) && DECL_CLASS_SCOPE_P (cand2
->fn
)
10872 && !DECL_CONV_FN_P (cand2
->fn
))
10874 tree base1
= DECL_CONTEXT (strip_inheriting_ctors (cand1
->fn
));
10875 tree base2
= DECL_CONTEXT (strip_inheriting_ctors (cand2
->fn
));
10877 bool used1
= false;
10878 bool used2
= false;
10879 if (base1
== base2
)
10880 /* No difference. */;
10881 else if (DERIVED_FROM_P (base1
, base2
))
10883 else if (DERIVED_FROM_P (base2
, base1
))
10886 if (int diff
= used2
- used1
)
10888 for (i
= 0; i
< len
; ++i
)
10890 conversion
*t1
= cand1
->convs
[i
+ off1
];
10891 conversion
*t2
= cand2
->convs
[i
+ off2
];
10892 if (!same_type_p (t1
->type
, t2
->type
))
10900 /* Check whether we can discard a builtin candidate, either because we
10901 have two identical ones or matching builtin and non-builtin candidates.
10903 (Pedantically in the latter case the builtin which matched the user
10904 function should not be added to the overload set, but we spot it here.
10907 ... the builtin candidates include ...
10908 - do not have the same parameter type list as any non-template
10909 non-member candidate. */
10911 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
10913 for (i
= 0; i
< len
; ++i
)
10914 if (!same_type_p (cand1
->convs
[i
]->type
,
10915 cand2
->convs
[i
]->type
))
10917 if (i
== cand1
->num_convs
)
10919 if (cand1
->fn
== cand2
->fn
)
10920 /* Two built-in candidates; arbitrarily pick one. */
10922 else if (identifier_p (cand1
->fn
))
10923 /* cand1 is built-in; prefer cand2. */
10926 /* cand2 is built-in; prefer cand1. */
10931 /* For candidates of a multi-versioned function, make the version with
10932 the highest priority win. This version will be checked for dispatching
10933 first. If this version can be inlined into the caller, the front-end
10934 will simply make a direct call to this function. */
10936 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
10937 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
10938 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
10939 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
10941 tree f1
= TREE_TYPE (cand1
->fn
);
10942 tree f2
= TREE_TYPE (cand2
->fn
);
10943 tree p1
= TYPE_ARG_TYPES (f1
);
10944 tree p2
= TYPE_ARG_TYPES (f2
);
10946 /* Check if cand1->fn and cand2->fn are versions of the same function. It
10947 is possible that cand1->fn and cand2->fn are function versions but of
10948 different functions. Check types to see if they are versions of the same
10950 if (compparms (p1
, p2
)
10951 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
10953 /* Always make the version with the higher priority, more
10954 specialized, win. */
10955 gcc_assert (targetm
.compare_version_priority
);
10956 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
10963 /* If the two function declarations represent the same function (this can
10964 happen with declarations in multiple scopes and arg-dependent lookup),
10965 arbitrarily choose one. But first make sure the default args we're
10967 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
10968 && equal_functions (cand1
->fn
, cand2
->fn
))
10970 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
10971 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
10973 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
10975 for (i
= 0; i
< len
; ++i
)
10977 /* Don't crash if the fn is variadic. */
10980 parms1
= TREE_CHAIN (parms1
);
10981 parms2
= TREE_CHAIN (parms2
);
10985 parms1
= TREE_CHAIN (parms1
);
10987 parms2
= TREE_CHAIN (parms2
);
10989 for (; parms1
; ++i
)
10991 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
10992 TREE_PURPOSE (parms2
)))
10996 if (complain
& tf_error
)
10998 auto_diagnostic_group d
;
10999 if (permerror (input_location
,
11000 "default argument mismatch in "
11001 "overload resolution"))
11003 inform (DECL_SOURCE_LOCATION (cand1
->fn
),
11004 " candidate 1: %q#F", cand1
->fn
);
11005 inform (DECL_SOURCE_LOCATION (cand2
->fn
),
11006 " candidate 2: %q#F", cand2
->fn
);
11013 add_warning (cand1
, cand2
);
11016 parms1
= TREE_CHAIN (parms1
);
11017 parms2
= TREE_CHAIN (parms2
);
11025 /* Extension: If the worst conversion for one candidate is better than the
11026 worst conversion for the other, take the first. */
11027 if (!pedantic
&& (complain
& tf_warning_or_error
))
11029 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
11030 struct z_candidate
*w
= 0, *l
= 0;
11032 for (i
= 0; i
< len
; ++i
)
11034 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
11035 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
11036 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
11037 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
11040 winner
= 1, w
= cand1
, l
= cand2
;
11042 winner
= -1, w
= cand2
, l
= cand1
;
11045 /* Don't choose a deleted function over ambiguity. */
11046 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
11050 auto_diagnostic_group d
;
11051 if (pedwarn (input_location
, 0,
11052 "ISO C++ says that these are ambiguous, even "
11053 "though the worst conversion for the first is "
11054 "better than the worst conversion for the second:"))
11056 print_z_candidate (input_location
, N_("candidate 1:"), w
);
11057 print_z_candidate (input_location
, N_("candidate 2:"), l
);
11061 add_warning (w
, l
);
11066 gcc_assert (!winner
);
11070 /* Given a list of candidates for overloading, find the best one, if any.
11071 This algorithm has a worst case of O(2n) (winner is last), and a best
11072 case of O(n/2) (totally ambiguous); much better than a sorting
11075 static struct z_candidate
*
11076 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
11078 struct z_candidate
*champ
= candidates
, *challenger
;
11080 int champ_compared_to_predecessor
= 0;
11082 /* Walk through the list once, comparing each current champ to the next
11083 candidate, knocking out a candidate or two with each comparison. */
11085 for (challenger
= champ
->next
; challenger
; )
11087 fate
= joust (champ
, challenger
, 0, complain
);
11089 challenger
= challenger
->next
;
11094 champ
= challenger
->next
;
11097 champ_compared_to_predecessor
= 0;
11101 champ
= challenger
;
11102 champ_compared_to_predecessor
= 1;
11105 challenger
= champ
->next
;
11109 /* Make sure the champ is better than all the candidates it hasn't yet
11110 been compared to. */
11112 for (challenger
= candidates
;
11113 challenger
!= champ
11114 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
11115 challenger
= challenger
->next
)
11117 fate
= joust (champ
, challenger
, 0, complain
);
11125 /* Returns nonzero if things of type FROM can be converted to TO. */
11128 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
11130 tree arg
= NULL_TREE
;
11131 /* implicit_conversion only considers user-defined conversions
11132 if it has an expression for the call argument list. */
11133 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
11134 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
11135 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
11138 /* Returns nonzero if things of type FROM can be converted to TO with a
11139 standard conversion. */
11142 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
11144 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
11147 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
11150 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
11151 tsubst_flags_t complain
)
11157 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11158 p
= conversion_obstack_alloc (0);
11159 /* We want to discard any access checks done for this test,
11160 as we might not be in the appropriate access context and
11161 we'll do the check again when we actually perform the
11163 push_deferring_access_checks (dk_deferred
);
11165 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
11167 ok_p
= (t
&& !t
->bad_p
);
11169 /* Discard the access checks now. */
11170 pop_deferring_access_checks ();
11171 /* Free all the conversions we allocated. */
11172 obstack_free (&conversion_obstack
, p
);
11177 /* Like can_convert_arg, but allows dubious conversions as well. */
11180 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
11181 tsubst_flags_t complain
)
11186 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11187 p
= conversion_obstack_alloc (0);
11188 /* Try to perform the conversion. */
11189 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
11191 /* Free all the conversions we allocated. */
11192 obstack_free (&conversion_obstack
, p
);
11197 /* Convert EXPR to TYPE. Return the converted expression.
11199 Note that we allow bad conversions here because by the time we get to
11200 this point we are committed to doing the conversion. If we end up
11201 doing a bad conversion, convert_like will complain. */
11204 perform_implicit_conversion_flags (tree type
, tree expr
,
11205 tsubst_flags_t complain
, int flags
)
11209 location_t loc
= cp_expr_loc_or_input_loc (expr
);
11211 if (TYPE_REF_P (type
))
11212 expr
= mark_lvalue_use (expr
);
11214 expr
= mark_rvalue_use (expr
);
11216 if (error_operand_p (expr
))
11217 return error_mark_node
;
11219 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11220 p
= conversion_obstack_alloc (0);
11222 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
11223 /*c_cast_p=*/false,
11228 if (complain
& tf_error
)
11230 /* If expr has unknown type, then it is an overloaded function.
11231 Call instantiate_type to get good error messages. */
11232 if (TREE_TYPE (expr
) == unknown_type_node
)
11233 instantiate_type (type
, expr
, complain
);
11234 else if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
11235 /* We gave an error. */;
11238 range_label_for_type_mismatch
label (TREE_TYPE (expr
), type
);
11239 gcc_rich_location
rich_loc (loc
, &label
);
11240 error_at (&rich_loc
, "could not convert %qE from %qH to %qI",
11241 expr
, TREE_TYPE (expr
), type
);
11244 expr
= error_mark_node
;
11246 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
11248 /* In a template, we are only concerned about determining the
11249 type of non-dependent expressions, so we do not have to
11250 perform the actual conversion. But for initializers, we
11251 need to be able to perform it at instantiation
11252 (or instantiate_non_dependent_expr) time. */
11253 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
11254 if (!(flags
& LOOKUP_ONLYCONVERTING
))
11255 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
11256 if (flags
& LOOKUP_NO_NARROWING
)
11257 IMPLICIT_CONV_EXPR_BRACED_INIT (expr
) = true;
11260 expr
= convert_like (conv
, expr
, complain
);
11262 /* Free all the conversions we allocated. */
11263 obstack_free (&conversion_obstack
, p
);
11269 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
11271 return perform_implicit_conversion_flags (type
, expr
, complain
,
11275 /* Convert EXPR to TYPE (as a direct-initialization) if that is
11276 permitted. If the conversion is valid, the converted expression is
11277 returned. Otherwise, NULL_TREE is returned, except in the case
11278 that TYPE is a class type; in that case, an error is issued. If
11279 C_CAST_P is true, then this direct-initialization is taking
11280 place as part of a static_cast being attempted as part of a C-style
11284 perform_direct_initialization_if_possible (tree type
,
11287 tsubst_flags_t complain
)
11292 if (type
== error_mark_node
|| error_operand_p (expr
))
11293 return error_mark_node
;
11296 If the destination type is a (possibly cv-qualified) class type:
11298 -- If the initialization is direct-initialization ...,
11299 constructors are considered. ... If no constructor applies, or
11300 the overload resolution is ambiguous, the initialization is
11302 if (CLASS_TYPE_P (type
))
11304 releasing_vec
args (make_tree_vector_single (expr
));
11305 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
11306 &args
, type
, LOOKUP_NORMAL
, complain
);
11307 return build_cplus_new (type
, expr
, complain
);
11310 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11311 p
= conversion_obstack_alloc (0);
11313 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
11315 LOOKUP_NORMAL
, complain
);
11316 if (!conv
|| conv
->bad_p
)
11318 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
11320 /* In a template, we are only concerned about determining the
11321 type of non-dependent expressions, so we do not have to
11322 perform the actual conversion. But for initializers, we
11323 need to be able to perform it at instantiation
11324 (or instantiate_non_dependent_expr) time. */
11325 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
11326 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
11329 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0,
11330 /*issue_conversion_warnings=*/false,
11334 /* Free all the conversions we allocated. */
11335 obstack_free (&conversion_obstack
, p
);
11340 /* When initializing a reference that lasts longer than a full-expression,
11341 this special rule applies:
11345 The temporary to which the reference is bound or the temporary
11346 that is the complete object to which the reference is bound
11347 persists for the lifetime of the reference.
11349 The temporaries created during the evaluation of the expression
11350 initializing the reference, except the temporary to which the
11351 reference is bound, are destroyed at the end of the
11352 full-expression in which they are created.
11354 In that case, we store the converted expression into a new
11355 VAR_DECL in a new scope.
11357 However, we want to be careful not to create temporaries when
11358 they are not required. For example, given:
11361 struct D : public B {};
11365 there is no need to copy the return value from "f"; we can just
11366 extend its lifetime. Similarly, given:
11369 struct T { operator S(); };
11373 we can extend the lifetime of the return value of the conversion
11376 The next several functions are involved in this lifetime extension. */
11378 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
11379 reference is being bound to a temporary. Create and return a new
11380 VAR_DECL with the indicated TYPE; this variable will store the value to
11381 which the reference is bound. */
11384 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
11386 tree var
= create_temporary_var (type
);
11388 /* Register the variable. */
11390 && (TREE_STATIC (decl
) || CP_DECL_THREAD_LOCAL_P (decl
)))
11392 /* Namespace-scope or local static; give it a mangled name. */
11394 /* If an initializer is visible to multiple translation units, those
11395 translation units must agree on the addresses of the
11396 temporaries. Therefore the temporaries must be given a consistent name
11397 and vague linkage. The mangled name of a temporary is the name of the
11398 non-temporary object in whose initializer they appear, prefixed with
11399 GR and suffixed with a sequence number mangled using the usual rules
11400 for a seq-id. Temporaries are numbered with a pre-order, depth-first,
11401 left-to-right walk of the complete initializer. */
11403 TREE_STATIC (var
) = TREE_STATIC (decl
);
11404 TREE_PUBLIC (var
) = TREE_PUBLIC (decl
);
11405 if (vague_linkage_p (decl
))
11406 comdat_linkage (var
);
11408 CP_DECL_THREAD_LOCAL_P (var
) = CP_DECL_THREAD_LOCAL_P (decl
);
11409 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
11411 tree name
= mangle_ref_init_variable (decl
);
11412 DECL_NAME (var
) = name
;
11413 SET_DECL_ASSEMBLER_NAME (var
, name
);
11416 /* Create a new cleanup level if necessary. */
11417 maybe_push_cleanup_level (type
);
11419 return pushdecl (var
);
11422 /* EXPR is the initializer for a variable DECL of reference or
11423 std::initializer_list type. Create, push and return a new VAR_DECL
11424 for the initializer so that it will live as long as DECL. Any
11425 cleanup for the new variable is returned through CLEANUP, and the
11426 code to initialize the new variable is returned through INITP. */
11429 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
11436 /* Create the temporary variable. */
11437 type
= TREE_TYPE (expr
);
11438 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
11439 layout_decl (var
, 0);
11440 /* If the rvalue is the result of a function call it will be
11441 a TARGET_EXPR. If it is some other construct (such as a
11442 member access expression where the underlying object is
11443 itself the result of a function call), turn it into a
11444 TARGET_EXPR here. It is important that EXPR be a
11445 TARGET_EXPR below since otherwise the INIT_EXPR will
11446 attempt to make a bitwise copy of EXPR to initialize
11448 if (TREE_CODE (expr
) != TARGET_EXPR
)
11449 expr
= get_target_expr (expr
);
11451 if (TREE_CODE (decl
) == FIELD_DECL
11452 && extra_warnings
&& !TREE_NO_WARNING (decl
))
11454 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
11455 "until the constructor exits", decl
);
11456 TREE_NO_WARNING (decl
) = true;
11459 /* Recursively extend temps in this initializer. */
11460 TARGET_EXPR_INITIAL (expr
)
11461 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
11463 /* Any reference temp has a non-trivial initializer. */
11464 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
11466 /* If the initializer is constant, put it in DECL_INITIAL so we get
11467 static initialization and use in constant expressions. */
11468 init
= maybe_constant_init (expr
);
11469 /* As in store_init_value. */
11470 init
= cp_fully_fold (init
);
11471 if (TREE_CONSTANT (init
))
11473 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
11475 /* 5.19 says that a constant expression can include an
11476 lvalue-rvalue conversion applied to "a glvalue of literal type
11477 that refers to a non-volatile temporary object initialized
11478 with a constant expression". Rather than try to communicate
11479 that this VAR_DECL is a temporary, just mark it constexpr. */
11480 DECL_DECLARED_CONSTEXPR_P (var
) = true;
11481 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
11482 TREE_CONSTANT (var
) = true;
11483 TREE_READONLY (var
) = true;
11485 DECL_INITIAL (var
) = init
;
11489 /* Create the INIT_EXPR that will initialize the temporary
11491 init
= split_nonconstant_init (var
, expr
);
11492 if (at_function_scope_p ())
11494 add_decl_expr (var
);
11496 if (TREE_STATIC (var
))
11497 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
11500 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
11502 vec_safe_push (*cleanups
, cleanup
);
11505 /* We must be careful to destroy the temporary only
11506 after its initialization has taken place. If the
11507 initialization throws an exception, then the
11508 destructor should not be run. We cannot simply
11509 transform INIT into something like:
11511 (INIT, ({ CLEANUP_STMT; }))
11513 because emit_local_var always treats the
11514 initializer as a full-expression. Thus, the
11515 destructor would run too early; it would run at the
11516 end of initializing the reference variable, rather
11517 than at the end of the block enclosing the
11518 reference variable.
11520 The solution is to pass back a cleanup expression
11521 which the caller is responsible for attaching to
11522 the statement tree. */
11526 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
11527 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
11529 if (CP_DECL_THREAD_LOCAL_P (var
))
11530 tls_aggregates
= tree_cons (NULL_TREE
, var
,
11533 static_aggregates
= tree_cons (NULL_TREE
, var
,
11534 static_aggregates
);
11537 /* Check whether the dtor is callable. */
11538 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
11540 /* Avoid -Wunused-variable warning (c++/38958). */
11541 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
11543 TREE_USED (decl
) = DECL_READ_P (decl
) = true;
11549 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
11550 initializing a variable of that TYPE. */
11553 initialize_reference (tree type
, tree expr
,
11554 int flags
, tsubst_flags_t complain
)
11558 location_t loc
= cp_expr_loc_or_input_loc (expr
);
11560 if (type
== error_mark_node
|| error_operand_p (expr
))
11561 return error_mark_node
;
11563 /* Get the high-water mark for the CONVERSION_OBSTACK. */
11564 p
= conversion_obstack_alloc (0);
11566 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
11568 if (!conv
|| conv
->bad_p
)
11570 if (complain
& tf_error
)
11573 convert_like (conv
, expr
, complain
);
11574 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
11575 && !TYPE_REF_IS_RVALUE (type
)
11576 && !lvalue_p (expr
))
11577 error_at (loc
, "invalid initialization of non-const reference of "
11578 "type %qH from an rvalue of type %qI",
11579 type
, TREE_TYPE (expr
));
11581 error_at (loc
, "invalid initialization of reference of type "
11582 "%qH from expression of type %qI", type
,
11585 return error_mark_node
;
11588 if (conv
->kind
== ck_ref_bind
)
11589 /* Perform the conversion. */
11590 expr
= convert_like (conv
, expr
, complain
);
11591 else if (conv
->kind
== ck_ambig
)
11592 /* We gave an error in build_user_type_conversion_1. */
11593 expr
= error_mark_node
;
11595 gcc_unreachable ();
11597 /* Free all the conversions we allocated. */
11598 obstack_free (&conversion_obstack
, p
);
11603 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
11604 which is bound either to a reference or a std::initializer_list. */
11607 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
11612 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
11614 TREE_OPERAND (sub
, 1)
11615 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
11618 if (TREE_CODE (sub
) != ADDR_EXPR
)
11620 /* Deal with binding to a subobject. */
11621 for (p
= &TREE_OPERAND (sub
, 0);
11622 (TREE_CODE (*p
) == COMPONENT_REF
11623 || TREE_CODE (*p
) == ARRAY_REF
); )
11624 p
= &TREE_OPERAND (*p
, 0);
11625 if (TREE_CODE (*p
) == TARGET_EXPR
)
11627 tree subinit
= NULL_TREE
;
11628 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
11629 recompute_tree_invariant_for_addr_expr (sub
);
11631 init
= fold_convert (TREE_TYPE (init
), sub
);
11633 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
11638 /* INIT is part of the initializer for DECL. If there are any
11639 reference or initializer lists being initialized, extend their
11640 lifetime to match that of DECL. */
11643 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
11645 tree type
= TREE_TYPE (init
);
11646 if (processing_template_decl
)
11648 if (TYPE_REF_P (type
))
11649 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
11653 if (TREE_CODE (ctor
) == TARGET_EXPR
)
11654 ctor
= TARGET_EXPR_INITIAL (ctor
);
11655 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
11657 if (is_std_init_list (type
))
11659 /* The temporary array underlying a std::initializer_list
11660 is handled like a reference temporary. */
11661 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
11662 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
11663 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
11668 constructor_elt
*p
;
11669 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
11670 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
11671 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
11673 recompute_constructor_flags (ctor
);
11674 if (decl_maybe_constant_var_p (decl
) && TREE_CONSTANT (ctor
))
11675 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
11682 /* Returns true iff an initializer for TYPE could contain temporaries that
11683 need to be extended because they are bound to references or
11684 std::initializer_list. */
11687 type_has_extended_temps (tree type
)
11689 type
= strip_array_types (type
);
11690 if (TYPE_REF_P (type
))
11692 if (CLASS_TYPE_P (type
))
11694 if (is_std_init_list (type
))
11696 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
11697 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
11698 if (type_has_extended_temps (TREE_TYPE (f
)))
11704 /* Returns true iff TYPE is some variant of std::initializer_list. */
11707 is_std_init_list (tree type
)
11709 if (!TYPE_P (type
))
11711 if (cxx_dialect
== cxx98
)
11713 /* Look through typedefs. */
11714 type
= TYPE_MAIN_VARIANT (type
);
11715 return (CLASS_TYPE_P (type
)
11716 && CP_TYPE_CONTEXT (type
) == std_node
11717 && init_list_identifier
== DECL_NAME (TYPE_NAME (type
)));
11720 /* Returns true iff DECL is a list constructor: i.e. a constructor which
11721 will accept an argument list of a single std::initializer_list<T>. */
11724 is_list_ctor (tree decl
)
11726 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
11729 if (!args
|| args
== void_list_node
)
11732 arg
= non_reference (TREE_VALUE (args
));
11733 if (!is_std_init_list (arg
))
11736 args
= TREE_CHAIN (args
);
11738 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11739 /* There are more non-defaulted parms. */
11745 #include "gt-cp-call.h"