1 /* Functions related to invoking -*- C++ -*- methods and overloaded functions.
2 Copyright (C) 1987-2024 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"
45 #include "gcc-rich-location.h"
48 /* The various kinds of conversion. */
50 enum conversion_kind
{
65 /* When LOOKUP_SHORTCUT_BAD_CONVS is set, we may return a conversion of
66 this kind whenever we know the true conversion is either bad or outright
67 invalid, but we don't want to attempt to compute the bad conversion (for
68 sake of avoiding unnecessary instantiation). bad_p should always be set
73 /* The rank of the conversion. Order of the enumerals matters; better
74 conversions should come earlier in the list. */
76 enum conversion_rank
{
87 /* An implicit conversion sequence, in the sense of [over.best.ics].
88 The first conversion to be performed is at the end of the chain.
89 That conversion is always a cr_identity conversion. */
92 /* The kind of conversion represented by this step. */
94 /* The rank of this conversion. */
96 BOOL_BITFIELD user_conv_p
: 1;
97 BOOL_BITFIELD ellipsis_p
: 1;
98 BOOL_BITFIELD this_p
: 1;
99 /* True if this conversion would be permitted with a bending of
100 language standards, e.g. disregarding pointer qualifiers or
101 converting integers to pointers. */
102 BOOL_BITFIELD bad_p
: 1;
103 /* If KIND is ck_ref_bind or ck_base, true to indicate that a
104 temporary should be created to hold the result of the
105 conversion. If KIND is ck_ambig or ck_user, true means force
106 copy-initialization. */
107 BOOL_BITFIELD need_temporary_p
: 1;
108 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
109 from a pointer-to-derived to pointer-to-base is being performed. */
110 BOOL_BITFIELD base_p
: 1;
111 /* If KIND is ck_ref_bind, true when either an lvalue reference is
112 being bound to an lvalue expression or an rvalue reference is
113 being bound to an rvalue expression. If KIND is ck_rvalue or ck_base,
114 true when we are treating an lvalue as an rvalue (12.8p33). If
115 ck_identity, we will be binding a reference directly or decaying to
117 BOOL_BITFIELD rvaluedness_matches_p
: 1;
118 BOOL_BITFIELD check_narrowing
: 1;
119 /* Whether check_narrowing should only check TREE_CONSTANTs; used
120 in build_converted_constant_expr. */
121 BOOL_BITFIELD check_narrowing_const_only
: 1;
122 /* True if this conversion is taking place in a copy-initialization context
123 and we should only consider converting constructors. Only set in
124 ck_base and ck_rvalue. */
125 BOOL_BITFIELD copy_init_p
: 1;
126 /* The type of the expression resulting from the conversion. */
129 /* The next conversion in the chain. Since the conversions are
130 arranged from outermost to innermost, the NEXT conversion will
131 actually be performed before this conversion. This variant is
132 used only when KIND is neither ck_identity, ck_aggr, ck_ambig nor
133 ck_list. Please use the next_conversion function instead
134 of using this field directly. */
136 /* The expression at the beginning of the conversion chain. This
137 variant is used only if KIND is ck_identity, ck_aggr, or ck_ambig.
138 You can use conv_get_original_expr to get this expression. */
140 /* The array of conversions for an initializer_list, so this
141 variant is used only when KIN D is ck_list. */
144 /* The function candidate corresponding to this conversion
145 sequence. This field is only used if KIND is ck_user. */
146 struct z_candidate
*cand
;
149 #define CONVERSION_RANK(NODE) \
150 ((NODE)->bad_p ? cr_bad \
151 : (NODE)->ellipsis_p ? cr_ellipsis \
152 : (NODE)->user_conv_p ? cr_user \
155 #define BAD_CONVERSION_RANK(NODE) \
156 ((NODE)->ellipsis_p ? cr_ellipsis \
157 : (NODE)->user_conv_p ? cr_user \
160 static struct obstack conversion_obstack
;
161 static bool conversion_obstack_initialized
;
162 struct rejection_reason
;
164 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
165 static int equal_functions (tree
, tree
);
166 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
168 static int compare_ics (conversion
*, conversion
*);
169 static void maybe_warn_class_memaccess (location_t
, tree
,
170 const vec
<tree
, va_gc
> *);
171 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
172 static tree
convert_like (conversion
*, tree
, tsubst_flags_t
);
173 static tree
convert_like_with_context (conversion
*, tree
, tree
, int,
175 static void op_error (const op_location_t
&, enum tree_code
, enum tree_code
,
176 tree
, tree
, tree
, bool);
177 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
179 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
180 static void print_z_candidates (location_t
, struct z_candidate
*,
181 tristate
= tristate::unknown ());
182 static tree
build_this (tree
);
183 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
184 static bool any_strictly_viable (struct z_candidate
*);
185 static struct z_candidate
*add_template_candidate
186 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
187 tree
, tree
, tree
, int, unification_kind_t
, bool, tsubst_flags_t
);
188 static struct z_candidate
*add_template_candidate_real
189 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
190 tree
, tree
, tree
, int, tree
, unification_kind_t
, bool, tsubst_flags_t
);
191 static bool is_complete (tree
);
192 static struct z_candidate
*add_conv_candidate
193 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
194 tree
, tsubst_flags_t
);
195 static struct z_candidate
*add_function_candidate
196 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
197 tree
, int, conversion
**, bool, tsubst_flags_t
);
198 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
200 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
202 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
203 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
204 static conversion
*next_conversion (conversion
*);
205 static bool is_subseq (conversion
*, conversion
*);
206 static conversion
*maybe_handle_ref_bind (conversion
**);
207 static void maybe_handle_implicit_object (conversion
**);
208 static struct z_candidate
*add_candidate
209 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
210 conversion
**, tree
, tree
, int, struct rejection_reason
*, int);
211 static tree
source_type (conversion
*);
212 static void add_warning (struct z_candidate
*, struct z_candidate
*);
213 static conversion
*direct_reference_binding (tree
, conversion
*);
214 static bool promoted_arithmetic_type_p (tree
);
215 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
216 static char *name_as_c_string (tree
, tree
, bool *);
217 static tree
prep_operand (tree
);
218 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
219 bool, tree
, tree
, int, struct z_candidate
**,
221 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
222 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
223 static conversion
*build_identity_conv (tree
, tree
);
224 static inline bool conv_binds_to_array_of_unknown_bound (conversion
*);
225 static bool conv_is_prvalue (conversion
*);
226 static tree
prevent_lifetime_extension (tree
);
228 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
229 NAME can take many forms... */
232 check_dtor_name (tree basetype
, tree name
)
234 /* Just accept something we've already complained about. */
235 if (name
== error_mark_node
)
238 if (TREE_CODE (name
) == TYPE_DECL
)
239 name
= TREE_TYPE (name
);
240 else if (TYPE_P (name
))
242 else if (identifier_p (name
))
244 if ((MAYBE_CLASS_TYPE_P (basetype
)
245 || TREE_CODE (basetype
) == ENUMERAL_TYPE
)
246 && name
== constructor_name (basetype
))
249 /* Otherwise lookup the name, it could be an unrelated typedef
250 of the correct type. */
251 name
= lookup_name (name
, LOOK_want::TYPE
);
254 name
= TREE_TYPE (name
);
255 if (name
== error_mark_node
)
262 template <class T> struct S { ~S(); };
266 NAME will be a class template. */
267 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
271 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
274 /* We want the address of a function or method. We avoid creating a
275 pointer-to-member function. */
278 build_addr_func (tree function
, tsubst_flags_t complain
)
280 tree type
= TREE_TYPE (function
);
282 /* We have to do these by hand to avoid real pointer to member
284 if (TREE_CODE (type
) == METHOD_TYPE
)
286 if (TREE_CODE (function
) == OFFSET_REF
)
288 tree object
= build_address (TREE_OPERAND (function
, 0));
289 return get_member_function_from_ptrfunc (&object
,
290 TREE_OPERAND (function
, 1),
293 function
= build_address (function
);
295 else if (TREE_CODE (function
) == FUNCTION_DECL
296 && DECL_IMMEDIATE_FUNCTION_P (function
))
297 function
= build_address (function
);
299 function
= decay_conversion (function
, complain
, /*reject_builtin=*/false);
304 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
305 POINTER_TYPE to those. Note, pointer to member function types
306 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
307 two variants. build_call_a is the primitive taking an array of
308 arguments, while build_call_n is a wrapper that handles varargs. */
311 build_call_n (tree function
, int n
, ...)
314 return build_call_a (function
, 0, NULL
);
317 tree
*argarray
= XALLOCAVEC (tree
, n
);
322 for (i
= 0; i
< n
; i
++)
323 argarray
[i
] = va_arg (ap
, tree
);
325 return build_call_a (function
, n
, argarray
);
329 /* Update various flags in cfun and the call itself based on what is being
330 called. Split out of build_call_a so that bot_manip can use it too. */
333 set_flags_from_callee (tree call
)
335 /* Handle both CALL_EXPRs and AGGR_INIT_EXPRs. */
336 tree decl
= cp_get_callee_fndecl_nofold (call
);
338 /* We check both the decl and the type; a function may be known not to
339 throw without being declared throw(). */
340 bool nothrow
= decl
&& TREE_NOTHROW (decl
);
341 tree callee
= cp_get_callee (call
);
343 nothrow
|= TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (callee
)));
344 else if (TREE_CODE (call
) == CALL_EXPR
345 && internal_fn_flags (CALL_EXPR_IFN (call
)) & ECF_NOTHROW
)
348 if (cfun
&& cp_function_chain
&& !cp_unevaluated_operand
)
350 if (!nothrow
&& at_function_scope_p ())
351 cp_function_chain
->can_throw
= 1;
353 if (decl
&& TREE_THIS_VOLATILE (decl
))
354 current_function_returns_abnormally
= 1;
357 TREE_NOTHROW (call
) = nothrow
;
361 build_call_a (tree function
, int n
, tree
*argarray
)
368 function
= build_addr_func (function
, tf_warning_or_error
);
370 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
371 fntype
= TREE_TYPE (TREE_TYPE (function
));
372 gcc_assert (FUNC_OR_METHOD_TYPE_P (fntype
));
373 result_type
= TREE_TYPE (fntype
);
374 /* An rvalue has no cv-qualifiers. */
375 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
376 result_type
= cv_unqualified (result_type
);
378 function
= build_call_array_loc (input_location
,
379 result_type
, function
, n
, argarray
);
380 set_flags_from_callee (function
);
382 decl
= get_callee_fndecl (function
);
384 if (decl
&& !TREE_USED (decl
))
386 /* We invoke build_call directly for several library
387 functions. These may have been declared normally if
388 we're building libgcc, so we can't just check
390 gcc_assert (DECL_ARTIFICIAL (decl
)
391 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
396 require_complete_eh_spec_types (fntype
, decl
);
398 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
400 /* Don't pass empty class objects by value. This is useful
401 for tags in STL, which are used to control overload resolution.
402 We don't need to handle other cases of copying empty classes. */
403 if (!decl
|| !fndecl_built_in_p (decl
))
404 for (i
= 0; i
< n
; i
++)
406 tree arg
= CALL_EXPR_ARG (function
, i
);
407 if (is_empty_class (TREE_TYPE (arg
))
408 && simple_empty_class_p (TREE_TYPE (arg
), arg
, INIT_EXPR
))
410 while (TREE_CODE (arg
) == TARGET_EXPR
)
411 /* We're disconnecting the initializer from its target,
412 don't create a temporary. */
413 arg
= TARGET_EXPR_INITIAL (arg
);
414 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (arg
));
415 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (t
), arg
, t
);
416 CALL_EXPR_ARG (function
, i
) = arg
;
423 /* New overloading code. */
427 struct candidate_warning
{
429 candidate_warning
*next
;
432 /* Information for providing diagnostics about why overloading failed. */
434 enum rejection_reason_code
{
437 rr_explicit_conversion
,
438 rr_template_conversion
,
440 rr_bad_arg_conversion
,
441 rr_template_unification
,
444 rr_constraint_failure
,
448 struct conversion_info
{
449 /* The index of the argument, 0-based. */
451 /* The actual argument or its type. */
453 /* The type of the parameter. */
455 /* The location of the argument. */
459 struct rejection_reason
{
460 enum rejection_reason_code code
;
462 /* Information about an arity mismatch. */
464 /* The expected number of arguments. */
466 /* The actual number of arguments in the call. */
468 /* Whether EXPECTED should be treated as a lower bound. */
471 /* Information about an argument conversion mismatch. */
472 struct conversion_info conversion
;
473 /* Same, but for bad argument conversions. */
474 struct conversion_info bad_conversion
;
475 /* Information about template unification failures. These are the
476 parameters passed to fn_type_unification. */
484 unification_kind_t strict
;
486 } template_unification
;
487 /* Information about template instantiation failures. These are the
488 parameters passed to instantiate_template. */
492 } template_instantiation
;
497 /* The FUNCTION_DECL that will be called if this candidate is
498 selected by overload resolution. */
500 /* If not NULL_TREE, the first argument to use when calling this
503 /* The rest of the arguments to use when calling this function. If
504 there are no further arguments this may be NULL or it may be an
506 const vec
<tree
, va_gc
> *args
;
507 /* The implicit conversion sequences for each of the arguments to
510 /* The number of implicit conversion sequences. */
512 /* If FN is a user-defined conversion, the standard conversion
513 sequence from the type returned by FN to the desired destination
515 conversion
*second_conv
;
516 struct rejection_reason
*reason
;
517 /* If FN is a member function, the binfo indicating the path used to
518 qualify the name of FN at the call site. This path is used to
519 determine whether or not FN is accessible if it is selected by
520 overload resolution. The DECL_CONTEXT of FN will always be a
521 (possibly improper) base of this binfo. */
523 /* If FN is a non-static member function, the binfo indicating the
524 subobject to which the `this' pointer should be converted if FN
525 is selected by overload resolution. The type pointed to by
526 the `this' pointer must correspond to the most derived class
527 indicated by the CONVERSION_PATH. */
528 tree conversion_path
;
531 candidate_warning
*warnings
;
535 /* The flags active in add_candidate. */
538 bool rewritten () const { return (flags
& LOOKUP_REWRITTEN
); }
539 bool reversed () const { return (flags
& LOOKUP_REVERSED
); }
542 /* Returns true iff T is a null pointer constant in the sense of
546 null_ptr_cst_p (tree t
)
548 tree type
= TREE_TYPE (t
);
552 A null pointer constant is an integer literal ([lex.icon]) with value
553 zero or a prvalue of type std::nullptr_t. */
554 if (NULLPTR_TYPE_P (type
))
557 if (cxx_dialect
>= cxx11
)
559 STRIP_ANY_LOCATION_WRAPPER (t
);
561 /* Core issue 903 says only literal 0 is a null pointer constant. */
562 if (TREE_CODE (t
) == INTEGER_CST
563 && !TREE_OVERFLOW (t
)
564 && TREE_CODE (type
) == INTEGER_TYPE
566 && !char_type_p (type
))
569 else if (CP_INTEGRAL_TYPE_P (type
))
571 t
= fold_non_dependent_expr (t
, tf_none
);
573 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
580 /* Returns true iff T is a null member pointer value (4.11). */
583 null_member_pointer_value_p (tree t
)
585 tree type
= TREE_TYPE (t
);
588 else if (TYPE_PTRMEMFUNC_P (type
))
589 return (TREE_CODE (t
) == CONSTRUCTOR
590 && CONSTRUCTOR_NELTS (t
)
591 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
592 else if (TYPE_PTRDATAMEM_P (type
))
593 return integer_all_onesp (t
);
598 /* Returns nonzero if PARMLIST consists of only default parms,
599 ellipsis, and/or undeduced parameter packs. */
602 sufficient_parms_p (const_tree parmlist
)
604 for (; parmlist
&& parmlist
!= void_list_node
;
605 parmlist
= TREE_CHAIN (parmlist
))
606 if (!TREE_PURPOSE (parmlist
)
607 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
612 /* Allocate N bytes of memory from the conversion obstack. The memory
613 is zeroed before being returned. */
616 conversion_obstack_alloc (size_t n
)
619 if (!conversion_obstack_initialized
)
621 gcc_obstack_init (&conversion_obstack
);
622 conversion_obstack_initialized
= true;
624 p
= obstack_alloc (&conversion_obstack
, n
);
629 /* RAII class to discard anything added to conversion_obstack. */
631 struct conversion_obstack_sentinel
634 conversion_obstack_sentinel (): p (conversion_obstack_alloc (0)) {}
635 ~conversion_obstack_sentinel () { obstack_free (&conversion_obstack
, p
); }
638 /* Allocate rejection reasons. */
640 static struct rejection_reason
*
641 alloc_rejection (enum rejection_reason_code code
)
643 struct rejection_reason
*p
;
644 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
649 static struct rejection_reason
*
650 arity_rejection (tree first_arg
, int expected
, int actual
, bool least_p
= false)
652 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
653 int adjust
= first_arg
!= NULL_TREE
;
654 r
->u
.arity
.expected
= expected
- adjust
;
655 r
->u
.arity
.actual
= actual
- adjust
;
656 r
->u
.arity
.least_p
= least_p
;
660 static struct rejection_reason
*
661 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
,
664 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
665 int adjust
= first_arg
!= NULL_TREE
;
666 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
667 r
->u
.conversion
.from
= from
;
668 r
->u
.conversion
.to_type
= to
;
669 r
->u
.conversion
.loc
= loc
;
673 static struct rejection_reason
*
674 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
,
677 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
678 int adjust
= first_arg
!= NULL_TREE
;
679 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
680 r
->u
.bad_conversion
.from
= from
;
681 r
->u
.bad_conversion
.to_type
= to
;
682 r
->u
.bad_conversion
.loc
= loc
;
686 static struct rejection_reason
*
687 explicit_conversion_rejection (tree from
, tree to
)
689 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
690 r
->u
.conversion
.n_arg
= 0;
691 r
->u
.conversion
.from
= from
;
692 r
->u
.conversion
.to_type
= to
;
693 r
->u
.conversion
.loc
= UNKNOWN_LOCATION
;
697 static struct rejection_reason
*
698 template_conversion_rejection (tree from
, tree to
)
700 struct rejection_reason
*r
= alloc_rejection (rr_template_conversion
);
701 r
->u
.conversion
.n_arg
= 0;
702 r
->u
.conversion
.from
= from
;
703 r
->u
.conversion
.to_type
= to
;
704 r
->u
.conversion
.loc
= UNKNOWN_LOCATION
;
708 static struct rejection_reason
*
709 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
710 const tree
*args
, unsigned int nargs
,
711 tree return_type
, unification_kind_t strict
,
714 size_t args_n_bytes
= sizeof (*args
) * nargs
;
715 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
716 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
717 r
->u
.template_unification
.tmpl
= tmpl
;
718 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
719 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
720 /* Copy args to our own storage. */
721 memcpy (args1
, args
, args_n_bytes
);
722 r
->u
.template_unification
.args
= args1
;
723 r
->u
.template_unification
.nargs
= nargs
;
724 r
->u
.template_unification
.return_type
= return_type
;
725 r
->u
.template_unification
.strict
= strict
;
726 r
->u
.template_unification
.flags
= flags
;
730 static struct rejection_reason
*
731 template_unification_error_rejection (void)
733 return alloc_rejection (rr_template_unification
);
736 static struct rejection_reason
*
737 invalid_copy_with_fn_template_rejection (void)
739 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
743 static struct rejection_reason
*
744 inherited_ctor_rejection (void)
746 struct rejection_reason
*r
= alloc_rejection (rr_inherited_ctor
);
750 /* Build a constraint failure record. */
752 static struct rejection_reason
*
753 constraint_failure (void)
755 struct rejection_reason
*r
= alloc_rejection (rr_constraint_failure
);
759 /* Dynamically allocate a conversion. */
762 alloc_conversion (conversion_kind kind
)
765 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
770 /* Make sure that all memory on the conversion obstack has been
774 validate_conversion_obstack (void)
776 if (conversion_obstack_initialized
)
777 gcc_assert ((obstack_next_free (&conversion_obstack
)
778 == obstack_base (&conversion_obstack
)));
781 /* Dynamically allocate an array of N conversions. */
784 alloc_conversions (size_t n
)
786 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
789 /* True iff the active member of conversion::u for code CODE is NEXT. */
792 has_next (conversion_kind code
)
794 return !(code
== ck_identity
798 || code
== ck_deferred_bad
);
802 build_conv (conversion_kind code
, tree type
, conversion
*from
)
805 conversion_rank rank
= CONVERSION_RANK (from
);
807 /* Only call this function for conversions that use u.next. */
808 gcc_assert (from
== NULL
|| has_next (code
));
810 /* Note that the caller is responsible for filling in t->cand for
811 user-defined conversions. */
812 t
= alloc_conversion (code
);
836 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
837 t
->bad_p
= from
->bad_p
;
842 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
843 specialization of std::initializer_list<T>, if such a conversion is
847 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
849 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
850 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
851 conversion
**subconvs
= alloc_conversions (len
);
856 /* Within a list-initialization we can have more user-defined
858 flags
&= ~LOOKUP_NO_CONVERSION
;
859 /* But no narrowing conversions. */
860 flags
|= LOOKUP_NO_NARROWING
;
862 /* Can't make an array of these types. */
863 if (TYPE_REF_P (elttype
)
864 || TREE_CODE (elttype
) == FUNCTION_TYPE
865 || VOID_TYPE_P (elttype
))
868 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
871 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
872 false, flags
, complain
);
879 t
= alloc_conversion (ck_list
);
881 t
->u
.list
= subconvs
;
884 for (i
= 0; i
< len
; ++i
)
886 conversion
*sub
= subconvs
[i
];
887 if (sub
->rank
> t
->rank
)
889 if (sub
->user_conv_p
)
890 t
->user_conv_p
= true;
898 /* Return the next conversion of the conversion chain (if applicable),
899 or NULL otherwise. Please use this function instead of directly
900 accessing fields of struct conversion. */
903 next_conversion (conversion
*conv
)
906 || !has_next (conv
->kind
))
911 /* Strip to the first ck_user, ck_ambig, ck_list, ck_aggr or ck_identity
915 strip_standard_conversion (conversion
*conv
)
918 && conv
->kind
!= ck_user
919 && has_next (conv
->kind
))
920 conv
= next_conversion (conv
);
924 /* Subroutine of build_aggr_conv: check whether FROM is a valid aggregate
925 initializer for array type ATYPE. */
928 can_convert_array (tree atype
, tree from
, int flags
, tsubst_flags_t complain
)
930 tree elttype
= TREE_TYPE (atype
);
933 if (TREE_CODE (from
) == CONSTRUCTOR
)
935 for (i
= 0; i
< CONSTRUCTOR_NELTS (from
); ++i
)
937 tree val
= CONSTRUCTOR_ELT (from
, i
)->value
;
939 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
940 ok
= can_convert_array (elttype
, val
, flags
, complain
);
942 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
950 if (char_type_p (TYPE_MAIN_VARIANT (elttype
))
951 && TREE_CODE (tree_strip_any_location_wrapper (from
)) == STRING_CST
)
952 return array_string_literal_compatible_p (atype
, from
);
954 /* No other valid way to aggregate initialize an array. */
958 /* Helper for build_aggr_conv. Return true if FIELD is in PSET, or if
959 FIELD has ANON_AGGR_TYPE_P and any initializable field in there recursively
963 field_in_pset (hash_set
<tree
, true> &pset
, tree field
)
965 if (pset
.contains (field
))
967 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
968 for (field
= TYPE_FIELDS (TREE_TYPE (field
));
969 field
; field
= DECL_CHAIN (field
))
971 field
= next_aggregate_field (field
);
972 if (field
== NULL_TREE
)
974 if (field_in_pset (pset
, field
))
980 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
981 aggregate class, if such a conversion is possible. */
984 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
986 unsigned HOST_WIDE_INT i
= 0;
988 tree field
= next_aggregate_field (TYPE_FIELDS (type
));
989 tree empty_ctor
= NULL_TREE
;
990 hash_set
<tree
, true> pset
;
992 /* We already called reshape_init in implicit_conversion, but it might not
993 have done anything in the case of parenthesized aggr init. */
995 /* The conversions within the init-list aren't affected by the enclosing
996 context; they're always simple copy-initialization. */
997 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
999 /* For designated initializers, verify that each initializer is convertible
1000 to corresponding TREE_TYPE (ce->index) and mark those FIELD_DECLs as
1001 visited. In the following loop then ignore already visited
1004 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), i
, idx
, val
)
1009 gcc_checking_assert (TREE_CODE (idx
) == FIELD_DECL
);
1011 tree ftype
= TREE_TYPE (idx
);
1014 if (TREE_CODE (ftype
) == ARRAY_TYPE
)
1015 ok
= can_convert_array (ftype
, val
, flags
, complain
);
1017 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
1023 /* For unions, there should be just one initializer. */
1024 if (TREE_CODE (type
) == UNION_TYPE
)
1033 for (; field
; field
= next_aggregate_field (DECL_CHAIN (field
)))
1035 tree ftype
= TREE_TYPE (field
);
1038 if (!pset
.is_empty () && field_in_pset (pset
, field
))
1040 if (i
< CONSTRUCTOR_NELTS (ctor
))
1042 constructor_elt
*ce
= CONSTRUCTOR_ELT (ctor
, i
);
1043 gcc_checking_assert (!ce
->index
);
1047 else if (DECL_INITIAL (field
))
1048 val
= get_nsdmi (field
, /*ctor*/false, complain
);
1049 else if (TYPE_REF_P (ftype
))
1050 /* Value-initialization of reference is ill-formed. */
1054 if (empty_ctor
== NULL_TREE
)
1055 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
1059 if (TREE_CODE (ftype
) == ARRAY_TYPE
)
1060 ok
= can_convert_array (ftype
, val
, flags
, complain
);
1062 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
1068 if (TREE_CODE (type
) == UNION_TYPE
)
1072 if (i
< CONSTRUCTOR_NELTS (ctor
))
1075 c
= alloc_conversion (ck_aggr
);
1078 c
->user_conv_p
= true;
1079 c
->check_narrowing
= true;
1084 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
1085 array type, if such a conversion is possible. */
1088 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
1091 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1092 tree elttype
= TREE_TYPE (type
);
1095 enum conversion_rank rank
= cr_exact
;
1097 /* We might need to propagate the size from the element to the array. */
1098 complete_type (type
);
1100 if (TYPE_DOMAIN (type
)
1101 && !variably_modified_type_p (TYPE_DOMAIN (type
), NULL_TREE
))
1103 unsigned HOST_WIDE_INT alen
= tree_to_uhwi (array_type_nelts_top (type
));
1108 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1110 for (auto &e
: CONSTRUCTOR_ELTS (ctor
))
1113 = implicit_conversion (elttype
, TREE_TYPE (e
.value
), e
.value
,
1114 false, flags
, complain
);
1118 if (sub
->rank
> rank
)
1120 if (sub
->user_conv_p
)
1126 c
= alloc_conversion (ck_aggr
);
1129 c
->user_conv_p
= user
;
1135 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
1136 complex type, if such a conversion is possible. */
1139 build_complex_conv (tree type
, tree ctor
, int flags
,
1140 tsubst_flags_t complain
)
1143 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1144 tree elttype
= TREE_TYPE (type
);
1147 enum conversion_rank rank
= cr_exact
;
1152 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1154 for (auto &e
: CONSTRUCTOR_ELTS (ctor
))
1157 = implicit_conversion (elttype
, TREE_TYPE (e
.value
), e
.value
,
1158 false, flags
, complain
);
1162 if (sub
->rank
> rank
)
1164 if (sub
->user_conv_p
)
1170 c
= alloc_conversion (ck_aggr
);
1173 c
->user_conv_p
= user
;
1179 /* Build a representation of the identity conversion from EXPR to
1180 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1183 build_identity_conv (tree type
, tree expr
)
1187 c
= alloc_conversion (ck_identity
);
1194 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1195 were multiple user-defined conversions to accomplish the job.
1196 Build a conversion that indicates that ambiguity. */
1199 build_ambiguous_conv (tree type
, tree expr
)
1203 c
= alloc_conversion (ck_ambig
);
1211 strip_top_quals (tree t
)
1213 if (TREE_CODE (t
) == ARRAY_TYPE
)
1215 return cp_build_qualified_type (t
, 0);
1218 /* Returns the standard conversion path (see [conv]) from type FROM to type
1219 TO, if any. For proper handling of null pointer constants, you must
1220 also pass the expression EXPR to convert from. If C_CAST_P is true,
1221 this conversion is coming from a C-style cast. */
1224 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1225 int flags
, tsubst_flags_t complain
)
1227 enum tree_code fcode
, tcode
;
1229 bool fromref
= false;
1232 to
= non_reference (to
);
1233 if (TYPE_REF_P (from
))
1236 from
= TREE_TYPE (from
);
1239 to
= strip_top_quals (to
);
1240 from
= strip_top_quals (from
);
1242 if (expr
&& type_unknown_p (expr
))
1244 if (TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1246 tsubst_flags_t tflags
= tf_conv
;
1247 expr
= instantiate_type (to
, expr
, tflags
);
1248 if (expr
== error_mark_node
)
1250 from
= TREE_TYPE (expr
);
1252 else if (TREE_CODE (to
) == BOOLEAN_TYPE
)
1254 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1255 expr
= resolve_nondeduced_context (expr
, complain
);
1256 from
= TREE_TYPE (expr
);
1260 fcode
= TREE_CODE (from
);
1261 tcode
= TREE_CODE (to
);
1263 conv
= build_identity_conv (from
, expr
);
1264 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1266 from
= type_decays_to (from
);
1267 fcode
= TREE_CODE (from
);
1268 /* Tell convert_like that we're using the address. */
1269 conv
->rvaluedness_matches_p
= true;
1270 conv
= build_conv (ck_lvalue
, from
, conv
);
1272 /* Wrapping a ck_rvalue around a class prvalue (as a result of using
1273 obvalue_p) seems odd, since it's already a prvalue, but that's how we
1274 express the copy constructor call required by copy-initialization. */
1275 else if (fromref
|| (expr
&& obvalue_p (expr
)))
1280 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1283 from
= strip_top_quals (bitfield_type
);
1284 fcode
= TREE_CODE (from
);
1287 conv
= build_conv (ck_rvalue
, from
, conv
);
1288 /* If we're performing copy-initialization, remember to skip
1289 explicit constructors. */
1290 if (flags
& LOOKUP_ONLYCONVERTING
)
1291 conv
->copy_init_p
= true;
1294 /* Allow conversion between `__complex__' data types. */
1295 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1297 /* The standard conversion sequence to convert FROM to TO is
1298 the standard conversion sequence to perform componentwise
1300 conversion
*part_conv
= standard_conversion
1301 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
,
1306 else if (part_conv
->kind
== ck_identity
)
1307 /* Leave conv alone. */;
1310 conv
= build_conv (part_conv
->kind
, to
, conv
);
1311 conv
->rank
= part_conv
->rank
;
1317 if (same_type_p (from
, to
))
1319 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1320 conv
->type
= qualified_to
;
1325 A null pointer constant can be converted to a pointer type; ... A
1326 null pointer constant of integral type can be converted to an
1327 rvalue of type std::nullptr_t. */
1328 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1329 || NULLPTR_TYPE_P (to
))
1330 && ((expr
&& null_ptr_cst_p (expr
))
1331 || NULLPTR_TYPE_P (from
)))
1332 conv
= build_conv (ck_std
, to
, conv
);
1333 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1334 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1336 /* For backwards brain damage compatibility, allow interconversion of
1337 pointers and integers with a pedwarn. */
1338 conv
= build_conv (ck_std
, to
, conv
);
1341 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1343 /* For backwards brain damage compatibility, allow interconversion of
1344 enums and integers with a pedwarn. */
1345 conv
= build_conv (ck_std
, to
, conv
);
1348 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1349 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1354 if (tcode
== POINTER_TYPE
)
1356 to_pointee
= TREE_TYPE (to
);
1357 from_pointee
= TREE_TYPE (from
);
1359 /* Since this is the target of a pointer, it can't have function
1360 qualifiers, so any TYPE_QUALS must be for attributes const or
1361 noreturn. Strip them. */
1362 if (TREE_CODE (to_pointee
) == FUNCTION_TYPE
1363 && TYPE_QUALS (to_pointee
))
1364 to_pointee
= build_qualified_type (to_pointee
, TYPE_UNQUALIFIED
);
1365 if (TREE_CODE (from_pointee
) == FUNCTION_TYPE
1366 && TYPE_QUALS (from_pointee
))
1367 from_pointee
= build_qualified_type (from_pointee
, TYPE_UNQUALIFIED
);
1371 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1372 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1375 if (tcode
== POINTER_TYPE
1376 && same_type_ignoring_top_level_qualifiers_p (from_pointee
,
1379 else if (VOID_TYPE_P (to_pointee
)
1380 && !TYPE_PTRDATAMEM_P (from
)
1381 && TREE_CODE (from_pointee
) != FUNCTION_TYPE
)
1383 tree nfrom
= TREE_TYPE (from
);
1384 /* Don't try to apply restrict to void. */
1385 int quals
= cp_type_quals (nfrom
) & ~TYPE_QUAL_RESTRICT
;
1386 from_pointee
= cp_build_qualified_type (void_type_node
, quals
);
1387 from
= build_pointer_type (from_pointee
);
1388 conv
= build_conv (ck_ptr
, from
, conv
);
1390 else if (TYPE_PTRDATAMEM_P (from
))
1392 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1393 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1395 if (same_type_p (fbase
, tbase
))
1396 /* No base conversion needed. */;
1397 else if (DERIVED_FROM_P (fbase
, tbase
)
1398 && (same_type_ignoring_top_level_qualifiers_p
1399 (from_pointee
, to_pointee
)))
1401 from
= build_ptrmem_type (tbase
, from_pointee
);
1402 conv
= build_conv (ck_pmem
, from
, conv
);
1407 else if (CLASS_TYPE_P (from_pointee
)
1408 && CLASS_TYPE_P (to_pointee
)
1411 An rvalue of type "pointer to cv D," where D is a
1412 class type, can be converted to an rvalue of type
1413 "pointer to cv B," where B is a base class (clause
1414 _class.derived_) of D. If B is an inaccessible
1415 (clause _class.access_) or ambiguous
1416 (_class.member.lookup_) base class of D, a program
1417 that necessitates this conversion is ill-formed.
1418 Therefore, we use DERIVED_FROM_P, and do not check
1419 access or uniqueness. */
1420 && DERIVED_FROM_P (to_pointee
, from_pointee
))
1423 = cp_build_qualified_type (to_pointee
,
1424 cp_type_quals (from_pointee
));
1425 from
= build_pointer_type (from_pointee
);
1426 conv
= build_conv (ck_ptr
, from
, conv
);
1427 conv
->base_p
= true;
1430 if (same_type_p (from
, to
))
1432 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
, bounds_either
))
1433 /* In a C-style cast, we ignore CV-qualification because we
1434 are allowed to perform a static_cast followed by a
1436 conv
= build_conv (ck_qual
, to
, conv
);
1437 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1438 conv
= build_conv (ck_qual
, to
, conv
);
1439 else if (expr
&& string_conv_p (to
, expr
, 0))
1440 /* converting from string constant to char *. */
1441 conv
= build_conv (ck_qual
, to
, conv
);
1442 else if (fnptr_conv_p (to
, from
))
1443 conv
= build_conv (ck_fnptr
, to
, conv
);
1444 /* Allow conversions among compatible ObjC pointer types (base
1445 conversions have been already handled above). */
1446 else if (c_dialect_objc ()
1447 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1448 conv
= build_conv (ck_ptr
, to
, conv
);
1449 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1451 conv
= build_conv (ck_ptr
, to
, conv
);
1459 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1461 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1462 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1463 tree fbase
= class_of_this_parm (fromfn
);
1464 tree tbase
= class_of_this_parm (tofn
);
1466 /* If FBASE and TBASE are equivalent but incomplete, DERIVED_FROM_P
1467 yields false. But a pointer to member of incomplete class is OK. */
1468 if (!same_type_p (fbase
, tbase
) && !DERIVED_FROM_P (fbase
, tbase
))
1471 tree fstat
= static_fn_type (fromfn
);
1472 tree tstat
= static_fn_type (tofn
);
1473 if (same_type_p (tstat
, fstat
)
1474 || fnptr_conv_p (tstat
, fstat
))
1479 if (!same_type_p (fbase
, tbase
))
1481 from
= build_memfn_type (fstat
,
1483 cp_type_quals (tbase
),
1484 type_memfn_rqual (tofn
));
1485 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1486 conv
= build_conv (ck_pmem
, from
, conv
);
1487 conv
->base_p
= true;
1489 if (fnptr_conv_p (tstat
, fstat
))
1490 conv
= build_conv (ck_fnptr
, to
, conv
);
1492 else if (tcode
== BOOLEAN_TYPE
)
1496 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1497 to member type can be converted to a prvalue of type bool. ...
1498 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1499 std::nullptr_t can be converted to a prvalue of type bool; */
1500 if (ARITHMETIC_TYPE_P (from
)
1501 || UNSCOPED_ENUM_P (from
)
1502 || fcode
== POINTER_TYPE
1503 || TYPE_PTRMEM_P (from
)
1504 || NULLPTR_TYPE_P (from
))
1506 conv
= build_conv (ck_std
, to
, conv
);
1507 if (fcode
== POINTER_TYPE
1508 || TYPE_PTRDATAMEM_P (from
)
1509 || (TYPE_PTRMEMFUNC_P (from
)
1510 && conv
->rank
< cr_pbool
)
1511 || NULLPTR_TYPE_P (from
))
1512 conv
->rank
= cr_pbool
;
1513 if (NULLPTR_TYPE_P (from
) && (flags
& LOOKUP_ONLYCONVERTING
))
1515 if (flags
& LOOKUP_NO_NARROWING
)
1516 conv
->check_narrowing
= true;
1522 /* We don't check for ENUMERAL_TYPE here because there are no standard
1523 conversions to enum type. */
1524 /* As an extension, allow conversion to complex type. */
1525 else if (ARITHMETIC_TYPE_P (to
))
1527 if (! (INTEGRAL_CODE_P (fcode
)
1528 || (fcode
== REAL_TYPE
&& !(flags
& LOOKUP_NO_NON_INTEGRAL
)))
1529 || SCOPED_ENUM_P (from
))
1532 /* If we're parsing an enum with no fixed underlying type, we're
1533 dealing with an incomplete type, which renders the conversion
1535 if (!COMPLETE_TYPE_P (from
))
1538 conv
= build_conv (ck_std
, to
, conv
);
1540 tree underlying_type
= NULL_TREE
;
1541 if (TREE_CODE (from
) == ENUMERAL_TYPE
1542 && ENUM_FIXED_UNDERLYING_TYPE_P (from
))
1543 underlying_type
= ENUM_UNDERLYING_TYPE (from
);
1545 /* Give this a better rank if it's a promotion.
1547 To handle CWG 1601, also bump the rank if we are converting
1548 an enumeration with a fixed underlying type to the underlying
1550 if ((same_type_p (to
, type_promotes_to (from
))
1551 || (underlying_type
&& same_type_p (to
, underlying_type
)))
1552 && next_conversion (conv
)->rank
<= cr_promotion
)
1553 conv
->rank
= cr_promotion
;
1555 /* A prvalue of floating-point type can be converted to a prvalue of
1556 another floating-point type with a greater or equal conversion
1557 rank ([conv.rank]). A prvalue of standard floating-point type can
1558 be converted to a prvalue of another standard floating-point type.
1559 For backwards compatibility with handling __float128 and other
1560 non-standard floating point types, allow all implicit floating
1561 point conversions if neither type is extended floating-point
1562 type and if at least one of them is, fail if they have unordered
1563 conversion rank or from has higher conversion rank. */
1564 if (fcode
== REAL_TYPE
1565 && tcode
== REAL_TYPE
1566 && (extended_float_type_p (from
)
1567 || extended_float_type_p (to
))
1568 && cp_compare_floating_point_conversion_ranks (from
, to
) >= 2)
1571 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1572 && vector_types_convertible_p (from
, to
, false))
1573 return build_conv (ck_std
, to
, conv
);
1574 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1575 && is_properly_derived_from (from
, to
))
1577 if (conv
->kind
== ck_rvalue
)
1578 conv
= next_conversion (conv
);
1579 conv
= build_conv (ck_base
, to
, conv
);
1580 /* The derived-to-base conversion indicates the initialization
1581 of a parameter with base type from an object of a derived
1582 type. A temporary object is created to hold the result of
1583 the conversion unless we're binding directly to a reference. */
1584 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1585 /* If we're performing copy-initialization, remember to skip
1586 explicit constructors. */
1587 if (flags
& LOOKUP_ONLYCONVERTING
)
1588 conv
->copy_init_p
= true;
1593 if (flags
& LOOKUP_NO_NARROWING
)
1594 conv
->check_narrowing
= true;
1599 /* Returns nonzero if T1 is reference-related to T2. */
1602 reference_related_p (tree t1
, tree t2
)
1604 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1607 t1
= TYPE_MAIN_VARIANT (t1
);
1608 t2
= TYPE_MAIN_VARIANT (t2
);
1612 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1613 to "cv2 T2" if T1 is similar to T2, or T1 is a base class of T2. */
1614 return (similar_type_p (t1
, t2
)
1615 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1616 && DERIVED_FROM_P (t1
, t2
)));
1619 /* Returns nonzero if T1 is reference-compatible with T2. */
1622 reference_compatible_p (tree t1
, tree t2
)
1626 "cv1 T1" is reference compatible with "cv2 T2" if
1627 a prvalue of type "pointer to cv2 T2" can be converted to the type
1628 "pointer to cv1 T1" via a standard conversion sequence. */
1629 tree ptype1
= build_pointer_type (t1
);
1630 tree ptype2
= build_pointer_type (t2
);
1631 conversion
*conv
= standard_conversion (ptype1
, ptype2
, NULL_TREE
,
1632 /*c_cast_p=*/false, 0, tf_none
);
1633 if (!conv
|| conv
->bad_p
)
1638 /* Return true if converting FROM to TO would involve a qualification
1642 involves_qualification_conversion_p (tree to
, tree from
)
1644 /* If we're not convering a pointer to another one, we won't get
1645 a qualification conversion. */
1646 if (!((TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
1647 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
))))
1650 conversion
*conv
= standard_conversion (to
, from
, NULL_TREE
,
1651 /*c_cast_p=*/false, 0, tf_none
);
1652 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1653 if (t
->kind
== ck_qual
)
1659 /* A reference of the indicated TYPE is being bound directly to the
1660 expression represented by the implicit conversion sequence CONV.
1661 Return a conversion sequence for this binding. */
1664 direct_reference_binding (tree type
, conversion
*conv
)
1668 gcc_assert (TYPE_REF_P (type
));
1669 gcc_assert (!TYPE_REF_P (conv
->type
));
1671 t
= TREE_TYPE (type
);
1673 if (conv
->kind
== ck_identity
)
1674 /* Mark the identity conv as to not decay to rvalue. */
1675 conv
->rvaluedness_matches_p
= true;
1679 When a parameter of reference type binds directly
1680 (_dcl.init.ref_) to an argument expression, the implicit
1681 conversion sequence is the identity conversion, unless the
1682 argument expression has a type that is a derived class of the
1683 parameter type, in which case the implicit conversion sequence is
1684 a derived-to-base Conversion.
1686 If the parameter binds directly to the result of applying a
1687 conversion function to the argument expression, the implicit
1688 conversion sequence is a user-defined conversion sequence
1689 (_over.ics.user_), with the second standard conversion sequence
1690 either an identity conversion or, if the conversion function
1691 returns an entity of a type that is a derived class of the
1692 parameter type, a derived-to-base conversion. */
1693 if (is_properly_derived_from (conv
->type
, t
))
1695 /* Represent the derived-to-base conversion. */
1696 conv
= build_conv (ck_base
, t
, conv
);
1697 /* We will actually be binding to the base-class subobject in
1698 the derived class, so we mark this conversion appropriately.
1699 That way, convert_like knows not to generate a temporary. */
1700 conv
->need_temporary_p
= false;
1702 else if (involves_qualification_conversion_p (t
, conv
->type
))
1703 /* Represent the qualification conversion. After DR 2352
1704 #1 and #2 were indistinguishable conversion sequences:
1707 void f(const int* const &); // #2
1708 void g(int* p) { f(p); }
1710 because the types "int *" and "const int *const" are
1711 reference-related and we were binding both directly and they
1712 had the same rank. To break it up, we add a ck_qual under the
1713 ck_ref_bind so that conversion sequence ranking chooses #1.
1715 We strip_top_quals here which is also what standard_conversion
1716 does. Failure to do so would confuse comp_cv_qual_signature
1717 into thinking that in
1719 void f(const int * const &); // #1
1720 void f(const int *); // #2
1724 #2 is a better match than #1 even though they're ambiguous (97296). */
1725 conv
= build_conv (ck_qual
, strip_top_quals (t
), conv
);
1727 return build_conv (ck_ref_bind
, type
, conv
);
1730 /* Returns the conversion path from type FROM to reference type TO for
1731 purposes of reference binding. For lvalue binding, either pass a
1732 reference type to FROM or an lvalue expression to EXPR. If the
1733 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1734 the conversion returned. If C_CAST_P is true, this
1735 conversion is coming from a C-style cast. */
1738 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1739 tsubst_flags_t complain
)
1741 conversion
*conv
= NULL
;
1742 conversion
*bad_direct_conv
= nullptr;
1743 tree to
= TREE_TYPE (rto
);
1748 cp_lvalue_kind gl_kind
;
1751 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1753 expr
= instantiate_type (to
, expr
, tf_none
);
1754 if (expr
== error_mark_node
)
1756 from
= TREE_TYPE (expr
);
1759 bool copy_list_init
= false;
1760 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1762 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1763 /* DR 1288: Otherwise, if the initializer list has a single element
1764 of type E and ... [T's] referenced type is reference-related to E,
1765 the object or reference is initialized from that element...
1767 ??? With P0388R4, we should bind 't' directly to U{}:
1770 because A[] and A[2] are reference-related. But we don't do it
1771 because grok_reference_init has deduced the array size (to 1), and
1772 A[1] and A[2] aren't reference-related. */
1773 if (CONSTRUCTOR_NELTS (expr
) == 1
1774 && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
))
1776 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1777 if (error_operand_p (elt
))
1779 tree etype
= TREE_TYPE (elt
);
1780 if (reference_related_p (to
, etype
))
1787 /* Otherwise, if T is a reference type, a prvalue temporary of the type
1788 referenced by T is copy-list-initialized, and the reference is bound
1789 to that temporary. */
1790 copy_list_init
= true;
1794 if (TYPE_REF_P (from
))
1796 from
= TREE_TYPE (from
);
1797 if (!TYPE_REF_IS_RVALUE (rfrom
)
1798 || TREE_CODE (from
) == FUNCTION_TYPE
)
1799 gl_kind
= clk_ordinary
;
1801 gl_kind
= clk_rvalueref
;
1804 gl_kind
= lvalue_kind (expr
);
1805 else if (CLASS_TYPE_P (from
)
1806 || TREE_CODE (from
) == ARRAY_TYPE
)
1807 gl_kind
= clk_class
;
1811 /* Don't allow a class prvalue when LOOKUP_NO_TEMP_BIND. */
1812 if ((flags
& LOOKUP_NO_TEMP_BIND
)
1813 && (gl_kind
& clk_class
))
1816 /* Same mask as real_lvalue_p. */
1817 is_lvalue
= gl_kind
&& !(gl_kind
& (clk_rvalueref
|clk_class
));
1820 if ((gl_kind
& clk_bitfield
) != 0)
1821 tfrom
= unlowered_expr_type (expr
);
1823 /* Figure out whether or not the types are reference-related and
1824 reference compatible. We have to do this after stripping
1825 references from FROM. */
1826 related_p
= reference_related_p (to
, tfrom
);
1827 /* If this is a C cast, first convert to an appropriately qualified
1828 type, so that we can later do a const_cast to the desired type. */
1829 if (related_p
&& c_cast_p
1830 && !at_least_as_qualified_p (to
, tfrom
))
1831 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1832 compatible_p
= reference_compatible_p (to
, tfrom
);
1834 /* Directly bind reference when target expression's type is compatible with
1835 the reference and expression is an lvalue. In DR391, the wording in
1836 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1837 const and rvalue references to rvalues of compatible class type.
1838 We should also do direct bindings for non-class xvalues. */
1839 if ((related_p
|| compatible_p
) && gl_kind
)
1843 If the initializer expression
1845 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1846 is reference-compatible with "cv2 T2,"
1848 the reference is bound directly to the initializer expression
1852 If the initializer expression is an rvalue, with T2 a class type,
1853 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1854 is bound to the object represented by the rvalue or to a sub-object
1855 within that object. */
1857 conv
= build_identity_conv (tfrom
, expr
);
1858 conv
= direct_reference_binding (rto
, conv
);
1860 if (TYPE_REF_P (rfrom
))
1861 /* Handle rvalue reference to function properly. */
1862 conv
->rvaluedness_matches_p
1863 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1865 conv
->rvaluedness_matches_p
1866 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1868 if ((gl_kind
& clk_bitfield
) != 0
1869 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1870 /* For the purposes of overload resolution, we ignore the fact
1871 this expression is a bitfield or packed field. (In particular,
1872 [over.ics.ref] says specifically that a function with a
1873 non-const reference parameter is viable even if the
1874 argument is a bitfield.)
1876 However, when we actually call the function we must create
1877 a temporary to which to bind the reference. If the
1878 reference is volatile, or isn't const, then we cannot make
1879 a temporary, so we just issue an error when the conversion
1881 conv
->need_temporary_p
= true;
1883 /* Don't allow binding of lvalues (other than function lvalues) to
1884 rvalue references. */
1885 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1886 && TREE_CODE (to
) != FUNCTION_TYPE
)
1889 /* Nor the reverse. */
1890 if (!is_lvalue
&& !TYPE_REF_IS_RVALUE (rto
)
1891 /* Unless it's really a C++20 lvalue being treated as an xvalue.
1892 But in C++23, such an expression is just an xvalue, not a special
1893 lvalue, so the binding is once again ill-formed. */
1894 && !(cxx_dialect
<= cxx20
1895 && (gl_kind
& clk_implicit_rval
))
1896 && (!CP_TYPE_CONST_NON_VOLATILE_P (to
)
1897 || (flags
& LOOKUP_NO_RVAL_BIND
))
1898 && TREE_CODE (to
) != FUNCTION_TYPE
)
1906 /* [class.conv.fct] A conversion function is never used to convert a
1907 (possibly cv-qualified) object to the (possibly cv-qualified) same
1908 object type (or a reference to it), to a (possibly cv-qualified) base
1909 class of that type (or a reference to it).... */
1910 else if (CLASS_TYPE_P (from
) && !related_p
1911 && !(flags
& LOOKUP_NO_CONVERSION
))
1915 If the initializer expression
1917 -- has a class type (i.e., T2 is a class type) can be
1918 implicitly converted to an lvalue of type "cv3 T3," where
1919 "cv1 T1" is reference-compatible with "cv3 T3". (this
1920 conversion is selected by enumerating the applicable
1921 conversion functions (_over.match.ref_) and choosing the
1922 best one through overload resolution. (_over.match_).
1924 the reference is bound to the lvalue result of the conversion
1925 in the second case. */
1926 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1930 if (!cand
->second_conv
->bad_p
)
1931 return cand
->second_conv
;
1933 /* Direct reference binding wasn't successful and yielded a bad
1934 conversion. Proceed with trying to go through a temporary
1935 instead, and if that also fails then we'll return this bad
1936 conversion rather than no conversion for sake of better
1938 bad_direct_conv
= cand
->second_conv
;
1942 /* From this point on, we conceptually need temporaries, even if we
1943 elide them. Only the cases above are "direct bindings". */
1944 if (flags
& LOOKUP_NO_TEMP_BIND
)
1945 return bad_direct_conv
? bad_direct_conv
: nullptr;
1949 When a parameter of reference type is not bound directly to an
1950 argument expression, the conversion sequence is the one required
1951 to convert the argument expression to the underlying type of the
1952 reference according to _over.best.ics_. Conceptually, this
1953 conversion sequence corresponds to copy-initializing a temporary
1954 of the underlying type with the argument expression. Any
1955 difference in top-level cv-qualification is subsumed by the
1956 initialization itself and does not constitute a conversion. */
1958 bool maybe_valid_p
= true;
1962 Otherwise, the reference shall be an lvalue reference to a
1963 non-volatile const type, or the reference shall be an rvalue
1965 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1966 maybe_valid_p
= false;
1970 Otherwise, a temporary of type "cv1 T1" is created and
1971 initialized from the initializer expression using the rules for a
1972 non-reference copy initialization. If T1 is reference-related to
1973 T2, cv1 must be the same cv-qualification as, or greater
1974 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1975 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1976 maybe_valid_p
= false;
1978 /* We try below to treat an invalid reference binding as a bad conversion
1979 to improve diagnostics, but doing so may cause otherwise unnecessary
1980 instantiations that can lead to a hard error. So during the first pass
1981 of overload resolution wherein we shortcut bad conversions, instead just
1982 produce a special conversion indicating a second pass is necessary if
1983 there's no strictly viable candidate. */
1984 if (!maybe_valid_p
&& (flags
& LOOKUP_SHORTCUT_BAD_CONVS
))
1986 if (bad_direct_conv
)
1987 return bad_direct_conv
;
1989 conv
= alloc_conversion (ck_deferred_bad
);
1994 /* We're generating a temporary now, but don't bind any more in the
1995 conversion (specifically, don't slice the temporary returned by a
1996 conversion operator). */
1997 flags
|= LOOKUP_NO_TEMP_BIND
;
1999 /* Core issue 899: When [copy-]initializing a temporary to be bound
2000 to the first parameter of a copy constructor (12.8) called with
2001 a single argument in the context of direct-initialization,
2002 explicit conversion functions are also considered.
2004 So don't set LOOKUP_ONLYCONVERTING in that case. */
2005 if (!(flags
& LOOKUP_COPY_PARM
))
2006 flags
|= LOOKUP_ONLYCONVERTING
;
2009 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
2012 return bad_direct_conv
? bad_direct_conv
: nullptr;
2014 if (conv
->user_conv_p
)
2017 /* Remember this was copy-list-initialization. */
2018 conv
->need_temporary_p
= true;
2020 /* If initializing the temporary used a conversion function,
2021 recalculate the second conversion sequence. */
2022 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
2023 if (t
->kind
== ck_user
2024 && DECL_CONV_FN_P (t
->cand
->fn
))
2026 tree ftype
= TREE_TYPE (TREE_TYPE (t
->cand
->fn
));
2027 /* A prvalue of non-class type is cv-unqualified. */
2028 if (!TYPE_REF_P (ftype
) && !CLASS_TYPE_P (ftype
))
2029 ftype
= cv_unqualified (ftype
);
2030 int sflags
= (flags
|LOOKUP_NO_CONVERSION
)&~LOOKUP_NO_TEMP_BIND
;
2031 conversion
*new_second
2032 = reference_binding (rto
, ftype
, NULL_TREE
, c_cast_p
,
2035 return bad_direct_conv
? bad_direct_conv
: nullptr;
2036 conv
= merge_conversion_sequences (t
, new_second
);
2037 gcc_assert (maybe_valid_p
|| conv
->bad_p
);
2042 conv
= build_conv (ck_ref_bind
, rto
, conv
);
2043 /* This reference binding, unlike those above, requires the
2044 creation of a temporary. */
2045 conv
->need_temporary_p
= true;
2046 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
2047 conv
->bad_p
|= !maybe_valid_p
;
2052 /* Returns the implicit conversion sequence (see [over.ics]) from type
2053 FROM to type TO. The optional expression EXPR may affect the
2054 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
2055 true, this conversion is coming from a C-style cast. */
2058 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
2059 int flags
, tsubst_flags_t complain
)
2063 if (from
== error_mark_node
|| to
== error_mark_node
2064 || expr
== error_mark_node
)
2067 /* Other flags only apply to the primary function in overload
2068 resolution, or after we've chosen one. */
2069 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
2070 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_NO_NARROWING
2071 |LOOKUP_PROTECT
|LOOKUP_NO_NON_INTEGRAL
|LOOKUP_SHORTCUT_BAD_CONVS
);
2073 /* FIXME: actually we don't want warnings either, but we can't just
2074 have 'complain &= ~(tf_warning|tf_error)' because it would cause
2075 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
2076 We really ought not to issue that warning until we've committed
2077 to that conversion. */
2078 complain
&= ~tf_error
;
2080 /* Call reshape_init early to remove redundant braces. */
2081 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
) && CLASS_TYPE_P (to
))
2083 to
= complete_type (to
);
2084 if (!COMPLETE_TYPE_P (to
))
2086 if (!CLASSTYPE_NON_AGGREGATE (to
))
2088 expr
= reshape_init (to
, expr
, complain
);
2089 if (expr
== error_mark_node
)
2091 from
= TREE_TYPE (expr
);
2095 if (TYPE_REF_P (to
))
2096 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
2098 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
, complain
);
2103 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
2105 if (is_std_init_list (to
) && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
))
2106 return build_list_conv (to
, expr
, flags
, complain
);
2108 /* As an extension, allow list-initialization of _Complex. */
2109 if (TREE_CODE (to
) == COMPLEX_TYPE
2110 && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
))
2112 conv
= build_complex_conv (to
, expr
, flags
, complain
);
2117 /* Allow conversion from an initializer-list with one element to a
2119 if (SCALAR_TYPE_P (to
))
2121 int nelts
= CONSTRUCTOR_NELTS (expr
);
2125 elt
= build_value_init (to
, tf_none
);
2126 else if (nelts
== 1 && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
))
2127 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
2129 elt
= error_mark_node
;
2131 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
2132 c_cast_p
, flags
, complain
);
2135 conv
->check_narrowing
= true;
2136 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
2137 /* Too many levels of braces, i.e. '{{1}}'. */
2142 else if (TREE_CODE (to
) == ARRAY_TYPE
)
2143 return build_array_conv (to
, expr
, flags
, complain
);
2146 if (expr
!= NULL_TREE
2147 && (MAYBE_CLASS_TYPE_P (from
)
2148 || MAYBE_CLASS_TYPE_P (to
))
2149 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
2151 struct z_candidate
*cand
;
2153 if (CLASS_TYPE_P (to
)
2154 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
2155 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
2156 return build_aggr_conv (to
, expr
, flags
, complain
);
2158 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
2161 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
2162 && CONSTRUCTOR_NELTS (expr
) == 1
2163 && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr
)
2164 && !is_list_ctor (cand
->fn
))
2166 /* "If C is not an initializer-list constructor and the
2167 initializer list has a single element of type cv U, where U is
2168 X or a class derived from X, the implicit conversion sequence
2169 has Exact Match rank if U is X, or Conversion rank if U is
2171 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
2172 tree elttype
= TREE_TYPE (elt
);
2173 if (reference_related_p (to
, elttype
))
2174 return implicit_conversion (to
, elttype
, elt
,
2175 c_cast_p
, flags
, complain
);
2177 conv
= cand
->second_conv
;
2180 /* We used to try to bind a reference to a temporary here, but that
2181 is now handled after the recursive call to this function at the end
2182 of reference_binding. */
2189 /* Like implicit_conversion, but return NULL if the conversion is bad.
2191 This is not static so that check_non_deducible_conversion can call it within
2192 add_template_candidate_real as part of overload resolution; it should not be
2193 called outside of overload resolution. */
2196 good_conversion (tree to
, tree from
, tree expr
,
2197 int flags
, tsubst_flags_t complain
)
2199 conversion
*c
= implicit_conversion (to
, from
, expr
, /*cast*/false,
2206 /* Add a new entry to the list of candidates. Used by the add_*_candidate
2207 functions. ARGS will not be changed until a single candidate is
2210 static struct z_candidate
*
2211 add_candidate (struct z_candidate
**candidates
,
2212 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
2213 size_t num_convs
, conversion
**convs
,
2214 tree access_path
, tree conversion_path
,
2215 int viable
, struct rejection_reason
*reason
,
2218 struct z_candidate
*cand
= (struct z_candidate
*)
2219 conversion_obstack_alloc (sizeof (struct z_candidate
));
2222 cand
->first_arg
= first_arg
;
2224 cand
->convs
= convs
;
2225 cand
->num_convs
= num_convs
;
2226 cand
->access_path
= access_path
;
2227 cand
->conversion_path
= conversion_path
;
2228 cand
->viable
= viable
;
2229 cand
->reason
= reason
;
2230 cand
->next
= *candidates
;
2231 cand
->flags
= flags
;
2234 if (convs
&& cand
->reversed ())
2235 /* Swap the conversions for comparison in joust; we'll swap them back
2236 before build_over_call. */
2237 std::swap (convs
[0], convs
[1]);
2242 /* FN is a function from the overload set that we outright didn't even
2243 consider (for some reason); add it to the list as an non-viable "ignored"
2246 static z_candidate
*
2247 add_ignored_candidate (z_candidate
**candidates
, tree fn
)
2249 /* No need to dynamically allocate these. */
2250 static const rejection_reason reason_ignored
= { rr_ignored
, {} };
2252 struct z_candidate
*cand
= (struct z_candidate
*)
2253 conversion_obstack_alloc (sizeof (struct z_candidate
));
2256 cand
->reason
= const_cast<rejection_reason
*> (&reason_ignored
);
2257 cand
->next
= *candidates
;
2263 /* True iff CAND is a candidate added by add_ignored_candidate. */
2266 ignored_candidate_p (const z_candidate
*cand
)
2268 return cand
->reason
&& cand
->reason
->code
== rr_ignored
;
2271 /* Return the number of remaining arguments in the parameter list
2272 beginning with ARG. */
2275 remaining_arguments (tree arg
)
2279 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
2280 arg
= TREE_CHAIN (arg
))
2286 /* [over.match.copy]: When initializing a temporary object (12.2) to be bound
2287 to the first parameter of a constructor where the parameter is of type
2288 "reference to possibly cv-qualified T" and the constructor is called with a
2289 single argument in the context of direct-initialization of an object of type
2290 "cv2 T", explicit conversion functions are also considered.
2292 So set LOOKUP_COPY_PARM to let reference_binding know that
2293 it's being called in that context. */
2296 conv_flags (int i
, int nargs
, tree fn
, tree arg
, int flags
)
2300 if (i
== 0 && nargs
== 1 && DECL_CONSTRUCTOR_P (fn
)
2301 && (t
= FUNCTION_FIRST_USER_PARMTYPE (fn
))
2302 && (same_type_ignoring_top_level_qualifiers_p
2303 (non_reference (TREE_VALUE (t
)), DECL_CONTEXT (fn
))))
2305 if (!(flags
& LOOKUP_ONLYCONVERTING
))
2306 lflags
|= LOOKUP_COPY_PARM
;
2307 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
2308 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
2309 lflags
|= LOOKUP_NO_CONVERSION
;
2312 lflags
|= LOOKUP_ONLYCONVERTING
;
2317 /* Build an appropriate 'this' conversion for the method FN and class
2318 type CTYPE from the value ARG (having type ARGTYPE) to the type PARMTYPE.
2319 This function modifies PARMTYPE, ARGTYPE and ARG. */
2322 build_this_conversion (tree fn
, tree ctype
,
2323 tree
& parmtype
, tree
& argtype
, tree
& arg
,
2324 int flags
, tsubst_flags_t complain
)
2326 gcc_assert (DECL_IOBJ_MEMBER_FUNCTION_P (fn
)
2327 && !DECL_CONSTRUCTOR_P (fn
));
2329 /* The type of the implicit object parameter ('this') for
2330 overload resolution is not always the same as for the
2331 function itself; conversion functions are considered to
2332 be members of the class being converted, and functions
2333 introduced by a using-declaration are considered to be
2334 members of the class that uses them.
2336 Since build_over_call ignores the ICS for the `this'
2337 parameter, we can just change the parm type. */
2338 parmtype
= cp_build_qualified_type (ctype
,
2339 cp_type_quals (TREE_TYPE (parmtype
)));
2341 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
2343 /* If the function has a ref-qualifier, the implicit
2344 object parameter has reference type. */
2345 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
2346 parmtype
= cp_build_reference_type (parmtype
, rv
);
2347 /* The special handling of 'this' conversions in compare_ics
2348 does not apply if there is a ref-qualifier. */
2353 parmtype
= build_pointer_type (parmtype
);
2354 /* We don't use build_this here because we don't want to
2355 capture the object argument until we've chosen a
2356 non-static member function. */
2357 arg
= build_address (arg
);
2358 argtype
= lvalue_type (arg
);
2360 flags
|= LOOKUP_ONLYCONVERTING
;
2361 conversion
*t
= implicit_conversion (parmtype
, argtype
, arg
,
2362 /*c_cast_p=*/false, flags
, complain
);
2367 /* Create an overload candidate for the function or method FN called
2368 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
2369 FLAGS is passed on to implicit_conversion.
2371 This does not change ARGS.
2373 CTYPE, if non-NULL, is the type we want to pretend this function
2374 comes from for purposes of overload resolution.
2376 SHORTCUT_BAD_CONVS controls how we handle "bad" argument conversions.
2377 If true, we stop computing conversions upon seeing the first bad
2378 conversion. This is used by add_candidates to avoid computing
2379 more conversions than necessary in the presence of a strictly viable
2380 candidate, while preserving the defacto behavior of overload resolution
2381 when it turns out there are only non-strictly viable candidates. */
2383 static struct z_candidate
*
2384 add_function_candidate (struct z_candidate
**candidates
,
2385 tree fn
, tree ctype
, tree first_arg
,
2386 const vec
<tree
, va_gc
> *args
, tree access_path
,
2387 tree conversion_path
, int flags
,
2389 bool shortcut_bad_convs
,
2390 tsubst_flags_t complain
)
2392 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2395 tree orig_first_arg
= first_arg
;
2398 struct rejection_reason
*reason
= NULL
;
2400 /* The `this', `in_chrg' and VTT arguments to constructors are not
2401 considered in overload resolution. */
2402 if (DECL_CONSTRUCTOR_P (fn
))
2404 if (ctor_omit_inherited_parms (fn
))
2405 /* Bring back parameters omitted from an inherited ctor. */
2406 parmlist
= FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn
));
2408 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
2409 skip
= num_artificial_parms_for (fn
);
2410 if (skip
> 0 && first_arg
!= NULL_TREE
)
2413 first_arg
= NULL_TREE
;
2419 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
2421 convs
= alloc_conversions (len
);
2423 /* 13.3.2 - Viable functions [over.match.viable]
2424 First, to be a viable function, a candidate function shall have enough
2425 parameters to agree in number with the arguments in the list.
2427 We need to check this first; otherwise, checking the ICSes might cause
2428 us to produce an ill-formed template instantiation. */
2430 parmnode
= parmlist
;
2431 for (i
= 0; i
< len
; ++i
)
2433 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
2435 parmnode
= TREE_CHAIN (parmnode
);
2438 if ((i
< len
&& parmnode
)
2439 || !sufficient_parms_p (parmnode
))
2441 int remaining
= remaining_arguments (parmnode
);
2443 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
2446 /* An inherited constructor (12.6.3 [class.inhctor.init]) that has a first
2447 parameter of type "reference to cv C" (including such a constructor
2448 instantiated from a template) is excluded from the set of candidate
2449 functions when used to construct an object of type D with an argument list
2450 containing a single argument if C is reference-related to D. */
2451 if (viable
&& len
== 1 && parmlist
&& DECL_CONSTRUCTOR_P (fn
)
2452 && flag_new_inheriting_ctors
2453 && DECL_INHERITED_CTOR (fn
))
2455 tree ptype
= non_reference (TREE_VALUE (parmlist
));
2456 tree dtype
= DECL_CONTEXT (fn
);
2457 tree btype
= DECL_INHERITED_CTOR_BASE (fn
);
2458 if (reference_related_p (ptype
, dtype
)
2459 && reference_related_p (btype
, ptype
))
2462 reason
= inherited_ctor_rejection ();
2466 /* Second, for a function to be viable, its constraints must be
2468 if (flag_concepts
&& viable
&& !constraints_satisfied_p (fn
))
2470 reason
= constraint_failure ();
2474 /* When looking for a function from a subobject from an implicit
2475 copy/move constructor/operator=, don't consider anything that takes (a
2476 reference to) an unrelated type. See c++/44909 and core 1092. */
2477 if (viable
&& parmlist
&& (flags
& LOOKUP_DEFAULTED
))
2479 if (DECL_CONSTRUCTOR_P (fn
))
2481 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
2482 && DECL_OVERLOADED_OPERATOR_IS (fn
, NOP_EXPR
))
2488 parmnode
= chain_index (i
-1, parmlist
);
2489 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
2494 /* This only applies at the top level. */
2495 flags
&= ~LOOKUP_DEFAULTED
;
2501 if (shortcut_bad_convs
)
2502 flags
|= LOOKUP_SHORTCUT_BAD_CONVS
;
2504 flags
&= ~LOOKUP_SHORTCUT_BAD_CONVS
;
2506 /* Third, for F to be a viable function, there shall exist for each
2507 argument an implicit conversion sequence that converts that argument
2508 to the corresponding parameter of F. */
2510 parmnode
= parmlist
;
2512 for (i
= 0; i
< len
; ++i
)
2514 tree argtype
, to_type
;
2517 if (parmnode
== void_list_node
)
2522 /* Already set during deduction. */
2523 parmnode
= TREE_CHAIN (parmnode
);
2527 if (i
== 0 && first_arg
!= NULL_TREE
)
2530 arg
= CONST_CAST_TREE (
2531 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
2532 argtype
= lvalue_type (arg
);
2537 tree parmtype
= TREE_VALUE (parmnode
);
2539 && DECL_IOBJ_MEMBER_FUNCTION_P (fn
)
2540 && !DECL_CONSTRUCTOR_P (fn
))
2541 t
= build_this_conversion (fn
, ctype
, parmtype
, argtype
, arg
,
2545 int lflags
= conv_flags (i
, len
-skip
, fn
, arg
, flags
);
2546 t
= implicit_conversion (parmtype
, argtype
, arg
,
2547 /*c_cast_p=*/false, lflags
, complain
);
2550 parmnode
= TREE_CHAIN (parmnode
);
2554 t
= build_identity_conv (argtype
, arg
);
2555 t
->ellipsis_p
= true;
2563 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
,
2564 EXPR_LOCATION (arg
));
2571 reason
= bad_arg_conversion_rejection (first_arg
, i
, arg
, to_type
,
2572 EXPR_LOCATION (arg
));
2573 if (shortcut_bad_convs
)
2579 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2580 access_path
, conversion_path
, viable
, reason
, flags
);
2583 /* Create an overload candidate for the conversion function FN which will
2584 be invoked for expression OBJ, producing a pointer-to-function which
2585 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2586 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2587 passed on to implicit_conversion.
2589 Actually, we don't really care about FN; we care about the type it
2590 converts to. There may be multiple conversion functions that will
2591 convert to that type, and we rely on build_user_type_conversion_1 to
2592 choose the best one; so when we create our candidate, we record the type
2593 instead of the function. */
2595 static struct z_candidate
*
2596 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2597 const vec
<tree
, va_gc
> *arglist
,
2598 tree access_path
, tree conversion_path
,
2599 tsubst_flags_t complain
)
2601 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2602 int i
, len
, viable
, flags
;
2603 tree parmlist
, parmnode
;
2605 struct rejection_reason
*reason
;
2607 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2608 parmlist
= TREE_TYPE (parmlist
);
2609 parmlist
= TYPE_ARG_TYPES (parmlist
);
2611 len
= vec_safe_length (arglist
) + 1;
2612 convs
= alloc_conversions (len
);
2613 parmnode
= parmlist
;
2615 flags
= LOOKUP_IMPLICIT
;
2618 /* Don't bother looking up the same type twice. */
2619 if (*candidates
&& (*candidates
)->fn
== totype
)
2622 if (!constraints_satisfied_p (fn
))
2624 reason
= constraint_failure ();
2626 return add_candidate (candidates
, fn
, obj
, arglist
, len
, convs
,
2627 access_path
, conversion_path
, viable
, reason
, flags
);
2630 for (i
= 0; i
< len
; ++i
)
2632 tree arg
, argtype
, convert_type
= NULL_TREE
;
2638 arg
= (*arglist
)[i
- 1];
2639 argtype
= lvalue_type (arg
);
2643 t
= build_identity_conv (argtype
, NULL_TREE
);
2644 t
= build_conv (ck_user
, totype
, t
);
2645 /* Leave the 'cand' field null; we'll figure out the conversion in
2646 convert_like if this candidate is chosen. */
2647 convert_type
= totype
;
2649 else if (parmnode
== void_list_node
)
2653 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2654 /*c_cast_p=*/false, flags
, complain
);
2655 convert_type
= TREE_VALUE (parmnode
);
2659 t
= build_identity_conv (argtype
, arg
);
2660 t
->ellipsis_p
= true;
2661 convert_type
= argtype
;
2671 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, arg
, convert_type
,
2672 EXPR_LOCATION (arg
));
2679 parmnode
= TREE_CHAIN (parmnode
);
2683 || ! sufficient_parms_p (parmnode
))
2685 int remaining
= remaining_arguments (parmnode
);
2687 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2690 return add_candidate (candidates
, totype
, obj
, arglist
, len
, convs
,
2691 access_path
, conversion_path
, viable
, reason
, flags
);
2695 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2696 tree type1
, tree type2
, const vec
<tree
,va_gc
> &args
,
2697 tree
*argtypes
, int flags
, tsubst_flags_t complain
)
2704 struct rejection_reason
*reason
= NULL
;
2709 num_convs
= args
.length ();
2710 convs
= alloc_conversions (num_convs
);
2712 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2713 conversion ops are allowed. We handle that here by just checking for
2714 boolean_type_node because other operators don't ask for it. COND_EXPR
2715 also does contextual conversion to bool for the first operand, but we
2716 handle that in build_conditional_expr, and type1 here is operand 2. */
2717 if (type1
!= boolean_type_node
)
2718 flags
|= LOOKUP_ONLYCONVERTING
;
2720 for (unsigned i
= 0; i
< 2 && i
< num_convs
; ++i
)
2722 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2723 /*c_cast_p=*/false, flags
, complain
);
2727 /* We need something for printing the candidate. */
2728 t
= build_identity_conv (types
[i
], NULL_TREE
);
2729 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2730 types
[i
], EXPR_LOCATION (args
[i
]));
2735 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, args
[i
],
2737 EXPR_LOCATION (args
[i
]));
2742 /* For COND_EXPR we rearranged the arguments; undo that now. */
2745 convs
[2] = convs
[1];
2746 convs
[1] = convs
[0];
2747 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2748 /*c_cast_p=*/false, flags
,
2755 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2757 EXPR_LOCATION (args
[2]));
2761 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2763 /*access_path=*/NULL_TREE
,
2764 /*conversion_path=*/NULL_TREE
,
2765 viable
, reason
, flags
);
2769 is_complete (tree t
)
2771 return COMPLETE_TYPE_P (complete_type (t
));
2774 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2777 promoted_arithmetic_type_p (tree type
)
2781 In this section, the term promoted integral type is used to refer
2782 to those integral types which are preserved by integral promotion
2783 (including e.g. int and long but excluding e.g. char).
2784 Similarly, the term promoted arithmetic type refers to promoted
2785 integral types plus floating types. */
2786 return ((CP_INTEGRAL_TYPE_P (type
)
2787 && same_type_p (type_promotes_to (type
), type
))
2788 || SCALAR_FLOAT_TYPE_P (type
));
2791 /* Create any builtin operator overload candidates for the operator in
2792 question given the converted operand types TYPE1 and TYPE2. The other
2793 args are passed through from add_builtin_candidates to
2794 build_builtin_candidate.
2796 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2797 If CODE is requires candidates operands of the same type of the kind
2798 of which TYPE1 and TYPE2 are, we add both candidates
2799 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2802 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2803 enum tree_code code2
, tree fnname
, tree type1
,
2804 tree type2
, vec
<tree
,va_gc
> &args
, tree
*argtypes
,
2805 int flags
, tsubst_flags_t complain
)
2809 case POSTINCREMENT_EXPR
:
2810 case POSTDECREMENT_EXPR
:
2811 args
[1] = integer_zero_node
;
2812 type2
= integer_type_node
;
2821 /* 4 For every pair (T, VQ), where T is an arithmetic type other than bool,
2822 and VQ is either volatile or empty, there exist candidate operator
2823 functions of the form
2824 VQ T& operator++(VQ T&);
2825 T operator++(VQ T&, int);
2826 5 For every pair (T, VQ), where T is an arithmetic type other than bool,
2827 and VQ is either volatile or empty, there exist candidate operator
2828 functions of the form
2829 VQ T& operator--(VQ T&);
2830 T operator--(VQ T&, int);
2831 6 For every pair (T, VQ), where T is a cv-qualified or cv-unqualified object
2832 type, and VQ is either volatile or empty, there exist candidate operator
2833 functions of the form
2834 T*VQ& operator++(T*VQ&);
2835 T*VQ& operator--(T*VQ&);
2836 T* operator++(T*VQ&, int);
2837 T* operator--(T*VQ&, int); */
2839 case POSTDECREMENT_EXPR
:
2840 case PREDECREMENT_EXPR
:
2841 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2844 case POSTINCREMENT_EXPR
:
2845 case PREINCREMENT_EXPR
:
2846 /* P0002R1, Remove deprecated operator++(bool) added "other than bool"
2848 if (TREE_CODE (type1
) == BOOLEAN_TYPE
&& cxx_dialect
>= cxx17
)
2850 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2852 type1
= build_reference_type (type1
);
2857 /* 7 For every cv-qualified or cv-unqualified object type T, there
2858 exist candidate operator functions of the form
2863 8 For every function type T that does not have cv-qualifiers or
2864 a ref-qualifier, there exist candidate operator functions of the form
2865 T& operator*(T*); */
2868 if (TYPE_PTR_P (type1
)
2869 && (TYPE_PTROB_P (type1
)
2870 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2874 /* 9 For every type T, there exist candidate operator functions of the form
2877 10 For every floating-point or promoted integral type T, there exist
2878 candidate operator functions of the form
2882 case UNARY_PLUS_EXPR
: /* unary + */
2883 if (TYPE_PTR_P (type1
))
2887 if (ARITHMETIC_TYPE_P (type1
))
2891 /* 11 For every promoted integral type T, there exist candidate operator
2892 functions of the form
2896 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2900 /* 12 For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type, C1
2901 is the same type as C2 or is a derived class of C2, and T is an object
2902 type or a function type there exist candidate operator functions of the
2904 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2905 where CV12 is the union of CV1 and CV2. */
2908 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2910 tree c1
= TREE_TYPE (type1
);
2911 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2913 if (CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2914 && (TYPE_PTRMEMFUNC_P (type2
)
2915 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2920 /* 13 For every pair of types L and R, where each of L and R is a floating-point
2921 or promoted integral type, there exist candidate operator functions of the
2927 bool operator<(L, R);
2928 bool operator>(L, R);
2929 bool operator<=(L, R);
2930 bool operator>=(L, R);
2931 bool operator==(L, R);
2932 bool operator!=(L, R);
2933 where LR is the result of the usual arithmetic conversions between
2936 14 For every integral type T there exists a candidate operator function of
2939 std::strong_ordering operator<=>(T, T);
2941 15 For every pair of floating-point types L and R, there exists a candidate
2942 operator function of the form
2944 std::partial_ordering operator<=>(L, R);
2946 16 For every cv-qualified or cv-unqualified object type T there exist
2947 candidate operator functions of the form
2948 T* operator+(T*, std::ptrdiff_t);
2949 T& operator[](T*, std::ptrdiff_t);
2950 T* operator-(T*, std::ptrdiff_t);
2951 T* operator+(std::ptrdiff_t, T*);
2952 T& operator[](std::ptrdiff_t, T*);
2954 17 For every T, where T is a pointer to object type, there exist candidate
2955 operator functions of the form
2956 std::ptrdiff_t operator-(T, T);
2958 18 For every T, where T is an enumeration type or a pointer type, there
2959 exist candidate operator functions of the form
2960 bool operator<(T, T);
2961 bool operator>(T, T);
2962 bool operator<=(T, T);
2963 bool operator>=(T, T);
2964 bool operator==(T, T);
2965 bool operator!=(T, T);
2966 R operator<=>(T, T);
2968 where R is the result type specified in [expr.spaceship].
2970 19 For every T, where T is a pointer-to-member type or std::nullptr_t,
2971 there exist candidate operator functions of the form
2972 bool operator==(T, T);
2973 bool operator!=(T, T); */
2976 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2978 if (TYPE_PTROB_P (type1
)
2979 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2981 type2
= ptrdiff_type_node
;
2986 case TRUNC_DIV_EXPR
:
2987 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2991 /* This isn't exactly what's specified above for operator<=>, but it's
2992 close enough. In particular, we don't care about the return type
2993 specified above; it doesn't participate in overload resolution and it
2994 doesn't affect the semantics of the built-in operator. */
2995 case SPACESHIP_EXPR
:
2998 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2999 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
3001 if (NULLPTR_TYPE_P (type1
) && NULLPTR_TYPE_P (type2
))
3003 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
3008 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
3020 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3022 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3024 if (TREE_CODE (type1
) == ENUMERAL_TYPE
3025 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
3027 if (TYPE_PTR_P (type1
)
3028 && null_ptr_cst_p (args
[1]))
3033 if (null_ptr_cst_p (args
[0])
3034 && TYPE_PTR_P (type2
))
3042 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3046 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
3048 type1
= ptrdiff_type_node
;
3051 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
3053 type2
= ptrdiff_type_node
;
3058 /* 18For every pair of promoted integral types L and R, there exist candi-
3059 date operator functions of the form
3066 where LR is the result of the usual arithmetic conversions between
3069 case TRUNC_MOD_EXPR
:
3075 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
3079 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
3080 type, VQ is either volatile or empty, and R is a promoted arithmetic
3081 type, there exist candidate operator functions of the form
3082 VQ L& operator=(VQ L&, R);
3083 VQ L& operator*=(VQ L&, R);
3084 VQ L& operator/=(VQ L&, R);
3085 VQ L& operator+=(VQ L&, R);
3086 VQ L& operator-=(VQ L&, R);
3088 20For every pair T, VQ), where T is any type and VQ is either volatile
3089 or empty, there exist candidate operator functions of the form
3090 T*VQ& operator=(T*VQ&, T*);
3092 21For every pair T, VQ), where T is a pointer to member type and VQ is
3093 either volatile or empty, there exist candidate operator functions of
3095 VQ T& operator=(VQ T&, T);
3097 22For every triple T, VQ, I), where T is a cv-qualified or cv-
3098 unqualified complete object type, VQ is either volatile or empty, and
3099 I is a promoted integral type, there exist candidate operator func-
3101 T*VQ& operator+=(T*VQ&, I);
3102 T*VQ& operator-=(T*VQ&, I);
3104 23For every triple L, VQ, R), where L is an integral or enumeration
3105 type, VQ is either volatile or empty, and R is a promoted integral
3106 type, there exist candidate operator functions of the form
3108 VQ L& operator%=(VQ L&, R);
3109 VQ L& operator<<=(VQ L&, R);
3110 VQ L& operator>>=(VQ L&, R);
3111 VQ L& operator&=(VQ L&, R);
3112 VQ L& operator^=(VQ L&, R);
3113 VQ L& operator|=(VQ L&, R); */
3120 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
3122 type2
= ptrdiff_type_node
;
3127 case TRUNC_DIV_EXPR
:
3128 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3132 case TRUNC_MOD_EXPR
:
3138 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
3143 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3145 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
3146 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3147 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
3148 || ((TYPE_PTRMEMFUNC_P (type1
)
3149 || TYPE_PTR_P (type1
))
3150 && null_ptr_cst_p (args
[1])))
3160 type1
= build_reference_type (type1
);
3166 For every pair of promoted arithmetic types L and R, there
3167 exist candidate operator functions of the form
3169 LR operator?(bool, L, R);
3171 where LR is the result of the usual arithmetic conversions
3172 between types L and R.
3174 For every type T, where T is a pointer or pointer-to-member
3175 type, there exist candidate operator functions of the form T
3176 operator?(bool, T, T); */
3178 if (promoted_arithmetic_type_p (type1
)
3179 && promoted_arithmetic_type_p (type2
))
3183 /* Otherwise, the types should be pointers. */
3184 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
3187 /* We don't check that the two types are the same; the logic
3188 below will actually create two candidates; one in which both
3189 parameter types are TYPE1, and one in which both parameter
3195 if (ARITHMETIC_TYPE_P (type1
))
3203 /* Make sure we don't create builtin candidates with dependent types. */
3204 bool u1
= uses_template_parms (type1
);
3205 bool u2
= type2
? uses_template_parms (type2
) : false;
3208 /* Try to recover if one of the types is non-dependent. But if
3209 there's only one type, there's nothing we can do. */
3212 /* And we lose if both are dependent. */
3215 /* Or if they have different forms. */
3216 if (TREE_CODE (type1
) != TREE_CODE (type2
))
3225 /* If we're dealing with two pointer types or two enumeral types,
3226 we need candidates for both of them. */
3227 if (type2
&& !same_type_p (type1
, type2
)
3228 && TREE_CODE (type1
) == TREE_CODE (type2
)
3229 && (TYPE_REF_P (type1
)
3230 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3231 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
3232 || TYPE_PTRMEMFUNC_P (type1
)
3233 || MAYBE_CLASS_TYPE_P (type1
)
3234 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
3236 if (TYPE_PTR_OR_PTRMEM_P (type1
))
3238 tree cptype
= composite_pointer_type (input_location
,
3244 if (cptype
!= error_mark_node
)
3246 build_builtin_candidate
3247 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
3253 build_builtin_candidate
3254 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
3255 build_builtin_candidate
3256 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
3260 build_builtin_candidate
3261 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
3265 type_decays_to (tree type
)
3267 if (TREE_CODE (type
) == ARRAY_TYPE
)
3268 return build_pointer_type (TREE_TYPE (type
));
3269 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3270 return build_pointer_type (type
);
3274 /* There are three conditions of builtin candidates:
3276 1) bool-taking candidates. These are the same regardless of the input.
3277 2) pointer-pair taking candidates. These are generated for each type
3278 one of the input types converts to.
3279 3) arithmetic candidates. According to the standard, we should generate
3280 all of these, but I'm trying not to...
3282 Here we generate a superset of the possible candidates for this particular
3283 case. That is a subset of the full set the standard defines, plus some
3284 other cases which the standard disallows. add_builtin_candidate will
3285 filter out the invalid set. */
3288 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
3289 enum tree_code code2
, tree fnname
,
3290 vec
<tree
, va_gc
> *argv
,
3291 int flags
, tsubst_flags_t complain
)
3295 tree type
, argtypes
[3], t
;
3296 /* TYPES[i] is the set of possible builtin-operator parameter types
3297 we will consider for the Ith argument. */
3298 vec
<tree
, va_gc
> *types
[2];
3300 vec
<tree
, va_gc
> &args
= *argv
;
3301 unsigned len
= args
.length ();
3303 for (unsigned i
= 0; i
< len
; ++i
)
3306 argtypes
[i
] = unlowered_expr_type (args
[i
]);
3308 argtypes
[i
] = NULL_TREE
;
3313 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3314 and VQ is either volatile or empty, there exist candidate operator
3315 functions of the form
3316 VQ T& operator++(VQ T&); */
3318 case POSTINCREMENT_EXPR
:
3319 case PREINCREMENT_EXPR
:
3320 case POSTDECREMENT_EXPR
:
3321 case PREDECREMENT_EXPR
:
3326 /* 24There also exist candidate operator functions of the form
3327 bool operator!(bool);
3328 bool operator&&(bool, bool);
3329 bool operator||(bool, bool); */
3331 case TRUTH_NOT_EXPR
:
3332 build_builtin_candidate
3333 (candidates
, fnname
, boolean_type_node
,
3334 NULL_TREE
, args
, argtypes
, flags
, complain
);
3337 case TRUTH_ORIF_EXPR
:
3338 case TRUTH_ANDIF_EXPR
:
3339 build_builtin_candidate
3340 (candidates
, fnname
, boolean_type_node
,
3341 boolean_type_node
, args
, argtypes
, flags
, complain
);
3357 case SPACESHIP_EXPR
:
3365 types
[0] = make_tree_vector ();
3366 types
[1] = make_tree_vector ();
3370 for (unsigned i
= 0; i
< len
; ++i
)
3372 if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
3376 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
3379 convs
= lookup_conversions (argtypes
[i
]);
3381 if (code
== COND_EXPR
)
3383 if (lvalue_p (args
[i
]))
3384 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
3386 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
3392 for (; convs
; convs
= TREE_CHAIN (convs
))
3394 type
= TREE_TYPE (convs
);
3397 && (!TYPE_REF_P (type
)
3398 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
3401 if (code
== COND_EXPR
&& TYPE_REF_P (type
))
3402 vec_safe_push (types
[i
], type
);
3404 type
= non_reference (type
);
3405 if (i
!= 0 || ! ref1
)
3407 type
= cv_unqualified (type_decays_to (type
));
3408 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
3409 vec_safe_push (types
[i
], type
);
3410 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3411 type
= type_promotes_to (type
);
3414 if (! vec_member (type
, types
[i
]))
3415 vec_safe_push (types
[i
], type
);
3420 if (code
== COND_EXPR
&& lvalue_p (args
[i
]))
3421 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
3422 type
= non_reference (argtypes
[i
]);
3423 if (i
!= 0 || ! ref1
)
3425 type
= cv_unqualified (type_decays_to (type
));
3426 if (enum_p
&& UNSCOPED_ENUM_P (type
))
3427 vec_safe_push (types
[i
], type
);
3428 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3429 type
= type_promotes_to (type
);
3431 vec_safe_push (types
[i
], type
);
3435 /* Run through the possible parameter types of both arguments,
3436 creating candidates with those parameter types. */
3437 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
3442 if (!types
[1]->is_empty ())
3443 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
3444 add_builtin_candidate
3445 (candidates
, code
, code2
, fnname
, t
,
3446 u
, args
, argtypes
, flags
, complain
);
3448 add_builtin_candidate
3449 (candidates
, code
, code2
, fnname
, t
,
3450 NULL_TREE
, args
, argtypes
, flags
, complain
);
3453 release_tree_vector (types
[0]);
3454 release_tree_vector (types
[1]);
3458 /* If TMPL can be successfully instantiated as indicated by
3459 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
3461 TMPL is the template. EXPLICIT_TARGS are any explicit template
3462 arguments. ARGLIST is the arguments provided at the call-site.
3463 This does not change ARGLIST. The RETURN_TYPE is the desired type
3464 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
3465 as for add_function_candidate. If an OBJ is supplied, FLAGS and
3466 CTYPE are ignored, and OBJ is as for add_conv_candidate.
3468 SHORTCUT_BAD_CONVS is as in add_function_candidate. */
3470 static struct z_candidate
*
3471 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
3472 tree ctype
, tree explicit_targs
, tree first_arg
,
3473 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3474 tree access_path
, tree conversion_path
,
3475 int flags
, tree obj
, unification_kind_t strict
,
3476 bool shortcut_bad_convs
, tsubst_flags_t complain
)
3478 int ntparms
= DECL_NTPARMS (tmpl
);
3479 tree targs
= make_tree_vec (ntparms
);
3480 unsigned int len
= vec_safe_length (arglist
);
3481 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
3482 unsigned int skip_without_in_chrg
= 0;
3483 tree first_arg_without_in_chrg
= first_arg
;
3484 tree
*args_without_in_chrg
;
3485 unsigned int nargs_without_in_chrg
;
3486 unsigned int ia
, ix
;
3488 struct z_candidate
*cand
;
3490 struct rejection_reason
*reason
= NULL
;
3492 conversion
**convs
= NULL
;
3494 /* We don't do deduction on the in-charge parameter, the VTT
3495 parameter or 'this'. */
3496 if (DECL_IOBJ_MEMBER_FUNCTION_P (tmpl
))
3498 if (first_arg_without_in_chrg
!= NULL_TREE
)
3499 first_arg_without_in_chrg
= NULL_TREE
;
3500 else if (return_type
&& strict
== DEDUCE_CALL
)
3501 /* We're deducing for a call to the result of a template conversion
3502 function, so the args don't contain 'this'; leave them alone. */;
3504 ++skip_without_in_chrg
;
3507 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
3508 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
3509 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
3511 if (first_arg_without_in_chrg
!= NULL_TREE
)
3512 first_arg_without_in_chrg
= NULL_TREE
;
3514 ++skip_without_in_chrg
;
3517 if (len
< skip_without_in_chrg
)
3518 return add_ignored_candidate (candidates
, tmpl
);
3520 if (DECL_CONSTRUCTOR_P (tmpl
) && nargs
== 2
3521 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (first_arg
),
3522 TREE_TYPE ((*arglist
)[0])))
3524 /* 12.8/6 says, "A declaration of a constructor for a class X is
3525 ill-formed if its first parameter is of type (optionally cv-qualified)
3526 X and either there are no other parameters or else all other
3527 parameters have default arguments. A member function template is never
3528 instantiated to produce such a constructor signature."
3530 So if we're trying to copy an object of the containing class, don't
3531 consider a template constructor that has a first parameter type that
3532 is just a template parameter, as we would deduce a signature that we
3533 would then reject in the code below. */
3534 if (tree firstparm
= FUNCTION_FIRST_USER_PARMTYPE (tmpl
))
3536 firstparm
= TREE_VALUE (firstparm
);
3537 if (PACK_EXPANSION_P (firstparm
))
3538 firstparm
= PACK_EXPANSION_PATTERN (firstparm
);
3539 if (TREE_CODE (firstparm
) == TEMPLATE_TYPE_PARM
)
3541 gcc_assert (!explicit_targs
);
3542 reason
= invalid_copy_with_fn_template_rejection ();
3548 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
3549 + (len
- skip_without_in_chrg
));
3550 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
3552 if (first_arg_without_in_chrg
!= NULL_TREE
)
3554 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
3557 for (ix
= skip_without_in_chrg
;
3558 vec_safe_iterate (arglist
, ix
, &arg
);
3561 args_without_in_chrg
[ia
] = arg
;
3564 gcc_assert (ia
== nargs_without_in_chrg
);
3568 /* Check that there's no obvious arity mismatch before proceeding with
3569 deduction. This avoids substituting explicit template arguments
3570 into the template or e.g. derived-to-base parm/arg unification
3571 (which could result in an error outside the immediate context) when
3572 the resulting candidate would be unviable anyway. */
3573 int min_arity
= 0, max_arity
= 0;
3574 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (tmpl
));
3575 parms
= skip_artificial_parms_for (tmpl
, parms
);
3576 for (; parms
!= void_list_node
; parms
= TREE_CHAIN (parms
))
3578 if (!parms
|| PACK_EXPANSION_P (TREE_VALUE (parms
)))
3583 if (TREE_PURPOSE (parms
))
3584 /* A parameter with a default argument. */
3587 ++min_arity
, ++max_arity
;
3589 if (ia
< (unsigned)min_arity
)
3591 /* Too few arguments. */
3592 reason
= arity_rejection (NULL_TREE
, min_arity
, ia
,
3593 /*least_p=*/(max_arity
== -1));
3596 else if (max_arity
!= -1 && ia
> (unsigned)max_arity
)
3598 /* Too many arguments. */
3599 reason
= arity_rejection (NULL_TREE
, max_arity
, ia
);
3603 convs
= alloc_conversions (nargs
);
3605 if (shortcut_bad_convs
3606 && DECL_IOBJ_MEMBER_FUNCTION_P (tmpl
)
3607 && !DECL_CONSTRUCTOR_P (tmpl
))
3609 /* Check the 'this' conversion before proceeding with deduction.
3610 This is effectively an extension of the DR 1391 resolution
3611 that we perform in check_non_deducible_conversions, though it's
3612 convenient to do this extra check here instead of there. */
3613 tree parmtype
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (tmpl
)));
3614 tree argtype
= lvalue_type (first_arg
);
3615 tree arg
= first_arg
;
3616 conversion
*t
= build_this_conversion (tmpl
, ctype
,
3617 parmtype
, argtype
, arg
,
3622 reason
= bad_arg_conversion_rejection (first_arg
, 0,
3624 EXPR_LOCATION (arg
));
3630 errs
= errorcount
+sorrycount
;
3631 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
3632 args_without_in_chrg
,
3633 nargs_without_in_chrg
,
3634 return_type
, strict
, flags
, convs
,
3635 false, complain
& tf_decltype
);
3637 if (fn
== error_mark_node
)
3639 /* Don't repeat unification later if it already resulted in errors. */
3640 if (errorcount
+sorrycount
== errs
)
3641 reason
= template_unification_rejection (tmpl
, explicit_targs
,
3642 targs
, args_without_in_chrg
,
3643 nargs_without_in_chrg
,
3644 return_type
, strict
, flags
);
3646 reason
= template_unification_error_rejection ();
3650 /* Now the explicit specifier might have been deduced; check if this
3651 declaration is explicit. If it is and we're ignoring non-converting
3652 constructors, don't add this function to the set of candidates. */
3653 if (((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
3654 == LOOKUP_ONLYCONVERTING
)
3655 && DECL_NONCONVERTING_P (fn
))
3656 return add_ignored_candidate (candidates
, fn
);
3658 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
3660 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3661 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
3664 /* We're trying to produce a constructor with a prohibited signature,
3665 as discussed above; handle here any cases we didn't catch then,
3667 reason
= invalid_copy_with_fn_template_rejection ();
3672 if (obj
!= NULL_TREE
)
3673 /* Aha, this is a conversion function. */
3674 cand
= add_conv_candidate (candidates
, fn
, obj
, arglist
,
3675 access_path
, conversion_path
, complain
);
3677 cand
= add_function_candidate (candidates
, fn
, ctype
,
3678 first_arg
, arglist
, access_path
,
3679 conversion_path
, flags
, convs
,
3680 shortcut_bad_convs
, complain
);
3681 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
3682 /* This situation can occur if a member template of a template
3683 class is specialized. Then, instantiate_template might return
3684 an instantiation of the specialization, in which case the
3685 DECL_TI_TEMPLATE field will point at the original
3686 specialization. For example:
3688 template <class T> struct S { template <class U> void f(U);
3689 template <> void f(int) {}; };
3693 Here, TMPL will be template <class U> S<double>::f(U).
3694 And, instantiate template will give us the specialization
3695 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3696 for this will point at template <class T> template <> S<T>::f(int),
3697 so that we can find the definition. For the purposes of
3698 overload resolution, however, we want the original TMPL. */
3699 cand
->template_decl
= build_template_info (tmpl
, targs
);
3701 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3702 cand
->explicit_targs
= explicit_targs
;
3706 int viable
= (reason
->code
== rr_bad_arg_conversion
? -1 : 0);
3707 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, convs
,
3708 access_path
, conversion_path
, viable
, reason
, flags
);
3712 static struct z_candidate
*
3713 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3714 tree explicit_targs
, tree first_arg
,
3715 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3716 tree access_path
, tree conversion_path
, int flags
,
3717 unification_kind_t strict
, bool shortcut_bad_convs
,
3718 tsubst_flags_t complain
)
3721 add_template_candidate_real (candidates
, tmpl
, ctype
,
3722 explicit_targs
, first_arg
, arglist
,
3723 return_type
, access_path
, conversion_path
,
3724 flags
, NULL_TREE
, strict
, shortcut_bad_convs
,
3728 /* Create an overload candidate for the conversion function template TMPL,
3729 returning RETURN_TYPE, which will be invoked for expression OBJ to produce a
3730 pointer-to-function which will in turn be called with the argument list
3731 ARGLIST, and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
3732 passed on to implicit_conversion. */
3734 static struct z_candidate
*
3735 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3737 const vec
<tree
, va_gc
> *arglist
,
3738 tree return_type
, tree access_path
,
3739 tree conversion_path
, tsubst_flags_t complain
)
3742 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3743 NULL_TREE
, arglist
, return_type
, access_path
,
3744 conversion_path
, 0, obj
, DEDUCE_CALL
,
3745 /*shortcut_bad_convs=*/false, complain
);
3748 /* The CANDS are the set of candidates that were considered for
3749 overload resolution. Sort CANDS so that the strictly viable
3750 candidates appear first, followed by non-strictly viable candidates,
3751 followed by non-viable candidates. Returns the first candidate
3752 in this sorted list. If any of the candidates were viable, set
3753 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3754 considered viable only if it is strictly viable when setting
3757 static struct z_candidate
*
3758 splice_viable (struct z_candidate
*cands
,
3762 z_candidate
*strictly_viable
= nullptr;
3763 z_candidate
**strictly_viable_tail
= &strictly_viable
;
3765 z_candidate
*non_strictly_viable
= nullptr;
3766 z_candidate
**non_strictly_viable_tail
= &non_strictly_viable
;
3768 z_candidate
*non_viable
= nullptr;
3769 z_candidate
**non_viable_tail
= &non_viable
;
3771 z_candidate
*non_viable_ignored
= nullptr;
3772 z_candidate
**non_viable_ignored_tail
= &non_viable_ignored
;
3774 /* Be strict inside templates, since build_over_call won't actually
3775 do the conversions to get pedwarns. */
3776 if (processing_template_decl
)
3779 for (z_candidate
*cand
= cands
; cand
; cand
= cand
->next
)
3782 && (cand
->viable
== 1 || TREE_CODE (cand
->fn
) == TEMPLATE_DECL
))
3783 /* Be strict in the presence of a viable candidate. Also if
3784 there are template candidates, so that we get deduction errors
3785 for them instead of silently preferring a bad conversion. */
3788 /* Move this candidate to the appropriate list according to
3790 auto& tail
= (cand
->viable
== 1 ? strictly_viable_tail
3791 : cand
->viable
== -1 ? non_strictly_viable_tail
3792 : ignored_candidate_p (cand
) ? non_viable_ignored_tail
3798 *any_viable_p
= (strictly_viable
!= nullptr
3799 || (!strict_p
&& non_strictly_viable
!= nullptr));
3801 /* Combine the lists. */
3802 *non_viable_ignored_tail
= nullptr;
3803 *non_viable_tail
= non_viable_ignored
;
3804 *non_strictly_viable_tail
= non_viable
;
3805 *strictly_viable_tail
= non_strictly_viable
;
3807 return strictly_viable
;
3811 any_strictly_viable (struct z_candidate
*cands
)
3813 for (; cands
; cands
= cands
->next
)
3814 if (cands
->viable
== 1)
3819 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3820 words, it is about to become the "this" pointer for a member
3821 function call. Take the address of the object. */
3824 build_this (tree obj
)
3826 /* In a template, we are only concerned about the type of the
3827 expression, so we can take a shortcut. */
3828 if (processing_template_decl
)
3829 return build_address (obj
);
3831 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3834 /* Returns true iff functions are equivalent. Equivalent functions are
3835 not '==' only if one is a function-local extern function or if
3836 both are extern "C". */
3839 equal_functions (tree fn1
, tree fn2
)
3841 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3843 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3845 if (DECL_LOCAL_DECL_P (fn1
) || DECL_LOCAL_DECL_P (fn2
)
3846 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3847 return decls_match (fn1
, fn2
);
3851 /* Print information about a candidate FN being rejected due to INFO. */
3854 print_conversion_rejection (location_t loc
, struct conversion_info
*info
,
3857 tree from
= info
->from
;
3859 from
= lvalue_type (from
);
3860 if (info
->n_arg
== -1)
3862 /* Conversion of implicit `this' argument failed. */
3863 if (!TYPE_P (info
->from
))
3864 /* A bad conversion for 'this' must be discarding cv-quals. */
3865 inform (loc
, " passing %qT as %<this%> "
3866 "argument discards qualifiers",
3869 inform (loc
, " no known conversion for implicit "
3870 "%<this%> parameter from %qH to %qI",
3871 from
, info
->to_type
);
3873 else if (!TYPE_P (info
->from
))
3875 if (info
->n_arg
>= 0)
3876 inform (loc
, " conversion of argument %d would be ill-formed:",
3878 iloc_sentinel ils
= loc
;
3879 perform_implicit_conversion (info
->to_type
, info
->from
,
3880 tf_warning_or_error
);
3882 else if (info
->n_arg
== -2)
3883 /* Conversion of conversion function return value failed. */
3884 inform (loc
, " no known conversion from %qH to %qI",
3885 from
, info
->to_type
);
3888 if (TREE_CODE (fn
) == FUNCTION_DECL
)
3889 loc
= get_fndecl_argument_location (fn
, info
->n_arg
);
3890 inform (loc
, " no known conversion for argument %d from %qH to %qI",
3891 info
->n_arg
+ 1, from
, info
->to_type
);
3895 /* Print information about a candidate with WANT parameters and we found
3899 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
,
3903 inform_n (loc
, want
,
3904 " candidate expects at least %d argument, %d provided",
3905 " candidate expects at least %d arguments, %d provided",
3908 inform_n (loc
, want
,
3909 " candidate expects %d argument, %d provided",
3910 " candidate expects %d arguments, %d provided",
3914 /* Print information about one overload candidate CANDIDATE. MSGSTR
3915 is the text to print before the candidate itself.
3917 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3918 to have been run through gettext by the caller. This wart makes
3919 life simpler in print_z_candidates and for the translators. */
3922 print_z_candidate (location_t loc
, const char *msgstr
,
3923 struct z_candidate
*candidate
)
3925 const char *msg
= (msgstr
== NULL
3927 : ACONCAT ((_(msgstr
), " ", NULL
)));
3928 tree fn
= candidate
->fn
;
3929 if (flag_new_inheriting_ctors
)
3930 fn
= strip_inheriting_ctors (fn
);
3931 location_t cloc
= location_of (fn
);
3933 if (identifier_p (fn
))
3936 if (candidate
->num_convs
== 3)
3937 inform (cloc
, "%s%<%D(%T, %T, %T)%> (built-in)", msg
, fn
,
3938 candidate
->convs
[0]->type
,
3939 candidate
->convs
[1]->type
,
3940 candidate
->convs
[2]->type
);
3941 else if (candidate
->num_convs
== 2)
3942 inform (cloc
, "%s%<%D(%T, %T)%> (built-in)", msg
, fn
,
3943 candidate
->convs
[0]->type
,
3944 candidate
->convs
[1]->type
);
3946 inform (cloc
, "%s%<%D(%T)%> (built-in)", msg
, fn
,
3947 candidate
->convs
[0]->type
);
3949 else if (TYPE_P (fn
))
3950 inform (cloc
, "%s%qT (conversion)", msg
, fn
);
3951 else if (candidate
->viable
== -1)
3952 inform (cloc
, "%s%#qD (near match)", msg
, fn
);
3953 else if (ignored_candidate_p (candidate
))
3954 inform (cloc
, "%s%#qD (ignored)", msg
, fn
);
3955 else if (DECL_DELETED_FN (fn
))
3956 inform (cloc
, "%s%#qD (deleted)", msg
, fn
);
3957 else if (candidate
->reversed ())
3958 inform (cloc
, "%s%#qD (reversed)", msg
, fn
);
3959 else if (candidate
->rewritten ())
3960 inform (cloc
, "%s%#qD (rewritten)", msg
, fn
);
3962 inform (cloc
, "%s%#qD", msg
, fn
);
3963 if (fn
!= candidate
->fn
)
3965 cloc
= location_of (candidate
->fn
);
3966 inform (cloc
, " inherited here");
3968 /* Give the user some information about why this candidate failed. */
3969 if (candidate
->reason
!= NULL
)
3971 struct rejection_reason
*r
= candidate
->reason
;
3976 print_arity_information (cloc
, r
->u
.arity
.actual
,
3977 r
->u
.arity
.expected
,
3978 r
->u
.arity
.least_p
);
3980 case rr_arg_conversion
:
3981 print_conversion_rejection (cloc
, &r
->u
.conversion
, fn
);
3983 case rr_bad_arg_conversion
:
3984 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
, fn
);
3986 case rr_explicit_conversion
:
3987 inform (cloc
, " return type %qT of explicit conversion function "
3988 "cannot be converted to %qT with a qualification "
3989 "conversion", r
->u
.conversion
.from
,
3990 r
->u
.conversion
.to_type
);
3992 case rr_template_conversion
:
3993 inform (cloc
, " conversion from return type %qT of template "
3994 "conversion function specialization to %qT is not an "
3995 "exact match", r
->u
.conversion
.from
,
3996 r
->u
.conversion
.to_type
);
3998 case rr_template_unification
:
3999 /* We use template_unification_error_rejection if unification caused
4000 actual non-SFINAE errors, in which case we don't need to repeat
4002 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
4004 inform (cloc
, " substitution of deduced template arguments "
4005 "resulted in errors seen above");
4008 /* Re-run template unification with diagnostics. */
4009 inform (cloc
, " template argument deduction/substitution failed:");
4010 fn_type_unification (r
->u
.template_unification
.tmpl
,
4011 r
->u
.template_unification
.explicit_targs
,
4013 (r
->u
.template_unification
.num_targs
)),
4014 r
->u
.template_unification
.args
,
4015 r
->u
.template_unification
.nargs
,
4016 r
->u
.template_unification
.return_type
,
4017 r
->u
.template_unification
.strict
,
4018 r
->u
.template_unification
.flags
,
4021 case rr_invalid_copy
:
4023 " a constructor taking a single argument of its own "
4024 "class type is invalid");
4026 case rr_constraint_failure
:
4027 diagnose_constraints (cloc
, fn
, NULL_TREE
);
4029 case rr_inherited_ctor
:
4030 inform (cloc
, " an inherited constructor is not a candidate for "
4031 "initialization from an expression of the same or derived "
4038 /* This candidate didn't have any issues or we failed to
4039 handle a particular code. Either way... */
4045 /* Print information about each overload candidate in CANDIDATES,
4046 which is assumed to have gone through splice_viable and tourney
4047 (if splice_viable succeeded). */
4050 print_z_candidates (location_t loc
, struct z_candidate
*candidates
,
4051 tristate only_viable_p
/* = tristate::unknown () */)
4053 struct z_candidate
*cand1
;
4054 struct z_candidate
**cand2
;
4059 /* Remove non-viable deleted candidates. */
4061 for (cand2
= &cand1
; *cand2
; )
4063 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
4064 && !(*cand2
)->viable
4065 && DECL_DELETED_FN ((*cand2
)->fn
))
4066 *cand2
= (*cand2
)->next
;
4068 cand2
= &(*cand2
)->next
;
4070 /* ...if there are any non-deleted ones. */
4074 /* There may be duplicates in the set of candidates. We put off
4075 checking this condition as long as possible, since we have no way
4076 to eliminate duplicates from a set of functions in less than n^2
4077 time. Now we are about to emit an error message, so it is more
4078 permissible to go slowly. */
4079 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
4081 tree fn
= cand1
->fn
;
4082 /* Skip builtin candidates and conversion functions. */
4085 cand2
= &cand1
->next
;
4088 if (DECL_P ((*cand2
)->fn
)
4089 && equal_functions (fn
, (*cand2
)->fn
))
4090 *cand2
= (*cand2
)->next
;
4092 cand2
= &(*cand2
)->next
;
4096 /* Unless otherwise specified, if there's a (strictly) viable candidate
4097 then we assume we're being called as part of diagnosing ambiguity, in
4098 which case we want to print only viable candidates since non-viable
4099 candidates couldn't have contributed to the ambiguity. */
4100 if (only_viable_p
.is_unknown ())
4101 only_viable_p
= candidates
->viable
== 1;
4103 for (; candidates
; candidates
= candidates
->next
)
4105 if (only_viable_p
.is_true () && candidates
->viable
!= 1)
4107 if (ignored_candidate_p (candidates
) && !flag_diagnostics_all_candidates
)
4109 inform (loc
, "some candidates omitted; "
4110 "use %<-fdiagnostics-all-candidates%> to display them");
4113 print_z_candidate (loc
, N_("candidate:"), candidates
);
4117 /* USER_SEQ is a user-defined conversion sequence, beginning with a
4118 USER_CONV. STD_SEQ is the standard conversion sequence applied to
4119 the result of the conversion function to convert it to the final
4120 desired type. Merge the two sequences into a single sequence,
4121 and return the merged sequence. */
4124 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
4127 bool bad
= user_seq
->bad_p
;
4129 gcc_assert (user_seq
->kind
== ck_user
);
4131 /* Find the end of the second conversion sequence. */
4132 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
4134 /* The entire sequence is a user-conversion sequence. */
4135 (*t
)->user_conv_p
= true;
4140 if ((*t
)->rvaluedness_matches_p
)
4141 /* We're binding a reference directly to the result of the conversion.
4142 build_user_type_conversion_1 stripped the REFERENCE_TYPE from the return
4143 type, but we want it back. */
4144 user_seq
->type
= TREE_TYPE (TREE_TYPE (user_seq
->cand
->fn
));
4146 /* Replace the identity conversion with the user conversion
4153 /* Handle overload resolution for initializing an object of class type from
4154 an initializer list. First we look for a suitable constructor that
4155 takes a std::initializer_list; if we don't find one, we then look for a
4156 non-list constructor.
4158 Parameters are as for add_candidates, except that the arguments are in
4159 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
4160 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
4163 add_list_candidates (tree fns
, tree first_arg
,
4164 const vec
<tree
, va_gc
> *args
, tree totype
,
4165 tree explicit_targs
, bool template_only
,
4166 tree conversion_path
, tree access_path
,
4168 struct z_candidate
**candidates
,
4169 tsubst_flags_t complain
)
4171 gcc_assert (*candidates
== NULL
);
4173 /* We're looking for a ctor for list-initialization. */
4174 flags
|= LOOKUP_LIST_INIT_CTOR
;
4175 /* And we don't allow narrowing conversions. We also use this flag to
4176 avoid the copy constructor call for copy-list-initialization. */
4177 flags
|= LOOKUP_NO_NARROWING
;
4179 unsigned nart
= num_artificial_parms_for (OVL_FIRST (fns
)) - 1;
4180 tree init_list
= (*args
)[nart
];
4182 /* Always use the default constructor if the list is empty (DR 990). */
4183 if (CONSTRUCTOR_NELTS (init_list
) == 0
4184 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
4186 else if (CONSTRUCTOR_IS_DESIGNATED_INIT (init_list
)
4187 && !CP_AGGREGATE_TYPE_P (totype
))
4189 if (complain
& tf_error
)
4190 error ("designated initializers cannot be used with a "
4191 "non-aggregate type %qT", totype
);
4194 /* If the class has a list ctor, try passing the list as a single
4195 argument first, but only consider list ctors. */
4196 else if (TYPE_HAS_LIST_CTOR (totype
))
4198 flags
|= LOOKUP_LIST_ONLY
;
4199 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
4200 explicit_targs
, template_only
, conversion_path
,
4201 access_path
, flags
, candidates
, complain
);
4202 if (any_strictly_viable (*candidates
))
4206 /* Expand the CONSTRUCTOR into a new argument vec. */
4207 vec
<tree
, va_gc
> *new_args
;
4208 vec_alloc (new_args
, nart
+ CONSTRUCTOR_NELTS (init_list
));
4209 for (unsigned i
= 0; i
< nart
; ++i
)
4210 new_args
->quick_push ((*args
)[i
]);
4211 for (unsigned i
= 0; i
< CONSTRUCTOR_NELTS (init_list
); ++i
)
4212 new_args
->quick_push (CONSTRUCTOR_ELT (init_list
, i
)->value
);
4214 /* We aren't looking for list-ctors anymore. */
4215 flags
&= ~LOOKUP_LIST_ONLY
;
4216 /* We allow more user-defined conversions within an init-list. */
4217 flags
&= ~LOOKUP_NO_CONVERSION
;
4219 add_candidates (fns
, first_arg
, new_args
, NULL_TREE
,
4220 explicit_targs
, template_only
, conversion_path
,
4221 access_path
, flags
, candidates
, complain
);
4224 /* Given C(std::initializer_list<A>), return A. */
4227 list_ctor_element_type (tree fn
)
4229 gcc_checking_assert (is_list_ctor (fn
));
4231 tree parm
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
4232 parm
= non_reference (TREE_VALUE (parm
));
4233 return TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
4236 /* If EXPR is a braced-init-list where the elements all decay to the same type,
4237 return that type. */
4240 braced_init_element_type (tree expr
)
4242 if (TREE_CODE (expr
) == CONSTRUCTOR
4243 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
4244 return TREE_TYPE (TREE_TYPE (expr
));
4245 if (!BRACE_ENCLOSED_INITIALIZER_P (expr
))
4248 tree elttype
= NULL_TREE
;
4249 for (constructor_elt
&e
: CONSTRUCTOR_ELTS (expr
))
4251 tree type
= TREE_TYPE (e
.value
);
4252 type
= type_decays_to (type
);
4255 else if (!same_type_p (type
, elttype
))
4261 /* True iff EXPR contains any temporaries with non-trivial destruction.
4263 ??? Also ignore classes with non-trivial but no-op destruction other than
4267 has_non_trivial_temporaries (tree expr
)
4269 auto_vec
<tree
*> temps
;
4270 cp_walk_tree_without_duplicates (&expr
, find_temps_r
, &temps
);
4271 for (tree
*p
: temps
)
4273 tree t
= TREE_TYPE (*p
);
4274 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (t
)
4275 && !is_std_allocator (t
))
4281 /* We're initializing an array of ELTTYPE from INIT. If it seems useful,
4282 return INIT as an array (of its own type) so the caller can initialize the
4283 target array in a loop. */
4286 maybe_init_list_as_array (tree elttype
, tree init
)
4288 /* Only do this if the array can go in rodata but not once converted. */
4289 if (!TYPE_NON_AGGREGATE_CLASS (elttype
))
4291 tree init_elttype
= braced_init_element_type (init
);
4292 if (!init_elttype
|| !SCALAR_TYPE_P (init_elttype
) || !TREE_CONSTANT (init
))
4295 /* Check with a stub expression to weed out special cases, and check whether
4296 we call the same function for direct-init as copy-list-init. */
4297 conversion_obstack_sentinel cos
;
4298 tree arg
= build_stub_object (init_elttype
);
4299 conversion
*c
= implicit_conversion (elttype
, init_elttype
, arg
, false,
4300 LOOKUP_NORMAL
, tf_none
);
4301 if (c
&& c
->kind
== ck_rvalue
)
4302 c
= next_conversion (c
);
4303 if (!c
|| c
->kind
!= ck_user
)
4306 tree first
= CONSTRUCTOR_ELT (init
, 0)->value
;
4307 conversion
*fc
= implicit_conversion (elttype
, init_elttype
, first
, false,
4308 LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
,
4310 if (fc
&& fc
->kind
== ck_rvalue
)
4311 fc
= next_conversion (fc
);
4312 if (!fc
|| fc
->kind
!= ck_user
|| fc
->cand
->fn
!= c
->cand
->fn
)
4314 first
= convert_like (fc
, first
, tf_none
);
4315 if (first
== error_mark_node
)
4316 /* Let the normal code give the error. */
4319 /* Don't do this if the conversion would be constant. */
4320 first
= maybe_constant_init (first
);
4321 if (TREE_CONSTANT (first
))
4324 /* We can't do this if the conversion creates temporaries that need
4325 to live until the whole array is initialized. */
4326 if (has_non_trivial_temporaries (first
))
4329 /* We can't do this if copying from the initializer_list would be
4331 tree copy_argtypes
= make_tree_vec (1);
4332 TREE_VEC_ELT (copy_argtypes
, 0)
4333 = cp_build_qualified_type (elttype
, TYPE_QUAL_CONST
);
4334 if (!is_xible (INIT_EXPR
, elttype
, copy_argtypes
))
4337 init_elttype
= cp_build_qualified_type (init_elttype
, TYPE_QUAL_CONST
);
4338 tree arr
= build_array_of_n_type (init_elttype
, CONSTRUCTOR_NELTS (init
));
4339 arr
= finish_compound_literal (arr
, init
, tf_none
);
4340 DECL_MERGEABLE (TARGET_EXPR_SLOT (arr
)) = true;
4344 /* If we were going to call e.g. vector(initializer_list<string>) starting
4345 with a list of string-literals (which is inefficient, see PR105838),
4346 instead build an array of const char* and pass it to the range constructor.
4347 But only do this for standard library types, where we can assume the
4348 transformation makes sense.
4350 Really the container classes should have initializer_list<U> constructors to
4351 get the same effect more simply; this is working around that lack. */
4354 maybe_init_list_as_range (tree fn
, tree expr
)
4356 if (!processing_template_decl
4357 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
4358 && is_list_ctor (fn
)
4359 && decl_in_std_namespace_p (fn
))
4361 tree to
= list_ctor_element_type (fn
);
4362 if (tree init
= maybe_init_list_as_array (to
, expr
))
4364 tree begin
= decay_conversion (TARGET_EXPR_SLOT (init
), tf_none
);
4365 tree nelts
= array_type_nelts_top (TREE_TYPE (init
));
4366 tree end
= cp_build_binary_op (input_location
, PLUS_EXPR
, begin
,
4368 begin
= cp_build_compound_expr (init
, begin
, tf_none
);
4369 return build_constructor_va (init_list_type_node
, 2,
4370 NULL_TREE
, begin
, NULL_TREE
, end
);
4377 /* Returns the best overload candidate to perform the requested
4378 conversion. This function is used for three the overloading situations
4379 described in [over.match.copy], [over.match.conv], and [over.match.ref].
4380 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
4381 per [dcl.init.ref], so we ignore temporary bindings. */
4383 static struct z_candidate
*
4384 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
4385 tsubst_flags_t complain
)
4387 struct z_candidate
*candidates
, *cand
;
4389 tree ctors
= NULL_TREE
;
4390 tree conv_fns
= NULL_TREE
;
4391 conversion
*conv
= NULL
;
4392 tree first_arg
= NULL_TREE
;
4393 vec
<tree
, va_gc
> *args
= NULL
;
4400 fromtype
= TREE_TYPE (expr
);
4402 /* We represent conversion within a hierarchy using RVALUE_CONV and
4403 BASE_CONV, as specified by [over.best.ics]; these become plain
4404 constructor calls, as specified in [dcl.init]. */
4405 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
4406 || !DERIVED_FROM_P (totype
, fromtype
));
4408 if (CLASS_TYPE_P (totype
))
4409 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
4410 creating a garbage BASELINK; constructors can't be inherited. */
4411 ctors
= get_class_binding (totype
, complete_ctor_identifier
);
4413 tree to_nonref
= non_reference (totype
);
4414 if (MAYBE_CLASS_TYPE_P (fromtype
))
4416 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
4417 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
4418 && DERIVED_FROM_P (to_nonref
, fromtype
)))
4420 /* [class.conv.fct] A conversion function is never used to
4421 convert a (possibly cv-qualified) object to the (possibly
4422 cv-qualified) same object type (or a reference to it), to a
4423 (possibly cv-qualified) base class of that type (or a
4424 reference to it)... */
4427 conv_fns
= lookup_conversions (fromtype
);
4431 flags
|= LOOKUP_NO_CONVERSION
;
4432 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
4433 flags
|= LOOKUP_NO_NARROWING
;
4434 /* Prevent add_candidates from treating a non-strictly viable candidate
4436 complain
|= tf_conv
;
4438 /* It's OK to bind a temporary for converting constructor arguments, but
4439 not in converting the return value of a conversion operator. */
4440 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
4441 | (flags
& LOOKUP_NO_NARROWING
));
4442 flags
&= ~LOOKUP_NO_TEMP_BIND
;
4446 int ctorflags
= flags
;
4448 first_arg
= build_dummy_object (totype
);
4450 /* We should never try to call the abstract or base constructor
4452 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_FIRST (ctors
))
4453 && !DECL_HAS_VTT_PARM_P (OVL_FIRST (ctors
)));
4455 args
= make_tree_vector_single (expr
);
4456 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
4458 /* List-initialization. */
4459 add_list_candidates (ctors
, first_arg
, args
, totype
, NULL_TREE
,
4460 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
4461 ctorflags
, &candidates
, complain
);
4465 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
4466 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
4467 ctorflags
, &candidates
, complain
);
4470 for (cand
= candidates
; cand
; cand
= cand
->next
)
4472 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
4474 /* If totype isn't a reference, and LOOKUP_ONLYCONVERTING is
4475 set, then this is copy-initialization. In that case, "The
4476 result of the call is then used to direct-initialize the
4477 object that is the destination of the copy-initialization."
4480 We represent this in the conversion sequence with an
4481 rvalue conversion, which means a constructor call. */
4482 if (!TYPE_REF_P (totype
)
4483 && cxx_dialect
< cxx17
4484 && (flags
& LOOKUP_ONLYCONVERTING
)
4485 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
4487 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
4493 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
4494 first_arg
= CONSTRUCTOR_ELT (expr
, 0)->value
;
4499 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
4501 tree conversion_path
= TREE_PURPOSE (conv_fns
);
4502 struct z_candidate
*old_candidates
;
4504 /* If LOOKUP_NO_CONVERSION, don't consider a conversion function that
4505 would need an addional user-defined conversion, i.e. if the return
4506 type differs in class-ness from the desired type. So we avoid
4507 considering operator bool when calling a copy constructor.
4509 This optimization avoids the failure in PR97600, and is allowed by
4510 [temp.inst]/9: "If the function selected by overload resolution can be
4511 determined without instantiating a class template definition, it is
4512 unspecified whether that instantiation actually takes place." */
4513 tree convtype
= non_reference (TREE_TYPE (conv_fns
));
4514 if ((flags
& LOOKUP_NO_CONVERSION
)
4515 && !WILDCARD_TYPE_P (convtype
)
4516 && (CLASS_TYPE_P (to_nonref
)
4517 != CLASS_TYPE_P (convtype
)))
4520 /* If we are called to convert to a reference type, we are trying to
4521 find a direct binding, so don't even consider temporaries. If
4522 we don't find a direct binding, the caller will try again to
4523 look for a temporary binding. */
4524 if (TYPE_REF_P (totype
))
4525 convflags
|= LOOKUP_NO_TEMP_BIND
;
4527 old_candidates
= candidates
;
4528 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
4530 conversion_path
, TYPE_BINFO (fromtype
),
4531 flags
, &candidates
, complain
);
4533 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
4535 if (cand
->viable
== 0)
4536 /* Already rejected, don't change to -1. */
4539 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
4541 = implicit_conversion (totype
,
4544 /*c_cast_p=*/false, convflags
,
4547 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
4548 copy-initialization. In that case, "The result of the
4549 call is then used to direct-initialize the object that is
4550 the destination of the copy-initialization." [dcl.init]
4552 We represent this in the conversion sequence with an
4553 rvalue conversion, which means a constructor call. But
4554 don't add a second rvalue conversion if there's already
4555 one there. Which there really shouldn't be, but it's
4556 harmless since we'd add it here anyway. */
4557 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
4558 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
4559 ics
= build_conv (ck_rvalue
, totype
, ics
);
4561 cand
->second_conv
= ics
;
4566 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -2,
4568 EXPR_LOCATION (expr
));
4570 else if (TYPE_REF_P (totype
) && !ics
->rvaluedness_matches_p
4571 /* Limit this to non-templates for now (PR90546). */
4572 && !cand
->template_decl
4573 && TREE_CODE (TREE_TYPE (totype
)) != FUNCTION_TYPE
)
4575 /* If we are called to convert to a reference type, we are trying
4576 to find a direct binding per [over.match.ref], so rvaluedness
4577 must match for non-functions. */
4580 else if (DECL_NONCONVERTING_P (cand
->fn
)
4581 && ics
->rank
> cr_exact
)
4583 /* 13.3.1.5: For direct-initialization, those explicit
4584 conversion functions that are not hidden within S and
4585 yield type T or a type that can be converted to type T
4586 with a qualification conversion (4.4) are also candidate
4588 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
4589 I've raised this issue with the committee. --jason 9/2011 */
4591 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
4593 else if (cand
->viable
== 1 && ics
->bad_p
)
4597 = bad_arg_conversion_rejection (NULL_TREE
, -2,
4599 EXPR_LOCATION (expr
));
4601 else if (primary_template_specialization_p (cand
->fn
)
4602 && ics
->rank
> cr_exact
)
4604 /* 13.3.3.1.2: If the user-defined conversion is specified by
4605 a specialization of a conversion function template, the
4606 second standard conversion sequence shall have exact match
4609 cand
->reason
= template_conversion_rejection (rettype
, totype
);
4614 candidates
= splice_viable (candidates
, false, &any_viable_p
);
4618 release_tree_vector (args
);
4622 cand
= tourney (candidates
, complain
);
4625 if (complain
& tf_error
)
4627 auto_diagnostic_group d
;
4628 error_at (cp_expr_loc_or_input_loc (expr
),
4629 "conversion from %qH to %qI is ambiguous",
4631 print_z_candidates (location_of (expr
), candidates
);
4634 cand
= candidates
; /* any one will do */
4635 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
4636 cand
->second_conv
->user_conv_p
= true;
4637 if (!any_strictly_viable (candidates
))
4638 cand
->second_conv
->bad_p
= true;
4639 if (flags
& LOOKUP_ONLYCONVERTING
)
4640 cand
->second_conv
->need_temporary_p
= true;
4641 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
4642 ambiguous conversion is no worse than another user-defined
4648 /* Maybe pass { } as iterators instead of an initializer_list. */
4649 if (tree iters
= maybe_init_list_as_range (cand
->fn
, expr
))
4650 if (z_candidate
*cand2
4651 = build_user_type_conversion_1 (totype
, iters
, flags
, tf_none
))
4652 if (cand2
->viable
== 1 && !is_list_ctor (cand2
->fn
))
4659 if (!DECL_CONSTRUCTOR_P (cand
->fn
))
4660 convtype
= non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)));
4661 else if (cand
->second_conv
->kind
== ck_rvalue
)
4662 /* DR 5: [in the first step of copy-initialization]...if the function
4663 is a constructor, the call initializes a temporary of the
4664 cv-unqualified version of the destination type. */
4665 convtype
= cv_unqualified (totype
);
4668 /* Build the user conversion sequence. */
4672 build_identity_conv (TREE_TYPE (expr
), expr
));
4674 if (cand
->viable
== -1)
4677 /* Remember that this was a list-initialization. */
4678 if (flags
& LOOKUP_NO_NARROWING
)
4679 conv
->check_narrowing
= true;
4681 /* Combine it with the second conversion sequence. */
4682 cand
->second_conv
= merge_conversion_sequences (conv
,
4688 /* Wrapper for above. */
4691 build_user_type_conversion (tree totype
, tree expr
, int flags
,
4692 tsubst_flags_t complain
)
4694 struct z_candidate
*cand
;
4697 auto_cond_timevar
tv (TV_OVERLOAD
);
4699 conversion_obstack_sentinel cos
;
4701 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
4705 if (cand
->second_conv
->kind
== ck_ambig
)
4706 ret
= error_mark_node
;
4709 expr
= convert_like (cand
->second_conv
, expr
, complain
);
4710 ret
= convert_from_reference (expr
);
4719 /* Give a helpful diagnostic when implicit_conversion fails. */
4722 implicit_conversion_error (location_t loc
, tree type
, tree expr
)
4724 tsubst_flags_t complain
= tf_warning_or_error
;
4726 /* If expr has unknown type, then it is an overloaded function.
4727 Call instantiate_type to get good error messages. */
4728 if (TREE_TYPE (expr
) == unknown_type_node
)
4729 instantiate_type (type
, expr
, complain
);
4730 else if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
4731 /* We gave an error. */;
4732 else if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
4733 && CONSTRUCTOR_IS_DESIGNATED_INIT (expr
)
4734 && !CP_AGGREGATE_TYPE_P (type
))
4735 error_at (loc
, "designated initializers cannot be used with a "
4736 "non-aggregate type %qT", type
);
4739 range_label_for_type_mismatch
label (TREE_TYPE (expr
), type
);
4740 gcc_rich_location
rich_loc (loc
, &label
);
4741 error_at (&rich_loc
, "could not convert %qE from %qH to %qI",
4742 expr
, TREE_TYPE (expr
), type
);
4746 /* Worker for build_converted_constant_expr. */
4749 build_converted_constant_expr_internal (tree type
, tree expr
,
4750 int flags
, tsubst_flags_t complain
)
4754 location_t loc
= cp_expr_loc_or_input_loc (expr
);
4756 if (error_operand_p (expr
))
4757 return error_mark_node
;
4759 conversion_obstack_sentinel cos
;
4761 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
4762 /*c_cast_p=*/false, flags
, complain
);
4764 /* A converted constant expression of type T is an expression, implicitly
4765 converted to type T, where the converted expression is a constant
4766 expression and the implicit conversion sequence contains only
4768 * user-defined conversions,
4769 * lvalue-to-rvalue conversions (7.1),
4770 * array-to-pointer conversions (7.2),
4771 * function-to-pointer conversions (7.3),
4772 * qualification conversions (7.5),
4773 * integral promotions (7.6),
4774 * integral conversions (7.8) other than narrowing conversions (11.6.4),
4775 * null pointer conversions (7.11) from std::nullptr_t,
4776 * null member pointer conversions (7.12) from std::nullptr_t, and
4777 * function pointer conversions (7.13),
4779 and where the reference binding (if any) binds directly. */
4781 for (conversion
*c
= conv
;
4782 c
&& c
->kind
!= ck_identity
;
4783 c
= next_conversion (c
))
4787 /* A conversion function is OK. If it isn't constexpr, we'll
4788 complain later that the argument isn't constant. */
4790 /* List-initialization is OK. */
4792 /* The lvalue-to-rvalue conversion is OK. */
4794 /* Array-to-pointer and function-to-pointer. */
4796 /* Function pointer conversions. */
4798 /* Qualification conversions. */
4803 if (c
->need_temporary_p
)
4805 if (complain
& tf_error
)
4806 error_at (loc
, "initializing %qH with %qI in converted "
4807 "constant expression does not bind directly",
4808 type
, next_conversion (c
)->type
);
4817 t
= next_conversion (c
)->type
;
4818 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
)
4819 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
4820 /* Integral promotion or conversion. */
4822 if (NULLPTR_TYPE_P (t
))
4823 /* Conversion from nullptr to pointer or pointer-to-member. */
4826 if (complain
& tf_error
)
4827 error_at (loc
, "conversion from %qH to %qI in a "
4828 "converted constant expression", t
, type
);
4837 /* Avoid confusing convert_nontype_argument by introducing
4838 a redundant conversion to the same reference type. */
4839 if (conv
&& conv
->kind
== ck_ref_bind
4840 && REFERENCE_REF_P (expr
))
4842 tree ref
= TREE_OPERAND (expr
, 0);
4843 if (same_type_p (type
, TREE_TYPE (ref
)))
4849 /* Don't copy a class in a template. */
4850 if (CLASS_TYPE_P (type
) && conv
->kind
== ck_rvalue
4851 && processing_template_decl
)
4852 conv
= next_conversion (conv
);
4854 /* Issuing conversion warnings for value-dependent expressions is
4855 likely too noisy. */
4856 warning_sentinel
w (warn_conversion
);
4857 conv
->check_narrowing
= true;
4858 conv
->check_narrowing_const_only
= true;
4859 expr
= convert_like (conv
, expr
, complain
);
4863 if (complain
& tf_error
)
4864 implicit_conversion_error (loc
, type
, expr
);
4865 expr
= error_mark_node
;
4871 /* Subroutine of convert_nontype_argument.
4873 EXPR is an expression used in a context that requires a converted
4874 constant-expression, such as a template non-type parameter. Do any
4875 necessary conversions (that are permitted for converted
4876 constant-expressions) to convert it to the desired type.
4878 This function doesn't consider explicit conversion functions. If
4879 you mean to use "a contextually converted constant expression of type
4880 bool", use build_converted_constant_bool_expr.
4882 If conversion is successful, returns the converted expression;
4883 otherwise, returns error_mark_node. */
4886 build_converted_constant_expr (tree type
, tree expr
, tsubst_flags_t complain
)
4888 return build_converted_constant_expr_internal (type
, expr
, LOOKUP_IMPLICIT
,
4892 /* Used to create "a contextually converted constant expression of type
4893 bool". This differs from build_converted_constant_expr in that it
4894 also considers explicit conversion functions. */
4897 build_converted_constant_bool_expr (tree expr
, tsubst_flags_t complain
)
4899 return build_converted_constant_expr_internal (boolean_type_node
, expr
,
4900 LOOKUP_NORMAL
, complain
);
4903 /* Do any initial processing on the arguments to a function call. */
4906 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
4911 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
4913 if (error_operand_p (arg
))
4915 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
4917 if (complain
& tf_error
)
4918 error_at (cp_expr_loc_or_input_loc (arg
),
4919 "invalid use of void expression");
4922 else if (invalid_nonstatic_memfn_p (EXPR_LOCATION (arg
), arg
, complain
))
4925 /* Force auto deduction now. Omit tf_warning to avoid redundant
4926 deprecated warning on deprecated-14.C. */
4927 if (!mark_single_function (arg
, complain
& ~tf_warning
))
4933 /* Perform overload resolution on FN, which is called with the ARGS.
4935 Return the candidate function selected by overload resolution, or
4936 NULL if the event that overload resolution failed. In the case
4937 that overload resolution fails, *CANDIDATES will be the set of
4938 candidates considered, and ANY_VIABLE_P will be set to true or
4939 false to indicate whether or not any of the candidates were
4942 The ARGS should already have gone through RESOLVE_ARGS before this
4943 function is called. */
4945 static struct z_candidate
*
4946 perform_overload_resolution (tree fn
,
4947 const vec
<tree
, va_gc
> *args
,
4948 struct z_candidate
**candidates
,
4949 bool *any_viable_p
, tsubst_flags_t complain
)
4951 struct z_candidate
*cand
;
4952 tree explicit_targs
;
4955 auto_cond_timevar
tv (TV_OVERLOAD
);
4957 explicit_targs
= NULL_TREE
;
4961 *any_viable_p
= true;
4964 gcc_assert (OVL_P (fn
) || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
4966 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4968 explicit_targs
= TREE_OPERAND (fn
, 1);
4969 fn
= TREE_OPERAND (fn
, 0);
4973 /* Add the various candidate functions. */
4974 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
4975 explicit_targs
, template_only
,
4976 /*conversion_path=*/NULL_TREE
,
4977 /*access_path=*/NULL_TREE
,
4979 candidates
, complain
);
4981 *candidates
= splice_viable (*candidates
, false, any_viable_p
);
4983 cand
= tourney (*candidates
, complain
);
4990 /* Print an error message about being unable to build a call to FN with
4991 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
4992 be located; CANDIDATES is a possibly empty list of such
4996 print_error_for_call_failure (tree fn
, const vec
<tree
, va_gc
> *args
,
4997 struct z_candidate
*candidates
)
4999 tree targs
= NULL_TREE
;
5000 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
5002 targs
= TREE_OPERAND (fn
, 1);
5003 fn
= TREE_OPERAND (fn
, 0);
5005 tree name
= OVL_NAME (fn
);
5006 location_t loc
= location_of (name
);
5008 name
= lookup_template_function (name
, targs
);
5010 auto_diagnostic_group d
;
5011 if (!any_strictly_viable (candidates
))
5012 error_at (loc
, "no matching function for call to %<%D(%A)%>",
5013 name
, build_tree_list_vec (args
));
5015 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
5016 name
, build_tree_list_vec (args
));
5018 print_z_candidates (loc
, candidates
);
5021 /* Perform overload resolution on the set of deduction guides DGUIDES
5022 using ARGS. Returns the selected deduction guide, or error_mark_node
5023 if overload resolution fails. */
5026 perform_dguide_overload_resolution (tree dguides
, const vec
<tree
, va_gc
> *args
,
5027 tsubst_flags_t complain
)
5029 z_candidate
*candidates
;
5033 gcc_assert (deduction_guide_p (OVL_FIRST (dguides
)));
5035 conversion_obstack_sentinel cos
;
5037 z_candidate
*cand
= perform_overload_resolution (dguides
, args
, &candidates
,
5038 &any_viable_p
, complain
);
5041 if (complain
& tf_error
)
5042 print_error_for_call_failure (dguides
, args
, candidates
);
5043 result
= error_mark_node
;
5051 /* Return an expression for a call to FN (a namespace-scope function,
5052 or a static member function) with the ARGS. This may change
5056 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
,
5057 tsubst_flags_t complain
)
5059 struct z_candidate
*candidates
, *cand
;
5063 if (args
!= NULL
&& *args
!= NULL
)
5065 *args
= resolve_args (*args
, complain
);
5067 return error_mark_node
;
5071 tm_malloc_replacement (fn
);
5073 conversion_obstack_sentinel cos
;
5075 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
5080 if (complain
& tf_error
)
5082 // If there is a single (non-viable) function candidate,
5083 // let the error be diagnosed by cp_build_function_call_vec.
5084 if (!any_viable_p
&& candidates
&& ! candidates
->next
5085 && TREE_CODE (candidates
->fn
) == FUNCTION_DECL
5086 /* A template-id callee consisting of a single (ignored)
5087 non-template candidate needs to be diagnosed the
5089 && (TREE_CODE (fn
) != TEMPLATE_ID_EXPR
5090 || candidates
->template_decl
))
5091 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
5093 // Otherwise, emit notes for non-viable candidates.
5094 print_error_for_call_failure (fn
, *args
, candidates
);
5096 result
= error_mark_node
;
5100 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5105 && TREE_CODE (result
) == CALL_EXPR
5106 && DECL_BUILT_IN_CLASS (TREE_OPERAND (CALL_EXPR_FN (result
), 0))
5108 result
= coro_validate_builtin_call (result
);
5113 /* Build a call to a global operator new. FNNAME is the name of the
5114 operator (either "operator new" or "operator new[]") and ARGS are
5115 the arguments provided. This may change ARGS. *SIZE points to the
5116 total number of bytes required by the allocation, and is updated if
5117 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
5118 be used. If this function determines that no cookie should be
5119 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
5120 is not NULL_TREE, it is evaluated before calculating the final
5121 array size, and if it fails, the array size is replaced with
5122 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
5123 is non-NULL, it will be set, upon return, to the allocation
5127 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
5128 tree
*size
, tree
*cookie_size
,
5129 tree align_arg
, tree size_check
,
5130 tree
*fn
, tsubst_flags_t complain
)
5132 tree original_size
= *size
;
5134 struct z_candidate
*candidates
;
5135 struct z_candidate
*cand
= NULL
;
5140 /* Set to (size_t)-1 if the size check fails. */
5141 if (size_check
!= NULL_TREE
)
5143 tree errval
= TYPE_MAX_VALUE (sizetype
);
5144 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
5145 errval
= throw_bad_array_new_length ();
5146 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
5147 original_size
, errval
);
5149 vec_safe_insert (*args
, 0, *size
);
5150 *args
= resolve_args (*args
, complain
);
5152 return error_mark_node
;
5154 conversion_obstack_sentinel cos
;
5160 If this lookup fails to find the name, or if the allocated type
5161 is not a class type, the allocation function's name is looked
5162 up in the global scope.
5164 we disregard block-scope declarations of "operator new". */
5165 fns
= lookup_qualified_name (global_namespace
, fnname
);
5169 vec
<tree
, va_gc
>* align_args
5170 = vec_copy_and_insert (*args
, align_arg
, 1);
5171 cand
= perform_overload_resolution (fns
, align_args
, &candidates
,
5172 &any_viable_p
, tf_none
);
5175 /* If no aligned allocation function matches, try again without the
5179 /* Figure out what function is being called. */
5181 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
5184 /* If no suitable function could be found, issue an error message
5188 if (complain
& tf_error
)
5189 print_error_for_call_failure (fns
, *args
, candidates
);
5190 return error_mark_node
;
5193 /* If a cookie is required, add some extra space. Whether
5194 or not a cookie is required cannot be determined until
5195 after we know which function was called. */
5198 bool use_cookie
= true;
5201 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5202 /* Skip the size_t parameter. */
5203 arg_types
= TREE_CHAIN (arg_types
);
5204 /* Check the remaining parameters (if any). */
5206 && TREE_CHAIN (arg_types
) == void_list_node
5207 && same_type_p (TREE_VALUE (arg_types
),
5210 /* If we need a cookie, adjust the number of bytes allocated. */
5213 /* Update the total size. */
5214 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
5217 /* Set to (size_t)-1 if the size check fails. */
5218 gcc_assert (size_check
!= NULL_TREE
);
5219 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
5220 *size
, TYPE_MAX_VALUE (sizetype
));
5222 /* Update the argument list to reflect the adjusted size. */
5223 (**args
)[0] = *size
;
5226 *cookie_size
= NULL_TREE
;
5229 /* Tell our caller which function we decided to call. */
5233 /* Build the CALL_EXPR. */
5234 tree ret
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5236 /* Set this flag for all callers of this function. In addition to
5237 new-expressions, this is called for allocating coroutine state; treat
5238 that as an implicit new-expression. */
5239 tree call
= extract_call_expr (ret
);
5240 if (TREE_CODE (call
) == CALL_EXPR
)
5241 CALL_FROM_NEW_OR_DELETE_P (call
) = 1;
5246 /* Evaluate side-effects from OBJ before evaluating call
5247 to FN in RESULT expression.
5248 This is for expressions of the form `obj->fn(...)'
5249 where `fn' turns out to be a static member function and
5250 `obj' needs to be evaluated. `fn' could be also static operator[]
5251 or static operator(), in which cases the source expression
5252 would be `obj[...]' or `obj(...)'. */
5255 keep_unused_object_arg (tree result
, tree obj
, tree fn
)
5257 if (result
== NULL_TREE
5258 || result
== error_mark_node
5259 || DECL_OBJECT_MEMBER_FUNCTION_P (fn
)
5260 || !TREE_SIDE_EFFECTS (obj
))
5263 /* But avoid the implicit lvalue-rvalue conversion when `obj' is
5266 if (TREE_THIS_VOLATILE (a
))
5268 if (TREE_SIDE_EFFECTS (a
))
5269 return cp_build_compound_expr (a
, result
, tf_error
);
5273 /* Build a new call to operator(). This may change ARGS. */
5276 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
5278 struct z_candidate
*candidates
= 0, *cand
;
5279 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
5281 tree result
= NULL_TREE
;
5283 auto_cond_timevar
tv (TV_OVERLOAD
);
5285 obj
= mark_lvalue_use (obj
);
5287 if (error_operand_p (obj
))
5288 return error_mark_node
;
5290 tree type
= TREE_TYPE (obj
);
5292 obj
= prep_operand (obj
);
5294 if (TYPE_PTRMEMFUNC_P (type
))
5296 if (complain
& tf_error
)
5297 /* It's no good looking for an overloaded operator() on a
5298 pointer-to-member-function. */
5299 error ("pointer-to-member function %qE cannot be called without "
5300 "an object; consider using %<.*%> or %<->*%>", obj
);
5301 return error_mark_node
;
5304 if (TYPE_BINFO (type
))
5306 fns
= lookup_fnfields (TYPE_BINFO (type
), call_op_identifier
, 1, complain
);
5307 if (fns
== error_mark_node
)
5308 return error_mark_node
;
5313 if (args
!= NULL
&& *args
!= NULL
)
5315 *args
= resolve_args (*args
, complain
);
5317 return error_mark_node
;
5320 conversion_obstack_sentinel cos
;
5324 first_mem_arg
= obj
;
5326 add_candidates (BASELINK_FUNCTIONS (fns
),
5327 first_mem_arg
, *args
, NULL_TREE
,
5329 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
5330 LOOKUP_NORMAL
, &candidates
, complain
);
5333 bool any_call_ops
= candidates
!= nullptr;
5335 convs
= lookup_conversions (type
);
5337 for (; convs
; convs
= TREE_CHAIN (convs
))
5339 tree totype
= TREE_TYPE (convs
);
5341 if (TYPE_PTRFN_P (totype
)
5342 || TYPE_REFFN_P (totype
)
5343 || (TYPE_REF_P (totype
)
5344 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
5345 for (tree fn
: ovl_range (TREE_VALUE (convs
)))
5347 if (DECL_NONCONVERTING_P (fn
))
5350 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5352 /* Making this work broke PR 71117 and 85118, so until the
5353 committee resolves core issue 2189, let's disable this
5354 candidate if there are any call operators. */
5358 add_template_conv_candidate
5359 (&candidates
, fn
, obj
, *args
, totype
,
5360 /*access_path=*/NULL_TREE
,
5361 /*conversion_path=*/NULL_TREE
, complain
);
5364 add_conv_candidate (&candidates
, fn
, obj
,
5365 *args
, /*conversion_path=*/NULL_TREE
,
5366 /*access_path=*/NULL_TREE
, complain
);
5370 /* Be strict here because if we choose a bad conversion candidate, the
5371 errors we get won't mention the call context. */
5372 candidates
= splice_viable (candidates
, true, &any_viable_p
);
5375 if (complain
& tf_error
)
5377 auto_diagnostic_group d
;
5378 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
5379 build_tree_list_vec (*args
));
5380 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
5382 result
= error_mark_node
;
5386 cand
= tourney (candidates
, complain
);
5389 if (complain
& tf_error
)
5391 auto_diagnostic_group d
;
5392 error ("call of %<(%T) (%A)%> is ambiguous",
5393 TREE_TYPE (obj
), build_tree_list_vec (*args
));
5394 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
5396 result
= error_mark_node
;
5398 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
5399 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
)
5400 && DECL_OVERLOADED_OPERATOR_IS (cand
->fn
, CALL_EXPR
))
5402 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5403 /* In an expression of the form `a()' where cand->fn
5404 which is operator() turns out to be a static member function,
5405 `a' is none-the-less evaluated. */
5406 result
= keep_unused_object_arg (result
, obj
, cand
->fn
);
5410 if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5411 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
,
5415 gcc_checking_assert (TYPE_P (cand
->fn
));
5416 obj
= convert_like (cand
->convs
[0], obj
, complain
);
5418 obj
= convert_from_reference (obj
);
5419 result
= cp_build_function_call_vec (obj
, args
, complain
);
5426 /* Called by op_error to prepare format strings suitable for the error
5427 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
5428 and a suffix (controlled by NTYPES). */
5431 op_error_string (const char *errmsg
, int ntypes
, bool match
)
5435 const char *msgp
= concat (match
? G_("ambiguous overload for ")
5436 : G_("no match for "), errmsg
, NULL
);
5439 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
5440 else if (ntypes
== 2)
5441 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
5443 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
5449 op_error (const op_location_t
&loc
,
5450 enum tree_code code
, enum tree_code code2
,
5451 tree arg1
, tree arg2
, tree arg3
, bool match
)
5453 bool assop
= code
== MODIFY_EXPR
;
5454 const char *opname
= OVL_OP_INFO (assop
, assop
? code2
: code
)->name
;
5459 if (flag_diagnostics_show_caret
)
5460 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
5462 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
5464 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
5465 "in %<%E ? %E : %E%>"), 3, match
),
5467 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
5470 case POSTINCREMENT_EXPR
:
5471 case POSTDECREMENT_EXPR
:
5472 if (flag_diagnostics_show_caret
)
5473 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
5474 opname
, TREE_TYPE (arg1
));
5476 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
5478 opname
, arg1
, opname
, TREE_TYPE (arg1
));
5482 if (flag_diagnostics_show_caret
)
5483 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
5484 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5486 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
5488 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5493 if (flag_diagnostics_show_caret
)
5494 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
5495 opname
, TREE_TYPE (arg1
));
5497 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
5498 opname
, opname
, arg1
, TREE_TYPE (arg1
));
5502 if (flag_diagnostics_show_caret
)
5503 error_at (loc
, op_error_string (G_("%<operator %s%>"), 1, match
),
5504 opname
, TREE_TYPE (arg1
));
5506 error_at (loc
, op_error_string (G_("%<operator %s%> in %<%s%E%>"),
5508 opname
, opname
, arg1
, TREE_TYPE (arg1
));
5513 if (flag_diagnostics_show_caret
)
5515 binary_op_rich_location
richloc (loc
, arg1
, arg2
, true);
5517 op_error_string (G_("%<operator%s%>"), 2, match
),
5518 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5521 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
5523 opname
, arg1
, opname
, arg2
,
5524 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5526 if (flag_diagnostics_show_caret
)
5527 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
5528 opname
, TREE_TYPE (arg1
));
5530 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
5532 opname
, opname
, arg1
, TREE_TYPE (arg1
));
5537 /* Return the implicit conversion sequence that could be used to
5538 convert E1 to E2 in [expr.cond]. */
5541 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
5543 tree t1
= non_reference (TREE_TYPE (e1
));
5544 tree t2
= non_reference (TREE_TYPE (e2
));
5550 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
5551 implicitly converted (clause _conv_) to the type "lvalue reference to
5552 T2", subject to the constraint that in the conversion the
5553 reference must bind directly (_dcl.init.ref_) to an lvalue.
5555 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
5556 implicitly converted to the type "rvalue reference to T2", subject to
5557 the constraint that the reference must bind directly. */
5560 tree rtype
= cp_build_reference_type (t2
, !lvalue_p (e2
));
5561 conv
= implicit_conversion (rtype
,
5565 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
5566 |LOOKUP_ONLYCONVERTING
,
5568 if (conv
&& !conv
->bad_p
)
5572 /* If E2 is a prvalue or if neither of the conversions above can be done
5573 and at least one of the operands has (possibly cv-qualified) class
5575 if (!CLASS_TYPE_P (t1
) && !CLASS_TYPE_P (t2
))
5580 If E1 and E2 have class type, and the underlying class types are
5581 the same or one is a base class of the other: E1 can be converted
5582 to match E2 if the class of T2 is the same type as, or a base
5583 class of, the class of T1, and the cv-qualification of T2 is the
5584 same cv-qualification as, or a greater cv-qualification than, the
5585 cv-qualification of T1. If the conversion is applied, E1 is
5586 changed to an rvalue of type T2 that still refers to the original
5587 source class object (or the appropriate subobject thereof). */
5588 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
5589 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
5591 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
5593 conv
= build_identity_conv (t1
, e1
);
5594 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
5595 TYPE_MAIN_VARIANT (t2
)))
5596 conv
= build_conv (ck_base
, t2
, conv
);
5598 conv
= build_conv (ck_rvalue
, t2
, conv
);
5607 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
5608 converted to the type that expression E2 would have if E2 were
5609 converted to an rvalue (or the type it has, if E2 is an rvalue). */
5610 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
5611 LOOKUP_IMPLICIT
, complain
);
5614 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
5615 arguments to the conditional expression. */
5618 build_conditional_expr (const op_location_t
&loc
,
5619 tree arg1
, tree arg2
, tree arg3
,
5620 tsubst_flags_t complain
)
5624 tree result
= NULL_TREE
;
5625 tree result_type
= NULL_TREE
;
5626 tree semantic_result_type
= NULL_TREE
;
5627 bool is_glvalue
= true;
5628 struct z_candidate
*candidates
= 0;
5629 struct z_candidate
*cand
;
5630 tree orig_arg2
, orig_arg3
;
5632 auto_cond_timevar
tv (TV_OVERLOAD
);
5634 /* As a G++ extension, the second argument to the conditional can be
5635 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
5636 c'.) If the second operand is omitted, make sure it is
5637 calculated only once. */
5640 if (complain
& tf_error
)
5641 pedwarn (loc
, OPT_Wpedantic
,
5642 "ISO C++ forbids omitting the middle term of "
5643 "a %<?:%> expression");
5645 if ((complain
& tf_warning
) && !truth_value_p (TREE_CODE (arg1
)))
5646 warn_for_omitted_condop (loc
, arg1
);
5648 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
5649 if (glvalue_p (arg1
))
5651 arg1
= cp_stabilize_reference (arg1
);
5652 arg2
= arg1
= prevent_lifetime_extension (arg1
);
5654 else if (TREE_CODE (arg1
) == TARGET_EXPR
)
5655 /* arg1 can't be a prvalue result of the conditional
5656 expression, since it needs to be materialized for the
5657 conversion to bool, so treat it as an xvalue in arg2. */
5658 arg2
= move (TARGET_EXPR_SLOT (arg1
));
5659 else if (TREE_CODE (arg1
) == EXCESS_PRECISION_EXPR
)
5660 arg2
= arg1
= build1 (EXCESS_PRECISION_EXPR
, TREE_TYPE (arg1
),
5661 cp_save_expr (TREE_OPERAND (arg1
, 0)));
5663 arg2
= arg1
= cp_save_expr (arg1
);
5666 /* If something has already gone wrong, just pass that fact up the
5668 if (error_operand_p (arg1
)
5669 || error_operand_p (arg2
)
5670 || error_operand_p (arg3
))
5671 return error_mark_node
;
5673 conversion_obstack_sentinel cos
;
5678 if (gnu_vector_type_p (TREE_TYPE (arg1
))
5679 && VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
5681 tree arg1_type
= TREE_TYPE (arg1
);
5683 /* If arg1 is another cond_expr choosing between -1 and 0,
5684 then we can use its comparison. It may help to avoid
5685 additional comparison, produce more accurate diagnostics
5686 and enables folding. */
5687 if (TREE_CODE (arg1
) == VEC_COND_EXPR
5688 && integer_minus_onep (TREE_OPERAND (arg1
, 1))
5689 && integer_zerop (TREE_OPERAND (arg1
, 2)))
5690 arg1
= TREE_OPERAND (arg1
, 0);
5692 arg1
= force_rvalue (arg1
, complain
);
5693 arg2
= force_rvalue (arg2
, complain
);
5694 arg3
= force_rvalue (arg3
, complain
);
5696 /* force_rvalue can return error_mark on valid arguments. */
5697 if (error_operand_p (arg1
)
5698 || error_operand_p (arg2
)
5699 || error_operand_p (arg3
))
5700 return error_mark_node
;
5702 arg2_type
= TREE_TYPE (arg2
);
5703 arg3_type
= TREE_TYPE (arg3
);
5705 if (!VECTOR_TYPE_P (arg2_type
)
5706 && !VECTOR_TYPE_P (arg3_type
))
5708 /* Rely on the error messages of the scalar version. */
5709 tree scal
= build_conditional_expr (loc
, integer_one_node
,
5710 orig_arg2
, orig_arg3
, complain
);
5711 if (scal
== error_mark_node
)
5712 return error_mark_node
;
5713 tree stype
= TREE_TYPE (scal
);
5714 tree ctype
= TREE_TYPE (arg1_type
);
5715 if (TYPE_SIZE (stype
) != TYPE_SIZE (ctype
)
5716 || (!INTEGRAL_TYPE_P (stype
) && !SCALAR_FLOAT_TYPE_P (stype
)))
5718 if (complain
& tf_error
)
5719 error_at (loc
, "inferred scalar type %qT is not an integer or "
5720 "floating-point type of the same size as %qT", stype
,
5721 COMPARISON_CLASS_P (arg1
)
5722 ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
5724 return error_mark_node
;
5727 tree vtype
= build_opaque_vector_type (stype
,
5728 TYPE_VECTOR_SUBPARTS (arg1_type
));
5729 /* We could pass complain & tf_warning to unsafe_conversion_p,
5730 but the warnings (like Wsign-conversion) have already been
5731 given by the scalar build_conditional_expr_1. We still check
5732 unsafe_conversion_p to forbid truncating long long -> float. */
5733 if (unsafe_conversion_p (stype
, arg2
, NULL_TREE
, false))
5735 if (complain
& tf_error
)
5736 error_at (loc
, "conversion of scalar %qH to vector %qI "
5737 "involves truncation", arg2_type
, vtype
);
5738 return error_mark_node
;
5740 if (unsafe_conversion_p (stype
, arg3
, NULL_TREE
, false))
5742 if (complain
& tf_error
)
5743 error_at (loc
, "conversion of scalar %qH to vector %qI "
5744 "involves truncation", arg3_type
, vtype
);
5745 return error_mark_node
;
5748 arg2
= cp_convert (stype
, arg2
, complain
);
5749 arg2
= save_expr (arg2
);
5750 arg2
= build_vector_from_val (vtype
, arg2
);
5752 arg3
= cp_convert (stype
, arg3
, complain
);
5753 arg3
= save_expr (arg3
);
5754 arg3
= build_vector_from_val (vtype
, arg3
);
5758 if ((gnu_vector_type_p (arg2_type
) && !VECTOR_TYPE_P (arg3_type
))
5759 || (gnu_vector_type_p (arg3_type
) && !VECTOR_TYPE_P (arg2_type
)))
5761 enum stv_conv convert_flag
=
5762 scalar_to_vector (loc
, VEC_COND_EXPR
, arg2
, arg3
,
5763 complain
& tf_error
);
5765 switch (convert_flag
)
5768 return error_mark_node
;
5771 arg2
= save_expr (arg2
);
5772 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
5773 arg2
= build_vector_from_val (arg3_type
, arg2
);
5774 arg2_type
= TREE_TYPE (arg2
);
5779 arg3
= save_expr (arg3
);
5780 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
5781 arg3
= build_vector_from_val (arg2_type
, arg3
);
5782 arg3_type
= TREE_TYPE (arg3
);
5790 if (!gnu_vector_type_p (arg2_type
)
5791 || !gnu_vector_type_p (arg3_type
)
5792 || !same_type_p (arg2_type
, arg3_type
)
5793 || maybe_ne (TYPE_VECTOR_SUBPARTS (arg1_type
),
5794 TYPE_VECTOR_SUBPARTS (arg2_type
))
5795 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
5797 if (complain
& tf_error
)
5799 "incompatible vector types in conditional expression: "
5800 "%qT, %qT and %qT", TREE_TYPE (arg1
),
5801 TREE_TYPE (orig_arg2
), TREE_TYPE (orig_arg3
));
5802 return error_mark_node
;
5805 if (!COMPARISON_CLASS_P (arg1
))
5807 tree cmp_type
= truth_type_for (arg1_type
);
5808 arg1
= build2 (NE_EXPR
, cmp_type
, arg1
, build_zero_cst (arg1_type
));
5810 return build3_loc (loc
, VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
5815 The first expression is implicitly converted to bool (clause
5817 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
5819 if (error_operand_p (arg1
))
5820 return error_mark_node
;
5822 arg2_type
= unlowered_expr_type (arg2
);
5823 arg3_type
= unlowered_expr_type (arg3
);
5825 if ((TREE_CODE (arg2
) == EXCESS_PRECISION_EXPR
5826 || TREE_CODE (arg3
) == EXCESS_PRECISION_EXPR
)
5827 && (TREE_CODE (arg2_type
) == INTEGER_TYPE
5828 || SCALAR_FLOAT_TYPE_P (arg2_type
)
5829 || TREE_CODE (arg2_type
) == COMPLEX_TYPE
)
5830 && (TREE_CODE (arg3_type
) == INTEGER_TYPE
5831 || SCALAR_FLOAT_TYPE_P (arg3_type
)
5832 || TREE_CODE (arg3_type
) == COMPLEX_TYPE
))
5834 semantic_result_type
5835 = type_after_usual_arithmetic_conversions (arg2_type
, arg3_type
);
5836 if (semantic_result_type
== error_mark_node
)
5838 tree t1
= arg2_type
;
5839 tree t2
= arg3_type
;
5840 if (TREE_CODE (t1
) == COMPLEX_TYPE
)
5841 t1
= TREE_TYPE (t1
);
5842 if (TREE_CODE (t2
) == COMPLEX_TYPE
)
5843 t2
= TREE_TYPE (t2
);
5844 gcc_checking_assert (SCALAR_FLOAT_TYPE_P (t1
)
5845 && SCALAR_FLOAT_TYPE_P (t2
)
5846 && (extended_float_type_p (t1
)
5847 || extended_float_type_p (t2
))
5848 && cp_compare_floating_point_conversion_ranks
5850 if (complain
& tf_error
)
5851 error_at (loc
, "operands to %<?:%> of types %qT and %qT "
5852 "have unordered conversion rank",
5853 arg2_type
, arg3_type
);
5854 return error_mark_node
;
5856 if (TREE_CODE (arg2
) == EXCESS_PRECISION_EXPR
)
5858 arg2
= TREE_OPERAND (arg2
, 0);
5859 arg2_type
= TREE_TYPE (arg2
);
5861 if (TREE_CODE (arg3
) == EXCESS_PRECISION_EXPR
)
5863 arg3
= TREE_OPERAND (arg3
, 0);
5864 arg3_type
= TREE_TYPE (arg3
);
5870 If either the second or the third operand has type (possibly
5871 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
5872 array-to-pointer (_conv.array_), and function-to-pointer
5873 (_conv.func_) standard conversions are performed on the second
5874 and third operands. */
5875 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
5877 /* 'void' won't help in resolving an overloaded expression on the
5878 other side, so require it to resolve by itself. */
5879 if (arg2_type
== unknown_type_node
)
5881 arg2
= resolve_nondeduced_context_or_error (arg2
, complain
);
5882 arg2_type
= TREE_TYPE (arg2
);
5884 if (arg3_type
== unknown_type_node
)
5886 arg3
= resolve_nondeduced_context_or_error (arg3
, complain
);
5887 arg3_type
= TREE_TYPE (arg3
);
5892 One of the following shall hold:
5894 --The second or the third operand (but not both) is a
5895 throw-expression (_except.throw_); the result is of the type
5896 and value category of the other.
5898 --Both the second and the third operands have type void; the
5899 result is of type void and is a prvalue. */
5900 if (TREE_CODE (arg2
) == THROW_EXPR
5901 && TREE_CODE (arg3
) != THROW_EXPR
)
5903 result_type
= arg3_type
;
5904 is_glvalue
= glvalue_p (arg3
);
5906 else if (TREE_CODE (arg2
) != THROW_EXPR
5907 && TREE_CODE (arg3
) == THROW_EXPR
)
5909 result_type
= arg2_type
;
5910 is_glvalue
= glvalue_p (arg2
);
5912 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
5914 result_type
= void_type_node
;
5919 if (complain
& tf_error
)
5921 if (VOID_TYPE_P (arg2_type
))
5922 error_at (cp_expr_loc_or_loc (arg3
, loc
),
5923 "second operand to the conditional operator "
5924 "is of type %<void%>, but the third operand is "
5925 "neither a throw-expression nor of type %<void%>");
5927 error_at (cp_expr_loc_or_loc (arg2
, loc
),
5928 "third operand to the conditional operator "
5929 "is of type %<void%>, but the second operand is "
5930 "neither a throw-expression nor of type %<void%>");
5932 return error_mark_node
;
5935 goto valid_operands
;
5939 Otherwise, if the second and third operand have different types,
5940 and either has (possibly cv-qualified) class type, or if both are
5941 glvalues of the same value category and the same type except for
5942 cv-qualification, an attempt is made to convert each of those operands
5943 to the type of the other. */
5944 else if (!same_type_p (arg2_type
, arg3_type
)
5945 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)
5946 || (same_type_ignoring_top_level_qualifiers_p (arg2_type
,
5948 && glvalue_p (arg2
) && glvalue_p (arg3
)
5949 && lvalue_p (arg2
) == lvalue_p (arg3
))))
5953 bool converted
= false;
5955 conv2
= conditional_conversion (arg2
, arg3
, complain
);
5956 conv3
= conditional_conversion (arg3
, arg2
, complain
);
5960 If both can be converted, or one can be converted but the
5961 conversion is ambiguous, the program is ill-formed. If
5962 neither can be converted, the operands are left unchanged and
5963 further checking is performed as described below. If exactly
5964 one conversion is possible, that conversion is applied to the
5965 chosen operand and the converted operand is used in place of
5966 the original operand for the remainder of this section. */
5967 if ((conv2
&& !conv2
->bad_p
5968 && conv3
&& !conv3
->bad_p
)
5969 || (conv2
&& conv2
->kind
== ck_ambig
)
5970 || (conv3
&& conv3
->kind
== ck_ambig
))
5972 if (complain
& tf_error
)
5974 error_at (loc
, "operands to %<?:%> have different types "
5976 arg2_type
, arg3_type
);
5977 if (conv2
&& !conv2
->bad_p
&& conv3
&& !conv3
->bad_p
)
5978 inform (loc
, " and each type can be converted to the other");
5979 else if (conv2
&& conv2
->kind
== ck_ambig
)
5980 convert_like (conv2
, arg2
, complain
);
5982 convert_like (conv3
, arg3
, complain
);
5984 result
= error_mark_node
;
5986 else if (conv2
&& !conv2
->bad_p
)
5988 arg2
= convert_like (conv2
, arg2
, complain
);
5989 arg2
= convert_from_reference (arg2
);
5990 arg2_type
= TREE_TYPE (arg2
);
5991 /* Even if CONV2 is a valid conversion, the result of the
5992 conversion may be invalid. For example, if ARG3 has type
5993 "volatile X", and X does not have a copy constructor
5994 accepting a "volatile X&", then even if ARG2 can be
5995 converted to X, the conversion will fail. */
5996 if (error_operand_p (arg2
))
5997 result
= error_mark_node
;
6000 else if (conv3
&& !conv3
->bad_p
)
6002 arg3
= convert_like (conv3
, arg3
, complain
);
6003 arg3
= convert_from_reference (arg3
);
6004 arg3_type
= TREE_TYPE (arg3
);
6005 if (error_operand_p (arg3
))
6006 result
= error_mark_node
;
6013 /* If, after the conversion, both operands have class type,
6014 treat the cv-qualification of both operands as if it were the
6015 union of the cv-qualification of the operands.
6017 The standard is not clear about what to do in this
6018 circumstance. For example, if the first operand has type
6019 "const X" and the second operand has a user-defined
6020 conversion to "volatile X", what is the type of the second
6021 operand after this step? Making it be "const X" (matching
6022 the first operand) seems wrong, as that discards the
6023 qualification without actually performing a copy. Leaving it
6024 as "volatile X" seems wrong as that will result in the
6025 conditional expression failing altogether, even though,
6026 according to this step, the one operand could be converted to
6027 the type of the other. */
6029 && CLASS_TYPE_P (arg2_type
)
6030 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
6031 arg2_type
= arg3_type
=
6032 cp_build_qualified_type (arg2_type
,
6033 cp_type_quals (arg2_type
)
6034 | cp_type_quals (arg3_type
));
6039 If the second and third operands are glvalues of the same value
6040 category and have the same type, the result is of that type and
6042 if (((lvalue_p (arg2
) && lvalue_p (arg3
))
6043 || (xvalue_p (arg2
) && xvalue_p (arg3
)))
6044 && same_type_p (arg2_type
, arg3_type
))
6046 result_type
= arg2_type
;
6047 goto valid_operands
;
6052 Otherwise, the result is an rvalue. If the second and third
6053 operand do not have the same type, and either has (possibly
6054 cv-qualified) class type, overload resolution is used to
6055 determine the conversions (if any) to be applied to the operands
6056 (_over.match.oper_, _over.built_). */
6058 if (!same_type_p (arg2_type
, arg3_type
)
6059 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
6065 /* Rearrange the arguments so that add_builtin_candidate only has
6066 to know about two args. In build_builtin_candidate, the
6067 arguments are unscrambled. */
6068 args
->quick_push (arg2
);
6069 args
->quick_push (arg3
);
6070 args
->quick_push (arg1
);
6071 add_builtin_candidates (&candidates
,
6074 ovl_op_identifier (false, COND_EXPR
),
6076 LOOKUP_NORMAL
, complain
);
6080 If the overload resolution fails, the program is
6082 candidates
= splice_viable (candidates
, false, &any_viable_p
);
6085 if (complain
& tf_error
)
6086 error_at (loc
, "operands to %<?:%> have different types %qT and %qT",
6087 arg2_type
, arg3_type
);
6088 return error_mark_node
;
6090 cand
= tourney (candidates
, complain
);
6093 if (complain
& tf_error
)
6095 auto_diagnostic_group d
;
6096 op_error (loc
, COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, false);
6097 print_z_candidates (loc
, candidates
);
6099 return error_mark_node
;
6104 Otherwise, the conversions thus determined are applied, and
6105 the converted operands are used in place of the original
6106 operands for the remainder of this section. */
6107 conv
= cand
->convs
[0];
6108 arg1
= convert_like (conv
, arg1
, complain
);
6109 conv
= cand
->convs
[1];
6110 arg2
= convert_like (conv
, arg2
, complain
);
6111 arg2_type
= TREE_TYPE (arg2
);
6112 conv
= cand
->convs
[2];
6113 arg3
= convert_like (conv
, arg3
, complain
);
6114 arg3_type
= TREE_TYPE (arg3
);
6119 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
6120 and function-to-pointer (_conv.func_) standard conversions are
6121 performed on the second and third operands.
6123 We need to force the lvalue-to-rvalue conversion here for class types,
6124 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
6125 that isn't wrapped with a TARGET_EXPR plays havoc with exception
6128 arg2
= force_rvalue (arg2
, complain
);
6129 if (!CLASS_TYPE_P (arg2_type
))
6130 arg2_type
= TREE_TYPE (arg2
);
6132 arg3
= force_rvalue (arg3
, complain
);
6133 if (!CLASS_TYPE_P (arg3_type
))
6134 arg3_type
= TREE_TYPE (arg3
);
6136 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
6137 return error_mark_node
;
6141 After those conversions, one of the following shall hold:
6143 --The second and third operands have the same type; the result is of
6145 if (same_type_p (arg2_type
, arg3_type
))
6146 result_type
= arg2_type
;
6149 --The second and third operands have arithmetic or enumeration
6150 type; the usual arithmetic conversions are performed to bring
6151 them to a common type, and the result is of that type. */
6152 else if ((ARITHMETIC_TYPE_P (arg2_type
)
6153 || UNSCOPED_ENUM_P (arg2_type
))
6154 && (ARITHMETIC_TYPE_P (arg3_type
)
6155 || UNSCOPED_ENUM_P (arg3_type
)))
6157 /* A conditional expression between a floating-point
6158 type and an integer type should convert the integer type to
6159 the evaluation format of the floating-point type, with
6160 possible excess precision. */
6161 tree eptype2
= arg2_type
;
6162 tree eptype3
= arg3_type
;
6164 if (ANY_INTEGRAL_TYPE_P (arg2_type
)
6165 && (eptype
= excess_precision_type (arg3_type
)) != NULL_TREE
)
6168 if (!semantic_result_type
)
6169 semantic_result_type
6170 = type_after_usual_arithmetic_conversions (arg2_type
, arg3_type
);
6172 else if (ANY_INTEGRAL_TYPE_P (arg3_type
)
6173 && (eptype
= excess_precision_type (arg2_type
)) != NULL_TREE
)
6176 if (!semantic_result_type
)
6177 semantic_result_type
6178 = type_after_usual_arithmetic_conversions (arg2_type
, arg3_type
);
6180 result_type
= type_after_usual_arithmetic_conversions (eptype2
,
6182 if (result_type
== error_mark_node
)
6186 if (TREE_CODE (t1
) == COMPLEX_TYPE
)
6187 t1
= TREE_TYPE (t1
);
6188 if (TREE_CODE (t2
) == COMPLEX_TYPE
)
6189 t2
= TREE_TYPE (t2
);
6190 gcc_checking_assert (SCALAR_FLOAT_TYPE_P (t1
)
6191 && SCALAR_FLOAT_TYPE_P (t2
)
6192 && (extended_float_type_p (t1
)
6193 || extended_float_type_p (t2
))
6194 && cp_compare_floating_point_conversion_ranks
6196 if (complain
& tf_error
)
6197 error_at (loc
, "operands to %<?:%> of types %qT and %qT "
6198 "have unordered conversion rank",
6200 return error_mark_node
;
6202 if (semantic_result_type
== error_mark_node
)
6204 tree t1
= arg2_type
;
6205 tree t2
= arg3_type
;
6206 if (TREE_CODE (t1
) == COMPLEX_TYPE
)
6207 t1
= TREE_TYPE (t1
);
6208 if (TREE_CODE (t2
) == COMPLEX_TYPE
)
6209 t2
= TREE_TYPE (t2
);
6210 gcc_checking_assert (SCALAR_FLOAT_TYPE_P (t1
)
6211 && SCALAR_FLOAT_TYPE_P (t2
)
6212 && (extended_float_type_p (t1
)
6213 || extended_float_type_p (t2
))
6214 && cp_compare_floating_point_conversion_ranks
6216 if (complain
& tf_error
)
6217 error_at (loc
, "operands to %<?:%> of types %qT and %qT "
6218 "have unordered conversion rank",
6219 arg2_type
, arg3_type
);
6220 return error_mark_node
;
6223 if (complain
& tf_warning
)
6224 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
6225 "implicit conversion from %qH to %qI to "
6226 "match other result of conditional",
6229 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
6230 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
6232 tree stripped_orig_arg2
= tree_strip_any_location_wrapper (orig_arg2
);
6233 tree stripped_orig_arg3
= tree_strip_any_location_wrapper (orig_arg3
);
6234 if (TREE_CODE (stripped_orig_arg2
) == CONST_DECL
6235 && TREE_CODE (stripped_orig_arg3
) == CONST_DECL
6236 && (DECL_CONTEXT (stripped_orig_arg2
)
6237 == DECL_CONTEXT (stripped_orig_arg3
)))
6238 /* Two enumerators from the same enumeration can have different
6239 types when the enumeration is still being defined. */;
6240 else if (complain
& (cxx_dialect
>= cxx26
6241 ? tf_warning_or_error
: tf_warning
))
6242 emit_diagnostic (cxx_dialect
>= cxx26
? DK_PEDWARN
: DK_WARNING
,
6243 loc
, OPT_Wenum_compare
, "enumerated mismatch "
6244 "in conditional expression: %qT vs %qT",
6245 arg2_type
, arg3_type
);
6246 else if (cxx_dialect
>= cxx26
)
6247 return error_mark_node
;
6249 else if ((((complain
& (cxx_dialect
>= cxx26
6250 ? tf_warning_or_error
: tf_warning
))
6251 && warn_deprecated_enum_float_conv
)
6252 || (cxx_dialect
>= cxx26
6253 && (complain
& tf_warning_or_error
) == 0))
6254 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
6255 && SCALAR_FLOAT_TYPE_P (arg3_type
))
6256 || (SCALAR_FLOAT_TYPE_P (arg2_type
)
6257 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)))
6259 if (cxx_dialect
>= cxx26
&& (complain
& tf_warning_or_error
) == 0)
6260 return error_mark_node
;
6261 if (cxx_dialect
>= cxx26
&& TREE_CODE (arg2_type
) == ENUMERAL_TYPE
)
6262 pedwarn (loc
, OPT_Wdeprecated_enum_float_conversion
,
6263 "conditional expression between enumeration type "
6264 "%qT and floating-point type %qT", arg2_type
, arg3_type
);
6265 else if (cxx_dialect
>= cxx26
)
6266 pedwarn (loc
, OPT_Wdeprecated_enum_float_conversion
,
6267 "conditional expression between floating-point type "
6268 "%qT and enumeration type %qT", arg2_type
, arg3_type
);
6269 else if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
)
6270 warning_at (loc
, OPT_Wdeprecated_enum_float_conversion
,
6271 "conditional expression between enumeration type "
6272 "%qT and floating-point type %qT is deprecated",
6273 arg2_type
, arg3_type
);
6275 warning_at (loc
, OPT_Wdeprecated_enum_float_conversion
,
6276 "conditional expression between floating-point "
6277 "type %qT and enumeration type %qT is deprecated",
6278 arg2_type
, arg3_type
);
6280 else if ((extra_warnings
|| warn_enum_conversion
)
6281 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
6282 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
6283 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
6284 && !same_type_p (arg2_type
,
6285 type_promotes_to (arg3_type
)))))
6287 if (complain
& tf_warning
)
6289 enum opt_code opt
= (warn_enum_conversion
6290 ? OPT_Wenum_conversion
6292 warning_at (loc
, opt
, "enumerated and "
6293 "non-enumerated type in conditional expression");
6297 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
6298 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
6302 --The second and third operands have pointer type, or one has
6303 pointer type and the other is a null pointer constant; pointer
6304 conversions (_conv.ptr_) and qualification conversions
6305 (_conv.qual_) are performed to bring them to their composite
6306 pointer type (_expr.rel_). The result is of the composite
6309 --The second and third operands have pointer to member type, or
6310 one has pointer to member type and the other is a null pointer
6311 constant; pointer to member conversions (_conv.mem_) and
6312 qualification conversions (_conv.qual_) are performed to bring
6313 them to a common type, whose cv-qualification shall match the
6314 cv-qualification of either the second or the third operand.
6315 The result is of the common type. */
6316 else if ((null_ptr_cst_p (arg2
)
6317 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
6318 || (null_ptr_cst_p (arg3
)
6319 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
6320 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
6321 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
6322 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
6324 result_type
= composite_pointer_type (loc
,
6325 arg2_type
, arg3_type
, arg2
,
6326 arg3
, CPO_CONDITIONAL_EXPR
,
6328 if (result_type
== error_mark_node
)
6329 return error_mark_node
;
6330 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
6331 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
6336 if (complain
& tf_error
)
6337 error_at (loc
, "operands to %<?:%> have different types %qT and %qT",
6338 arg2_type
, arg3_type
);
6339 return error_mark_node
;
6342 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
6343 return error_mark_node
;
6346 if (processing_template_decl
&& is_glvalue
)
6348 /* Let lvalue_kind know this was a glvalue. */
6349 tree arg
= (result_type
== arg2_type
? arg2
: arg3
);
6350 result_type
= cp_build_reference_type (result_type
, xvalue_p (arg
));
6353 result
= build3_loc (loc
, COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
6355 /* If the ARG2 and ARG3 are the same and don't have side-effects,
6356 warn here, because the COND_EXPR will be turned into ARG2. */
6357 if (warn_duplicated_branches
6358 && (complain
& tf_warning
)
6359 && (arg2
== arg3
|| operand_equal_p (arg2
, arg3
,
6360 OEP_ADDRESS_OF_SAME_FIELD
)))
6361 warning_at (EXPR_LOCATION (result
), OPT_Wduplicated_branches
,
6362 "this condition has identical branches");
6364 /* We can't use result_type below, as fold might have returned a
6369 /* Expand both sides into the same slot, hopefully the target of
6370 the ?: expression. We used to check for TARGET_EXPRs here,
6371 but now we sometimes wrap them in NOP_EXPRs so the test would
6373 if (CLASS_TYPE_P (TREE_TYPE (result
)))
6375 result
= get_target_expr (result
, complain
);
6376 /* Tell gimplify_modify_expr_rhs not to strip this in
6377 assignment context: we want both arms to initialize
6378 the same temporary. */
6379 TARGET_EXPR_NO_ELIDE (result
) = true;
6381 /* If this expression is an rvalue, but might be mistaken for an
6382 lvalue, we must add a NON_LVALUE_EXPR. */
6383 result
= rvalue (result
);
6384 if (semantic_result_type
)
6385 result
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
,
6390 result
= force_paren_expr (result
);
6391 gcc_assert (semantic_result_type
== NULL_TREE
);
6397 /* OPERAND is an operand to an expression. Perform necessary steps
6398 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
6402 prep_operand (tree operand
)
6406 if (CLASS_TYPE_P (TREE_TYPE (operand
))
6407 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
6408 /* Make sure the template type is instantiated now. */
6409 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
6415 /* True iff CONV represents a conversion sequence which no other can be better
6416 than under [over.ics.rank]: in other words, a "conversion" to the exact same
6417 type (including binding to a reference to the same type). This is stronger
6418 than the standard's "identity" category, which also includes reference
6419 bindings that add cv-qualifiers or change rvalueness. */
6422 perfect_conversion_p (conversion
*conv
)
6424 if (CONVERSION_RANK (conv
) != cr_identity
)
6426 if (conv
->kind
== ck_ref_bind
)
6428 if (!conv
->rvaluedness_matches_p
)
6430 if (!same_type_p (TREE_TYPE (conv
->type
),
6431 next_conversion (conv
)->type
))
6434 if (conv
->check_narrowing
)
6435 /* Brace elision is imperfect. */
6440 /* True if CAND represents a perfect match, i.e. all perfect conversions, so no
6441 other candidate can be a better match. Since the template/non-template
6442 tiebreaker comes immediately after the conversion comparison in
6443 [over.match.best], a perfect non-template candidate is better than all
6447 perfect_candidate_p (z_candidate
*cand
)
6449 if (cand
->viable
< 1)
6451 /* CWG1402 makes an implicitly deleted move op worse than other
6453 if (DECL_DELETED_FN (cand
->fn
) && DECL_DEFAULTED_FN (cand
->fn
)
6454 && move_fn_p (cand
->fn
))
6456 int len
= cand
->num_convs
;
6457 for (int i
= 0; i
< len
; ++i
)
6458 if (!perfect_conversion_p (cand
->convs
[i
]))
6460 if (conversion
*conv
= cand
->second_conv
)
6461 if (!perfect_conversion_p (conv
))
6466 /* True iff one of CAND's argument conversions is missing. */
6469 missing_conversion_p (const z_candidate
*cand
)
6471 for (unsigned i
= 0; i
< cand
->num_convs
; ++i
)
6473 conversion
*conv
= cand
->convs
[i
];
6476 if (conv
->kind
== ck_deferred_bad
)
6478 /* We don't know whether this conversion is outright invalid or
6479 just bad, so conservatively assume it's missing. */
6480 gcc_checking_assert (conv
->bad_p
);
6487 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
6488 OVERLOAD) to the CANDIDATES, returning an updated list of
6489 CANDIDATES. The ARGS are the arguments provided to the call;
6490 if FIRST_ARG is non-null it is the implicit object argument,
6491 otherwise the first element of ARGS is used if needed. The
6492 EXPLICIT_TARGS are explicit template arguments provided.
6493 TEMPLATE_ONLY is true if only template functions should be
6494 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
6495 add_function_candidate. */
6498 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
6500 tree explicit_targs
, bool template_only
,
6501 tree conversion_path
, tree access_path
,
6503 struct z_candidate
**candidates
,
6504 tsubst_flags_t complain
)
6507 const vec
<tree
, va_gc
> *non_static_args
;
6508 bool check_list_ctor
= false;
6509 bool check_converting
= false;
6510 unification_kind_t strict
;
6511 tree ne_fns
= NULL_TREE
;
6516 /* Precalculate special handling of constructors and conversion ops. */
6517 tree fn
= OVL_FIRST (fns
);
6518 if (DECL_CONV_FN_P (fn
))
6520 check_list_ctor
= false;
6521 check_converting
= (flags
& LOOKUP_ONLYCONVERTING
) != 0;
6522 if (flags
& LOOKUP_NO_CONVERSION
)
6523 /* We're doing return_type(x). */
6524 strict
= DEDUCE_CONV
;
6526 /* We're doing x.operator return_type(). */
6527 strict
= DEDUCE_EXACT
;
6528 /* [over.match.funcs] For conversion functions, the function
6529 is considered to be a member of the class of the implicit
6530 object argument for the purpose of defining the type of
6531 the implicit object parameter. */
6532 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
6536 if (DECL_CONSTRUCTOR_P (fn
))
6538 check_list_ctor
= (flags
& LOOKUP_LIST_ONLY
) != 0;
6539 /* For list-initialization we consider explicit constructors
6540 and complain if one is chosen. */
6542 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
6543 == LOOKUP_ONLYCONVERTING
);
6545 strict
= DEDUCE_CALL
;
6546 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
6549 /* P2468: Check if operator== is a rewrite target with first operand
6550 (*args)[0]; for now just do the lookups. */
6551 if ((flags
& (LOOKUP_REWRITTEN
| LOOKUP_REVERSED
))
6552 && DECL_OVERLOADED_OPERATOR_IS (fn
, EQ_EXPR
))
6554 tree ne_name
= ovl_op_identifier (false, NE_EXPR
);
6555 if (DECL_CLASS_SCOPE_P (fn
))
6557 ne_fns
= lookup_fnfields (TREE_TYPE ((*args
)[0]), ne_name
,
6559 if (ne_fns
== error_mark_node
|| ne_fns
== NULL_TREE
)
6562 ne_fns
= BASELINK_FUNCTIONS (ne_fns
);
6566 tree context
= decl_namespace_context (fn
);
6567 ne_fns
= lookup_qualified_name (context
, ne_name
, LOOK_want::NORMAL
,
6569 if (ne_fns
== error_mark_node
6570 || !is_overloaded_fn (ne_fns
))
6576 non_static_args
= args
;
6578 /* Delay creating the implicit this parameter until it is needed. */
6579 non_static_args
= NULL
;
6581 bool seen_strictly_viable
= any_strictly_viable (*candidates
);
6582 /* If there's a non-template perfect match, we don't need to consider
6583 templates. So check non-templates first. This optimization is only
6584 really needed for the defaulted copy constructor of tuple and the like
6585 (96926), but it seems like we might as well enable it more generally. */
6586 bool seen_perfect
= false;
6587 enum { templates
, non_templates
, either
} which
= either
;
6590 else /*if (flags & LOOKUP_DEFAULTED)*/
6591 which
= non_templates
;
6593 /* Template candidates that we'll potentially ignore if the
6594 perfect candidate optimization succeeds. */
6595 z_candidate
*ignored_template_cands
= nullptr;
6597 /* During overload resolution, we first consider each function under the
6598 assumption that we'll eventually find a strictly viable candidate.
6599 This allows us to circumvent our defacto behavior when checking
6600 argument conversions and shortcut consideration of the candidate
6601 upon encountering the first bad conversion. If this assumption
6602 turns out to be false, and all candidates end up being non-strictly
6603 viable, then we reconsider such candidates under the defacto behavior.
6604 This trick is important for pruning member function overloads according
6605 to their const/ref-qualifiers (since all 'this' conversions are at
6606 worst bad) without breaking -fpermissive. */
6607 z_candidate
*bad_cands
= nullptr;
6608 bool shortcut_bad_convs
= true;
6611 for (tree fn
: lkp_range (fns
))
6613 if (which
== templates
&& TREE_CODE (fn
) != TEMPLATE_DECL
)
6616 add_ignored_candidate (candidates
, fn
);
6619 if (which
== non_templates
&& TREE_CODE (fn
) == TEMPLATE_DECL
)
6621 add_ignored_candidate (&ignored_template_cands
, fn
);
6624 if ((check_converting
&& DECL_NONCONVERTING_P (fn
))
6625 || (check_list_ctor
&& !is_list_ctor (fn
)))
6627 add_ignored_candidate (candidates
, fn
);
6631 tree fn_first_arg
= NULL_TREE
;
6632 const vec
<tree
, va_gc
> *fn_args
= args
;
6634 if (DECL_OBJECT_MEMBER_FUNCTION_P (fn
))
6636 /* Figure out where the object arg comes from. If this
6637 function is a non-static member and we didn't get an
6638 implicit object argument, move it out of args. */
6639 if (first_arg
== NULL_TREE
)
6643 vec
<tree
, va_gc
> *tempvec
;
6644 vec_alloc (tempvec
, args
->length () - 1);
6645 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
6646 tempvec
->quick_push (arg
);
6647 non_static_args
= tempvec
;
6648 first_arg
= (*args
)[0];
6651 fn_first_arg
= first_arg
;
6652 fn_args
= non_static_args
;
6655 /* Don't bother reversing an operator with two identical parameters. */
6656 else if (vec_safe_length (args
) == 2 && (flags
& LOOKUP_REVERSED
))
6658 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6659 if (same_type_p (TREE_VALUE (parmlist
),
6660 TREE_VALUE (TREE_CHAIN (parmlist
))))
6664 /* When considering reversed operator==, if there's a corresponding
6665 operator!= in the same scope, it's not a rewrite target. */
6669 for (lkp_iterator
ne (ne_fns
); !found
&& ne
; ++ne
)
6670 if (0 && !ne
.using_p ()
6671 && DECL_NAMESPACE_SCOPE_P (fn
)
6672 && DECL_CONTEXT (*ne
) != DECL_CONTEXT (fn
))
6673 /* ??? This kludge excludes inline namespace members for the H
6674 test in spaceship-eq15.C, but I don't see why we would want
6675 that behavior. Asked Core 2022-11-04. Disabling for now. */;
6676 else if (fns_correspond (fn
, *ne
))
6685 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
6686 add_template_candidate (candidates
,
6701 add_function_candidate (candidates
,
6712 if (perfect_candidate_p (*candidates
))
6713 seen_perfect
= true;
6716 z_candidate
*cand
= *candidates
;
6717 if (cand
->viable
== 1)
6718 seen_strictly_viable
= true;
6720 if (cand
->viable
== -1
6721 && shortcut_bad_convs
6722 && missing_conversion_p (cand
))
6724 /* This candidate has been tentatively marked non-strictly viable,
6725 and we didn't compute all argument conversions for it (having
6726 stopped at the first bad conversion). Move it to BAD_CANDS to
6727 to fully reconsider later if we don't find any strictly viable
6729 if (complain
& (tf_error
| tf_conv
))
6731 *candidates
= cand
->next
;
6732 cand
->next
= bad_cands
;
6736 /* But if we're in a SFINAE context, just mark this candidate as
6737 unviable outright and avoid potentially reconsidering it.
6738 This is safe to do because in a SFINAE context, performing a bad
6739 conversion is always an error (even with -fpermissive), so a
6740 non-strictly viable candidate is effectively unviable anyway. */
6744 if (which
== non_templates
&& !seen_perfect
)
6747 ignored_template_cands
= nullptr;
6750 else if (which
== templates
6751 && !seen_strictly_viable
6752 && shortcut_bad_convs
6755 /* None of the candidates are strictly viable, so consider again those
6756 functions in BAD_CANDS, this time without shortcutting bad conversions
6757 so that all their argument conversions are computed. */
6760 for (z_candidate
*cand
= bad_cands
; cand
; cand
= cand
->next
)
6763 if (tree ti
= cand
->template_decl
)
6764 fn
= TI_TEMPLATE (ti
);
6765 fns
= ovl_make (fn
, fns
);
6767 shortcut_bad_convs
= false;
6768 bad_cands
= nullptr;
6772 if (complain
& tf_error
)
6774 /* Remember any omitted candidates; we may want to print all candidates
6775 as part of overload resolution failure diagnostics. */
6776 for (z_candidate
*omitted_cands
: { ignored_template_cands
, bad_cands
})
6778 z_candidate
**omitted_cands_tail
= &omitted_cands
;
6779 while (*omitted_cands_tail
)
6780 omitted_cands_tail
= &(*omitted_cands_tail
)->next
;
6781 *omitted_cands_tail
= *candidates
;
6782 *candidates
= omitted_cands
;
6787 /* Returns 1 if P0145R2 says that the LHS of operator CODE is evaluated first,
6788 -1 if the RHS is evaluated first, or 0 if the order is unspecified. */
6791 op_is_ordered (tree_code code
)
6797 return (flag_strong_eval_order
> 1 ? -1 : 0);
6801 return (flag_strong_eval_order
> 1 ? 1 : 0);
6804 // Not overloadable (yet).
6806 // Only one argument.
6814 // Predates P0145R3.
6815 case TRUTH_ANDIF_EXPR
:
6817 // Predates P0145R3.
6818 case TRUTH_ORIF_EXPR
:
6820 // Predates P0145R3.
6822 return (flag_strong_eval_order
? 1 : 0);
6829 /* Subroutine of build_new_op: Add to CANDIDATES all candidates for the
6830 operator indicated by CODE/CODE2. This function calls itself recursively to
6831 handle C++20 rewritten comparison operator candidates. Returns NULL_TREE
6832 upon success, and error_mark_node if something went wrong that prevented
6833 us from performing overload resolution (e.g. ambiguous member name lookup).
6835 LOOKUPS, if non-NULL, is the set of pertinent namespace-scope operator
6836 overloads to consider. This parameter is used when instantiating a
6837 dependent operator expression and has the same structure as
6838 DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS. */
6841 add_operator_candidates (z_candidate
**candidates
,
6842 tree_code code
, tree_code code2
,
6843 vec
<tree
, va_gc
> *arglist
, tree lookups
,
6844 int flags
, tsubst_flags_t complain
)
6846 z_candidate
*start_candidates
= *candidates
;
6847 bool ismodop
= code2
!= ERROR_MARK
;
6848 tree fnname
= ovl_op_identifier (ismodop
, ismodop
? code2
: code
);
6850 /* LOOKUP_REWRITTEN is set when we're looking for the == or <=> operator to
6851 rewrite from, and also when we're looking for the e.g. < operator to use
6852 on the result of <=>. In the latter case, we don't want the flag set in
6853 the candidate, we just want to suppress looking for rewrites. */
6854 bool rewritten
= (flags
& LOOKUP_REWRITTEN
);
6855 if (rewritten
&& code
!= EQ_EXPR
&& code
!= SPACESHIP_EXPR
)
6856 flags
&= ~LOOKUP_REWRITTEN
;
6858 bool memonly
= false;
6861 /* =, ->, [], () must be non-static member functions. */
6863 if (code2
!= NOP_EXPR
)
6875 /* Add namespace-scope operators to the list of functions to
6881 fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
);
6882 /* If LOOKUPS is non-NULL, then we're instantiating a dependent operator
6883 expression, and LOOKUPS is the result of stage 1 name lookup. */
6884 else if (tree found
= purpose_member (fnname
, lookups
))
6885 fns
= TREE_VALUE (found
);
6888 fns
= lookup_arg_dependent (fnname
, fns
, arglist
);
6889 add_candidates (fns
, NULL_TREE
, arglist
, NULL_TREE
,
6890 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
6891 flags
, candidates
, complain
);
6894 /* Add class-member operators to the candidate set. */
6895 tree arg1_type
= TREE_TYPE ((*arglist
)[0]);
6896 unsigned nargs
= arglist
->length () > 1 ? 2 : 1;
6897 tree arg2_type
= nargs
> 1 ? TREE_TYPE ((*arglist
)[1]) : NULL_TREE
;
6898 if (CLASS_TYPE_P (arg1_type
))
6900 tree fns
= lookup_fnfields (arg1_type
, fnname
, 1, complain
);
6901 if (fns
== error_mark_node
)
6902 return error_mark_node
;
6905 if (code
== ARRAY_REF
)
6907 vec
<tree
,va_gc
> *restlist
= make_tree_vector ();
6908 for (unsigned i
= 1; i
< nargs
; ++i
)
6909 vec_safe_push (restlist
, (*arglist
)[i
]);
6910 z_candidate
*save_cand
= *candidates
;
6911 add_candidates (BASELINK_FUNCTIONS (fns
),
6912 (*arglist
)[0], restlist
, NULL_TREE
,
6914 BASELINK_BINFO (fns
),
6915 BASELINK_ACCESS_BINFO (fns
),
6916 flags
, candidates
, complain
);
6917 /* Release the vec if we didn't add a candidate that uses it. */
6918 for (z_candidate
*c
= *candidates
; c
!= save_cand
; c
= c
->next
)
6919 if (c
->args
== restlist
)
6924 release_tree_vector (restlist
);
6927 add_candidates (BASELINK_FUNCTIONS (fns
),
6928 NULL_TREE
, arglist
, NULL_TREE
,
6930 BASELINK_BINFO (fns
),
6931 BASELINK_ACCESS_BINFO (fns
),
6932 flags
, candidates
, complain
);
6935 /* Per [over.match.oper]3.2, if no operand has a class type, then
6936 only non-member functions that have type T1 or reference to
6937 cv-qualified-opt T1 for the first argument, if the first argument
6938 has an enumeration type, or T2 or reference to cv-qualified-opt
6939 T2 for the second argument, if the second argument has an
6940 enumeration type. Filter out those that don't match. */
6941 else if (! arg2_type
|| ! CLASS_TYPE_P (arg2_type
))
6943 struct z_candidate
**candp
, **next
;
6945 for (candp
= candidates
; *candp
!= start_candidates
; candp
= next
)
6948 z_candidate
*cand
= *candp
;
6951 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
6953 for (i
= 0; i
< nargs
; ++i
)
6955 tree parmtype
= TREE_VALUE (parmlist
);
6956 tree argtype
= unlowered_expr_type ((*arglist
)[i
]);
6958 if (TYPE_REF_P (parmtype
))
6959 parmtype
= TREE_TYPE (parmtype
);
6960 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
6961 && (same_type_ignoring_top_level_qualifiers_p
6962 (argtype
, parmtype
)))
6965 parmlist
= TREE_CHAIN (parmlist
);
6968 /* No argument has an appropriate type, so remove this
6969 candidate function from the list. */
6972 *candp
= cand
->next
;
6980 /* The standard says to rewrite built-in candidates, too,
6981 but there's no point. */
6982 add_builtin_candidates (candidates
, code
, code2
, fnname
, arglist
,
6985 /* Maybe add C++20 rewritten comparison candidates. */
6986 tree_code rewrite_code
= ERROR_MARK
;
6987 if (cxx_dialect
>= cxx20
6989 && (OVERLOAD_TYPE_P (arg1_type
) || OVERLOAD_TYPE_P (arg2_type
)))
6996 case SPACESHIP_EXPR
:
6997 rewrite_code
= SPACESHIP_EXPR
;
7002 rewrite_code
= EQ_EXPR
;
7011 flags
|= LOOKUP_REWRITTEN
;
7012 if (rewrite_code
!= code
)
7014 /* Add rewritten candidates in same order. */
7015 r
= add_operator_candidates (candidates
, rewrite_code
, ERROR_MARK
,
7016 arglist
, lookups
, flags
, complain
);
7017 if (r
== error_mark_node
)
7018 return error_mark_node
;
7021 z_candidate
*save_cand
= *candidates
;
7023 /* Add rewritten candidates in reverse order. */
7024 flags
|= LOOKUP_REVERSED
;
7025 vec
<tree
,va_gc
> *revlist
= make_tree_vector ();
7026 revlist
->quick_push ((*arglist
)[1]);
7027 revlist
->quick_push ((*arglist
)[0]);
7028 r
= add_operator_candidates (candidates
, rewrite_code
, ERROR_MARK
,
7029 revlist
, lookups
, flags
, complain
);
7030 if (r
== error_mark_node
)
7031 return error_mark_node
;
7033 /* Release the vec if we didn't add a candidate that uses it. */
7034 for (z_candidate
*c
= *candidates
; c
!= save_cand
; c
= c
->next
)
7035 if (c
->args
== revlist
)
7040 release_tree_vector (revlist
);
7048 build_new_op (const op_location_t
&loc
, enum tree_code code
, int flags
,
7049 tree arg1
, tree arg2
, tree arg3
, tree lookups
,
7050 tree
*overload
, tsubst_flags_t complain
)
7052 struct z_candidate
*candidates
= 0, *cand
;
7053 releasing_vec arglist
;
7054 tree result
= NULL_TREE
;
7055 bool result_valid_p
= false;
7056 enum tree_code code2
= ERROR_MARK
;
7057 enum tree_code code_orig_arg1
= ERROR_MARK
;
7058 enum tree_code code_orig_arg2
= ERROR_MARK
;
7062 auto_cond_timevar
tv (TV_OVERLOAD
);
7064 if (error_operand_p (arg1
)
7065 || error_operand_p (arg2
)
7066 || error_operand_p (arg3
))
7067 return error_mark_node
;
7069 conversion_obstack_sentinel cos
;
7071 bool ismodop
= code
== MODIFY_EXPR
;
7074 code2
= TREE_CODE (arg3
);
7078 tree arg1_type
= unlowered_expr_type (arg1
);
7079 tree arg2_type
= arg2
? unlowered_expr_type (arg2
) : NULL_TREE
;
7081 arg1
= prep_operand (arg1
);
7087 case VEC_DELETE_EXPR
:
7089 /* Use build_operator_new_call and build_op_delete_call instead. */
7093 /* Use build_op_call instead. */
7096 case TRUTH_ORIF_EXPR
:
7097 case TRUTH_ANDIF_EXPR
:
7098 case TRUTH_AND_EXPR
:
7100 /* These are saved for the sake of warn_logical_operator. */
7101 code_orig_arg1
= TREE_CODE (arg1
);
7102 code_orig_arg2
= TREE_CODE (arg2
);
7110 /* These are saved for the sake of maybe_warn_bool_compare. */
7111 code_orig_arg1
= TREE_CODE (arg1_type
);
7112 code_orig_arg2
= TREE_CODE (arg2_type
);
7119 arg2
= prep_operand (arg2
);
7120 arg3
= prep_operand (arg3
);
7122 if (code
== COND_EXPR
)
7123 /* Use build_conditional_expr instead. */
7125 else if (! OVERLOAD_TYPE_P (arg1_type
)
7126 && (! arg2
|| ! OVERLOAD_TYPE_P (arg2_type
)))
7129 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
7131 arg2
= integer_zero_node
;
7132 arg2_type
= integer_type_node
;
7135 arglist
->quick_push (arg1
);
7136 if (arg2
!= NULL_TREE
)
7137 arglist
->quick_push (arg2
);
7138 if (arg3
!= NULL_TREE
)
7139 arglist
->quick_push (arg3
);
7141 result
= add_operator_candidates (&candidates
, code
, code2
, arglist
,
7142 lookups
, flags
, complain
);
7143 if (result
== error_mark_node
)
7144 return error_mark_node
;
7150 /* For these, the built-in candidates set is empty
7151 [over.match.oper]/3. We don't want non-strict matches
7152 because exact matches are always possible with built-in
7153 operators. The built-in candidate set for COMPONENT_REF
7154 would be empty too, but since there are no such built-in
7155 operators, we accept non-strict matches for them. */
7164 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
7169 case POSTINCREMENT_EXPR
:
7170 case POSTDECREMENT_EXPR
:
7171 /* Don't try anything fancy if we're not allowed to produce
7173 if (!(complain
& tf_error
))
7174 return error_mark_node
;
7176 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
7177 distinguish between prefix and postfix ++ and
7178 operator++() was used for both, so we allow this with
7182 tree fnname
= ovl_op_identifier (ismodop
, ismodop
? code2
: code
);
7183 const char *msg
= (flag_permissive
)
7184 ? G_("no %<%D(int)%> declared for postfix %qs,"
7185 " trying prefix operator instead")
7186 : G_("no %<%D(int)%> declared for postfix %qs");
7187 permerror (loc
, msg
, fnname
, OVL_OP_INFO (false, code
)->name
);
7190 if (!flag_permissive
)
7191 return error_mark_node
;
7193 if (code
== POSTINCREMENT_EXPR
)
7194 code
= PREINCREMENT_EXPR
;
7196 code
= PREDECREMENT_EXPR
;
7197 result
= build_new_op (loc
, code
, flags
, arg1
, NULL_TREE
,
7198 NULL_TREE
, lookups
, overload
, complain
);
7201 /* The caller will deal with these. */
7207 result_valid_p
= true;
7211 if (complain
& tf_error
)
7213 /* If one of the arguments of the operator represents
7214 an invalid use of member function pointer, try to report
7215 a meaningful error ... */
7216 if (invalid_nonstatic_memfn_p (loc
, arg1
, tf_error
)
7217 || invalid_nonstatic_memfn_p (loc
, arg2
, tf_error
)
7218 || invalid_nonstatic_memfn_p (loc
, arg3
, tf_error
))
7219 /* We displayed the error message. */;
7222 /* ... Otherwise, report the more generic
7223 "no matching operator found" error */
7224 auto_diagnostic_group d
;
7225 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, false);
7226 print_z_candidates (loc
, candidates
);
7229 result
= error_mark_node
;
7235 cand
= tourney (candidates
, complain
);
7238 if (complain
& tf_error
)
7240 auto_diagnostic_group d
;
7241 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, true);
7242 print_z_candidates (loc
, candidates
);
7244 result
= error_mark_node
;
7246 *overload
= error_mark_node
;
7248 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
7251 *overload
= cand
->fn
;
7253 if (resolve_args (arglist
, complain
) == NULL
)
7254 result
= error_mark_node
;
7257 tsubst_flags_t ocomplain
= complain
;
7258 if (cand
->rewritten ())
7259 /* We'll wrap this call in another one. */
7260 ocomplain
&= ~tf_decltype
;
7261 if (cand
->reversed ())
7263 /* We swapped these in add_candidate, swap them back now. */
7264 std::swap (cand
->convs
[0], cand
->convs
[1]);
7265 if (cand
->fn
== current_function_decl
)
7266 warning_at (loc
, 0, "in C++20 this comparison calls the "
7267 "current function recursively with reversed "
7270 result
= build_over_call (cand
, LOOKUP_NORMAL
, ocomplain
);
7273 if (trivial_fn_p (cand
->fn
) || DECL_IMMEDIATE_FUNCTION_P (cand
->fn
))
7274 /* There won't be a CALL_EXPR. */;
7275 else if (result
&& result
!= error_mark_node
)
7277 tree call
= extract_call_expr (result
);
7278 CALL_EXPR_OPERATOR_SYNTAX (call
) = true;
7280 /* Specify evaluation order as per P0145R2. */
7281 CALL_EXPR_ORDERED_ARGS (call
) = false;
7282 switch (op_is_ordered (code
))
7285 CALL_EXPR_REVERSE_ARGS (call
) = true;
7289 CALL_EXPR_ORDERED_ARGS (call
) = true;
7297 /* If this was a C++20 rewritten comparison, adjust the result. */
7298 if (cand
->rewritten ())
7300 /* FIXME build_min_non_dep_op_overload can't handle rewrites. */
7302 *overload
= NULL_TREE
;
7306 gcc_checking_assert (cand
->reversed ());
7309 if (result
== error_mark_node
)
7311 /* If a rewritten operator== candidate is selected by
7312 overload resolution for an operator @, its return type
7313 shall be cv bool.... */
7314 else if (TREE_CODE (TREE_TYPE (result
)) != BOOLEAN_TYPE
)
7316 if (complain
& tf_error
)
7318 auto_diagnostic_group d
;
7319 error_at (loc
, "return type of %qD is not %qs",
7321 inform (loc
, "used as rewritten candidate for "
7322 "comparison of %qT and %qT",
7323 arg1_type
, arg2_type
);
7325 result
= error_mark_node
;
7327 else if (code
== NE_EXPR
)
7328 /* !(y == x) or !(x == y) */
7329 result
= build1_loc (loc
, TRUTH_NOT_EXPR
,
7330 boolean_type_node
, result
);
7333 /* If a rewritten operator<=> candidate is selected by
7334 overload resolution for an operator @, x @ y is
7335 interpreted as 0 @ (y <=> x) if the selected candidate is
7336 a synthesized candidate with reversed order of parameters,
7337 or (x <=> y) @ 0 otherwise, using the selected rewritten
7338 operator<=> candidate. */
7339 case SPACESHIP_EXPR
:
7340 if (!cand
->reversed ())
7341 /* We're in the build_new_op call below for an outer
7342 reversed call; we don't need to do anything more. */
7351 tree rhs
= integer_zero_node
;
7352 if (cand
->reversed ())
7353 std::swap (lhs
, rhs
);
7354 warning_sentinel
ws (warn_zero_as_null_pointer_constant
);
7355 result
= build_new_op (loc
, code
,
7356 LOOKUP_NORMAL
|LOOKUP_REWRITTEN
,
7357 lhs
, rhs
, NULL_TREE
, lookups
,
7367 /* In an expression of the form `a[]' where cand->fn
7368 which is operator[] turns out to be a static member function,
7369 `a' is none-the-less evaluated. */
7370 if (code
== ARRAY_REF
)
7371 result
= keep_unused_object_arg (result
, arg1
, cand
->fn
);
7375 /* Give any warnings we noticed during overload resolution. */
7376 if (cand
->warnings
&& (complain
& tf_warning
))
7378 struct candidate_warning
*w
;
7379 for (w
= cand
->warnings
; w
; w
= w
->next
)
7380 joust (cand
, w
->loser
, 1, complain
);
7383 /* Check for comparison of different enum types. */
7392 if (TREE_CODE (arg1_type
) == ENUMERAL_TYPE
7393 && TREE_CODE (arg2_type
) == ENUMERAL_TYPE
7394 && (TYPE_MAIN_VARIANT (arg1_type
)
7395 != TYPE_MAIN_VARIANT (arg2_type
)))
7397 if (cxx_dialect
>= cxx26
7398 && (complain
& tf_warning_or_error
) == 0)
7399 result
= error_mark_node
;
7400 else if (cxx_dialect
>= cxx26
|| (complain
& tf_warning
))
7401 emit_diagnostic (cxx_dialect
>= cxx26
7402 ? DK_PEDWARN
: DK_WARNING
,
7403 loc
, OPT_Wenum_compare
,
7404 "comparison between %q#T and %q#T",
7405 arg1_type
, arg2_type
);
7412 /* "If a built-in candidate is selected by overload resolution, the
7413 operands of class type are converted to the types of the
7414 corresponding parameters of the selected operation function,
7415 except that the second standard conversion sequence of a
7416 user-defined conversion sequence (12.3.3.1.2) is not applied." */
7417 conversion
*conv
= cand
->convs
[0];
7418 if (conv
->user_conv_p
)
7420 conv
= strip_standard_conversion (conv
);
7421 arg1
= convert_like (conv
, arg1
, complain
);
7426 conv
= cand
->convs
[1];
7427 if (conv
->user_conv_p
)
7429 conv
= strip_standard_conversion (conv
);
7430 arg2
= convert_like (conv
, arg2
, complain
);
7436 conv
= cand
->convs
[2];
7437 if (conv
->user_conv_p
)
7439 conv
= strip_standard_conversion (conv
);
7440 arg3
= convert_like (conv
, arg3
, complain
);
7446 if (result
|| result_valid_p
)
7453 return cp_build_modify_expr (loc
, arg1
, code2
, arg2
, complain
);
7456 return cp_build_indirect_ref (loc
, arg1
, RO_UNARY_STAR
, complain
);
7458 case TRUTH_ANDIF_EXPR
:
7459 case TRUTH_ORIF_EXPR
:
7460 case TRUTH_AND_EXPR
:
7462 if ((complain
& tf_warning
) && !processing_template_decl
)
7463 warn_logical_operator (loc
, code
, boolean_type_node
,
7464 code_orig_arg1
, arg1
,
7465 code_orig_arg2
, arg2
);
7473 if ((complain
& tf_warning
)
7474 && ((code_orig_arg1
== BOOLEAN_TYPE
)
7475 ^ (code_orig_arg2
== BOOLEAN_TYPE
)))
7476 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
7477 if (complain
& tf_warning
&& warn_tautological_compare
)
7478 warn_tautological_cmp (loc
, code
, arg1
, arg2
);
7480 case SPACESHIP_EXPR
:
7484 case TRUNC_DIV_EXPR
:
7489 case TRUNC_MOD_EXPR
:
7493 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
7495 case UNARY_PLUS_EXPR
:
7498 case TRUTH_NOT_EXPR
:
7499 case PREINCREMENT_EXPR
:
7500 case POSTINCREMENT_EXPR
:
7501 case PREDECREMENT_EXPR
:
7502 case POSTDECREMENT_EXPR
:
7507 return cp_build_unary_op (code
, arg1
, false, complain
);
7510 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
7513 return build_m_component_ref (cp_build_indirect_ref (loc
, arg1
,
7518 /* The caller will deal with these. */
7530 /* Build a new call to operator[]. This may change ARGS. */
7533 build_op_subscript (const op_location_t
&loc
, tree obj
,
7534 vec
<tree
, va_gc
> **args
, tree
*overload
,
7535 tsubst_flags_t complain
)
7537 struct z_candidate
*candidates
= 0, *cand
;
7538 tree fns
, first_mem_arg
= NULL_TREE
;
7540 tree result
= NULL_TREE
;
7542 auto_cond_timevar
tv (TV_OVERLOAD
);
7544 obj
= mark_lvalue_use (obj
);
7546 if (error_operand_p (obj
))
7547 return error_mark_node
;
7549 tree type
= TREE_TYPE (obj
);
7551 obj
= prep_operand (obj
);
7553 if (TYPE_BINFO (type
))
7555 fns
= lookup_fnfields (TYPE_BINFO (type
), ovl_op_identifier (ARRAY_REF
),
7557 if (fns
== error_mark_node
)
7558 return error_mark_node
;
7563 if (args
!= NULL
&& *args
!= NULL
)
7565 *args
= resolve_args (*args
, complain
);
7567 return error_mark_node
;
7570 conversion_obstack_sentinel cos
;
7574 first_mem_arg
= obj
;
7576 add_candidates (BASELINK_FUNCTIONS (fns
),
7577 first_mem_arg
, *args
, NULL_TREE
,
7579 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
7580 LOOKUP_NORMAL
, &candidates
, complain
);
7583 /* Be strict here because if we choose a bad conversion candidate, the
7584 errors we get won't mention the call context. */
7585 candidates
= splice_viable (candidates
, true, &any_viable_p
);
7588 if (complain
& tf_error
)
7590 auto_diagnostic_group d
;
7591 error ("no match for call to %<%T::operator[] (%A)%>",
7592 TREE_TYPE (obj
), build_tree_list_vec (*args
));
7593 print_z_candidates (loc
, candidates
);
7595 result
= error_mark_node
;
7599 cand
= tourney (candidates
, complain
);
7602 if (complain
& tf_error
)
7604 auto_diagnostic_group d
;
7605 error ("call of %<%T::operator[] (%A)%> is ambiguous",
7606 TREE_TYPE (obj
), build_tree_list_vec (*args
));
7607 print_z_candidates (loc
, candidates
);
7609 result
= error_mark_node
;
7611 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
7612 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
)
7613 && DECL_OVERLOADED_OPERATOR_IS (cand
->fn
, ARRAY_REF
))
7616 *overload
= cand
->fn
;
7617 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
7618 if (trivial_fn_p (cand
->fn
) || DECL_IMMEDIATE_FUNCTION_P (cand
->fn
))
7619 /* There won't be a CALL_EXPR. */;
7620 else if (result
&& result
!= error_mark_node
)
7622 tree call
= extract_call_expr (result
);
7623 CALL_EXPR_OPERATOR_SYNTAX (call
) = true;
7625 /* Specify evaluation order as per P0145R2. */
7626 CALL_EXPR_ORDERED_ARGS (call
) = op_is_ordered (ARRAY_REF
) == 1;
7629 /* In an expression of the form `a[]' where cand->fn
7630 which is operator[] turns out to be a static member function,
7631 `a' is none-the-less evaluated. */
7632 result
= keep_unused_object_arg (result
, obj
, cand
->fn
);
7641 /* CALL was returned by some call-building function; extract the actual
7642 CALL_EXPR from any bits that have been tacked on, e.g. by
7643 convert_from_reference. */
7646 extract_call_expr (tree call
)
7648 while (TREE_CODE (call
) == COMPOUND_EXPR
)
7649 call
= TREE_OPERAND (call
, 1);
7650 if (REFERENCE_REF_P (call
))
7651 call
= TREE_OPERAND (call
, 0);
7652 if (TREE_CODE (call
) == TARGET_EXPR
)
7653 call
= TARGET_EXPR_INITIAL (call
);
7654 if (cxx_dialect
>= cxx20
)
7655 switch (TREE_CODE (call
))
7657 /* C++20 rewritten comparison operators. */
7658 case TRUTH_NOT_EXPR
:
7659 call
= TREE_OPERAND (call
, 0);
7665 case SPACESHIP_EXPR
:
7667 tree op0
= TREE_OPERAND (call
, 0);
7668 if (integer_zerop (op0
))
7669 call
= TREE_OPERAND (call
, 1);
7677 if (TREE_CODE (call
) != CALL_EXPR
7678 && TREE_CODE (call
) != AGGR_INIT_EXPR
7679 && call
!= error_mark_node
)
7684 /* Returns true if FN has two parameters, of which the second has type
7688 second_parm_is_size_t (tree fn
)
7690 tree t
= FUNCTION_ARG_CHAIN (fn
);
7691 if (!t
|| !same_type_p (TREE_VALUE (t
), size_type_node
))
7694 if (t
== void_list_node
)
7699 /* True if T, an allocation function, has std::align_val_t as its second
7703 aligned_allocation_fn_p (tree t
)
7705 if (!aligned_new_threshold
)
7708 tree a
= FUNCTION_ARG_CHAIN (t
);
7709 return (a
&& same_type_p (TREE_VALUE (a
), align_type_node
));
7712 /* True if T is std::destroying_delete_t. */
7715 std_destroying_delete_t_p (tree t
)
7717 return (TYPE_CONTEXT (t
) == std_node
7718 && id_equal (TYPE_IDENTIFIER (t
), "destroying_delete_t"));
7721 /* A deallocation function with at least two parameters whose second parameter
7722 type is of type std::destroying_delete_t is a destroying operator delete. A
7723 destroying operator delete shall be a class member function named operator
7724 delete. [ Note: Array deletion cannot use a destroying operator
7725 delete. --end note ] */
7728 destroying_delete_p (tree t
)
7730 tree a
= TYPE_ARG_TYPES (TREE_TYPE (t
));
7731 if (!a
|| !TREE_CHAIN (a
))
7733 tree type
= TREE_VALUE (TREE_CHAIN (a
));
7734 return std_destroying_delete_t_p (type
) ? type
: NULL_TREE
;
7744 /* Returns true iff T, an element of an OVERLOAD chain, is a usual deallocation
7745 function (3.7.4.2 [basic.stc.dynamic.deallocation]). If so, and DI is
7746 non-null, also set *DI. */
7749 usual_deallocation_fn_p (tree t
, dealloc_info
*di
)
7751 if (di
) *di
= dealloc_info();
7753 /* A template instance is never a usual deallocation function,
7754 regardless of its signature. */
7755 if (TREE_CODE (t
) == TEMPLATE_DECL
7756 || primary_template_specialization_p (t
))
7759 /* A usual deallocation function is a deallocation function whose parameters
7761 - optionally, a parameter of type std::destroying_delete_t, then
7762 - optionally, a parameter of type std::size_t, then
7763 - optionally, a parameter of type std::align_val_t. */
7764 bool global
= DECL_NAMESPACE_SCOPE_P (t
);
7765 tree chain
= FUNCTION_ARG_CHAIN (t
);
7766 if (chain
&& destroying_delete_p (t
))
7768 if (di
) di
->destroying
= TREE_VALUE (chain
);
7769 chain
= TREE_CHAIN (chain
);
7772 && (!global
|| flag_sized_deallocation
)
7773 && same_type_p (TREE_VALUE (chain
), size_type_node
))
7775 if (di
) di
->sized
= true;
7776 chain
= TREE_CHAIN (chain
);
7778 if (chain
&& aligned_new_threshold
7779 && same_type_p (TREE_VALUE (chain
), align_type_node
))
7781 if (di
) di
->aligned
= true;
7782 chain
= TREE_CHAIN (chain
);
7784 return (chain
== void_list_node
);
7787 /* Just return whether FN is a usual deallocation function. */
7790 usual_deallocation_fn_p (tree fn
)
7792 return usual_deallocation_fn_p (fn
, NULL
);
7795 /* Build a call to operator delete. This has to be handled very specially,
7796 because the restrictions on what signatures match are different from all
7797 other call instances. For a normal delete, only a delete taking (void *)
7798 or (void *, size_t) is accepted. For a placement delete, only an exact
7799 match with the placement new is accepted.
7801 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
7802 ADDR is the pointer to be deleted.
7803 SIZE is the size of the memory block to be deleted.
7804 GLOBAL_P is true if the delete-expression should not consider
7805 class-specific delete operators.
7806 PLACEMENT is the corresponding placement new call, or NULL_TREE.
7808 If this call to "operator delete" is being generated as part to
7809 deallocate memory allocated via a new-expression (as per [expr.new]
7810 which requires that if the initialization throws an exception then
7811 we call a deallocation function), then ALLOC_FN is the allocation
7815 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
7816 bool global_p
, tree placement
,
7817 tree alloc_fn
, tsubst_flags_t complain
)
7819 tree fn
= NULL_TREE
;
7820 tree fns
, fnname
, type
, t
;
7821 dealloc_info di_fn
= { };
7823 if (addr
== error_mark_node
)
7824 return error_mark_node
;
7826 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
7828 fnname
= ovl_op_identifier (false, code
);
7830 if (CLASS_TYPE_P (type
)
7831 && COMPLETE_TYPE_P (complete_type (type
))
7835 If the result of the lookup is ambiguous or inaccessible, or if
7836 the lookup selects a placement deallocation function, the
7837 program is ill-formed.
7839 Therefore, we ask lookup_fnfields to complain about ambiguity. */
7841 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1, complain
);
7842 if (fns
== error_mark_node
)
7843 return error_mark_node
;
7848 if (fns
== NULL_TREE
)
7849 fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
);
7851 /* Strip const and volatile from addr. */
7853 addr
= cp_convert (ptr_type_node
, addr
, complain
);
7855 tree excluded_destroying
= NULL_TREE
;
7859 /* "A declaration of a placement deallocation function matches the
7860 declaration of a placement allocation function if it has the same
7861 number of parameters and, after parameter transformations (8.3.5),
7862 all parameter types except the first are identical."
7864 So we build up the function type we want and ask instantiate_type
7865 to get it for us. */
7866 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
7867 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
7868 t
= build_function_type (void_type_node
, t
);
7870 fn
= instantiate_type (t
, fns
, tf_none
);
7871 if (fn
== error_mark_node
)
7874 fn
= MAYBE_BASELINK_FUNCTIONS (fn
);
7876 /* "If the lookup finds the two-parameter form of a usual deallocation
7877 function (3.7.4.2) and that function, considered as a placement
7878 deallocation function, would have been selected as a match for the
7879 allocation function, the program is ill-formed." */
7880 if (second_parm_is_size_t (fn
))
7882 const char *const msg1
7883 = G_("exception cleanup for this placement new selects "
7884 "non-placement %<operator delete%>");
7885 const char *const msg2
7886 = G_("%qD is a usual (non-placement) deallocation "
7887 "function in C++14 (or with %<-fsized-deallocation%>)");
7889 /* But if the class has an operator delete (void *), then that is
7890 the usual deallocation function, so we shouldn't complain
7891 about using the operator delete (void *, size_t). */
7892 if (DECL_CLASS_SCOPE_P (fn
))
7893 for (tree elt
: lkp_range (MAYBE_BASELINK_FUNCTIONS (fns
)))
7895 if (usual_deallocation_fn_p (elt
)
7896 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
7899 /* Before C++14 a two-parameter global deallocation function is
7900 always a placement deallocation function, but warn if
7902 else if (!flag_sized_deallocation
)
7904 if (complain
& tf_warning
)
7906 auto_diagnostic_group d
;
7907 if (warning (OPT_Wc__14_compat
, msg1
))
7908 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
7913 if (complain
& tf_warning_or_error
)
7915 auto_diagnostic_group d
;
7916 if (permerror (input_location
, msg1
))
7918 /* Only mention C++14 for namespace-scope delete. */
7919 if (DECL_NAMESPACE_SCOPE_P (fn
))
7920 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
7922 inform (DECL_SOURCE_LOCATION (fn
),
7923 "%qD is a usual (non-placement) deallocation "
7928 return error_mark_node
;
7933 /* "Any non-placement deallocation function matches a non-placement
7934 allocation function. If the lookup finds a single matching
7935 deallocation function, that function will be called; otherwise, no
7936 deallocation function will be called." */
7937 for (tree elt
: lkp_range (MAYBE_BASELINK_FUNCTIONS (fns
)))
7939 dealloc_info di_elt
;
7940 if (usual_deallocation_fn_p (elt
, &di_elt
))
7942 /* If we're called for an EH cleanup in a new-expression, we can't
7943 use a destroying delete; the exception was thrown before the
7944 object was constructed. */
7945 if (alloc_fn
&& di_elt
.destroying
)
7947 excluded_destroying
= elt
;
7958 /* -- If any of the deallocation functions is a destroying
7959 operator delete, all deallocation functions that are not
7960 destroying operator deletes are eliminated from further
7962 if (di_elt
.destroying
!= di_fn
.destroying
)
7964 if (di_elt
.destroying
)
7972 /* -- If the type has new-extended alignment, a function with a
7973 parameter of type std::align_val_t is preferred; otherwise a
7974 function without such a parameter is preferred. If exactly one
7975 preferred function is found, that function is selected and the
7976 selection process terminates. If more than one preferred
7977 function is found, all non-preferred functions are eliminated
7978 from further consideration. */
7979 if (aligned_new_threshold
)
7981 bool want_align
= type_has_new_extended_alignment (type
);
7982 if (di_elt
.aligned
!= di_fn
.aligned
)
7984 if (want_align
== di_elt
.aligned
)
7993 /* -- If the deallocation functions have class scope, the one
7994 without a parameter of type std::size_t is selected. */
7996 if (DECL_CLASS_SCOPE_P (fn
))
7999 /* -- If the type is complete and if, for the second alternative
8000 (delete array) only, the operand is a pointer to a class type
8001 with a non-trivial destructor or a (possibly multi-dimensional)
8002 array thereof, the function with a parameter of type std::size_t
8005 -- Otherwise, it is unspecified whether a deallocation function
8006 with a parameter of type std::size_t is selected. */
8009 want_size
= COMPLETE_TYPE_P (type
);
8010 if (code
== VEC_DELETE_EXPR
8011 && !TYPE_VEC_NEW_USES_COOKIE (type
))
8012 /* We need a cookie to determine the array size. */
8015 gcc_assert (di_fn
.sized
!= di_elt
.sized
);
8016 if (want_size
== di_elt
.sized
)
8024 /* If we have a matching function, call it. */
8027 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
8029 /* If the FN is a member function, make sure that it is
8031 if (BASELINK_P (fns
))
8032 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
8035 /* Core issue 901: It's ok to new a type with deleted delete. */
8036 if (DECL_DELETED_FN (fn
) && alloc_fn
)
8042 /* The placement args might not be suitable for overload
8043 resolution at this point, so build the call directly. */
8044 int nargs
= call_expr_nargs (placement
);
8045 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
8048 for (i
= 1; i
< nargs
; i
++)
8049 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
8050 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
8051 return error_mark_node
;
8052 ret
= build_cxx_call (fn
, nargs
, argarray
, complain
);
8056 tree destroying
= di_fn
.destroying
;
8059 /* Strip const and volatile from addr but retain the type of the
8061 tree rtype
= TREE_TYPE (TREE_TYPE (oaddr
));
8062 rtype
= cv_unqualified (rtype
);
8063 rtype
= TYPE_POINTER_TO (rtype
);
8064 addr
= cp_convert (rtype
, oaddr
, complain
);
8065 destroying
= build_functional_cast (input_location
,
8066 destroying
, NULL_TREE
,
8071 args
->quick_push (addr
);
8073 args
->quick_push (destroying
);
8075 args
->quick_push (size
);
8078 tree al
= build_int_cst (align_type_node
, TYPE_ALIGN_UNIT (type
));
8079 args
->quick_push (al
);
8081 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
8084 /* Set this flag for all callers of this function. In addition to
8085 delete-expressions, this is called for deallocating coroutine state;
8086 treat that as an implicit delete-expression. This is also called for
8087 the delete if the constructor throws in a new-expression, and for a
8088 deleting destructor (which implements a delete-expression). */
8089 /* But leave this flag off for destroying delete to avoid wrong
8090 assumptions in the optimizers. */
8091 tree call
= extract_call_expr (ret
);
8092 if (TREE_CODE (call
) == CALL_EXPR
&& !destroying_delete_p (fn
))
8093 CALL_FROM_NEW_OR_DELETE_P (call
) = 1;
8098 /* If there's only a destroying delete that we can't use because the
8099 object isn't constructed yet, and we used global new, use global
8101 if (excluded_destroying
8102 && DECL_NAMESPACE_SCOPE_P (alloc_fn
))
8103 return build_op_delete_call (code
, addr
, size
, true, placement
,
8104 alloc_fn
, complain
);
8108 If no unambiguous matching deallocation function can be found,
8109 propagating the exception does not cause the object's memory to
8113 if ((complain
& tf_warning
)
8116 bool w
= warning (0,
8117 "no corresponding deallocation function for %qD",
8119 if (w
&& excluded_destroying
)
8120 inform (DECL_SOURCE_LOCATION (excluded_destroying
), "destroying "
8121 "delete %qD cannot be used to release the allocated memory"
8122 " if the initialization throws because the object is not "
8123 "constructed yet", excluded_destroying
);
8128 if (complain
& tf_error
)
8129 error ("no suitable %<operator %s%> for %qT",
8130 OVL_OP_INFO (false, code
)->name
, type
);
8131 return error_mark_node
;
8134 /* Issue diagnostics about a disallowed access of DECL, using DIAG_DECL
8137 If ISSUE_ERROR is true, then issue an error about the access, followed
8138 by a note showing the declaration. Otherwise, just show the note.
8140 DIAG_DECL and DIAG_LOCATION will almost always be the same.
8141 DIAG_LOCATION is just another DECL. NO_ACCESS_REASON is an optional
8142 parameter used to specify why DECL wasn't accessible (e.g. ak_private
8143 would be because DECL was private). If not using NO_ACCESS_REASON,
8144 then it must be ak_none, and the access failure reason will be
8145 figured out by looking at the protection of DECL. */
8148 complain_about_access (tree decl
, tree diag_decl
, tree diag_location
,
8149 bool issue_error
, access_kind no_access_reason
)
8151 /* If we have not already figured out why DECL is inaccessible... */
8152 if (no_access_reason
== ak_none
)
8154 /* Examine the access of DECL to find out why. */
8155 if (TREE_PRIVATE (decl
))
8156 no_access_reason
= ak_private
;
8157 else if (TREE_PROTECTED (decl
))
8158 no_access_reason
= ak_protected
;
8161 /* Now generate an error message depending on calculated access. */
8162 if (no_access_reason
== ak_private
)
8165 error ("%q#D is private within this context", diag_decl
);
8166 inform (DECL_SOURCE_LOCATION (diag_location
), "declared private here");
8168 else if (no_access_reason
== ak_protected
)
8171 error ("%q#D is protected within this context", diag_decl
);
8172 inform (DECL_SOURCE_LOCATION (diag_location
), "declared protected here");
8174 /* Couldn't figure out why DECL is inaccesible, so just say it's
8179 error ("%q#D is inaccessible within this context", diag_decl
);
8180 inform (DECL_SOURCE_LOCATION (diag_decl
), "declared here");
8184 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
8185 bitwise or of LOOKUP_* values. If any errors are warnings are
8186 generated, set *DIAGNOSTIC_FN to "error" or "warning",
8187 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
8191 build_temp (tree expr
, tree type
, int flags
,
8192 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
8196 *diagnostic_kind
= DK_UNSPECIFIED
;
8198 /* If the source is a packed field, calling the copy constructor will require
8199 binding the field to the reference parameter to the copy constructor, and
8200 we'll end up with an infinite loop. If we can use a bitwise copy, then
8202 if ((lvalue_kind (expr
) & clk_packed
)
8203 && CLASS_TYPE_P (TREE_TYPE (expr
))
8204 && !type_has_nontrivial_copy_init (TREE_TYPE (expr
)))
8205 return get_target_expr (expr
, complain
);
8207 /* In decltype, we might have decided not to wrap this call in a TARGET_EXPR.
8208 But it turns out to be a subexpression, so perform temporary
8209 materialization now. */
8210 if (TREE_CODE (expr
) == CALL_EXPR
8211 && CLASS_TYPE_P (type
)
8212 && same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
8213 expr
= build_cplus_new (type
, expr
, complain
);
8215 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
8216 releasing_vec
args (make_tree_vector_single (expr
));
8217 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
8218 &args
, type
, flags
, complain
);
8219 if (warningcount
+ werrorcount
> savew
)
8220 *diagnostic_kind
= DK_WARNING
;
8221 else if (errorcount
> savee
)
8222 *diagnostic_kind
= DK_ERROR
;
8226 /* Get any location for EXPR, falling back to input_location.
8228 If the result is in a system header and is the virtual location for
8229 a token coming from the expansion of a macro, unwind it to the
8230 location of the expansion point of the macro (e.g. to avoid the
8231 diagnostic being suppressed for expansions of NULL where "NULL" is
8232 in a system header). */
8235 get_location_for_expr_unwinding_for_system_header (tree expr
)
8237 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
8238 loc
= expansion_point_location_if_in_system_header (loc
);
8242 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
8243 Also handle a subset of zero as null warnings.
8244 EXPR is implicitly converted to type TOTYPE.
8245 FN and ARGNUM are used for diagnostics. */
8248 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
8250 /* Issue warnings about peculiar, but valid, uses of NULL. */
8251 if (TREE_CODE (totype
) != BOOLEAN_TYPE
8252 && ARITHMETIC_TYPE_P (totype
)
8253 && null_node_p (expr
))
8255 location_t loc
= get_location_for_expr_unwinding_for_system_header (expr
);
8258 auto_diagnostic_group d
;
8259 if (warning_at (loc
, OPT_Wconversion_null
,
8260 "passing NULL to non-pointer argument %P of %qD",
8262 inform (get_fndecl_argument_location (fn
, argnum
),
8266 warning_at (loc
, OPT_Wconversion_null
,
8267 "converting to non-pointer type %qT from NULL", totype
);
8270 /* Issue warnings if "false" is converted to a NULL pointer */
8271 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
8272 && TYPE_PTR_P (totype
))
8274 location_t loc
= get_location_for_expr_unwinding_for_system_header (expr
);
8277 auto_diagnostic_group d
;
8278 if (warning_at (loc
, OPT_Wconversion_null
,
8279 "converting %<false%> to pointer type for argument "
8280 "%P of %qD", argnum
, fn
))
8281 inform (get_fndecl_argument_location (fn
, argnum
),
8285 warning_at (loc
, OPT_Wconversion_null
,
8286 "converting %<false%> to pointer type %qT", totype
);
8288 /* Handle zero as null pointer warnings for cases other
8289 than EQ_EXPR and NE_EXPR */
8290 else if ((TYPE_PTR_OR_PTRMEM_P (totype
) || NULLPTR_TYPE_P (totype
))
8291 && null_ptr_cst_p (expr
))
8293 location_t loc
= get_location_for_expr_unwinding_for_system_header (expr
);
8294 maybe_warn_zero_as_null_pointer_constant (expr
, loc
);
8298 /* We gave a diagnostic during a conversion. If this was in the second
8299 standard conversion sequence of a user-defined conversion sequence, say
8300 which user-defined conversion. */
8303 maybe_print_user_conv_context (conversion
*convs
)
8305 if (convs
->user_conv_p
)
8306 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
8307 if (t
->kind
== ck_user
)
8309 print_z_candidate (0, N_(" after user-defined conversion:"),
8315 /* Locate the parameter with the given index within FNDECL.
8316 ARGNUM is zero based, -1 indicates the `this' argument of a method.
8317 Return the location of the FNDECL itself if there are problems. */
8320 get_fndecl_argument_location (tree fndecl
, int argnum
)
8322 /* The locations of implicitly-declared functions are likely to be
8323 more meaningful than those of their parameters. */
8324 if (DECL_ARTIFICIAL (fndecl
))
8325 return DECL_SOURCE_LOCATION (fndecl
);
8330 /* Locate param by index within DECL_ARGUMENTS (fndecl). */
8331 for (i
= 0, param
= FUNCTION_FIRST_USER_PARM (fndecl
);
8332 i
< argnum
&& param
;
8333 i
++, param
= TREE_CHAIN (param
))
8336 /* If something went wrong (e.g. if we have a builtin and thus no arguments),
8337 return the location of FNDECL. */
8339 return DECL_SOURCE_LOCATION (fndecl
);
8341 return DECL_SOURCE_LOCATION (param
);
8344 /* If FNDECL is non-NULL, issue a note highlighting ARGNUM
8345 within its declaration (or the fndecl itself if something went
8349 maybe_inform_about_fndecl_for_bogus_argument_init (tree fn
, int argnum
)
8352 inform (get_fndecl_argument_location (fn
, argnum
),
8353 " initializing argument %P of %qD", argnum
, fn
);
8356 /* Maybe warn about C++20 Conversions to arrays of unknown bound. C is
8357 the conversion, EXPR is the expression we're converting. */
8360 maybe_warn_array_conv (location_t loc
, conversion
*c
, tree expr
)
8362 if (cxx_dialect
>= cxx20
)
8365 tree type
= TREE_TYPE (expr
);
8366 type
= strip_pointer_operator (type
);
8368 if (TREE_CODE (type
) != ARRAY_TYPE
8369 || TYPE_DOMAIN (type
) == NULL_TREE
)
8372 if (pedantic
&& conv_binds_to_array_of_unknown_bound (c
))
8373 pedwarn (loc
, OPT_Wc__20_extensions
,
8374 "conversions to arrays of unknown bound "
8375 "are only available with %<-std=c++20%> or %<-std=gnu++20%>");
8378 /* We call this recursively in convert_like_internal. */
8379 static tree
convert_like (conversion
*, tree
, tree
, int, bool, bool, bool,
8382 /* Perform the conversions in CONVS on the expression EXPR. FN and
8383 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
8384 indicates the `this' argument of a method. INNER is nonzero when
8385 being called to continue a conversion chain. It is negative when a
8386 reference binding will be applied, positive otherwise. If
8387 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
8388 conversions will be emitted if appropriate. If C_CAST_P is true,
8389 this conversion is coming from a C-style cast; in that case,
8390 conversions to inaccessible bases are permitted. */
8393 convert_like_internal (conversion
*convs
, tree expr
, tree fn
, int argnum
,
8394 bool issue_conversion_warnings
, bool c_cast_p
,
8395 bool nested_p
, tsubst_flags_t complain
)
8397 tree totype
= convs
->type
;
8398 diagnostic_t diag_kind
;
8400 location_t loc
= cp_expr_loc_or_input_loc (expr
);
8402 if (convs
->bad_p
&& !(complain
& tf_error
))
8403 return error_mark_node
;
8406 && convs
->kind
!= ck_user
8407 && convs
->kind
!= ck_list
8408 && convs
->kind
!= ck_ambig
8409 && (convs
->kind
!= ck_ref_bind
8410 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
8411 && (convs
->kind
!= ck_rvalue
8412 || SCALAR_TYPE_P (totype
))
8413 && convs
->kind
!= ck_base
)
8416 conversion
*t
= convs
;
8418 /* Give a helpful error if this is bad because of excess braces. */
8419 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
8420 && SCALAR_TYPE_P (totype
)
8421 && CONSTRUCTOR_NELTS (expr
) > 0
8422 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
8424 complained
= permerror (loc
, "too many braces around initializer "
8426 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
8427 && CONSTRUCTOR_NELTS (expr
) == 1)
8428 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
8431 /* Give a helpful error if this is bad because a conversion to bool
8432 from std::nullptr_t requires direct-initialization. */
8433 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
8434 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
8435 complained
= permerror (loc
, "converting to %qH from %qI requires "
8436 "direct-initialization",
8437 totype
, TREE_TYPE (expr
));
8439 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (expr
))
8440 && SCALAR_FLOAT_TYPE_P (totype
)
8441 && (extended_float_type_p (TREE_TYPE (expr
))
8442 || extended_float_type_p (totype
)))
8443 switch (cp_compare_floating_point_conversion_ranks (TREE_TYPE (expr
),
8447 if (pedwarn (loc
, OPT_Wnarrowing
, "ISO C++ does not allow "
8448 "converting to %qH from %qI with greater "
8449 "conversion rank", totype
, TREE_TYPE (expr
)))
8451 else if (!complained
)
8455 if (pedwarn (loc
, OPT_Wnarrowing
, "ISO C++ does not allow "
8456 "converting to %qH from %qI with unordered "
8457 "conversion rank", totype
, TREE_TYPE (expr
)))
8459 else if (!complained
)
8466 for (; t
; t
= next_conversion (t
))
8468 if (t
->kind
== ck_user
&& t
->cand
->reason
)
8470 auto_diagnostic_group d
;
8471 complained
= permerror (loc
, "invalid user-defined conversion "
8472 "from %qH to %qI", TREE_TYPE (expr
),
8475 print_z_candidate (loc
, N_("candidate is:"), t
->cand
);
8476 expr
= convert_like (t
, expr
, fn
, argnum
,
8477 /*issue_conversion_warnings=*/false,
8478 /*c_cast_p=*/false, /*nested_p=*/true,
8481 else if (t
->kind
== ck_user
|| !t
->bad_p
)
8483 expr
= convert_like (t
, expr
, fn
, argnum
,
8484 /*issue_conversion_warnings=*/false,
8485 /*c_cast_p=*/false, /*nested_p=*/true,
8491 else if (t
->kind
== ck_ambig
)
8492 return convert_like (t
, expr
, fn
, argnum
,
8493 /*issue_conversion_warnings=*/false,
8494 /*c_cast_p=*/false, /*nested_p=*/true,
8496 else if (t
->kind
== ck_identity
)
8499 if (!complained
&& expr
!= error_mark_node
)
8501 range_label_for_type_mismatch
label (TREE_TYPE (expr
), totype
);
8502 gcc_rich_location
richloc (loc
, &label
);
8503 complained
= permerror (&richloc
,
8504 "invalid conversion from %qH to %qI",
8505 TREE_TYPE (expr
), totype
);
8507 if (convs
->kind
== ck_ref_bind
)
8508 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
8509 LOOKUP_NORMAL
, NULL_TREE
,
8512 expr
= cp_convert (totype
, expr
, complain
);
8513 if (complained
== 1)
8514 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
8518 if (issue_conversion_warnings
&& (complain
& tf_warning
))
8519 conversion_null_warnings (totype
, expr
, fn
, argnum
);
8521 switch (convs
->kind
)
8525 struct z_candidate
*cand
= convs
->cand
;
8528 /* We chose the surrogate function from add_conv_candidate, now we
8529 actually need to build the conversion. */
8530 cand
= build_user_type_conversion_1 (totype
, expr
,
8531 LOOKUP_NO_CONVERSION
, complain
);
8533 tree convfn
= cand
->fn
;
8535 /* When converting from an init list we consider explicit
8536 constructors, but actually trying to call one is an error. */
8537 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
8538 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
8539 /* Unless this is for direct-list-initialization. */
8540 && (!CONSTRUCTOR_IS_DIRECT_INIT (expr
) || convs
->need_temporary_p
)
8541 /* And in C++98 a default constructor can't be explicit. */
8542 && cxx_dialect
>= cxx11
)
8544 if (!(complain
& tf_error
))
8545 return error_mark_node
;
8546 location_t loc
= location_of (expr
);
8547 if (CONSTRUCTOR_NELTS (expr
) == 0
8548 && FUNCTION_FIRST_USER_PARMTYPE (convfn
) != void_list_node
)
8550 auto_diagnostic_group d
;
8551 if (pedwarn (loc
, 0, "converting to %qT from initializer list "
8552 "would use explicit constructor %qD",
8555 inform (DECL_SOURCE_LOCATION (convfn
), "%qD declared here",
8557 inform (loc
, "in C++11 and above a default constructor "
8563 auto_diagnostic_group d
;
8564 error ("converting to %qT from initializer list would use "
8565 "explicit constructor %qD", totype
, convfn
);
8566 inform (DECL_SOURCE_LOCATION (convfn
), "%qD declared here",
8571 /* If we're initializing from {}, it's value-initialization. */
8572 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
8573 && CONSTRUCTOR_NELTS (expr
) == 0
8574 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
)
8575 && !processing_template_decl
)
8577 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
8578 if (abstract_virtuals_error (NULL_TREE
, totype
, complain
))
8579 return error_mark_node
;
8580 expr
= build_value_init (totype
, complain
);
8581 expr
= get_target_expr (expr
, complain
);
8582 if (expr
!= error_mark_node
)
8584 TARGET_EXPR_LIST_INIT_P (expr
) = true;
8585 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
8590 /* We don't know here whether EXPR is being used as an lvalue or
8591 rvalue, but we know it's read. */
8592 mark_exp_read (expr
);
8594 /* Pass LOOKUP_NO_CONVERSION so rvalue/base handling knows not to allow
8596 expr
= build_over_call (cand
, LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
8599 /* If this is a constructor or a function returning an aggr type,
8600 we need to build up a TARGET_EXPR. */
8601 if (DECL_CONSTRUCTOR_P (convfn
))
8603 expr
= build_cplus_new (totype
, expr
, complain
);
8605 /* Remember that this was list-initialization. */
8606 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
8607 TARGET_EXPR_LIST_INIT_P (expr
) = true;
8613 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
8615 int nelts
= CONSTRUCTOR_NELTS (expr
);
8617 expr
= build_value_init (totype
, complain
);
8618 else if (nelts
== 1)
8619 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
8623 expr
= mark_use (expr
, /*rvalue_p=*/!convs
->rvaluedness_matches_p
,
8624 /*read_p=*/true, UNKNOWN_LOCATION
,
8625 /*reject_builtin=*/true);
8627 if (type_unknown_p (expr
))
8628 expr
= instantiate_type (totype
, expr
, complain
);
8629 if (!nested_p
&& TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
8630 expr
= cp_convert (totype
, TREE_OPERAND (expr
, 0), complain
);
8631 if (expr
== null_node
8632 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
8633 /* If __null has been converted to an integer type, we do not want to
8634 continue to warn about uses of EXPR as an integer, rather than as a
8636 expr
= build_int_cst (totype
, 0);
8639 /* We leave bad_p off ck_ambig because overload resolution considers
8640 it valid, it just fails when we try to perform it. So we need to
8641 check complain here, too. */
8642 if (complain
& tf_error
)
8644 /* Call build_user_type_conversion again for the error. */
8645 int flags
= (convs
->need_temporary_p
8646 ? LOOKUP_IMPLICIT
: LOOKUP_NORMAL
);
8647 build_user_type_conversion (totype
, convs
->u
.expr
, flags
, complain
);
8648 gcc_assert (seen_error ());
8649 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
8651 return error_mark_node
;
8655 /* Conversion to std::initializer_list<T>. */
8656 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
8657 unsigned len
= CONSTRUCTOR_NELTS (expr
);
8660 if (tree init
= maybe_init_list_as_array (elttype
, expr
))
8662 elttype
= cp_build_qualified_type
8663 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
8664 array
= build_array_of_n_type (elttype
, len
);
8665 array
= build_vec_init_expr (array
, init
, complain
);
8666 array
= get_target_expr (array
);
8667 array
= cp_build_addr_expr (array
, complain
);
8671 tree val
; unsigned ix
;
8673 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
8675 /* Convert all the elements. */
8676 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
8678 tree sub
= convert_like (convs
->u
.list
[ix
], val
, fn
,
8679 argnum
, false, false,
8680 /*nested_p=*/true, complain
);
8681 if (sub
== error_mark_node
)
8683 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
8684 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
8685 return error_mark_node
;
8686 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
),
8688 if (!TREE_CONSTANT (sub
))
8689 TREE_CONSTANT (new_ctor
) = false;
8691 /* Build up the array. */
8692 elttype
= cp_build_qualified_type
8693 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
8694 array
= build_array_of_n_type (elttype
, len
);
8695 array
= finish_compound_literal (array
, new_ctor
, complain
);
8696 /* This is dubious now, should be blessed by P2752. */
8697 DECL_MERGEABLE (TARGET_EXPR_SLOT (array
)) = true;
8698 array
= cp_build_addr_expr (array
, complain
);
8701 array
= nullptr_node
;
8703 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
8704 if (array
== error_mark_node
)
8705 return error_mark_node
;
8707 /* Build up the initializer_list object. Note: fail gracefully
8708 if the object cannot be completed because, for example, no
8709 definition is provided (c++/80956). */
8710 totype
= complete_type_or_maybe_complain (totype
, NULL_TREE
, complain
);
8712 return error_mark_node
;
8713 tree field
= next_aggregate_field (TYPE_FIELDS (totype
));
8714 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
8715 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
8716 field
= next_aggregate_field (DECL_CHAIN (field
));
8717 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
8718 tree new_ctor
= build_constructor (totype
, vec
);
8719 return get_target_expr (new_ctor
, complain
);
8723 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
8725 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
8726 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
8727 real
= perform_implicit_conversion (TREE_TYPE (totype
),
8729 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
8731 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
8734 expr
= reshape_init (totype
, expr
, complain
);
8735 expr
= get_target_expr (digest_init (totype
, expr
, complain
),
8737 if (expr
!= error_mark_node
)
8738 TARGET_EXPR_LIST_INIT_P (expr
) = true;
8745 expr
= convert_like (next_conversion (convs
), expr
, fn
, argnum
,
8746 convs
->kind
== ck_ref_bind
8747 ? issue_conversion_warnings
: false,
8748 c_cast_p
, /*nested_p=*/true, complain
& ~tf_no_cleanup
);
8749 if (expr
== error_mark_node
)
8750 return error_mark_node
;
8752 switch (convs
->kind
)
8755 expr
= decay_conversion (expr
, complain
);
8756 if (expr
== error_mark_node
)
8758 if (complain
& tf_error
)
8760 auto_diagnostic_group d
;
8761 maybe_print_user_conv_context (convs
);
8762 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
8764 return error_mark_node
;
8767 if (! MAYBE_CLASS_TYPE_P (totype
))
8770 /* Don't introduce copies when passing arguments along to the inherited
8772 if (current_function_decl
8773 && flag_new_inheriting_ctors
8774 && DECL_INHERITED_CTOR (current_function_decl
))
8777 if (TREE_CODE (expr
) == TARGET_EXPR
8778 && TARGET_EXPR_LIST_INIT_P (expr
))
8779 /* Copy-list-initialization doesn't actually involve a copy. */
8784 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
8786 /* We are going to bind a reference directly to a base-class
8787 subobject of EXPR. */
8788 /* Build an expression for `*((base*) &expr)'. */
8789 expr
= convert_to_base (expr
, totype
,
8790 !c_cast_p
, /*nonnull=*/true, complain
);
8794 /* Copy-initialization where the cv-unqualified version of the source
8795 type is the same class as, or a derived class of, the class of the
8796 destination [is treated as direct-initialization]. [dcl.init] */
8797 flags
= LOOKUP_NORMAL
;
8798 /* This conversion is being done in the context of a user-defined
8799 conversion (i.e. the second step of copy-initialization), so
8800 don't allow any more. */
8801 if (convs
->user_conv_p
)
8802 flags
|= LOOKUP_NO_CONVERSION
;
8803 /* We might be performing a conversion of the argument
8804 to the user-defined conversion, i.e., not a conversion of the
8805 result of the user-defined conversion. In which case we skip
8806 explicit constructors. */
8807 if (convs
->copy_init_p
)
8808 flags
|= LOOKUP_ONLYCONVERTING
;
8809 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
8810 if (diag_kind
&& complain
)
8812 auto_diagnostic_group d
;
8813 maybe_print_user_conv_context (convs
);
8814 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
8817 return build_cplus_new (totype
, expr
, complain
);
8821 tree ref_type
= totype
;
8823 /* direct_reference_binding might have inserted a ck_qual under
8824 this ck_ref_bind for the benefit of conversion sequence ranking.
8825 Ignore the conversion; we'll create our own below. */
8826 if (next_conversion (convs
)->kind
== ck_qual
8827 && !convs
->need_temporary_p
)
8829 gcc_assert (same_type_p (TREE_TYPE (expr
),
8830 next_conversion (convs
)->type
));
8831 /* Strip the cast created by the ck_qual; cp_build_addr_expr
8832 below expects an lvalue. */
8836 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
8838 tree extype
= TREE_TYPE (expr
);
8839 auto_diagnostic_group d
;
8840 if (TYPE_REF_IS_RVALUE (ref_type
)
8842 error_at (loc
, "cannot bind rvalue reference of type %qH to "
8843 "lvalue of type %qI", totype
, extype
);
8844 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !lvalue_p (expr
)
8845 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
8847 conversion
*next
= next_conversion (convs
);
8848 if (next
->kind
== ck_std
)
8850 next
= next_conversion (next
);
8851 error_at (loc
, "cannot bind non-const lvalue reference of "
8852 "type %qH to a value of type %qI",
8853 totype
, next
->type
);
8855 else if (!CP_TYPE_CONST_P (TREE_TYPE (ref_type
)))
8856 error_at (loc
, "cannot bind non-const lvalue reference of "
8857 "type %qH to an rvalue of type %qI", totype
, extype
);
8858 else // extype is volatile
8859 error_at (loc
, "cannot bind lvalue reference of type "
8860 "%qH to an rvalue of type %qI", totype
,
8863 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
8865 /* If we're converting from T[] to T[N], don't talk
8866 about discarding qualifiers. (Converting from T[N] to
8867 T[] is allowed by P0388R4.) */
8868 if (TREE_CODE (extype
) == ARRAY_TYPE
8869 && TYPE_DOMAIN (extype
) == NULL_TREE
8870 && TREE_CODE (TREE_TYPE (totype
)) == ARRAY_TYPE
8871 && TYPE_DOMAIN (TREE_TYPE (totype
)) != NULL_TREE
)
8872 error_at (loc
, "cannot bind reference of type %qH to %qI "
8873 "due to different array bounds", totype
, extype
);
8875 error_at (loc
, "binding reference of type %qH to %qI "
8876 "discards qualifiers", totype
, extype
);
8880 maybe_print_user_conv_context (convs
);
8881 maybe_inform_about_fndecl_for_bogus_argument_init (fn
, argnum
);
8883 return error_mark_node
;
8885 else if (complain
& tf_warning
)
8886 maybe_warn_array_conv (loc
, convs
, expr
);
8888 /* If necessary, create a temporary.
8890 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
8891 that need temporaries, even when their types are reference
8892 compatible with the type of reference being bound, so the
8893 upcoming call to cp_build_addr_expr doesn't fail. */
8894 if (convs
->need_temporary_p
8895 || TREE_CODE (expr
) == CONSTRUCTOR
8896 || TREE_CODE (expr
) == VA_ARG_EXPR
)
8898 /* Otherwise, a temporary of type "cv1 T1" is created and
8899 initialized from the initializer expression using the rules
8900 for a non-reference copy-initialization (8.5). */
8902 tree type
= TREE_TYPE (ref_type
);
8903 cp_lvalue_kind lvalue
= lvalue_kind (expr
);
8905 gcc_assert (similar_type_p (type
, next_conversion (convs
)->type
));
8906 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
8907 && !TYPE_REF_IS_RVALUE (ref_type
))
8909 /* If the reference is volatile or non-const, we
8910 cannot create a temporary. */
8911 if (complain
& tf_error
)
8913 if (lvalue
& clk_bitfield
)
8914 error_at (loc
, "cannot bind bit-field %qE to %qT",
8916 else if (lvalue
& clk_packed
)
8917 error_at (loc
, "cannot bind packed field %qE to %qT",
8920 error_at (loc
, "cannot bind rvalue %qE to %qT",
8923 return error_mark_node
;
8925 /* If the source is a packed field, and we must use a copy
8926 constructor, then building the target expr will require
8927 binding the field to the reference parameter to the
8928 copy constructor, and we'll end up with an infinite
8929 loop. If we can use a bitwise copy, then we'll be
8931 if ((lvalue
& clk_packed
)
8932 && CLASS_TYPE_P (type
)
8933 && type_has_nontrivial_copy_init (type
))
8935 error_at (loc
, "cannot bind packed field %qE to %qT",
8937 return error_mark_node
;
8939 if (lvalue
& clk_bitfield
)
8941 expr
= convert_bitfield_to_declared_type (expr
);
8942 expr
= fold_convert (type
, expr
);
8945 /* Creating &TARGET_EXPR<> in a template would break when
8946 tsubsting the expression, so use an IMPLICIT_CONV_EXPR
8947 instead. This can happen even when there's no class
8948 involved, e.g., when converting an integer to a reference
8950 if (processing_template_decl
)
8951 return build1 (IMPLICIT_CONV_EXPR
, totype
, expr
);
8952 expr
= build_target_expr_with_type (expr
, type
, complain
);
8955 /* Take the address of the thing to which we will bind the
8957 expr
= cp_build_addr_expr (expr
, complain
);
8958 if (expr
== error_mark_node
)
8959 return error_mark_node
;
8961 /* Convert it to a pointer to the type referred to by the
8962 reference. This will adjust the pointer if a derived to
8963 base conversion is being performed. */
8964 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
8966 /* Convert the pointer to the desired reference type. */
8967 return build_nop (ref_type
, expr
);
8971 return decay_conversion (expr
, complain
);
8974 /* ??? Should the address of a transaction-safe pointer point to the TM
8975 clone, and this conversion look up the primary function? */
8976 return build_nop (totype
, expr
);
8979 /* Warn about deprecated conversion if appropriate. */
8980 if (complain
& tf_warning
)
8982 string_conv_p (totype
, expr
, 1);
8983 maybe_warn_array_conv (loc
, convs
, expr
);
8989 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
8990 /*nonnull=*/false, complain
);
8991 return build_nop (totype
, expr
);
8994 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
8995 c_cast_p
, complain
);
9001 if (convs
->check_narrowing
9002 && !check_narrowing (totype
, expr
, complain
,
9003 convs
->check_narrowing_const_only
))
9004 return error_mark_node
;
9006 warning_sentinel
w (warn_zero_as_null_pointer_constant
);
9007 if (issue_conversion_warnings
)
9008 expr
= cp_convert_and_check (totype
, expr
, complain
);
9011 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
9012 expr
= TREE_OPERAND (expr
, 0);
9013 expr
= cp_convert (totype
, expr
, complain
);
9019 /* Return true if converting FROM to TO is unsafe in a template. */
9022 conv_unsafe_in_template_p (tree to
, tree from
)
9024 /* Converting classes involves TARGET_EXPR. */
9025 if (CLASS_TYPE_P (to
) || CLASS_TYPE_P (from
))
9028 /* Converting real to integer produces FIX_TRUNC_EXPR which tsubst
9030 if (SCALAR_FLOAT_TYPE_P (from
) && INTEGRAL_OR_ENUMERATION_TYPE_P (to
))
9033 /* Converting integer to real isn't a trivial conversion, either. */
9034 if (INTEGRAL_OR_ENUMERATION_TYPE_P (from
) && SCALAR_FLOAT_TYPE_P (to
))
9040 /* Wrapper for convert_like_internal that handles creating
9041 IMPLICIT_CONV_EXPR. */
9044 convert_like (conversion
*convs
, tree expr
, tree fn
, int argnum
,
9045 bool issue_conversion_warnings
, bool c_cast_p
, bool nested_p
,
9046 tsubst_flags_t complain
)
9048 /* Creating &TARGET_EXPR<> in a template breaks when substituting,
9049 and creating a CALL_EXPR in a template breaks in finish_call_expr
9050 so use an IMPLICIT_CONV_EXPR for this conversion. We would have
9051 created such codes e.g. when calling a user-defined conversion
9053 tree conv_expr
= NULL_TREE
;
9054 if (processing_template_decl
9055 && convs
->kind
!= ck_identity
9056 && conv_unsafe_in_template_p (convs
->type
, TREE_TYPE (expr
)))
9058 conv_expr
= build1 (IMPLICIT_CONV_EXPR
, convs
->type
, expr
);
9059 if (convs
->kind
!= ck_ref_bind
)
9060 conv_expr
= convert_from_reference (conv_expr
);
9063 /* Do the normal processing to give the bad_p errors. But we still
9064 need to return the IMPLICIT_CONV_EXPR, unless we're returning
9067 expr
= convert_like_internal (convs
, expr
, fn
, argnum
,
9068 issue_conversion_warnings
, c_cast_p
,
9069 nested_p
, complain
);
9070 if (expr
== error_mark_node
)
9071 return error_mark_node
;
9072 return conv_expr
? conv_expr
: expr
;
9075 /* Convenience wrapper for convert_like. */
9078 convert_like (conversion
*convs
, tree expr
, tsubst_flags_t complain
)
9080 return convert_like (convs
, expr
, NULL_TREE
, 0,
9081 /*issue_conversion_warnings=*/true,
9082 /*c_cast_p=*/false, /*nested_p=*/false, complain
);
9085 /* Convenience wrapper for convert_like. */
9088 convert_like_with_context (conversion
*convs
, tree expr
, tree fn
, int argnum
,
9089 tsubst_flags_t complain
)
9091 return convert_like (convs
, expr
, fn
, argnum
,
9092 /*issue_conversion_warnings=*/true,
9093 /*c_cast_p=*/false, /*nested_p=*/false, complain
);
9096 /* ARG is being passed to a varargs function. Perform any conversions
9097 required. Return the converted value. */
9100 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
9102 tree arg_type
= TREE_TYPE (arg
);
9103 location_t loc
= cp_expr_loc_or_input_loc (arg
);
9107 If the argument has integral or enumeration type that is subject
9108 to the integral promotions (_conv.prom_), or a floating-point
9109 type that is subject to the floating-point promotion
9110 (_conv.fpprom_), the value of the argument is converted to the
9111 promoted type before the call. */
9112 if (SCALAR_FLOAT_TYPE_P (arg_type
)
9113 && (TYPE_PRECISION (arg_type
)
9114 < TYPE_PRECISION (double_type_node
))
9115 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
))
9116 && !extended_float_type_p (arg_type
))
9118 if ((complain
& tf_warning
)
9119 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
9120 warning_at (loc
, OPT_Wdouble_promotion
,
9121 "implicit conversion from %qH to %qI when passing "
9122 "argument to function",
9123 arg_type
, double_type_node
);
9124 if (TREE_CODE (arg
) == EXCESS_PRECISION_EXPR
)
9125 arg
= TREE_OPERAND (arg
, 0);
9126 arg
= mark_rvalue_use (arg
);
9127 arg
= convert_to_real_nofold (double_type_node
, arg
);
9129 else if (NULLPTR_TYPE_P (arg_type
))
9131 arg
= mark_rvalue_use (arg
);
9132 if (TREE_SIDE_EFFECTS (arg
))
9134 warning_sentinel
w(warn_unused_result
);
9135 arg
= cp_build_compound_expr (arg
, null_pointer_node
, complain
);
9138 arg
= null_pointer_node
;
9140 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
9142 if (SCOPED_ENUM_P (arg_type
))
9144 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
9146 prom
= cp_perform_integral_promotions (prom
, complain
);
9147 if (abi_version_crosses (6)
9148 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
9149 && (complain
& tf_warning
))
9150 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through %<...%>"
9151 " as %qT before %<-fabi-version=6%>, %qT after",
9153 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
9154 if (!abi_version_at_least (6))
9158 arg
= cp_perform_integral_promotions (arg
, complain
);
9163 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
9164 standard conversions are performed. */
9165 arg
= decay_conversion (arg
, complain
);
9167 arg
= require_complete_type (arg
, complain
);
9168 arg_type
= TREE_TYPE (arg
);
9170 if (arg
!= error_mark_node
9171 /* In a template (or ill-formed code), we can have an incomplete type
9172 even after require_complete_type, in which case we don't know
9173 whether it has trivial copy or not. */
9174 && COMPLETE_TYPE_P (arg_type
)
9175 && !cp_unevaluated_operand
)
9177 /* [expr.call] 5.2.2/7:
9178 Passing a potentially-evaluated argument of class type (Clause 9)
9179 with a non-trivial copy constructor or a non-trivial destructor
9180 with no corresponding parameter is conditionally-supported, with
9181 implementation-defined semantics.
9183 We support it as pass-by-invisible-reference, just like a normal
9186 If the call appears in the context of a sizeof expression,
9187 it is not potentially-evaluated. */
9188 if (type_has_nontrivial_copy_init (arg_type
)
9189 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
))
9191 arg
= force_rvalue (arg
, complain
);
9192 if (complain
& tf_warning
)
9193 warning (OPT_Wconditionally_supported
,
9194 "passing objects of non-trivially-copyable "
9195 "type %q#T through %<...%> is conditionally supported",
9197 return build1 (ADDR_EXPR
, build_reference_type (arg_type
), arg
);
9199 /* Build up a real lvalue-to-rvalue conversion in case the
9200 copy constructor is trivial but not callable. */
9201 else if (CLASS_TYPE_P (arg_type
))
9202 force_rvalue (arg
, complain
);
9209 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
9212 build_x_va_arg (location_t loc
, tree expr
, tree type
)
9214 if (processing_template_decl
)
9216 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
9217 SET_EXPR_LOCATION (r
, loc
);
9221 type
= complete_type_or_else (type
, NULL_TREE
);
9223 if (expr
== error_mark_node
|| !type
)
9224 return error_mark_node
;
9226 expr
= mark_lvalue_use (expr
);
9228 if (TYPE_REF_P (type
))
9230 error ("cannot receive reference type %qT through %<...%>", type
);
9231 return error_mark_node
;
9234 if (type_has_nontrivial_copy_init (type
)
9235 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9237 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
9238 it as pass by invisible reference. */
9239 warning_at (loc
, OPT_Wconditionally_supported
,
9240 "receiving objects of non-trivially-copyable type %q#T "
9241 "through %<...%> is conditionally-supported", type
);
9243 tree ref
= cp_build_reference_type (type
, false);
9244 expr
= build_va_arg (loc
, expr
, ref
);
9245 return convert_from_reference (expr
);
9248 tree ret
= build_va_arg (loc
, expr
, type
);
9249 if (CLASS_TYPE_P (type
))
9250 /* Wrap the VA_ARG_EXPR in a TARGET_EXPR now so other code doesn't need to
9251 know how to handle it. */
9252 ret
= get_target_expr (ret
);
9256 /* TYPE has been given to va_arg. Apply the default conversions which
9257 would have happened when passed via ellipsis. Return the promoted
9258 type, or the passed type if there is no change. */
9261 cxx_type_promotes_to (tree type
)
9265 /* Perform the array-to-pointer and function-to-pointer
9267 type
= type_decays_to (type
);
9269 promote
= type_promotes_to (type
);
9270 if (same_type_p (type
, promote
))
9276 /* ARG is a default argument expression being passed to a parameter of
9277 the indicated TYPE, which is a parameter to FN. PARMNUM is the
9278 zero-based argument number. Do any required conversions. Return
9279 the converted value. */
9281 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
9283 push_defarg_context (tree fn
)
9284 { vec_safe_push (default_arg_context
, fn
); }
9287 pop_defarg_context (void)
9288 { default_arg_context
->pop (); }
9291 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
9292 tsubst_flags_t complain
)
9297 /* See through clones. */
9298 fn
= DECL_ORIGIN (fn
);
9299 /* And inheriting ctors. */
9300 if (flag_new_inheriting_ctors
)
9301 fn
= strip_inheriting_ctors (fn
);
9303 /* Detect recursion. */
9304 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
9307 if (complain
& tf_error
)
9308 error ("recursive evaluation of default argument for %q#D", fn
);
9309 return error_mark_node
;
9312 /* If the ARG is an unparsed default argument expression, the
9313 conversion cannot be performed. */
9314 if (TREE_CODE (arg
) == DEFERRED_PARSE
)
9316 if (complain
& tf_error
)
9317 error ("call to %qD uses the default argument for parameter %P, which "
9318 "is not yet defined", fn
, parmnum
);
9319 return error_mark_node
;
9322 push_defarg_context (fn
);
9324 if (fn
&& DECL_TEMPLATE_INFO (fn
))
9325 arg
= tsubst_default_argument (fn
, parmnum
, type
, arg
, complain
);
9331 The names in the expression are bound, and the semantic
9332 constraints are checked, at the point where the default
9333 expressions appears.
9335 we must not perform access checks here. */
9336 push_deferring_access_checks (dk_no_check
);
9337 /* We must make a copy of ARG, in case subsequent processing
9338 alters any part of it. */
9339 arg
= break_out_target_exprs (arg
, /*clear location*/true);
9341 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
9342 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
9344 arg
= convert_for_arg_passing (type
, arg
, complain
);
9345 pop_deferring_access_checks();
9347 pop_defarg_context ();
9352 /* Returns the type which will really be used for passing an argument of
9356 type_passed_as (tree type
)
9358 /* Pass classes with copy ctors by invisible reference. */
9359 if (TREE_ADDRESSABLE (type
))
9360 type
= build_reference_type (type
);
9361 else if (targetm
.calls
.promote_prototypes (NULL_TREE
)
9362 && INTEGRAL_TYPE_P (type
)
9363 && COMPLETE_TYPE_P (type
)
9364 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
9365 type
= integer_type_node
;
9370 /* Actually perform the appropriate conversion. */
9373 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
9377 /* If VAL is a bitfield, then -- since it has already been converted
9378 to TYPE -- it cannot have a precision greater than TYPE.
9380 If it has a smaller precision, we must widen it here. For
9381 example, passing "int f:3;" to a function expecting an "int" will
9382 not result in any conversion before this point.
9384 If the precision is the same we must not risk widening. For
9385 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
9386 often have type "int", even though the C++ type for the field is
9387 "long long". If the value is being passed to a function
9388 expecting an "int", then no conversions will be required. But,
9389 if we call convert_bitfield_to_declared_type, the bitfield will
9390 be converted to "long long". */
9391 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
9393 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
9394 val
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
), val
);
9396 if (val
== error_mark_node
)
9398 /* Pass classes with copy ctors by invisible reference. */
9399 else if (TREE_ADDRESSABLE (type
))
9400 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
9401 else if (targetm
.calls
.promote_prototypes (NULL_TREE
)
9402 && INTEGRAL_TYPE_P (type
)
9403 && COMPLETE_TYPE_P (type
)
9404 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
9405 val
= cp_perform_integral_promotions (val
, complain
);
9406 if (complain
& tf_warning
)
9408 if (warn_suggest_attribute_format
)
9410 tree rhstype
= TREE_TYPE (val
);
9411 const enum tree_code coder
= TREE_CODE (rhstype
);
9412 const enum tree_code codel
= TREE_CODE (type
);
9413 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
9415 && check_missing_format_attribute (type
, rhstype
))
9416 warning (OPT_Wsuggest_attribute_format
,
9417 "argument of function call might be a candidate "
9418 "for a format attribute");
9420 maybe_warn_parm_abi (type
, cp_expr_loc_or_input_loc (val
));
9423 if (complain
& tf_warning
)
9424 warn_for_address_of_packed_member (type
, val
);
9429 /* Returns non-zero iff FN is a function with magic varargs, i.e. ones for
9430 which just decay_conversion or no conversions at all should be done.
9431 This is true for some builtins which don't act like normal functions.
9432 Return 2 if just decay_conversion and removal of excess precision should
9433 be done, 1 if just decay_conversion. Return 3 for special treatment of
9434 the 3rd argument for __builtin_*_overflow_p. Return 4 for special
9435 treatment of the 1st argument for
9436 __builtin_{clz,ctz,clrsb,ffs,parity,popcount}g. */
9439 magic_varargs_p (tree fn
)
9441 if (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
9442 switch (DECL_FUNCTION_CODE (fn
))
9444 case BUILT_IN_CLASSIFY_TYPE
:
9445 case BUILT_IN_CONSTANT_P
:
9446 case BUILT_IN_NEXT_ARG
:
9447 case BUILT_IN_VA_START
:
9450 case BUILT_IN_ADD_OVERFLOW_P
:
9451 case BUILT_IN_SUB_OVERFLOW_P
:
9452 case BUILT_IN_MUL_OVERFLOW_P
:
9455 case BUILT_IN_ISFINITE
:
9456 case BUILT_IN_ISINF
:
9457 case BUILT_IN_ISINF_SIGN
:
9458 case BUILT_IN_ISNAN
:
9459 case BUILT_IN_ISNORMAL
:
9460 case BUILT_IN_FPCLASSIFY
:
9465 case BUILT_IN_CLRSBG
:
9467 case BUILT_IN_PARITYG
:
9468 case BUILT_IN_POPCOUNTG
:
9472 return lookup_attribute ("type generic",
9473 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
9479 /* Returns the decl of the dispatcher function if FN is a function version. */
9482 get_function_version_dispatcher (tree fn
)
9484 tree dispatcher_decl
= NULL
;
9486 if (DECL_LOCAL_DECL_P (fn
))
9487 fn
= DECL_LOCAL_DECL_ALIAS (fn
);
9489 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
9490 && DECL_FUNCTION_VERSIONED (fn
));
9492 gcc_assert (targetm
.get_function_versions_dispatcher
);
9493 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
9495 if (dispatcher_decl
== NULL
)
9497 error_at (input_location
, "use of multiversioned function "
9498 "without a default");
9502 retrofit_lang_decl (dispatcher_decl
);
9503 gcc_assert (dispatcher_decl
!= NULL
);
9504 return dispatcher_decl
;
9507 /* fn is a function version dispatcher that is marked used. Mark all the
9508 semantically identical function versions it will dispatch as used. */
9511 mark_versions_used (tree fn
)
9513 struct cgraph_node
*node
;
9514 struct cgraph_function_version_info
*node_v
;
9515 struct cgraph_function_version_info
*it_v
;
9517 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
9519 node
= cgraph_node::get (fn
);
9523 gcc_assert (node
->dispatcher_function
);
9525 node_v
= node
->function_version ();
9529 /* All semantically identical versions are chained. Traverse and mark each
9530 one of them as used. */
9531 it_v
= node_v
->next
;
9532 while (it_v
!= NULL
)
9534 mark_used (it_v
->this_node
->decl
);
9539 /* Build a call to "the copy constructor" for the type of A, even if it
9540 wouldn't be selected by normal overload resolution. Used for
9544 call_copy_ctor (tree a
, tsubst_flags_t complain
)
9546 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
9547 tree binfo
= TYPE_BINFO (ctype
);
9548 tree copy
= get_copy_ctor (ctype
, complain
);
9549 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
9550 tree ob
= build_dummy_object (ctype
);
9551 releasing_vec
args (make_tree_vector_single (a
));
9552 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
9553 LOOKUP_NORMAL
, NULL
, complain
);
9557 /* Return the base constructor corresponding to COMPLETE_CTOR or NULL_TREE. */
9560 base_ctor_for (tree complete_ctor
)
9563 FOR_EACH_CLONE (clone
, DECL_CLONED_FUNCTION (complete_ctor
))
9564 if (DECL_BASE_CONSTRUCTOR_P (clone
))
9569 /* Try to make EXP suitable to be used as the initializer for a base subobject,
9570 and return whether we were successful. EXP must have already been cleared
9571 by unsafe_copy_elision_p{,_opt}. */
9574 make_base_init_ok (tree exp
)
9576 if (TREE_CODE (exp
) == TARGET_EXPR
)
9577 exp
= TARGET_EXPR_INITIAL (exp
);
9578 while (TREE_CODE (exp
) == COMPOUND_EXPR
)
9579 exp
= TREE_OPERAND (exp
, 1);
9580 if (TREE_CODE (exp
) == COND_EXPR
)
9582 bool ret
= make_base_init_ok (TREE_OPERAND (exp
, 2));
9583 if (tree op1
= TREE_OPERAND (exp
, 1))
9585 bool r1
= make_base_init_ok (op1
);
9586 /* If unsafe_copy_elision_p was false, the arms should match. */
9587 gcc_assert (r1
== ret
);
9591 if (TREE_CODE (exp
) != AGGR_INIT_EXPR
)
9592 /* A trivial copy is OK. */
9594 if (!AGGR_INIT_VIA_CTOR_P (exp
))
9595 /* unsafe_copy_elision_p_opt must have said this is OK. */
9597 tree fn
= cp_get_callee_fndecl_nofold (exp
);
9598 if (DECL_BASE_CONSTRUCTOR_P (fn
))
9600 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (fn
));
9601 fn
= base_ctor_for (fn
);
9602 if (!fn
|| DECL_HAS_VTT_PARM_P (fn
))
9603 /* The base constructor has more parameters, so we can't just change the
9604 call target. It would be possible to splice in the appropriate
9605 arguments, but probably not worth the complexity. */
9608 AGGR_INIT_EXPR_FN (exp
) = build_address (fn
);
9612 /* Return 2 if T refers to a base, 1 if a potentially-overlapping field,
9613 neither of which can be used for return by invisible reference. We avoid
9614 doing C++17 mandatory copy elision for either of these cases.
9616 This returns non-zero even if the type of T has no tail padding that other
9617 data could be allocated into, because that depends on the particular ABI.
9618 unsafe_copy_elision_p_opt does consider whether there is padding. */
9621 unsafe_return_slot_p (tree t
)
9623 /* Check empty bases separately, they don't have fields. */
9624 if (is_empty_base_ref (t
))
9627 /* A delegating constructor might be used to initialize a base. */
9628 if (current_function_decl
9629 && DECL_CONSTRUCTOR_P (current_function_decl
)
9630 && (t
== current_class_ref
9631 || tree_strip_nop_conversions (t
) == current_class_ptr
))
9635 if (TREE_CODE (t
) == ADDR_EXPR
)
9636 t
= TREE_OPERAND (t
, 0);
9637 if (TREE_CODE (t
) == COMPONENT_REF
)
9638 t
= TREE_OPERAND (t
, 1);
9639 if (TREE_CODE (t
) != FIELD_DECL
)
9641 if (!CLASS_TYPE_P (TREE_TYPE (t
)))
9642 /* The middle-end will do the right thing for scalar types. */
9644 if (DECL_FIELD_IS_BASE (t
))
9646 if (lookup_attribute ("no_unique_address", DECL_ATTRIBUTES (t
)))
9651 /* True IFF EXP is a prvalue that represents return by invisible reference. */
9654 init_by_return_slot_p (tree exp
)
9656 /* Copy elision only happens with a TARGET_EXPR. */
9657 if (TREE_CODE (exp
) != TARGET_EXPR
)
9659 tree init
= TARGET_EXPR_INITIAL (exp
);
9660 /* build_compound_expr pushes COMPOUND_EXPR inside TARGET_EXPR. */
9661 while (TREE_CODE (init
) == COMPOUND_EXPR
)
9662 init
= TREE_OPERAND (init
, 1);
9663 if (TREE_CODE (init
) == COND_EXPR
)
9665 /* We'll end up copying from each of the arms of the COND_EXPR directly
9666 into the target, so look at them. */
9667 if (tree op
= TREE_OPERAND (init
, 1))
9668 if (init_by_return_slot_p (op
))
9670 return init_by_return_slot_p (TREE_OPERAND (init
, 2));
9672 return (TREE_CODE (init
) == AGGR_INIT_EXPR
9673 && !AGGR_INIT_VIA_CTOR_P (init
));
9676 /* We can't elide a copy from a function returning by value to a
9677 potentially-overlapping subobject, as the callee might clobber tail padding.
9678 Return true iff this could be that case.
9680 Places that use this function (or _opt) to decide to elide a copy should
9681 probably use make_safe_copy_elision instead. */
9684 unsafe_copy_elision_p (tree target
, tree exp
)
9686 return unsafe_return_slot_p (target
) && init_by_return_slot_p (exp
);
9689 /* As above, but for optimization allow more cases that are actually safe. */
9692 unsafe_copy_elision_p_opt (tree target
, tree exp
)
9694 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
9695 /* It's safe to elide the copy for a class with no tail padding. */
9696 if (!is_empty_class (type
)
9697 && tree_int_cst_equal (TYPE_SIZE (type
), CLASSTYPE_SIZE (type
)))
9699 return unsafe_copy_elision_p (target
, exp
);
9702 /* Try to make EXP suitable to be used as the initializer for TARGET,
9703 and return whether we were successful. */
9706 make_safe_copy_elision (tree target
, tree exp
)
9708 int uns
= unsafe_return_slot_p (target
);
9711 if (init_by_return_slot_p (exp
))
9715 return make_base_init_ok (exp
);
9718 /* True IFF the result of the conversion C is a prvalue. */
9721 conv_is_prvalue (conversion
*c
)
9723 if (c
->kind
== ck_rvalue
)
9725 if (c
->kind
== ck_base
&& c
->need_temporary_p
)
9727 if (c
->kind
== ck_user
&& !TYPE_REF_P (c
->type
))
9729 if (c
->kind
== ck_identity
&& c
->u
.expr
9730 && TREE_CODE (c
->u
.expr
) == TARGET_EXPR
)
9736 /* True iff C is a conversion that binds a reference to a prvalue. */
9739 conv_binds_ref_to_prvalue (conversion
*c
)
9741 if (c
->kind
!= ck_ref_bind
)
9743 if (c
->need_temporary_p
)
9746 return conv_is_prvalue (next_conversion (c
));
9749 /* True iff EXPR represents a (subobject of a) temporary. */
9752 expr_represents_temporary_p (tree expr
)
9754 while (handled_component_p (expr
))
9755 expr
= TREE_OPERAND (expr
, 0);
9756 return TREE_CODE (expr
) == TARGET_EXPR
;
9759 /* True iff C is a conversion that binds a reference to a temporary.
9760 This is a superset of conv_binds_ref_to_prvalue: here we're also
9761 interested in xvalues. */
9764 conv_binds_ref_to_temporary (conversion
*c
)
9766 if (conv_binds_ref_to_prvalue (c
))
9768 if (c
->kind
!= ck_ref_bind
)
9770 c
= next_conversion (c
);
9771 /* This is the case for
9773 struct Derived : Base {};
9774 const Base& b(Derived{});
9775 where we bind 'b' to the Base subobject of a temporary object of type
9776 Derived. The subobject is an xvalue; the whole object is a prvalue.
9778 The ck_base doesn't have to be present for cases like X{}.m. */
9779 if (c
->kind
== ck_base
)
9780 c
= next_conversion (c
);
9781 if (c
->kind
== ck_identity
&& c
->u
.expr
9782 && expr_represents_temporary_p (c
->u
.expr
))
9787 /* Return tristate::TS_TRUE if converting EXPR to a reference type TYPE binds
9788 the reference to a temporary. Return tristate::TS_FALSE if converting
9789 EXPR to a reference type TYPE doesn't bind the reference to a temporary. If
9790 the conversion is invalid or bad, return tristate::TS_UNKNOWN. DIRECT_INIT_P
9791 says whether the conversion should be done in direct- or copy-initialization
9795 ref_conv_binds_to_temporary (tree type
, tree expr
, bool direct_init_p
/*=false*/)
9797 gcc_assert (TYPE_REF_P (type
));
9799 conversion_obstack_sentinel cos
;
9801 const int flags
= direct_init_p
? LOOKUP_NORMAL
: LOOKUP_IMPLICIT
;
9802 conversion
*conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9803 /*c_cast_p=*/false, flags
, tf_none
);
9804 tristate
ret (tristate::TS_UNKNOWN
);
9805 if (conv
&& !conv
->bad_p
)
9806 ret
= tristate (conv_binds_ref_to_temporary (conv
));
9811 /* Call the trivial destructor for INSTANCE, which can be either an lvalue of
9812 class type or a pointer to class type. If NO_PTR_DEREF is true and
9813 INSTANCE has pointer type, clobber the pointer rather than what it points
9817 build_trivial_dtor_call (tree instance
, bool no_ptr_deref
)
9819 gcc_assert (!is_dummy_object (instance
));
9821 if (!flag_lifetime_dse
)
9824 return fold_convert (void_type_node
, instance
);
9827 if (INDIRECT_TYPE_P (TREE_TYPE (instance
))
9828 && (!no_ptr_deref
|| TYPE_REF_P (TREE_TYPE (instance
))))
9830 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (instance
))))
9832 instance
= cp_build_fold_indirect_ref (instance
);
9835 /* A trivial destructor should still clobber the object. */
9836 tree clobber
= build_clobber (TREE_TYPE (instance
), CLOBBER_OBJECT_END
);
9837 return build2 (MODIFY_EXPR
, void_type_node
,
9841 /* Return true if in an immediate function context, or an unevaluated operand,
9842 or a default argument/member initializer, or a subexpression of an immediate
9846 in_immediate_context ()
9848 return (cp_unevaluated_operand
!= 0
9849 || (current_function_decl
!= NULL_TREE
9850 && DECL_IMMEDIATE_FUNCTION_P (current_function_decl
))
9851 /* DR 2631: default args and DMI aren't immediately evaluated.
9852 Return true here so immediate_invocation_p returns false. */
9853 || current_binding_level
->kind
== sk_function_parms
9854 || current_binding_level
->kind
== sk_template_parms
9856 || in_consteval_if_p
);
9859 /* Return true if a call to FN with number of arguments NARGS
9860 is an immediate invocation. */
9863 immediate_invocation_p (tree fn
)
9865 return (TREE_CODE (fn
) == FUNCTION_DECL
9866 && DECL_IMMEDIATE_FUNCTION_P (fn
)
9867 && !in_immediate_context ());
9870 /* Subroutine of the various build_*_call functions. Overload resolution
9871 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
9872 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
9873 bitmask of various LOOKUP_* flags which apply to the call itself. */
9876 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
9879 const vec
<tree
, va_gc
> *args
= cand
->args
;
9880 tree first_arg
= cand
->first_arg
;
9881 conversion
**convs
= cand
->convs
;
9882 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
9887 bool already_used
= false;
9889 /* In a template, there is no need to perform all of the work that
9890 is normally done. We are only interested in the type of the call
9891 expression, i.e., the return type of the function. Any semantic
9892 errors will be deferred until the template is instantiated. */
9893 if (processing_template_decl
)
9895 if (undeduced_auto_decl (fn
))
9896 mark_used (fn
, complain
);
9898 /* Otherwise set TREE_USED for the benefit of -Wunused-function.
9902 tree return_type
= TREE_TYPE (TREE_TYPE (fn
));
9904 if (first_arg
== NULL_TREE
)
9906 callee
= build_addr_func (fn
, complain
);
9907 if (callee
== error_mark_node
)
9908 return error_mark_node
;
9912 callee
= build_baselink (cand
->conversion_path
, cand
->access_path
,
9914 callee
= build_min (COMPONENT_REF
, TREE_TYPE (fn
),
9915 first_arg
, callee
, NULL_TREE
);
9918 tree expr
= build_call_vec (return_type
, callee
, args
);
9919 SET_EXPR_LOCATION (expr
, input_location
);
9920 if (TREE_THIS_VOLATILE (fn
) && cfun
)
9921 current_function_returns_abnormally
= 1;
9922 if (immediate_invocation_p (fn
))
9924 tree obj_arg
= NULL_TREE
, exprimm
= expr
;
9925 if (DECL_CONSTRUCTOR_P (fn
))
9926 obj_arg
= first_arg
;
9928 && is_dummy_object (obj_arg
)
9929 && !type_dependent_expression_p (obj_arg
))
9931 exprimm
= build_cplus_new (DECL_CONTEXT (fn
), expr
, complain
);
9932 obj_arg
= NULL_TREE
;
9934 /* Look through *(const T *)&obj. */
9935 else if (obj_arg
&& INDIRECT_REF_P (obj_arg
))
9937 tree addr
= TREE_OPERAND (obj_arg
, 0);
9939 if (TREE_CODE (addr
) == ADDR_EXPR
)
9941 tree typeo
= TREE_TYPE (obj_arg
);
9942 tree typei
= TREE_TYPE (TREE_OPERAND (addr
, 0));
9943 if (same_type_ignoring_top_level_qualifiers_p (typeo
, typei
))
9944 obj_arg
= TREE_OPERAND (addr
, 0);
9947 fold_non_dependent_expr (exprimm
, complain
,
9948 /*manifestly_const_eval=*/true,
9951 return convert_from_reference (expr
);
9954 /* Give any warnings we noticed during overload resolution. */
9955 if (cand
->warnings
&& (complain
& tf_warning
))
9957 struct candidate_warning
*w
;
9958 for (w
= cand
->warnings
; w
; w
= w
->next
)
9959 joust (cand
, w
->loser
, 1, complain
);
9962 /* Core issue 2327: P0135 doesn't say how to handle the case where the
9963 argument to the copy constructor ends up being a prvalue after
9964 conversion. Let's do the normal processing, but pretend we aren't
9965 actually using the copy constructor. */
9966 bool force_elide
= false;
9967 if (cxx_dialect
>= cxx17
9968 && cand
->num_convs
== 1
9969 && DECL_COMPLETE_CONSTRUCTOR_P (fn
)
9970 && (DECL_COPY_CONSTRUCTOR_P (fn
)
9971 || DECL_MOVE_CONSTRUCTOR_P (fn
))
9972 && !unsafe_return_slot_p (first_arg
)
9973 && conv_binds_ref_to_prvalue (convs
[0]))
9976 goto not_really_used
;
9979 /* OK, we're actually calling this inherited constructor; set its deletedness
9980 appropriately. We can get away with doing this here because calling is
9981 the only way to refer to a constructor. */
9982 if (DECL_INHERITED_CTOR (fn
)
9983 && !deduce_inheriting_ctor (fn
))
9985 if (complain
& tf_error
)
9987 return error_mark_node
;
9990 /* Make =delete work with SFINAE. */
9991 if (DECL_DELETED_FN (fn
))
9993 if (complain
& tf_error
)
9998 if (flag_diagnostics_all_candidates
)
9999 print_z_candidates (input_location
, cand
, /*only_viable_p=*/false);
10001 inform (input_location
,
10002 "use %<-fdiagnostics-all-candidates%> to display "
10003 "considered candidates");
10006 return error_mark_node
;
10009 if (DECL_FUNCTION_MEMBER_P (fn
))
10012 /* If FN is a template function, two cases must be considered.
10017 template <class T> void f();
10019 template <class T> struct B {
10023 struct C : A, B<int> {
10025 using B<int>::g; // #2
10028 In case #1 where `A::f' is a member template, DECL_ACCESS is
10029 recorded in the primary template but not in its specialization.
10030 We check access of FN using its primary template.
10032 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
10033 because it is a member of class template B, DECL_ACCESS is
10034 recorded in the specialization `B<int>::g'. We cannot use its
10035 primary template because `B<T>::g' and `B<int>::g' may have
10036 different access. */
10037 if (DECL_TEMPLATE_INFO (fn
)
10038 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
10039 access_fn
= DECL_TI_TEMPLATE (fn
);
10042 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
10044 return error_mark_node
;
10047 /* If we're checking for implicit delete, don't bother with argument
10049 if (flags
& LOOKUP_SPECULATIVE
)
10051 if (cand
->viable
== 1)
10053 else if (!(complain
& tf_error
))
10054 /* Reject bad conversions now. */
10055 return error_mark_node
;
10056 /* else continue to get conversion error. */
10061 /* N3276 magic doesn't apply to nested calls. */
10062 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
10063 complain
&= ~tf_decltype
;
10064 /* No-Cleanup doesn't apply to nested calls either. */
10065 tsubst_flags_t no_cleanup_complain
= complain
;
10066 complain
&= ~tf_no_cleanup
;
10068 /* Find maximum size of vector to hold converted arguments. */
10069 parmlen
= list_length (parm
);
10070 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
10071 if (parmlen
> nargs
)
10073 argarray
= XALLOCAVEC (tree
, nargs
);
10075 in_consteval_if_p_temp_override icip
;
10076 /* If the call is immediate function invocation, make sure
10077 taking address of immediate functions is allowed in its arguments. */
10078 if (immediate_invocation_p (STRIP_TEMPLATE (fn
)))
10079 in_consteval_if_p
= true;
10081 int argarray_size
= 0;
10082 unsigned int arg_index
= 0;
10083 int conv_index
= 0;
10084 int param_index
= 0;
10086 auto consume_object_arg
= [&arg_index
, &first_arg
, args
]()
10089 return (*args
)[arg_index
++];
10090 tree object_arg
= first_arg
;
10091 first_arg
= NULL_TREE
;
10095 /* The implicit parameters to a constructor are not considered by overload
10096 resolution, and must be of the proper type. */
10097 if (DECL_CONSTRUCTOR_P (fn
))
10099 tree object_arg
= consume_object_arg ();
10100 argarray
[argarray_size
++] = build_this (object_arg
);
10101 parm
= TREE_CHAIN (parm
);
10102 /* We should never try to call the abstract constructor. */
10103 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
10105 if (DECL_HAS_VTT_PARM_P (fn
))
10107 argarray
[argarray_size
++] = (*args
)[arg_index
];
10109 parm
= TREE_CHAIN (parm
);
10112 /* Bypass access control for 'this' parameter. */
10113 else if (DECL_IOBJ_MEMBER_FUNCTION_P (fn
))
10115 tree arg
= build_this (consume_object_arg ());
10116 tree argtype
= TREE_TYPE (arg
);
10118 if (arg
== error_mark_node
)
10119 return error_mark_node
;
10120 if (convs
[conv_index
++]->bad_p
)
10122 if (complain
& tf_error
)
10124 auto_diagnostic_group d
;
10125 if (permerror (input_location
, "passing %qT as %<this%> "
10126 "argument discards qualifiers",
10127 TREE_TYPE (argtype
)))
10128 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
10131 return error_mark_node
;
10134 /* The class where FN is defined. */
10135 tree ctx
= DECL_CONTEXT (fn
);
10137 /* See if the function member or the whole class type is declared
10138 final and the call can be devirtualized. */
10139 if (DECL_FINAL_P (fn
) || CLASSTYPE_FINAL (ctx
))
10140 flags
|= LOOKUP_NONVIRTUAL
;
10142 /* [class.mfct.non-static]: If a non-static member function of a class
10143 X is called for an object that is not of type X, or of a type
10144 derived from X, the behavior is undefined.
10146 So we can assume that anything passed as 'this' is non-null, and
10147 optimize accordingly. */
10148 /* Check that the base class is accessible. */
10149 if (!accessible_base_p (TREE_TYPE (argtype
),
10150 BINFO_TYPE (cand
->conversion_path
), true))
10152 if (complain
& tf_error
)
10153 error ("%qT is not an accessible base of %qT",
10154 BINFO_TYPE (cand
->conversion_path
),
10155 TREE_TYPE (argtype
));
10157 return error_mark_node
;
10159 /* If fn was found by a using declaration, the conversion path
10160 will be to the derived class, not the base declaring fn. We
10161 must convert to the base. */
10162 tree base_binfo
= cand
->conversion_path
;
10163 if (BINFO_TYPE (base_binfo
) != ctx
)
10165 base_binfo
= lookup_base (base_binfo
, ctx
, ba_unique
, NULL
, complain
);
10166 if (base_binfo
== error_mark_node
)
10167 return error_mark_node
;
10170 /* If we know the dynamic type of the object, look up the final overrider
10172 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
10173 && resolves_to_fixed_type_p (arg
))
10175 tree ov
= lookup_vfn_in_binfo (DECL_VINDEX (fn
), base_binfo
);
10177 /* And unwind base_binfo to match. If we don't find the type we're
10178 looking for in BINFO_INHERITANCE_CHAIN, we're looking at diamond
10179 inheritance; for now do a normal virtual call in that case. */
10180 tree octx
= DECL_CONTEXT (ov
);
10181 tree obinfo
= base_binfo
;
10182 while (obinfo
&& !SAME_BINFO_TYPE_P (BINFO_TYPE (obinfo
), octx
))
10183 obinfo
= BINFO_INHERITANCE_CHAIN (obinfo
);
10187 base_binfo
= obinfo
;
10188 flags
|= LOOKUP_NONVIRTUAL
;
10192 tree converted_arg
= build_base_path (PLUS_EXPR
, arg
,
10193 base_binfo
, 1, complain
);
10195 argarray
[argarray_size
++] = converted_arg
;
10196 parm
= TREE_CHAIN (parm
);
10199 auto handle_arg
= [fn
, flags
](tree type
,
10201 int const param_index
,
10203 tsubst_flags_t
const arg_complain
)
10205 /* Set user_conv_p on the argument conversions, so rvalue/base handling
10206 knows not to allow any more UDCs. This needs to happen after we
10207 process cand->warnings. */
10208 if (flags
& LOOKUP_NO_CONVERSION
)
10209 conv
->user_conv_p
= true;
10211 if (arg_complain
& tf_warning
)
10212 maybe_warn_pessimizing_move (arg
, type
, /*return_p=*/false);
10214 tree val
= convert_like_with_context (conv
, arg
, fn
,
10215 param_index
, arg_complain
);
10216 val
= convert_for_arg_passing (type
, val
, arg_complain
);
10220 if (DECL_XOBJ_MEMBER_FUNCTION_P (fn
))
10222 gcc_assert (cand
->num_convs
> 0);
10223 tree object_arg
= consume_object_arg ();
10224 val
= handle_arg (TREE_VALUE (parm
),
10227 convs
[conv_index
++],
10230 if (val
== error_mark_node
)
10231 return error_mark_node
;
10233 argarray
[argarray_size
++] = val
;
10234 parm
= TREE_CHAIN (parm
);
10237 gcc_assert (first_arg
== NULL_TREE
);
10238 for (; arg_index
< vec_safe_length (args
) && parm
;
10239 parm
= TREE_CHAIN (parm
), ++arg_index
, ++param_index
, ++conv_index
)
10241 tree current_arg
= (*args
)[arg_index
];
10243 /* If the argument is NULL and used to (implicitly) instantiate a
10244 template function (and bind one of the template arguments to
10245 the type of 'long int'), we don't want to warn about passing NULL
10246 to non-pointer argument.
10247 For example, if we have this template function:
10249 template<typename T> void func(T x) {}
10251 we want to warn (when -Wconversion is enabled) in this case:
10257 but not in this case:
10263 bool const conversion_warning
= !(null_node_p (current_arg
)
10264 && DECL_TEMPLATE_INFO (fn
)
10265 && cand
->template_decl
10266 && !cand
->explicit_targs
);
10268 tsubst_flags_t
const arg_complain
10269 = conversion_warning
? complain
: complain
& ~tf_warning
;
10271 val
= handle_arg (TREE_VALUE (parm
),
10277 if (val
== error_mark_node
)
10278 return error_mark_node
;
10280 argarray
[argarray_size
++] = val
;
10283 /* Default arguments */
10284 for (; parm
&& parm
!= void_list_node
;
10285 parm
= TREE_CHAIN (parm
), param_index
++)
10287 if (TREE_VALUE (parm
) == error_mark_node
)
10288 return error_mark_node
;
10289 val
= convert_default_arg (TREE_VALUE (parm
),
10290 TREE_PURPOSE (parm
),
10293 if (val
== error_mark_node
)
10294 return error_mark_node
;
10295 argarray
[argarray_size
++] = val
;
10299 int magic
= magic_varargs_p (fn
);
10300 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
10302 tree a
= (*args
)[arg_index
];
10303 if ((magic
== 3 && arg_index
== 2) || (magic
== 4 && arg_index
== 0))
10305 /* Do no conversions for certain magic varargs. */
10306 a
= mark_type_use (a
);
10307 if (TREE_CODE (a
) == FUNCTION_DECL
&& reject_gcc_builtin (a
))
10308 return error_mark_node
;
10310 else if (magic
!= 0)
10312 /* Don't truncate excess precision to the semantic type. */
10313 if (magic
== 1 && TREE_CODE (a
) == EXCESS_PRECISION_EXPR
)
10314 a
= TREE_OPERAND (a
, 0);
10315 /* For other magic varargs only do decay_conversion. */
10316 a
= decay_conversion (a
, complain
);
10318 else if (DECL_CONSTRUCTOR_P (fn
)
10319 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
10322 /* Avoid infinite recursion trying to call A(...). */
10323 if (complain
& tf_error
)
10324 /* Try to call the actual copy constructor for a good error. */
10325 call_copy_ctor (a
, complain
);
10326 return error_mark_node
;
10329 a
= convert_arg_to_ellipsis (a
, complain
);
10330 if (a
== error_mark_node
)
10331 return error_mark_node
;
10332 argarray
[argarray_size
++] = a
;
10335 gcc_assert (argarray_size
<= nargs
);
10336 nargs
= argarray_size
;
10339 /* Avoid performing argument transformation if warnings are disabled.
10340 When tf_warning is set and at least one of the warnings is active
10341 the check_function_arguments function might warn about something. */
10343 bool warned_p
= false;
10344 if ((complain
& tf_warning
)
10347 || warn_suggest_attribute_format
10350 tree
*fargs
= (!nargs
? argarray
10351 : (tree
*) alloca (nargs
* sizeof (tree
)));
10352 for (int j
= 0; j
< nargs
; j
++)
10354 /* For -Wformat undo the implicit passing by hidden reference
10355 done by convert_arg_to_ellipsis. */
10356 if (TREE_CODE (argarray
[j
]) == ADDR_EXPR
10357 && TYPE_REF_P (TREE_TYPE (argarray
[j
])))
10358 fargs
[j
] = TREE_OPERAND (argarray
[j
], 0);
10360 fargs
[j
] = argarray
[j
];
10363 warned_p
= check_function_arguments (input_location
, fn
, TREE_TYPE (fn
),
10364 nargs
, fargs
, NULL
);
10367 if (DECL_INHERITED_CTOR (fn
))
10369 /* Check for passing ellipsis arguments to an inherited constructor. We
10370 could handle this by open-coding the inherited constructor rather than
10371 defining it, but let's not bother now. */
10372 if (!cp_unevaluated_operand
10374 && cand
->convs
[cand
->num_convs
-1]->ellipsis_p
)
10376 if (complain
& tf_error
)
10378 sorry ("passing arguments to ellipsis of inherited constructor "
10380 inform (DECL_SOURCE_LOCATION (cand
->fn
), "declared here");
10382 return error_mark_node
;
10385 /* A base constructor inheriting from a virtual base doesn't get the
10386 inherited arguments, just this and __vtt. */
10387 if (ctor_omit_inherited_parms (fn
))
10391 /* Avoid actually calling copy constructors and copy assignment operators,
10395 && (!flag_elide_constructors
10396 /* It's unsafe to elide the operation when handling
10397 a noexcept-expression, it may evaluate to the wrong
10398 value (c++/53025, c++/96090). */
10399 || cp_noexcept_operand
!= 0))
10400 /* Do things the hard way. */;
10401 else if (cand
->num_convs
== 1
10402 && (DECL_COPY_CONSTRUCTOR_P (fn
)
10403 || DECL_MOVE_CONSTRUCTOR_P (fn
)))
10406 tree arg
= argarray
[num_artificial_parms_for (fn
)];
10407 tree fa
= argarray
[0];
10408 bool trivial
= trivial_fn_p (fn
);
10410 /* Pull out the real argument, disregarding const-correctness. */
10412 /* Strip the reference binding for the constructor parameter. */
10413 if (CONVERT_EXPR_P (targ
)
10414 && TYPE_REF_P (TREE_TYPE (targ
)))
10415 targ
= TREE_OPERAND (targ
, 0);
10416 /* But don't strip any other reference bindings; binding a temporary to a
10417 reference prevents copy elision. */
10418 while ((CONVERT_EXPR_P (targ
)
10419 && !TYPE_REF_P (TREE_TYPE (targ
)))
10420 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
10421 targ
= TREE_OPERAND (targ
, 0);
10422 if (TREE_CODE (targ
) == ADDR_EXPR
)
10424 targ
= TREE_OPERAND (targ
, 0);
10425 if (!same_type_ignoring_top_level_qualifiers_p
10426 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
10435 arg
= cp_build_fold_indirect_ref (arg
);
10437 /* In C++17 we shouldn't be copying a TARGET_EXPR except into a
10438 potentially-overlapping subobject. */
10439 if (CHECKING_P
&& cxx_dialect
>= cxx17
)
10440 gcc_assert (TREE_CODE (arg
) != TARGET_EXPR
10442 /* It's from binding the ref parm to a packed field. */
10443 || convs
[0]->need_temporary_p
10445 /* See unsafe_copy_elision_p. */
10446 || unsafe_return_slot_p (fa
));
10448 bool unsafe
= unsafe_copy_elision_p_opt (fa
, arg
);
10449 bool eliding_temp
= (TREE_CODE (arg
) == TARGET_EXPR
&& !unsafe
);
10451 /* [class.copy]: the copy constructor is implicitly defined even if the
10452 implementation elided its use. But don't warn about deprecation when
10453 eliding a temporary, as then no copy is actually performed. */
10454 warning_sentinel
s (warn_deprecated_copy
, eliding_temp
);
10456 /* The language says this isn't called. */;
10459 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
10460 return error_mark_node
;
10461 already_used
= true;
10464 cp_handle_deprecated_or_unavailable (fn
, complain
);
10466 if (eliding_temp
&& DECL_BASE_CONSTRUCTOR_P (fn
)
10467 && !make_base_init_ok (arg
))
10470 /* If we're creating a temp and we already have one, don't create a
10471 new one. If we're not creating a temp but we get one, use
10472 INIT_EXPR to collapse the temp into our target. Otherwise, if the
10473 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
10474 temp or an INIT_EXPR otherwise. */
10475 if (is_dummy_object (fa
))
10477 if (TREE_CODE (arg
) == TARGET_EXPR
)
10480 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
10482 else if ((trivial
|| TREE_CODE (arg
) == TARGET_EXPR
)
10485 tree to
= cp_build_fold_indirect_ref (fa
);
10486 val
= cp_build_init_expr (to
, arg
);
10490 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
10491 && DECL_OVERLOADED_OPERATOR_IS (fn
, NOP_EXPR
)
10492 && trivial_fn_p (fn
))
10494 tree to
= cp_build_fold_indirect_ref (argarray
[0]);
10495 tree type
= TREE_TYPE (to
);
10496 tree as_base
= CLASSTYPE_AS_BASE (type
);
10497 tree arg
= argarray
[1];
10498 location_t loc
= cp_expr_loc_or_input_loc (arg
);
10500 if (is_really_empty_class (type
, /*ignore_vptr*/true))
10502 /* Avoid copying empty classes, but ensure op= returns an lvalue even
10503 if the object argument isn't one. This isn't needed in other cases
10504 since MODIFY_EXPR is always considered an lvalue. */
10505 to
= cp_build_addr_expr (to
, tf_none
);
10506 to
= cp_build_indirect_ref (input_location
, to
, RO_ARROW
, complain
);
10507 val
= build2 (COMPOUND_EXPR
, type
, arg
, to
);
10508 suppress_warning (val
, OPT_Wunused
);
10510 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
10512 if (is_std_init_list (type
)
10513 && conv_binds_ref_to_prvalue (convs
[1]))
10514 warning_at (loc
, OPT_Winit_list_lifetime
,
10515 "assignment from temporary %<initializer_list%> does "
10516 "not extend the lifetime of the underlying array");
10517 arg
= cp_build_fold_indirect_ref (arg
);
10518 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
10522 /* We must only copy the non-tail padding parts. */
10523 tree arg0
, arg2
, t
;
10524 tree array_type
, alias_set
;
10526 arg2
= TYPE_SIZE_UNIT (as_base
);
10527 to
= cp_stabilize_reference (to
);
10528 arg0
= cp_build_addr_expr (to
, complain
);
10530 array_type
= build_array_type (unsigned_char_type_node
,
10532 (size_binop (MINUS_EXPR
,
10533 arg2
, size_int (1))));
10534 alias_set
= build_int_cst (build_pointer_type (type
), 0);
10535 t
= build2 (MODIFY_EXPR
, void_type_node
,
10536 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
10537 build2 (MEM_REF
, array_type
, arg
, alias_set
));
10538 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
10539 suppress_warning (val
, OPT_Wunused
);
10542 cp_handle_deprecated_or_unavailable (fn
, complain
);
10546 else if (trivial_fn_p (fn
))
10548 if (DECL_DESTRUCTOR_P (fn
))
10549 return build_trivial_dtor_call (argarray
[0]);
10550 else if (default_ctor_p (fn
))
10552 if (is_dummy_object (argarray
[0]))
10553 return force_target_expr (DECL_CONTEXT (fn
), void_node
,
10554 no_cleanup_complain
);
10556 return cp_build_fold_indirect_ref (argarray
[0]);
10560 gcc_assert (!force_elide
);
10563 && !mark_used (fn
, complain
))
10564 return error_mark_node
;
10566 /* Warn if the built-in writes to an object of a non-trivial type. */
10567 if (warn_class_memaccess
10568 && vec_safe_length (args
) >= 2
10569 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
10570 maybe_warn_class_memaccess (input_location
, fn
, args
);
10572 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
10575 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
10577 ba_any
, NULL
, complain
);
10578 gcc_assert (binfo
&& binfo
!= error_mark_node
);
10580 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
10582 if (TREE_SIDE_EFFECTS (argarray
[0]))
10583 argarray
[0] = save_expr (argarray
[0]);
10584 t
= build_pointer_type (TREE_TYPE (fn
));
10585 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
10586 TREE_TYPE (fn
) = t
;
10590 /* If FN is marked deprecated or unavailable, then we've already
10591 issued a diagnostic from mark_used above, so avoid redundantly
10592 issuing another one from build_addr_func. */
10593 auto w
= make_temp_override (deprecated_state
,
10594 UNAVAILABLE_DEPRECATED_SUPPRESS
);
10596 fn
= build_addr_func (fn
, complain
);
10597 if (fn
== error_mark_node
)
10598 return error_mark_node
;
10600 /* We're actually invoking the function. (Immediate functions get an
10601 & when invoking it even though the user didn't use &.) */
10602 ADDR_EXPR_DENOTES_CALL_P (fn
) = true;
10605 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
10606 if (call
== error_mark_node
)
10608 if (cand
->flags
& LOOKUP_LIST_INIT_CTOR
)
10610 tree c
= extract_call_expr (call
);
10611 /* build_new_op will clear this when appropriate. */
10612 CALL_EXPR_ORDERED_ARGS (c
) = true;
10616 tree c
= extract_call_expr (call
);
10617 if (TREE_CODE (c
) == CALL_EXPR
)
10618 suppress_warning (c
/* Suppress all warnings. */);
10627 /* Return the DECL of the first non-static subobject of class TYPE
10628 that satisfies the predicate PRED or null if none can be found. */
10630 template <class Predicate
>
10632 first_non_static_field (tree type
, Predicate pred
)
10634 if (!type
|| !CLASS_TYPE_P (type
))
10637 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
10639 if (TREE_CODE (field
) != FIELD_DECL
)
10641 if (TREE_STATIC (field
))
10649 for (tree base_binfo
, binfo
= TYPE_BINFO (type
);
10650 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
10652 tree base
= TREE_TYPE (base_binfo
);
10655 if (tree field
= first_non_static_field (base
, pred
))
10662 struct NonPublicField
10664 bool operator() (const_tree t
) const
10666 return DECL_P (t
) && (TREE_PRIVATE (t
) || TREE_PROTECTED (t
));
10670 /* Return the DECL of the first non-public subobject of class TYPE
10671 or null if none can be found. */
10674 first_non_public_field (tree type
)
10676 return first_non_static_field (type
, NonPublicField ());
10679 struct NonTrivialField
10681 bool operator() (const_tree t
) const
10683 return !trivial_type_p (DECL_P (t
) ? TREE_TYPE (t
) : t
);
10687 /* Return the DECL of the first non-trivial subobject of class TYPE
10688 or null if none can be found. */
10691 first_non_trivial_field (tree type
)
10693 return first_non_static_field (type
, NonTrivialField ());
10696 } /* unnamed namespace */
10698 /* Return true if all copy and move assignment operator overloads for
10699 class TYPE are trivial and at least one of them is not deleted and,
10700 when ACCESS is set, accessible. Return false otherwise. Set
10701 HASASSIGN to true when the TYPE has a (not necessarily trivial)
10702 copy or move assignment. */
10705 has_trivial_copy_assign_p (tree type
, bool access
, bool *hasassign
)
10707 tree fns
= get_class_binding (type
, assign_op_identifier
);
10708 bool all_trivial
= true;
10710 /* Iterate over overloads of the assignment operator, checking
10711 accessible copy assignments for triviality. */
10713 for (tree f
: ovl_range (fns
))
10715 /* Skip operators that aren't copy assignments. */
10716 if (!copy_fn_p (f
))
10719 bool accessible
= (!access
|| !(TREE_PRIVATE (f
) || TREE_PROTECTED (f
))
10720 || accessible_p (TYPE_BINFO (type
), f
, true));
10722 /* Skip template assignment operators and deleted functions. */
10723 if (TREE_CODE (f
) != FUNCTION_DECL
|| DECL_DELETED_FN (f
))
10729 if (!accessible
|| !trivial_fn_p (f
))
10730 all_trivial
= false;
10732 /* Break early when both properties have been determined. */
10733 if (*hasassign
&& !all_trivial
)
10737 /* Return true if they're all trivial and one of the expressions
10738 TYPE() = TYPE() or TYPE() = (TYPE&)() is valid. */
10739 tree ref
= cp_build_reference_type (type
, false);
10740 return (all_trivial
10741 && (is_trivially_xible (MODIFY_EXPR
, type
, type
)
10742 || is_trivially_xible (MODIFY_EXPR
, type
, ref
)));
10745 /* Return true if all copy and move ctor overloads for class TYPE are
10746 trivial and at least one of them is not deleted and, when ACCESS is
10747 set, accessible. Return false otherwise. Set each element of HASCTOR[]
10748 to true when the TYPE has a (not necessarily trivial) default and copy
10749 (or move) ctor, respectively. */
10752 has_trivial_copy_p (tree type
, bool access
, bool hasctor
[2])
10754 tree fns
= get_class_binding (type
, complete_ctor_identifier
);
10755 bool all_trivial
= true;
10757 for (tree f
: ovl_range (fns
))
10759 /* Skip template constructors. */
10760 if (TREE_CODE (f
) != FUNCTION_DECL
)
10763 bool cpy_or_move_ctor_p
= copy_fn_p (f
);
10765 /* Skip ctors other than default, copy, and move. */
10766 if (!cpy_or_move_ctor_p
&& !default_ctor_p (f
))
10769 if (DECL_DELETED_FN (f
))
10772 bool accessible
= (!access
|| !(TREE_PRIVATE (f
) || TREE_PROTECTED (f
))
10773 || accessible_p (TYPE_BINFO (type
), f
, true));
10776 hasctor
[cpy_or_move_ctor_p
] = true;
10778 if (cpy_or_move_ctor_p
&& (!accessible
|| !trivial_fn_p (f
)))
10779 all_trivial
= false;
10781 /* Break early when both properties have been determined. */
10782 if (hasctor
[0] && hasctor
[1] && !all_trivial
)
10786 return all_trivial
;
10789 /* Issue a warning on a call to the built-in function FNDECL if it is
10790 a raw memory write whose destination is not an object of (something
10791 like) trivial or standard layout type with a non-deleted assignment
10792 and copy ctor. Detects const correctness violations, corrupting
10793 references, virtual table pointers, and bypassing non-trivial
10797 maybe_warn_class_memaccess (location_t loc
, tree fndecl
,
10798 const vec
<tree
, va_gc
> *args
)
10800 /* Except for bcopy where it's second, the destination pointer is
10801 the first argument for all functions handled here. Compute
10802 the index of the destination and source arguments. */
10803 unsigned dstidx
= DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_BCOPY
;
10804 unsigned srcidx
= !dstidx
;
10806 tree dest
= (*args
)[dstidx
];
10807 if (!TREE_TYPE (dest
)
10808 || (TREE_CODE (TREE_TYPE (dest
)) != ARRAY_TYPE
10809 && !INDIRECT_TYPE_P (TREE_TYPE (dest
))))
10812 tree srctype
= NULL_TREE
;
10814 /* Determine the type of the pointed-to object and whether it's
10815 a complete class type. */
10816 tree desttype
= TREE_TYPE (TREE_TYPE (dest
));
10818 if (!desttype
|| !COMPLETE_TYPE_P (desttype
) || !CLASS_TYPE_P (desttype
))
10821 /* Check to see if the raw memory call is made by a non-static member
10822 function with THIS as the destination argument for the destination
10823 type. If so, and if the class has no non-trivial bases or members,
10824 be more permissive. */
10825 if (current_function_decl
10826 && DECL_OBJECT_MEMBER_FUNCTION_P (current_function_decl
)
10827 && is_object_parameter (tree_strip_nop_conversions (dest
)))
10829 tree ctx
= DECL_CONTEXT (current_function_decl
);
10830 bool special
= same_type_ignoring_top_level_qualifiers_p (ctx
, desttype
);
10831 tree binfo
= TYPE_BINFO (ctx
);
10834 && !BINFO_VTABLE (binfo
)
10835 && !first_non_trivial_field (desttype
))
10839 /* True if the class is trivial. */
10840 bool trivial
= trivial_type_p (desttype
);
10842 /* Set to true if DESTYPE has an accessible copy assignment. */
10843 bool hasassign
= false;
10844 /* True if all of the class' overloaded copy assignment operators
10845 are all trivial (and not deleted) and at least one of them is
10847 bool trivassign
= has_trivial_copy_assign_p (desttype
, true, &hasassign
);
10849 /* Set to true if DESTTYPE has an accessible default and copy ctor,
10851 bool hasctors
[2] = { false, false };
10853 /* True if all of the class' overloaded copy constructors are all
10854 trivial (and not deleted) and at least one of them is accessible. */
10855 bool trivcopy
= has_trivial_copy_p (desttype
, true, hasctors
);
10857 /* Set FLD to the first private/protected member of the class. */
10858 tree fld
= trivial
? first_non_public_field (desttype
) : NULL_TREE
;
10860 /* The warning format string. */
10861 const char *warnfmt
= NULL
;
10862 /* A suggested alternative to offer instead of the raw memory call.
10863 Empty string when none can be come up with. */
10864 const char *suggest
= "";
10865 bool warned
= false;
10867 switch (DECL_FUNCTION_CODE (fndecl
))
10869 case BUILT_IN_MEMSET
:
10870 if (!integer_zerop (maybe_constant_value ((*args
)[1])))
10872 /* Diagnose setting non-copy-assignable or non-trivial types,
10873 or types with a private member, to (potentially) non-zero
10874 bytes. Since the value of the bytes being written is unknown,
10875 suggest using assignment instead (if one exists). Also warn
10876 for writes into objects for which zero-initialization doesn't
10877 mean all bits clear (pointer-to-member data, where null is all
10878 bits set). Since the value being written is (most likely)
10879 non-zero, simply suggest assignment (but not copy assignment). */
10880 suggest
= "; use assignment instead";
10882 warnfmt
= G_("%qD writing to an object of type %#qT with "
10883 "no trivial copy-assignment");
10885 warnfmt
= G_("%qD writing to an object of non-trivial type %#qT%s");
10888 const char *access
= TREE_PRIVATE (fld
) ? "private" : "protected";
10889 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
10890 "%qD writing to an object of type %#qT with "
10892 fndecl
, desttype
, access
, fld
);
10894 else if (!zero_init_p (desttype
))
10895 warnfmt
= G_("%qD writing to an object of type %#qT containing "
10896 "a pointer to data member%s");
10900 /* Fall through. */
10902 case BUILT_IN_BZERO
:
10903 /* Similarly to the above, diagnose clearing non-trivial or non-
10904 standard layout objects, or objects of types with no assignmenmt.
10905 Since the value being written is known to be zero, suggest either
10906 copy assignment, copy ctor, or default ctor as an alternative,
10907 depending on what's available. */
10909 if (hasassign
&& hasctors
[0])
10910 suggest
= G_("; use assignment or value-initialization instead");
10911 else if (hasassign
)
10912 suggest
= G_("; use assignment instead");
10913 else if (hasctors
[0])
10914 suggest
= G_("; use value-initialization instead");
10917 warnfmt
= G_("%qD clearing an object of type %#qT with "
10918 "no trivial copy-assignment%s");
10920 warnfmt
= G_("%qD clearing an object of non-trivial type %#qT%s");
10921 else if (!zero_init_p (desttype
))
10922 warnfmt
= G_("%qD clearing an object of type %#qT containing "
10923 "a pointer-to-member%s");
10926 case BUILT_IN_BCOPY
:
10927 case BUILT_IN_MEMCPY
:
10928 case BUILT_IN_MEMMOVE
:
10929 case BUILT_IN_MEMPCPY
:
10930 /* Determine the type of the source object. */
10931 srctype
= TREE_TYPE ((*args
)[srcidx
]);
10932 if (!srctype
|| !INDIRECT_TYPE_P (srctype
))
10933 srctype
= void_type_node
;
10935 srctype
= TREE_TYPE (srctype
);
10937 /* Since it's impossible to determine wheter the byte copy is
10938 being used in place of assignment to an existing object or
10939 as a substitute for initialization, assume it's the former.
10940 Determine the best alternative to use instead depending on
10941 what's not deleted. */
10942 if (hasassign
&& hasctors
[1])
10943 suggest
= G_("; use copy-assignment or copy-initialization instead");
10944 else if (hasassign
)
10945 suggest
= G_("; use copy-assignment instead");
10946 else if (hasctors
[1])
10947 suggest
= G_("; use copy-initialization instead");
10950 warnfmt
= G_("%qD writing to an object of type %#qT with no trivial "
10951 "copy-assignment%s");
10952 else if (!trivially_copyable_p (desttype
))
10953 warnfmt
= G_("%qD writing to an object of non-trivially copyable "
10955 else if (!trivcopy
)
10956 warnfmt
= G_("%qD writing to an object with a deleted copy constructor");
10959 && !VOID_TYPE_P (srctype
)
10960 && !is_byte_access_type (srctype
)
10961 && !same_type_ignoring_top_level_qualifiers_p (desttype
,
10964 /* Warn when copying into a non-trivial object from an object
10965 of a different type other than void or char. */
10966 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
10967 "%qD copying an object of non-trivial type "
10968 "%#qT from an array of %#qT",
10969 fndecl
, desttype
, srctype
);
10972 && !VOID_TYPE_P (srctype
)
10973 && !is_byte_access_type (srctype
)
10974 && !same_type_ignoring_top_level_qualifiers_p (desttype
,
10977 const char *access
= TREE_PRIVATE (fld
) ? "private" : "protected";
10978 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
10979 "%qD copying an object of type %#qT with "
10980 "%qs member %qD from an array of %#qT; use "
10981 "assignment or copy-initialization instead",
10982 fndecl
, desttype
, access
, fld
, srctype
);
10984 else if (!trivial
&& vec_safe_length (args
) > 2)
10986 tree sz
= maybe_constant_value ((*args
)[2]);
10987 if (!tree_fits_uhwi_p (sz
))
10990 /* Finally, warn on partial copies. */
10991 unsigned HOST_WIDE_INT typesize
10992 = tree_to_uhwi (TYPE_SIZE_UNIT (desttype
));
10995 if (unsigned HOST_WIDE_INT partial
= tree_to_uhwi (sz
) % typesize
)
10996 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
10997 (typesize
- partial
> 1
10998 ? G_("%qD writing to an object of "
10999 "a non-trivial type %#qT leaves %wu "
11001 : G_("%qD writing to an object of "
11002 "a non-trivial type %#qT leaves %wu "
11003 "byte unchanged")),
11004 fndecl
, desttype
, typesize
- partial
);
11008 case BUILT_IN_REALLOC
:
11010 if (!trivially_copyable_p (desttype
))
11011 warnfmt
= G_("%qD moving an object of non-trivially copyable type "
11012 "%#qT; use %<new%> and %<delete%> instead");
11013 else if (!trivcopy
)
11014 warnfmt
= G_("%qD moving an object of type %#qT with deleted copy "
11015 "constructor; use %<new%> and %<delete%> instead");
11016 else if (!get_dtor (desttype
, tf_none
))
11017 warnfmt
= G_("%qD moving an object of type %#qT with deleted "
11021 tree sz
= maybe_constant_value ((*args
)[1]);
11022 if (TREE_CODE (sz
) == INTEGER_CST
11023 && tree_int_cst_lt (sz
, TYPE_SIZE_UNIT (desttype
)))
11024 /* Finally, warn on reallocation into insufficient space. */
11025 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
11026 "%qD moving an object of non-trivial type "
11027 "%#qT and size %E into a region of size %E",
11028 fndecl
, desttype
, TYPE_SIZE_UNIT (desttype
),
11040 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
11041 warnfmt
, fndecl
, desttype
, suggest
);
11043 warned
= warning_at (loc
, OPT_Wclass_memaccess
,
11044 warnfmt
, fndecl
, desttype
);
11048 inform (location_of (desttype
), "%#qT declared here", desttype
);
11051 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
11052 If FN is the result of resolving an overloaded target built-in,
11053 ORIG_FNDECL is the original function decl, otherwise it is null.
11054 This function performs no overload resolution, conversion, or other
11055 high-level operations. */
11058 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
11059 tsubst_flags_t complain
, tree orig_fndecl
)
11063 /* Remember roughly where this call is. */
11064 location_t loc
= cp_expr_loc_or_input_loc (fn
);
11065 fn
= build_call_a (fn
, nargs
, argarray
);
11066 SET_EXPR_LOCATION (fn
, loc
);
11068 fndecl
= get_callee_fndecl (fn
);
11070 orig_fndecl
= fndecl
;
11072 /* Check that arguments to builtin functions match the expectations. */
11074 && !processing_template_decl
11075 && fndecl_built_in_p (fndecl
))
11079 /* We need to take care that values to BUILT_IN_NORMAL
11081 for (i
= 0; i
< nargs
; i
++)
11082 argarray
[i
] = maybe_constant_value (argarray
[i
]);
11084 if (!check_builtin_function_arguments (EXPR_LOCATION (fn
), vNULL
, fndecl
,
11085 orig_fndecl
, nargs
, argarray
))
11086 return error_mark_node
;
11087 else if (fndecl_built_in_p (fndecl
, BUILT_IN_CLEAR_PADDING
))
11089 tree arg0
= argarray
[0];
11091 if (TREE_CODE (arg0
) == ADDR_EXPR
11092 && DECL_P (TREE_OPERAND (arg0
, 0))
11093 && same_type_ignoring_top_level_qualifiers_p
11094 (TREE_TYPE (TREE_TYPE (argarray
[0])),
11095 TREE_TYPE (TREE_TYPE (arg0
))))
11096 /* For __builtin_clear_padding (&var) we know the type
11097 is for a complete object, so there is no risk in clearing
11098 padding that is reused in some derived class member. */;
11099 else if (!trivially_copyable_p (TREE_TYPE (TREE_TYPE (argarray
[0]))))
11101 error_at (EXPR_LOC_OR_LOC (argarray
[0], input_location
),
11102 "argument %u in call to function %qE "
11103 "has pointer to a non-trivially-copyable type (%qT)",
11104 1, fndecl
, TREE_TYPE (argarray
[0]));
11105 return error_mark_node
;
11110 if (VOID_TYPE_P (TREE_TYPE (fn
)))
11113 /* 5.2.2/11: If a function call is a prvalue of object type: if the
11114 function call is either the operand of a decltype-specifier or the
11115 right operand of a comma operator that is the operand of a
11116 decltype-specifier, a temporary object is not introduced for the
11117 prvalue. The type of the prvalue may be incomplete. */
11118 if (!(complain
& tf_decltype
))
11120 fn
= require_complete_type (fn
, complain
);
11121 if (fn
== error_mark_node
)
11122 return error_mark_node
;
11124 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
11126 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
11127 maybe_warn_parm_abi (TREE_TYPE (fn
), loc
);
11130 return convert_from_reference (fn
);
11133 /* Returns the value to use for the in-charge parameter when making a
11134 call to a function with the indicated NAME.
11136 FIXME:Can't we find a neater way to do this mapping? */
11139 in_charge_arg_for_name (tree name
)
11141 if (IDENTIFIER_CTOR_P (name
))
11143 if (name
== complete_ctor_identifier
)
11144 return integer_one_node
;
11145 gcc_checking_assert (name
== base_ctor_identifier
);
11149 if (name
== complete_dtor_identifier
)
11150 return integer_two_node
;
11151 else if (name
== deleting_dtor_identifier
)
11152 return integer_three_node
;
11153 gcc_checking_assert (name
== base_dtor_identifier
);
11156 return integer_zero_node
;
11159 /* We've built up a constructor call RET. Complain if it delegates to the
11160 constructor we're currently compiling. */
11163 check_self_delegation (tree ret
)
11165 if (TREE_CODE (ret
) == TARGET_EXPR
)
11166 ret
= TARGET_EXPR_INITIAL (ret
);
11167 tree fn
= cp_get_callee_fndecl_nofold (ret
);
11168 if (fn
&& DECL_ABSTRACT_ORIGIN (fn
) == current_function_decl
)
11169 error ("constructor delegates to itself");
11172 /* Build a call to a constructor, destructor, or an assignment
11173 operator for INSTANCE, an expression with class type. NAME
11174 indicates the special member function to call; *ARGS are the
11175 arguments. ARGS may be NULL. This may change ARGS. BINFO
11176 indicates the base of INSTANCE that is to be passed as the `this'
11177 parameter to the member function called.
11179 FLAGS are the LOOKUP_* flags to use when processing the call.
11181 If NAME indicates a complete object constructor, INSTANCE may be
11182 NULL_TREE. In this case, the caller will call build_cplus_new to
11183 store the newly constructed object into a VAR_DECL. */
11186 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
11187 tree binfo
, int flags
, tsubst_flags_t complain
)
11190 /* The type of the subobject to be constructed or destroyed. */
11192 vec
<tree
, va_gc
> *allocated
= NULL
;
11195 gcc_assert (IDENTIFIER_CDTOR_P (name
) || name
== assign_op_identifier
);
11197 if (error_operand_p (instance
))
11198 return error_mark_node
;
11200 if (IDENTIFIER_DTOR_P (name
))
11202 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
11203 if (!type_build_dtor_call (TREE_TYPE (instance
)))
11204 /* Shortcut to avoid lazy destructor declaration. */
11205 return build_trivial_dtor_call (instance
);
11208 if (TYPE_P (binfo
))
11210 /* Resolve the name. */
11211 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
11212 return error_mark_node
;
11214 binfo
= TYPE_BINFO (binfo
);
11217 gcc_assert (binfo
!= NULL_TREE
);
11219 class_type
= BINFO_TYPE (binfo
);
11221 /* Handle the special case where INSTANCE is NULL_TREE. */
11222 if (name
== complete_ctor_identifier
&& !instance
)
11223 instance
= build_dummy_object (class_type
);
11226 /* Convert to the base class, if necessary. */
11227 if (!same_type_ignoring_top_level_qualifiers_p
11228 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
11230 if (IDENTIFIER_CDTOR_P (name
))
11231 /* For constructors and destructors, either the base is
11232 non-virtual, or it is virtual but we are doing the
11233 conversion from a constructor or destructor for the
11234 complete object. In either case, we can convert
11236 instance
= convert_to_base_statically (instance
, binfo
);
11239 /* However, for assignment operators, we must convert
11240 dynamically if the base is virtual. */
11241 gcc_checking_assert (name
== assign_op_identifier
);
11242 instance
= build_base_path (PLUS_EXPR
, instance
,
11243 binfo
, /*nonnull=*/1, complain
);
11248 gcc_assert (instance
!= NULL_TREE
);
11250 /* In C++17, "If the initializer expression is a prvalue and the
11251 cv-unqualified version of the source type is the same class as the class
11252 of the destination, the initializer expression is used to initialize the
11253 destination object." Handle that here to avoid doing overload
11255 if (cxx_dialect
>= cxx17
11256 && args
&& vec_safe_length (*args
) == 1
11257 && !unsafe_return_slot_p (instance
))
11259 tree arg
= (**args
)[0];
11261 if (BRACE_ENCLOSED_INITIALIZER_P (arg
)
11262 && !TYPE_HAS_LIST_CTOR (class_type
)
11263 && !CONSTRUCTOR_IS_DESIGNATED_INIT (arg
)
11264 && CONSTRUCTOR_NELTS (arg
) == 1)
11265 arg
= CONSTRUCTOR_ELT (arg
, 0)->value
;
11267 if ((TREE_CODE (arg
) == TARGET_EXPR
11268 || TREE_CODE (arg
) == CONSTRUCTOR
)
11269 && (same_type_ignoring_top_level_qualifiers_p
11270 (class_type
, TREE_TYPE (arg
))))
11272 if (is_dummy_object (instance
))
11274 else if (TREE_CODE (arg
) == TARGET_EXPR
)
11275 TARGET_EXPR_DIRECT_INIT_P (arg
) = true;
11277 if ((complain
& tf_error
)
11278 && (flags
& LOOKUP_DELEGATING_CONS
))
11279 check_self_delegation (arg
);
11280 /* Avoid change of behavior on Wunused-var-2.C. */
11281 instance
= mark_lvalue_use (instance
);
11282 return cp_build_init_expr (instance
, arg
);
11286 fns
= lookup_fnfields (binfo
, name
, 1, complain
);
11288 /* When making a call to a constructor or destructor for a subobject
11289 that uses virtual base classes, pass down a pointer to a VTT for
11291 if ((name
== base_ctor_identifier
11292 || name
== base_dtor_identifier
)
11293 && CLASSTYPE_VBASECLASSES (class_type
))
11298 /* If the current function is a complete object constructor
11299 or destructor, then we fetch the VTT directly.
11300 Otherwise, we look it up using the VTT we were given. */
11301 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
11302 vtt
= decay_conversion (vtt
, complain
);
11303 if (vtt
== error_mark_node
)
11304 return error_mark_node
;
11305 vtt
= build_if_in_charge (vtt
, current_vtt_parm
);
11306 if (BINFO_SUBVTT_INDEX (binfo
))
11307 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
11313 allocated
= make_tree_vector ();
11317 vec_safe_insert (*args
, 0, sub_vtt
);
11320 ret
= build_new_method_call (instance
, fns
, args
,
11321 TYPE_BINFO (BINFO_TYPE (binfo
)),
11322 flags
, /*fn=*/NULL
,
11325 if (allocated
!= NULL
)
11326 release_tree_vector (allocated
);
11328 if ((complain
& tf_error
)
11329 && (flags
& LOOKUP_DELEGATING_CONS
)
11330 && name
== complete_ctor_identifier
)
11331 check_self_delegation (ret
);
11336 /* Return the NAME, as a C string. The NAME indicates a function that
11337 is a member of TYPE. *FREE_P is set to true if the caller must
11338 free the memory returned.
11340 Rather than go through all of this, we should simply set the names
11341 of constructors and destructors appropriately, and dispense with
11342 ctor_identifier, dtor_identifier, etc. */
11345 name_as_c_string (tree name
, tree type
, bool *free_p
)
11347 const char *pretty_name
;
11349 /* Assume that we will not allocate memory. */
11351 /* Constructors and destructors are special. */
11352 if (IDENTIFIER_CDTOR_P (name
))
11355 = identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
)));
11356 /* For a destructor, add the '~'. */
11357 if (IDENTIFIER_DTOR_P (name
))
11359 pretty_name
= concat ("~", pretty_name
, NULL
);
11360 /* Remember that we need to free the memory allocated. */
11364 else if (IDENTIFIER_CONV_OP_P (name
))
11366 pretty_name
= concat ("operator ",
11367 type_as_string_translate (TREE_TYPE (name
),
11368 TFF_PLAIN_IDENTIFIER
),
11370 /* Remember that we need to free the memory allocated. */
11374 pretty_name
= identifier_to_locale (IDENTIFIER_POINTER (name
));
11376 return CONST_CAST (char *, pretty_name
);
11379 /* If CANDIDATES contains exactly one candidate, return it, otherwise
11382 static z_candidate
*
11383 single_z_candidate (z_candidate
*candidates
)
11385 if (candidates
== NULL
)
11388 if (candidates
->next
)
11394 /* If CANDIDATE is invalid due to a bad argument type, return the
11395 pertinent conversion_info.
11397 Otherwise, return NULL. */
11399 static const conversion_info
*
11400 maybe_get_bad_conversion_for_unmatched_call (const z_candidate
*candidate
)
11402 /* Must be an rr_arg_conversion or rr_bad_arg_conversion. */
11403 rejection_reason
*r
= candidate
->reason
;
11413 case rr_arg_conversion
:
11414 return &r
->u
.conversion
;
11416 case rr_bad_arg_conversion
:
11417 return &r
->u
.bad_conversion
;
11421 /* Issue an error and note complaining about a bad argument type at a
11422 callsite with a single candidate FNDECL.
11424 ARG_LOC is the location of the argument (or UNKNOWN_LOCATION, in which
11425 case input_location is used).
11426 FROM_TYPE is the type of the actual argument; TO_TYPE is the type of
11427 the formal parameter. */
11430 complain_about_bad_argument (location_t arg_loc
,
11431 tree from_type
, tree to_type
,
11432 tree fndecl
, int parmnum
)
11434 auto_diagnostic_group d
;
11435 range_label_for_type_mismatch
rhs_label (from_type
, to_type
);
11436 range_label
*label
= &rhs_label
;
11437 if (arg_loc
== UNKNOWN_LOCATION
)
11439 arg_loc
= input_location
;
11442 gcc_rich_location
richloc (arg_loc
, label
);
11443 error_at (&richloc
,
11444 "cannot convert %qH to %qI",
11445 from_type
, to_type
);
11446 maybe_inform_about_fndecl_for_bogus_argument_init (fndecl
,
11450 /* Subroutine of build_new_method_call_1, for where there are no viable
11451 candidates for the call. */
11454 complain_about_no_candidates_for_method_call (tree instance
,
11455 z_candidate
*candidates
,
11456 tree explicit_targs
,
11458 tree optype
, tree name
,
11459 bool skip_first_for_error
,
11460 vec
<tree
, va_gc
> *user_args
)
11462 auto_diagnostic_group d
;
11463 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
11464 cxx_incomplete_type_error (instance
, basetype
);
11466 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
11467 basetype
, optype
, build_tree_list_vec (user_args
),
11468 TREE_TYPE (instance
));
11471 /* Special-case for when there's a single candidate that's failing
11472 due to a bad argument type. */
11473 if (z_candidate
*candidate
= single_z_candidate (candidates
))
11474 if (const conversion_info
*conv
11475 = maybe_get_bad_conversion_for_unmatched_call (candidate
))
11477 tree from_type
= conv
->from
;
11478 if (!TYPE_P (conv
->from
))
11479 from_type
= lvalue_type (conv
->from
);
11480 complain_about_bad_argument (conv
->loc
,
11481 from_type
, conv
->to_type
,
11482 candidate
->fn
, conv
->n_arg
);
11486 tree arglist
= build_tree_list_vec (user_args
);
11487 tree errname
= name
;
11488 bool twiddle
= false;
11489 if (IDENTIFIER_CDTOR_P (errname
))
11491 twiddle
= IDENTIFIER_DTOR_P (errname
);
11492 errname
= constructor_name (basetype
);
11494 if (explicit_targs
)
11495 errname
= lookup_template_function (errname
, explicit_targs
);
11496 if (skip_first_for_error
)
11497 arglist
= TREE_CHAIN (arglist
);
11498 error ("no matching function for call to %<%T::%s%E(%A)%#V%>",
11499 basetype
, &"~"[!twiddle
], errname
, arglist
,
11500 TREE_TYPE (instance
));
11502 print_z_candidates (location_of (name
), candidates
);
11505 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
11506 be set, upon return, to the function called. ARGS may be NULL.
11507 This may change ARGS. */
11510 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
11511 tree conversion_path
, int flags
,
11512 tree
*fn_p
, tsubst_flags_t complain
)
11514 struct z_candidate
*candidates
= 0, *cand
;
11515 tree explicit_targs
= NULL_TREE
;
11516 tree basetype
= NULL_TREE
;
11519 tree first_mem_arg
= NULL_TREE
;
11521 bool skip_first_for_error
;
11522 vec
<tree
, va_gc
> *user_args
;
11525 int template_only
= 0;
11527 tree orig_instance
;
11529 vec
<tree
, va_gc
> *orig_args
= NULL
;
11531 auto_cond_timevar
tv (TV_OVERLOAD
);
11533 gcc_assert (instance
!= NULL_TREE
);
11535 /* We don't know what function we're going to call, yet. */
11539 if (error_operand_p (instance
)
11540 || !fns
|| error_operand_p (fns
))
11541 return error_mark_node
;
11543 if (!BASELINK_P (fns
))
11545 if (complain
& tf_error
)
11546 error ("call to non-function %qD", fns
);
11547 return error_mark_node
;
11550 orig_instance
= instance
;
11553 /* Dismantle the baselink to collect all the information we need. */
11554 if (!conversion_path
)
11555 conversion_path
= BASELINK_BINFO (fns
);
11556 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
11557 optype
= BASELINK_OPTYPE (fns
);
11558 fns
= BASELINK_FUNCTIONS (fns
);
11559 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
11561 explicit_targs
= TREE_OPERAND (fns
, 1);
11562 fns
= TREE_OPERAND (fns
, 0);
11565 gcc_assert (OVL_P (fns
));
11566 fn
= OVL_FIRST (fns
);
11567 name
= DECL_NAME (fn
);
11569 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
11570 gcc_assert (CLASS_TYPE_P (basetype
));
11572 user_args
= args
== NULL
? NULL
: *args
;
11573 /* Under DR 147 A::A() is an invalid constructor call,
11574 not a functional cast. */
11575 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
11577 if (! (complain
& tf_error
))
11578 return error_mark_node
;
11580 basetype
= DECL_CONTEXT (fn
);
11581 name
= constructor_name (basetype
);
11582 auto_diagnostic_group d
;
11583 if (permerror (input_location
,
11584 "cannot call constructor %<%T::%D%> directly",
11586 inform (input_location
, "for a function-style cast, remove the "
11587 "redundant %<::%D%>", name
);
11588 call
= build_functional_cast (input_location
, basetype
,
11589 build_tree_list_vec (user_args
),
11594 if (processing_template_decl
)
11595 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
11597 /* Process the argument list. */
11598 if (args
!= NULL
&& *args
!= NULL
)
11600 *args
= resolve_args (*args
, complain
);
11602 return error_mark_node
;
11606 /* Consider the object argument to be used even if we end up selecting a
11607 static member function. */
11608 instance
= mark_type_use (instance
);
11610 /* Figure out whether to skip the first argument for the error
11611 message we will display to users if an error occurs. We don't
11612 want to display any compiler-generated arguments. The "this"
11613 pointer hasn't been added yet. However, we must remove the VTT
11614 pointer if this is a call to a base-class constructor or
11616 skip_first_for_error
= false;
11617 if (IDENTIFIER_CDTOR_P (name
))
11619 /* Callers should explicitly indicate whether they want to ctor
11620 the complete object or just the part without virtual bases. */
11621 gcc_assert (name
!= ctor_identifier
);
11623 /* Remove the VTT pointer, if present. */
11624 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
11625 && CLASSTYPE_VBASECLASSES (basetype
))
11626 skip_first_for_error
= true;
11628 /* It's OK to call destructors and constructors on cv-qualified
11629 objects. Therefore, convert the INSTANCE to the unqualified
11630 type, if necessary. */
11631 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
11633 instance
= build_this (instance
);
11634 instance
= build_nop (build_pointer_type (basetype
), instance
);
11635 instance
= build_fold_indirect_ref (instance
);
11639 gcc_assert (!DECL_DESTRUCTOR_P (fn
) && !DECL_CONSTRUCTOR_P (fn
));
11641 /* For the overload resolution we need to find the actual `this`
11642 that would be captured if the call turns out to be to a
11643 non-static member function. Do not actually capture it at this
11645 if (DECL_CONSTRUCTOR_P (fn
))
11646 /* Constructors don't use the enclosing 'this'. */
11647 first_mem_arg
= instance
;
11649 first_mem_arg
= maybe_resolve_dummy (instance
, false);
11651 conversion_obstack_sentinel cos
;
11653 /* The number of arguments artificial parms in ARGS; we subtract one because
11654 there's no 'this' in ARGS. */
11655 unsigned skip
= num_artificial_parms_for (fn
) - 1;
11657 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
11658 initializer, not T({ }). */
11659 if (DECL_CONSTRUCTOR_P (fn
)
11660 && vec_safe_length (user_args
) > skip
11661 && DIRECT_LIST_INIT_P ((*user_args
)[skip
]))
11663 tree init_list
= (*user_args
)[skip
];
11664 tree init
= NULL_TREE
;
11666 gcc_assert (user_args
->length () == skip
+ 1
11667 && !(flags
& LOOKUP_ONLYCONVERTING
));
11669 /* If the initializer list has no elements and T is a class type with
11670 a default constructor, the object is value-initialized. Handle
11671 this here so we don't need to handle it wherever we use
11672 build_special_member_call. */
11673 if (CONSTRUCTOR_NELTS (init_list
) == 0
11674 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
11675 /* For a user-provided default constructor, use the normal
11676 mechanisms so that protected access works. */
11677 && type_has_non_user_provided_default_constructor (basetype
)
11678 && !processing_template_decl
)
11679 init
= build_value_init (basetype
, complain
);
11681 /* If BASETYPE is an aggregate, we need to do aggregate
11683 else if (CP_AGGREGATE_TYPE_P (basetype
))
11685 init
= reshape_init (basetype
, init_list
, complain
);
11686 init
= digest_init (basetype
, init
, complain
);
11691 if (is_dummy_object (instance
))
11692 return get_target_expr (init
, complain
);
11693 return cp_build_init_expr (instance
, init
);
11696 /* Otherwise go ahead with overload resolution. */
11697 add_list_candidates (fns
, first_mem_arg
, user_args
,
11698 basetype
, explicit_targs
, template_only
,
11699 conversion_path
, access_binfo
, flags
,
11700 &candidates
, complain
);
11703 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
11704 explicit_targs
, template_only
, conversion_path
,
11705 access_binfo
, flags
, &candidates
, complain
);
11707 any_viable_p
= false;
11708 candidates
= splice_viable (candidates
, false, &any_viable_p
);
11712 /* [dcl.init], 17.6.2.2:
11714 Otherwise, if no constructor is viable, the destination type is
11715 a (possibly cv-qualified) aggregate class A, and the initializer
11716 is a parenthesized expression-list, the object is initialized as
11719 We achieve this by building up a CONSTRUCTOR, as for list-init,
11720 and setting CONSTRUCTOR_IS_PAREN_INIT to distinguish between
11722 if (DECL_CONSTRUCTOR_P (fn
)
11723 && !(flags
& LOOKUP_ONLYCONVERTING
)
11724 && cxx_dialect
>= cxx20
11725 && CP_AGGREGATE_TYPE_P (basetype
)
11726 && !vec_safe_is_empty (user_args
))
11728 /* Create a CONSTRUCTOR from ARGS, e.g. {1, 2} from <1, 2>. */
11729 tree ctor
= build_constructor_from_vec (init_list_type_node
,
11731 CONSTRUCTOR_IS_DIRECT_INIT (ctor
) = true;
11732 CONSTRUCTOR_IS_PAREN_INIT (ctor
) = true;
11733 if (is_dummy_object (instance
))
11737 ctor
= digest_init (basetype
, ctor
, complain
);
11738 if (ctor
== error_mark_node
)
11739 return error_mark_node
;
11740 return cp_build_init_expr (instance
, ctor
);
11743 if (complain
& tf_error
)
11744 complain_about_no_candidates_for_method_call (instance
, candidates
,
11745 explicit_targs
, basetype
,
11747 skip_first_for_error
,
11749 call
= error_mark_node
;
11753 cand
= tourney (candidates
, complain
);
11760 if (complain
& tf_error
)
11762 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
11763 arglist
= build_tree_list_vec (user_args
);
11764 if (skip_first_for_error
)
11765 arglist
= TREE_CHAIN (arglist
);
11766 auto_diagnostic_group d
;
11767 if (!any_strictly_viable (candidates
))
11768 error ("no matching function for call to %<%s(%A)%>",
11769 pretty_name
, arglist
);
11771 error ("call of overloaded %<%s(%A)%> is ambiguous",
11772 pretty_name
, arglist
);
11773 print_z_candidates (location_of (name
), candidates
);
11775 free (pretty_name
);
11777 call
= error_mark_node
;
11779 *fn_p
= error_mark_node
;
11786 if (!(flags
& LOOKUP_NONVIRTUAL
)
11787 && DECL_PURE_VIRTUAL_P (fn
)
11788 && instance
== current_class_ref
11789 && (complain
& tf_warning
))
11791 /* This is not an error, it is runtime undefined
11793 if (!current_function_decl
)
11794 warning (0, "pure virtual %q#D called from "
11795 "non-static data member initializer", fn
);
11796 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
11797 || DECL_DESTRUCTOR_P (current_function_decl
))
11798 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
11799 ? G_("pure virtual %q#D called from constructor")
11800 : G_("pure virtual %q#D called from destructor")),
11804 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
11805 && !DECL_CONSTRUCTOR_P (fn
)
11806 && is_dummy_object (instance
))
11808 instance
= maybe_resolve_dummy (instance
, true);
11809 if (instance
== error_mark_node
)
11810 call
= error_mark_node
;
11811 else if (!is_dummy_object (instance
))
11813 /* We captured 'this' in the current lambda now that
11814 we know we really need it. */
11815 cand
->first_arg
= instance
;
11817 else if (current_class_ptr
&& any_dependent_bases_p ())
11818 /* We can't tell until instantiation time whether we can use
11819 *this as the implicit object argument. */;
11822 if (complain
& tf_error
)
11823 error ("cannot call member function %qD without object",
11825 call
= error_mark_node
;
11829 if (call
!= error_mark_node
)
11831 /* Now we know what function is being called. */
11834 /* Build the actual CALL_EXPR. */
11835 call
= build_over_call (cand
, flags
, complain
);
11837 /* Suppress warnings for if (my_struct.operator= (x)) where
11838 my_struct is implicitly converted to bool. */
11839 if (TREE_CODE (call
) == MODIFY_EXPR
)
11840 suppress_warning (call
, OPT_Wparentheses
);
11842 /* In an expression of the form `a->f()' where `f' turns
11843 out to be a static member function, `a' is
11844 none-the-less evaluated. */
11845 if (!is_dummy_object (instance
))
11846 call
= keep_unused_object_arg (call
, instance
, fn
);
11847 if (call
!= error_mark_node
11848 && DECL_DESTRUCTOR_P (cand
->fn
)
11849 && !VOID_TYPE_P (TREE_TYPE (call
)))
11850 /* An explicit call of the form "x->~X()" has type
11851 "void". However, on platforms where destructors
11852 return "this" (i.e., those where
11853 targetm.cxx.cdtor_returns_this is true), such calls
11854 will appear to have a return value of pointer type
11855 to the low-level call machinery. We do not want to
11856 change the low-level machinery, since we want to be
11857 able to optimize "delete f()" on such platforms as
11858 "operator delete(~X(f()))" (rather than generating
11859 "t = f(), ~X(t), operator delete (t)"). */
11860 call
= build_nop (void_type_node
, call
);
11865 if (processing_template_decl
&& call
!= error_mark_node
)
11867 bool cast_to_void
= false;
11869 if (TREE_CODE (call
) == COMPOUND_EXPR
)
11870 call
= TREE_OPERAND (call
, 1);
11871 else if (TREE_CODE (call
) == NOP_EXPR
)
11873 cast_to_void
= true;
11874 call
= TREE_OPERAND (call
, 0);
11876 if (INDIRECT_REF_P (call
))
11877 call
= TREE_OPERAND (call
, 0);
11879 /* Prune all but the selected function from the original overload
11880 set so that we can avoid some duplicate work at instantiation time. */
11881 if (really_overloaded_fn (fns
))
11883 if (DECL_TEMPLATE_INFO (fn
)
11884 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
11886 /* Use the selected template, not the specialization, so that
11887 this looks like an actual lookup result for sake of
11888 filter_memfn_lookup. */
11890 if (OVL_SINGLE_P (fns
))
11891 /* If the original overload set consists of a single function
11892 template, this isn't beneficial. */
11895 fn
= ovl_make (DECL_TI_TEMPLATE (fn
));
11897 fn
= lookup_template_function (fn
, explicit_targs
);
11899 orig_fns
= copy_node (orig_fns
);
11900 BASELINK_FUNCTIONS (orig_fns
) = fn
;
11901 BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (orig_fns
) = true;
11905 call
= (build_min_non_dep_call_vec
11907 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
11908 orig_instance
, orig_fns
, NULL_TREE
),
11910 SET_EXPR_LOCATION (call
, input_location
);
11911 call
= convert_from_reference (call
);
11913 call
= build_nop (void_type_node
, call
);
11916 if (orig_args
!= NULL
)
11917 release_tree_vector (orig_args
);
11922 /* Returns true iff standard conversion sequence ICS1 is a proper
11923 subsequence of ICS2. */
11926 is_subseq (conversion
*ics1
, conversion
*ics2
)
11928 /* We can assume that a conversion of the same code
11929 between the same types indicates a subsequence since we only get
11930 here if the types we are converting from are the same. */
11932 while (ics1
->kind
== ck_rvalue
11933 || ics1
->kind
== ck_lvalue
)
11934 ics1
= next_conversion (ics1
);
11938 while (ics2
->kind
== ck_rvalue
11939 || ics2
->kind
== ck_lvalue
)
11940 ics2
= next_conversion (ics2
);
11942 if (ics2
->kind
== ck_user
11943 || !has_next (ics2
->kind
))
11944 /* At this point, ICS1 cannot be a proper subsequence of
11945 ICS2. We can get a USER_CONV when we are comparing the
11946 second standard conversion sequence of two user conversion
11950 ics2
= next_conversion (ics2
);
11952 while (ics2
->kind
== ck_rvalue
11953 || ics2
->kind
== ck_lvalue
)
11954 ics2
= next_conversion (ics2
);
11956 if (ics2
->kind
== ics1
->kind
11957 && same_type_p (ics2
->type
, ics1
->type
)
11958 && (ics1
->kind
== ck_identity
11959 || same_type_p (next_conversion (ics2
)->type
,
11960 next_conversion (ics1
)->type
)))
11965 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
11966 be any _TYPE nodes. */
11969 is_properly_derived_from (tree derived
, tree base
)
11971 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
11974 /* We only allow proper derivation here. The DERIVED_FROM_P macro
11975 considers every class derived from itself. */
11976 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
11977 && DERIVED_FROM_P (base
, derived
));
11980 /* We build the ICS for an implicit object parameter as a pointer
11981 conversion sequence. However, such a sequence should be compared
11982 as if it were a reference conversion sequence. If ICS is the
11983 implicit conversion sequence for an implicit object parameter,
11984 modify it accordingly. */
11987 maybe_handle_implicit_object (conversion
**ics
)
11989 if ((*ics
)->this_p
)
11991 /* [over.match.funcs]
11993 For non-static member functions, the type of the
11994 implicit object parameter is "reference to cv X"
11995 where X is the class of which the function is a
11996 member and cv is the cv-qualification on the member
11997 function declaration. */
11998 conversion
*t
= *ics
;
11999 tree reference_type
;
12001 /* The `this' parameter is a pointer to a class type. Make the
12002 implicit conversion talk about a reference to that same class
12004 reference_type
= TREE_TYPE (t
->type
);
12005 reference_type
= build_reference_type (reference_type
);
12007 if (t
->kind
== ck_qual
)
12008 t
= next_conversion (t
);
12009 if (t
->kind
== ck_ptr
)
12010 t
= next_conversion (t
);
12011 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
12012 t
= direct_reference_binding (reference_type
, t
);
12014 t
->rvaluedness_matches_p
= 0;
12019 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
12020 and return the initial reference binding conversion. Otherwise,
12021 leave *ICS unchanged and return NULL. */
12023 static conversion
*
12024 maybe_handle_ref_bind (conversion
**ics
)
12026 if ((*ics
)->kind
== ck_ref_bind
)
12028 conversion
*old_ics
= *ics
;
12029 *ics
= next_conversion (old_ics
);
12030 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
12037 /* Get the expression at the beginning of the conversion chain C. */
12040 conv_get_original_expr (conversion
*c
)
12042 for (; c
; c
= next_conversion (c
))
12043 if (c
->kind
== ck_identity
|| c
->kind
== ck_ambig
|| c
->kind
== ck_aggr
)
12048 /* Return a tree representing the number of elements initialized by the
12049 list-initialization C. The caller must check that C converts to an
12053 nelts_initialized_by_list_init (conversion
*c
)
12055 /* If the array we're converting to has a dimension, we'll use that. */
12056 if (TYPE_DOMAIN (c
->type
))
12057 return array_type_nelts_top (c
->type
);
12060 /* Otherwise, we look at how many elements the constructor we're
12061 initializing from has. */
12062 tree ctor
= conv_get_original_expr (c
);
12063 return size_int (CONSTRUCTOR_NELTS (ctor
));
12067 /* True iff C is a conversion that binds a reference or a pointer to
12068 an array of unknown bound. */
12071 conv_binds_to_array_of_unknown_bound (conversion
*c
)
12073 /* ck_ref_bind won't have the reference stripped. */
12074 tree type
= non_reference (c
->type
);
12075 /* ck_qual won't have the pointer stripped. */
12076 type
= strip_pointer_operator (type
);
12077 return (TREE_CODE (type
) == ARRAY_TYPE
12078 && TYPE_DOMAIN (type
) == NULL_TREE
);
12081 /* Compare two implicit conversion sequences according to the rules set out in
12082 [over.ics.rank]. Return values:
12084 1: ics1 is better than ics2
12085 -1: ics2 is better than ics1
12086 0: ics1 and ics2 are indistinguishable */
12089 compare_ics (conversion
*ics1
, conversion
*ics2
)
12095 tree deref_from_type1
= NULL_TREE
;
12096 tree deref_from_type2
= NULL_TREE
;
12097 tree deref_to_type1
= NULL_TREE
;
12098 tree deref_to_type2
= NULL_TREE
;
12099 conversion_rank rank1
, rank2
;
12101 /* REF_BINDING is nonzero if the result of the conversion sequence
12102 is a reference type. In that case REF_CONV is the reference
12103 binding conversion. */
12104 conversion
*ref_conv1
;
12105 conversion
*ref_conv2
;
12107 /* Compare badness before stripping the reference conversion. */
12108 if (ics1
->bad_p
> ics2
->bad_p
)
12110 else if (ics1
->bad_p
< ics2
->bad_p
)
12113 /* Handle implicit object parameters. */
12114 maybe_handle_implicit_object (&ics1
);
12115 maybe_handle_implicit_object (&ics2
);
12117 /* Handle reference parameters. */
12118 ref_conv1
= maybe_handle_ref_bind (&ics1
);
12119 ref_conv2
= maybe_handle_ref_bind (&ics2
);
12121 /* List-initialization sequence L1 is a better conversion sequence than
12122 list-initialization sequence L2 if L1 converts to
12123 std::initializer_list<X> for some X and L2 does not. */
12124 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
12126 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
12131 When comparing the basic forms of implicit conversion sequences (as
12132 defined in _over.best.ics_)
12134 --a standard conversion sequence (_over.ics.scs_) is a better
12135 conversion sequence than a user-defined conversion sequence
12136 or an ellipsis conversion sequence, and
12138 --a user-defined conversion sequence (_over.ics.user_) is a
12139 better conversion sequence than an ellipsis conversion sequence
12140 (_over.ics.ellipsis_). */
12141 /* Use BAD_CONVERSION_RANK because we already checked for a badness
12142 mismatch. If both ICS are bad, we try to make a decision based on
12143 what would have happened if they'd been good. This is not an
12144 extension, we'll still give an error when we build up the call; this
12145 just helps us give a more helpful error message. */
12146 rank1
= BAD_CONVERSION_RANK (ics1
);
12147 rank2
= BAD_CONVERSION_RANK (ics2
);
12151 else if (rank1
< rank2
)
12154 if (ics1
->ellipsis_p
)
12155 /* Both conversions are ellipsis conversions. */
12158 /* User-defined conversion sequence U1 is a better conversion sequence
12159 than another user-defined conversion sequence U2 if they contain the
12160 same user-defined conversion operator or constructor and if the sec-
12161 ond standard conversion sequence of U1 is better than the second
12162 standard conversion sequence of U2. */
12164 /* Handle list-conversion with the same code even though it isn't always
12165 ranked as a user-defined conversion and it doesn't have a second
12166 standard conversion sequence; it will still have the desired effect.
12167 Specifically, we need to do the reference binding comparison at the
12168 end of this function. */
12170 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
12171 || ics1
->kind
== ck_aggr
|| ics2
->kind
== ck_aggr
)
12173 conversion
*t1
= strip_standard_conversion (ics1
);
12174 conversion
*t2
= strip_standard_conversion (ics2
);
12176 if (!t1
|| !t2
|| t1
->kind
!= t2
->kind
)
12178 else if (t1
->kind
== ck_user
)
12180 tree f1
= t1
->cand
? t1
->cand
->fn
: t1
->type
;
12181 tree f2
= t2
->cand
? t2
->cand
->fn
: t2
->type
;
12185 /* List-initialization sequence L1 is a better conversion sequence than
12186 list-initialization sequence L2 if
12188 -- L1 and L2 convert to arrays of the same element type, and either
12189 the number of elements n1 initialized by L1 is less than the number
12190 of elements n2 initialized by L2, or n1=n2 and L2 converts to an array
12191 of unknown bound and L1 does not. (Added in CWG 1307 and extended by
12193 else if (t1
->kind
== ck_aggr
12194 && TREE_CODE (t1
->type
) == ARRAY_TYPE
12195 && TREE_CODE (t2
->type
) == ARRAY_TYPE
12196 && same_type_p (TREE_TYPE (t1
->type
), TREE_TYPE (t2
->type
)))
12198 tree n1
= nelts_initialized_by_list_init (t1
);
12199 tree n2
= nelts_initialized_by_list_init (t2
);
12200 if (tree_int_cst_lt (n1
, n2
))
12202 else if (tree_int_cst_lt (n2
, n1
))
12204 /* The n1 == n2 case. */
12205 bool c1
= conv_binds_to_array_of_unknown_bound (t1
);
12206 bool c2
= conv_binds_to_array_of_unknown_bound (t2
);
12209 else if (!c1
&& c2
)
12216 /* For ambiguous or aggregate conversions, use the target type as
12217 a proxy for the conversion function. */
12218 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
12222 /* We can just fall through here, after setting up
12223 FROM_TYPE1 and FROM_TYPE2. */
12224 from_type1
= t1
->type
;
12225 from_type2
= t2
->type
;
12232 /* We're dealing with two standard conversion sequences.
12236 Standard conversion sequence S1 is a better conversion
12237 sequence than standard conversion sequence S2 if
12239 --S1 is a proper subsequence of S2 (comparing the conversion
12240 sequences in the canonical form defined by _over.ics.scs_,
12241 excluding any Lvalue Transformation; the identity
12242 conversion sequence is considered to be a subsequence of
12243 any non-identity conversion sequence */
12246 while (t1
->kind
!= ck_identity
)
12247 t1
= next_conversion (t1
);
12248 from_type1
= t1
->type
;
12251 while (t2
->kind
!= ck_identity
)
12252 t2
= next_conversion (t2
);
12253 from_type2
= t2
->type
;
12256 /* One sequence can only be a subsequence of the other if they start with
12257 the same type. They can start with different types when comparing the
12258 second standard conversion sequence in two user-defined conversion
12260 if (same_type_p (from_type1
, from_type2
))
12262 if (is_subseq (ics1
, ics2
))
12264 if (is_subseq (ics2
, ics1
))
12272 --the rank of S1 is better than the rank of S2 (by the rules
12275 Standard conversion sequences are ordered by their ranks: an Exact
12276 Match is a better conversion than a Promotion, which is a better
12277 conversion than a Conversion.
12279 Two conversion sequences with the same rank are indistinguishable
12280 unless one of the following rules applies:
12282 --A conversion that does not a convert a pointer, pointer to member,
12283 or std::nullptr_t to bool is better than one that does.
12285 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
12286 so that we do not have to check it explicitly. */
12287 if (ics1
->rank
< ics2
->rank
)
12289 else if (ics2
->rank
< ics1
->rank
)
12292 to_type1
= ics1
->type
;
12293 to_type2
= ics2
->type
;
12295 /* A conversion from scalar arithmetic type to complex is worse than a
12296 conversion between scalar arithmetic types. */
12297 if (same_type_p (from_type1
, from_type2
)
12298 && ARITHMETIC_TYPE_P (from_type1
)
12299 && ARITHMETIC_TYPE_P (to_type1
)
12300 && ARITHMETIC_TYPE_P (to_type2
)
12301 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
12302 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
12304 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
12311 /* A conversion in either direction between floating-point type FP1 and
12312 floating-point type FP2 is better than a conversion in the same
12313 direction between FP1 and arithmetic type T3 if
12314 - the floating-point conversion rank of FP1 is equal to the rank of
12316 - T3 is not a floating-point type, or T3 is a floating-point type
12317 whose rank is not equal to the rank of FP1, or the floating-point
12318 conversion subrank of FP2 is greater than the subrank of T3. */
12319 tree fp1
= from_type1
;
12320 tree fp2
= to_type1
;
12321 tree fp3
= from_type2
;
12322 tree t3
= to_type2
;
12324 if (TYPE_MAIN_VARIANT (fp2
) == TYPE_MAIN_VARIANT (t3
))
12326 std::swap (fp1
, fp2
);
12327 std::swap (fp3
, t3
);
12329 if (TYPE_MAIN_VARIANT (fp1
) == TYPE_MAIN_VARIANT (fp3
)
12330 && SCALAR_FLOAT_TYPE_P (fp1
)
12331 /* Only apply this rule if at least one of the 3 types is
12332 extended floating-point type, otherwise keep them as
12333 before for compatibility reasons with types like __float128.
12334 float, double and long double alone have different conversion
12335 ranks and so when just those 3 types are involved, this
12336 rule doesn't trigger. */
12337 && (extended_float_type_p (fp1
)
12338 || (SCALAR_FLOAT_TYPE_P (fp2
) && extended_float_type_p (fp2
))
12339 || (SCALAR_FLOAT_TYPE_P (t3
) && extended_float_type_p (t3
))))
12341 if (TREE_CODE (fp2
) != REAL_TYPE
)
12344 std::swap (fp2
, t3
);
12346 if (SCALAR_FLOAT_TYPE_P (fp2
))
12348 /* cp_compare_floating_point_conversion_ranks returns -1, 0 or 1
12349 if the conversion rank is equal (-1 or 1 if the subrank is
12351 if (IN_RANGE (cp_compare_floating_point_conversion_ranks (fp1
,
12355 /* Conversion ranks of FP1 and FP2 are equal. */
12356 if (TREE_CODE (t3
) != REAL_TYPE
12357 || !IN_RANGE (cp_compare_floating_point_conversion_ranks
12360 /* FP1 <-> FP2 conversion is better. */
12362 int c
= cp_compare_floating_point_conversion_ranks (fp2
, t3
);
12363 gcc_assert (IN_RANGE (c
, -1, 1));
12365 /* Conversion subrank of FP2 is greater than subrank of T3.
12366 FP1 <-> FP2 conversion is better. */
12369 /* Conversion subrank of FP2 is less than subrank of T3.
12370 FP1 <-> T3 conversion is better. */
12373 else if (SCALAR_FLOAT_TYPE_P (t3
)
12374 && IN_RANGE (cp_compare_floating_point_conversion_ranks
12377 /* Conversion ranks of FP1 and FP2 are not equal, conversion
12378 ranks of FP1 and T3 are equal.
12379 FP1 <-> T3 conversion is better. */
12385 if (TYPE_PTR_P (from_type1
)
12386 && TYPE_PTR_P (from_type2
)
12387 && TYPE_PTR_P (to_type1
)
12388 && TYPE_PTR_P (to_type2
))
12390 deref_from_type1
= TREE_TYPE (from_type1
);
12391 deref_from_type2
= TREE_TYPE (from_type2
);
12392 deref_to_type1
= TREE_TYPE (to_type1
);
12393 deref_to_type2
= TREE_TYPE (to_type2
);
12395 /* The rules for pointers to members A::* are just like the rules
12396 for pointers A*, except opposite: if B is derived from A then
12397 A::* converts to B::*, not vice versa. For that reason, we
12398 switch the from_ and to_ variables here. */
12399 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
12400 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
12401 || (TYPE_PTRMEMFUNC_P (from_type1
)
12402 && TYPE_PTRMEMFUNC_P (from_type2
)
12403 && TYPE_PTRMEMFUNC_P (to_type1
)
12404 && TYPE_PTRMEMFUNC_P (to_type2
)))
12406 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
12407 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
12408 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
12409 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
12412 if (deref_from_type1
!= NULL_TREE
12413 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
12414 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
12416 /* This was one of the pointer or pointer-like conversions.
12420 --If class B is derived directly or indirectly from class A,
12421 conversion of B* to A* is better than conversion of B* to
12422 void*, and conversion of A* to void* is better than
12423 conversion of B* to void*. */
12424 if (VOID_TYPE_P (deref_to_type1
)
12425 && VOID_TYPE_P (deref_to_type2
))
12427 if (is_properly_derived_from (deref_from_type1
,
12430 else if (is_properly_derived_from (deref_from_type2
,
12434 else if (VOID_TYPE_P (deref_to_type1
)
12435 || VOID_TYPE_P (deref_to_type2
))
12437 if (same_type_p (deref_from_type1
, deref_from_type2
))
12439 if (VOID_TYPE_P (deref_to_type2
))
12441 if (is_properly_derived_from (deref_from_type1
,
12445 /* We know that DEREF_TO_TYPE1 is `void' here. */
12446 else if (is_properly_derived_from (deref_from_type1
,
12451 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
12452 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
12456 --If class B is derived directly or indirectly from class A
12457 and class C is derived directly or indirectly from B,
12459 --conversion of C* to B* is better than conversion of C* to
12462 --conversion of B* to A* is better than conversion of C* to
12464 if (same_type_p (deref_from_type1
, deref_from_type2
))
12466 if (is_properly_derived_from (deref_to_type1
,
12469 else if (is_properly_derived_from (deref_to_type2
,
12473 else if (same_type_p (deref_to_type1
, deref_to_type2
))
12475 if (is_properly_derived_from (deref_from_type2
,
12478 else if (is_properly_derived_from (deref_from_type1
,
12484 else if (CLASS_TYPE_P (non_reference (from_type1
))
12485 && same_type_p (from_type1
, from_type2
))
12487 tree from
= non_reference (from_type1
);
12491 --binding of an expression of type C to a reference of type
12492 B& is better than binding an expression of type C to a
12493 reference of type A&
12495 --conversion of C to B is better than conversion of C to A, */
12496 if (is_properly_derived_from (from
, to_type1
)
12497 && is_properly_derived_from (from
, to_type2
))
12499 if (is_properly_derived_from (to_type1
, to_type2
))
12501 else if (is_properly_derived_from (to_type2
, to_type1
))
12505 else if (CLASS_TYPE_P (non_reference (to_type1
))
12506 && same_type_p (to_type1
, to_type2
))
12508 tree to
= non_reference (to_type1
);
12512 --binding of an expression of type B to a reference of type
12513 A& is better than binding an expression of type C to a
12514 reference of type A&,
12516 --conversion of B to A is better than conversion of C to A */
12517 if (is_properly_derived_from (from_type1
, to
)
12518 && is_properly_derived_from (from_type2
, to
))
12520 if (is_properly_derived_from (from_type2
, from_type1
))
12522 else if (is_properly_derived_from (from_type1
, from_type2
))
12529 --S1 and S2 differ only in their qualification conversion and yield
12530 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
12531 qualification signature of type T1 is a proper subset of the cv-
12532 qualification signature of type T2 */
12533 if (ics1
->kind
== ck_qual
12534 && ics2
->kind
== ck_qual
12535 && same_type_p (from_type1
, from_type2
))
12537 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
12544 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
12545 to an implicit object parameter of a non-static member function
12546 declared without a ref-qualifier, and either S1 binds an lvalue
12547 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
12548 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
12549 draft standard, 13.3.3.2)
12551 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
12552 types to which the references refer are the same type except for
12553 top-level cv-qualifiers, and the type to which the reference
12554 initialized by S2 refers is more cv-qualified than the type to
12555 which the reference initialized by S1 refers.
12557 DR 1328 [over.match.best]: the context is an initialization by
12558 conversion function for direct reference binding (13.3.1.6) of a
12559 reference to function type, the return type of F1 is the same kind of
12560 reference (i.e. lvalue or rvalue) as the reference being initialized,
12561 and the return type of F2 is not. */
12563 if (ref_conv1
&& ref_conv2
)
12565 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
12566 && (ref_conv1
->rvaluedness_matches_p
12567 != ref_conv2
->rvaluedness_matches_p
)
12568 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
12569 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
12570 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
12572 if (ref_conv1
->bad_p
12573 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
12574 TREE_TYPE (ref_conv2
->type
)))
12575 /* Don't prefer a bad conversion that drops cv-quals to a bad
12576 conversion with the wrong rvalueness. */
12578 return (ref_conv1
->rvaluedness_matches_p
12579 - ref_conv2
->rvaluedness_matches_p
);
12582 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
12586 void f (int(&)[]), // (1)
12587 f (int(&)[1]), // (2)
12590 (2) is better than (1), but (3) should be equal to (1) and to
12591 (2). For that reason we don't use ck_qual for (1) which would
12592 give it the cr_exact rank while (3) remains ck_identity.
12593 Therefore we compare (1) and (2) here. For (1) we'll have
12595 ck_ref_bind <- ck_identity
12598 so to handle this we must look at ref_conv. */
12599 bool c1
= conv_binds_to_array_of_unknown_bound (ref_conv1
);
12600 bool c2
= conv_binds_to_array_of_unknown_bound (ref_conv2
);
12603 else if (!c1
&& c2
)
12606 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
12607 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
12608 if (ref_conv1
->bad_p
)
12610 /* Prefer the one that drops fewer cv-quals. */
12611 tree ftype
= next_conversion (ref_conv1
)->type
;
12612 int fquals
= cp_type_quals (ftype
);
12616 return comp_cv_qualification (q2
, q1
);
12623 -- A conversion that promotes an enumeration whose underlying type
12624 is fixed to its underlying type is better than one that promotes to
12625 the promoted underlying type, if the two are different. */
12626 if (ics1
->rank
== cr_promotion
12627 && ics2
->rank
== cr_promotion
12628 && UNSCOPED_ENUM_P (from_type1
)
12629 && ENUM_FIXED_UNDERLYING_TYPE_P (from_type1
)
12630 && same_type_p (from_type1
, from_type2
))
12632 tree utype
= ENUM_UNDERLYING_TYPE (from_type1
);
12633 tree prom
= type_promotes_to (from_type1
);
12634 if (!same_type_p (utype
, prom
))
12636 if (same_type_p (to_type1
, utype
)
12637 && same_type_p (to_type2
, prom
))
12639 else if (same_type_p (to_type2
, utype
)
12640 && same_type_p (to_type1
, prom
))
12645 /* Neither conversion sequence is better than the other. */
12649 /* The source type for this standard conversion sequence. */
12652 source_type (conversion
*t
)
12654 return strip_standard_conversion (t
)->type
;
12657 /* Note a warning about preferring WINNER to LOSER. We do this by storing
12658 a pointer to LOSER and re-running joust to produce the warning if WINNER
12659 is actually used. */
12662 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
12664 candidate_warning
*cw
= (candidate_warning
*)
12665 conversion_obstack_alloc (sizeof (candidate_warning
));
12667 cw
->next
= winner
->warnings
;
12668 winner
->warnings
= cw
;
12671 /* CAND is a constructor candidate in joust in C++17 and up. If it copies a
12672 prvalue returned from a conversion function, return true. Otherwise, return
12676 joust_maybe_elide_copy (z_candidate
*cand
)
12678 tree fn
= cand
->fn
;
12679 if (!DECL_COPY_CONSTRUCTOR_P (fn
) && !DECL_MOVE_CONSTRUCTOR_P (fn
))
12681 conversion
*conv
= cand
->convs
[0];
12682 if (conv
->kind
== ck_ambig
)
12684 gcc_checking_assert (conv
->kind
== ck_ref_bind
);
12685 conv
= next_conversion (conv
);
12686 if (conv
->kind
== ck_user
&& !TYPE_REF_P (conv
->type
))
12688 gcc_checking_assert (same_type_ignoring_top_level_qualifiers_p
12689 (conv
->type
, DECL_CONTEXT (fn
)));
12690 z_candidate
*uc
= conv
->cand
;
12691 if (DECL_CONV_FN_P (uc
->fn
))
12697 /* Return the class that CAND's implicit object parameter refers to. */
12700 class_of_implicit_object (z_candidate
*cand
)
12702 if (!DECL_IOBJ_MEMBER_FUNCTION_P (cand
->fn
))
12705 /* "For conversion functions that are implicit object member functions,
12706 the function is considered to be a member of the class of the implied
12707 object argument for the purpose of defining the type of the implicit
12708 object parameter." */
12709 if (DECL_CONV_FN_P (cand
->fn
))
12710 return TYPE_MAIN_VARIANT (TREE_TYPE (cand
->first_arg
));
12712 /* "For non-conversion functions that are implicit object member
12713 functions nominated by a using-declaration in a derived class, the
12714 function is considered to be a member of the derived class for the
12715 purpose of defining the type of the implicit object parameter."
12717 That derived class is reflected in the conversion_path binfo. */
12718 return BINFO_TYPE (cand
->conversion_path
);
12721 /* True if candidates C1 and C2 have corresponding object parameters per
12722 [basic.scope.scope]. */
12725 object_parms_correspond (z_candidate
*c1
, tree fn1
, z_candidate
*c2
, tree fn2
)
12727 tree context
= class_of_implicit_object (c1
);
12728 tree ctx2
= class_of_implicit_object (c2
);
12730 /* Leave context as is. */;
12733 else if (context
!= ctx2
)
12734 /* This can't happen for normal function calls, since it means finding
12735 functions in multiple bases which would fail with an ambiguous lookup,
12736 but it can occur with reversed operators. */
12739 return object_parms_correspond (fn1
, fn2
, context
);
12742 /* Return whether the first parameter of C1 matches the second parameter
12746 reversed_match (z_candidate
*c1
, z_candidate
*c2
)
12749 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (c2
->fn
));
12750 tree parm2
= TREE_VALUE (TREE_CHAIN (parms2
));
12751 if (DECL_IOBJ_MEMBER_FUNCTION_P (fn1
))
12753 tree ctx
= class_of_implicit_object (c1
);
12754 return iobj_parm_corresponds_to (fn1
, parm2
, ctx
);
12758 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (fn1
));
12759 tree parm1
= TREE_VALUE (parms1
);
12760 return same_type_p (parm1
, parm2
);
12764 /* True if the defining declarations of the two candidates have equivalent
12765 parameters. MATCH_KIND controls whether we're trying to compare the
12766 original declarations (for a warning) or the actual candidates. */
12768 enum class pmatch
{ original
, current
};
12771 cand_parms_match (z_candidate
*c1
, z_candidate
*c2
, pmatch match_kind
)
12775 bool reversed
= (match_kind
== pmatch::current
12776 && c1
->reversed () != c2
->reversed ());
12777 if (fn1
== fn2
&& !reversed
)
12779 if (identifier_p (fn1
) || identifier_p (fn2
))
12781 if (match_kind
== pmatch::original
)
12783 /* We don't look at c1->template_decl because that's only set for
12784 primary templates, not e.g. non-template member functions of
12785 class templates. */
12786 tree t1
= most_general_template (fn1
);
12787 tree t2
= most_general_template (fn2
);
12794 fn1
= DECL_TEMPLATE_RESULT (t1
);
12795 fn2
= DECL_TEMPLATE_RESULT (t2
);
12800 return (reversed_match (c1
, c2
)
12801 && reversed_match (c2
, c1
));
12803 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (fn1
));
12804 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (fn2
));
12806 if (!(DECL_FUNCTION_MEMBER_P (fn1
)
12807 && DECL_FUNCTION_MEMBER_P (fn2
)))
12808 /* Early escape. */;
12810 /* CWG2789 is not adequate, it should specify corresponding object
12811 parameters, not same typed object parameters. */
12812 else if (!object_parms_correspond (c1
, fn1
, c2
, fn2
))
12816 /* We just compared the object parameters, if they don't correspond
12817 we already returned false. */
12818 auto skip_parms
= [] (tree fn
, tree parms
)
12820 if (DECL_XOBJ_MEMBER_FUNCTION_P (fn
))
12821 return TREE_CHAIN (parms
);
12823 return skip_artificial_parms_for (fn
, parms
);
12825 parms1
= skip_parms (fn1
, parms1
);
12826 parms2
= skip_parms (fn2
, parms2
);
12828 return compparms (parms1
, parms2
);
12831 /* True iff FN is a copy or move constructor or assignment operator. */
12834 sfk_copy_or_move (tree fn
)
12836 if (TREE_CODE (fn
) != FUNCTION_DECL
)
12838 special_function_kind sfk
= special_function_p (fn
);
12839 return sfk
>= sfk_copy_constructor
&& sfk
<= sfk_move_assignment
;
12842 /* Compare two candidates for overloading as described in
12843 [over.match.best]. Return values:
12845 1: cand1 is better than cand2
12846 -1: cand2 is better than cand1
12847 0: cand1 and cand2 are indistinguishable */
12850 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
12851 tsubst_flags_t complain
)
12854 int off1
= 0, off2
= 0;
12858 /* Candidates that involve bad conversions are always worse than those
12860 if (cand1
->viable
> cand2
->viable
)
12862 if (cand1
->viable
< cand2
->viable
)
12865 /* If we have two pseudo-candidates for conversions to the same type,
12866 or two candidates for the same function, arbitrarily pick one. */
12867 if (cand1
->fn
== cand2
->fn
12868 && cand1
->reversed () == cand2
->reversed ()
12869 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
12872 /* Prefer a non-deleted function over an implicitly deleted move
12873 constructor or assignment operator. This differs slightly from the
12874 wording for issue 1402 (which says the move op is ignored by overload
12875 resolution), but this way produces better error messages. */
12876 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
12877 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
12878 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
12880 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
12881 && move_fn_p (cand1
->fn
))
12883 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
12884 && move_fn_p (cand2
->fn
))
12888 /* a viable function F1
12889 is defined to be a better function than another viable function F2 if
12890 for all arguments i, ICSi(F1) is not a worse conversion sequence than
12891 ICSi(F2), and then */
12893 /* for some argument j, ICSj(F1) is a better conversion sequence than
12896 /* For comparing static and non-static member functions, we ignore
12897 the implicit object parameter of the non-static function. The
12898 standard says to pretend that the static function has an object
12899 parm, but that won't work with operator overloading. */
12900 len
= cand1
->num_convs
;
12901 if (len
!= cand2
->num_convs
)
12903 int static_1
= (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
12904 && DECL_STATIC_FUNCTION_P (cand1
->fn
));
12905 int static_2
= (TREE_CODE (cand2
->fn
) == FUNCTION_DECL
12906 && DECL_STATIC_FUNCTION_P (cand2
->fn
));
12908 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
12909 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
12910 && DECL_CONSTRUCTOR_P (cand1
->fn
)
12911 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
12912 /* We're comparing a near-match list constructor and a near-match
12913 non-list constructor. Just treat them as unordered. */
12916 gcc_assert (static_1
!= static_2
);
12920 /* C++23 [over.best.ics.general] says:
12921 When the parameter is the implicit object parameter of a static
12922 member function, the implicit conversion sequence is a standard
12923 conversion sequence that is neither better nor worse than any
12924 other standard conversion sequence. */
12925 if (CONVERSION_RANK (cand2
->convs
[0]) >= cr_user
)
12931 if (CONVERSION_RANK (cand1
->convs
[0]) >= cr_user
)
12938 for (i
= 0; i
< len
; ++i
)
12940 conversion
*t1
= cand1
->convs
[i
+ off1
];
12941 conversion
*t2
= cand2
->convs
[i
+ off2
];
12942 int comp
= compare_ics (t1
, t2
);
12946 if ((complain
& tf_warning
)
12948 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
12949 == cr_std
+ cr_promotion
)
12950 && t1
->kind
== ck_std
12951 && t2
->kind
== ck_std
12952 && TREE_CODE (t1
->type
) == INTEGER_TYPE
12953 && TREE_CODE (t2
->type
) == INTEGER_TYPE
12954 && (TYPE_PRECISION (t1
->type
)
12955 == TYPE_PRECISION (t2
->type
))
12956 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
12957 || (TREE_CODE (next_conversion (t1
)->type
)
12958 == ENUMERAL_TYPE
)))
12960 tree type
= next_conversion (t1
)->type
;
12962 struct z_candidate
*w
, *l
;
12964 type1
= t1
->type
, type2
= t2
->type
,
12965 w
= cand1
, l
= cand2
;
12967 type1
= t2
->type
, type2
= t1
->type
,
12968 w
= cand2
, l
= cand1
;
12972 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
12973 type
, type1
, type2
);
12974 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
12977 add_warning (w
, l
);
12980 if (winner
&& comp
!= winner
)
12982 /* Ambiguity between normal and reversed comparison operators
12983 with the same parameter types. P2468 decided not to go with
12984 this approach to resolving the ambiguity, so pedwarn. */
12985 if ((complain
& tf_warning_or_error
)
12986 && (cand1
->reversed () != cand2
->reversed ())
12987 && cand_parms_match (cand1
, cand2
, pmatch::original
))
12989 struct z_candidate
*w
, *l
;
12990 if (cand2
->reversed ())
12991 winner
= 1, w
= cand1
, l
= cand2
;
12993 winner
= -1, w
= cand2
, l
= cand1
;
12996 auto_diagnostic_group d
;
12997 if (pedwarn (input_location
, 0,
12998 "C++20 says that these are ambiguous, "
12999 "even though the second is reversed:"))
13001 print_z_candidate (input_location
,
13002 N_("candidate 1:"), w
);
13003 print_z_candidate (input_location
,
13004 N_("candidate 2:"), l
);
13006 && DECL_IOBJ_MEMBER_FUNCTION_P (w
->fn
)
13007 && (type_memfn_quals (TREE_TYPE (w
->fn
))
13008 & TYPE_QUAL_CONST
) == 0)
13010 /* Suggest adding const to
13011 struct A { bool operator==(const A&); }; */
13013 = FUNCTION_FIRST_USER_PARMTYPE (w
->fn
);
13014 parmtype
= TREE_VALUE (parmtype
);
13015 if (TYPE_REF_P (parmtype
)
13016 && TYPE_READONLY (TREE_TYPE (parmtype
))
13017 && (same_type_ignoring_top_level_qualifiers_p
13018 (TREE_TYPE (parmtype
),
13019 DECL_CONTEXT (w
->fn
))))
13020 inform (DECL_SOURCE_LOCATION (w
->fn
),
13021 "try making the operator a %<const%> "
13022 "member function");
13027 add_warning (w
, l
);
13038 /* warn about confusing overload resolution for user-defined conversions,
13039 either between a constructor and a conversion op, or between two
13041 if ((complain
& tf_warning
)
13042 /* In C++17, the constructor might have been elided, which means that
13043 an originally null ->second_conv could become non-null. */
13044 && winner
&& warn_conversion
&& cand1
->second_conv
&& cand2
->second_conv
13045 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
13046 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
13048 struct z_candidate
*w
, *l
;
13049 bool give_warning
= false;
13052 w
= cand1
, l
= cand2
;
13054 w
= cand2
, l
= cand1
;
13056 /* We don't want to complain about `X::operator T1 ()'
13057 beating `X::operator T2 () const', when T2 is a no less
13058 cv-qualified version of T1. */
13059 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
13060 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
13062 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
13063 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
13065 if (TREE_CODE (t
) == TREE_CODE (f
) && INDIRECT_TYPE_P (t
))
13070 if (!comp_ptr_ttypes (t
, f
))
13071 give_warning
= true;
13074 give_warning
= true;
13080 tree source
= source_type (w
->convs
[0]);
13081 if (INDIRECT_TYPE_P (source
))
13082 source
= TREE_TYPE (source
);
13083 auto_diagnostic_group d
;
13084 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
13085 && warning (OPT_Wconversion
, " for conversion from %qH to %qI",
13086 source
, w
->second_conv
->type
))
13088 inform (input_location
, " because conversion sequence "
13089 "for the argument is better");
13093 add_warning (w
, l
);
13099 /* DR 495 moved this tiebreaker above the template ones. */
13100 /* or, if not that,
13101 the context is an initialization by user-defined conversion (see
13102 _dcl.init_ and _over.match.user_) and the standard conversion
13103 sequence from the return type of F1 to the destination type (i.e.,
13104 the type of the entity being initialized) is a better conversion
13105 sequence than the standard conversion sequence from the return type
13106 of F2 to the destination type. */
13108 if (cand1
->second_conv
)
13110 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
13115 /* CWG2735 (PR109247): A copy/move ctor/op= for which its operand uses an
13116 explicit conversion (due to list-initialization) is worse. */
13118 z_candidate
*sp
= nullptr;
13119 if (sfk_copy_or_move (cand1
->fn
))
13121 if (sfk_copy_or_move (cand2
->fn
))
13122 sp
= sp
? nullptr : cand2
;
13125 conversion
*conv
= sp
->convs
[!DECL_CONSTRUCTOR_P (sp
->fn
)];
13126 if (conv
->user_conv_p
)
13127 for (; conv
; conv
= next_conversion (conv
))
13128 if (conv
->kind
== ck_user
13129 && DECL_P (conv
->cand
->fn
)
13130 && DECL_NONCONVERTING_P (conv
->cand
->fn
))
13131 return (sp
== cand1
) ? -1 : 1;
13135 /* DR2327: C++17 copy elision in [over.match.ctor] (direct-init) context.
13136 The standard currently says that only constructors are candidates, but if
13137 one copies a prvalue returned by a conversion function we prefer that.
13139 Clang does something similar, as discussed at
13140 http://lists.isocpp.org/core/2017/10/3166.php
13141 http://lists.isocpp.org/core/2019/03/5721.php */
13142 if (len
== 1 && cxx_dialect
>= cxx17
13143 && DECL_P (cand1
->fn
)
13144 && DECL_COMPLETE_CONSTRUCTOR_P (cand1
->fn
)
13145 && !(cand1
->flags
& LOOKUP_ONLYCONVERTING
))
13147 bool elided1
= joust_maybe_elide_copy (cand1
);
13148 bool elided2
= joust_maybe_elide_copy (cand2
);
13149 winner
= elided1
- elided2
;
13154 /* or, if not that,
13155 F1 is a non-template function and F2 is a template function
13158 if (!cand1
->template_decl
&& cand2
->template_decl
)
13160 else if (cand1
->template_decl
&& !cand2
->template_decl
)
13163 /* or, if not that,
13164 F1 and F2 are template functions and the function template for F1 is
13165 more specialized than the template for F2 according to the partial
13168 if (cand1
->template_decl
&& cand2
->template_decl
)
13170 winner
= more_specialized_fn
13171 (TI_TEMPLATE (cand1
->template_decl
),
13172 TI_TEMPLATE (cand2
->template_decl
),
13173 /* [temp.func.order]: The presence of unused ellipsis and default
13174 arguments has no effect on the partial ordering of function
13175 templates. add_function_candidate() will not have
13176 counted the "this" argument for constructors. */
13177 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
13182 /* Concepts: F1 and F2 are non-template functions with the same
13183 parameter-type-lists, and F1 is more constrained than F2 according to the
13184 partial ordering of constraints described in 13.5.4. */
13186 if (flag_concepts
&& DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
13187 && !cand1
->template_decl
&& !cand2
->template_decl
13188 && cand_parms_match (cand1
, cand2
, pmatch::current
))
13190 winner
= more_constrained (cand1
->fn
, cand2
->fn
);
13195 /* F2 is a rewritten candidate (12.4.1.2) and F1 is not, or F1 and F2 are
13196 rewritten candidates, and F2 is a synthesized candidate with reversed
13197 order of parameters and F1 is not. */
13198 if (cand1
->rewritten ())
13200 if (!cand2
->rewritten ())
13202 if (!cand1
->reversed () && cand2
->reversed ())
13204 if (cand1
->reversed () && !cand2
->reversed ())
13207 else if (cand2
->rewritten ())
13210 /* F1 is generated from a deduction-guide (13.3.1.8) and F2 is not */
13211 if (deduction_guide_p (cand1
->fn
))
13213 gcc_assert (deduction_guide_p (cand2
->fn
));
13214 /* We distinguish between candidates from an explicit deduction guide and
13215 candidates built from a constructor based on DECL_ARTIFICIAL. */
13216 int art1
= DECL_ARTIFICIAL (cand1
->fn
);
13217 int art2
= DECL_ARTIFICIAL (cand2
->fn
);
13219 return art2
- art1
;
13223 /* Prefer the special copy guide over a declared copy/move
13225 if (copy_guide_p (cand1
->fn
))
13227 if (copy_guide_p (cand2
->fn
))
13230 /* Prefer a candidate generated from a non-template constructor. */
13231 int tg1
= template_guide_p (cand1
->fn
);
13232 int tg2
= template_guide_p (cand2
->fn
);
13238 /* F1 is a member of a class D, F2 is a member of a base class B of D, and
13239 for all arguments the corresponding parameters of F1 and F2 have the same
13240 type (CWG 2273/2277). */
13241 if (DECL_P (cand1
->fn
) && DECL_CLASS_SCOPE_P (cand1
->fn
)
13242 && !DECL_CONV_FN_P (cand1
->fn
)
13243 && DECL_P (cand2
->fn
) && DECL_CLASS_SCOPE_P (cand2
->fn
)
13244 && !DECL_CONV_FN_P (cand2
->fn
))
13246 tree base1
= DECL_CONTEXT (strip_inheriting_ctors (cand1
->fn
));
13247 tree base2
= DECL_CONTEXT (strip_inheriting_ctors (cand2
->fn
));
13249 bool used1
= false;
13250 bool used2
= false;
13251 if (base1
== base2
)
13252 /* No difference. */;
13253 else if (DERIVED_FROM_P (base1
, base2
))
13255 else if (DERIVED_FROM_P (base2
, base1
))
13258 if (int diff
= used2
- used1
)
13260 for (i
= 0; i
< len
; ++i
)
13262 conversion
*t1
= cand1
->convs
[i
+ off1
];
13263 conversion
*t2
= cand2
->convs
[i
+ off2
];
13264 if (!same_type_p (t1
->type
, t2
->type
))
13272 /* Check whether we can discard a builtin candidate, either because we
13273 have two identical ones or matching builtin and non-builtin candidates.
13275 (Pedantically in the latter case the builtin which matched the user
13276 function should not be added to the overload set, but we spot it here.
13279 ... the builtin candidates include ...
13280 - do not have the same parameter type list as any non-template
13281 non-member candidate. */
13283 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
13285 for (i
= 0; i
< len
; ++i
)
13286 if (!same_type_p (cand1
->convs
[i
]->type
,
13287 cand2
->convs
[i
]->type
))
13289 if (i
== cand1
->num_convs
)
13291 if (cand1
->fn
== cand2
->fn
)
13292 /* Two built-in candidates; arbitrarily pick one. */
13294 else if (identifier_p (cand1
->fn
))
13295 /* cand1 is built-in; prefer cand2. */
13298 /* cand2 is built-in; prefer cand1. */
13303 /* For candidates of a multi-versioned function, make the version with
13304 the highest priority win. This version will be checked for dispatching
13305 first. If this version can be inlined into the caller, the front-end
13306 will simply make a direct call to this function. */
13308 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
13309 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
13310 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
13311 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
13313 tree f1
= TREE_TYPE (cand1
->fn
);
13314 tree f2
= TREE_TYPE (cand2
->fn
);
13315 tree p1
= TYPE_ARG_TYPES (f1
);
13316 tree p2
= TYPE_ARG_TYPES (f2
);
13318 /* Check if cand1->fn and cand2->fn are versions of the same function. It
13319 is possible that cand1->fn and cand2->fn are function versions but of
13320 different functions. Check types to see if they are versions of the same
13322 if (compparms (p1
, p2
)
13323 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
13325 /* Always make the version with the higher priority, more
13326 specialized, win. */
13327 gcc_assert (targetm
.compare_version_priority
);
13328 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
13335 /* If the two function declarations represent the same function (this can
13336 happen with declarations in multiple scopes and arg-dependent lookup),
13337 arbitrarily choose one. But first make sure the default args we're
13339 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
13340 && equal_functions (cand1
->fn
, cand2
->fn
))
13342 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
13343 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
13345 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
13347 for (i
= 0; i
< len
; ++i
)
13349 /* Don't crash if the fn is variadic. */
13352 parms1
= TREE_CHAIN (parms1
);
13353 parms2
= TREE_CHAIN (parms2
);
13357 parms1
= TREE_CHAIN (parms1
);
13359 parms2
= TREE_CHAIN (parms2
);
13361 for (; parms1
; ++i
)
13363 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
13364 TREE_PURPOSE (parms2
)))
13368 if (complain
& tf_error
)
13370 auto_diagnostic_group d
;
13371 if (permerror (input_location
,
13372 "default argument mismatch in "
13373 "overload resolution"))
13375 inform (DECL_SOURCE_LOCATION (cand1
->fn
),
13376 " candidate 1: %q#F", cand1
->fn
);
13377 inform (DECL_SOURCE_LOCATION (cand2
->fn
),
13378 " candidate 2: %q#F", cand2
->fn
);
13385 add_warning (cand1
, cand2
);
13388 parms1
= TREE_CHAIN (parms1
);
13389 parms2
= TREE_CHAIN (parms2
);
13397 /* Extension: If the worst conversion for one candidate is better than the
13398 worst conversion for the other, take the first. */
13399 if (!pedantic
&& (complain
& tf_warning_or_error
))
13401 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
13402 struct z_candidate
*w
= 0, *l
= 0;
13404 for (i
= 0; i
< len
; ++i
)
13406 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
13407 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
13408 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
13409 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
13412 winner
= 1, w
= cand1
, l
= cand2
;
13414 winner
= -1, w
= cand2
, l
= cand1
;
13417 /* Don't choose a deleted function over ambiguity. */
13418 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
13422 auto_diagnostic_group d
;
13423 if (pedwarn (input_location
, 0,
13424 "ISO C++ says that these are ambiguous, even "
13425 "though the worst conversion for the first is "
13426 "better than the worst conversion for the second:"))
13428 print_z_candidate (input_location
, N_("candidate 1:"), w
);
13429 print_z_candidate (input_location
, N_("candidate 2:"), l
);
13433 add_warning (w
, l
);
13438 gcc_assert (!winner
);
13442 /* Given a list of candidates for overloading, find the best one, if any.
13443 This algorithm has a worst case of O(2n) (winner is last), and a best
13444 case of O(n/2) (totally ambiguous); much better than a sorting
13445 algorithm. The candidates list is assumed to be sorted according
13446 to viability (via splice_viable). */
13448 static struct z_candidate
*
13449 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
13451 struct z_candidate
**champ
= &candidates
, **challenger
;
13453 struct z_candidate
*previous_worse_champ
= nullptr;
13455 /* Walk through the list once, comparing each current champ to the next
13456 candidate, knocking out a candidate or two with each comparison. */
13458 for (challenger
= &candidates
->next
; *challenger
&& (*challenger
)->viable
; )
13460 fate
= joust (*champ
, *challenger
, 0, complain
);
13462 challenger
= &(*challenger
)->next
;
13463 else if (fate
== -1)
13465 previous_worse_champ
= *champ
;
13466 champ
= challenger
;
13467 challenger
= &(*challenger
)->next
;
13471 previous_worse_champ
= nullptr;
13472 champ
= &(*challenger
)->next
;
13473 if (!*champ
|| !(*champ
)->viable
)
13478 challenger
= &(*champ
)->next
;
13482 /* Make sure the champ is better than all the candidates it hasn't yet
13483 been compared to. */
13486 for (challenger
= &candidates
;
13487 challenger
!= champ
;
13488 challenger
= &(*challenger
)->next
)
13490 if (*challenger
== previous_worse_champ
)
13491 /* We already know this candidate is worse than the champ. */
13493 fate
= joust (*champ
, *challenger
, 0, complain
);
13504 /* Move the champ to the front of the candidate list. */
13506 if (champ
!= &candidates
)
13508 z_candidate
*saved_champ
= *champ
;
13509 *champ
= saved_champ
->next
;
13510 saved_champ
->next
= candidates
;
13511 candidates
= saved_champ
;
13517 /* Returns nonzero if things of type FROM can be converted to TO. */
13520 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
13522 tree arg
= NULL_TREE
;
13523 /* implicit_conversion only considers user-defined conversions
13524 if it has an expression for the call argument list. */
13525 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
13526 arg
= build_stub_object (from
);
13527 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
13530 /* Returns nonzero if things of type FROM can be converted to TO with a
13531 standard conversion. */
13534 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
13536 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
13539 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
13542 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
13543 tsubst_flags_t complain
)
13548 conversion_obstack_sentinel cos
;
13549 /* We want to discard any access checks done for this test,
13550 as we might not be in the appropriate access context and
13551 we'll do the check again when we actually perform the
13553 push_deferring_access_checks (dk_deferred
);
13555 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
13557 ok_p
= (t
&& !t
->bad_p
);
13559 /* Discard the access checks now. */
13560 pop_deferring_access_checks ();
13565 /* Like can_convert_arg, but allows dubious conversions as well. */
13568 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
13569 tsubst_flags_t complain
)
13573 conversion_obstack_sentinel cos
;
13574 /* Try to perform the conversion. */
13575 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
13581 /* Return an IMPLICIT_CONV_EXPR from EXPR to TYPE with bits set from overload
13582 resolution FLAGS. */
13585 build_implicit_conv_flags (tree type
, tree expr
, int flags
)
13587 /* In a template, we are only concerned about determining the
13588 type of non-dependent expressions, so we do not have to
13589 perform the actual conversion. But for initializers, we
13590 need to be able to perform it at instantiation
13591 (or instantiate_non_dependent_expr) time. */
13592 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
13593 if (!(flags
& LOOKUP_ONLYCONVERTING
))
13594 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
13595 if (flags
& LOOKUP_NO_NARROWING
)
13596 IMPLICIT_CONV_EXPR_BRACED_INIT (expr
) = true;
13600 /* Convert EXPR to TYPE. Return the converted expression.
13602 Note that we allow bad conversions here because by the time we get to
13603 this point we are committed to doing the conversion. If we end up
13604 doing a bad conversion, convert_like will complain. */
13607 perform_implicit_conversion_flags (tree type
, tree expr
,
13608 tsubst_flags_t complain
, int flags
)
13611 location_t loc
= cp_expr_loc_or_input_loc (expr
);
13613 if (TYPE_REF_P (type
))
13614 expr
= mark_lvalue_use (expr
);
13616 expr
= mark_rvalue_use (expr
);
13618 if (error_operand_p (expr
))
13619 return error_mark_node
;
13621 conversion_obstack_sentinel cos
;
13623 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
13624 /*c_cast_p=*/false,
13629 if (complain
& tf_error
)
13630 implicit_conversion_error (loc
, type
, expr
);
13631 expr
= error_mark_node
;
13633 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
13634 expr
= build_implicit_conv_flags (type
, expr
, flags
);
13637 /* Give a conversion call the same location as expr. */
13638 iloc_sentinel
il (loc
);
13639 expr
= convert_like (conv
, expr
, complain
);
13646 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
13648 return perform_implicit_conversion_flags (type
, expr
, complain
,
13652 /* Convert EXPR to TYPE (as a direct-initialization) if that is
13653 permitted. If the conversion is valid, the converted expression is
13654 returned. Otherwise, NULL_TREE is returned, except in the case
13655 that TYPE is a class type; in that case, an error is issued. If
13656 C_CAST_P is true, then this direct-initialization is taking
13657 place as part of a static_cast being attempted as part of a C-style
13661 perform_direct_initialization_if_possible (tree type
,
13664 tsubst_flags_t complain
)
13668 if (type
== error_mark_node
|| error_operand_p (expr
))
13669 return error_mark_node
;
13672 If the destination type is a (possibly cv-qualified) class type:
13674 -- If the initialization is direct-initialization ...,
13675 constructors are considered.
13677 -- If overload resolution is successful, the selected constructor
13678 is called to initialize the object, with the initializer expression
13679 or expression-list as its argument(s).
13681 -- Otherwise, if no constructor is viable, the destination type is
13682 a (possibly cv-qualified) aggregate class A, and the initializer is
13683 a parenthesized expression-list, the object is initialized as
13685 if (CLASS_TYPE_P (type
))
13687 releasing_vec
args (make_tree_vector_single (expr
));
13688 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
13689 &args
, type
, LOOKUP_NORMAL
, complain
);
13690 return build_cplus_new (type
, expr
, complain
);
13693 conversion_obstack_sentinel cos
;
13695 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
13697 LOOKUP_NORMAL
, complain
);
13698 if (!conv
|| conv
->bad_p
)
13700 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
13702 /* In a template, we are only concerned about determining the
13703 type of non-dependent expressions, so we do not have to
13704 perform the actual conversion. But for initializers, we
13705 need to be able to perform it at instantiation
13706 (or instantiate_non_dependent_expr) time. */
13707 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
13708 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
13711 expr
= convert_like (conv
, expr
, NULL_TREE
, 0,
13712 /*issue_conversion_warnings=*/false,
13713 c_cast_p
, /*nested_p=*/false, complain
);
13718 /* When initializing a reference that lasts longer than a full-expression,
13719 this special rule applies:
13723 The temporary to which the reference is bound or the temporary
13724 that is the complete object to which the reference is bound
13725 persists for the lifetime of the reference.
13727 The temporaries created during the evaluation of the expression
13728 initializing the reference, except the temporary to which the
13729 reference is bound, are destroyed at the end of the
13730 full-expression in which they are created.
13732 In that case, we store the converted expression into a new
13733 VAR_DECL in a new scope.
13735 However, we want to be careful not to create temporaries when
13736 they are not required. For example, given:
13739 struct D : public B {};
13743 there is no need to copy the return value from "f"; we can just
13744 extend its lifetime. Similarly, given:
13747 struct T { operator S(); };
13751 we can extend the lifetime of the return value of the conversion
13754 The next several functions are involved in this lifetime extension. */
13756 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
13757 reference is being bound to a temporary. Create and return a new
13758 VAR_DECL with the indicated TYPE; this variable will store the value to
13759 which the reference is bound. */
13762 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
13764 tree var
= create_temporary_var (type
);
13766 /* Register the variable. */
13768 && (TREE_STATIC (decl
) || CP_DECL_THREAD_LOCAL_P (decl
)))
13770 /* Namespace-scope or local static; give it a mangled name. */
13772 /* If an initializer is visible to multiple translation units, those
13773 translation units must agree on the addresses of the
13774 temporaries. Therefore the temporaries must be given a consistent name
13775 and vague linkage. The mangled name of a temporary is the name of the
13776 non-temporary object in whose initializer they appear, prefixed with
13777 GR and suffixed with a sequence number mangled using the usual rules
13778 for a seq-id. Temporaries are numbered with a pre-order, depth-first,
13779 left-to-right walk of the complete initializer. */
13780 copy_linkage (var
, decl
);
13782 tree name
= mangle_ref_init_variable (decl
);
13783 DECL_NAME (var
) = name
;
13784 SET_DECL_ASSEMBLER_NAME (var
, name
);
13787 /* Create a new cleanup level if necessary. */
13788 maybe_push_cleanup_level (type
);
13790 return pushdecl (var
);
13793 /* EXPR is the initializer for a variable DECL of reference or
13794 std::initializer_list type. Create, push and return a new VAR_DECL
13795 for the initializer so that it will live as long as DECL. Any
13796 cleanup for the new variable is returned through CLEANUP, and the
13797 code to initialize the new variable is returned through INITP. */
13800 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
13801 tree
*initp
, tree
*cond_guard
)
13807 /* Create the temporary variable. */
13808 type
= TREE_TYPE (expr
);
13809 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
13810 layout_decl (var
, 0);
13811 /* If the rvalue is the result of a function call it will be
13812 a TARGET_EXPR. If it is some other construct (such as a
13813 member access expression where the underlying object is
13814 itself the result of a function call), turn it into a
13815 TARGET_EXPR here. It is important that EXPR be a
13816 TARGET_EXPR below since otherwise the INIT_EXPR will
13817 attempt to make a bitwise copy of EXPR to initialize
13819 if (TREE_CODE (expr
) != TARGET_EXPR
)
13820 expr
= get_target_expr (expr
);
13823 if (TREE_ADDRESSABLE (expr
))
13824 TREE_ADDRESSABLE (var
) = 1;
13825 if (DECL_MERGEABLE (TARGET_EXPR_SLOT (expr
)))
13826 DECL_MERGEABLE (var
) = true;
13829 if (TREE_CODE (decl
) == FIELD_DECL
13830 && extra_warnings
&& !warning_suppressed_p (decl
))
13832 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
13833 "until the constructor exits", decl
);
13834 suppress_warning (decl
);
13837 /* Recursively extend temps in this initializer. */
13838 TARGET_EXPR_INITIAL (expr
)
13839 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
,
13842 /* Any reference temp has a non-trivial initializer. */
13843 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
13845 /* If the initializer is constant, put it in DECL_INITIAL so we get
13846 static initialization and use in constant expressions. */
13847 init
= maybe_constant_init (expr
, var
, /*manifestly_const_eval=*/true);
13848 /* As in store_init_value. */
13849 init
= cp_fully_fold (init
);
13850 if (TREE_CONSTANT (init
))
13852 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
13854 /* 5.19 says that a constant expression can include an
13855 lvalue-rvalue conversion applied to "a glvalue of literal type
13856 that refers to a non-volatile temporary object initialized
13857 with a constant expression". Rather than try to communicate
13858 that this VAR_DECL is a temporary, just mark it constexpr. */
13859 DECL_DECLARED_CONSTEXPR_P (var
) = true;
13860 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
13861 TREE_CONSTANT (var
) = true;
13862 TREE_READONLY (var
) = true;
13864 DECL_INITIAL (var
) = init
;
13868 /* Create the INIT_EXPR that will initialize the temporary
13870 init
= split_nonconstant_init (var
, expr
);
13871 if (at_function_scope_p ())
13873 add_decl_expr (var
);
13875 if (TREE_STATIC (var
))
13876 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
13879 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
13882 if (cond_guard
&& cleanup
!= error_mark_node
)
13884 if (*cond_guard
== NULL_TREE
)
13886 *cond_guard
= build_local_temp (boolean_type_node
);
13887 add_decl_expr (*cond_guard
);
13888 tree set
= cp_build_modify_expr (UNKNOWN_LOCATION
,
13889 *cond_guard
, NOP_EXPR
,
13890 boolean_false_node
,
13891 tf_warning_or_error
);
13892 finish_expr_stmt (set
);
13894 cleanup
= build3 (COND_EXPR
, void_type_node
,
13895 *cond_guard
, cleanup
, NULL_TREE
);
13897 vec_safe_push (*cleanups
, cleanup
);
13901 /* We must be careful to destroy the temporary only
13902 after its initialization has taken place. If the
13903 initialization throws an exception, then the
13904 destructor should not be run. We cannot simply
13905 transform INIT into something like:
13907 (INIT, ({ CLEANUP_STMT; }))
13909 because emit_local_var always treats the
13910 initializer as a full-expression. Thus, the
13911 destructor would run too early; it would run at the
13912 end of initializing the reference variable, rather
13913 than at the end of the block enclosing the
13914 reference variable.
13916 The solution is to pass back a cleanup expression
13917 which the caller is responsible for attaching to
13918 the statement tree. */
13922 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
13923 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
13925 if (CP_DECL_THREAD_LOCAL_P (var
))
13926 tls_aggregates
= tree_cons (NULL_TREE
, var
,
13929 static_aggregates
= tree_cons (NULL_TREE
, var
,
13930 static_aggregates
);
13933 /* Check whether the dtor is callable. */
13934 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
13936 /* Avoid -Wunused-variable warning (c++/38958). */
13937 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
13939 TREE_USED (decl
) = DECL_READ_P (decl
) = true;
13945 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
13946 initializing a variable of that TYPE. */
13949 initialize_reference (tree type
, tree expr
,
13950 int flags
, tsubst_flags_t complain
)
13953 location_t loc
= cp_expr_loc_or_input_loc (expr
);
13955 if (type
== error_mark_node
|| error_operand_p (expr
))
13956 return error_mark_node
;
13958 conversion_obstack_sentinel cos
;
13960 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
13962 /* If this conversion failed, we're in C++20, and we have something like
13963 A& a(b) where A is an aggregate, try again, this time as A& a{b}. */
13964 if ((!conv
|| conv
->bad_p
)
13965 && (flags
& LOOKUP_AGGREGATE_PAREN_INIT
))
13967 tree e
= build_constructor_single (init_list_type_node
, NULL_TREE
, expr
);
13968 CONSTRUCTOR_IS_DIRECT_INIT (e
) = true;
13969 CONSTRUCTOR_IS_PAREN_INIT (e
) = true;
13970 conversion
*c
= reference_binding (type
, TREE_TYPE (e
), e
,
13971 /*c_cast_p=*/false, flags
, complain
);
13972 /* If this worked, use it. */
13973 if (c
&& !c
->bad_p
)
13974 expr
= e
, conv
= c
;
13976 if (!conv
|| conv
->bad_p
)
13978 if (complain
& tf_error
)
13981 convert_like (conv
, expr
, complain
);
13982 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
13983 && !TYPE_REF_IS_RVALUE (type
)
13984 && !lvalue_p (expr
))
13985 error_at (loc
, "invalid initialization of non-const reference of "
13986 "type %qH from an rvalue of type %qI",
13987 type
, TREE_TYPE (expr
));
13989 error_at (loc
, "invalid initialization of reference of type "
13990 "%qH from expression of type %qI", type
,
13993 return error_mark_node
;
13996 if (conv
->kind
== ck_ref_bind
)
13997 /* Perform the conversion. */
13998 expr
= convert_like (conv
, expr
, complain
);
13999 else if (conv
->kind
== ck_ambig
)
14000 /* We gave an error in build_user_type_conversion_1. */
14001 expr
= error_mark_node
;
14003 gcc_unreachable ();
14008 /* Return true if T is std::pair<const T&, const T&>. */
14011 std_pair_ref_ref_p (tree t
)
14013 /* First, check if we have std::pair. */
14014 if (!NON_UNION_CLASS_TYPE_P (t
)
14015 || !CLASSTYPE_TEMPLATE_INSTANTIATION (t
))
14017 tree tdecl
= TYPE_NAME (TYPE_MAIN_VARIANT (t
));
14018 if (!decl_in_std_namespace_p (tdecl
))
14020 tree name
= DECL_NAME (tdecl
);
14021 if (!name
|| !id_equal (name
, "pair"))
14024 /* Now see if the template arguments are both const T&. */
14025 tree args
= CLASSTYPE_TI_ARGS (t
);
14026 if (TREE_VEC_LENGTH (args
) != 2)
14028 for (int i
= 0; i
< 2; i
++)
14029 if (!TYPE_REF_OBJ_P (TREE_VEC_ELT (args
, i
))
14030 || !CP_TYPE_CONST_P (TREE_TYPE (TREE_VEC_ELT (args
, i
))))
14036 /* Return true if a class T has a reference member. */
14039 class_has_reference_member_p (tree t
)
14041 for (tree fields
= TYPE_FIELDS (t
);
14043 fields
= DECL_CHAIN (fields
))
14044 if (TREE_CODE (fields
) == FIELD_DECL
14045 && !DECL_ARTIFICIAL (fields
)
14046 && TYPE_REF_P (TREE_TYPE (fields
)))
14051 /* A wrapper for the above suitable as a callback for dfs_walk_once. */
14054 class_has_reference_member_p_r (tree binfo
, void *)
14056 return (class_has_reference_member_p (BINFO_TYPE (binfo
))
14057 ? integer_one_node
: NULL_TREE
);
14061 /* Return true if T (either a class or a function) has been marked as
14065 no_dangling_p (tree t
)
14067 t
= lookup_attribute ("no_dangling", TYPE_ATTRIBUTES (t
));
14071 t
= TREE_VALUE (t
);
14075 t
= build_converted_constant_bool_expr (TREE_VALUE (t
), tf_warning_or_error
);
14076 t
= cxx_constant_value (t
);
14077 return t
== boolean_true_node
;
14080 /* Return true if a class CTYPE is either std::reference_wrapper or
14081 std::ref_view, or a reference wrapper class. We consider a class
14082 a reference wrapper class if it has a reference member. We no
14083 longer check that it has a constructor taking the same reference type
14084 since that approach still generated too many false positives. */
14087 reference_like_class_p (tree ctype
)
14089 if (!CLASS_TYPE_P (ctype
))
14092 if (no_dangling_p (ctype
))
14095 /* Also accept a std::pair<const T&, const T&>. */
14096 if (std_pair_ref_ref_p (ctype
))
14099 tree tdecl
= TYPE_NAME (TYPE_MAIN_VARIANT (ctype
));
14100 if (decl_in_std_namespace_p (tdecl
))
14102 tree name
= DECL_NAME (tdecl
);
14104 && (id_equal (name
, "reference_wrapper")
14105 || id_equal (name
, "span")
14106 || id_equal (name
, "ref_view")))
14110 /* Avoid warning if CTYPE looks like std::span: it has a T* member and
14111 a trivial destructor. For example,
14113 template<typename T>
14119 is considered std::span-like. */
14120 if (NON_UNION_CLASS_TYPE_P (ctype
) && TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype
))
14121 for (tree field
= next_aggregate_field (TYPE_FIELDS (ctype
));
14122 field
; field
= next_aggregate_field (DECL_CHAIN (field
)))
14123 if (TYPE_PTR_P (TREE_TYPE (field
)))
14126 /* Some classes, such as std::tuple, have the reference member in its
14127 (non-direct) base class. */
14128 if (dfs_walk_once (TYPE_BINFO (ctype
), class_has_reference_member_p_r
,
14135 /* Helper for maybe_warn_dangling_reference to find a problematic CALL_EXPR
14136 that initializes the LHS (and at least one of its arguments represents
14137 a temporary, as outlined in maybe_warn_dangling_reference), or NULL_TREE
14138 if none found. For instance:
14140 const S& s = S().self(); // S::self (&TARGET_EXPR <...>)
14141 const int& r = (42, f(1)); // f(1)
14142 const int& t = b ? f(1) : f(2); // f(1)
14143 const int& u = b ? f(1) : f(g); // f(1)
14144 const int& v = b ? f(g) : f(2); // f(2)
14145 const int& w = b ? f(g) : f(g); // NULL_TREE
14146 const int& y = (f(1), 42); // NULL_TREE
14147 const int& z = f(f(1)); // f(f(1))
14149 EXPR is the initializer. If ARG_P is true, we're processing an argument
14150 to a function; the point is to distinguish between, for example,
14152 Ref::inner (&TARGET_EXPR <D.2839, F::foo (fm)>)
14154 where we shouldn't warn, and
14156 Ref::inner (&TARGET_EXPR <D.2908, F::foo (&TARGET_EXPR <...>)>)
14158 where we should warn (Ref is a reference_like_class_p so we see through
14162 do_warn_dangling_reference (tree expr
, bool arg_p
)
14166 if (arg_p
&& expr_represents_temporary_p (expr
))
14168 /* An attempt to reduce the number of -Wdangling-reference
14169 false positives concerning reference wrappers (c++/107532).
14170 When we encounter a reference_like_class_p, we don't warn
14171 just yet; instead, we keep recursing to see if there were
14172 any temporaries behind the reference-wrapper class. */
14174 while (handled_component_p (e
))
14175 e
= TREE_OPERAND (e
, 0);
14176 tree type
= TREE_TYPE (e
);
14177 /* If the temporary represents a lambda, we don't really know
14178 what's going on here. */
14179 if (!reference_like_class_p (type
) && !LAMBDA_TYPE_P (type
))
14183 switch (TREE_CODE (expr
))
14187 tree fndecl
= cp_get_callee_fndecl_nofold (expr
);
14189 || warning_suppressed_p (fndecl
, OPT_Wdangling_reference
)
14190 || !warning_enabled_at (DECL_SOURCE_LOCATION (fndecl
),
14191 OPT_Wdangling_reference
)
14192 /* Don't emit a false positive for:
14193 std::vector<int> v = ...;
14194 std::vector<int>::const_iterator it = v.begin();
14195 const int &r = *it++;
14196 because R refers to one of the int elements of V, not to
14197 a temporary object. Member operator* may return a reference
14198 but probably not to one of its arguments. */
14199 || (DECL_OBJECT_MEMBER_FUNCTION_P (fndecl
)
14200 && DECL_OVERLOADED_OPERATOR_P (fndecl
)
14201 && DECL_OVERLOADED_OPERATOR_IS (fndecl
, INDIRECT_REF
))
14202 || no_dangling_p (TREE_TYPE (fndecl
)))
14205 tree rettype
= TREE_TYPE (TREE_TYPE (fndecl
));
14206 /* If the function doesn't return a reference, don't warn. This
14208 const int& z = std::min({1, 2, 3, 4, 5, 6, 7});
14209 which doesn't dangle: std::min here returns an int.
14211 If the function returns a std::pair<const T&, const T&>, we
14212 warn, to detect e.g.
14213 std::pair<const int&, const int&> v = std::minmax(1, 2);
14214 which also creates a dangling reference, because std::minmax
14215 returns std::pair<const T&, const T&>(b, a). */
14216 if (!(TYPE_REF_OBJ_P (rettype
) || reference_like_class_p (rettype
)))
14219 /* Here we're looking to see if any of the arguments is a temporary
14220 initializing a reference parameter. */
14221 for (int i
= 0; i
< call_expr_nargs (expr
); ++i
)
14223 tree arg
= CALL_EXPR_ARG (expr
, i
);
14224 /* Check that this argument initializes a reference, except for
14225 the argument initializing the object of a member function. */
14226 if (!DECL_IOBJ_MEMBER_FUNCTION_P (fndecl
)
14227 && !TYPE_REF_P (TREE_TYPE (arg
)))
14230 if (TREE_CODE (arg
) == ADDR_EXPR
)
14231 arg
= TREE_OPERAND (arg
, 0);
14232 /* Recurse to see if the argument is a temporary. It could also
14233 be another call taking a temporary and returning it and
14234 initializing this reference parameter. */
14235 if (do_warn_dangling_reference (arg
, /*arg_p=*/true))
14237 /* Don't warn about member functions like:
14239 S& s = a.emplace<S>({0}, 0);
14240 which construct a new object and return a reference to it, but
14241 we still want to detect:
14242 struct S { const S& self () { return *this; } };
14243 const S& s = S().self();
14244 where 's' dangles. If we've gotten here, the object this function
14245 is invoked on is not a temporary. */
14246 if (DECL_OBJECT_MEMBER_FUNCTION_P (fndecl
))
14251 case COMPOUND_EXPR
:
14252 return do_warn_dangling_reference (TREE_OPERAND (expr
, 1), arg_p
);
14254 if (tree t
= do_warn_dangling_reference (TREE_OPERAND (expr
, 1), arg_p
))
14256 return do_warn_dangling_reference (TREE_OPERAND (expr
, 2), arg_p
);
14258 return do_warn_dangling_reference (TREE_OPERAND (expr
, 0), arg_p
);
14260 return do_warn_dangling_reference (TARGET_EXPR_INITIAL (expr
), arg_p
);
14266 /* Implement -Wdangling-reference, to detect cases like
14269 const int& r = std::max(n - 1, n + 1); // r is dangling
14271 This creates temporaries from the arguments, returns a reference to
14272 one of the temporaries, but both temporaries are destroyed at the end
14273 of the full expression.
14275 This works by checking if a reference is initialized with a function
14276 that returns a reference, and at least one parameter of the function
14277 is a reference that is bound to a temporary. It assumes that such a
14278 function actually returns one of its arguments.
14280 DECL is the reference being initialized, INIT is the initializer. */
14283 maybe_warn_dangling_reference (const_tree decl
, tree init
)
14285 if (!warn_dangling_reference
)
14287 tree type
= TREE_TYPE (decl
);
14288 /* Only warn if what we're initializing has type T&& or const T&, or
14289 std::pair<const T&, const T&>. (A non-const lvalue reference can't
14290 bind to a temporary.) */
14291 if (!((TYPE_REF_OBJ_P (type
)
14292 && (TYPE_REF_IS_RVALUE (type
)
14293 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
14294 || std_pair_ref_ref_p (type
)))
14296 /* Don't suppress the diagnostic just because the call comes from
14297 a system header. If the DECL is not in a system header, or if
14298 -Wsystem-headers was provided, warn. */
14300 = make_temp_override (global_dc
->m_warn_system_headers
,
14301 (!in_system_header_at (DECL_SOURCE_LOCATION (decl
))
14302 || global_dc
->m_warn_system_headers
));
14303 if (tree call
= do_warn_dangling_reference (init
, /*arg_p=*/false))
14305 auto_diagnostic_group d
;
14306 if (warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wdangling_reference
,
14307 "possibly dangling reference to a temporary"))
14308 inform (EXPR_LOCATION (call
), "the temporary was destroyed at "
14309 "the end of the full expression %qE", call
);
14313 /* If *P is an xvalue expression, prevent temporary lifetime extension if it
14314 gets used to initialize a reference. */
14317 prevent_lifetime_extension (tree t
)
14320 while (TREE_CODE (*p
) == COMPOUND_EXPR
)
14321 p
= &TREE_OPERAND (*p
, 1);
14322 while (handled_component_p (*p
))
14323 p
= &TREE_OPERAND (*p
, 0);
14324 /* Change a TARGET_EXPR from prvalue to xvalue. */
14325 if (TREE_CODE (*p
) == TARGET_EXPR
)
14326 *p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*p
), *p
,
14327 move (TARGET_EXPR_SLOT (*p
)));
14331 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
14332 which is bound either to a reference or a std::initializer_list. */
14335 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
,
14338 /* CWG1299 (C++20): The temporary object to which the reference is bound or
14339 the temporary object that is the complete object of a subobject to which
14340 the reference is bound persists for the lifetime of the reference if the
14341 glvalue to which the reference is bound was obtained through one of the
14343 - a temporary materialization conversion ([conv.rval]),
14344 - ( expression ), where expression is one of these expressions,
14345 - subscripting ([expr.sub]) of an array operand, where that operand is one
14346 of these expressions,
14347 - a class member access ([expr.ref]) using the . operator where the left
14348 operand is one of these expressions and the right operand designates a
14349 non-static data member of non-reference type,
14350 - a pointer-to-member operation ([expr.mptr.oper]) using the .* operator
14351 where the left operand is one of these expressions and the right operand
14352 is a pointer to data member of non-reference type,
14353 - a const_cast ([expr.const.cast]), static_cast ([expr.static.cast]),
14354 dynamic_cast ([expr.dynamic.cast]), or reinterpret_cast
14355 ([expr.reinterpret.cast]) converting, without a user-defined conversion,
14356 a glvalue operand that is one of these expressions to a glvalue that
14357 refers to the object designated by the operand, or to its complete
14358 object or a subobject thereof,
14359 - a conditional expression ([expr.cond]) that is a glvalue where the
14360 second or third operand is one of these expressions, or
14361 - a comma expression ([expr.comma]) that is a glvalue where the right
14362 operand is one of these expressions. */
14364 /* FIXME several cases are still handled wrong (101572, 81420). */
14369 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
14371 TREE_OPERAND (sub
, 1)
14372 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
,
14376 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
14377 && TYPE_PTRDATAMEM_P (TREE_TYPE (tree_strip_nop_conversions
14378 (TREE_OPERAND (sub
, 1)))))
14380 /* A pointer-to-member operation. */
14381 TREE_OPERAND (sub
, 0)
14382 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 0), cleanups
,
14386 if (TREE_CODE (sub
) == COND_EXPR
)
14388 tree cur_cond_guard
= NULL_TREE
;
14389 if (TREE_OPERAND (sub
, 1))
14390 TREE_OPERAND (sub
, 1)
14391 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
,
14393 if (cur_cond_guard
)
14395 tree set
= cp_build_modify_expr (UNKNOWN_LOCATION
, cur_cond_guard
,
14396 NOP_EXPR
, boolean_true_node
,
14397 tf_warning_or_error
);
14398 TREE_OPERAND (sub
, 1)
14399 = cp_build_compound_expr (set
, TREE_OPERAND (sub
, 1),
14400 tf_warning_or_error
);
14402 cur_cond_guard
= NULL_TREE
;
14403 if (TREE_OPERAND (sub
, 2))
14404 TREE_OPERAND (sub
, 2)
14405 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 2), cleanups
,
14407 if (cur_cond_guard
)
14409 tree set
= cp_build_modify_expr (UNKNOWN_LOCATION
, cur_cond_guard
,
14410 NOP_EXPR
, boolean_true_node
,
14411 tf_warning_or_error
);
14412 TREE_OPERAND (sub
, 2)
14413 = cp_build_compound_expr (set
, TREE_OPERAND (sub
, 2),
14414 tf_warning_or_error
);
14418 if (TREE_CODE (sub
) != ADDR_EXPR
)
14420 /* Deal with binding to a subobject. */
14421 for (p
= &TREE_OPERAND (sub
, 0);
14422 TREE_CODE (*p
) == COMPONENT_REF
|| TREE_CODE (*p
) == ARRAY_REF
; )
14423 p
= &TREE_OPERAND (*p
, 0);
14424 if (TREE_CODE (*p
) == TARGET_EXPR
)
14426 tree subinit
= NULL_TREE
;
14427 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
, cond_guard
);
14428 recompute_tree_invariant_for_addr_expr (sub
);
14430 init
= fold_convert (TREE_TYPE (init
), sub
);
14432 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
14437 /* INIT is part of the initializer for DECL. If there are any
14438 reference or initializer lists being initialized, extend their
14439 lifetime to match that of DECL. */
14442 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
,
14445 tree type
= TREE_TYPE (init
);
14446 if (processing_template_decl
)
14449 maybe_warn_dangling_reference (decl
, init
);
14451 if (TYPE_REF_P (type
))
14452 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
, cond_guard
);
14456 if (TREE_CODE (ctor
) == TARGET_EXPR
)
14457 ctor
= TARGET_EXPR_INITIAL (ctor
);
14458 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
14460 /* [dcl.init] When initializing an aggregate from a parenthesized list
14461 of values... a temporary object bound to a reference does not have
14462 its lifetime extended. */
14463 if (CONSTRUCTOR_IS_PAREN_INIT (ctor
))
14466 if (is_std_init_list (type
))
14468 /* The temporary array underlying a std::initializer_list
14469 is handled like a reference temporary. */
14470 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
14471 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
,
14473 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
14478 constructor_elt
*p
;
14479 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
14480 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
14481 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
,
14484 recompute_constructor_flags (ctor
);
14485 if (decl_maybe_constant_var_p (decl
) && TREE_CONSTANT (ctor
))
14486 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
14493 /* Returns true iff an initializer for TYPE could contain temporaries that
14494 need to be extended because they are bound to references or
14495 std::initializer_list. */
14498 type_has_extended_temps (tree type
)
14500 type
= strip_array_types (type
);
14501 if (TYPE_REF_P (type
))
14503 if (CLASS_TYPE_P (type
))
14505 if (is_std_init_list (type
))
14507 for (tree f
= next_aggregate_field (TYPE_FIELDS (type
));
14508 f
; f
= next_aggregate_field (DECL_CHAIN (f
)))
14509 if (type_has_extended_temps (TREE_TYPE (f
)))
14515 /* Returns true iff TYPE is some variant of std::initializer_list. */
14518 is_std_init_list (tree type
)
14520 if (!TYPE_P (type
))
14522 if (cxx_dialect
== cxx98
)
14524 /* Look through typedefs. */
14525 type
= TYPE_MAIN_VARIANT (type
);
14526 return (CLASS_TYPE_P (type
)
14527 && CP_TYPE_CONTEXT (type
) == std_node
14528 && init_list_identifier
== DECL_NAME (TYPE_NAME (type
)));
14531 /* Returns true iff DECL is a list constructor: i.e. a constructor which
14532 will accept an argument list of a single std::initializer_list<T>. */
14535 is_list_ctor (tree decl
)
14537 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
14540 if (!args
|| args
== void_list_node
)
14543 arg
= non_reference (TREE_VALUE (args
));
14544 if (!is_std_init_list (arg
))
14547 args
= TREE_CHAIN (args
);
14549 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
14550 /* There are more non-defaulted parms. */
14556 /* We know that can_convert_arg_bad already said "no" when trying to convert
14557 FROM to TO with ARG and FLAGS. Try to figure out if it was because
14558 an explicit conversion function was skipped when looking for a way to
14559 perform the conversion. At this point we've already printed an error. */
14562 maybe_show_nonconverting_candidate (tree to
, tree from
, tree arg
, int flags
)
14564 if (!(flags
& LOOKUP_ONLYCONVERTING
))
14567 conversion_obstack_sentinel cos
;
14568 conversion
*c
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
14569 flags
& ~LOOKUP_ONLYCONVERTING
, tf_none
);
14570 if (c
&& !c
->bad_p
&& c
->user_conv_p
)
14571 /* Ay, the conversion would have worked in direct-init context. */
14572 for (; c
; c
= next_conversion (c
))
14573 if (c
->kind
== ck_user
14574 && DECL_P (c
->cand
->fn
)
14575 && DECL_NONCONVERTING_P (c
->cand
->fn
))
14576 inform (DECL_SOURCE_LOCATION (c
->cand
->fn
), "explicit conversion "
14577 "function was not considered");
14580 /* We're converting EXPR to TYPE. If that conversion involves a conversion
14581 function and we're binding EXPR to a reference parameter of that function,
14585 conv_binds_to_reference_parm_p (tree type
, tree expr
)
14587 conversion_obstack_sentinel cos
;
14588 conversion
*c
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
14589 /*c_cast_p=*/false, LOOKUP_NORMAL
,
14591 if (c
&& !c
->bad_p
&& c
->user_conv_p
)
14592 for (; c
; c
= next_conversion (c
))
14593 if (c
->kind
== ck_user
)
14594 for (z_candidate
*cand
= c
->cand
; cand
; cand
= cand
->next
)
14595 if (cand
->viable
== 1)
14596 for (size_t i
= 0; i
< cand
->num_convs
; ++i
)
14597 if (cand
->convs
[i
]->kind
== ck_ref_bind
14598 && conv_get_original_expr (cand
->convs
[i
]) == expr
)
14604 #include "gt-cp-call.h"