1 /* Functions related to invoking -*- C++ -*- methods and overloaded functions.
2 Copyright (C) 1987-2017 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"
43 /* The various kinds of conversion. */
45 enum conversion_kind
{
62 /* The rank of the conversion. Order of the enumerals matters; better
63 conversions should come earlier in the list. */
65 enum conversion_rank
{
76 /* An implicit conversion sequence, in the sense of [over.best.ics].
77 The first conversion to be performed is at the end of the chain.
78 That conversion is always a cr_identity conversion. */
81 /* The kind of conversion represented by this step. */
83 /* The rank of this conversion. */
85 BOOL_BITFIELD user_conv_p
: 1;
86 BOOL_BITFIELD ellipsis_p
: 1;
87 BOOL_BITFIELD this_p
: 1;
88 /* True if this conversion would be permitted with a bending of
89 language standards, e.g. disregarding pointer qualifiers or
90 converting integers to pointers. */
91 BOOL_BITFIELD bad_p
: 1;
92 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
93 temporary should be created to hold the result of the
95 BOOL_BITFIELD need_temporary_p
: 1;
96 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
97 from a pointer-to-derived to pointer-to-base is being performed. */
98 BOOL_BITFIELD base_p
: 1;
99 /* If KIND is ck_ref_bind, true when either an lvalue reference is
100 being bound to an lvalue expression or an rvalue reference is
101 being bound to an rvalue expression. If KIND is ck_rvalue,
102 true when we should treat an lvalue as an rvalue (12.8p33). If
103 KIND is ck_base, always false. */
104 BOOL_BITFIELD rvaluedness_matches_p
: 1;
105 BOOL_BITFIELD check_narrowing
: 1;
106 /* The type of the expression resulting from the conversion. */
109 /* The next conversion in the chain. Since the conversions are
110 arranged from outermost to innermost, the NEXT conversion will
111 actually be performed before this conversion. This variant is
112 used only when KIND is neither ck_identity, ck_ambig nor
113 ck_list. Please use the next_conversion function instead
114 of using this field directly. */
116 /* The expression at the beginning of the conversion chain. This
117 variant is used only if KIND is ck_identity or ck_ambig. */
119 /* The array of conversions for an initializer_list, so this
120 variant is used only when KIN D is ck_list. */
123 /* The function candidate corresponding to this conversion
124 sequence. This field is only used if KIND is ck_user. */
125 struct z_candidate
*cand
;
128 #define CONVERSION_RANK(NODE) \
129 ((NODE)->bad_p ? cr_bad \
130 : (NODE)->ellipsis_p ? cr_ellipsis \
131 : (NODE)->user_conv_p ? cr_user \
134 #define BAD_CONVERSION_RANK(NODE) \
135 ((NODE)->ellipsis_p ? cr_ellipsis \
136 : (NODE)->user_conv_p ? cr_user \
139 static struct obstack conversion_obstack
;
140 static bool conversion_obstack_initialized
;
141 struct rejection_reason
;
143 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
144 static int equal_functions (tree
, tree
);
145 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
147 static int compare_ics (conversion
*, conversion
*);
148 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
149 #define convert_like(CONV, EXPR, COMPLAIN) \
150 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
151 /*issue_conversion_warnings=*/true, \
152 /*c_cast_p=*/false, (COMPLAIN))
153 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
154 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
155 /*issue_conversion_warnings=*/true, \
156 /*c_cast_p=*/false, (COMPLAIN))
157 static tree
convert_like_real (conversion
*, tree
, tree
, int, int, bool,
158 bool, tsubst_flags_t
);
159 static void op_error (location_t
, enum tree_code
, enum tree_code
, tree
,
161 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
163 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
164 static void print_z_candidates (location_t
, struct z_candidate
*);
165 static tree
build_this (tree
);
166 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
167 static bool any_strictly_viable (struct z_candidate
*);
168 static struct z_candidate
*add_template_candidate
169 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
170 tree
, tree
, tree
, int, unification_kind_t
, tsubst_flags_t
);
171 static struct z_candidate
*add_template_candidate_real
172 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
173 tree
, tree
, tree
, int, tree
, unification_kind_t
, tsubst_flags_t
);
174 static void add_builtin_candidates
175 (struct z_candidate
**, enum tree_code
, enum tree_code
,
176 tree
, tree
*, int, tsubst_flags_t
);
177 static void add_builtin_candidate
178 (struct z_candidate
**, enum tree_code
, enum tree_code
,
179 tree
, tree
, tree
, tree
*, tree
*, int, tsubst_flags_t
);
180 static bool is_complete (tree
);
181 static void build_builtin_candidate
182 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
183 int, tsubst_flags_t
);
184 static struct z_candidate
*add_conv_candidate
185 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
186 tree
, tsubst_flags_t
);
187 static struct z_candidate
*add_function_candidate
188 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
189 tree
, int, tsubst_flags_t
);
190 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
192 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
194 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
195 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
196 static conversion
*next_conversion (conversion
*);
197 static bool is_subseq (conversion
*, conversion
*);
198 static conversion
*maybe_handle_ref_bind (conversion
**);
199 static void maybe_handle_implicit_object (conversion
**);
200 static struct z_candidate
*add_candidate
201 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
202 conversion
**, tree
, tree
, int, struct rejection_reason
*, int);
203 static tree
source_type (conversion
*);
204 static void add_warning (struct z_candidate
*, struct z_candidate
*);
205 static bool reference_compatible_p (tree
, tree
);
206 static conversion
*direct_reference_binding (tree
, conversion
*);
207 static bool promoted_arithmetic_type_p (tree
);
208 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
209 static char *name_as_c_string (tree
, tree
, bool *);
210 static tree
prep_operand (tree
);
211 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
212 bool, tree
, tree
, int, struct z_candidate
**,
214 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
215 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
217 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
218 NAME can take many forms... */
221 check_dtor_name (tree basetype
, tree name
)
223 /* Just accept something we've already complained about. */
224 if (name
== error_mark_node
)
227 if (TREE_CODE (name
) == TYPE_DECL
)
228 name
= TREE_TYPE (name
);
229 else if (TYPE_P (name
))
231 else if (identifier_p (name
))
233 if ((MAYBE_CLASS_TYPE_P (basetype
)
234 && name
== constructor_name (basetype
))
235 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
236 && name
== TYPE_IDENTIFIER (basetype
)))
239 name
= get_type_value (name
);
245 template <class T> struct S { ~S(); };
249 NAME will be a class template. */
250 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
254 if (!name
|| name
== error_mark_node
)
256 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
259 /* We want the address of a function or method. We avoid creating a
260 pointer-to-member function. */
263 build_addr_func (tree function
, tsubst_flags_t complain
)
265 tree type
= TREE_TYPE (function
);
267 /* We have to do these by hand to avoid real pointer to member
269 if (TREE_CODE (type
) == METHOD_TYPE
)
271 if (TREE_CODE (function
) == OFFSET_REF
)
273 tree object
= build_address (TREE_OPERAND (function
, 0));
274 return get_member_function_from_ptrfunc (&object
,
275 TREE_OPERAND (function
, 1),
278 function
= build_address (function
);
281 function
= decay_conversion (function
, complain
, /*reject_builtin=*/false);
286 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
287 POINTER_TYPE to those. Note, pointer to member function types
288 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
289 two variants. build_call_a is the primitive taking an array of
290 arguments, while build_call_n is a wrapper that handles varargs. */
293 build_call_n (tree function
, int n
, ...)
296 return build_call_a (function
, 0, NULL
);
299 tree
*argarray
= XALLOCAVEC (tree
, n
);
304 for (i
= 0; i
< n
; i
++)
305 argarray
[i
] = va_arg (ap
, tree
);
307 return build_call_a (function
, n
, argarray
);
311 /* Update various flags in cfun and the call itself based on what is being
312 called. Split out of build_call_a so that bot_manip can use it too. */
315 set_flags_from_callee (tree call
)
318 tree decl
= get_callee_fndecl (call
);
320 /* We check both the decl and the type; a function may be known not to
321 throw without being declared throw(). */
322 nothrow
= decl
&& TREE_NOTHROW (decl
);
323 if (CALL_EXPR_FN (call
))
324 nothrow
|= TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call
))));
325 else if (internal_fn_flags (CALL_EXPR_IFN (call
)) & ECF_NOTHROW
)
328 if (!nothrow
&& at_function_scope_p () && cfun
&& cp_function_chain
)
329 cp_function_chain
->can_throw
= 1;
331 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
&& cp_function_chain
)
332 current_function_returns_abnormally
= 1;
334 TREE_NOTHROW (call
) = nothrow
;
338 build_call_a (tree function
, int n
, tree
*argarray
)
345 function
= build_addr_func (function
, tf_warning_or_error
);
347 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
348 fntype
= TREE_TYPE (TREE_TYPE (function
));
349 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
350 || TREE_CODE (fntype
) == METHOD_TYPE
);
351 result_type
= TREE_TYPE (fntype
);
352 /* An rvalue has no cv-qualifiers. */
353 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
354 result_type
= cv_unqualified (result_type
);
356 function
= build_call_array_loc (input_location
,
357 result_type
, function
, n
, argarray
);
358 set_flags_from_callee (function
);
360 decl
= get_callee_fndecl (function
);
362 if (decl
&& !TREE_USED (decl
))
364 /* We invoke build_call directly for several library
365 functions. These may have been declared normally if
366 we're building libgcc, so we can't just check
368 gcc_assert (DECL_ARTIFICIAL (decl
)
369 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
374 require_complete_eh_spec_types (fntype
, decl
);
376 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
378 if (current_function_decl
&& decl
379 && flag_new_inheriting_ctors
380 && DECL_INHERITED_CTOR (current_function_decl
)
381 && (DECL_INHERITED_CTOR (current_function_decl
)
382 == DECL_CLONED_FUNCTION (decl
)))
383 /* Pass arguments directly to the inherited constructor. */
384 CALL_FROM_THUNK_P (function
) = true;
386 /* Don't pass empty class objects by value. This is useful
387 for tags in STL, which are used to control overload resolution.
388 We don't need to handle other cases of copying empty classes. */
389 else if (! decl
|| ! DECL_BUILT_IN (decl
))
390 for (i
= 0; i
< n
; i
++)
392 tree arg
= CALL_EXPR_ARG (function
, i
);
393 if (is_empty_class (TREE_TYPE (arg
))
394 && ! TREE_ADDRESSABLE (TREE_TYPE (arg
)))
396 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (arg
));
397 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (t
), arg
, t
);
398 CALL_EXPR_ARG (function
, i
) = arg
;
405 /* New overloading code. */
409 struct candidate_warning
{
411 candidate_warning
*next
;
414 /* Information for providing diagnostics about why overloading failed. */
416 enum rejection_reason_code
{
419 rr_explicit_conversion
,
420 rr_template_conversion
,
422 rr_bad_arg_conversion
,
423 rr_template_unification
,
426 rr_constraint_failure
429 struct conversion_info
{
430 /* The index of the argument, 0-based. */
432 /* The actual argument or its type. */
434 /* The type of the parameter. */
438 struct rejection_reason
{
439 enum rejection_reason_code code
;
441 /* Information about an arity mismatch. */
443 /* The expected number of arguments. */
445 /* The actual number of arguments in the call. */
447 /* Whether the call was a varargs call. */
450 /* Information about an argument conversion mismatch. */
451 struct conversion_info conversion
;
452 /* Same, but for bad argument conversions. */
453 struct conversion_info bad_conversion
;
454 /* Information about template unification failures. These are the
455 parameters passed to fn_type_unification. */
463 unification_kind_t strict
;
465 } template_unification
;
466 /* Information about template instantiation failures. These are the
467 parameters passed to instantiate_template. */
471 } template_instantiation
;
476 /* The FUNCTION_DECL that will be called if this candidate is
477 selected by overload resolution. */
479 /* If not NULL_TREE, the first argument to use when calling this
482 /* The rest of the arguments to use when calling this function. If
483 there are no further arguments this may be NULL or it may be an
485 const vec
<tree
, va_gc
> *args
;
486 /* The implicit conversion sequences for each of the arguments to
489 /* The number of implicit conversion sequences. */
491 /* If FN is a user-defined conversion, the standard conversion
492 sequence from the type returned by FN to the desired destination
494 conversion
*second_conv
;
495 struct rejection_reason
*reason
;
496 /* If FN is a member function, the binfo indicating the path used to
497 qualify the name of FN at the call site. This path is used to
498 determine whether or not FN is accessible if it is selected by
499 overload resolution. The DECL_CONTEXT of FN will always be a
500 (possibly improper) base of this binfo. */
502 /* If FN is a non-static member function, the binfo indicating the
503 subobject to which the `this' pointer should be converted if FN
504 is selected by overload resolution. The type pointed to by
505 the `this' pointer must correspond to the most derived class
506 indicated by the CONVERSION_PATH. */
507 tree conversion_path
;
510 candidate_warning
*warnings
;
514 /* The flags active in add_candidate. */
518 /* Returns true iff T is a null pointer constant in the sense of
522 null_ptr_cst_p (tree t
)
524 tree type
= TREE_TYPE (t
);
528 A null pointer constant is an integral constant expression
529 (_expr.const_) rvalue of integer type that evaluates to zero or
530 an rvalue of type std::nullptr_t. */
531 if (NULLPTR_TYPE_P (type
))
534 if (cxx_dialect
>= cxx11
)
536 /* Core issue 903 says only literal 0 is a null pointer constant. */
537 if (TREE_CODE (type
) == INTEGER_TYPE
538 && !char_type_p (type
)
539 && TREE_CODE (t
) == INTEGER_CST
541 && !TREE_OVERFLOW (t
))
544 else if (CP_INTEGRAL_TYPE_P (type
))
546 t
= fold_non_dependent_expr (t
);
548 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
555 /* Returns true iff T is a null member pointer value (4.11). */
558 null_member_pointer_value_p (tree t
)
560 tree type
= TREE_TYPE (t
);
563 else if (TYPE_PTRMEMFUNC_P (type
))
564 return (TREE_CODE (t
) == CONSTRUCTOR
565 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
566 else if (TYPE_PTRDATAMEM_P (type
))
567 return integer_all_onesp (t
);
572 /* Returns nonzero if PARMLIST consists of only default parms,
573 ellipsis, and/or undeduced parameter packs. */
576 sufficient_parms_p (const_tree parmlist
)
578 for (; parmlist
&& parmlist
!= void_list_node
;
579 parmlist
= TREE_CHAIN (parmlist
))
580 if (!TREE_PURPOSE (parmlist
)
581 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
586 /* Allocate N bytes of memory from the conversion obstack. The memory
587 is zeroed before being returned. */
590 conversion_obstack_alloc (size_t n
)
593 if (!conversion_obstack_initialized
)
595 gcc_obstack_init (&conversion_obstack
);
596 conversion_obstack_initialized
= true;
598 p
= obstack_alloc (&conversion_obstack
, n
);
603 /* Allocate rejection reasons. */
605 static struct rejection_reason
*
606 alloc_rejection (enum rejection_reason_code code
)
608 struct rejection_reason
*p
;
609 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
614 static struct rejection_reason
*
615 arity_rejection (tree first_arg
, int expected
, int actual
)
617 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
618 int adjust
= first_arg
!= NULL_TREE
;
619 r
->u
.arity
.expected
= expected
- adjust
;
620 r
->u
.arity
.actual
= actual
- adjust
;
624 static struct rejection_reason
*
625 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
627 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
628 int adjust
= first_arg
!= NULL_TREE
;
629 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
630 r
->u
.conversion
.from
= from
;
631 r
->u
.conversion
.to_type
= to
;
635 static struct rejection_reason
*
636 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
638 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
639 int adjust
= first_arg
!= NULL_TREE
;
640 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
641 r
->u
.bad_conversion
.from
= from
;
642 r
->u
.bad_conversion
.to_type
= to
;
646 static struct rejection_reason
*
647 explicit_conversion_rejection (tree from
, tree to
)
649 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
650 r
->u
.conversion
.n_arg
= 0;
651 r
->u
.conversion
.from
= from
;
652 r
->u
.conversion
.to_type
= to
;
656 static struct rejection_reason
*
657 template_conversion_rejection (tree from
, tree to
)
659 struct rejection_reason
*r
= alloc_rejection (rr_template_conversion
);
660 r
->u
.conversion
.n_arg
= 0;
661 r
->u
.conversion
.from
= from
;
662 r
->u
.conversion
.to_type
= to
;
666 static struct rejection_reason
*
667 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
668 const tree
*args
, unsigned int nargs
,
669 tree return_type
, unification_kind_t strict
,
672 size_t args_n_bytes
= sizeof (*args
) * nargs
;
673 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
674 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
675 r
->u
.template_unification
.tmpl
= tmpl
;
676 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
677 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
678 /* Copy args to our own storage. */
679 memcpy (args1
, args
, args_n_bytes
);
680 r
->u
.template_unification
.args
= args1
;
681 r
->u
.template_unification
.nargs
= nargs
;
682 r
->u
.template_unification
.return_type
= return_type
;
683 r
->u
.template_unification
.strict
= strict
;
684 r
->u
.template_unification
.flags
= flags
;
688 static struct rejection_reason
*
689 template_unification_error_rejection (void)
691 return alloc_rejection (rr_template_unification
);
694 static struct rejection_reason
*
695 invalid_copy_with_fn_template_rejection (void)
697 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
701 static struct rejection_reason
*
702 inherited_ctor_rejection (void)
704 struct rejection_reason
*r
= alloc_rejection (rr_inherited_ctor
);
708 // Build a constraint failure record, saving information into the
709 // template_instantiation field of the rejection. If FN is not a template
710 // declaration, the TMPL member is the FN declaration and TARGS is empty.
712 static struct rejection_reason
*
713 constraint_failure (tree fn
)
715 struct rejection_reason
*r
= alloc_rejection (rr_constraint_failure
);
716 if (tree ti
= DECL_TEMPLATE_INFO (fn
))
718 r
->u
.template_instantiation
.tmpl
= TI_TEMPLATE (ti
);
719 r
->u
.template_instantiation
.targs
= TI_ARGS (ti
);
723 r
->u
.template_instantiation
.tmpl
= fn
;
724 r
->u
.template_instantiation
.targs
= NULL_TREE
;
729 /* Dynamically allocate a conversion. */
732 alloc_conversion (conversion_kind kind
)
735 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
740 /* Make sure that all memory on the conversion obstack has been
744 validate_conversion_obstack (void)
746 if (conversion_obstack_initialized
)
747 gcc_assert ((obstack_next_free (&conversion_obstack
)
748 == obstack_base (&conversion_obstack
)));
751 /* Dynamically allocate an array of N conversions. */
754 alloc_conversions (size_t n
)
756 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
760 build_conv (conversion_kind code
, tree type
, conversion
*from
)
763 conversion_rank rank
= CONVERSION_RANK (from
);
765 /* Note that the caller is responsible for filling in t->cand for
766 user-defined conversions. */
767 t
= alloc_conversion (code
);
791 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
792 t
->bad_p
= from
->bad_p
;
797 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
798 specialization of std::initializer_list<T>, if such a conversion is
802 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
804 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
805 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
806 conversion
**subconvs
= alloc_conversions (len
);
811 /* Within a list-initialization we can have more user-defined
813 flags
&= ~LOOKUP_NO_CONVERSION
;
814 /* But no narrowing conversions. */
815 flags
|= LOOKUP_NO_NARROWING
;
817 /* Can't make an array of these types. */
818 if (TREE_CODE (elttype
) == REFERENCE_TYPE
819 || TREE_CODE (elttype
) == FUNCTION_TYPE
820 || VOID_TYPE_P (elttype
))
823 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
826 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
827 false, flags
, complain
);
834 t
= alloc_conversion (ck_list
);
836 t
->u
.list
= subconvs
;
839 for (i
= 0; i
< len
; ++i
)
841 conversion
*sub
= subconvs
[i
];
842 if (sub
->rank
> t
->rank
)
844 if (sub
->user_conv_p
)
845 t
->user_conv_p
= true;
853 /* Return the next conversion of the conversion chain (if applicable),
854 or NULL otherwise. Please use this function instead of directly
855 accessing fields of struct conversion. */
858 next_conversion (conversion
*conv
)
861 || conv
->kind
== ck_identity
862 || conv
->kind
== ck_ambig
863 || conv
->kind
== ck_list
)
868 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
869 is a valid aggregate initializer for array type ATYPE. */
872 can_convert_array (tree atype
, tree ctor
, int flags
, tsubst_flags_t complain
)
875 tree elttype
= TREE_TYPE (atype
);
876 for (i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
878 tree val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
880 if (TREE_CODE (elttype
) == ARRAY_TYPE
881 && TREE_CODE (val
) == CONSTRUCTOR
)
882 ok
= can_convert_array (elttype
, val
, flags
, complain
);
884 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
892 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
893 aggregate class, if such a conversion is possible. */
896 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
898 unsigned HOST_WIDE_INT i
= 0;
900 tree field
= next_initializable_field (TYPE_FIELDS (type
));
901 tree empty_ctor
= NULL_TREE
;
903 /* We already called reshape_init in implicit_conversion. */
905 /* The conversions within the init-list aren't affected by the enclosing
906 context; they're always simple copy-initialization. */
907 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
909 for (; field
; field
= next_initializable_field (DECL_CHAIN (field
)))
911 tree ftype
= TREE_TYPE (field
);
915 if (i
< CONSTRUCTOR_NELTS (ctor
))
916 val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
917 else if (DECL_INITIAL (field
))
918 val
= get_nsdmi (field
, /*ctor*/false);
919 else if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
920 /* Value-initialization of reference is ill-formed. */
924 if (empty_ctor
== NULL_TREE
)
925 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
930 if (TREE_CODE (ftype
) == ARRAY_TYPE
931 && TREE_CODE (val
) == CONSTRUCTOR
)
932 ok
= can_convert_array (ftype
, val
, flags
, complain
);
934 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
940 if (TREE_CODE (type
) == UNION_TYPE
)
944 if (i
< CONSTRUCTOR_NELTS (ctor
))
947 c
= alloc_conversion (ck_aggr
);
950 c
->user_conv_p
= true;
951 c
->check_narrowing
= true;
956 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
957 array type, if such a conversion is possible. */
960 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
963 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
964 tree elttype
= TREE_TYPE (type
);
969 enum conversion_rank rank
= cr_exact
;
971 /* We might need to propagate the size from the element to the array. */
972 complete_type (type
);
974 if (TYPE_DOMAIN (type
)
975 && !variably_modified_type_p (TYPE_DOMAIN (type
), NULL_TREE
))
977 unsigned HOST_WIDE_INT alen
= tree_to_uhwi (array_type_nelts_top (type
));
982 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
984 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
987 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
988 false, flags
, complain
);
992 if (sub
->rank
> rank
)
994 if (sub
->user_conv_p
)
1000 c
= alloc_conversion (ck_aggr
);
1003 c
->user_conv_p
= user
;
1009 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
1010 complex type, if such a conversion is possible. */
1013 build_complex_conv (tree type
, tree ctor
, int flags
,
1014 tsubst_flags_t complain
)
1017 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1018 tree elttype
= TREE_TYPE (type
);
1023 enum conversion_rank rank
= cr_exact
;
1028 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1030 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
1033 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
1034 false, flags
, complain
);
1038 if (sub
->rank
> rank
)
1040 if (sub
->user_conv_p
)
1046 c
= alloc_conversion (ck_aggr
);
1049 c
->user_conv_p
= user
;
1055 /* Build a representation of the identity conversion from EXPR to
1056 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1059 build_identity_conv (tree type
, tree expr
)
1063 c
= alloc_conversion (ck_identity
);
1070 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1071 were multiple user-defined conversions to accomplish the job.
1072 Build a conversion that indicates that ambiguity. */
1075 build_ambiguous_conv (tree type
, tree expr
)
1079 c
= alloc_conversion (ck_ambig
);
1087 strip_top_quals (tree t
)
1089 if (TREE_CODE (t
) == ARRAY_TYPE
)
1091 return cp_build_qualified_type (t
, 0);
1094 /* Returns the standard conversion path (see [conv]) from type FROM to type
1095 TO, if any. For proper handling of null pointer constants, you must
1096 also pass the expression EXPR to convert from. If C_CAST_P is true,
1097 this conversion is coming from a C-style cast. */
1100 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1101 int flags
, tsubst_flags_t complain
)
1103 enum tree_code fcode
, tcode
;
1105 bool fromref
= false;
1108 to
= non_reference (to
);
1109 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1112 from
= TREE_TYPE (from
);
1115 to
= strip_top_quals (to
);
1116 from
= strip_top_quals (from
);
1118 if (expr
&& type_unknown_p (expr
))
1120 if (TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1122 tsubst_flags_t tflags
= tf_conv
;
1123 expr
= instantiate_type (to
, expr
, tflags
);
1124 if (expr
== error_mark_node
)
1126 from
= TREE_TYPE (expr
);
1128 else if (TREE_CODE (to
) == BOOLEAN_TYPE
)
1130 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1131 expr
= resolve_nondeduced_context (expr
, complain
);
1132 from
= TREE_TYPE (expr
);
1136 fcode
= TREE_CODE (from
);
1137 tcode
= TREE_CODE (to
);
1139 conv
= build_identity_conv (from
, expr
);
1140 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1142 from
= type_decays_to (from
);
1143 fcode
= TREE_CODE (from
);
1144 conv
= build_conv (ck_lvalue
, from
, conv
);
1146 /* Wrapping a ck_rvalue around a class prvalue (as a result of using
1147 obvalue_p) seems odd, since it's already a prvalue, but that's how we
1148 express the copy constructor call required by copy-initialization. */
1149 else if (fromref
|| (expr
&& obvalue_p (expr
)))
1154 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1157 from
= strip_top_quals (bitfield_type
);
1158 fcode
= TREE_CODE (from
);
1161 conv
= build_conv (ck_rvalue
, from
, conv
);
1162 if (flags
& LOOKUP_PREFER_RVALUE
)
1163 conv
->rvaluedness_matches_p
= true;
1166 /* Allow conversion between `__complex__' data types. */
1167 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1169 /* The standard conversion sequence to convert FROM to TO is
1170 the standard conversion sequence to perform componentwise
1172 conversion
*part_conv
= standard_conversion
1173 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
,
1178 conv
= build_conv (part_conv
->kind
, to
, conv
);
1179 conv
->rank
= part_conv
->rank
;
1187 if (same_type_p (from
, to
))
1189 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1190 conv
->type
= qualified_to
;
1195 A null pointer constant can be converted to a pointer type; ... A
1196 null pointer constant of integral type can be converted to an
1197 rvalue of type std::nullptr_t. */
1198 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1199 || NULLPTR_TYPE_P (to
))
1200 && ((expr
&& null_ptr_cst_p (expr
))
1201 || NULLPTR_TYPE_P (from
)))
1202 conv
= build_conv (ck_std
, to
, conv
);
1203 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1204 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1206 /* For backwards brain damage compatibility, allow interconversion of
1207 pointers and integers with a pedwarn. */
1208 conv
= build_conv (ck_std
, to
, conv
);
1211 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1213 /* For backwards brain damage compatibility, allow interconversion of
1214 enums and integers with a pedwarn. */
1215 conv
= build_conv (ck_std
, to
, conv
);
1218 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1219 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1224 if (tcode
== POINTER_TYPE
)
1226 to_pointee
= TREE_TYPE (to
);
1227 from_pointee
= TREE_TYPE (from
);
1229 /* Since this is the target of a pointer, it can't have function
1230 qualifiers, so any TYPE_QUALS must be for attributes const or
1231 noreturn. Strip them. */
1232 if (TREE_CODE (to_pointee
) == FUNCTION_TYPE
1233 && TYPE_QUALS (to_pointee
))
1234 to_pointee
= build_qualified_type (to_pointee
, TYPE_UNQUALIFIED
);
1235 if (TREE_CODE (from_pointee
) == FUNCTION_TYPE
1236 && TYPE_QUALS (from_pointee
))
1237 from_pointee
= build_qualified_type (from_pointee
, TYPE_UNQUALIFIED
);
1241 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1242 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1245 if (tcode
== POINTER_TYPE
1246 && same_type_ignoring_top_level_qualifiers_p (from_pointee
,
1249 else if (VOID_TYPE_P (to_pointee
)
1250 && !TYPE_PTRDATAMEM_P (from
)
1251 && TREE_CODE (from_pointee
) != FUNCTION_TYPE
)
1253 tree nfrom
= TREE_TYPE (from
);
1254 /* Don't try to apply restrict to void. */
1255 int quals
= cp_type_quals (nfrom
) & ~TYPE_QUAL_RESTRICT
;
1256 from_pointee
= cp_build_qualified_type (void_type_node
, quals
);
1257 from
= build_pointer_type (from_pointee
);
1258 conv
= build_conv (ck_ptr
, from
, conv
);
1260 else if (TYPE_PTRDATAMEM_P (from
))
1262 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1263 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1265 if (DERIVED_FROM_P (fbase
, tbase
)
1266 && (same_type_ignoring_top_level_qualifiers_p
1267 (from_pointee
, to_pointee
)))
1269 from
= build_ptrmem_type (tbase
, from_pointee
);
1270 conv
= build_conv (ck_pmem
, from
, conv
);
1272 else if (!same_type_p (fbase
, tbase
))
1275 else if (CLASS_TYPE_P (from_pointee
)
1276 && CLASS_TYPE_P (to_pointee
)
1279 An rvalue of type "pointer to cv D," where D is a
1280 class type, can be converted to an rvalue of type
1281 "pointer to cv B," where B is a base class (clause
1282 _class.derived_) of D. If B is an inaccessible
1283 (clause _class.access_) or ambiguous
1284 (_class.member.lookup_) base class of D, a program
1285 that necessitates this conversion is ill-formed.
1286 Therefore, we use DERIVED_FROM_P, and do not check
1287 access or uniqueness. */
1288 && DERIVED_FROM_P (to_pointee
, from_pointee
))
1291 = cp_build_qualified_type (to_pointee
,
1292 cp_type_quals (from_pointee
));
1293 from
= build_pointer_type (from_pointee
);
1294 conv
= build_conv (ck_ptr
, from
, conv
);
1295 conv
->base_p
= true;
1298 if (same_type_p (from
, to
))
1300 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
1301 /* In a C-style cast, we ignore CV-qualification because we
1302 are allowed to perform a static_cast followed by a
1304 conv
= build_conv (ck_qual
, to
, conv
);
1305 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1306 conv
= build_conv (ck_qual
, to
, conv
);
1307 else if (expr
&& string_conv_p (to
, expr
, 0))
1308 /* converting from string constant to char *. */
1309 conv
= build_conv (ck_qual
, to
, conv
);
1310 else if (fnptr_conv_p (to
, from
))
1311 conv
= build_conv (ck_fnptr
, to
, conv
);
1312 /* Allow conversions among compatible ObjC pointer types (base
1313 conversions have been already handled above). */
1314 else if (c_dialect_objc ()
1315 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1316 conv
= build_conv (ck_ptr
, to
, conv
);
1317 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1319 conv
= build_conv (ck_ptr
, to
, conv
);
1327 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1329 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1330 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1331 tree fbase
= class_of_this_parm (fromfn
);
1332 tree tbase
= class_of_this_parm (tofn
);
1334 if (!DERIVED_FROM_P (fbase
, tbase
))
1337 tree fstat
= static_fn_type (fromfn
);
1338 tree tstat
= static_fn_type (tofn
);
1339 if (same_type_p (tstat
, fstat
)
1340 || fnptr_conv_p (tstat
, fstat
))
1345 if (!same_type_p (fbase
, tbase
))
1347 from
= build_memfn_type (fstat
,
1349 cp_type_quals (tbase
),
1350 type_memfn_rqual (tofn
));
1351 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1352 conv
= build_conv (ck_pmem
, from
, conv
);
1353 conv
->base_p
= true;
1355 if (fnptr_conv_p (tstat
, fstat
))
1356 conv
= build_conv (ck_fnptr
, to
, conv
);
1358 else if (tcode
== BOOLEAN_TYPE
)
1362 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1363 to member type can be converted to a prvalue of type bool. ...
1364 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1365 std::nullptr_t can be converted to a prvalue of type bool; */
1366 if (ARITHMETIC_TYPE_P (from
)
1367 || UNSCOPED_ENUM_P (from
)
1368 || fcode
== POINTER_TYPE
1369 || TYPE_PTRMEM_P (from
)
1370 || NULLPTR_TYPE_P (from
))
1372 conv
= build_conv (ck_std
, to
, conv
);
1373 if (fcode
== POINTER_TYPE
1374 || TYPE_PTRDATAMEM_P (from
)
1375 || (TYPE_PTRMEMFUNC_P (from
)
1376 && conv
->rank
< cr_pbool
)
1377 || NULLPTR_TYPE_P (from
))
1378 conv
->rank
= cr_pbool
;
1379 if (NULLPTR_TYPE_P (from
) && (flags
& LOOKUP_ONLYCONVERTING
))
1386 /* We don't check for ENUMERAL_TYPE here because there are no standard
1387 conversions to enum type. */
1388 /* As an extension, allow conversion to complex type. */
1389 else if (ARITHMETIC_TYPE_P (to
))
1391 if (! (INTEGRAL_CODE_P (fcode
)
1392 || (fcode
== REAL_TYPE
&& !(flags
& LOOKUP_NO_NON_INTEGRAL
)))
1393 || SCOPED_ENUM_P (from
))
1395 conv
= build_conv (ck_std
, to
, conv
);
1397 /* Give this a better rank if it's a promotion. */
1398 if (same_type_p (to
, type_promotes_to (from
))
1399 && next_conversion (conv
)->rank
<= cr_promotion
)
1400 conv
->rank
= cr_promotion
;
1402 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1403 && vector_types_convertible_p (from
, to
, false))
1404 return build_conv (ck_std
, to
, conv
);
1405 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1406 && is_properly_derived_from (from
, to
))
1408 if (conv
->kind
== ck_rvalue
)
1409 conv
= next_conversion (conv
);
1410 conv
= build_conv (ck_base
, to
, conv
);
1411 /* The derived-to-base conversion indicates the initialization
1412 of a parameter with base type from an object of a derived
1413 type. A temporary object is created to hold the result of
1414 the conversion unless we're binding directly to a reference. */
1415 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1420 if (flags
& LOOKUP_NO_NARROWING
)
1421 conv
->check_narrowing
= true;
1426 /* Returns nonzero if T1 is reference-related to T2. */
1429 reference_related_p (tree t1
, tree t2
)
1431 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1434 t1
= TYPE_MAIN_VARIANT (t1
);
1435 t2
= TYPE_MAIN_VARIANT (t2
);
1439 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1440 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1442 return (same_type_p (t1
, t2
)
1443 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1444 && DERIVED_FROM_P (t1
, t2
)));
1447 /* Returns nonzero if T1 is reference-compatible with T2. */
1450 reference_compatible_p (tree t1
, tree t2
)
1454 "cv1 T1" is reference compatible with "cv2 T2" if
1455 * T1 is reference-related to T2 or
1456 * T2 is "noexcept function" and T1 is "function", where the
1457 function types are otherwise the same,
1458 and cv1 is the same cv-qualification as, or greater cv-qualification
1460 return ((reference_related_p (t1
, t2
)
1461 || fnptr_conv_p (t1
, t2
))
1462 && at_least_as_qualified_p (t1
, t2
));
1465 /* A reference of the indicated TYPE is being bound directly to the
1466 expression represented by the implicit conversion sequence CONV.
1467 Return a conversion sequence for this binding. */
1470 direct_reference_binding (tree type
, conversion
*conv
)
1474 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1475 gcc_assert (TREE_CODE (conv
->type
) != REFERENCE_TYPE
);
1477 t
= TREE_TYPE (type
);
1481 When a parameter of reference type binds directly
1482 (_dcl.init.ref_) to an argument expression, the implicit
1483 conversion sequence is the identity conversion, unless the
1484 argument expression has a type that is a derived class of the
1485 parameter type, in which case the implicit conversion sequence is
1486 a derived-to-base Conversion.
1488 If the parameter binds directly to the result of applying a
1489 conversion function to the argument expression, the implicit
1490 conversion sequence is a user-defined conversion sequence
1491 (_over.ics.user_), with the second standard conversion sequence
1492 either an identity conversion or, if the conversion function
1493 returns an entity of a type that is a derived class of the
1494 parameter type, a derived-to-base conversion. */
1495 if (is_properly_derived_from (conv
->type
, t
))
1497 /* Represent the derived-to-base conversion. */
1498 conv
= build_conv (ck_base
, t
, conv
);
1499 /* We will actually be binding to the base-class subobject in
1500 the derived class, so we mark this conversion appropriately.
1501 That way, convert_like knows not to generate a temporary. */
1502 conv
->need_temporary_p
= false;
1504 return build_conv (ck_ref_bind
, type
, conv
);
1507 /* Returns the conversion path from type FROM to reference type TO for
1508 purposes of reference binding. For lvalue binding, either pass a
1509 reference type to FROM or an lvalue expression to EXPR. If the
1510 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1511 the conversion returned. If C_CAST_P is true, this
1512 conversion is coming from a C-style cast. */
1515 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1516 tsubst_flags_t complain
)
1518 conversion
*conv
= NULL
;
1519 tree to
= TREE_TYPE (rto
);
1524 cp_lvalue_kind gl_kind
;
1527 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1529 expr
= instantiate_type (to
, expr
, tf_none
);
1530 if (expr
== error_mark_node
)
1532 from
= TREE_TYPE (expr
);
1535 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1537 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1538 /* DR 1288: Otherwise, if the initializer list has a single element
1539 of type E and ... [T's] referenced type is reference-related to E,
1540 the object or reference is initialized from that element... */
1541 if (CONSTRUCTOR_NELTS (expr
) == 1)
1543 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1544 if (error_operand_p (elt
))
1546 tree etype
= TREE_TYPE (elt
);
1547 if (reference_related_p (to
, etype
))
1554 /* Otherwise, if T is a reference type, a prvalue temporary of the
1555 type referenced by T is copy-list-initialized or
1556 direct-list-initialized, depending on the kind of initialization
1557 for the reference, and the reference is bound to that temporary. */
1558 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1559 flags
|LOOKUP_NO_TEMP_BIND
, complain
);
1563 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1565 from
= TREE_TYPE (from
);
1566 if (!TYPE_REF_IS_RVALUE (rfrom
)
1567 || TREE_CODE (from
) == FUNCTION_TYPE
)
1568 gl_kind
= clk_ordinary
;
1570 gl_kind
= clk_rvalueref
;
1573 gl_kind
= lvalue_kind (expr
);
1574 else if (CLASS_TYPE_P (from
)
1575 || TREE_CODE (from
) == ARRAY_TYPE
)
1576 gl_kind
= clk_class
;
1580 /* Don't allow a class prvalue when LOOKUP_NO_TEMP_BIND. */
1581 if ((flags
& LOOKUP_NO_TEMP_BIND
)
1582 && (gl_kind
& clk_class
))
1585 /* Same mask as real_lvalue_p. */
1586 is_lvalue
= gl_kind
&& !(gl_kind
& (clk_rvalueref
|clk_class
));
1589 if ((gl_kind
& clk_bitfield
) != 0)
1590 tfrom
= unlowered_expr_type (expr
);
1592 /* Figure out whether or not the types are reference-related and
1593 reference compatible. We have to do this after stripping
1594 references from FROM. */
1595 related_p
= reference_related_p (to
, tfrom
);
1596 /* If this is a C cast, first convert to an appropriately qualified
1597 type, so that we can later do a const_cast to the desired type. */
1598 if (related_p
&& c_cast_p
1599 && !at_least_as_qualified_p (to
, tfrom
))
1600 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1601 compatible_p
= reference_compatible_p (to
, tfrom
);
1603 /* Directly bind reference when target expression's type is compatible with
1604 the reference and expression is an lvalue. In DR391, the wording in
1605 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1606 const and rvalue references to rvalues of compatible class type.
1607 We should also do direct bindings for non-class xvalues. */
1608 if ((related_p
|| compatible_p
) && gl_kind
)
1612 If the initializer expression
1614 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1615 is reference-compatible with "cv2 T2,"
1617 the reference is bound directly to the initializer expression
1621 If the initializer expression is an rvalue, with T2 a class type,
1622 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1623 is bound to the object represented by the rvalue or to a sub-object
1624 within that object. */
1626 conv
= build_identity_conv (tfrom
, expr
);
1627 conv
= direct_reference_binding (rto
, conv
);
1629 if (flags
& LOOKUP_PREFER_RVALUE
)
1630 /* The top-level caller requested that we pretend that the lvalue
1631 be treated as an rvalue. */
1632 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1633 else if (TREE_CODE (rfrom
) == REFERENCE_TYPE
)
1634 /* Handle rvalue reference to function properly. */
1635 conv
->rvaluedness_matches_p
1636 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1638 conv
->rvaluedness_matches_p
1639 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1641 if ((gl_kind
& clk_bitfield
) != 0
1642 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1643 /* For the purposes of overload resolution, we ignore the fact
1644 this expression is a bitfield or packed field. (In particular,
1645 [over.ics.ref] says specifically that a function with a
1646 non-const reference parameter is viable even if the
1647 argument is a bitfield.)
1649 However, when we actually call the function we must create
1650 a temporary to which to bind the reference. If the
1651 reference is volatile, or isn't const, then we cannot make
1652 a temporary, so we just issue an error when the conversion
1654 conv
->need_temporary_p
= true;
1656 /* Don't allow binding of lvalues (other than function lvalues) to
1657 rvalue references. */
1658 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1659 && TREE_CODE (to
) != FUNCTION_TYPE
1660 && !(flags
& LOOKUP_PREFER_RVALUE
))
1663 /* Nor the reverse. */
1664 if (!is_lvalue
&& !TYPE_REF_IS_RVALUE (rto
)
1665 && (!CP_TYPE_CONST_NON_VOLATILE_P (to
)
1666 || (flags
& LOOKUP_NO_RVAL_BIND
))
1667 && TREE_CODE (to
) != FUNCTION_TYPE
)
1675 /* [class.conv.fct] A conversion function is never used to convert a
1676 (possibly cv-qualified) object to the (possibly cv-qualified) same
1677 object type (or a reference to it), to a (possibly cv-qualified) base
1678 class of that type (or a reference to it).... */
1679 else if (CLASS_TYPE_P (from
) && !related_p
1680 && !(flags
& LOOKUP_NO_CONVERSION
))
1684 If the initializer expression
1686 -- has a class type (i.e., T2 is a class type) can be
1687 implicitly converted to an lvalue of type "cv3 T3," where
1688 "cv1 T1" is reference-compatible with "cv3 T3". (this
1689 conversion is selected by enumerating the applicable
1690 conversion functions (_over.match.ref_) and choosing the
1691 best one through overload resolution. (_over.match_).
1693 the reference is bound to the lvalue result of the conversion
1694 in the second case. */
1695 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1698 return cand
->second_conv
;
1701 /* From this point on, we conceptually need temporaries, even if we
1702 elide them. Only the cases above are "direct bindings". */
1703 if (flags
& LOOKUP_NO_TEMP_BIND
)
1708 When a parameter of reference type is not bound directly to an
1709 argument expression, the conversion sequence is the one required
1710 to convert the argument expression to the underlying type of the
1711 reference according to _over.best.ics_. Conceptually, this
1712 conversion sequence corresponds to copy-initializing a temporary
1713 of the underlying type with the argument expression. Any
1714 difference in top-level cv-qualification is subsumed by the
1715 initialization itself and does not constitute a conversion. */
1719 Otherwise, the reference shall be an lvalue reference to a
1720 non-volatile const type, or the reference shall be an rvalue
1723 We try below to treat this as a bad conversion to improve diagnostics,
1724 but if TO is an incomplete class, we need to reject this conversion
1725 now to avoid unnecessary instantiation. */
1726 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
)
1727 && !COMPLETE_TYPE_P (to
))
1730 /* We're generating a temporary now, but don't bind any more in the
1731 conversion (specifically, don't slice the temporary returned by a
1732 conversion operator). */
1733 flags
|= LOOKUP_NO_TEMP_BIND
;
1735 /* Core issue 899: When [copy-]initializing a temporary to be bound
1736 to the first parameter of a copy constructor (12.8) called with
1737 a single argument in the context of direct-initialization,
1738 explicit conversion functions are also considered.
1740 So don't set LOOKUP_ONLYCONVERTING in that case. */
1741 if (!(flags
& LOOKUP_COPY_PARM
))
1742 flags
|= LOOKUP_ONLYCONVERTING
;
1745 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1750 if (conv
->user_conv_p
)
1752 /* If initializing the temporary used a conversion function,
1753 recalculate the second conversion sequence. */
1754 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1755 if (t
->kind
== ck_user
1756 && DECL_CONV_FN_P (t
->cand
->fn
))
1758 tree ftype
= TREE_TYPE (TREE_TYPE (t
->cand
->fn
));
1759 int sflags
= (flags
|LOOKUP_NO_CONVERSION
)&~LOOKUP_NO_TEMP_BIND
;
1760 conversion
*new_second
1761 = reference_binding (rto
, ftype
, NULL_TREE
, c_cast_p
,
1765 return merge_conversion_sequences (t
, new_second
);
1769 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1770 /* This reference binding, unlike those above, requires the
1771 creation of a temporary. */
1772 conv
->need_temporary_p
= true;
1773 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1777 Otherwise, the reference shall be an lvalue reference to a
1778 non-volatile const type, or the reference shall be an rvalue
1780 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1785 Otherwise, a temporary of type "cv1 T1" is created and
1786 initialized from the initializer expression using the rules for a
1787 non-reference copy initialization. If T1 is reference-related to
1788 T2, cv1 must be the same cv-qualification as, or greater
1789 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1790 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1796 /* Returns the implicit conversion sequence (see [over.ics]) from type
1797 FROM to type TO. The optional expression EXPR may affect the
1798 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1799 true, this conversion is coming from a C-style cast. */
1802 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1803 int flags
, tsubst_flags_t complain
)
1807 if (from
== error_mark_node
|| to
== error_mark_node
1808 || expr
== error_mark_node
)
1811 /* Other flags only apply to the primary function in overload
1812 resolution, or after we've chosen one. */
1813 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
1814 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_PREFER_RVALUE
1815 |LOOKUP_NO_NARROWING
|LOOKUP_PROTECT
|LOOKUP_NO_NON_INTEGRAL
);
1817 /* FIXME: actually we don't want warnings either, but we can't just
1818 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1819 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1820 We really ought not to issue that warning until we've committed
1821 to that conversion. */
1822 complain
&= ~tf_error
;
1824 /* Call reshape_init early to remove redundant braces. */
1825 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
)
1826 && CLASS_TYPE_P (to
)
1827 && COMPLETE_TYPE_P (complete_type (to
))
1828 && !CLASSTYPE_NON_AGGREGATE (to
))
1830 expr
= reshape_init (to
, expr
, complain
);
1831 if (expr
== error_mark_node
)
1833 from
= TREE_TYPE (expr
);
1836 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1837 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
1839 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
, complain
);
1844 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1846 if (is_std_init_list (to
))
1847 return build_list_conv (to
, expr
, flags
, complain
);
1849 /* As an extension, allow list-initialization of _Complex. */
1850 if (TREE_CODE (to
) == COMPLEX_TYPE
)
1852 conv
= build_complex_conv (to
, expr
, flags
, complain
);
1857 /* Allow conversion from an initializer-list with one element to a
1859 if (SCALAR_TYPE_P (to
))
1861 int nelts
= CONSTRUCTOR_NELTS (expr
);
1865 elt
= build_value_init (to
, tf_none
);
1866 else if (nelts
== 1)
1867 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1869 elt
= error_mark_node
;
1871 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
1872 c_cast_p
, flags
, complain
);
1875 conv
->check_narrowing
= true;
1876 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
1877 /* Too many levels of braces, i.e. '{{1}}'. */
1882 else if (TREE_CODE (to
) == ARRAY_TYPE
)
1883 return build_array_conv (to
, expr
, flags
, complain
);
1886 if (expr
!= NULL_TREE
1887 && (MAYBE_CLASS_TYPE_P (from
)
1888 || MAYBE_CLASS_TYPE_P (to
))
1889 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1891 struct z_candidate
*cand
;
1893 if (CLASS_TYPE_P (to
)
1894 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
1895 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
1896 return build_aggr_conv (to
, expr
, flags
, complain
);
1898 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
1901 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
1902 && CONSTRUCTOR_NELTS (expr
) == 1
1903 && !is_list_ctor (cand
->fn
))
1905 /* "If C is not an initializer-list constructor and the
1906 initializer list has a single element of type cv U, where U is
1907 X or a class derived from X, the implicit conversion sequence
1908 has Exact Match rank if U is X, or Conversion rank if U is
1910 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1911 tree elttype
= TREE_TYPE (elt
);
1912 if (reference_related_p (to
, elttype
))
1913 return implicit_conversion (to
, elttype
, elt
,
1914 c_cast_p
, flags
, complain
);
1916 conv
= cand
->second_conv
;
1919 /* We used to try to bind a reference to a temporary here, but that
1920 is now handled after the recursive call to this function at the end
1921 of reference_binding. */
1928 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1929 functions. ARGS will not be changed until a single candidate is
1932 static struct z_candidate
*
1933 add_candidate (struct z_candidate
**candidates
,
1934 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
1935 size_t num_convs
, conversion
**convs
,
1936 tree access_path
, tree conversion_path
,
1937 int viable
, struct rejection_reason
*reason
,
1940 struct z_candidate
*cand
= (struct z_candidate
*)
1941 conversion_obstack_alloc (sizeof (struct z_candidate
));
1944 cand
->first_arg
= first_arg
;
1946 cand
->convs
= convs
;
1947 cand
->num_convs
= num_convs
;
1948 cand
->access_path
= access_path
;
1949 cand
->conversion_path
= conversion_path
;
1950 cand
->viable
= viable
;
1951 cand
->reason
= reason
;
1952 cand
->next
= *candidates
;
1953 cand
->flags
= flags
;
1959 /* Return the number of remaining arguments in the parameter list
1960 beginning with ARG. */
1963 remaining_arguments (tree arg
)
1967 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
1968 arg
= TREE_CHAIN (arg
))
1974 /* Create an overload candidate for the function or method FN called
1975 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1976 FLAGS is passed on to implicit_conversion.
1978 This does not change ARGS.
1980 CTYPE, if non-NULL, is the type we want to pretend this function
1981 comes from for purposes of overload resolution. */
1983 static struct z_candidate
*
1984 add_function_candidate (struct z_candidate
**candidates
,
1985 tree fn
, tree ctype
, tree first_arg
,
1986 const vec
<tree
, va_gc
> *args
, tree access_path
,
1987 tree conversion_path
, int flags
,
1988 tsubst_flags_t complain
)
1990 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1994 tree orig_first_arg
= first_arg
;
1997 struct rejection_reason
*reason
= NULL
;
1999 /* At this point we should not see any functions which haven't been
2000 explicitly declared, except for friend functions which will have
2001 been found using argument dependent lookup. */
2002 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
2004 /* The `this', `in_chrg' and VTT arguments to constructors are not
2005 considered in overload resolution. */
2006 if (DECL_CONSTRUCTOR_P (fn
))
2008 if (ctor_omit_inherited_parms (fn
))
2009 /* Bring back parameters omitted from an inherited ctor. */
2010 parmlist
= FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn
));
2012 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
2013 skip
= num_artificial_parms_for (fn
);
2014 if (skip
> 0 && first_arg
!= NULL_TREE
)
2017 first_arg
= NULL_TREE
;
2023 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
2024 convs
= alloc_conversions (len
);
2026 /* 13.3.2 - Viable functions [over.match.viable]
2027 First, to be a viable function, a candidate function shall have enough
2028 parameters to agree in number with the arguments in the list.
2030 We need to check this first; otherwise, checking the ICSes might cause
2031 us to produce an ill-formed template instantiation. */
2033 parmnode
= parmlist
;
2034 for (i
= 0; i
< len
; ++i
)
2036 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
2038 parmnode
= TREE_CHAIN (parmnode
);
2041 if ((i
< len
&& parmnode
)
2042 || !sufficient_parms_p (parmnode
))
2044 int remaining
= remaining_arguments (parmnode
);
2046 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
2049 /* An inherited constructor (12.6.3 [class.inhctor.init]) that has a first
2050 parameter of type "reference to cv C" (including such a constructor
2051 instantiated from a template) is excluded from the set of candidate
2052 functions when used to construct an object of type D with an argument list
2053 containing a single argument if C is reference-related to D. */
2054 if (viable
&& len
== 1 && parmlist
&& DECL_CONSTRUCTOR_P (fn
)
2055 && flag_new_inheriting_ctors
2056 && DECL_INHERITED_CTOR (fn
))
2058 tree ptype
= non_reference (TREE_VALUE (parmlist
));
2059 tree dtype
= DECL_CONTEXT (fn
);
2060 if (reference_related_p (ptype
, dtype
))
2063 reason
= inherited_ctor_rejection ();
2067 /* Second, for a function to be viable, its constraints must be
2069 if (flag_concepts
&& viable
2070 && !constraints_satisfied_p (fn
))
2072 reason
= constraint_failure (fn
);
2076 /* When looking for a function from a subobject from an implicit
2077 copy/move constructor/operator=, don't consider anything that takes (a
2078 reference to) an unrelated type. See c++/44909 and core 1092. */
2079 if (viable
&& parmlist
&& (flags
& LOOKUP_DEFAULTED
))
2081 if (DECL_CONSTRUCTOR_P (fn
))
2083 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
2084 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
2090 parmnode
= chain_index (i
-1, parmlist
);
2091 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
2096 /* This only applies at the top level. */
2097 flags
&= ~LOOKUP_DEFAULTED
;
2103 /* Third, for F to be a viable function, there shall exist for each
2104 argument an implicit conversion sequence that converts that argument
2105 to the corresponding parameter of F. */
2107 parmnode
= parmlist
;
2109 for (i
= 0; i
< len
; ++i
)
2111 tree argtype
, to_type
;
2116 if (parmnode
== void_list_node
)
2119 if (i
== 0 && first_arg
!= NULL_TREE
)
2122 arg
= CONST_CAST_TREE (
2123 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
2124 argtype
= lvalue_type (arg
);
2126 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2127 && ! DECL_CONSTRUCTOR_P (fn
));
2131 tree parmtype
= TREE_VALUE (parmnode
);
2134 parmnode
= TREE_CHAIN (parmnode
);
2136 /* The type of the implicit object parameter ('this') for
2137 overload resolution is not always the same as for the
2138 function itself; conversion functions are considered to
2139 be members of the class being converted, and functions
2140 introduced by a using-declaration are considered to be
2141 members of the class that uses them.
2143 Since build_over_call ignores the ICS for the `this'
2144 parameter, we can just change the parm type. */
2145 if (ctype
&& is_this
)
2147 parmtype
= cp_build_qualified_type
2148 (ctype
, cp_type_quals (TREE_TYPE (parmtype
)));
2149 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
2151 /* If the function has a ref-qualifier, the implicit
2152 object parameter has reference type. */
2153 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
2154 parmtype
= cp_build_reference_type (parmtype
, rv
);
2155 /* The special handling of 'this' conversions in compare_ics
2156 does not apply if there is a ref-qualifier. */
2161 parmtype
= build_pointer_type (parmtype
);
2162 arg
= build_this (arg
);
2163 argtype
= lvalue_type (arg
);
2167 /* Core issue 899: When [copy-]initializing a temporary to be bound
2168 to the first parameter of a copy constructor (12.8) called with
2169 a single argument in the context of direct-initialization,
2170 explicit conversion functions are also considered.
2172 So set LOOKUP_COPY_PARM to let reference_binding know that
2173 it's being called in that context. We generalize the above
2174 to handle move constructors and template constructors as well;
2175 the standardese should soon be updated similarly. */
2176 if (ctype
&& i
== 0 && (len
-skip
== 1)
2177 && DECL_CONSTRUCTOR_P (fn
)
2178 && parmtype
!= error_mark_node
2179 && (same_type_ignoring_top_level_qualifiers_p
2180 (non_reference (parmtype
), ctype
)))
2182 if (!(flags
& LOOKUP_ONLYCONVERTING
))
2183 lflags
|= LOOKUP_COPY_PARM
;
2184 /* We allow user-defined conversions within init-lists, but
2185 don't list-initialize the copy parm, as that would mean
2186 using two levels of braces for the same type. */
2187 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
2188 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
2189 lflags
|= LOOKUP_NO_CONVERSION
;
2192 lflags
|= LOOKUP_ONLYCONVERTING
;
2194 t
= implicit_conversion (parmtype
, argtype
, arg
,
2195 /*c_cast_p=*/false, lflags
, complain
);
2200 t
= build_identity_conv (argtype
, arg
);
2201 t
->ellipsis_p
= true;
2212 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
);
2219 reason
= bad_arg_conversion_rejection (first_arg
, i
, arg
, to_type
);
2224 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2225 access_path
, conversion_path
, viable
, reason
, flags
);
2228 /* Create an overload candidate for the conversion function FN which will
2229 be invoked for expression OBJ, producing a pointer-to-function which
2230 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2231 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2232 passed on to implicit_conversion.
2234 Actually, we don't really care about FN; we care about the type it
2235 converts to. There may be multiple conversion functions that will
2236 convert to that type, and we rely on build_user_type_conversion_1 to
2237 choose the best one; so when we create our candidate, we record the type
2238 instead of the function. */
2240 static struct z_candidate
*
2241 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2242 const vec
<tree
, va_gc
> *arglist
,
2243 tree access_path
, tree conversion_path
,
2244 tsubst_flags_t complain
)
2246 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2247 int i
, len
, viable
, flags
;
2248 tree parmlist
, parmnode
;
2250 struct rejection_reason
*reason
;
2252 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2253 parmlist
= TREE_TYPE (parmlist
);
2254 parmlist
= TYPE_ARG_TYPES (parmlist
);
2256 len
= vec_safe_length (arglist
) + 1;
2257 convs
= alloc_conversions (len
);
2258 parmnode
= parmlist
;
2260 flags
= LOOKUP_IMPLICIT
;
2263 /* Don't bother looking up the same type twice. */
2264 if (*candidates
&& (*candidates
)->fn
== totype
)
2267 for (i
= 0; i
< len
; ++i
)
2269 tree arg
, argtype
, convert_type
= NULL_TREE
;
2275 arg
= (*arglist
)[i
- 1];
2276 argtype
= lvalue_type (arg
);
2280 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
2282 convert_type
= totype
;
2284 else if (parmnode
== void_list_node
)
2288 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2289 /*c_cast_p=*/false, flags
, complain
);
2290 convert_type
= TREE_VALUE (parmnode
);
2294 t
= build_identity_conv (argtype
, arg
);
2295 t
->ellipsis_p
= true;
2296 convert_type
= argtype
;
2306 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, arg
, convert_type
);
2313 parmnode
= TREE_CHAIN (parmnode
);
2317 || ! sufficient_parms_p (parmnode
))
2319 int remaining
= remaining_arguments (parmnode
);
2321 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2324 return add_candidate (candidates
, totype
, obj
, arglist
, len
, convs
,
2325 access_path
, conversion_path
, viable
, reason
, flags
);
2329 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2330 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
2331 int flags
, tsubst_flags_t complain
)
2338 struct rejection_reason
*reason
= NULL
;
2343 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
2344 convs
= alloc_conversions (num_convs
);
2346 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2347 conversion ops are allowed. We handle that here by just checking for
2348 boolean_type_node because other operators don't ask for it. COND_EXPR
2349 also does contextual conversion to bool for the first operand, but we
2350 handle that in build_conditional_expr, and type1 here is operand 2. */
2351 if (type1
!= boolean_type_node
)
2352 flags
|= LOOKUP_ONLYCONVERTING
;
2354 for (i
= 0; i
< 2; ++i
)
2359 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2360 /*c_cast_p=*/false, flags
, complain
);
2364 /* We need something for printing the candidate. */
2365 t
= build_identity_conv (types
[i
], NULL_TREE
);
2366 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2372 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, args
[i
],
2378 /* For COND_EXPR we rearranged the arguments; undo that now. */
2381 convs
[2] = convs
[1];
2382 convs
[1] = convs
[0];
2383 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2384 /*c_cast_p=*/false, flags
,
2391 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2396 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2398 /*access_path=*/NULL_TREE
,
2399 /*conversion_path=*/NULL_TREE
,
2400 viable
, reason
, flags
);
2404 is_complete (tree t
)
2406 return COMPLETE_TYPE_P (complete_type (t
));
2409 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2412 promoted_arithmetic_type_p (tree type
)
2416 In this section, the term promoted integral type is used to refer
2417 to those integral types which are preserved by integral promotion
2418 (including e.g. int and long but excluding e.g. char).
2419 Similarly, the term promoted arithmetic type refers to promoted
2420 integral types plus floating types. */
2421 return ((CP_INTEGRAL_TYPE_P (type
)
2422 && same_type_p (type_promotes_to (type
), type
))
2423 || TREE_CODE (type
) == REAL_TYPE
);
2426 /* Create any builtin operator overload candidates for the operator in
2427 question given the converted operand types TYPE1 and TYPE2. The other
2428 args are passed through from add_builtin_candidates to
2429 build_builtin_candidate.
2431 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2432 If CODE is requires candidates operands of the same type of the kind
2433 of which TYPE1 and TYPE2 are, we add both candidates
2434 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2437 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2438 enum tree_code code2
, tree fnname
, tree type1
,
2439 tree type2
, tree
*args
, tree
*argtypes
, int flags
,
2440 tsubst_flags_t complain
)
2444 case POSTINCREMENT_EXPR
:
2445 case POSTDECREMENT_EXPR
:
2446 args
[1] = integer_zero_node
;
2447 type2
= integer_type_node
;
2456 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2457 and VQ is either volatile or empty, there exist candidate operator
2458 functions of the form
2459 VQ T& operator++(VQ T&);
2460 T operator++(VQ T&, int);
2461 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2462 type other than bool, and VQ is either volatile or empty, there exist
2463 candidate operator functions of the form
2464 VQ T& operator--(VQ T&);
2465 T operator--(VQ T&, int);
2466 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2467 complete object type, and VQ is either volatile or empty, there exist
2468 candidate operator functions of the form
2469 T*VQ& operator++(T*VQ&);
2470 T*VQ& operator--(T*VQ&);
2471 T* operator++(T*VQ&, int);
2472 T* operator--(T*VQ&, int); */
2474 case POSTDECREMENT_EXPR
:
2475 case PREDECREMENT_EXPR
:
2476 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2479 case POSTINCREMENT_EXPR
:
2480 case PREINCREMENT_EXPR
:
2481 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2483 type1
= build_reference_type (type1
);
2488 /* 7 For every cv-qualified or cv-unqualified object type T, there
2489 exist candidate operator functions of the form
2493 8 For every function type T, there exist candidate operator functions of
2495 T& operator*(T*); */
2498 if (TYPE_PTR_P (type1
)
2499 && (TYPE_PTROB_P (type1
)
2500 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2504 /* 9 For every type T, there exist candidate operator functions of the form
2507 10For every promoted arithmetic type T, there exist candidate operator
2508 functions of the form
2512 case UNARY_PLUS_EXPR
: /* unary + */
2513 if (TYPE_PTR_P (type1
))
2517 if (ARITHMETIC_TYPE_P (type1
))
2521 /* 11For every promoted integral type T, there exist candidate operator
2522 functions of the form
2526 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2530 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2531 is the same type as C2 or is a derived class of C2, T is a complete
2532 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2533 there exist candidate operator functions of the form
2534 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2535 where CV12 is the union of CV1 and CV2. */
2538 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2540 tree c1
= TREE_TYPE (type1
);
2541 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2543 if (MAYBE_CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2544 && (TYPE_PTRMEMFUNC_P (type2
)
2545 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2550 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2551 didate operator functions of the form
2556 bool operator<(L, R);
2557 bool operator>(L, R);
2558 bool operator<=(L, R);
2559 bool operator>=(L, R);
2560 bool operator==(L, R);
2561 bool operator!=(L, R);
2562 where LR is the result of the usual arithmetic conversions between
2565 14For every pair of types T and I, where T is a cv-qualified or cv-
2566 unqualified complete object type and I is a promoted integral type,
2567 there exist candidate operator functions of the form
2568 T* operator+(T*, I);
2569 T& operator[](T*, I);
2570 T* operator-(T*, I);
2571 T* operator+(I, T*);
2572 T& operator[](I, T*);
2574 15For every T, where T is a pointer to complete object type, there exist
2575 candidate operator functions of the form112)
2576 ptrdiff_t operator-(T, T);
2578 16For every pointer or enumeration type T, there exist candidate operator
2579 functions of the form
2580 bool operator<(T, T);
2581 bool operator>(T, T);
2582 bool operator<=(T, T);
2583 bool operator>=(T, T);
2584 bool operator==(T, T);
2585 bool operator!=(T, T);
2587 17For every pointer to member type T, there exist candidate operator
2588 functions of the form
2589 bool operator==(T, T);
2590 bool operator!=(T, T); */
2593 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2595 if (TYPE_PTROB_P (type1
)
2596 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2598 type2
= ptrdiff_type_node
;
2603 case TRUNC_DIV_EXPR
:
2604 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2610 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2611 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
2613 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
2618 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
2630 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2632 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2634 if (TREE_CODE (type1
) == ENUMERAL_TYPE
2635 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
2637 if (TYPE_PTR_P (type1
)
2638 && null_ptr_cst_p (args
[1]))
2643 if (null_ptr_cst_p (args
[0])
2644 && TYPE_PTR_P (type2
))
2652 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2656 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
2658 type1
= ptrdiff_type_node
;
2661 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2663 type2
= ptrdiff_type_node
;
2668 /* 18For every pair of promoted integral types L and R, there exist candi-
2669 date operator functions of the form
2676 where LR is the result of the usual arithmetic conversions between
2679 case TRUNC_MOD_EXPR
:
2685 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2689 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2690 type, VQ is either volatile or empty, and R is a promoted arithmetic
2691 type, there exist candidate operator functions of the form
2692 VQ L& operator=(VQ L&, R);
2693 VQ L& operator*=(VQ L&, R);
2694 VQ L& operator/=(VQ L&, R);
2695 VQ L& operator+=(VQ L&, R);
2696 VQ L& operator-=(VQ L&, R);
2698 20For every pair T, VQ), where T is any type and VQ is either volatile
2699 or empty, there exist candidate operator functions of the form
2700 T*VQ& operator=(T*VQ&, T*);
2702 21For every pair T, VQ), where T is a pointer to member type and VQ is
2703 either volatile or empty, there exist candidate operator functions of
2705 VQ T& operator=(VQ T&, T);
2707 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2708 unqualified complete object type, VQ is either volatile or empty, and
2709 I is a promoted integral type, there exist candidate operator func-
2711 T*VQ& operator+=(T*VQ&, I);
2712 T*VQ& operator-=(T*VQ&, I);
2714 23For every triple L, VQ, R), where L is an integral or enumeration
2715 type, VQ is either volatile or empty, and R is a promoted integral
2716 type, there exist candidate operator functions of the form
2718 VQ L& operator%=(VQ L&, R);
2719 VQ L& operator<<=(VQ L&, R);
2720 VQ L& operator>>=(VQ L&, R);
2721 VQ L& operator&=(VQ L&, R);
2722 VQ L& operator^=(VQ L&, R);
2723 VQ L& operator|=(VQ L&, R); */
2730 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2732 type2
= ptrdiff_type_node
;
2737 case TRUNC_DIV_EXPR
:
2738 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2742 case TRUNC_MOD_EXPR
:
2748 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2753 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2755 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2756 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2757 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2758 || ((TYPE_PTRMEMFUNC_P (type1
)
2759 || TYPE_PTR_P (type1
))
2760 && null_ptr_cst_p (args
[1])))
2770 type1
= build_reference_type (type1
);
2776 For every pair of promoted arithmetic types L and R, there
2777 exist candidate operator functions of the form
2779 LR operator?(bool, L, R);
2781 where LR is the result of the usual arithmetic conversions
2782 between types L and R.
2784 For every type T, where T is a pointer or pointer-to-member
2785 type, there exist candidate operator functions of the form T
2786 operator?(bool, T, T); */
2788 if (promoted_arithmetic_type_p (type1
)
2789 && promoted_arithmetic_type_p (type2
))
2793 /* Otherwise, the types should be pointers. */
2794 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
2797 /* We don't check that the two types are the same; the logic
2798 below will actually create two candidates; one in which both
2799 parameter types are TYPE1, and one in which both parameter
2805 if (ARITHMETIC_TYPE_P (type1
))
2813 /* Make sure we don't create builtin candidates with dependent types. */
2814 bool u1
= uses_template_parms (type1
);
2815 bool u2
= type2
? uses_template_parms (type2
) : false;
2818 /* Try to recover if one of the types is non-dependent. But if
2819 there's only one type, there's nothing we can do. */
2822 /* And we lose if both are dependent. */
2825 /* Or if they have different forms. */
2826 if (TREE_CODE (type1
) != TREE_CODE (type2
))
2835 /* If we're dealing with two pointer types or two enumeral types,
2836 we need candidates for both of them. */
2837 if (type2
&& !same_type_p (type1
, type2
)
2838 && TREE_CODE (type1
) == TREE_CODE (type2
)
2839 && (TREE_CODE (type1
) == REFERENCE_TYPE
2840 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2841 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2842 || TYPE_PTRMEMFUNC_P (type1
)
2843 || MAYBE_CLASS_TYPE_P (type1
)
2844 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2846 if (TYPE_PTR_OR_PTRMEM_P (type1
))
2848 tree cptype
= composite_pointer_type (type1
, type2
,
2853 if (cptype
!= error_mark_node
)
2855 build_builtin_candidate
2856 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
2862 build_builtin_candidate
2863 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
2864 build_builtin_candidate
2865 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
2869 build_builtin_candidate
2870 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
2874 type_decays_to (tree type
)
2876 if (TREE_CODE (type
) == ARRAY_TYPE
)
2877 return build_pointer_type (TREE_TYPE (type
));
2878 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2879 return build_pointer_type (type
);
2883 /* There are three conditions of builtin candidates:
2885 1) bool-taking candidates. These are the same regardless of the input.
2886 2) pointer-pair taking candidates. These are generated for each type
2887 one of the input types converts to.
2888 3) arithmetic candidates. According to the standard, we should generate
2889 all of these, but I'm trying not to...
2891 Here we generate a superset of the possible candidates for this particular
2892 case. That is a subset of the full set the standard defines, plus some
2893 other cases which the standard disallows. add_builtin_candidate will
2894 filter out the invalid set. */
2897 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2898 enum tree_code code2
, tree fnname
, tree
*args
,
2899 int flags
, tsubst_flags_t complain
)
2903 tree type
, argtypes
[3], t
;
2904 /* TYPES[i] is the set of possible builtin-operator parameter types
2905 we will consider for the Ith argument. */
2906 vec
<tree
, va_gc
> *types
[2];
2909 for (i
= 0; i
< 3; ++i
)
2912 argtypes
[i
] = unlowered_expr_type (args
[i
]);
2914 argtypes
[i
] = NULL_TREE
;
2919 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2920 and VQ is either volatile or empty, there exist candidate operator
2921 functions of the form
2922 VQ T& operator++(VQ T&); */
2924 case POSTINCREMENT_EXPR
:
2925 case PREINCREMENT_EXPR
:
2926 case POSTDECREMENT_EXPR
:
2927 case PREDECREMENT_EXPR
:
2932 /* 24There also exist candidate operator functions of the form
2933 bool operator!(bool);
2934 bool operator&&(bool, bool);
2935 bool operator||(bool, bool); */
2937 case TRUTH_NOT_EXPR
:
2938 build_builtin_candidate
2939 (candidates
, fnname
, boolean_type_node
,
2940 NULL_TREE
, args
, argtypes
, flags
, complain
);
2943 case TRUTH_ORIF_EXPR
:
2944 case TRUTH_ANDIF_EXPR
:
2945 build_builtin_candidate
2946 (candidates
, fnname
, boolean_type_node
,
2947 boolean_type_node
, args
, argtypes
, flags
, complain
);
2969 types
[0] = make_tree_vector ();
2970 types
[1] = make_tree_vector ();
2972 for (i
= 0; i
< 2; ++i
)
2976 else if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
2980 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2983 convs
= lookup_conversions (argtypes
[i
]);
2985 if (code
== COND_EXPR
)
2987 if (lvalue_p (args
[i
]))
2988 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2990 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
2996 for (; convs
; convs
= TREE_CHAIN (convs
))
2998 type
= TREE_TYPE (convs
);
3001 && (TREE_CODE (type
) != REFERENCE_TYPE
3002 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
3005 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
3006 vec_safe_push (types
[i
], type
);
3008 type
= non_reference (type
);
3009 if (i
!= 0 || ! ref1
)
3011 type
= cv_unqualified (type_decays_to (type
));
3012 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
3013 vec_safe_push (types
[i
], type
);
3014 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3015 type
= type_promotes_to (type
);
3018 if (! vec_member (type
, types
[i
]))
3019 vec_safe_push (types
[i
], type
);
3024 if (code
== COND_EXPR
&& lvalue_p (args
[i
]))
3025 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
3026 type
= non_reference (argtypes
[i
]);
3027 if (i
!= 0 || ! ref1
)
3029 type
= cv_unqualified (type_decays_to (type
));
3030 if (enum_p
&& UNSCOPED_ENUM_P (type
))
3031 vec_safe_push (types
[i
], type
);
3032 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3033 type
= type_promotes_to (type
);
3035 vec_safe_push (types
[i
], type
);
3039 /* Run through the possible parameter types of both arguments,
3040 creating candidates with those parameter types. */
3041 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
3046 if (!types
[1]->is_empty ())
3047 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
3048 add_builtin_candidate
3049 (candidates
, code
, code2
, fnname
, t
,
3050 u
, args
, argtypes
, flags
, complain
);
3052 add_builtin_candidate
3053 (candidates
, code
, code2
, fnname
, t
,
3054 NULL_TREE
, args
, argtypes
, flags
, complain
);
3057 release_tree_vector (types
[0]);
3058 release_tree_vector (types
[1]);
3062 /* If TMPL can be successfully instantiated as indicated by
3063 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
3065 TMPL is the template. EXPLICIT_TARGS are any explicit template
3066 arguments. ARGLIST is the arguments provided at the call-site.
3067 This does not change ARGLIST. The RETURN_TYPE is the desired type
3068 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
3069 as for add_function_candidate. If an OBJ is supplied, FLAGS and
3070 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
3072 static struct z_candidate
*
3073 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
3074 tree ctype
, tree explicit_targs
, tree first_arg
,
3075 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3076 tree access_path
, tree conversion_path
,
3077 int flags
, tree obj
, unification_kind_t strict
,
3078 tsubst_flags_t complain
)
3080 int ntparms
= DECL_NTPARMS (tmpl
);
3081 tree targs
= make_tree_vec (ntparms
);
3082 unsigned int len
= vec_safe_length (arglist
);
3083 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
3084 unsigned int skip_without_in_chrg
= 0;
3085 tree first_arg_without_in_chrg
= first_arg
;
3086 tree
*args_without_in_chrg
;
3087 unsigned int nargs_without_in_chrg
;
3088 unsigned int ia
, ix
;
3090 struct z_candidate
*cand
;
3092 struct rejection_reason
*reason
= NULL
;
3095 /* We don't do deduction on the in-charge parameter, the VTT
3096 parameter or 'this'. */
3097 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
3099 if (first_arg_without_in_chrg
!= NULL_TREE
)
3100 first_arg_without_in_chrg
= NULL_TREE
;
3101 else if (return_type
&& strict
== DEDUCE_CALL
)
3102 /* We're deducing for a call to the result of a template conversion
3103 function, so the args don't contain 'this'; leave them alone. */;
3105 ++skip_without_in_chrg
;
3108 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
3109 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
3110 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
3112 if (first_arg_without_in_chrg
!= NULL_TREE
)
3113 first_arg_without_in_chrg
= NULL_TREE
;
3115 ++skip_without_in_chrg
;
3118 if (len
< skip_without_in_chrg
)
3121 if (DECL_CONSTRUCTOR_P (tmpl
) && nargs
== 2
3122 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (first_arg
),
3123 TREE_TYPE ((*arglist
)[0])))
3125 /* 12.8/6 says, "A declaration of a constructor for a class X is
3126 ill-formed if its first parameter is of type (optionally cv-qualified)
3127 X and either there are no other parameters or else all other
3128 parameters have default arguments. A member function template is never
3129 instantiated to produce such a constructor signature."
3131 So if we're trying to copy an object of the containing class, don't
3132 consider a template constructor that has a first parameter type that
3133 is just a template parameter, as we would deduce a signature that we
3134 would then reject in the code below. */
3135 if (tree firstparm
= FUNCTION_FIRST_USER_PARMTYPE (tmpl
))
3137 firstparm
= TREE_VALUE (firstparm
);
3138 if (PACK_EXPANSION_P (firstparm
))
3139 firstparm
= PACK_EXPANSION_PATTERN (firstparm
);
3140 if (TREE_CODE (firstparm
) == TEMPLATE_TYPE_PARM
)
3142 gcc_assert (!explicit_targs
);
3143 reason
= invalid_copy_with_fn_template_rejection ();
3149 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
3150 + (len
- skip_without_in_chrg
));
3151 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
3153 if (first_arg_without_in_chrg
!= NULL_TREE
)
3155 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
3158 for (ix
= skip_without_in_chrg
;
3159 vec_safe_iterate (arglist
, ix
, &arg
);
3162 args_without_in_chrg
[ia
] = arg
;
3165 gcc_assert (ia
== nargs_without_in_chrg
);
3167 errs
= errorcount
+sorrycount
;
3168 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
3169 args_without_in_chrg
,
3170 nargs_without_in_chrg
,
3171 return_type
, strict
, flags
, false,
3172 complain
& tf_decltype
);
3174 if (fn
== error_mark_node
)
3176 /* Don't repeat unification later if it already resulted in errors. */
3177 if (errorcount
+sorrycount
== errs
)
3178 reason
= template_unification_rejection (tmpl
, explicit_targs
,
3179 targs
, args_without_in_chrg
,
3180 nargs_without_in_chrg
,
3181 return_type
, strict
, flags
);
3183 reason
= template_unification_error_rejection ();
3187 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
3189 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3190 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
3193 /* We're trying to produce a constructor with a prohibited signature,
3194 as discussed above; handle here any cases we didn't catch then,
3196 reason
= invalid_copy_with_fn_template_rejection ();
3201 if (obj
!= NULL_TREE
)
3202 /* Aha, this is a conversion function. */
3203 cand
= add_conv_candidate (candidates
, fn
, obj
, arglist
,
3204 access_path
, conversion_path
, complain
);
3206 cand
= add_function_candidate (candidates
, fn
, ctype
,
3207 first_arg
, arglist
, access_path
,
3208 conversion_path
, flags
, complain
);
3209 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
3210 /* This situation can occur if a member template of a template
3211 class is specialized. Then, instantiate_template might return
3212 an instantiation of the specialization, in which case the
3213 DECL_TI_TEMPLATE field will point at the original
3214 specialization. For example:
3216 template <class T> struct S { template <class U> void f(U);
3217 template <> void f(int) {}; };
3221 Here, TMPL will be template <class U> S<double>::f(U).
3222 And, instantiate template will give us the specialization
3223 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3224 for this will point at template <class T> template <> S<T>::f(int),
3225 so that we can find the definition. For the purposes of
3226 overload resolution, however, we want the original TMPL. */
3227 cand
->template_decl
= build_template_info (tmpl
, targs
);
3229 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3230 cand
->explicit_targs
= explicit_targs
;
3234 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, NULL
,
3235 access_path
, conversion_path
, 0, reason
, flags
);
3239 static struct z_candidate
*
3240 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3241 tree explicit_targs
, tree first_arg
,
3242 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3243 tree access_path
, tree conversion_path
, int flags
,
3244 unification_kind_t strict
, tsubst_flags_t complain
)
3247 add_template_candidate_real (candidates
, tmpl
, ctype
,
3248 explicit_targs
, first_arg
, arglist
,
3249 return_type
, access_path
, conversion_path
,
3250 flags
, NULL_TREE
, strict
, complain
);
3253 /* Create an overload candidate for the conversion function template TMPL,
3254 returning RETURN_TYPE, which will be invoked for expression OBJ to produce a
3255 pointer-to-function which will in turn be called with the argument list
3256 ARGLIST, and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
3257 passed on to implicit_conversion. */
3259 static struct z_candidate
*
3260 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3262 const vec
<tree
, va_gc
> *arglist
,
3263 tree return_type
, tree access_path
,
3264 tree conversion_path
, tsubst_flags_t complain
)
3266 /* Making this work broke PR 71117, so until the committee resolves core
3267 issue 2189, let's disable this candidate if there are any viable call
3269 if (any_strictly_viable (*candidates
))
3273 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3274 NULL_TREE
, arglist
, return_type
, access_path
,
3275 conversion_path
, 0, obj
, DEDUCE_CALL
,
3279 /* The CANDS are the set of candidates that were considered for
3280 overload resolution. Return the set of viable candidates, or CANDS
3281 if none are viable. If any of the candidates were viable, set
3282 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3283 considered viable only if it is strictly viable. */
3285 static struct z_candidate
*
3286 splice_viable (struct z_candidate
*cands
,
3290 struct z_candidate
*viable
;
3291 struct z_candidate
**last_viable
;
3292 struct z_candidate
**cand
;
3293 bool found_strictly_viable
= false;
3295 /* Be strict inside templates, since build_over_call won't actually
3296 do the conversions to get pedwarns. */
3297 if (processing_template_decl
)
3301 last_viable
= &viable
;
3302 *any_viable_p
= false;
3307 struct z_candidate
*c
= *cand
;
3309 && (c
->viable
== 1 || TREE_CODE (c
->fn
) == TEMPLATE_DECL
))
3311 /* Be strict in the presence of a viable candidate. Also if
3312 there are template candidates, so that we get deduction errors
3313 for them instead of silently preferring a bad conversion. */
3315 if (viable
&& !found_strictly_viable
)
3317 /* Put any spliced near matches back onto the main list so
3318 that we see them if there is no strict match. */
3319 *any_viable_p
= false;
3320 *last_viable
= cands
;
3323 last_viable
= &viable
;
3327 if (strict_p
? c
->viable
== 1 : c
->viable
)
3332 last_viable
= &c
->next
;
3333 *any_viable_p
= true;
3335 found_strictly_viable
= true;
3341 return viable
? viable
: cands
;
3345 any_strictly_viable (struct z_candidate
*cands
)
3347 for (; cands
; cands
= cands
->next
)
3348 if (cands
->viable
== 1)
3353 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3354 words, it is about to become the "this" pointer for a member
3355 function call. Take the address of the object. */
3358 build_this (tree obj
)
3360 /* In a template, we are only concerned about the type of the
3361 expression, so we can take a shortcut. */
3362 if (processing_template_decl
)
3363 return build_address (obj
);
3365 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3368 /* Returns true iff functions are equivalent. Equivalent functions are
3369 not '==' only if one is a function-local extern function or if
3370 both are extern "C". */
3373 equal_functions (tree fn1
, tree fn2
)
3375 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3377 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3379 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
3380 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3381 return decls_match (fn1
, fn2
);
3385 /* Print information about a candidate being rejected due to INFO. */
3388 print_conversion_rejection (location_t loc
, struct conversion_info
*info
)
3390 tree from
= info
->from
;
3392 from
= lvalue_type (from
);
3393 if (info
->n_arg
== -1)
3395 /* Conversion of implicit `this' argument failed. */
3396 if (!TYPE_P (info
->from
))
3397 /* A bad conversion for 'this' must be discarding cv-quals. */
3398 inform (loc
, " passing %qT as %<this%> "
3399 "argument discards qualifiers",
3402 inform (loc
, " no known conversion for implicit "
3403 "%<this%> parameter from %qT to %qT",
3404 from
, info
->to_type
);
3406 else if (!TYPE_P (info
->from
))
3408 if (info
->n_arg
>= 0)
3409 inform (loc
, " conversion of argument %d would be ill-formed:",
3411 perform_implicit_conversion (info
->to_type
, info
->from
,
3412 tf_warning_or_error
);
3414 else if (info
->n_arg
== -2)
3415 /* Conversion of conversion function return value failed. */
3416 inform (loc
, " no known conversion from %qT to %qT",
3417 from
, info
->to_type
);
3419 inform (loc
, " no known conversion for argument %d from %qT to %qT",
3420 info
->n_arg
+ 1, from
, info
->to_type
);
3423 /* Print information about a candidate with WANT parameters and we found
3427 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
)
3429 inform_n (loc
, want
,
3430 " candidate expects %d argument, %d provided",
3431 " candidate expects %d arguments, %d provided",
3435 /* Print information about one overload candidate CANDIDATE. MSGSTR
3436 is the text to print before the candidate itself.
3438 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3439 to have been run through gettext by the caller. This wart makes
3440 life simpler in print_z_candidates and for the translators. */
3443 print_z_candidate (location_t loc
, const char *msgstr
,
3444 struct z_candidate
*candidate
)
3446 const char *msg
= (msgstr
== NULL
3448 : ACONCAT ((msgstr
, " ", NULL
)));
3449 tree fn
= candidate
->fn
;
3450 if (flag_new_inheriting_ctors
)
3451 fn
= strip_inheriting_ctors (fn
);
3452 location_t cloc
= location_of (fn
);
3454 if (identifier_p (fn
))
3457 if (candidate
->num_convs
== 3)
3458 inform (cloc
, "%s%D(%T, %T, %T) <built-in>", msg
, fn
,
3459 candidate
->convs
[0]->type
,
3460 candidate
->convs
[1]->type
,
3461 candidate
->convs
[2]->type
);
3462 else if (candidate
->num_convs
== 2)
3463 inform (cloc
, "%s%D(%T, %T) <built-in>", msg
, fn
,
3464 candidate
->convs
[0]->type
,
3465 candidate
->convs
[1]->type
);
3467 inform (cloc
, "%s%D(%T) <built-in>", msg
, fn
,
3468 candidate
->convs
[0]->type
);
3470 else if (TYPE_P (fn
))
3471 inform (cloc
, "%s%T <conversion>", msg
, fn
);
3472 else if (candidate
->viable
== -1)
3473 inform (cloc
, "%s%#D <near match>", msg
, fn
);
3474 else if (DECL_DELETED_FN (fn
))
3475 inform (cloc
, "%s%#D <deleted>", msg
, fn
);
3477 inform (cloc
, "%s%#D", msg
, fn
);
3478 if (fn
!= candidate
->fn
)
3480 cloc
= location_of (candidate
->fn
);
3481 inform (cloc
, " inherited here");
3483 /* Give the user some information about why this candidate failed. */
3484 if (candidate
->reason
!= NULL
)
3486 struct rejection_reason
*r
= candidate
->reason
;
3491 print_arity_information (cloc
, r
->u
.arity
.actual
,
3492 r
->u
.arity
.expected
);
3494 case rr_arg_conversion
:
3495 print_conversion_rejection (cloc
, &r
->u
.conversion
);
3497 case rr_bad_arg_conversion
:
3498 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
);
3500 case rr_explicit_conversion
:
3501 inform (cloc
, " return type %qT of explicit conversion function "
3502 "cannot be converted to %qT with a qualification "
3503 "conversion", r
->u
.conversion
.from
,
3504 r
->u
.conversion
.to_type
);
3506 case rr_template_conversion
:
3507 inform (cloc
, " conversion from return type %qT of template "
3508 "conversion function specialization to %qT is not an "
3509 "exact match", r
->u
.conversion
.from
,
3510 r
->u
.conversion
.to_type
);
3512 case rr_template_unification
:
3513 /* We use template_unification_error_rejection if unification caused
3514 actual non-SFINAE errors, in which case we don't need to repeat
3516 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
3518 inform (cloc
, " substitution of deduced template arguments "
3519 "resulted in errors seen above");
3522 /* Re-run template unification with diagnostics. */
3523 inform (cloc
, " template argument deduction/substitution failed:");
3524 fn_type_unification (r
->u
.template_unification
.tmpl
,
3525 r
->u
.template_unification
.explicit_targs
,
3527 (r
->u
.template_unification
.num_targs
)),
3528 r
->u
.template_unification
.args
,
3529 r
->u
.template_unification
.nargs
,
3530 r
->u
.template_unification
.return_type
,
3531 r
->u
.template_unification
.strict
,
3532 r
->u
.template_unification
.flags
,
3535 case rr_invalid_copy
:
3537 " a constructor taking a single argument of its own "
3538 "class type is invalid");
3540 case rr_constraint_failure
:
3542 tree tmpl
= r
->u
.template_instantiation
.tmpl
;
3543 tree args
= r
->u
.template_instantiation
.targs
;
3544 diagnose_constraints (cloc
, tmpl
, args
);
3547 case rr_inherited_ctor
:
3548 inform (cloc
, " an inherited constructor is not a candidate for "
3549 "initialization from an expression of the same or derived "
3554 /* This candidate didn't have any issues or we failed to
3555 handle a particular code. Either way... */
3562 print_z_candidates (location_t loc
, struct z_candidate
*candidates
)
3564 struct z_candidate
*cand1
;
3565 struct z_candidate
**cand2
;
3570 /* Remove non-viable deleted candidates. */
3572 for (cand2
= &cand1
; *cand2
; )
3574 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
3575 && !(*cand2
)->viable
3576 && DECL_DELETED_FN ((*cand2
)->fn
))
3577 *cand2
= (*cand2
)->next
;
3579 cand2
= &(*cand2
)->next
;
3581 /* ...if there are any non-deleted ones. */
3585 /* There may be duplicates in the set of candidates. We put off
3586 checking this condition as long as possible, since we have no way
3587 to eliminate duplicates from a set of functions in less than n^2
3588 time. Now we are about to emit an error message, so it is more
3589 permissible to go slowly. */
3590 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3592 tree fn
= cand1
->fn
;
3593 /* Skip builtin candidates and conversion functions. */
3596 cand2
= &cand1
->next
;
3599 if (DECL_P ((*cand2
)->fn
)
3600 && equal_functions (fn
, (*cand2
)->fn
))
3601 *cand2
= (*cand2
)->next
;
3603 cand2
= &(*cand2
)->next
;
3607 for (; candidates
; candidates
= candidates
->next
)
3608 print_z_candidate (loc
, "candidate:", candidates
);
3611 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3612 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3613 the result of the conversion function to convert it to the final
3614 desired type. Merge the two sequences into a single sequence,
3615 and return the merged sequence. */
3618 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
3621 bool bad
= user_seq
->bad_p
;
3623 gcc_assert (user_seq
->kind
== ck_user
);
3625 /* Find the end of the second conversion sequence. */
3626 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
3628 /* The entire sequence is a user-conversion sequence. */
3629 (*t
)->user_conv_p
= true;
3634 /* Replace the identity conversion with the user conversion
3641 /* Handle overload resolution for initializing an object of class type from
3642 an initializer list. First we look for a suitable constructor that
3643 takes a std::initializer_list; if we don't find one, we then look for a
3644 non-list constructor.
3646 Parameters are as for add_candidates, except that the arguments are in
3647 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3648 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3651 add_list_candidates (tree fns
, tree first_arg
,
3652 const vec
<tree
, va_gc
> *args
, tree totype
,
3653 tree explicit_targs
, bool template_only
,
3654 tree conversion_path
, tree access_path
,
3656 struct z_candidate
**candidates
,
3657 tsubst_flags_t complain
)
3659 gcc_assert (*candidates
== NULL
);
3661 /* We're looking for a ctor for list-initialization. */
3662 flags
|= LOOKUP_LIST_INIT_CTOR
;
3663 /* And we don't allow narrowing conversions. We also use this flag to
3664 avoid the copy constructor call for copy-list-initialization. */
3665 flags
|= LOOKUP_NO_NARROWING
;
3667 unsigned nart
= num_artificial_parms_for (get_first_fn (fns
)) - 1;
3668 tree init_list
= (*args
)[nart
];
3670 /* Always use the default constructor if the list is empty (DR 990). */
3671 if (CONSTRUCTOR_NELTS (init_list
) == 0
3672 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
3674 /* If the class has a list ctor, try passing the list as a single
3675 argument first, but only consider list ctors. */
3676 else if (TYPE_HAS_LIST_CTOR (totype
))
3678 flags
|= LOOKUP_LIST_ONLY
;
3679 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3680 explicit_targs
, template_only
, conversion_path
,
3681 access_path
, flags
, candidates
, complain
);
3682 if (any_strictly_viable (*candidates
))
3686 /* Expand the CONSTRUCTOR into a new argument vec. */
3687 vec
<tree
, va_gc
> *new_args
;
3688 vec_alloc (new_args
, nart
+ CONSTRUCTOR_NELTS (init_list
));
3689 for (unsigned i
= 0; i
< nart
; ++i
)
3690 new_args
->quick_push ((*args
)[i
]);
3691 for (unsigned i
= 0; i
< CONSTRUCTOR_NELTS (init_list
); ++i
)
3692 new_args
->quick_push (CONSTRUCTOR_ELT (init_list
, i
)->value
);
3694 /* We aren't looking for list-ctors anymore. */
3695 flags
&= ~LOOKUP_LIST_ONLY
;
3696 /* We allow more user-defined conversions within an init-list. */
3697 flags
&= ~LOOKUP_NO_CONVERSION
;
3699 add_candidates (fns
, first_arg
, new_args
, NULL_TREE
,
3700 explicit_targs
, template_only
, conversion_path
,
3701 access_path
, flags
, candidates
, complain
);
3704 /* Returns the best overload candidate to perform the requested
3705 conversion. This function is used for three the overloading situations
3706 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3707 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3708 per [dcl.init.ref], so we ignore temporary bindings. */
3710 static struct z_candidate
*
3711 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
3712 tsubst_flags_t complain
)
3714 struct z_candidate
*candidates
, *cand
;
3716 tree ctors
= NULL_TREE
;
3717 tree conv_fns
= NULL_TREE
;
3718 conversion
*conv
= NULL
;
3719 tree first_arg
= NULL_TREE
;
3720 vec
<tree
, va_gc
> *args
= NULL
;
3727 fromtype
= TREE_TYPE (expr
);
3729 /* We represent conversion within a hierarchy using RVALUE_CONV and
3730 BASE_CONV, as specified by [over.best.ics]; these become plain
3731 constructor calls, as specified in [dcl.init]. */
3732 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
3733 || !DERIVED_FROM_P (totype
, fromtype
));
3735 if (MAYBE_CLASS_TYPE_P (totype
))
3736 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3737 creating a garbage BASELINK; constructors can't be inherited. */
3738 ctors
= lookup_fnfields_slot (totype
, complete_ctor_identifier
);
3740 /* FIXME P0135 doesn't say what to do in C++17 about list-initialization from
3741 a single element. For now, let's handle constructors as before and also
3742 consider conversion operators from the element. */
3743 if (cxx_dialect
>= cxx1z
3744 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
3745 && CONSTRUCTOR_NELTS (expr
) == 1)
3746 fromtype
= TREE_TYPE (CONSTRUCTOR_ELT (expr
, 0)->value
);
3748 if (MAYBE_CLASS_TYPE_P (fromtype
))
3750 tree to_nonref
= non_reference (totype
);
3751 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
3752 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
3753 && DERIVED_FROM_P (to_nonref
, fromtype
)))
3755 /* [class.conv.fct] A conversion function is never used to
3756 convert a (possibly cv-qualified) object to the (possibly
3757 cv-qualified) same object type (or a reference to it), to a
3758 (possibly cv-qualified) base class of that type (or a
3759 reference to it)... */
3762 conv_fns
= lookup_conversions (fromtype
);
3766 flags
|= LOOKUP_NO_CONVERSION
;
3767 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3768 flags
|= LOOKUP_NO_NARROWING
;
3770 /* It's OK to bind a temporary for converting constructor arguments, but
3771 not in converting the return value of a conversion operator. */
3772 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
3773 | (flags
& LOOKUP_NO_NARROWING
));
3774 flags
&= ~LOOKUP_NO_TEMP_BIND
;
3778 int ctorflags
= flags
;
3780 first_arg
= build_dummy_object (totype
);
3782 /* We should never try to call the abstract or base constructor
3784 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
3785 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
3787 args
= make_tree_vector_single (expr
);
3788 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3790 /* List-initialization. */
3791 add_list_candidates (ctors
, first_arg
, args
, totype
, NULL_TREE
,
3792 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3793 ctorflags
, &candidates
, complain
);
3797 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
3798 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3799 ctorflags
, &candidates
, complain
);
3802 for (cand
= candidates
; cand
; cand
= cand
->next
)
3804 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
3806 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3807 set, then this is copy-initialization. In that case, "The
3808 result of the call is then used to direct-initialize the
3809 object that is the destination of the copy-initialization."
3812 We represent this in the conversion sequence with an
3813 rvalue conversion, which means a constructor call. */
3814 if (TREE_CODE (totype
) != REFERENCE_TYPE
3815 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3817 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
3823 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3824 /* FIXME see above about C++17. */
3825 first_arg
= CONSTRUCTOR_ELT (expr
, 0)->value
;
3830 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
3832 tree conversion_path
= TREE_PURPOSE (conv_fns
);
3833 struct z_candidate
*old_candidates
;
3835 /* If we are called to convert to a reference type, we are trying to
3836 find a direct binding, so don't even consider temporaries. If
3837 we don't find a direct binding, the caller will try again to
3838 look for a temporary binding. */
3839 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
3840 convflags
|= LOOKUP_NO_TEMP_BIND
;
3842 old_candidates
= candidates
;
3843 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
3845 conversion_path
, TYPE_BINFO (fromtype
),
3846 flags
, &candidates
, complain
);
3848 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
3850 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
3852 = implicit_conversion (totype
,
3855 /*c_cast_p=*/false, convflags
,
3858 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3859 copy-initialization. In that case, "The result of the
3860 call is then used to direct-initialize the object that is
3861 the destination of the copy-initialization." [dcl.init]
3863 We represent this in the conversion sequence with an
3864 rvalue conversion, which means a constructor call. But
3865 don't add a second rvalue conversion if there's already
3866 one there. Which there really shouldn't be, but it's
3867 harmless since we'd add it here anyway. */
3868 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
3869 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3870 ics
= build_conv (ck_rvalue
, totype
, ics
);
3872 cand
->second_conv
= ics
;
3877 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -2,
3880 else if (DECL_NONCONVERTING_P (cand
->fn
)
3881 && ics
->rank
> cr_exact
)
3883 /* 13.3.1.5: For direct-initialization, those explicit
3884 conversion functions that are not hidden within S and
3885 yield type T or a type that can be converted to type T
3886 with a qualification conversion (4.4) are also candidate
3888 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3889 I've raised this issue with the committee. --jason 9/2011 */
3891 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
3893 else if (cand
->viable
== 1 && ics
->bad_p
)
3897 = bad_arg_conversion_rejection (NULL_TREE
, -2,
3900 else if (primary_template_instantiation_p (cand
->fn
)
3901 && ics
->rank
> cr_exact
)
3903 /* 13.3.3.1.2: If the user-defined conversion is specified by
3904 a specialization of a conversion function template, the
3905 second standard conversion sequence shall have exact match
3908 cand
->reason
= template_conversion_rejection (rettype
, totype
);
3913 candidates
= splice_viable (candidates
, false, &any_viable_p
);
3917 release_tree_vector (args
);
3921 cand
= tourney (candidates
, complain
);
3924 if (complain
& tf_error
)
3926 error ("conversion from %qT to %qT is ambiguous",
3928 print_z_candidates (location_of (expr
), candidates
);
3931 cand
= candidates
; /* any one will do */
3932 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
3933 cand
->second_conv
->user_conv_p
= true;
3934 if (!any_strictly_viable (candidates
))
3935 cand
->second_conv
->bad_p
= true;
3936 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3937 ambiguous conversion is no worse than another user-defined
3944 if (!DECL_CONSTRUCTOR_P (cand
->fn
))
3945 convtype
= non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)));
3946 else if (cand
->second_conv
->kind
== ck_rvalue
)
3947 /* DR 5: [in the first step of copy-initialization]...if the function
3948 is a constructor, the call initializes a temporary of the
3949 cv-unqualified version of the destination type. */
3950 convtype
= cv_unqualified (totype
);
3953 /* Build the user conversion sequence. */
3957 build_identity_conv (TREE_TYPE (expr
), expr
));
3959 if (cand
->viable
== -1)
3962 /* Remember that this was a list-initialization. */
3963 if (flags
& LOOKUP_NO_NARROWING
)
3964 conv
->check_narrowing
= true;
3966 /* Combine it with the second conversion sequence. */
3967 cand
->second_conv
= merge_conversion_sequences (conv
,
3973 /* Wrapper for above. */
3976 build_user_type_conversion (tree totype
, tree expr
, int flags
,
3977 tsubst_flags_t complain
)
3979 struct z_candidate
*cand
;
3982 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3983 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
3987 if (cand
->second_conv
->kind
== ck_ambig
)
3988 ret
= error_mark_node
;
3991 expr
= convert_like (cand
->second_conv
, expr
, complain
);
3992 ret
= convert_from_reference (expr
);
3998 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4002 /* Subroutine of convert_nontype_argument.
4004 EXPR is an argument for a template non-type parameter of integral or
4005 enumeration type. Do any necessary conversions (that are permitted for
4006 non-type arguments) to convert it to the parameter type.
4008 If conversion is successful, returns the converted expression;
4009 otherwise, returns error_mark_node. */
4012 build_integral_nontype_arg_conv (tree type
, tree expr
, tsubst_flags_t complain
)
4017 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
4019 if (error_operand_p (expr
))
4020 return error_mark_node
;
4022 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
4024 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4025 p
= conversion_obstack_alloc (0);
4027 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
4029 LOOKUP_IMPLICIT
, complain
);
4031 /* for a non-type template-parameter of integral or
4032 enumeration type, integral promotions (4.5) and integral
4033 conversions (4.7) are applied. */
4034 /* It should be sufficient to check the outermost conversion step, since
4035 there are no qualification conversions to integer type. */
4039 /* A conversion function is OK. If it isn't constexpr, we'll
4040 complain later that the argument isn't constant. */
4042 /* The lvalue-to-rvalue conversion is OK. */
4048 t
= next_conversion (conv
)->type
;
4049 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
4052 if (complain
& tf_error
)
4053 error_at (loc
, "conversion from %qT to %qT not considered for "
4054 "non-type template argument", t
, type
);
4063 expr
= convert_like (conv
, expr
, complain
);
4065 expr
= error_mark_node
;
4067 /* Free all the conversions we allocated. */
4068 obstack_free (&conversion_obstack
, p
);
4073 /* Do any initial processing on the arguments to a function call. */
4075 static vec
<tree
, va_gc
> *
4076 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
4081 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
4083 if (error_operand_p (arg
))
4085 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
4087 if (complain
& tf_error
)
4088 error ("invalid use of void expression");
4091 else if (invalid_nonstatic_memfn_p (input_location
, arg
, complain
))
4097 /* Perform overload resolution on FN, which is called with the ARGS.
4099 Return the candidate function selected by overload resolution, or
4100 NULL if the event that overload resolution failed. In the case
4101 that overload resolution fails, *CANDIDATES will be the set of
4102 candidates considered, and ANY_VIABLE_P will be set to true or
4103 false to indicate whether or not any of the candidates were
4106 The ARGS should already have gone through RESOLVE_ARGS before this
4107 function is called. */
4109 static struct z_candidate
*
4110 perform_overload_resolution (tree fn
,
4111 const vec
<tree
, va_gc
> *args
,
4112 struct z_candidate
**candidates
,
4113 bool *any_viable_p
, tsubst_flags_t complain
)
4115 struct z_candidate
*cand
;
4116 tree explicit_targs
;
4119 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4121 explicit_targs
= NULL_TREE
;
4125 *any_viable_p
= true;
4128 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
4129 || TREE_CODE (fn
) == TEMPLATE_DECL
4130 || TREE_CODE (fn
) == OVERLOAD
4131 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
4133 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4135 explicit_targs
= TREE_OPERAND (fn
, 1);
4136 fn
= TREE_OPERAND (fn
, 0);
4140 /* Add the various candidate functions. */
4141 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
4142 explicit_targs
, template_only
,
4143 /*conversion_path=*/NULL_TREE
,
4144 /*access_path=*/NULL_TREE
,
4146 candidates
, complain
);
4148 *candidates
= splice_viable (*candidates
, false, any_viable_p
);
4150 cand
= tourney (*candidates
, complain
);
4154 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4158 /* Print an error message about being unable to build a call to FN with
4159 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
4160 be located; CANDIDATES is a possibly empty list of such
4164 print_error_for_call_failure (tree fn
, vec
<tree
, va_gc
> *args
,
4165 struct z_candidate
*candidates
)
4167 tree targs
= NULL_TREE
;
4168 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4170 targs
= TREE_OPERAND (fn
, 1);
4171 fn
= TREE_OPERAND (fn
, 0);
4173 tree name
= DECL_NAME (OVL_CURRENT (fn
));
4174 location_t loc
= location_of (name
);
4176 name
= lookup_template_function (name
, targs
);
4178 if (!any_strictly_viable (candidates
))
4179 error_at (loc
, "no matching function for call to %<%D(%A)%>",
4180 name
, build_tree_list_vec (args
));
4182 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
4183 name
, build_tree_list_vec (args
));
4185 print_z_candidates (loc
, candidates
);
4188 /* Return an expression for a call to FN (a namespace-scope function,
4189 or a static member function) with the ARGS. This may change
4193 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
, bool koenig_p
,
4194 tsubst_flags_t complain
)
4196 struct z_candidate
*candidates
, *cand
;
4201 if (args
!= NULL
&& *args
!= NULL
)
4203 *args
= resolve_args (*args
, complain
);
4205 return error_mark_node
;
4209 tm_malloc_replacement (fn
);
4211 /* If this function was found without using argument dependent
4212 lookup, then we want to ignore any undeclared friend
4218 fn
= remove_hidden_names (fn
);
4221 if (complain
& tf_error
)
4222 print_error_for_call_failure (orig_fn
, *args
, NULL
);
4223 return error_mark_node
;
4227 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4228 p
= conversion_obstack_alloc (0);
4230 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
4235 if (complain
& tf_error
)
4237 // If there is a single (non-viable) function candidate,
4238 // let the error be diagnosed by cp_build_function_call_vec.
4239 if (!any_viable_p
&& candidates
&& ! candidates
->next
4240 && (TREE_CODE (candidates
->fn
) == FUNCTION_DECL
))
4241 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
4243 // Otherwise, emit notes for non-viable candidates.
4244 print_error_for_call_failure (fn
, *args
, candidates
);
4246 result
= error_mark_node
;
4250 int flags
= LOOKUP_NORMAL
;
4251 /* If fn is template_id_expr, the call has explicit template arguments
4252 (e.g. func<int>(5)), communicate this info to build_over_call
4253 through flags so that later we can use it to decide whether to warn
4254 about peculiar null pointer conversion. */
4255 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4257 /* If overload resolution selects a specialization of a
4258 function concept for non-dependent template arguments,
4259 the expression is true if the constraints are satisfied
4260 and false otherwise.
4262 NOTE: This is an extension of Concepts Lite TS that
4263 allows constraints to be used in expressions. */
4264 if (flag_concepts
&& !processing_template_decl
)
4266 tree tmpl
= DECL_TI_TEMPLATE (cand
->fn
);
4267 tree targs
= DECL_TI_ARGS (cand
->fn
);
4268 tree decl
= DECL_TEMPLATE_RESULT (tmpl
);
4269 if (DECL_DECLARED_CONCEPT_P (decl
))
4270 return evaluate_function_concept (decl
, targs
);
4273 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
4276 result
= build_over_call (cand
, flags
, complain
);
4279 /* Free all the conversions we allocated. */
4280 obstack_free (&conversion_obstack
, p
);
4285 /* Build a call to a global operator new. FNNAME is the name of the
4286 operator (either "operator new" or "operator new[]") and ARGS are
4287 the arguments provided. This may change ARGS. *SIZE points to the
4288 total number of bytes required by the allocation, and is updated if
4289 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
4290 be used. If this function determines that no cookie should be
4291 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
4292 is not NULL_TREE, it is evaluated before calculating the final
4293 array size, and if it fails, the array size is replaced with
4294 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
4295 is non-NULL, it will be set, upon return, to the allocation
4299 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
4300 tree
*size
, tree
*cookie_size
,
4301 tree align_arg
, tree size_check
,
4302 tree
*fn
, tsubst_flags_t complain
)
4304 tree original_size
= *size
;
4306 struct z_candidate
*candidates
;
4307 struct z_candidate
*cand
= NULL
;
4312 /* Set to (size_t)-1 if the size check fails. */
4313 if (size_check
!= NULL_TREE
)
4315 tree errval
= TYPE_MAX_VALUE (sizetype
);
4316 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
4317 errval
= throw_bad_array_new_length ();
4318 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4319 original_size
, errval
);
4321 vec_safe_insert (*args
, 0, *size
);
4322 *args
= resolve_args (*args
, complain
);
4324 return error_mark_node
;
4330 If this lookup fails to find the name, or if the allocated type
4331 is not a class type, the allocation function's name is looked
4332 up in the global scope.
4334 we disregard block-scope declarations of "operator new". */
4335 fns
= lookup_function_nonclass (fnname
, *args
, /*block_p=*/false);
4339 vec
<tree
, va_gc
>* align_args
4340 = vec_copy_and_insert (*args
, align_arg
, 1);
4341 cand
= perform_overload_resolution (fns
, align_args
, &candidates
,
4342 &any_viable_p
, tf_none
);
4343 /* If no aligned allocation function matches, try again without the
4347 /* Figure out what function is being called. */
4349 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
4352 /* If no suitable function could be found, issue an error message
4356 if (complain
& tf_error
)
4357 print_error_for_call_failure (fns
, *args
, candidates
);
4358 return error_mark_node
;
4361 /* If a cookie is required, add some extra space. Whether
4362 or not a cookie is required cannot be determined until
4363 after we know which function was called. */
4366 bool use_cookie
= true;
4369 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
4370 /* Skip the size_t parameter. */
4371 arg_types
= TREE_CHAIN (arg_types
);
4372 /* Check the remaining parameters (if any). */
4374 && TREE_CHAIN (arg_types
) == void_list_node
4375 && same_type_p (TREE_VALUE (arg_types
),
4378 /* If we need a cookie, adjust the number of bytes allocated. */
4381 /* Update the total size. */
4382 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
4385 /* Set to (size_t)-1 if the size check fails. */
4386 gcc_assert (size_check
!= NULL_TREE
);
4387 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4388 *size
, TYPE_MAX_VALUE (sizetype
));
4390 /* Update the argument list to reflect the adjusted size. */
4391 (**args
)[0] = *size
;
4394 *cookie_size
= NULL_TREE
;
4397 /* Tell our caller which function we decided to call. */
4401 /* Build the CALL_EXPR. */
4402 return build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4405 /* Build a new call to operator(). This may change ARGS. */
4408 build_op_call_1 (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4410 struct z_candidate
*candidates
= 0, *cand
;
4411 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
4412 tree type
= TREE_TYPE (obj
);
4414 tree result
= NULL_TREE
;
4417 if (error_operand_p (obj
))
4418 return error_mark_node
;
4420 obj
= prep_operand (obj
);
4422 if (TYPE_PTRMEMFUNC_P (type
))
4424 if (complain
& tf_error
)
4425 /* It's no good looking for an overloaded operator() on a
4426 pointer-to-member-function. */
4427 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
4428 return error_mark_node
;
4431 if (TYPE_BINFO (type
))
4433 fns
= lookup_fnfields (TYPE_BINFO (type
), cp_operator_id (CALL_EXPR
), 1);
4434 if (fns
== error_mark_node
)
4435 return error_mark_node
;
4440 if (args
!= NULL
&& *args
!= NULL
)
4442 *args
= resolve_args (*args
, complain
);
4444 return error_mark_node
;
4447 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4448 p
= conversion_obstack_alloc (0);
4452 first_mem_arg
= obj
;
4454 add_candidates (BASELINK_FUNCTIONS (fns
),
4455 first_mem_arg
, *args
, NULL_TREE
,
4457 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
4458 LOOKUP_NORMAL
, &candidates
, complain
);
4461 convs
= lookup_conversions (type
);
4463 for (; convs
; convs
= TREE_CHAIN (convs
))
4465 tree fns
= TREE_VALUE (convs
);
4466 tree totype
= TREE_TYPE (convs
);
4468 if (TYPE_PTRFN_P (totype
)
4469 || TYPE_REFFN_P (totype
)
4470 || (TREE_CODE (totype
) == REFERENCE_TYPE
4471 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
4472 for (; fns
; fns
= OVL_NEXT (fns
))
4474 tree fn
= OVL_CURRENT (fns
);
4476 if (DECL_NONCONVERTING_P (fn
))
4479 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4480 add_template_conv_candidate
4481 (&candidates
, fn
, obj
, *args
, totype
,
4482 /*access_path=*/NULL_TREE
,
4483 /*conversion_path=*/NULL_TREE
, complain
);
4485 add_conv_candidate (&candidates
, fn
, obj
,
4486 *args
, /*conversion_path=*/NULL_TREE
,
4487 /*access_path=*/NULL_TREE
, complain
);
4491 /* Be strict here because if we choose a bad conversion candidate, the
4492 errors we get won't mention the call context. */
4493 candidates
= splice_viable (candidates
, true, &any_viable_p
);
4496 if (complain
& tf_error
)
4498 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
4499 build_tree_list_vec (*args
));
4500 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4502 result
= error_mark_node
;
4506 cand
= tourney (candidates
, complain
);
4509 if (complain
& tf_error
)
4511 error ("call of %<(%T) (%A)%> is ambiguous",
4512 TREE_TYPE (obj
), build_tree_list_vec (*args
));
4513 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4515 result
= error_mark_node
;
4517 /* Since cand->fn will be a type, not a function, for a conversion
4518 function, we must be careful not to unconditionally look at
4520 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
4521 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
4522 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4525 if (DECL_P (cand
->fn
))
4526 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
,
4529 obj
= convert_like (cand
->convs
[0], obj
, complain
);
4530 obj
= convert_from_reference (obj
);
4531 result
= cp_build_function_call_vec (obj
, args
, complain
);
4535 /* Free all the conversions we allocated. */
4536 obstack_free (&conversion_obstack
, p
);
4541 /* Wrapper for above. */
4544 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4547 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4548 ret
= build_op_call_1 (obj
, args
, complain
);
4549 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4553 /* Called by op_error to prepare format strings suitable for the error
4554 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4555 and a suffix (controlled by NTYPES). */
4558 op_error_string (const char *errmsg
, int ntypes
, bool match
)
4562 const char *msgp
= concat (match
? G_("ambiguous overload for ")
4563 : G_("no match for "), errmsg
, NULL
);
4566 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
4567 else if (ntypes
== 2)
4568 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
4570 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
4576 op_error (location_t loc
, enum tree_code code
, enum tree_code code2
,
4577 tree arg1
, tree arg2
, tree arg3
, bool match
)
4581 if (code
== MODIFY_EXPR
)
4582 opname
= assignment_operator_name_info
[code2
].name
;
4584 opname
= operator_name_info
[code
].name
;
4589 if (flag_diagnostics_show_caret
)
4590 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
4592 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4594 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
4595 "in %<%E ? %E : %E%>"), 3, match
),
4597 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4600 case POSTINCREMENT_EXPR
:
4601 case POSTDECREMENT_EXPR
:
4602 if (flag_diagnostics_show_caret
)
4603 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4604 opname
, TREE_TYPE (arg1
));
4606 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4608 opname
, arg1
, opname
, TREE_TYPE (arg1
));
4612 if (flag_diagnostics_show_caret
)
4613 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
4614 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4616 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4618 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4623 if (flag_diagnostics_show_caret
)
4624 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
4625 opname
, TREE_TYPE (arg1
));
4627 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
4628 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4633 if (flag_diagnostics_show_caret
)
4634 error_at (loc
, op_error_string (G_("%<operator%s%>"), 2, match
),
4635 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4637 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4639 opname
, arg1
, opname
, arg2
,
4640 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4642 if (flag_diagnostics_show_caret
)
4643 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4644 opname
, TREE_TYPE (arg1
));
4646 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4648 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4653 /* Return the implicit conversion sequence that could be used to
4654 convert E1 to E2 in [expr.cond]. */
4657 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
4659 tree t1
= non_reference (TREE_TYPE (e1
));
4660 tree t2
= non_reference (TREE_TYPE (e2
));
4666 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4667 implicitly converted (clause _conv_) to the type "lvalue reference to
4668 T2", subject to the constraint that in the conversion the
4669 reference must bind directly (_dcl.init.ref_) to an lvalue.
4671 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
4672 implicitly converted to the type "rvalue reference to T2", subject to
4673 the constraint that the reference must bind directly. */
4676 tree rtype
= cp_build_reference_type (t2
, !lvalue_p (e2
));
4677 conv
= implicit_conversion (rtype
,
4681 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
4682 |LOOKUP_ONLYCONVERTING
,
4684 if (conv
&& !conv
->bad_p
)
4688 /* If E2 is a prvalue or if neither of the conversions above can be done
4689 and at least one of the operands has (possibly cv-qualified) class
4691 if (!CLASS_TYPE_P (t1
) && !CLASS_TYPE_P (t2
))
4696 If E1 and E2 have class type, and the underlying class types are
4697 the same or one is a base class of the other: E1 can be converted
4698 to match E2 if the class of T2 is the same type as, or a base
4699 class of, the class of T1, and the cv-qualification of T2 is the
4700 same cv-qualification as, or a greater cv-qualification than, the
4701 cv-qualification of T1. If the conversion is applied, E1 is
4702 changed to an rvalue of type T2 that still refers to the original
4703 source class object (or the appropriate subobject thereof). */
4704 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
4705 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
4707 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
4709 conv
= build_identity_conv (t1
, e1
);
4710 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
4711 TYPE_MAIN_VARIANT (t2
)))
4712 conv
= build_conv (ck_base
, t2
, conv
);
4714 conv
= build_conv (ck_rvalue
, t2
, conv
);
4723 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4724 converted to the type that expression E2 would have if E2 were
4725 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4726 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
4727 LOOKUP_IMPLICIT
, complain
);
4730 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4731 arguments to the conditional expression. */
4734 build_conditional_expr_1 (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
4735 tsubst_flags_t complain
)
4739 tree result
= NULL_TREE
;
4740 tree result_type
= NULL_TREE
;
4741 bool is_lvalue
= true;
4742 struct z_candidate
*candidates
= 0;
4743 struct z_candidate
*cand
;
4745 tree orig_arg2
, orig_arg3
;
4747 /* As a G++ extension, the second argument to the conditional can be
4748 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4749 c'.) If the second operand is omitted, make sure it is
4750 calculated only once. */
4753 if (complain
& tf_error
)
4754 pedwarn (loc
, OPT_Wpedantic
,
4755 "ISO C++ forbids omitting the middle term of a ?: expression");
4757 if ((complain
& tf_warning
) && !truth_value_p (TREE_CODE (arg1
)))
4758 warn_for_omitted_condop (loc
, arg1
);
4760 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4761 if (lvalue_p (arg1
))
4762 arg2
= arg1
= cp_stabilize_reference (arg1
);
4764 arg2
= arg1
= save_expr (arg1
);
4767 /* If something has already gone wrong, just pass that fact up the
4769 if (error_operand_p (arg1
)
4770 || error_operand_p (arg2
)
4771 || error_operand_p (arg3
))
4772 return error_mark_node
;
4777 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
4779 tree arg1_type
= TREE_TYPE (arg1
);
4781 /* If arg1 is another cond_expr choosing between -1 and 0,
4782 then we can use its comparison. It may help to avoid
4783 additional comparison, produce more accurate diagnostics
4784 and enables folding. */
4785 if (TREE_CODE (arg1
) == VEC_COND_EXPR
4786 && integer_minus_onep (TREE_OPERAND (arg1
, 1))
4787 && integer_zerop (TREE_OPERAND (arg1
, 2)))
4788 arg1
= TREE_OPERAND (arg1
, 0);
4790 arg1
= force_rvalue (arg1
, complain
);
4791 arg2
= force_rvalue (arg2
, complain
);
4792 arg3
= force_rvalue (arg3
, complain
);
4794 /* force_rvalue can return error_mark on valid arguments. */
4795 if (error_operand_p (arg1
)
4796 || error_operand_p (arg2
)
4797 || error_operand_p (arg3
))
4798 return error_mark_node
;
4800 arg2_type
= TREE_TYPE (arg2
);
4801 arg3_type
= TREE_TYPE (arg3
);
4803 if (!VECTOR_TYPE_P (arg2_type
)
4804 && !VECTOR_TYPE_P (arg3_type
))
4806 /* Rely on the error messages of the scalar version. */
4807 tree scal
= build_conditional_expr_1 (loc
, integer_one_node
,
4808 orig_arg2
, orig_arg3
, complain
);
4809 if (scal
== error_mark_node
)
4810 return error_mark_node
;
4811 tree stype
= TREE_TYPE (scal
);
4812 tree ctype
= TREE_TYPE (arg1_type
);
4813 if (TYPE_SIZE (stype
) != TYPE_SIZE (ctype
)
4814 || (!INTEGRAL_TYPE_P (stype
) && !SCALAR_FLOAT_TYPE_P (stype
)))
4816 if (complain
& tf_error
)
4817 error_at (loc
, "inferred scalar type %qT is not an integer or "
4818 "floating point type of the same size as %qT", stype
,
4819 COMPARISON_CLASS_P (arg1
)
4820 ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
4822 return error_mark_node
;
4825 tree vtype
= build_opaque_vector_type (stype
,
4826 TYPE_VECTOR_SUBPARTS (arg1_type
));
4827 /* We could pass complain & tf_warning to unsafe_conversion_p,
4828 but the warnings (like Wsign-conversion) have already been
4829 given by the scalar build_conditional_expr_1. We still check
4830 unsafe_conversion_p to forbid truncating long long -> float. */
4831 if (unsafe_conversion_p (loc
, stype
, arg2
, false))
4833 if (complain
& tf_error
)
4834 error_at (loc
, "conversion of scalar %qT to vector %qT "
4835 "involves truncation", arg2_type
, vtype
);
4836 return error_mark_node
;
4838 if (unsafe_conversion_p (loc
, stype
, arg3
, false))
4840 if (complain
& tf_error
)
4841 error_at (loc
, "conversion of scalar %qT to vector %qT "
4842 "involves truncation", arg3_type
, vtype
);
4843 return error_mark_node
;
4846 arg2
= cp_convert (stype
, arg2
, complain
);
4847 arg2
= save_expr (arg2
);
4848 arg2
= build_vector_from_val (vtype
, arg2
);
4850 arg3
= cp_convert (stype
, arg3
, complain
);
4851 arg3
= save_expr (arg3
);
4852 arg3
= build_vector_from_val (vtype
, arg3
);
4856 if (VECTOR_TYPE_P (arg2_type
) != VECTOR_TYPE_P (arg3_type
))
4858 enum stv_conv convert_flag
=
4859 scalar_to_vector (loc
, VEC_COND_EXPR
, arg2
, arg3
,
4860 complain
& tf_error
);
4862 switch (convert_flag
)
4865 return error_mark_node
;
4868 arg2
= save_expr (arg2
);
4869 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
4870 arg2
= build_vector_from_val (arg3_type
, arg2
);
4871 arg2_type
= TREE_TYPE (arg2
);
4876 arg3
= save_expr (arg3
);
4877 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
4878 arg3
= build_vector_from_val (arg2_type
, arg3
);
4879 arg3_type
= TREE_TYPE (arg3
);
4887 if (!same_type_p (arg2_type
, arg3_type
)
4888 || TYPE_VECTOR_SUBPARTS (arg1_type
)
4889 != TYPE_VECTOR_SUBPARTS (arg2_type
)
4890 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
4892 if (complain
& tf_error
)
4894 "incompatible vector types in conditional expression: "
4895 "%qT, %qT and %qT", TREE_TYPE (arg1
),
4896 TREE_TYPE (orig_arg2
), TREE_TYPE (orig_arg3
));
4897 return error_mark_node
;
4900 if (!COMPARISON_CLASS_P (arg1
))
4902 tree cmp_type
= build_same_sized_truth_vector_type (arg1_type
);
4903 arg1
= build2 (NE_EXPR
, cmp_type
, arg1
, build_zero_cst (arg1_type
));
4905 return build3_loc (loc
, VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
4910 The first expression is implicitly converted to bool (clause
4912 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
4914 if (error_operand_p (arg1
))
4915 return error_mark_node
;
4919 If either the second or the third operand has type (possibly
4920 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4921 array-to-pointer (_conv.array_), and function-to-pointer
4922 (_conv.func_) standard conversions are performed on the second
4923 and third operands. */
4924 arg2_type
= unlowered_expr_type (arg2
);
4925 arg3_type
= unlowered_expr_type (arg3
);
4926 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
4928 /* Do the conversions. We don't these for `void' type arguments
4929 since it can't have any effect and since decay_conversion
4930 does not handle that case gracefully. */
4931 if (!VOID_TYPE_P (arg2_type
))
4932 arg2
= decay_conversion (arg2
, complain
);
4933 if (!VOID_TYPE_P (arg3_type
))
4934 arg3
= decay_conversion (arg3
, complain
);
4935 arg2_type
= TREE_TYPE (arg2
);
4936 arg3_type
= TREE_TYPE (arg3
);
4940 One of the following shall hold:
4942 --The second or the third operand (but not both) is a
4943 throw-expression (_except.throw_); the result is of the
4944 type of the other and is an rvalue.
4946 --Both the second and the third operands have type void; the
4947 result is of type void and is an rvalue.
4949 We must avoid calling force_rvalue for expressions of type
4950 "void" because it will complain that their value is being
4952 if (TREE_CODE (arg2
) == THROW_EXPR
4953 && TREE_CODE (arg3
) != THROW_EXPR
)
4955 if (!VOID_TYPE_P (arg3_type
))
4957 arg3
= force_rvalue (arg3
, complain
);
4958 if (arg3
== error_mark_node
)
4959 return error_mark_node
;
4961 arg3_type
= TREE_TYPE (arg3
);
4962 result_type
= arg3_type
;
4964 else if (TREE_CODE (arg2
) != THROW_EXPR
4965 && TREE_CODE (arg3
) == THROW_EXPR
)
4967 if (!VOID_TYPE_P (arg2_type
))
4969 arg2
= force_rvalue (arg2
, complain
);
4970 if (arg2
== error_mark_node
)
4971 return error_mark_node
;
4973 arg2_type
= TREE_TYPE (arg2
);
4974 result_type
= arg2_type
;
4976 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
4977 result_type
= void_type_node
;
4980 if (complain
& tf_error
)
4982 if (VOID_TYPE_P (arg2_type
))
4983 error_at (EXPR_LOC_OR_LOC (arg3
, loc
),
4984 "second operand to the conditional operator "
4985 "is of type %<void%>, but the third operand is "
4986 "neither a throw-expression nor of type %<void%>");
4988 error_at (EXPR_LOC_OR_LOC (arg2
, loc
),
4989 "third operand to the conditional operator "
4990 "is of type %<void%>, but the second operand is "
4991 "neither a throw-expression nor of type %<void%>");
4993 return error_mark_node
;
4997 goto valid_operands
;
5001 Otherwise, if the second and third operand have different types,
5002 and either has (possibly cv-qualified) class type, or if both are
5003 glvalues of the same value category and the same type except for
5004 cv-qualification, an attempt is made to convert each of those operands
5005 to the type of the other. */
5006 else if (!same_type_p (arg2_type
, arg3_type
)
5007 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)
5008 || (same_type_ignoring_top_level_qualifiers_p (arg2_type
,
5010 && glvalue_p (arg2
) && glvalue_p (arg3
)
5011 && lvalue_p (arg2
) == lvalue_p (arg3
))))
5015 bool converted
= false;
5017 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5018 p
= conversion_obstack_alloc (0);
5020 conv2
= conditional_conversion (arg2
, arg3
, complain
);
5021 conv3
= conditional_conversion (arg3
, arg2
, complain
);
5025 If both can be converted, or one can be converted but the
5026 conversion is ambiguous, the program is ill-formed. If
5027 neither can be converted, the operands are left unchanged and
5028 further checking is performed as described below. If exactly
5029 one conversion is possible, that conversion is applied to the
5030 chosen operand and the converted operand is used in place of
5031 the original operand for the remainder of this section. */
5032 if ((conv2
&& !conv2
->bad_p
5033 && conv3
&& !conv3
->bad_p
)
5034 || (conv2
&& conv2
->kind
== ck_ambig
)
5035 || (conv3
&& conv3
->kind
== ck_ambig
))
5037 if (complain
& tf_error
)
5039 error_at (loc
, "operands to ?: have different types %qT and %qT",
5040 arg2_type
, arg3_type
);
5041 if (conv2
&& !conv2
->bad_p
&& conv3
&& !conv3
->bad_p
)
5042 inform (loc
, " and each type can be converted to the other");
5043 else if (conv2
&& conv2
->kind
== ck_ambig
)
5044 convert_like (conv2
, arg2
, complain
);
5046 convert_like (conv3
, arg3
, complain
);
5048 result
= error_mark_node
;
5050 else if (conv2
&& !conv2
->bad_p
)
5052 arg2
= convert_like (conv2
, arg2
, complain
);
5053 arg2
= convert_from_reference (arg2
);
5054 arg2_type
= TREE_TYPE (arg2
);
5055 /* Even if CONV2 is a valid conversion, the result of the
5056 conversion may be invalid. For example, if ARG3 has type
5057 "volatile X", and X does not have a copy constructor
5058 accepting a "volatile X&", then even if ARG2 can be
5059 converted to X, the conversion will fail. */
5060 if (error_operand_p (arg2
))
5061 result
= error_mark_node
;
5064 else if (conv3
&& !conv3
->bad_p
)
5066 arg3
= convert_like (conv3
, arg3
, complain
);
5067 arg3
= convert_from_reference (arg3
);
5068 arg3_type
= TREE_TYPE (arg3
);
5069 if (error_operand_p (arg3
))
5070 result
= error_mark_node
;
5074 /* Free all the conversions we allocated. */
5075 obstack_free (&conversion_obstack
, p
);
5080 /* If, after the conversion, both operands have class type,
5081 treat the cv-qualification of both operands as if it were the
5082 union of the cv-qualification of the operands.
5084 The standard is not clear about what to do in this
5085 circumstance. For example, if the first operand has type
5086 "const X" and the second operand has a user-defined
5087 conversion to "volatile X", what is the type of the second
5088 operand after this step? Making it be "const X" (matching
5089 the first operand) seems wrong, as that discards the
5090 qualification without actually performing a copy. Leaving it
5091 as "volatile X" seems wrong as that will result in the
5092 conditional expression failing altogether, even though,
5093 according to this step, the one operand could be converted to
5094 the type of the other. */
5096 && CLASS_TYPE_P (arg2_type
)
5097 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
5098 arg2_type
= arg3_type
=
5099 cp_build_qualified_type (arg2_type
,
5100 cp_type_quals (arg2_type
)
5101 | cp_type_quals (arg3_type
));
5106 If the second and third operands are glvalues of the same value
5107 category and have the same type, the result is of that type and
5109 if (((lvalue_p (arg2
) && lvalue_p (arg3
))
5110 || (xvalue_p (arg2
) && xvalue_p (arg3
)))
5111 && same_type_p (arg2_type
, arg3_type
))
5113 result_type
= arg2_type
;
5114 arg2
= mark_lvalue_use (arg2
);
5115 arg3
= mark_lvalue_use (arg3
);
5116 goto valid_operands
;
5121 Otherwise, the result is an rvalue. If the second and third
5122 operand do not have the same type, and either has (possibly
5123 cv-qualified) class type, overload resolution is used to
5124 determine the conversions (if any) to be applied to the operands
5125 (_over.match.oper_, _over.built_). */
5127 if (!same_type_p (arg2_type
, arg3_type
)
5128 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
5134 /* Rearrange the arguments so that add_builtin_candidate only has
5135 to know about two args. In build_builtin_candidate, the
5136 arguments are unscrambled. */
5140 add_builtin_candidates (&candidates
,
5143 cp_operator_id (COND_EXPR
),
5145 LOOKUP_NORMAL
, complain
);
5149 If the overload resolution fails, the program is
5151 candidates
= splice_viable (candidates
, false, &any_viable_p
);
5154 if (complain
& tf_error
)
5155 error_at (loc
, "operands to ?: have different types %qT and %qT",
5156 arg2_type
, arg3_type
);
5157 return error_mark_node
;
5159 cand
= tourney (candidates
, complain
);
5162 if (complain
& tf_error
)
5164 op_error (loc
, COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, FALSE
);
5165 print_z_candidates (loc
, candidates
);
5167 return error_mark_node
;
5172 Otherwise, the conversions thus determined are applied, and
5173 the converted operands are used in place of the original
5174 operands for the remainder of this section. */
5175 conv
= cand
->convs
[0];
5176 arg1
= convert_like (conv
, arg1
, complain
);
5177 conv
= cand
->convs
[1];
5178 arg2
= convert_like (conv
, arg2
, complain
);
5179 arg2_type
= TREE_TYPE (arg2
);
5180 conv
= cand
->convs
[2];
5181 arg3
= convert_like (conv
, arg3
, complain
);
5182 arg3_type
= TREE_TYPE (arg3
);
5187 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
5188 and function-to-pointer (_conv.func_) standard conversions are
5189 performed on the second and third operands.
5191 We need to force the lvalue-to-rvalue conversion here for class types,
5192 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
5193 that isn't wrapped with a TARGET_EXPR plays havoc with exception
5196 arg2
= force_rvalue (arg2
, complain
);
5197 if (!CLASS_TYPE_P (arg2_type
))
5198 arg2_type
= TREE_TYPE (arg2
);
5200 arg3
= force_rvalue (arg3
, complain
);
5201 if (!CLASS_TYPE_P (arg3_type
))
5202 arg3_type
= TREE_TYPE (arg3
);
5204 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5205 return error_mark_node
;
5209 After those conversions, one of the following shall hold:
5211 --The second and third operands have the same type; the result is of
5213 if (same_type_p (arg2_type
, arg3_type
))
5214 result_type
= arg2_type
;
5217 --The second and third operands have arithmetic or enumeration
5218 type; the usual arithmetic conversions are performed to bring
5219 them to a common type, and the result is of that type. */
5220 else if ((ARITHMETIC_TYPE_P (arg2_type
)
5221 || UNSCOPED_ENUM_P (arg2_type
))
5222 && (ARITHMETIC_TYPE_P (arg3_type
)
5223 || UNSCOPED_ENUM_P (arg3_type
)))
5225 /* In this case, there is always a common type. */
5226 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
5228 if (complain
& tf_warning
)
5229 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
5230 "implicit conversion from %qT to %qT to "
5231 "match other result of conditional",
5234 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5235 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
5237 if (TREE_CODE (orig_arg2
) == CONST_DECL
5238 && TREE_CODE (orig_arg3
) == CONST_DECL
5239 && DECL_CONTEXT (orig_arg2
) == DECL_CONTEXT (orig_arg3
))
5240 /* Two enumerators from the same enumeration can have different
5241 types when the enumeration is still being defined. */;
5242 else if (complain
& tf_warning
)
5243 warning_at (loc
, OPT_Wenum_compare
, "enumeral mismatch in "
5244 "conditional expression: %qT vs %qT",
5245 arg2_type
, arg3_type
);
5247 else if (extra_warnings
5248 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5249 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
5250 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
5251 && !same_type_p (arg2_type
,
5252 type_promotes_to (arg3_type
)))))
5254 if (complain
& tf_warning
)
5255 warning_at (loc
, OPT_Wextra
, "enumeral and non-enumeral type in "
5256 "conditional expression");
5259 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5260 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5264 --The second and third operands have pointer type, or one has
5265 pointer type and the other is a null pointer constant; pointer
5266 conversions (_conv.ptr_) and qualification conversions
5267 (_conv.qual_) are performed to bring them to their composite
5268 pointer type (_expr.rel_). The result is of the composite
5271 --The second and third operands have pointer to member type, or
5272 one has pointer to member type and the other is a null pointer
5273 constant; pointer to member conversions (_conv.mem_) and
5274 qualification conversions (_conv.qual_) are performed to bring
5275 them to a common type, whose cv-qualification shall match the
5276 cv-qualification of either the second or the third operand.
5277 The result is of the common type. */
5278 else if ((null_ptr_cst_p (arg2
)
5279 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
5280 || (null_ptr_cst_p (arg3
)
5281 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
5282 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
5283 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
5284 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
5286 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
5287 arg3
, CPO_CONDITIONAL_EXPR
,
5289 if (result_type
== error_mark_node
)
5290 return error_mark_node
;
5291 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5292 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5297 if (complain
& tf_error
)
5298 error_at (loc
, "operands to ?: have different types %qT and %qT",
5299 arg2_type
, arg3_type
);
5300 return error_mark_node
;
5303 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5304 return error_mark_node
;
5307 result
= build3_loc (loc
, COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
5309 /* If the ARG2 and ARG3 are the same and don't have side-effects,
5310 warn here, because the COND_EXPR will be turned into ARG2. */
5311 if (warn_duplicated_branches
5312 && (arg2
== arg3
|| operand_equal_p (arg2
, arg3
, 0)))
5313 warning_at (EXPR_LOCATION (result
), OPT_Wduplicated_branches
,
5314 "this condition has identical branches");
5316 /* We can't use result_type below, as fold might have returned a
5321 /* Expand both sides into the same slot, hopefully the target of
5322 the ?: expression. We used to check for TARGET_EXPRs here,
5323 but now we sometimes wrap them in NOP_EXPRs so the test would
5325 if (CLASS_TYPE_P (TREE_TYPE (result
)))
5326 result
= get_target_expr_sfinae (result
, complain
);
5327 /* If this expression is an rvalue, but might be mistaken for an
5328 lvalue, we must add a NON_LVALUE_EXPR. */
5329 result
= rvalue (result
);
5332 result
= force_paren_expr (result
);
5337 /* Wrapper for above. */
5340 build_conditional_expr (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
5341 tsubst_flags_t complain
)
5344 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5345 ret
= build_conditional_expr_1 (loc
, arg1
, arg2
, arg3
, complain
);
5346 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5350 /* OPERAND is an operand to an expression. Perform necessary steps
5351 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
5355 prep_operand (tree operand
)
5359 if (CLASS_TYPE_P (TREE_TYPE (operand
))
5360 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
5361 /* Make sure the template type is instantiated now. */
5362 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
5368 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
5369 OVERLOAD) to the CANDIDATES, returning an updated list of
5370 CANDIDATES. The ARGS are the arguments provided to the call;
5371 if FIRST_ARG is non-null it is the implicit object argument,
5372 otherwise the first element of ARGS is used if needed. The
5373 EXPLICIT_TARGS are explicit template arguments provided.
5374 TEMPLATE_ONLY is true if only template functions should be
5375 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
5376 add_function_candidate. */
5379 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
5381 tree explicit_targs
, bool template_only
,
5382 tree conversion_path
, tree access_path
,
5384 struct z_candidate
**candidates
,
5385 tsubst_flags_t complain
)
5388 const vec
<tree
, va_gc
> *non_static_args
;
5389 bool check_list_ctor
;
5390 bool check_converting
;
5391 unification_kind_t strict
;
5397 /* Precalculate special handling of constructors and conversion ops. */
5398 fn
= OVL_CURRENT (fns
);
5399 if (DECL_CONV_FN_P (fn
))
5401 check_list_ctor
= false;
5402 check_converting
= !!(flags
& LOOKUP_ONLYCONVERTING
);
5403 if (flags
& LOOKUP_NO_CONVERSION
)
5404 /* We're doing return_type(x). */
5405 strict
= DEDUCE_CONV
;
5407 /* We're doing x.operator return_type(). */
5408 strict
= DEDUCE_EXACT
;
5409 /* [over.match.funcs] For conversion functions, the function
5410 is considered to be a member of the class of the implicit
5411 object argument for the purpose of defining the type of
5412 the implicit object parameter. */
5413 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
5417 if (DECL_CONSTRUCTOR_P (fn
))
5419 check_list_ctor
= !!(flags
& LOOKUP_LIST_ONLY
);
5420 /* For list-initialization we consider explicit constructors
5421 and complain if one is chosen. */
5423 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
5424 == LOOKUP_ONLYCONVERTING
);
5428 check_list_ctor
= false;
5429 check_converting
= false;
5431 strict
= DEDUCE_CALL
;
5432 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
5436 non_static_args
= args
;
5438 /* Delay creating the implicit this parameter until it is needed. */
5439 non_static_args
= NULL
;
5441 for (; fns
; fns
= OVL_NEXT (fns
))
5444 const vec
<tree
, va_gc
> *fn_args
;
5446 fn
= OVL_CURRENT (fns
);
5448 if (check_converting
&& DECL_NONCONVERTING_P (fn
))
5450 if (check_list_ctor
&& !is_list_ctor (fn
))
5453 /* Figure out which set of arguments to use. */
5454 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
5456 /* If this function is a non-static member and we didn't get an
5457 implicit object argument, move it out of args. */
5458 if (first_arg
== NULL_TREE
)
5462 vec
<tree
, va_gc
> *tempvec
;
5463 vec_alloc (tempvec
, args
->length () - 1);
5464 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
5465 tempvec
->quick_push (arg
);
5466 non_static_args
= tempvec
;
5467 first_arg
= (*args
)[0];
5470 fn_first_arg
= first_arg
;
5471 fn_args
= non_static_args
;
5475 /* Otherwise, just use the list of arguments provided. */
5476 fn_first_arg
= NULL_TREE
;
5480 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5481 add_template_candidate (candidates
,
5493 else if (!template_only
)
5494 add_function_candidate (candidates
,
5506 /* Returns 1 if P0145R2 says that the LHS of operator CODE is evaluated first,
5507 -1 if the RHS is evaluated first, or 0 if the order is unspecified. */
5510 op_is_ordered (tree_code code
)
5516 return (flag_strong_eval_order
> 1 ? -1 : 0);
5520 return (flag_strong_eval_order
> 1 ? 1 : 0);
5523 // Not overloadable (yet).
5525 // Only one argument.
5532 return (flag_strong_eval_order
? 1 : 0);
5540 build_new_op_1 (location_t loc
, enum tree_code code
, int flags
, tree arg1
,
5541 tree arg2
, tree arg3
, tree
*overload
, tsubst_flags_t complain
)
5543 struct z_candidate
*candidates
= 0, *cand
;
5544 vec
<tree
, va_gc
> *arglist
;
5547 tree result
= NULL_TREE
;
5548 bool result_valid_p
= false;
5549 enum tree_code code2
= NOP_EXPR
;
5550 enum tree_code code_orig_arg1
= ERROR_MARK
;
5551 enum tree_code code_orig_arg2
= ERROR_MARK
;
5557 if (error_operand_p (arg1
)
5558 || error_operand_p (arg2
)
5559 || error_operand_p (arg3
))
5560 return error_mark_node
;
5562 if (code
== MODIFY_EXPR
)
5564 code2
= TREE_CODE (arg3
);
5566 fnname
= cp_assignment_operator_id (code2
);
5569 fnname
= cp_operator_id (code
);
5571 arg1
= prep_operand (arg1
);
5573 bool memonly
= false;
5578 case VEC_DELETE_EXPR
:
5580 /* Use build_op_new_call and build_op_delete_call instead. */
5584 /* Use build_op_call instead. */
5587 case TRUTH_ORIF_EXPR
:
5588 case TRUTH_ANDIF_EXPR
:
5589 case TRUTH_AND_EXPR
:
5591 /* These are saved for the sake of warn_logical_operator. */
5592 code_orig_arg1
= TREE_CODE (arg1
);
5593 code_orig_arg2
= TREE_CODE (arg2
);
5601 /* These are saved for the sake of maybe_warn_bool_compare. */
5602 code_orig_arg1
= TREE_CODE (TREE_TYPE (arg1
));
5603 code_orig_arg2
= TREE_CODE (TREE_TYPE (arg2
));
5606 /* =, ->, [], () must be non-static member functions. */
5608 if (code2
!= NOP_EXPR
)
5620 arg2
= prep_operand (arg2
);
5621 arg3
= prep_operand (arg3
);
5623 if (code
== COND_EXPR
)
5624 /* Use build_conditional_expr instead. */
5626 else if (! OVERLOAD_TYPE_P (TREE_TYPE (arg1
))
5627 && (! arg2
|| ! OVERLOAD_TYPE_P (TREE_TYPE (arg2
))))
5630 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5631 arg2
= integer_zero_node
;
5633 vec_alloc (arglist
, 3);
5634 arglist
->quick_push (arg1
);
5635 if (arg2
!= NULL_TREE
)
5636 arglist
->quick_push (arg2
);
5637 if (arg3
!= NULL_TREE
)
5638 arglist
->quick_push (arg3
);
5640 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5641 p
= conversion_obstack_alloc (0);
5643 /* Add namespace-scope operators to the list of functions to
5646 add_candidates (lookup_function_nonclass (fnname
, arglist
,
5648 NULL_TREE
, arglist
, NULL_TREE
,
5649 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5650 flags
, &candidates
, complain
);
5654 args
[2] = NULL_TREE
;
5656 /* Add class-member operators to the candidate set. */
5657 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
5661 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
5662 if (fns
== error_mark_node
)
5664 result
= error_mark_node
;
5665 goto user_defined_result_ready
;
5668 add_candidates (BASELINK_FUNCTIONS (fns
),
5669 NULL_TREE
, arglist
, NULL_TREE
,
5671 BASELINK_BINFO (fns
),
5672 BASELINK_ACCESS_BINFO (fns
),
5673 flags
, &candidates
, complain
);
5675 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5676 only non-member functions that have type T1 or reference to
5677 cv-qualified-opt T1 for the first argument, if the first argument
5678 has an enumeration type, or T2 or reference to cv-qualified-opt
5679 T2 for the second argument, if the second argument has an
5680 enumeration type. Filter out those that don't match. */
5681 else if (! arg2
|| ! CLASS_TYPE_P (TREE_TYPE (arg2
)))
5683 struct z_candidate
**candp
, **next
;
5685 for (candp
= &candidates
; *candp
; candp
= next
)
5687 tree parmlist
, parmtype
;
5688 int i
, nargs
= (arg2
? 2 : 1);
5693 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5695 for (i
= 0; i
< nargs
; ++i
)
5697 parmtype
= TREE_VALUE (parmlist
);
5699 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
5700 parmtype
= TREE_TYPE (parmtype
);
5701 if (TREE_CODE (TREE_TYPE (args
[i
])) == ENUMERAL_TYPE
5702 && (same_type_ignoring_top_level_qualifiers_p
5703 (TREE_TYPE (args
[i
]), parmtype
)))
5706 parmlist
= TREE_CHAIN (parmlist
);
5709 /* No argument has an appropriate type, so remove this
5710 candidate function from the list. */
5713 *candp
= cand
->next
;
5719 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
5726 /* For these, the built-in candidates set is empty
5727 [over.match.oper]/3. We don't want non-strict matches
5728 because exact matches are always possible with built-in
5729 operators. The built-in candidate set for COMPONENT_REF
5730 would be empty too, but since there are no such built-in
5731 operators, we accept non-strict matches for them. */
5740 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
5745 case POSTINCREMENT_EXPR
:
5746 case POSTDECREMENT_EXPR
:
5747 /* Don't try anything fancy if we're not allowed to produce
5749 if (!(complain
& tf_error
))
5750 return error_mark_node
;
5752 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5753 distinguish between prefix and postfix ++ and
5754 operator++() was used for both, so we allow this with
5758 const char *msg
= (flag_permissive
)
5759 ? G_("no %<%D(int)%> declared for postfix %qs,"
5760 " trying prefix operator instead")
5761 : G_("no %<%D(int)%> declared for postfix %qs");
5762 permerror (loc
, msg
, fnname
, operator_name_info
[code
].name
);
5765 if (!flag_permissive
)
5766 return error_mark_node
;
5768 if (code
== POSTINCREMENT_EXPR
)
5769 code
= PREINCREMENT_EXPR
;
5771 code
= PREDECREMENT_EXPR
;
5772 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
5773 NULL_TREE
, overload
, complain
);
5776 /* The caller will deal with these. */
5781 result_valid_p
= true;
5785 if (complain
& tf_error
)
5787 /* If one of the arguments of the operator represents
5788 an invalid use of member function pointer, try to report
5789 a meaningful error ... */
5790 if (invalid_nonstatic_memfn_p (loc
, arg1
, tf_error
)
5791 || invalid_nonstatic_memfn_p (loc
, arg2
, tf_error
)
5792 || invalid_nonstatic_memfn_p (loc
, arg3
, tf_error
))
5793 /* We displayed the error message. */;
5796 /* ... Otherwise, report the more generic
5797 "no matching operator found" error */
5798 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
5799 print_z_candidates (loc
, candidates
);
5802 result
= error_mark_node
;
5808 cand
= tourney (candidates
, complain
);
5811 if (complain
& tf_error
)
5813 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
5814 print_z_candidates (loc
, candidates
);
5816 result
= error_mark_node
;
5818 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5821 *overload
= cand
->fn
;
5823 if (resolve_args (arglist
, complain
) == NULL
)
5824 result
= error_mark_node
;
5826 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5828 if (trivial_fn_p (cand
->fn
))
5829 /* There won't be a CALL_EXPR. */;
5830 else if (result
&& result
!= error_mark_node
)
5832 tree call
= extract_call_expr (result
);
5833 CALL_EXPR_OPERATOR_SYNTAX (call
) = true;
5835 if (processing_template_decl
&& DECL_HIDDEN_FRIEND_P (cand
->fn
))
5836 /* This prevents build_new_function_call from discarding this
5837 function during instantiation of the enclosing template. */
5838 KOENIG_LOOKUP_P (call
) = 1;
5840 /* Specify evaluation order as per P0145R2. */
5841 CALL_EXPR_ORDERED_ARGS (call
) = false;
5842 switch (op_is_ordered (code
))
5845 CALL_EXPR_REVERSE_ARGS (call
) = true;
5849 CALL_EXPR_ORDERED_ARGS (call
) = true;
5859 /* Give any warnings we noticed during overload resolution. */
5860 if (cand
->warnings
&& (complain
& tf_warning
))
5862 struct candidate_warning
*w
;
5863 for (w
= cand
->warnings
; w
; w
= w
->next
)
5864 joust (cand
, w
->loser
, 1, complain
);
5867 /* Check for comparison of different enum types. */
5876 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
5877 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
5878 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
5879 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
)))
5880 && (complain
& tf_warning
))
5882 warning (OPT_Wenum_compare
,
5883 "comparison between %q#T and %q#T",
5884 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5891 /* We need to strip any leading REF_BIND so that bitfields
5892 don't cause errors. This should not remove any important
5893 conversions, because builtins don't apply to class
5894 objects directly. */
5895 conv
= cand
->convs
[0];
5896 if (conv
->kind
== ck_ref_bind
)
5897 conv
= next_conversion (conv
);
5898 arg1
= convert_like (conv
, arg1
, complain
);
5902 conv
= cand
->convs
[1];
5903 if (conv
->kind
== ck_ref_bind
)
5904 conv
= next_conversion (conv
);
5906 arg2
= decay_conversion (arg2
, complain
);
5908 /* We need to call warn_logical_operator before
5909 converting arg2 to a boolean_type, but after
5910 decaying an enumerator to its value. */
5911 if (complain
& tf_warning
)
5912 warn_logical_operator (loc
, code
, boolean_type_node
,
5913 code_orig_arg1
, arg1
,
5914 code_orig_arg2
, arg2
);
5916 arg2
= convert_like (conv
, arg2
, complain
);
5920 conv
= cand
->convs
[2];
5921 if (conv
->kind
== ck_ref_bind
)
5922 conv
= next_conversion (conv
);
5923 arg3
= convert_like (conv
, arg3
, complain
);
5929 user_defined_result_ready
:
5931 /* Free all the conversions we allocated. */
5932 obstack_free (&conversion_obstack
, p
);
5934 if (result
|| result_valid_p
)
5941 return cp_build_modify_expr (loc
, arg1
, code2
, arg2
, complain
);
5944 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
5946 case TRUTH_ANDIF_EXPR
:
5947 case TRUTH_ORIF_EXPR
:
5948 case TRUTH_AND_EXPR
:
5950 if (complain
& tf_warning
)
5951 warn_logical_operator (loc
, code
, boolean_type_node
,
5952 code_orig_arg1
, arg1
,
5953 code_orig_arg2
, arg2
);
5961 if ((complain
& tf_warning
)
5962 && ((code_orig_arg1
== BOOLEAN_TYPE
)
5963 ^ (code_orig_arg2
== BOOLEAN_TYPE
)))
5964 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
5965 if (complain
& tf_warning
&& warn_tautological_compare
)
5966 warn_tautological_cmp (loc
, code
, arg1
, arg2
);
5971 case TRUNC_DIV_EXPR
:
5976 case TRUNC_MOD_EXPR
:
5980 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
5982 case UNARY_PLUS_EXPR
:
5985 case TRUTH_NOT_EXPR
:
5986 case PREINCREMENT_EXPR
:
5987 case POSTINCREMENT_EXPR
:
5988 case PREDECREMENT_EXPR
:
5989 case POSTDECREMENT_EXPR
:
5993 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5996 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5999 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
6003 /* The caller will deal with these. */
6015 /* Wrapper for above. */
6018 build_new_op (location_t loc
, enum tree_code code
, int flags
,
6019 tree arg1
, tree arg2
, tree arg3
,
6020 tree
*overload
, tsubst_flags_t complain
)
6023 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
6024 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
6025 overload
, complain
);
6026 timevar_cond_stop (TV_OVERLOAD
, subtime
);
6030 /* CALL was returned by some call-building function; extract the actual
6031 CALL_EXPR from any bits that have been tacked on, e.g. by
6032 convert_from_reference. */
6035 extract_call_expr (tree call
)
6037 while (TREE_CODE (call
) == COMPOUND_EXPR
)
6038 call
= TREE_OPERAND (call
, 1);
6039 if (REFERENCE_REF_P (call
))
6040 call
= TREE_OPERAND (call
, 0);
6041 if (TREE_CODE (call
) == TARGET_EXPR
)
6042 call
= TARGET_EXPR_INITIAL (call
);
6043 gcc_assert (TREE_CODE (call
) == CALL_EXPR
6044 || TREE_CODE (call
) == AGGR_INIT_EXPR
6045 || call
== error_mark_node
);
6049 /* Returns true if FN has two parameters, of which the second has type
6053 second_parm_is_size_t (tree fn
)
6055 tree t
= FUNCTION_ARG_CHAIN (fn
);
6056 if (!t
|| !same_type_p (TREE_VALUE (t
), size_type_node
))
6059 if (t
== void_list_node
)
6061 if (aligned_new_threshold
&& t
6062 && same_type_p (TREE_VALUE (t
), align_type_node
)
6063 && TREE_CHAIN (t
) == void_list_node
)
6068 /* True if T, an allocation function, has std::align_val_t as its second
6072 aligned_allocation_fn_p (tree t
)
6074 if (!aligned_new_threshold
)
6077 tree a
= FUNCTION_ARG_CHAIN (t
);
6078 return (a
&& same_type_p (TREE_VALUE (a
), align_type_node
));
6081 /* Returns true iff T, an element of an OVERLOAD chain, is a usual deallocation
6082 function (3.7.4.2 [basic.stc.dynamic.deallocation]) with a parameter of
6083 std::align_val_t. */
6086 aligned_deallocation_fn_p (tree t
)
6088 if (!aligned_new_threshold
)
6091 /* A template instance is never a usual deallocation function,
6092 regardless of its signature. */
6093 if (TREE_CODE (t
) == TEMPLATE_DECL
6094 || primary_template_instantiation_p (t
))
6097 tree a
= FUNCTION_ARG_CHAIN (t
);
6098 if (same_type_p (TREE_VALUE (a
), align_type_node
)
6099 && TREE_CHAIN (a
) == void_list_node
)
6101 if (!same_type_p (TREE_VALUE (a
), size_type_node
))
6104 if (a
&& same_type_p (TREE_VALUE (a
), align_type_node
)
6105 && TREE_CHAIN (a
) == void_list_node
)
6110 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
6111 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
6114 usual_deallocation_fn_p (tree t
)
6116 /* A template instance is never a usual deallocation function,
6117 regardless of its signature. */
6118 if (TREE_CODE (t
) == TEMPLATE_DECL
6119 || primary_template_instantiation_p (t
))
6122 /* If a class T has a member deallocation function named operator delete
6123 with exactly one parameter, then that function is a usual
6124 (non-placement) deallocation function. If class T does not declare
6125 such an operator delete but does declare a member deallocation
6126 function named operator delete with exactly two parameters, the second
6127 of which has type std::size_t (18.2), then this function is a usual
6128 deallocation function. */
6129 bool global
= DECL_NAMESPACE_SCOPE_P (t
);
6130 tree chain
= FUNCTION_ARG_CHAIN (t
);
6133 if (chain
== void_list_node
6134 || ((!global
|| flag_sized_deallocation
)
6135 && second_parm_is_size_t (t
)))
6137 if (aligned_deallocation_fn_p (t
))
6142 /* Build a call to operator delete. This has to be handled very specially,
6143 because the restrictions on what signatures match are different from all
6144 other call instances. For a normal delete, only a delete taking (void *)
6145 or (void *, size_t) is accepted. For a placement delete, only an exact
6146 match with the placement new is accepted.
6148 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
6149 ADDR is the pointer to be deleted.
6150 SIZE is the size of the memory block to be deleted.
6151 GLOBAL_P is true if the delete-expression should not consider
6152 class-specific delete operators.
6153 PLACEMENT is the corresponding placement new call, or NULL_TREE.
6155 If this call to "operator delete" is being generated as part to
6156 deallocate memory allocated via a new-expression (as per [expr.new]
6157 which requires that if the initialization throws an exception then
6158 we call a deallocation function), then ALLOC_FN is the allocation
6162 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
6163 bool global_p
, tree placement
,
6164 tree alloc_fn
, tsubst_flags_t complain
)
6166 tree fn
= NULL_TREE
;
6167 tree fns
, fnname
, type
, t
;
6169 if (addr
== error_mark_node
)
6170 return error_mark_node
;
6172 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
6174 fnname
= cp_operator_id (code
);
6176 if (CLASS_TYPE_P (type
)
6177 && COMPLETE_TYPE_P (complete_type (type
))
6181 If the result of the lookup is ambiguous or inaccessible, or if
6182 the lookup selects a placement deallocation function, the
6183 program is ill-formed.
6185 Therefore, we ask lookup_fnfields to complain about ambiguity. */
6187 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
6188 if (fns
== error_mark_node
)
6189 return error_mark_node
;
6194 if (fns
== NULL_TREE
)
6195 fns
= lookup_name_nonclass (fnname
);
6197 /* Strip const and volatile from addr. */
6198 addr
= cp_convert (ptr_type_node
, addr
, complain
);
6202 /* "A declaration of a placement deallocation function matches the
6203 declaration of a placement allocation function if it has the same
6204 number of parameters and, after parameter transformations (8.3.5),
6205 all parameter types except the first are identical."
6207 So we build up the function type we want and ask instantiate_type
6208 to get it for us. */
6209 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
6210 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
6211 t
= build_function_type (void_type_node
, t
);
6213 fn
= instantiate_type (t
, fns
, tf_none
);
6214 if (fn
== error_mark_node
)
6217 if (BASELINK_P (fn
))
6218 fn
= BASELINK_FUNCTIONS (fn
);
6220 /* "If the lookup finds the two-parameter form of a usual deallocation
6221 function (3.7.4.2) and that function, considered as a placement
6222 deallocation function, would have been selected as a match for the
6223 allocation function, the program is ill-formed." */
6224 if (second_parm_is_size_t (fn
))
6227 = G_("exception cleanup for this placement new selects "
6228 "non-placement operator delete");
6230 = G_("%qD is a usual (non-placement) deallocation "
6231 "function in C++14 (or with -fsized-deallocation)");
6233 /* But if the class has an operator delete (void *), then that is
6234 the usual deallocation function, so we shouldn't complain
6235 about using the operator delete (void *, size_t). */
6236 if (DECL_CLASS_SCOPE_P (fn
))
6237 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
6238 t
; t
= OVL_NEXT (t
))
6240 tree elt
= OVL_CURRENT (t
);
6241 if (usual_deallocation_fn_p (elt
)
6242 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
6245 /* Before C++14 a two-parameter global deallocation function is
6246 always a placement deallocation function, but warn if
6248 else if (!flag_sized_deallocation
)
6250 if ((complain
& tf_warning
)
6251 && warning (OPT_Wc__14_compat
, msg1
))
6252 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
6256 if (complain
& tf_warning_or_error
)
6258 if (permerror (input_location
, msg1
))
6260 /* Only mention C++14 for namespace-scope delete. */
6261 if (DECL_NAMESPACE_SCOPE_P (fn
))
6262 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
6264 inform (DECL_SOURCE_LOCATION (fn
),
6265 "%qD is a usual (non-placement) deallocation "
6270 return error_mark_node
;
6275 /* "Any non-placement deallocation function matches a non-placement
6276 allocation function. If the lookup finds a single matching
6277 deallocation function, that function will be called; otherwise, no
6278 deallocation function will be called." */
6279 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
6280 t
; t
= OVL_NEXT (t
))
6282 tree elt
= OVL_CURRENT (t
);
6283 if (usual_deallocation_fn_p (elt
))
6291 /* -- If the type has new-extended alignment, a function with a
6292 parameter of type std::align_val_t is preferred; otherwise a
6293 function without such a parameter is preferred. If exactly one
6294 preferred function is found, that function is selected and the
6295 selection process terminates. If more than one preferred
6296 function is found, all non-preferred functions are eliminated
6297 from further consideration. */
6298 if (aligned_new_threshold
)
6300 bool want_align
= type_has_new_extended_alignment (type
);
6301 bool fn_align
= aligned_deallocation_fn_p (fn
);
6302 bool elt_align
= aligned_deallocation_fn_p (elt
);
6304 if (elt_align
!= fn_align
)
6306 if (want_align
== elt_align
)
6312 /* -- If the deallocation functions have class scope, the one
6313 without a parameter of type std::size_t is selected. */
6315 if (DECL_CLASS_SCOPE_P (fn
))
6318 /* -- If the type is complete and if, for the second alternative
6319 (delete array) only, the operand is a pointer to a class type
6320 with a non-trivial destructor or a (possibly multi-dimensional)
6321 array thereof, the function with a parameter of type std::size_t
6324 -- Otherwise, it is unspecified whether a deallocation function
6325 with a parameter of type std::size_t is selected. */
6328 want_size
= COMPLETE_TYPE_P (type
);
6329 if (code
== VEC_DELETE_EXPR
6330 && !TYPE_VEC_NEW_USES_COOKIE (type
))
6331 /* We need a cookie to determine the array size. */
6334 bool fn_size
= second_parm_is_size_t (fn
);
6335 bool elt_size
= second_parm_is_size_t (elt
);
6336 gcc_assert (fn_size
!= elt_size
);
6337 if (want_size
== elt_size
)
6342 /* If we have a matching function, call it. */
6345 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6347 /* If the FN is a member function, make sure that it is
6349 if (BASELINK_P (fns
))
6350 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
6353 /* Core issue 901: It's ok to new a type with deleted delete. */
6354 if (DECL_DELETED_FN (fn
) && alloc_fn
)
6359 /* The placement args might not be suitable for overload
6360 resolution at this point, so build the call directly. */
6361 int nargs
= call_expr_nargs (placement
);
6362 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
6365 for (i
= 1; i
< nargs
; i
++)
6366 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
6367 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6368 return error_mark_node
;
6369 return build_cxx_call (fn
, nargs
, argarray
, complain
);
6374 vec
<tree
, va_gc
> *args
= make_tree_vector ();
6375 args
->quick_push (addr
);
6376 if (second_parm_is_size_t (fn
))
6377 args
->quick_push (size
);
6378 if (aligned_deallocation_fn_p (fn
))
6380 tree al
= build_int_cst (align_type_node
, TYPE_ALIGN_UNIT (type
));
6381 args
->quick_push (al
);
6383 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
6384 release_tree_vector (args
);
6391 If no unambiguous matching deallocation function can be found,
6392 propagating the exception does not cause the object's memory to
6396 if ((complain
& tf_warning
)
6398 warning (0, "no corresponding deallocation function for %qD",
6403 if (complain
& tf_error
)
6404 error ("no suitable %<operator %s%> for %qT",
6405 operator_name_info
[(int)code
].name
, type
);
6406 return error_mark_node
;
6409 /* If the current scope isn't allowed to access DECL along
6410 BASETYPE_PATH, give an error. The most derived class in
6411 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
6412 the declaration to use in the error diagnostic. */
6415 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
6416 tsubst_flags_t complain
)
6418 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
6420 if (flag_new_inheriting_ctors
6421 && DECL_INHERITED_CTOR (decl
))
6423 /* 7.3.3/18: The additional constructors are accessible if they would be
6424 accessible when used to construct an object of the corresponding base
6426 decl
= strip_inheriting_ctors (decl
);
6427 basetype_path
= lookup_base (basetype_path
, DECL_CONTEXT (decl
),
6428 ba_any
, NULL
, complain
);
6431 if (!accessible_p (basetype_path
, decl
, true))
6433 if (complain
& tf_error
)
6435 if (flag_new_inheriting_ctors
)
6436 diag_decl
= strip_inheriting_ctors (diag_decl
);
6437 if (TREE_PRIVATE (decl
))
6439 error ("%q#D is private within this context", diag_decl
);
6440 inform (DECL_SOURCE_LOCATION (diag_decl
),
6441 "declared private here");
6443 else if (TREE_PROTECTED (decl
))
6445 error ("%q#D is protected within this context", diag_decl
);
6446 inform (DECL_SOURCE_LOCATION (diag_decl
),
6447 "declared protected here");
6451 error ("%q#D is inaccessible within this context", diag_decl
);
6452 inform (DECL_SOURCE_LOCATION (diag_decl
), "declared here");
6461 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
6462 bitwise or of LOOKUP_* values. If any errors are warnings are
6463 generated, set *DIAGNOSTIC_FN to "error" or "warning",
6464 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
6468 build_temp (tree expr
, tree type
, int flags
,
6469 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
6472 vec
<tree
, va_gc
> *args
;
6474 *diagnostic_kind
= DK_UNSPECIFIED
;
6476 /* If the source is a packed field, calling the copy constructor will require
6477 binding the field to the reference parameter to the copy constructor, and
6478 we'll end up with an infinite loop. If we can use a bitwise copy, then
6480 if ((lvalue_kind (expr
) & clk_packed
)
6481 && CLASS_TYPE_P (TREE_TYPE (expr
))
6482 && !type_has_nontrivial_copy_init (TREE_TYPE (expr
)))
6483 return get_target_expr_sfinae (expr
, complain
);
6485 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
6486 args
= make_tree_vector_single (expr
);
6487 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6488 &args
, type
, flags
, complain
);
6489 release_tree_vector (args
);
6490 if (warningcount
+ werrorcount
> savew
)
6491 *diagnostic_kind
= DK_WARNING
;
6492 else if (errorcount
> savee
)
6493 *diagnostic_kind
= DK_ERROR
;
6497 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
6498 EXPR is implicitly converted to type TOTYPE.
6499 FN and ARGNUM are used for diagnostics. */
6502 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6504 /* Issue warnings about peculiar, but valid, uses of NULL. */
6505 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
6506 && ARITHMETIC_TYPE_P (totype
))
6508 source_location loc
=
6509 expansion_point_location_if_in_system_header (input_location
);
6512 warning_at (loc
, OPT_Wconversion_null
,
6513 "passing NULL to non-pointer argument %P of %qD",
6516 warning_at (loc
, OPT_Wconversion_null
,
6517 "converting to non-pointer type %qT from NULL", totype
);
6520 /* Issue warnings if "false" is converted to a NULL pointer */
6521 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6522 && TYPE_PTR_P (totype
))
6525 warning_at (input_location
, OPT_Wconversion_null
,
6526 "converting %<false%> to pointer type for argument %P "
6527 "of %qD", argnum
, fn
);
6529 warning_at (input_location
, OPT_Wconversion_null
,
6530 "converting %<false%> to pointer type %qT", totype
);
6534 /* We gave a diagnostic during a conversion. If this was in the second
6535 standard conversion sequence of a user-defined conversion sequence, say
6536 which user-defined conversion. */
6539 maybe_print_user_conv_context (conversion
*convs
)
6541 if (convs
->user_conv_p
)
6542 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6543 if (t
->kind
== ck_user
)
6545 print_z_candidate (0, " after user-defined conversion:",
6551 /* Perform the conversions in CONVS on the expression EXPR. FN and
6552 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6553 indicates the `this' argument of a method. INNER is nonzero when
6554 being called to continue a conversion chain. It is negative when a
6555 reference binding will be applied, positive otherwise. If
6556 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6557 conversions will be emitted if appropriate. If C_CAST_P is true,
6558 this conversion is coming from a C-style cast; in that case,
6559 conversions to inaccessible bases are permitted. */
6562 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6563 int inner
, bool issue_conversion_warnings
,
6564 bool c_cast_p
, tsubst_flags_t complain
)
6566 tree totype
= convs
->type
;
6567 diagnostic_t diag_kind
;
6569 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6571 if (convs
->bad_p
&& !(complain
& tf_error
))
6572 return error_mark_node
;
6575 && convs
->kind
!= ck_user
6576 && convs
->kind
!= ck_list
6577 && convs
->kind
!= ck_ambig
6578 && (convs
->kind
!= ck_ref_bind
6579 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
6580 && (convs
->kind
!= ck_rvalue
6581 || SCALAR_TYPE_P (totype
))
6582 && convs
->kind
!= ck_base
)
6584 bool complained
= false;
6585 conversion
*t
= convs
;
6587 /* Give a helpful error if this is bad because of excess braces. */
6588 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6589 && SCALAR_TYPE_P (totype
)
6590 && CONSTRUCTOR_NELTS (expr
) > 0
6591 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
6593 complained
= permerror (loc
, "too many braces around initializer "
6595 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6596 && CONSTRUCTOR_NELTS (expr
) == 1)
6597 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6600 /* Give a helpful error if this is bad because a conversion to bool
6601 from std::nullptr_t requires direct-initialization. */
6602 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
6603 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
6604 complained
= permerror (loc
, "converting to %qT from %qT requires "
6605 "direct-initialization",
6606 totype
, TREE_TYPE (expr
));
6608 for (; t
; t
= next_conversion (t
))
6610 if (t
->kind
== ck_user
&& t
->cand
->reason
)
6612 complained
= permerror (loc
, "invalid user-defined conversion "
6613 "from %qT to %qT", TREE_TYPE (expr
),
6616 print_z_candidate (loc
, "candidate is:", t
->cand
);
6617 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6618 /*issue_conversion_warnings=*/false,
6621 if (convs
->kind
== ck_ref_bind
)
6622 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
6623 LOOKUP_NORMAL
, NULL_TREE
,
6626 expr
= cp_convert (totype
, expr
, complain
);
6627 if (complained
&& fn
)
6628 inform (DECL_SOURCE_LOCATION (fn
),
6629 " initializing argument %P of %qD", argnum
, fn
);
6632 else if (t
->kind
== ck_user
|| !t
->bad_p
)
6634 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6635 /*issue_conversion_warnings=*/false,
6640 else if (t
->kind
== ck_ambig
)
6641 return convert_like_real (t
, expr
, fn
, argnum
, 1,
6642 /*issue_conversion_warnings=*/false,
6645 else if (t
->kind
== ck_identity
)
6649 complained
= permerror (loc
, "invalid conversion from %qT to %qT",
6650 TREE_TYPE (expr
), totype
);
6651 if (complained
&& fn
)
6652 inform (DECL_SOURCE_LOCATION (fn
),
6653 " initializing argument %P of %qD", argnum
, fn
);
6655 return cp_convert (totype
, expr
, complain
);
6658 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6659 conversion_null_warnings (totype
, expr
, fn
, argnum
);
6661 switch (convs
->kind
)
6665 struct z_candidate
*cand
= convs
->cand
;
6666 tree convfn
= cand
->fn
;
6668 /* When converting from an init list we consider explicit
6669 constructors, but actually trying to call one is an error. */
6670 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
6671 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
6672 /* Unless this is for direct-list-initialization. */
6673 && !CONSTRUCTOR_IS_DIRECT_INIT (expr
)
6674 /* And in C++98 a default constructor can't be explicit. */
6675 && cxx_dialect
>= cxx11
)
6677 if (!(complain
& tf_error
))
6678 return error_mark_node
;
6679 location_t loc
= location_of (expr
);
6680 if (CONSTRUCTOR_NELTS (expr
) == 0
6681 && FUNCTION_FIRST_USER_PARMTYPE (convfn
) != void_list_node
)
6683 if (pedwarn (loc
, 0, "converting to %qT from initializer list "
6684 "would use explicit constructor %qD",
6686 inform (loc
, "in C++11 and above a default constructor "
6690 error ("converting to %qT from initializer list would use "
6691 "explicit constructor %qD", totype
, convfn
);
6694 /* If we're initializing from {}, it's value-initialization. */
6695 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6696 && CONSTRUCTOR_NELTS (expr
) == 0
6697 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
6699 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
6700 expr
= build_value_init (totype
, complain
);
6701 expr
= get_target_expr_sfinae (expr
, complain
);
6702 if (expr
!= error_mark_node
)
6704 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6705 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
6710 expr
= mark_rvalue_use (expr
);
6712 /* Pass LOOKUP_NO_CONVERSION so rvalue/base handling knows not to allow
6714 expr
= build_over_call (cand
, LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
6717 /* If this is a constructor or a function returning an aggr type,
6718 we need to build up a TARGET_EXPR. */
6719 if (DECL_CONSTRUCTOR_P (convfn
))
6721 expr
= build_cplus_new (totype
, expr
, complain
);
6723 /* Remember that this was list-initialization. */
6724 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
6725 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6731 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
6733 int nelts
= CONSTRUCTOR_NELTS (expr
);
6735 expr
= build_value_init (totype
, complain
);
6736 else if (nelts
== 1)
6737 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6741 expr
= mark_rvalue_use (expr
);
6743 if (type_unknown_p (expr
))
6744 expr
= instantiate_type (totype
, expr
, complain
);
6745 /* Convert a constant to its underlying value, unless we are
6746 about to bind it to a reference, in which case we need to
6747 leave it as an lvalue. */
6750 expr
= scalar_constant_value (expr
);
6751 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
6752 /* If __null has been converted to an integer type, we do not
6753 want to warn about uses of EXPR as an integer, rather than
6755 expr
= build_int_cst (totype
, 0);
6759 /* We leave bad_p off ck_ambig because overload resolution considers
6760 it valid, it just fails when we try to perform it. So we need to
6761 check complain here, too. */
6762 if (complain
& tf_error
)
6764 /* Call build_user_type_conversion again for the error. */
6765 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
6768 inform (DECL_SOURCE_LOCATION (fn
),
6769 " initializing argument %P of %qD", argnum
, fn
);
6771 return error_mark_node
;
6775 /* Conversion to std::initializer_list<T>. */
6776 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
6777 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
6778 unsigned len
= CONSTRUCTOR_NELTS (expr
);
6779 tree array
, val
, field
;
6780 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6783 /* Convert all the elements. */
6784 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
6786 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
6787 1, false, false, complain
);
6788 if (sub
== error_mark_node
)
6790 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
6791 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
6792 return error_mark_node
;
6793 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
6794 if (!TREE_CONSTANT (sub
))
6795 TREE_CONSTANT (new_ctor
) = false;
6797 /* Build up the array. */
6798 elttype
= cp_build_qualified_type
6799 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
6800 array
= build_array_of_n_type (elttype
, len
);
6801 array
= finish_compound_literal (array
, new_ctor
, complain
);
6802 /* Take the address explicitly rather than via decay_conversion
6803 to avoid the error about taking the address of a temporary. */
6804 array
= cp_build_addr_expr (array
, complain
);
6805 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
6806 if (array
== error_mark_node
)
6807 return error_mark_node
;
6809 /* Build up the initializer_list object. */
6810 totype
= complete_type (totype
);
6811 field
= next_initializable_field (TYPE_FIELDS (totype
));
6812 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6813 field
= next_initializable_field (DECL_CHAIN (field
));
6814 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6815 new_ctor
= build_constructor (totype
, vec
);
6816 return get_target_expr_sfinae (new_ctor
, complain
);
6820 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6822 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6823 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6824 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6826 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6828 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6831 expr
= reshape_init (totype
, expr
, complain
);
6832 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6834 if (expr
!= error_mark_node
)
6835 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6842 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6843 convs
->kind
== ck_ref_bind
? -1 : 1,
6844 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6847 if (expr
== error_mark_node
)
6848 return error_mark_node
;
6850 switch (convs
->kind
)
6853 expr
= decay_conversion (expr
, complain
);
6854 if (expr
== error_mark_node
)
6856 if (complain
& tf_error
)
6858 maybe_print_user_conv_context (convs
);
6860 inform (DECL_SOURCE_LOCATION (fn
),
6861 " initializing argument %P of %qD", argnum
, fn
);
6863 return error_mark_node
;
6866 if (! MAYBE_CLASS_TYPE_P (totype
))
6869 /* Don't introduce copies when passing arguments along to the inherited
6871 if (current_function_decl
6872 && flag_new_inheriting_ctors
6873 && DECL_INHERITED_CTOR (current_function_decl
))
6878 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6880 /* We are going to bind a reference directly to a base-class
6881 subobject of EXPR. */
6882 /* Build an expression for `*((base*) &expr)'. */
6883 expr
= convert_to_base (expr
, totype
,
6884 !c_cast_p
, /*nonnull=*/true, complain
);
6888 /* Copy-initialization where the cv-unqualified version of the source
6889 type is the same class as, or a derived class of, the class of the
6890 destination [is treated as direct-initialization]. [dcl.init] */
6891 flags
= LOOKUP_NORMAL
;
6892 if (convs
->user_conv_p
)
6893 /* This conversion is being done in the context of a user-defined
6894 conversion (i.e. the second step of copy-initialization), so
6895 don't allow any more. */
6896 flags
|= LOOKUP_NO_CONVERSION
;
6898 flags
|= LOOKUP_ONLYCONVERTING
;
6899 if (convs
->rvaluedness_matches_p
)
6900 flags
|= LOOKUP_PREFER_RVALUE
;
6901 if (TREE_CODE (expr
) == TARGET_EXPR
6902 && TARGET_EXPR_LIST_INIT_P (expr
))
6903 /* Copy-list-initialization doesn't actually involve a copy. */
6905 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6906 if (diag_kind
&& complain
)
6908 maybe_print_user_conv_context (convs
);
6910 inform (DECL_SOURCE_LOCATION (fn
),
6911 " initializing argument %P of %qD", argnum
, fn
);
6914 return build_cplus_new (totype
, expr
, complain
);
6918 tree ref_type
= totype
;
6920 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6922 tree extype
= TREE_TYPE (expr
);
6923 if (TYPE_REF_IS_RVALUE (ref_type
)
6925 error_at (loc
, "cannot bind rvalue reference of type %qT to "
6926 "lvalue of type %qT", totype
, extype
);
6927 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !lvalue_p (expr
)
6928 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
6929 error_at (loc
, "cannot bind non-const lvalue reference of "
6930 "type %qT to an rvalue of type %qT", totype
, extype
);
6931 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
6932 error_at (loc
, "binding reference of type %qT to %qT "
6933 "discards qualifiers", totype
, extype
);
6936 maybe_print_user_conv_context (convs
);
6938 inform (DECL_SOURCE_LOCATION (fn
),
6939 " initializing argument %P of %qD", argnum
, fn
);
6940 return error_mark_node
;
6943 /* If necessary, create a temporary.
6945 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6946 that need temporaries, even when their types are reference
6947 compatible with the type of reference being bound, so the
6948 upcoming call to cp_build_addr_expr doesn't fail. */
6949 if (convs
->need_temporary_p
6950 || TREE_CODE (expr
) == CONSTRUCTOR
6951 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6953 /* Otherwise, a temporary of type "cv1 T1" is created and
6954 initialized from the initializer expression using the rules
6955 for a non-reference copy-initialization (8.5). */
6957 tree type
= TREE_TYPE (ref_type
);
6958 cp_lvalue_kind lvalue
= lvalue_kind (expr
);
6960 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6961 (type
, next_conversion (convs
)->type
));
6962 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6963 && !TYPE_REF_IS_RVALUE (ref_type
))
6965 /* If the reference is volatile or non-const, we
6966 cannot create a temporary. */
6967 if (lvalue
& clk_bitfield
)
6968 error_at (loc
, "cannot bind bitfield %qE to %qT",
6970 else if (lvalue
& clk_packed
)
6971 error_at (loc
, "cannot bind packed field %qE to %qT",
6974 error_at (loc
, "cannot bind rvalue %qE to %qT",
6976 return error_mark_node
;
6978 /* If the source is a packed field, and we must use a copy
6979 constructor, then building the target expr will require
6980 binding the field to the reference parameter to the
6981 copy constructor, and we'll end up with an infinite
6982 loop. If we can use a bitwise copy, then we'll be
6984 if ((lvalue
& clk_packed
)
6985 && CLASS_TYPE_P (type
)
6986 && type_has_nontrivial_copy_init (type
))
6988 error_at (loc
, "cannot bind packed field %qE to %qT",
6990 return error_mark_node
;
6992 if (lvalue
& clk_bitfield
)
6994 expr
= convert_bitfield_to_declared_type (expr
);
6995 expr
= fold_convert (type
, expr
);
6997 expr
= build_target_expr_with_type (expr
, type
, complain
);
7000 /* Take the address of the thing to which we will bind the
7002 expr
= cp_build_addr_expr (expr
, complain
);
7003 if (expr
== error_mark_node
)
7004 return error_mark_node
;
7006 /* Convert it to a pointer to the type referred to by the
7007 reference. This will adjust the pointer if a derived to
7008 base conversion is being performed. */
7009 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
7011 /* Convert the pointer to the desired reference type. */
7012 return build_nop (ref_type
, expr
);
7016 return decay_conversion (expr
, complain
);
7019 /* ??? Should the address of a transaction-safe pointer point to the TM
7020 clone, and this conversion look up the primary function? */
7021 return build_nop (totype
, expr
);
7024 /* Warn about deprecated conversion if appropriate. */
7025 string_conv_p (totype
, expr
, 1);
7030 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
7031 /*nonnull=*/false, complain
);
7032 return build_nop (totype
, expr
);
7035 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
7036 c_cast_p
, complain
);
7042 if (convs
->check_narrowing
7043 && !check_narrowing (totype
, expr
, complain
))
7044 return error_mark_node
;
7046 if (issue_conversion_warnings
)
7047 expr
= cp_convert_and_check (totype
, expr
, complain
);
7049 expr
= cp_convert (totype
, expr
, complain
);
7054 /* ARG is being passed to a varargs function. Perform any conversions
7055 required. Return the converted value. */
7058 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
7061 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
7065 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
7066 standard conversions are performed. */
7067 arg
= decay_conversion (arg
, complain
);
7068 arg_type
= TREE_TYPE (arg
);
7071 If the argument has integral or enumeration type that is subject
7072 to the integral promotions (_conv.prom_), or a floating point
7073 type that is subject to the floating point promotion
7074 (_conv.fpprom_), the value of the argument is converted to the
7075 promoted type before the call. */
7076 if (TREE_CODE (arg_type
) == REAL_TYPE
7077 && (TYPE_PRECISION (arg_type
)
7078 < TYPE_PRECISION (double_type_node
))
7079 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
7081 if ((complain
& tf_warning
)
7082 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
7083 warning_at (loc
, OPT_Wdouble_promotion
,
7084 "implicit conversion from %qT to %qT when passing "
7085 "argument to function",
7086 arg_type
, double_type_node
);
7087 arg
= convert_to_real_nofold (double_type_node
, arg
);
7089 else if (NULLPTR_TYPE_P (arg_type
))
7090 arg
= null_pointer_node
;
7091 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
7093 if (SCOPED_ENUM_P (arg_type
))
7095 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
7097 prom
= cp_perform_integral_promotions (prom
, complain
);
7098 if (abi_version_crosses (6)
7099 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
7100 && (complain
& tf_warning
))
7101 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through ... as "
7102 "%qT before -fabi-version=6, %qT after", arg_type
,
7103 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
7104 if (!abi_version_at_least (6))
7108 arg
= cp_perform_integral_promotions (arg
, complain
);
7111 arg
= require_complete_type_sfinae (arg
, complain
);
7112 arg_type
= TREE_TYPE (arg
);
7114 if (arg
!= error_mark_node
7115 /* In a template (or ill-formed code), we can have an incomplete type
7116 even after require_complete_type_sfinae, in which case we don't know
7117 whether it has trivial copy or not. */
7118 && COMPLETE_TYPE_P (arg_type
))
7120 /* Build up a real lvalue-to-rvalue conversion in case the
7121 copy constructor is trivial but not callable. */
7122 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
7123 force_rvalue (arg
, complain
);
7125 /* [expr.call] 5.2.2/7:
7126 Passing a potentially-evaluated argument of class type (Clause 9)
7127 with a non-trivial copy constructor or a non-trivial destructor
7128 with no corresponding parameter is conditionally-supported, with
7129 implementation-defined semantics.
7131 We support it as pass-by-invisible-reference, just like a normal
7134 If the call appears in the context of a sizeof expression,
7135 it is not potentially-evaluated. */
7136 if (cp_unevaluated_operand
== 0
7137 && (type_has_nontrivial_copy_init (arg_type
)
7138 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
7140 if (complain
& tf_warning
)
7141 warning (OPT_Wconditionally_supported
,
7142 "passing objects of non-trivially-copyable "
7143 "type %q#T through %<...%> is conditionally supported",
7145 return cp_build_addr_expr (arg
, complain
);
7152 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
7155 build_x_va_arg (source_location loc
, tree expr
, tree type
)
7157 if (processing_template_decl
)
7159 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
7160 SET_EXPR_LOCATION (r
, loc
);
7164 type
= complete_type_or_else (type
, NULL_TREE
);
7166 if (expr
== error_mark_node
|| !type
)
7167 return error_mark_node
;
7169 expr
= mark_lvalue_use (expr
);
7171 if (TREE_CODE (type
) == REFERENCE_TYPE
)
7173 error ("cannot receive reference type %qT through %<...%>", type
);
7174 return error_mark_node
;
7177 if (type_has_nontrivial_copy_init (type
)
7178 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7180 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
7181 it as pass by invisible reference. */
7182 warning_at (loc
, OPT_Wconditionally_supported
,
7183 "receiving objects of non-trivially-copyable type %q#T "
7184 "through %<...%> is conditionally-supported", type
);
7186 tree ref
= cp_build_reference_type (type
, false);
7187 expr
= build_va_arg (loc
, expr
, ref
);
7188 return convert_from_reference (expr
);
7191 tree ret
= build_va_arg (loc
, expr
, type
);
7192 if (CLASS_TYPE_P (type
))
7193 /* Wrap the VA_ARG_EXPR in a TARGET_EXPR now so other code doesn't need to
7194 know how to handle it. */
7195 ret
= get_target_expr (ret
);
7199 /* TYPE has been given to va_arg. Apply the default conversions which
7200 would have happened when passed via ellipsis. Return the promoted
7201 type, or the passed type if there is no change. */
7204 cxx_type_promotes_to (tree type
)
7208 /* Perform the array-to-pointer and function-to-pointer
7210 type
= type_decays_to (type
);
7212 promote
= type_promotes_to (type
);
7213 if (same_type_p (type
, promote
))
7219 /* ARG is a default argument expression being passed to a parameter of
7220 the indicated TYPE, which is a parameter to FN. PARMNUM is the
7221 zero-based argument number. Do any required conversions. Return
7222 the converted value. */
7224 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
7226 push_defarg_context (tree fn
)
7227 { vec_safe_push (default_arg_context
, fn
); }
7230 pop_defarg_context (void)
7231 { default_arg_context
->pop (); }
7234 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
7235 tsubst_flags_t complain
)
7240 /* See through clones. */
7241 fn
= DECL_ORIGIN (fn
);
7242 /* And inheriting ctors. */
7243 if (flag_new_inheriting_ctors
)
7244 fn
= strip_inheriting_ctors (fn
);
7246 /* Detect recursion. */
7247 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
7250 if (complain
& tf_error
)
7251 error ("recursive evaluation of default argument for %q#D", fn
);
7252 return error_mark_node
;
7255 /* If the ARG is an unparsed default argument expression, the
7256 conversion cannot be performed. */
7257 if (TREE_CODE (arg
) == DEFAULT_ARG
)
7259 if (complain
& tf_error
)
7260 error ("call to %qD uses the default argument for parameter %P, which "
7261 "is not yet defined", fn
, parmnum
);
7262 return error_mark_node
;
7265 push_defarg_context (fn
);
7267 if (fn
&& DECL_TEMPLATE_INFO (fn
))
7268 arg
= tsubst_default_argument (fn
, type
, arg
, complain
);
7274 The names in the expression are bound, and the semantic
7275 constraints are checked, at the point where the default
7276 expressions appears.
7278 we must not perform access checks here. */
7279 push_deferring_access_checks (dk_no_check
);
7280 /* We must make a copy of ARG, in case subsequent processing
7281 alters any part of it. */
7282 arg
= break_out_target_exprs (arg
);
7283 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
7284 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
7286 arg
= convert_for_arg_passing (type
, arg
, complain
);
7287 pop_deferring_access_checks();
7289 pop_defarg_context ();
7294 /* Returns the type which will really be used for passing an argument of
7298 type_passed_as (tree type
)
7300 /* Pass classes with copy ctors by invisible reference. */
7301 if (TREE_ADDRESSABLE (type
))
7303 type
= build_reference_type (type
);
7304 /* There are no other pointers to this temporary. */
7305 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
7307 else if (targetm
.calls
.promote_prototypes (type
)
7308 && INTEGRAL_TYPE_P (type
)
7309 && COMPLETE_TYPE_P (type
)
7310 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
7311 type
= integer_type_node
;
7316 /* Actually perform the appropriate conversion. */
7319 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
7323 /* If VAL is a bitfield, then -- since it has already been converted
7324 to TYPE -- it cannot have a precision greater than TYPE.
7326 If it has a smaller precision, we must widen it here. For
7327 example, passing "int f:3;" to a function expecting an "int" will
7328 not result in any conversion before this point.
7330 If the precision is the same we must not risk widening. For
7331 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
7332 often have type "int", even though the C++ type for the field is
7333 "long long". If the value is being passed to a function
7334 expecting an "int", then no conversions will be required. But,
7335 if we call convert_bitfield_to_declared_type, the bitfield will
7336 be converted to "long long". */
7337 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
7339 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
7340 val
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
), val
);
7342 if (val
== error_mark_node
)
7344 /* Pass classes with copy ctors by invisible reference. */
7345 else if (TREE_ADDRESSABLE (type
))
7346 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
7347 else if (targetm
.calls
.promote_prototypes (type
)
7348 && INTEGRAL_TYPE_P (type
)
7349 && COMPLETE_TYPE_P (type
)
7350 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
7351 val
= cp_perform_integral_promotions (val
, complain
);
7352 if ((complain
& tf_warning
)
7353 && warn_suggest_attribute_format
)
7355 tree rhstype
= TREE_TYPE (val
);
7356 const enum tree_code coder
= TREE_CODE (rhstype
);
7357 const enum tree_code codel
= TREE_CODE (type
);
7358 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
7360 && check_missing_format_attribute (type
, rhstype
))
7361 warning (OPT_Wsuggest_attribute_format
,
7362 "argument of function call might be a candidate for a format attribute");
7367 /* Returns non-zero iff FN is a function with magic varargs, i.e. ones for
7368 which just decay_conversion or no conversions at all should be done.
7369 This is true for some builtins which don't act like normal functions.
7370 Return 2 if no conversions at all should be done, 1 if just
7371 decay_conversion. Return 3 for special treatment of the 3rd argument
7372 for __builtin_*_overflow_p. */
7375 magic_varargs_p (tree fn
)
7377 if (flag_cilkplus
&& is_cilkplus_reduce_builtin (fn
) != BUILT_IN_NONE
)
7380 if (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
7381 switch (DECL_FUNCTION_CODE (fn
))
7383 case BUILT_IN_CLASSIFY_TYPE
:
7384 case BUILT_IN_CONSTANT_P
:
7385 case BUILT_IN_NEXT_ARG
:
7386 case BUILT_IN_VA_START
:
7389 case BUILT_IN_ADD_OVERFLOW_P
:
7390 case BUILT_IN_SUB_OVERFLOW_P
:
7391 case BUILT_IN_MUL_OVERFLOW_P
:
7395 return lookup_attribute ("type generic",
7396 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
7402 /* Returns the decl of the dispatcher function if FN is a function version. */
7405 get_function_version_dispatcher (tree fn
)
7407 tree dispatcher_decl
= NULL
;
7409 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
7410 && DECL_FUNCTION_VERSIONED (fn
));
7412 gcc_assert (targetm
.get_function_versions_dispatcher
);
7413 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
7415 if (dispatcher_decl
== NULL
)
7417 error_at (input_location
, "use of multiversioned function "
7418 "without a default");
7422 retrofit_lang_decl (dispatcher_decl
);
7423 gcc_assert (dispatcher_decl
!= NULL
);
7424 return dispatcher_decl
;
7427 /* fn is a function version dispatcher that is marked used. Mark all the
7428 semantically identical function versions it will dispatch as used. */
7431 mark_versions_used (tree fn
)
7433 struct cgraph_node
*node
;
7434 struct cgraph_function_version_info
*node_v
;
7435 struct cgraph_function_version_info
*it_v
;
7437 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
7439 node
= cgraph_node::get (fn
);
7443 gcc_assert (node
->dispatcher_function
);
7445 node_v
= node
->function_version ();
7449 /* All semantically identical versions are chained. Traverse and mark each
7450 one of them as used. */
7451 it_v
= node_v
->next
;
7452 while (it_v
!= NULL
)
7454 mark_used (it_v
->this_node
->decl
);
7459 /* Build a call to "the copy constructor" for the type of A, even if it
7460 wouldn't be selected by normal overload resolution. Used for
7464 call_copy_ctor (tree a
, tsubst_flags_t complain
)
7466 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
7467 tree binfo
= TYPE_BINFO (ctype
);
7468 tree copy
= get_copy_ctor (ctype
, complain
);
7469 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
7470 tree ob
= build_dummy_object (ctype
);
7471 vec
<tree
, va_gc
>* args
= make_tree_vector_single (a
);
7472 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
7473 LOOKUP_NORMAL
, NULL
, complain
);
7474 release_tree_vector (args
);
7478 /* Return true iff T refers to a base field. */
7481 is_base_field_ref (tree t
)
7484 if (TREE_CODE (t
) == ADDR_EXPR
)
7485 t
= TREE_OPERAND (t
, 0);
7486 if (TREE_CODE (t
) == COMPONENT_REF
)
7487 t
= TREE_OPERAND (t
, 1);
7488 if (TREE_CODE (t
) == FIELD_DECL
)
7489 return DECL_FIELD_IS_BASE (t
);
7493 /* We can't elide a copy from a function returning by value to a base
7494 subobject, as the callee might clobber tail padding. Return true iff this
7495 could be that case. */
7498 unsafe_copy_elision_p (tree target
, tree exp
)
7500 /* Copy elision only happens with a TARGET_EXPR. */
7501 if (TREE_CODE (exp
) != TARGET_EXPR
)
7503 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
7504 /* It's safe to elide the copy for a class with no tail padding. */
7505 if (tree_int_cst_equal (TYPE_SIZE (type
), CLASSTYPE_SIZE (type
)))
7507 /* It's safe to elide the copy if we aren't initializing a base object. */
7508 if (!is_base_field_ref (target
))
7510 tree init
= TARGET_EXPR_INITIAL (exp
);
7511 /* build_compound_expr pushes COMPOUND_EXPR inside TARGET_EXPR. */
7512 while (TREE_CODE (init
) == COMPOUND_EXPR
)
7513 init
= TREE_OPERAND (init
, 1);
7514 return (TREE_CODE (init
) == AGGR_INIT_EXPR
7515 && !AGGR_INIT_VIA_CTOR_P (init
));
7518 /* Subroutine of the various build_*_call functions. Overload resolution
7519 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
7520 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
7521 bitmask of various LOOKUP_* flags which apply to the call itself. */
7524 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
7527 const vec
<tree
, va_gc
> *args
= cand
->args
;
7528 tree first_arg
= cand
->first_arg
;
7529 conversion
**convs
= cand
->convs
;
7531 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7536 unsigned int arg_index
= 0;
7540 bool already_used
= false;
7542 /* In a template, there is no need to perform all of the work that
7543 is normally done. We are only interested in the type of the call
7544 expression, i.e., the return type of the function. Any semantic
7545 errors will be deferred until the template is instantiated. */
7546 if (processing_template_decl
)
7550 const tree
*argarray
;
7553 return_type
= TREE_TYPE (TREE_TYPE (fn
));
7554 nargs
= vec_safe_length (args
);
7555 if (first_arg
== NULL_TREE
)
7556 argarray
= args
->address ();
7564 alcarray
= XALLOCAVEC (tree
, nargs
);
7565 alcarray
[0] = build_this (first_arg
);
7566 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
7567 alcarray
[ix
+ 1] = arg
;
7568 argarray
= alcarray
;
7571 addr
= build_addr_func (fn
, complain
);
7572 if (addr
== error_mark_node
)
7573 return error_mark_node
;
7574 expr
= build_call_array_loc (input_location
, return_type
,
7575 addr
, nargs
, argarray
);
7576 if (TREE_THIS_VOLATILE (fn
) && cfun
)
7577 current_function_returns_abnormally
= 1;
7578 return convert_from_reference (expr
);
7581 /* Give any warnings we noticed during overload resolution. */
7582 if (cand
->warnings
&& (complain
& tf_warning
))
7584 struct candidate_warning
*w
;
7585 for (w
= cand
->warnings
; w
; w
= w
->next
)
7586 joust (cand
, w
->loser
, 1, complain
);
7589 /* OK, we're actually calling this inherited constructor; set its deletedness
7590 appropriately. We can get away with doing this here because calling is
7591 the only way to refer to a constructor. */
7592 if (DECL_INHERITED_CTOR (fn
))
7593 deduce_inheriting_ctor (fn
);
7595 /* Make =delete work with SFINAE. */
7596 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7597 return error_mark_node
;
7599 if (DECL_FUNCTION_MEMBER_P (fn
))
7602 /* If FN is a template function, two cases must be considered.
7607 template <class T> void f();
7609 template <class T> struct B {
7613 struct C : A, B<int> {
7615 using B<int>::g; // #2
7618 In case #1 where `A::f' is a member template, DECL_ACCESS is
7619 recorded in the primary template but not in its specialization.
7620 We check access of FN using its primary template.
7622 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
7623 because it is a member of class template B, DECL_ACCESS is
7624 recorded in the specialization `B<int>::g'. We cannot use its
7625 primary template because `B<T>::g' and `B<int>::g' may have
7626 different access. */
7627 if (DECL_TEMPLATE_INFO (fn
)
7628 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
7629 access_fn
= DECL_TI_TEMPLATE (fn
);
7632 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
7634 return error_mark_node
;
7637 /* If we're checking for implicit delete, don't bother with argument
7639 if (flags
& LOOKUP_SPECULATIVE
)
7641 if (DECL_DELETED_FN (fn
))
7643 if (complain
& tf_error
)
7645 return error_mark_node
;
7647 if (cand
->viable
== 1)
7649 else if (!(complain
& tf_error
))
7650 /* Reject bad conversions now. */
7651 return error_mark_node
;
7652 /* else continue to get conversion error. */
7655 /* N3276 magic doesn't apply to nested calls. */
7656 int decltype_flag
= (complain
& tf_decltype
);
7657 complain
&= ~tf_decltype
;
7659 /* Find maximum size of vector to hold converted arguments. */
7660 parmlen
= list_length (parm
);
7661 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
7662 if (parmlen
> nargs
)
7664 argarray
= XALLOCAVEC (tree
, nargs
);
7666 /* The implicit parameters to a constructor are not considered by overload
7667 resolution, and must be of the proper type. */
7668 if (DECL_CONSTRUCTOR_P (fn
))
7671 if (first_arg
!= NULL_TREE
)
7673 object_arg
= first_arg
;
7674 first_arg
= NULL_TREE
;
7678 object_arg
= (*args
)[arg_index
];
7681 argarray
[j
++] = build_this (object_arg
);
7682 parm
= TREE_CHAIN (parm
);
7683 /* We should never try to call the abstract constructor. */
7684 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
7686 if (DECL_HAS_VTT_PARM_P (fn
))
7688 argarray
[j
++] = (*args
)[arg_index
];
7690 parm
= TREE_CHAIN (parm
);
7693 /* Bypass access control for 'this' parameter. */
7694 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7696 tree parmtype
= TREE_VALUE (parm
);
7697 tree arg
= build_this (first_arg
!= NULL_TREE
7699 : (*args
)[arg_index
]);
7700 tree argtype
= TREE_TYPE (arg
);
7704 if (convs
[i
]->bad_p
)
7706 if (complain
& tf_error
)
7708 if (permerror (input_location
, "passing %qT as %<this%> "
7709 "argument discards qualifiers",
7710 TREE_TYPE (argtype
)))
7711 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
7714 return error_mark_node
;
7717 /* See if the function member or the whole class type is declared
7718 final and the call can be devirtualized. */
7719 if (DECL_FINAL_P (fn
)
7720 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
7721 flags
|= LOOKUP_NONVIRTUAL
;
7723 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
7724 X is called for an object that is not of type X, or of a type
7725 derived from X, the behavior is undefined.
7727 So we can assume that anything passed as 'this' is non-null, and
7728 optimize accordingly. */
7729 gcc_assert (TYPE_PTR_P (parmtype
));
7730 /* Convert to the base in which the function was declared. */
7731 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
7732 converted_arg
= build_base_path (PLUS_EXPR
,
7734 cand
->conversion_path
,
7736 /* Check that the base class is accessible. */
7737 if (!accessible_base_p (TREE_TYPE (argtype
),
7738 BINFO_TYPE (cand
->conversion_path
), true))
7740 if (complain
& tf_error
)
7741 error ("%qT is not an accessible base of %qT",
7742 BINFO_TYPE (cand
->conversion_path
),
7743 TREE_TYPE (argtype
));
7745 return error_mark_node
;
7747 /* If fn was found by a using declaration, the conversion path
7748 will be to the derived class, not the base declaring fn. We
7749 must convert from derived to base. */
7750 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
7751 TREE_TYPE (parmtype
), ba_unique
,
7753 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
7754 base_binfo
, 1, complain
);
7756 argarray
[j
++] = converted_arg
;
7757 parm
= TREE_CHAIN (parm
);
7758 if (first_arg
!= NULL_TREE
)
7759 first_arg
= NULL_TREE
;
7766 gcc_assert (first_arg
== NULL_TREE
);
7767 for (; arg_index
< vec_safe_length (args
) && parm
;
7768 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
7770 tree type
= TREE_VALUE (parm
);
7771 tree arg
= (*args
)[arg_index
];
7772 bool conversion_warning
= true;
7776 /* If the argument is NULL and used to (implicitly) instantiate a
7777 template function (and bind one of the template arguments to
7778 the type of 'long int'), we don't want to warn about passing NULL
7779 to non-pointer argument.
7780 For example, if we have this template function:
7782 template<typename T> void func(T x) {}
7784 we want to warn (when -Wconversion is enabled) in this case:
7790 but not in this case:
7796 if (arg
== null_node
7797 && DECL_TEMPLATE_INFO (fn
)
7798 && cand
->template_decl
7799 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
7800 conversion_warning
= false;
7802 /* Warn about initializer_list deduction that isn't currently in the
7804 if (cxx_dialect
> cxx98
7805 && flag_deduce_init_list
7806 && cand
->template_decl
7807 && is_std_init_list (non_reference (type
))
7808 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
7810 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
7811 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
7812 tree patparm
= get_pattern_parm (realparm
, tmpl
);
7813 tree pattype
= TREE_TYPE (patparm
);
7814 if (PACK_EXPANSION_P (pattype
))
7815 pattype
= PACK_EXPANSION_PATTERN (pattype
);
7816 pattype
= non_reference (pattype
);
7818 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
7819 && (cand
->explicit_targs
== NULL_TREE
7820 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
7821 <= TEMPLATE_TYPE_IDX (pattype
))))
7823 pedwarn (input_location
, 0, "deducing %qT as %qT",
7824 non_reference (TREE_TYPE (patparm
)),
7825 non_reference (type
));
7826 pedwarn (DECL_SOURCE_LOCATION (cand
->fn
), 0,
7827 " in call to %qD", cand
->fn
);
7828 pedwarn (input_location
, 0,
7829 " (you can disable this with -fno-deduce-init-list)");
7833 /* Set user_conv_p on the argument conversions, so rvalue/base handling
7834 knows not to allow any more UDCs. This needs to happen after we
7835 process cand->warnings. */
7836 if (flags
& LOOKUP_NO_CONVERSION
)
7837 conv
->user_conv_p
= true;
7839 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
7842 : complain
& (~tf_warning
));
7844 val
= convert_for_arg_passing (type
, val
, complain
);
7846 if (val
== error_mark_node
)
7847 return error_mark_node
;
7849 argarray
[j
++] = val
;
7852 /* Default arguments */
7853 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
7855 if (TREE_VALUE (parm
) == error_mark_node
)
7856 return error_mark_node
;
7857 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
7858 TREE_PURPOSE (parm
),
7864 int magic
= magic_varargs_p (fn
);
7865 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
7867 tree a
= (*args
)[arg_index
];
7868 if ((magic
== 3 && arg_index
== 2) || magic
== 2)
7870 /* Do no conversions for certain magic varargs. */
7871 a
= mark_type_use (a
);
7872 if (TREE_CODE (a
) == FUNCTION_DECL
&& reject_gcc_builtin (a
))
7873 return error_mark_node
;
7875 else if (magic
!= 0)
7876 /* For other magic varargs only do decay_conversion. */
7877 a
= decay_conversion (a
, complain
);
7878 else if (DECL_CONSTRUCTOR_P (fn
)
7879 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
7882 /* Avoid infinite recursion trying to call A(...). */
7883 if (complain
& tf_error
)
7884 /* Try to call the actual copy constructor for a good error. */
7885 call_copy_ctor (a
, complain
);
7886 return error_mark_node
;
7889 a
= convert_arg_to_ellipsis (a
, complain
);
7890 if (a
== error_mark_node
)
7891 return error_mark_node
;
7895 gcc_assert (j
<= nargs
);
7898 /* Avoid to do argument-transformation, if warnings for format, and for
7899 nonnull are disabled. Just in case that at least one of them is active
7900 the check_function_arguments function might warn about something. */
7902 bool warned_p
= false;
7903 if (warn_nonnull
|| warn_format
|| warn_suggest_attribute_format
)
7905 tree
*fargs
= (!nargs
? argarray
7906 : (tree
*) alloca (nargs
* sizeof (tree
)));
7907 for (j
= 0; j
< nargs
; j
++)
7908 fargs
[j
] = maybe_constant_value (argarray
[j
]);
7910 warned_p
= check_function_arguments (input_location
, TREE_TYPE (fn
),
7914 if (DECL_INHERITED_CTOR (fn
))
7916 /* Check for passing ellipsis arguments to an inherited constructor. We
7917 could handle this by open-coding the inherited constructor rather than
7918 defining it, but let's not bother now. */
7919 if (!cp_unevaluated_operand
7921 && cand
->convs
[cand
->num_convs
-1]->ellipsis_p
)
7923 if (complain
& tf_error
)
7925 sorry ("passing arguments to ellipsis of inherited constructor "
7927 inform (DECL_SOURCE_LOCATION (cand
->fn
), "declared here");
7929 return error_mark_node
;
7932 /* A base constructor inheriting from a virtual base doesn't get the
7933 inherited arguments, just this and __vtt. */
7934 if (ctor_omit_inherited_parms (fn
))
7938 /* Avoid actually calling copy constructors and copy assignment operators,
7941 if (! flag_elide_constructors
)
7942 /* Do things the hard way. */;
7943 else if (cand
->num_convs
== 1
7944 && (DECL_COPY_CONSTRUCTOR_P (fn
)
7945 || DECL_MOVE_CONSTRUCTOR_P (fn
))
7946 /* It's unsafe to elide the constructor when handling
7947 a noexcept-expression, it may evaluate to the wrong
7948 value (c++/53025). */
7949 && cp_noexcept_operand
== 0)
7952 tree arg
= argarray
[num_artificial_parms_for (fn
)];
7954 bool trivial
= trivial_fn_p (fn
);
7956 /* Pull out the real argument, disregarding const-correctness. */
7958 while (CONVERT_EXPR_P (targ
)
7959 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
7960 targ
= TREE_OPERAND (targ
, 0);
7961 if (TREE_CODE (targ
) == ADDR_EXPR
)
7963 targ
= TREE_OPERAND (targ
, 0);
7964 if (!same_type_ignoring_top_level_qualifiers_p
7965 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
7974 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7976 /* In C++17 we shouldn't be copying a TARGET_EXPR except into a base
7978 if (CHECKING_P
&& cxx_dialect
>= cxx1z
)
7979 gcc_assert (TREE_CODE (arg
) != TARGET_EXPR
7981 /* See unsafe_copy_elision_p. */
7982 || DECL_BASE_CONSTRUCTOR_P (fn
));
7984 /* [class.copy]: the copy constructor is implicitly defined even if
7985 the implementation elided its use. */
7986 if (!trivial
|| DECL_DELETED_FN (fn
))
7988 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7989 return error_mark_node
;
7990 already_used
= true;
7993 /* If we're creating a temp and we already have one, don't create a
7994 new one. If we're not creating a temp but we get one, use
7995 INIT_EXPR to collapse the temp into our target. Otherwise, if the
7996 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
7997 temp or an INIT_EXPR otherwise. */
7999 if (is_dummy_object (fa
))
8001 if (TREE_CODE (arg
) == TARGET_EXPR
)
8004 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
8006 else if ((trivial
|| TREE_CODE (arg
) == TARGET_EXPR
)
8007 && !unsafe_copy_elision_p (fa
, arg
))
8009 tree to
= cp_stabilize_reference (cp_build_indirect_ref (fa
,
8013 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
8017 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
8018 && trivial_fn_p (fn
)
8019 && !DECL_DELETED_FN (fn
))
8021 tree to
= cp_stabilize_reference
8022 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
8023 tree type
= TREE_TYPE (to
);
8024 tree as_base
= CLASSTYPE_AS_BASE (type
);
8025 tree arg
= argarray
[1];
8027 if (is_really_empty_class (type
))
8029 /* Avoid copying empty classes. */
8030 val
= build2 (COMPOUND_EXPR
, type
, arg
, to
);
8031 TREE_NO_WARNING (val
) = 1;
8033 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
8035 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
8036 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
8040 /* We must only copy the non-tail padding parts. */
8042 tree array_type
, alias_set
;
8044 arg2
= TYPE_SIZE_UNIT (as_base
);
8045 arg0
= cp_build_addr_expr (to
, complain
);
8047 array_type
= build_array_type (unsigned_char_type_node
,
8049 (size_binop (MINUS_EXPR
,
8050 arg2
, size_int (1))));
8051 alias_set
= build_int_cst (build_pointer_type (type
), 0);
8052 t
= build2 (MODIFY_EXPR
, void_type_node
,
8053 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
8054 build2 (MEM_REF
, array_type
, arg
, alias_set
));
8055 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
8056 TREE_NO_WARNING (val
) = 1;
8061 else if (!DECL_DELETED_FN (fn
)
8062 && trivial_fn_p (fn
))
8064 if (DECL_DESTRUCTOR_P (fn
))
8065 return fold_convert (void_type_node
, argarray
[0]);
8066 else if (default_ctor_p (fn
))
8068 if (is_dummy_object (argarray
[0]))
8069 return force_target_expr (DECL_CONTEXT (fn
), void_node
, complain
);
8071 return cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
);
8075 /* For calls to a multi-versioned function, overload resolution
8076 returns the function with the highest target priority, that is,
8077 the version that will checked for dispatching first. If this
8078 version is inlinable, a direct call to this version can be made
8079 otherwise the call should go through the dispatcher. */
8081 if (DECL_FUNCTION_VERSIONED (fn
)
8082 && (current_function_decl
== NULL
8083 || !targetm
.target_option
.can_inline_p (current_function_decl
, fn
)))
8085 fn
= get_function_version_dispatcher (fn
);
8089 mark_versions_used (fn
);
8093 && !mark_used (fn
, complain
))
8094 return error_mark_node
;
8096 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
8097 /* Don't mess with virtual lookup in instantiate_non_dependent_expr;
8098 virtual functions can't be constexpr. */
8099 && !in_template_function ())
8102 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
8104 ba_any
, NULL
, complain
);
8105 gcc_assert (binfo
&& binfo
!= error_mark_node
);
8107 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
8109 if (TREE_SIDE_EFFECTS (argarray
[0]))
8110 argarray
[0] = save_expr (argarray
[0]);
8111 t
= build_pointer_type (TREE_TYPE (fn
));
8112 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
8117 fn
= build_addr_func (fn
, complain
);
8118 if (fn
== error_mark_node
)
8119 return error_mark_node
;
8122 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
8123 if (call
== error_mark_node
)
8125 if (cand
->flags
& LOOKUP_LIST_INIT_CTOR
)
8127 tree c
= extract_call_expr (call
);
8128 /* build_new_op_1 will clear this when appropriate. */
8129 CALL_EXPR_ORDERED_ARGS (c
) = true;
8133 tree c
= extract_call_expr (call
);
8134 if (TREE_CODE (c
) == CALL_EXPR
)
8135 TREE_NO_WARNING (c
) = 1;
8140 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
8141 This function performs no overload resolution, conversion, or other
8142 high-level operations. */
8145 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
8146 tsubst_flags_t complain
)
8150 /* Remember roughly where this call is. */
8151 location_t loc
= EXPR_LOC_OR_LOC (fn
, input_location
);
8152 fn
= build_call_a (fn
, nargs
, argarray
);
8153 SET_EXPR_LOCATION (fn
, loc
);
8155 fndecl
= get_callee_fndecl (fn
);
8157 /* Check that arguments to builtin functions match the expectations. */
8159 && DECL_BUILT_IN (fndecl
)
8160 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
8164 /* We need to take care that values to BUILT_IN_NORMAL
8166 for (i
= 0; i
< nargs
; i
++)
8167 argarray
[i
] = fold_non_dependent_expr (argarray
[i
]);
8169 if (!check_builtin_function_arguments (EXPR_LOCATION (fn
), vNULL
, fndecl
,
8171 return error_mark_node
;
8174 /* If it is a built-in array notation function, then the return type of
8175 the function is the element type of the array passed in as array
8176 notation (i.e. the first parameter of the function). */
8177 if (flag_cilkplus
&& TREE_CODE (fn
) == CALL_EXPR
)
8179 enum built_in_function bif
=
8180 is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn
));
8181 if (bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
8182 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
8183 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
8184 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
8185 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE
8186 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
8188 if (call_expr_nargs (fn
) == 0)
8190 error_at (EXPR_LOCATION (fn
), "Invalid builtin arguments");
8191 return error_mark_node
;
8193 /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or
8194 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or
8195 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or
8196 BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or
8197 BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or
8198 BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
8199 The pre-defined return-type is the correct one. */
8200 tree array_ntn
= CALL_EXPR_ARG (fn
, 0);
8201 TREE_TYPE (fn
) = TREE_TYPE (array_ntn
);
8206 if (VOID_TYPE_P (TREE_TYPE (fn
)))
8209 /* 5.2.2/11: If a function call is a prvalue of object type: if the
8210 function call is either the operand of a decltype-specifier or the
8211 right operand of a comma operator that is the operand of a
8212 decltype-specifier, a temporary object is not introduced for the
8213 prvalue. The type of the prvalue may be incomplete. */
8214 if (!(complain
& tf_decltype
))
8216 fn
= require_complete_type_sfinae (fn
, complain
);
8217 if (fn
== error_mark_node
)
8218 return error_mark_node
;
8220 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
8221 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
8223 return convert_from_reference (fn
);
8226 /* Returns the value to use for the in-charge parameter when making a
8227 call to a function with the indicated NAME.
8229 FIXME:Can't we find a neater way to do this mapping? */
8232 in_charge_arg_for_name (tree name
)
8234 if (name
== base_ctor_identifier
8235 || name
== base_dtor_identifier
)
8236 return integer_zero_node
;
8237 else if (name
== complete_ctor_identifier
)
8238 return integer_one_node
;
8239 else if (name
== complete_dtor_identifier
)
8240 return integer_two_node
;
8241 else if (name
== deleting_dtor_identifier
)
8242 return integer_three_node
;
8244 /* This function should only be called with one of the names listed
8250 /* We've built up a constructor call RET. Complain if it delegates to the
8251 constructor we're currently compiling. */
8254 check_self_delegation (tree ret
)
8256 if (TREE_CODE (ret
) == TARGET_EXPR
)
8257 ret
= TARGET_EXPR_INITIAL (ret
);
8258 tree fn
= cp_get_callee_fndecl (ret
);
8259 if (fn
&& DECL_ABSTRACT_ORIGIN (fn
) == current_function_decl
)
8260 error ("constructor delegates to itself");
8263 /* Build a call to a constructor, destructor, or an assignment
8264 operator for INSTANCE, an expression with class type. NAME
8265 indicates the special member function to call; *ARGS are the
8266 arguments. ARGS may be NULL. This may change ARGS. BINFO
8267 indicates the base of INSTANCE that is to be passed as the `this'
8268 parameter to the member function called.
8270 FLAGS are the LOOKUP_* flags to use when processing the call.
8272 If NAME indicates a complete object constructor, INSTANCE may be
8273 NULL_TREE. In this case, the caller will call build_cplus_new to
8274 store the newly constructed object into a VAR_DECL. */
8277 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
8278 tree binfo
, int flags
, tsubst_flags_t complain
)
8281 /* The type of the subobject to be constructed or destroyed. */
8283 vec
<tree
, va_gc
> *allocated
= NULL
;
8286 gcc_assert (name
== complete_ctor_identifier
8287 || name
== base_ctor_identifier
8288 || name
== complete_dtor_identifier
8289 || name
== base_dtor_identifier
8290 || name
== deleting_dtor_identifier
8291 || name
== cp_assignment_operator_id (NOP_EXPR
));
8294 /* Resolve the name. */
8295 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
8296 return error_mark_node
;
8298 binfo
= TYPE_BINFO (binfo
);
8301 gcc_assert (binfo
!= NULL_TREE
);
8303 class_type
= BINFO_TYPE (binfo
);
8305 /* Handle the special case where INSTANCE is NULL_TREE. */
8306 if (name
== complete_ctor_identifier
&& !instance
)
8307 instance
= build_dummy_object (class_type
);
8310 if (name
== complete_dtor_identifier
8311 || name
== base_dtor_identifier
8312 || name
== deleting_dtor_identifier
)
8313 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
8315 /* Convert to the base class, if necessary. */
8316 if (!same_type_ignoring_top_level_qualifiers_p
8317 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
8319 if (name
!= cp_assignment_operator_id (NOP_EXPR
))
8320 /* For constructors and destructors, either the base is
8321 non-virtual, or it is virtual but we are doing the
8322 conversion from a constructor or destructor for the
8323 complete object. In either case, we can convert
8325 instance
= convert_to_base_statically (instance
, binfo
);
8327 /* However, for assignment operators, we must convert
8328 dynamically if the base is virtual. */
8329 instance
= build_base_path (PLUS_EXPR
, instance
,
8330 binfo
, /*nonnull=*/1, complain
);
8334 gcc_assert (instance
!= NULL_TREE
);
8336 /* In C++17, "If the initializer expression is a prvalue and the
8337 cv-unqualified version of the source type is the same class as the class
8338 of the destination, the initializer expression is used to initialize the
8339 destination object." Handle that here to avoid doing overload
8341 if (cxx_dialect
>= cxx1z
8342 && args
&& vec_safe_length (*args
) == 1
8343 && name
== complete_ctor_identifier
)
8345 tree arg
= (**args
)[0];
8347 /* FIXME P0135 doesn't say how to handle direct initialization from a
8348 type with a suitable conversion operator. Let's handle it like
8349 copy-initialization, but allowing explict conversions. */
8350 if (!reference_related_p (class_type
, TREE_TYPE (arg
)))
8351 arg
= perform_implicit_conversion_flags (class_type
, arg
,
8353 if ((TREE_CODE (arg
) == TARGET_EXPR
8354 || TREE_CODE (arg
) == CONSTRUCTOR
)
8355 && (same_type_ignoring_top_level_qualifiers_p
8356 (class_type
, TREE_TYPE (arg
))))
8358 if (is_dummy_object (instance
))
8360 if ((complain
& tf_error
)
8361 && (flags
& LOOKUP_DELEGATING_CONS
))
8362 check_self_delegation (arg
);
8363 /* Avoid change of behavior on Wunused-var-2.C. */
8364 mark_lvalue_use (instance
);
8365 return build2 (INIT_EXPR
, class_type
, instance
, arg
);
8369 fns
= lookup_fnfields (binfo
, name
, 1);
8371 /* When making a call to a constructor or destructor for a subobject
8372 that uses virtual base classes, pass down a pointer to a VTT for
8374 if ((name
== base_ctor_identifier
8375 || name
== base_dtor_identifier
)
8376 && CLASSTYPE_VBASECLASSES (class_type
))
8381 /* If the current function is a complete object constructor
8382 or destructor, then we fetch the VTT directly.
8383 Otherwise, we look it up using the VTT we were given. */
8384 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
8385 vtt
= decay_conversion (vtt
, complain
);
8386 if (vtt
== error_mark_node
)
8387 return error_mark_node
;
8388 vtt
= build_if_in_charge (vtt
, current_vtt_parm
);
8389 if (BINFO_SUBVTT_INDEX (binfo
))
8390 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
8396 allocated
= make_tree_vector ();
8400 vec_safe_insert (*args
, 0, sub_vtt
);
8403 ret
= build_new_method_call (instance
, fns
, args
,
8404 TYPE_BINFO (BINFO_TYPE (binfo
)),
8408 if (allocated
!= NULL
)
8409 release_tree_vector (allocated
);
8411 if ((complain
& tf_error
)
8412 && (flags
& LOOKUP_DELEGATING_CONS
)
8413 && name
== complete_ctor_identifier
)
8414 check_self_delegation (ret
);
8419 /* Return the NAME, as a C string. The NAME indicates a function that
8420 is a member of TYPE. *FREE_P is set to true if the caller must
8421 free the memory returned.
8423 Rather than go through all of this, we should simply set the names
8424 of constructors and destructors appropriately, and dispense with
8425 ctor_identifier, dtor_identifier, etc. */
8428 name_as_c_string (tree name
, tree type
, bool *free_p
)
8432 /* Assume that we will not allocate memory. */
8434 /* Constructors and destructors are special. */
8435 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
8438 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
8439 /* For a destructor, add the '~'. */
8440 if (name
== complete_dtor_identifier
8441 || name
== base_dtor_identifier
8442 || name
== deleting_dtor_identifier
)
8444 pretty_name
= concat ("~", pretty_name
, NULL
);
8445 /* Remember that we need to free the memory allocated. */
8449 else if (IDENTIFIER_TYPENAME_P (name
))
8451 pretty_name
= concat ("operator ",
8452 type_as_string_translate (TREE_TYPE (name
),
8453 TFF_PLAIN_IDENTIFIER
),
8455 /* Remember that we need to free the memory allocated. */
8459 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
8464 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
8465 be set, upon return, to the function called. ARGS may be NULL.
8466 This may change ARGS. */
8469 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8470 tree conversion_path
, int flags
,
8471 tree
*fn_p
, tsubst_flags_t complain
)
8473 struct z_candidate
*candidates
= 0, *cand
;
8474 tree explicit_targs
= NULL_TREE
;
8475 tree basetype
= NULL_TREE
;
8476 tree access_binfo
, binfo
;
8478 tree first_mem_arg
= NULL_TREE
;
8480 bool skip_first_for_error
;
8481 vec
<tree
, va_gc
> *user_args
;
8484 int template_only
= 0;
8488 vec
<tree
, va_gc
> *orig_args
= NULL
;
8491 gcc_assert (instance
!= NULL_TREE
);
8493 /* We don't know what function we're going to call, yet. */
8497 if (error_operand_p (instance
)
8498 || !fns
|| error_operand_p (fns
))
8499 return error_mark_node
;
8501 if (!BASELINK_P (fns
))
8503 if (complain
& tf_error
)
8504 error ("call to non-function %qD", fns
);
8505 return error_mark_node
;
8508 orig_instance
= instance
;
8511 /* Dismantle the baselink to collect all the information we need. */
8512 if (!conversion_path
)
8513 conversion_path
= BASELINK_BINFO (fns
);
8514 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
8515 binfo
= BASELINK_BINFO (fns
);
8516 optype
= BASELINK_OPTYPE (fns
);
8517 fns
= BASELINK_FUNCTIONS (fns
);
8518 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
8520 explicit_targs
= TREE_OPERAND (fns
, 1);
8521 fns
= TREE_OPERAND (fns
, 0);
8524 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
8525 || TREE_CODE (fns
) == TEMPLATE_DECL
8526 || TREE_CODE (fns
) == OVERLOAD
);
8527 fn
= get_first_fn (fns
);
8528 name
= DECL_NAME (fn
);
8530 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
8531 gcc_assert (CLASS_TYPE_P (basetype
));
8533 if (processing_template_decl
)
8535 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
8536 instance
= build_non_dependent_expr (instance
);
8538 make_args_non_dependent (*args
);
8541 user_args
= args
== NULL
? NULL
: *args
;
8542 /* Under DR 147 A::A() is an invalid constructor call,
8543 not a functional cast. */
8544 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
8546 if (! (complain
& tf_error
))
8547 return error_mark_node
;
8549 if (permerror (input_location
,
8550 "cannot call constructor %<%T::%D%> directly",
8552 inform (input_location
, "for a function-style cast, remove the "
8553 "redundant %<::%D%>", name
);
8554 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
8559 /* Figure out whether to skip the first argument for the error
8560 message we will display to users if an error occurs. We don't
8561 want to display any compiler-generated arguments. The "this"
8562 pointer hasn't been added yet. However, we must remove the VTT
8563 pointer if this is a call to a base-class constructor or
8565 skip_first_for_error
= false;
8566 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
8568 /* Callers should explicitly indicate whether they want to construct
8569 the complete object or just the part without virtual bases. */
8570 gcc_assert (name
!= ctor_identifier
);
8571 /* Similarly for destructors. */
8572 gcc_assert (name
!= dtor_identifier
);
8573 /* Remove the VTT pointer, if present. */
8574 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
8575 && CLASSTYPE_VBASECLASSES (basetype
))
8576 skip_first_for_error
= true;
8579 /* Process the argument list. */
8580 if (args
!= NULL
&& *args
!= NULL
)
8582 *args
= resolve_args (*args
, complain
);
8584 return error_mark_node
;
8587 /* Consider the object argument to be used even if we end up selecting a
8588 static member function. */
8589 instance
= mark_type_use (instance
);
8591 /* It's OK to call destructors and constructors on cv-qualified objects.
8592 Therefore, convert the INSTANCE to the unqualified type, if
8594 if (DECL_DESTRUCTOR_P (fn
)
8595 || DECL_CONSTRUCTOR_P (fn
))
8597 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
8599 instance
= build_this (instance
);
8600 instance
= build_nop (build_pointer_type (basetype
), instance
);
8601 instance
= build_fold_indirect_ref (instance
);
8604 if (DECL_DESTRUCTOR_P (fn
))
8605 name
= complete_dtor_identifier
;
8607 /* For the overload resolution we need to find the actual `this`
8608 that would be captured if the call turns out to be to a
8609 non-static member function. Do not actually capture it at this
8611 if (DECL_CONSTRUCTOR_P (fn
))
8612 /* Constructors don't use the enclosing 'this'. */
8613 first_mem_arg
= instance
;
8615 first_mem_arg
= maybe_resolve_dummy (instance
, false);
8617 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8618 p
= conversion_obstack_alloc (0);
8620 /* The number of arguments artificial parms in ARGS; we subtract one because
8621 there's no 'this' in ARGS. */
8622 unsigned skip
= num_artificial_parms_for (fn
) - 1;
8624 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
8625 initializer, not T({ }). */
8626 if (DECL_CONSTRUCTOR_P (fn
)
8627 && vec_safe_length (user_args
) > skip
8628 && DIRECT_LIST_INIT_P ((*user_args
)[skip
]))
8630 tree init_list
= (*user_args
)[skip
];
8631 tree init
= NULL_TREE
;
8633 gcc_assert (user_args
->length () == skip
+ 1
8634 && !(flags
& LOOKUP_ONLYCONVERTING
));
8636 /* If the initializer list has no elements and T is a class type with
8637 a default constructor, the object is value-initialized. Handle
8638 this here so we don't need to handle it wherever we use
8639 build_special_member_call. */
8640 if (CONSTRUCTOR_NELTS (init_list
) == 0
8641 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
8642 /* For a user-provided default constructor, use the normal
8643 mechanisms so that protected access works. */
8644 && type_has_non_user_provided_default_constructor (basetype
)
8645 && !processing_template_decl
)
8646 init
= build_value_init (basetype
, complain
);
8648 /* If BASETYPE is an aggregate, we need to do aggregate
8650 else if (CP_AGGREGATE_TYPE_P (basetype
))
8652 init
= reshape_init (basetype
, init_list
, complain
);
8653 init
= digest_init (basetype
, init
, complain
);
8658 if (is_dummy_object (instance
))
8659 return get_target_expr_sfinae (init
, complain
);
8660 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
8661 TREE_SIDE_EFFECTS (init
) = true;
8665 /* Otherwise go ahead with overload resolution. */
8666 add_list_candidates (fns
, first_mem_arg
, user_args
,
8667 basetype
, explicit_targs
, template_only
,
8668 conversion_path
, access_binfo
, flags
,
8669 &candidates
, complain
);
8673 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
8674 explicit_targs
, template_only
, conversion_path
,
8675 access_binfo
, flags
, &candidates
, complain
);
8677 any_viable_p
= false;
8678 candidates
= splice_viable (candidates
, false, &any_viable_p
);
8682 if (complain
& tf_error
)
8684 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
8685 cxx_incomplete_type_error (instance
, basetype
);
8687 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
8688 basetype
, optype
, build_tree_list_vec (user_args
),
8689 TREE_TYPE (instance
));
8692 tree arglist
= build_tree_list_vec (user_args
);
8693 tree errname
= name
;
8694 if (IDENTIFIER_CTOR_OR_DTOR_P (errname
))
8696 tree fn
= DECL_ORIGIN (get_first_fn (fns
));
8697 errname
= DECL_NAME (fn
);
8700 errname
= lookup_template_function (errname
, explicit_targs
);
8701 if (skip_first_for_error
)
8702 arglist
= TREE_CHAIN (arglist
);
8703 error ("no matching function for call to %<%T::%E(%A)%#V%>",
8704 basetype
, errname
, arglist
,
8705 TREE_TYPE (instance
));
8707 print_z_candidates (location_of (name
), candidates
);
8709 call
= error_mark_node
;
8713 cand
= tourney (candidates
, complain
);
8720 if (complain
& tf_error
)
8722 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8723 arglist
= build_tree_list_vec (user_args
);
8724 if (skip_first_for_error
)
8725 arglist
= TREE_CHAIN (arglist
);
8726 if (!any_strictly_viable (candidates
))
8727 error ("no matching function for call to %<%s(%A)%>",
8728 pretty_name
, arglist
);
8730 error ("call of overloaded %<%s(%A)%> is ambiguous",
8731 pretty_name
, arglist
);
8732 print_z_candidates (location_of (name
), candidates
);
8736 call
= error_mark_node
;
8743 if (!(flags
& LOOKUP_NONVIRTUAL
)
8744 && DECL_PURE_VIRTUAL_P (fn
)
8745 && instance
== current_class_ref
8746 && (complain
& tf_warning
))
8748 /* This is not an error, it is runtime undefined
8750 if (!current_function_decl
)
8751 warning (0, "pure virtual %q#D called from "
8752 "non-static data member initializer", fn
);
8753 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
8754 || DECL_DESTRUCTOR_P (current_function_decl
))
8755 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
8756 ? "pure virtual %q#D called from constructor"
8757 : "pure virtual %q#D called from destructor"),
8761 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
8762 && !DECL_CONSTRUCTOR_P (fn
)
8763 && is_dummy_object (instance
))
8765 instance
= maybe_resolve_dummy (instance
, true);
8766 if (instance
== error_mark_node
)
8767 call
= error_mark_node
;
8768 else if (!is_dummy_object (instance
))
8770 /* We captured 'this' in the current lambda now that
8771 we know we really need it. */
8772 cand
->first_arg
= instance
;
8774 else if (any_dependent_bases_p ())
8775 /* We can't tell until instantiation time whether we can use
8776 *this as the implicit object argument. */;
8779 if (complain
& tf_error
)
8780 error ("cannot call member function %qD without object",
8782 call
= error_mark_node
;
8786 if (call
!= error_mark_node
)
8788 /* Optimize away vtable lookup if we know that this
8789 function can't be overridden. We need to check if
8790 the context and the type where we found fn are the same,
8791 actually FN might be defined in a different class
8792 type because of a using-declaration. In this case, we
8793 do not want to perform a non-virtual call. */
8794 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
8795 && same_type_ignoring_top_level_qualifiers_p
8796 (DECL_CONTEXT (fn
), BINFO_TYPE (binfo
))
8797 && resolves_to_fixed_type_p (instance
, 0))
8798 flags
|= LOOKUP_NONVIRTUAL
;
8800 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
8801 /* Now we know what function is being called. */
8804 /* Build the actual CALL_EXPR. */
8805 call
= build_over_call (cand
, flags
, complain
);
8806 /* In an expression of the form `a->f()' where `f' turns
8807 out to be a static member function, `a' is
8808 none-the-less evaluated. */
8809 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
8810 && !is_dummy_object (instance
)
8811 && TREE_SIDE_EFFECTS (instance
))
8812 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
8814 else if (call
!= error_mark_node
8815 && DECL_DESTRUCTOR_P (cand
->fn
)
8816 && !VOID_TYPE_P (TREE_TYPE (call
)))
8817 /* An explicit call of the form "x->~X()" has type
8818 "void". However, on platforms where destructors
8819 return "this" (i.e., those where
8820 targetm.cxx.cdtor_returns_this is true), such calls
8821 will appear to have a return value of pointer type
8822 to the low-level call machinery. We do not want to
8823 change the low-level machinery, since we want to be
8824 able to optimize "delete f()" on such platforms as
8825 "operator delete(~X(f()))" (rather than generating
8826 "t = f(), ~X(t), operator delete (t)"). */
8827 call
= build_nop (void_type_node
, call
);
8832 if (processing_template_decl
&& call
!= error_mark_node
)
8834 bool cast_to_void
= false;
8836 if (TREE_CODE (call
) == COMPOUND_EXPR
)
8837 call
= TREE_OPERAND (call
, 1);
8838 else if (TREE_CODE (call
) == NOP_EXPR
)
8840 cast_to_void
= true;
8841 call
= TREE_OPERAND (call
, 0);
8843 if (INDIRECT_REF_P (call
))
8844 call
= TREE_OPERAND (call
, 0);
8845 call
= (build_min_non_dep_call_vec
8847 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
8848 orig_instance
, orig_fns
, NULL_TREE
),
8850 SET_EXPR_LOCATION (call
, input_location
);
8851 call
= convert_from_reference (call
);
8853 call
= build_nop (void_type_node
, call
);
8856 /* Free all the conversions we allocated. */
8857 obstack_free (&conversion_obstack
, p
);
8859 if (orig_args
!= NULL
)
8860 release_tree_vector (orig_args
);
8865 /* Wrapper for above. */
8868 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8869 tree conversion_path
, int flags
,
8870 tree
*fn_p
, tsubst_flags_t complain
)
8873 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
8874 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
8876 timevar_cond_stop (TV_OVERLOAD
, subtime
);
8880 /* Returns true iff standard conversion sequence ICS1 is a proper
8881 subsequence of ICS2. */
8884 is_subseq (conversion
*ics1
, conversion
*ics2
)
8886 /* We can assume that a conversion of the same code
8887 between the same types indicates a subsequence since we only get
8888 here if the types we are converting from are the same. */
8890 while (ics1
->kind
== ck_rvalue
8891 || ics1
->kind
== ck_lvalue
)
8892 ics1
= next_conversion (ics1
);
8896 while (ics2
->kind
== ck_rvalue
8897 || ics2
->kind
== ck_lvalue
)
8898 ics2
= next_conversion (ics2
);
8900 if (ics2
->kind
== ck_user
8901 || ics2
->kind
== ck_ambig
8902 || ics2
->kind
== ck_aggr
8903 || ics2
->kind
== ck_list
8904 || ics2
->kind
== ck_identity
)
8905 /* At this point, ICS1 cannot be a proper subsequence of
8906 ICS2. We can get a USER_CONV when we are comparing the
8907 second standard conversion sequence of two user conversion
8911 ics2
= next_conversion (ics2
);
8913 while (ics2
->kind
== ck_rvalue
8914 || ics2
->kind
== ck_lvalue
)
8915 ics2
= next_conversion (ics2
);
8917 if (ics2
->kind
== ics1
->kind
8918 && same_type_p (ics2
->type
, ics1
->type
)
8919 && (ics1
->kind
== ck_identity
8920 || same_type_p (next_conversion (ics2
)->type
,
8921 next_conversion (ics1
)->type
)))
8926 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
8927 be any _TYPE nodes. */
8930 is_properly_derived_from (tree derived
, tree base
)
8932 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
8935 /* We only allow proper derivation here. The DERIVED_FROM_P macro
8936 considers every class derived from itself. */
8937 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
8938 && DERIVED_FROM_P (base
, derived
));
8941 /* We build the ICS for an implicit object parameter as a pointer
8942 conversion sequence. However, such a sequence should be compared
8943 as if it were a reference conversion sequence. If ICS is the
8944 implicit conversion sequence for an implicit object parameter,
8945 modify it accordingly. */
8948 maybe_handle_implicit_object (conversion
**ics
)
8952 /* [over.match.funcs]
8954 For non-static member functions, the type of the
8955 implicit object parameter is "reference to cv X"
8956 where X is the class of which the function is a
8957 member and cv is the cv-qualification on the member
8958 function declaration. */
8959 conversion
*t
= *ics
;
8960 tree reference_type
;
8962 /* The `this' parameter is a pointer to a class type. Make the
8963 implicit conversion talk about a reference to that same class
8965 reference_type
= TREE_TYPE (t
->type
);
8966 reference_type
= build_reference_type (reference_type
);
8968 if (t
->kind
== ck_qual
)
8969 t
= next_conversion (t
);
8970 if (t
->kind
== ck_ptr
)
8971 t
= next_conversion (t
);
8972 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
8973 t
= direct_reference_binding (reference_type
, t
);
8975 t
->rvaluedness_matches_p
= 0;
8980 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
8981 and return the initial reference binding conversion. Otherwise,
8982 leave *ICS unchanged and return NULL. */
8985 maybe_handle_ref_bind (conversion
**ics
)
8987 if ((*ics
)->kind
== ck_ref_bind
)
8989 conversion
*old_ics
= *ics
;
8990 *ics
= next_conversion (old_ics
);
8991 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
8998 /* Compare two implicit conversion sequences according to the rules set out in
8999 [over.ics.rank]. Return values:
9001 1: ics1 is better than ics2
9002 -1: ics2 is better than ics1
9003 0: ics1 and ics2 are indistinguishable */
9006 compare_ics (conversion
*ics1
, conversion
*ics2
)
9012 tree deref_from_type1
= NULL_TREE
;
9013 tree deref_from_type2
= NULL_TREE
;
9014 tree deref_to_type1
= NULL_TREE
;
9015 tree deref_to_type2
= NULL_TREE
;
9016 conversion_rank rank1
, rank2
;
9018 /* REF_BINDING is nonzero if the result of the conversion sequence
9019 is a reference type. In that case REF_CONV is the reference
9020 binding conversion. */
9021 conversion
*ref_conv1
;
9022 conversion
*ref_conv2
;
9024 /* Compare badness before stripping the reference conversion. */
9025 if (ics1
->bad_p
> ics2
->bad_p
)
9027 else if (ics1
->bad_p
< ics2
->bad_p
)
9030 /* Handle implicit object parameters. */
9031 maybe_handle_implicit_object (&ics1
);
9032 maybe_handle_implicit_object (&ics2
);
9034 /* Handle reference parameters. */
9035 ref_conv1
= maybe_handle_ref_bind (&ics1
);
9036 ref_conv2
= maybe_handle_ref_bind (&ics2
);
9038 /* List-initialization sequence L1 is a better conversion sequence than
9039 list-initialization sequence L2 if L1 converts to
9040 std::initializer_list<X> for some X and L2 does not. */
9041 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
9043 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
9048 When comparing the basic forms of implicit conversion sequences (as
9049 defined in _over.best.ics_)
9051 --a standard conversion sequence (_over.ics.scs_) is a better
9052 conversion sequence than a user-defined conversion sequence
9053 or an ellipsis conversion sequence, and
9055 --a user-defined conversion sequence (_over.ics.user_) is a
9056 better conversion sequence than an ellipsis conversion sequence
9057 (_over.ics.ellipsis_). */
9058 /* Use BAD_CONVERSION_RANK because we already checked for a badness
9059 mismatch. If both ICS are bad, we try to make a decision based on
9060 what would have happened if they'd been good. This is not an
9061 extension, we'll still give an error when we build up the call; this
9062 just helps us give a more helpful error message. */
9063 rank1
= BAD_CONVERSION_RANK (ics1
);
9064 rank2
= BAD_CONVERSION_RANK (ics2
);
9068 else if (rank1
< rank2
)
9071 if (ics1
->ellipsis_p
)
9072 /* Both conversions are ellipsis conversions. */
9075 /* User-defined conversion sequence U1 is a better conversion sequence
9076 than another user-defined conversion sequence U2 if they contain the
9077 same user-defined conversion operator or constructor and if the sec-
9078 ond standard conversion sequence of U1 is better than the second
9079 standard conversion sequence of U2. */
9081 /* Handle list-conversion with the same code even though it isn't always
9082 ranked as a user-defined conversion and it doesn't have a second
9083 standard conversion sequence; it will still have the desired effect.
9084 Specifically, we need to do the reference binding comparison at the
9085 end of this function. */
9087 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
9092 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
9093 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
9094 || t1
->kind
== ck_list
)
9096 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
9097 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
9098 || t2
->kind
== ck_list
)
9101 if (t1
->kind
!= t2
->kind
)
9103 else if (t1
->kind
== ck_user
)
9105 if (t1
->cand
->fn
!= t2
->cand
->fn
)
9110 /* For ambiguous or aggregate conversions, use the target type as
9111 a proxy for the conversion function. */
9112 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
9116 /* We can just fall through here, after setting up
9117 FROM_TYPE1 and FROM_TYPE2. */
9118 from_type1
= t1
->type
;
9119 from_type2
= t2
->type
;
9126 /* We're dealing with two standard conversion sequences.
9130 Standard conversion sequence S1 is a better conversion
9131 sequence than standard conversion sequence S2 if
9133 --S1 is a proper subsequence of S2 (comparing the conversion
9134 sequences in the canonical form defined by _over.ics.scs_,
9135 excluding any Lvalue Transformation; the identity
9136 conversion sequence is considered to be a subsequence of
9137 any non-identity conversion sequence */
9140 while (t1
->kind
!= ck_identity
)
9141 t1
= next_conversion (t1
);
9142 from_type1
= t1
->type
;
9145 while (t2
->kind
!= ck_identity
)
9146 t2
= next_conversion (t2
);
9147 from_type2
= t2
->type
;
9150 /* One sequence can only be a subsequence of the other if they start with
9151 the same type. They can start with different types when comparing the
9152 second standard conversion sequence in two user-defined conversion
9154 if (same_type_p (from_type1
, from_type2
))
9156 if (is_subseq (ics1
, ics2
))
9158 if (is_subseq (ics2
, ics1
))
9166 --the rank of S1 is better than the rank of S2 (by the rules
9169 Standard conversion sequences are ordered by their ranks: an Exact
9170 Match is a better conversion than a Promotion, which is a better
9171 conversion than a Conversion.
9173 Two conversion sequences with the same rank are indistinguishable
9174 unless one of the following rules applies:
9176 --A conversion that does not a convert a pointer, pointer to member,
9177 or std::nullptr_t to bool is better than one that does.
9179 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
9180 so that we do not have to check it explicitly. */
9181 if (ics1
->rank
< ics2
->rank
)
9183 else if (ics2
->rank
< ics1
->rank
)
9186 to_type1
= ics1
->type
;
9187 to_type2
= ics2
->type
;
9189 /* A conversion from scalar arithmetic type to complex is worse than a
9190 conversion between scalar arithmetic types. */
9191 if (same_type_p (from_type1
, from_type2
)
9192 && ARITHMETIC_TYPE_P (from_type1
)
9193 && ARITHMETIC_TYPE_P (to_type1
)
9194 && ARITHMETIC_TYPE_P (to_type2
)
9195 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
9196 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
9198 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
9204 if (TYPE_PTR_P (from_type1
)
9205 && TYPE_PTR_P (from_type2
)
9206 && TYPE_PTR_P (to_type1
)
9207 && TYPE_PTR_P (to_type2
))
9209 deref_from_type1
= TREE_TYPE (from_type1
);
9210 deref_from_type2
= TREE_TYPE (from_type2
);
9211 deref_to_type1
= TREE_TYPE (to_type1
);
9212 deref_to_type2
= TREE_TYPE (to_type2
);
9214 /* The rules for pointers to members A::* are just like the rules
9215 for pointers A*, except opposite: if B is derived from A then
9216 A::* converts to B::*, not vice versa. For that reason, we
9217 switch the from_ and to_ variables here. */
9218 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
9219 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
9220 || (TYPE_PTRMEMFUNC_P (from_type1
)
9221 && TYPE_PTRMEMFUNC_P (from_type2
)
9222 && TYPE_PTRMEMFUNC_P (to_type1
)
9223 && TYPE_PTRMEMFUNC_P (to_type2
)))
9225 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
9226 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
9227 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
9228 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
9231 if (deref_from_type1
!= NULL_TREE
9232 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
9233 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
9235 /* This was one of the pointer or pointer-like conversions.
9239 --If class B is derived directly or indirectly from class A,
9240 conversion of B* to A* is better than conversion of B* to
9241 void*, and conversion of A* to void* is better than
9242 conversion of B* to void*. */
9243 if (VOID_TYPE_P (deref_to_type1
)
9244 && VOID_TYPE_P (deref_to_type2
))
9246 if (is_properly_derived_from (deref_from_type1
,
9249 else if (is_properly_derived_from (deref_from_type2
,
9253 else if (VOID_TYPE_P (deref_to_type1
)
9254 || VOID_TYPE_P (deref_to_type2
))
9256 if (same_type_p (deref_from_type1
, deref_from_type2
))
9258 if (VOID_TYPE_P (deref_to_type2
))
9260 if (is_properly_derived_from (deref_from_type1
,
9264 /* We know that DEREF_TO_TYPE1 is `void' here. */
9265 else if (is_properly_derived_from (deref_from_type1
,
9270 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
9271 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
9275 --If class B is derived directly or indirectly from class A
9276 and class C is derived directly or indirectly from B,
9278 --conversion of C* to B* is better than conversion of C* to
9281 --conversion of B* to A* is better than conversion of C* to
9283 if (same_type_p (deref_from_type1
, deref_from_type2
))
9285 if (is_properly_derived_from (deref_to_type1
,
9288 else if (is_properly_derived_from (deref_to_type2
,
9292 else if (same_type_p (deref_to_type1
, deref_to_type2
))
9294 if (is_properly_derived_from (deref_from_type2
,
9297 else if (is_properly_derived_from (deref_from_type1
,
9303 else if (CLASS_TYPE_P (non_reference (from_type1
))
9304 && same_type_p (from_type1
, from_type2
))
9306 tree from
= non_reference (from_type1
);
9310 --binding of an expression of type C to a reference of type
9311 B& is better than binding an expression of type C to a
9312 reference of type A&
9314 --conversion of C to B is better than conversion of C to A, */
9315 if (is_properly_derived_from (from
, to_type1
)
9316 && is_properly_derived_from (from
, to_type2
))
9318 if (is_properly_derived_from (to_type1
, to_type2
))
9320 else if (is_properly_derived_from (to_type2
, to_type1
))
9324 else if (CLASS_TYPE_P (non_reference (to_type1
))
9325 && same_type_p (to_type1
, to_type2
))
9327 tree to
= non_reference (to_type1
);
9331 --binding of an expression of type B to a reference of type
9332 A& is better than binding an expression of type C to a
9333 reference of type A&,
9335 --conversion of B to A is better than conversion of C to A */
9336 if (is_properly_derived_from (from_type1
, to
)
9337 && is_properly_derived_from (from_type2
, to
))
9339 if (is_properly_derived_from (from_type2
, from_type1
))
9341 else if (is_properly_derived_from (from_type1
, from_type2
))
9348 --S1 and S2 differ only in their qualification conversion and yield
9349 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
9350 qualification signature of type T1 is a proper subset of the cv-
9351 qualification signature of type T2 */
9352 if (ics1
->kind
== ck_qual
9353 && ics2
->kind
== ck_qual
9354 && same_type_p (from_type1
, from_type2
))
9356 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
9363 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
9364 to an implicit object parameter of a non-static member function
9365 declared without a ref-qualifier, and either S1 binds an lvalue
9366 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
9367 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
9368 draft standard, 13.3.3.2)
9370 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
9371 types to which the references refer are the same type except for
9372 top-level cv-qualifiers, and the type to which the reference
9373 initialized by S2 refers is more cv-qualified than the type to
9374 which the reference initialized by S1 refers.
9376 DR 1328 [over.match.best]: the context is an initialization by
9377 conversion function for direct reference binding (13.3.1.6) of a
9378 reference to function type, the return type of F1 is the same kind of
9379 reference (i.e. lvalue or rvalue) as the reference being initialized,
9380 and the return type of F2 is not. */
9382 if (ref_conv1
&& ref_conv2
)
9384 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
9385 && (ref_conv1
->rvaluedness_matches_p
9386 != ref_conv2
->rvaluedness_matches_p
)
9387 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
9388 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
9389 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
9391 if (ref_conv1
->bad_p
9392 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
9393 TREE_TYPE (ref_conv2
->type
)))
9394 /* Don't prefer a bad conversion that drops cv-quals to a bad
9395 conversion with the wrong rvalueness. */
9397 return (ref_conv1
->rvaluedness_matches_p
9398 - ref_conv2
->rvaluedness_matches_p
);
9401 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
9403 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
9404 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
9405 if (ref_conv1
->bad_p
)
9407 /* Prefer the one that drops fewer cv-quals. */
9408 tree ftype
= next_conversion (ref_conv1
)->type
;
9409 int fquals
= cp_type_quals (ftype
);
9413 return comp_cv_qualification (q2
, q1
);
9417 /* Neither conversion sequence is better than the other. */
9421 /* The source type for this standard conversion sequence. */
9424 source_type (conversion
*t
)
9426 for (;; t
= next_conversion (t
))
9428 if (t
->kind
== ck_user
9429 || t
->kind
== ck_ambig
9430 || t
->kind
== ck_identity
)
9436 /* Note a warning about preferring WINNER to LOSER. We do this by storing
9437 a pointer to LOSER and re-running joust to produce the warning if WINNER
9438 is actually used. */
9441 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
9443 candidate_warning
*cw
= (candidate_warning
*)
9444 conversion_obstack_alloc (sizeof (candidate_warning
));
9446 cw
->next
= winner
->warnings
;
9447 winner
->warnings
= cw
;
9450 /* Compare two candidates for overloading as described in
9451 [over.match.best]. Return values:
9453 1: cand1 is better than cand2
9454 -1: cand2 is better than cand1
9455 0: cand1 and cand2 are indistinguishable */
9458 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
9459 tsubst_flags_t complain
)
9462 int off1
= 0, off2
= 0;
9466 /* Candidates that involve bad conversions are always worse than those
9468 if (cand1
->viable
> cand2
->viable
)
9470 if (cand1
->viable
< cand2
->viable
)
9473 /* If we have two pseudo-candidates for conversions to the same type,
9474 or two candidates for the same function, arbitrarily pick one. */
9475 if (cand1
->fn
== cand2
->fn
9476 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
9479 /* Prefer a non-deleted function over an implicitly deleted move
9480 constructor or assignment operator. This differs slightly from the
9481 wording for issue 1402 (which says the move op is ignored by overload
9482 resolution), but this way produces better error messages. */
9483 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9484 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9485 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
9487 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
9488 && move_fn_p (cand1
->fn
))
9490 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
9491 && move_fn_p (cand2
->fn
))
9495 /* a viable function F1
9496 is defined to be a better function than another viable function F2 if
9497 for all arguments i, ICSi(F1) is not a worse conversion sequence than
9498 ICSi(F2), and then */
9500 /* for some argument j, ICSj(F1) is a better conversion sequence than
9503 /* For comparing static and non-static member functions, we ignore
9504 the implicit object parameter of the non-static function. The
9505 standard says to pretend that the static function has an object
9506 parm, but that won't work with operator overloading. */
9507 len
= cand1
->num_convs
;
9508 if (len
!= cand2
->num_convs
)
9510 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
9511 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
9513 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
9514 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
9515 /* We're comparing a near-match list constructor and a near-match
9516 non-list constructor. Just treat them as unordered. */
9519 gcc_assert (static_1
!= static_2
);
9530 for (i
= 0; i
< len
; ++i
)
9532 conversion
*t1
= cand1
->convs
[i
+ off1
];
9533 conversion
*t2
= cand2
->convs
[i
+ off2
];
9534 int comp
= compare_ics (t1
, t2
);
9538 if ((complain
& tf_warning
)
9540 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
9541 == cr_std
+ cr_promotion
)
9542 && t1
->kind
== ck_std
9543 && t2
->kind
== ck_std
9544 && TREE_CODE (t1
->type
) == INTEGER_TYPE
9545 && TREE_CODE (t2
->type
) == INTEGER_TYPE
9546 && (TYPE_PRECISION (t1
->type
)
9547 == TYPE_PRECISION (t2
->type
))
9548 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
9549 || (TREE_CODE (next_conversion (t1
)->type
)
9552 tree type
= next_conversion (t1
)->type
;
9554 struct z_candidate
*w
, *l
;
9556 type1
= t1
->type
, type2
= t2
->type
,
9557 w
= cand1
, l
= cand2
;
9559 type1
= t2
->type
, type2
= t1
->type
,
9560 w
= cand2
, l
= cand1
;
9564 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
9565 type
, type1
, type2
);
9566 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
9572 if (winner
&& comp
!= winner
)
9581 /* warn about confusing overload resolution for user-defined conversions,
9582 either between a constructor and a conversion op, or between two
9584 if ((complain
& tf_warning
)
9585 && winner
&& warn_conversion
&& cand1
->second_conv
9586 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
9587 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
9589 struct z_candidate
*w
, *l
;
9590 bool give_warning
= false;
9593 w
= cand1
, l
= cand2
;
9595 w
= cand2
, l
= cand1
;
9597 /* We don't want to complain about `X::operator T1 ()'
9598 beating `X::operator T2 () const', when T2 is a no less
9599 cv-qualified version of T1. */
9600 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
9601 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
9603 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
9604 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
9606 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
9611 if (!comp_ptr_ttypes (t
, f
))
9612 give_warning
= true;
9615 give_warning
= true;
9621 tree source
= source_type (w
->convs
[0]);
9622 if (! DECL_CONSTRUCTOR_P (w
->fn
))
9623 source
= TREE_TYPE (source
);
9624 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
9625 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
9626 source
, w
->second_conv
->type
))
9628 inform (input_location
, " because conversion sequence for the argument is better");
9638 /* DR 495 moved this tiebreaker above the template ones. */
9640 the context is an initialization by user-defined conversion (see
9641 _dcl.init_ and _over.match.user_) and the standard conversion
9642 sequence from the return type of F1 to the destination type (i.e.,
9643 the type of the entity being initialized) is a better conversion
9644 sequence than the standard conversion sequence from the return type
9645 of F2 to the destination type. */
9647 if (cand1
->second_conv
)
9649 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
9654 /* F1 is generated from a deduction-guide (13.3.1.8) and F2 is not */
9655 if (deduction_guide_p (cand1
->fn
))
9657 gcc_assert (deduction_guide_p (cand2
->fn
));
9658 /* We distinguish between candidates from an explicit deduction guide and
9659 candidates built from a constructor based on DECL_ARTIFICIAL. */
9660 int art1
= DECL_ARTIFICIAL (cand1
->fn
);
9661 int art2
= DECL_ARTIFICIAL (cand2
->fn
);
9667 F1 is a non-template function and F2 is a template function
9670 if (!cand1
->template_decl
&& cand2
->template_decl
)
9672 else if (cand1
->template_decl
&& !cand2
->template_decl
)
9676 F1 and F2 are template functions and the function template for F1 is
9677 more specialized than the template for F2 according to the partial
9680 if (cand1
->template_decl
&& cand2
->template_decl
)
9682 winner
= more_specialized_fn
9683 (TI_TEMPLATE (cand1
->template_decl
),
9684 TI_TEMPLATE (cand2
->template_decl
),
9685 /* [temp.func.order]: The presence of unused ellipsis and default
9686 arguments has no effect on the partial ordering of function
9687 templates. add_function_candidate() will not have
9688 counted the "this" argument for constructors. */
9689 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
9695 // or, if not that, F1 is more constrained than F2.
9696 if (flag_concepts
&& DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
))
9698 winner
= more_constrained (cand1
->fn
, cand2
->fn
);
9703 /* or, if not that, F2 is from a using-declaration, F1 is not, and the
9704 conversion sequences are equivalent.
9705 (proposed in http://lists.isocpp.org/core/2016/10/1142.php) */
9706 if (DECL_P (cand1
->fn
) && DECL_CLASS_SCOPE_P (cand1
->fn
)
9707 && !DECL_CONV_FN_P (cand1
->fn
)
9708 && DECL_P (cand2
->fn
) && DECL_CLASS_SCOPE_P (cand2
->fn
)
9709 && !DECL_CONV_FN_P (cand2
->fn
))
9711 bool used1
= (DECL_INHERITED_CTOR (cand1
->fn
)
9712 || (BINFO_TYPE (cand1
->access_path
)
9713 != DECL_CONTEXT (cand1
->fn
)));
9714 bool used2
= (DECL_INHERITED_CTOR (cand2
->fn
)
9715 || (BINFO_TYPE (cand2
->access_path
)
9716 != DECL_CONTEXT (cand2
->fn
)));
9717 if (int diff
= used2
- used1
)
9719 for (i
= 0; i
< len
; ++i
)
9721 conversion
*t1
= cand1
->convs
[i
+ off1
];
9722 conversion
*t2
= cand2
->convs
[i
+ off2
];
9723 if (!same_type_p (t1
->type
, t2
->type
))
9731 /* Check whether we can discard a builtin candidate, either because we
9732 have two identical ones or matching builtin and non-builtin candidates.
9734 (Pedantically in the latter case the builtin which matched the user
9735 function should not be added to the overload set, but we spot it here.
9738 ... the builtin candidates include ...
9739 - do not have the same parameter type list as any non-template
9740 non-member candidate. */
9742 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
9744 for (i
= 0; i
< len
; ++i
)
9745 if (!same_type_p (cand1
->convs
[i
]->type
,
9746 cand2
->convs
[i
]->type
))
9748 if (i
== cand1
->num_convs
)
9750 if (cand1
->fn
== cand2
->fn
)
9751 /* Two built-in candidates; arbitrarily pick one. */
9753 else if (identifier_p (cand1
->fn
))
9754 /* cand1 is built-in; prefer cand2. */
9757 /* cand2 is built-in; prefer cand1. */
9762 /* For candidates of a multi-versioned function, make the version with
9763 the highest priority win. This version will be checked for dispatching
9764 first. If this version can be inlined into the caller, the front-end
9765 will simply make a direct call to this function. */
9767 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9768 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
9769 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9770 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
9772 tree f1
= TREE_TYPE (cand1
->fn
);
9773 tree f2
= TREE_TYPE (cand2
->fn
);
9774 tree p1
= TYPE_ARG_TYPES (f1
);
9775 tree p2
= TYPE_ARG_TYPES (f2
);
9777 /* Check if cand1->fn and cand2->fn are versions of the same function. It
9778 is possible that cand1->fn and cand2->fn are function versions but of
9779 different functions. Check types to see if they are versions of the same
9781 if (compparms (p1
, p2
)
9782 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
9784 /* Always make the version with the higher priority, more
9785 specialized, win. */
9786 gcc_assert (targetm
.compare_version_priority
);
9787 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
9794 /* If the two function declarations represent the same function (this can
9795 happen with declarations in multiple scopes and arg-dependent lookup),
9796 arbitrarily choose one. But first make sure the default args we're
9798 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
9799 && equal_functions (cand1
->fn
, cand2
->fn
))
9801 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
9802 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
9804 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
9806 for (i
= 0; i
< len
; ++i
)
9808 /* Don't crash if the fn is variadic. */
9811 parms1
= TREE_CHAIN (parms1
);
9812 parms2
= TREE_CHAIN (parms2
);
9816 parms1
= TREE_CHAIN (parms1
);
9818 parms2
= TREE_CHAIN (parms2
);
9822 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
9823 TREE_PURPOSE (parms2
)))
9827 if (complain
& tf_error
)
9829 if (permerror (input_location
,
9830 "default argument mismatch in "
9831 "overload resolution"))
9833 inform (DECL_SOURCE_LOCATION (cand1
->fn
),
9834 " candidate 1: %q#F", cand1
->fn
);
9835 inform (DECL_SOURCE_LOCATION (cand2
->fn
),
9836 " candidate 2: %q#F", cand2
->fn
);
9843 add_warning (cand1
, cand2
);
9846 parms1
= TREE_CHAIN (parms1
);
9847 parms2
= TREE_CHAIN (parms2
);
9855 /* Extension: If the worst conversion for one candidate is worse than the
9856 worst conversion for the other, take the first. */
9857 if (!pedantic
&& (complain
& tf_warning_or_error
))
9859 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
9860 struct z_candidate
*w
= 0, *l
= 0;
9862 for (i
= 0; i
< len
; ++i
)
9864 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
9865 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
9866 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
9867 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
9870 winner
= 1, w
= cand1
, l
= cand2
;
9872 winner
= -1, w
= cand2
, l
= cand1
;
9875 /* Don't choose a deleted function over ambiguity. */
9876 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
9880 pedwarn (input_location
, 0,
9881 "ISO C++ says that these are ambiguous, even "
9882 "though the worst conversion for the first is better than "
9883 "the worst conversion for the second:");
9884 print_z_candidate (input_location
, _("candidate 1:"), w
);
9885 print_z_candidate (input_location
, _("candidate 2:"), l
);
9893 gcc_assert (!winner
);
9897 /* Given a list of candidates for overloading, find the best one, if any.
9898 This algorithm has a worst case of O(2n) (winner is last), and a best
9899 case of O(n/2) (totally ambiguous); much better than a sorting
9902 static struct z_candidate
*
9903 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
9905 struct z_candidate
*champ
= candidates
, *challenger
;
9907 int champ_compared_to_predecessor
= 0;
9909 /* Walk through the list once, comparing each current champ to the next
9910 candidate, knocking out a candidate or two with each comparison. */
9912 for (challenger
= champ
->next
; challenger
; )
9914 fate
= joust (champ
, challenger
, 0, complain
);
9916 challenger
= challenger
->next
;
9921 champ
= challenger
->next
;
9924 champ_compared_to_predecessor
= 0;
9929 champ_compared_to_predecessor
= 1;
9932 challenger
= champ
->next
;
9936 /* Make sure the champ is better than all the candidates it hasn't yet
9937 been compared to. */
9939 for (challenger
= candidates
;
9941 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
9942 challenger
= challenger
->next
)
9944 fate
= joust (champ
, challenger
, 0, complain
);
9952 /* Returns nonzero if things of type FROM can be converted to TO. */
9955 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
9957 tree arg
= NULL_TREE
;
9958 /* implicit_conversion only considers user-defined conversions
9959 if it has an expression for the call argument list. */
9960 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
9961 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
9962 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
9965 /* Returns nonzero if things of type FROM can be converted to TO with a
9966 standard conversion. */
9969 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
9971 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
9974 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
9977 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
9978 tsubst_flags_t complain
)
9984 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9985 p
= conversion_obstack_alloc (0);
9986 /* We want to discard any access checks done for this test,
9987 as we might not be in the appropriate access context and
9988 we'll do the check again when we actually perform the
9990 push_deferring_access_checks (dk_deferred
);
9992 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9994 ok_p
= (t
&& !t
->bad_p
);
9996 /* Discard the access checks now. */
9997 pop_deferring_access_checks ();
9998 /* Free all the conversions we allocated. */
9999 obstack_free (&conversion_obstack
, p
);
10004 /* Like can_convert_arg, but allows dubious conversions as well. */
10007 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
10008 tsubst_flags_t complain
)
10013 /* Get the high-water mark for the CONVERSION_OBSTACK. */
10014 p
= conversion_obstack_alloc (0);
10015 /* Try to perform the conversion. */
10016 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
10018 /* Free all the conversions we allocated. */
10019 obstack_free (&conversion_obstack
, p
);
10024 /* Convert EXPR to TYPE. Return the converted expression.
10026 Note that we allow bad conversions here because by the time we get to
10027 this point we are committed to doing the conversion. If we end up
10028 doing a bad conversion, convert_like will complain. */
10031 perform_implicit_conversion_flags (tree type
, tree expr
,
10032 tsubst_flags_t complain
, int flags
)
10036 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
10038 if (error_operand_p (expr
))
10039 return error_mark_node
;
10041 /* Get the high-water mark for the CONVERSION_OBSTACK. */
10042 p
= conversion_obstack_alloc (0);
10044 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
10045 /*c_cast_p=*/false,
10050 if (complain
& tf_error
)
10052 /* If expr has unknown type, then it is an overloaded function.
10053 Call instantiate_type to get good error messages. */
10054 if (TREE_TYPE (expr
) == unknown_type_node
)
10055 instantiate_type (type
, expr
, complain
);
10056 else if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
10057 /* We gave an error. */;
10059 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
10060 TREE_TYPE (expr
), type
);
10062 expr
= error_mark_node
;
10064 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
10066 /* In a template, we are only concerned about determining the
10067 type of non-dependent expressions, so we do not have to
10068 perform the actual conversion. But for initializers, we
10069 need to be able to perform it at instantiation
10070 (or instantiate_non_dependent_expr) time. */
10071 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
10072 if (!(flags
& LOOKUP_ONLYCONVERTING
))
10073 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
10076 expr
= convert_like (conv
, expr
, complain
);
10078 /* Free all the conversions we allocated. */
10079 obstack_free (&conversion_obstack
, p
);
10085 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
10087 return perform_implicit_conversion_flags (type
, expr
, complain
,
10091 /* Convert EXPR to TYPE (as a direct-initialization) if that is
10092 permitted. If the conversion is valid, the converted expression is
10093 returned. Otherwise, NULL_TREE is returned, except in the case
10094 that TYPE is a class type; in that case, an error is issued. If
10095 C_CAST_P is true, then this direct-initialization is taking
10096 place as part of a static_cast being attempted as part of a C-style
10100 perform_direct_initialization_if_possible (tree type
,
10103 tsubst_flags_t complain
)
10108 if (type
== error_mark_node
|| error_operand_p (expr
))
10109 return error_mark_node
;
10112 If the destination type is a (possibly cv-qualified) class type:
10114 -- If the initialization is direct-initialization ...,
10115 constructors are considered. ... If no constructor applies, or
10116 the overload resolution is ambiguous, the initialization is
10118 if (CLASS_TYPE_P (type
))
10120 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
10121 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
10122 &args
, type
, LOOKUP_NORMAL
, complain
);
10123 release_tree_vector (args
);
10124 return build_cplus_new (type
, expr
, complain
);
10127 /* Get the high-water mark for the CONVERSION_OBSTACK. */
10128 p
= conversion_obstack_alloc (0);
10130 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
10132 LOOKUP_NORMAL
, complain
);
10133 if (!conv
|| conv
->bad_p
)
10136 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
10137 /*issue_conversion_warnings=*/false,
10141 /* Free all the conversions we allocated. */
10142 obstack_free (&conversion_obstack
, p
);
10147 /* When initializing a reference that lasts longer than a full-expression,
10148 this special rule applies:
10152 The temporary to which the reference is bound or the temporary
10153 that is the complete object to which the reference is bound
10154 persists for the lifetime of the reference.
10156 The temporaries created during the evaluation of the expression
10157 initializing the reference, except the temporary to which the
10158 reference is bound, are destroyed at the end of the
10159 full-expression in which they are created.
10161 In that case, we store the converted expression into a new
10162 VAR_DECL in a new scope.
10164 However, we want to be careful not to create temporaries when
10165 they are not required. For example, given:
10168 struct D : public B {};
10172 there is no need to copy the return value from "f"; we can just
10173 extend its lifetime. Similarly, given:
10176 struct T { operator S(); };
10180 we can extend the lifetime of the return value of the conversion
10183 The next several functions are involved in this lifetime extension. */
10185 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
10186 reference is being bound to a temporary. Create and return a new
10187 VAR_DECL with the indicated TYPE; this variable will store the value to
10188 which the reference is bound. */
10191 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
10195 /* Create the variable. */
10196 var
= create_temporary_var (type
);
10198 /* Register the variable. */
10200 && (TREE_STATIC (decl
) || CP_DECL_THREAD_LOCAL_P (decl
)))
10202 /* Namespace-scope or local static; give it a mangled name. */
10203 /* FIXME share comdat with decl? */
10206 TREE_STATIC (var
) = TREE_STATIC (decl
);
10207 CP_DECL_THREAD_LOCAL_P (var
) = CP_DECL_THREAD_LOCAL_P (decl
);
10208 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
10209 name
= mangle_ref_init_variable (decl
);
10210 DECL_NAME (var
) = name
;
10211 SET_DECL_ASSEMBLER_NAME (var
, name
);
10212 var
= pushdecl_top_level (var
);
10215 /* Create a new cleanup level if necessary. */
10216 maybe_push_cleanup_level (type
);
10221 /* EXPR is the initializer for a variable DECL of reference or
10222 std::initializer_list type. Create, push and return a new VAR_DECL
10223 for the initializer so that it will live as long as DECL. Any
10224 cleanup for the new variable is returned through CLEANUP, and the
10225 code to initialize the new variable is returned through INITP. */
10228 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
10235 /* Create the temporary variable. */
10236 type
= TREE_TYPE (expr
);
10237 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
10238 layout_decl (var
, 0);
10239 /* If the rvalue is the result of a function call it will be
10240 a TARGET_EXPR. If it is some other construct (such as a
10241 member access expression where the underlying object is
10242 itself the result of a function call), turn it into a
10243 TARGET_EXPR here. It is important that EXPR be a
10244 TARGET_EXPR below since otherwise the INIT_EXPR will
10245 attempt to make a bitwise copy of EXPR to initialize
10247 if (TREE_CODE (expr
) != TARGET_EXPR
)
10248 expr
= get_target_expr (expr
);
10250 if (TREE_CODE (decl
) == FIELD_DECL
10251 && extra_warnings
&& !TREE_NO_WARNING (decl
))
10253 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
10254 "until the constructor exits", decl
);
10255 TREE_NO_WARNING (decl
) = true;
10258 /* Recursively extend temps in this initializer. */
10259 TARGET_EXPR_INITIAL (expr
)
10260 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
10262 /* Any reference temp has a non-trivial initializer. */
10263 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
10265 /* If the initializer is constant, put it in DECL_INITIAL so we get
10266 static initialization and use in constant expressions. */
10267 init
= maybe_constant_init (expr
);
10268 if (TREE_CONSTANT (init
))
10270 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
10272 /* 5.19 says that a constant expression can include an
10273 lvalue-rvalue conversion applied to "a glvalue of literal type
10274 that refers to a non-volatile temporary object initialized
10275 with a constant expression". Rather than try to communicate
10276 that this VAR_DECL is a temporary, just mark it constexpr.
10278 Currently this is only useful for initializer_list temporaries,
10279 since reference vars can't appear in constant expressions. */
10280 DECL_DECLARED_CONSTEXPR_P (var
) = true;
10281 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
10282 TREE_CONSTANT (var
) = true;
10284 DECL_INITIAL (var
) = init
;
10288 /* Create the INIT_EXPR that will initialize the temporary
10290 init
= split_nonconstant_init (var
, expr
);
10291 if (at_function_scope_p ())
10293 add_decl_expr (var
);
10295 if (TREE_STATIC (var
))
10296 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
10299 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
10301 vec_safe_push (*cleanups
, cleanup
);
10304 /* We must be careful to destroy the temporary only
10305 after its initialization has taken place. If the
10306 initialization throws an exception, then the
10307 destructor should not be run. We cannot simply
10308 transform INIT into something like:
10310 (INIT, ({ CLEANUP_STMT; }))
10312 because emit_local_var always treats the
10313 initializer as a full-expression. Thus, the
10314 destructor would run too early; it would run at the
10315 end of initializing the reference variable, rather
10316 than at the end of the block enclosing the
10317 reference variable.
10319 The solution is to pass back a cleanup expression
10320 which the caller is responsible for attaching to
10321 the statement tree. */
10325 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
10326 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
10328 if (CP_DECL_THREAD_LOCAL_P (var
))
10329 tls_aggregates
= tree_cons (NULL_TREE
, var
,
10332 static_aggregates
= tree_cons (NULL_TREE
, var
,
10333 static_aggregates
);
10336 /* Check whether the dtor is callable. */
10337 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
10339 /* Avoid -Wunused-variable warning (c++/38958). */
10340 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
10342 TREE_USED (decl
) = DECL_READ_P (decl
) = true;
10348 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
10349 initializing a variable of that TYPE. */
10352 initialize_reference (tree type
, tree expr
,
10353 int flags
, tsubst_flags_t complain
)
10357 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
10359 if (type
== error_mark_node
|| error_operand_p (expr
))
10360 return error_mark_node
;
10362 /* Get the high-water mark for the CONVERSION_OBSTACK. */
10363 p
= conversion_obstack_alloc (0);
10365 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
10367 if (!conv
|| conv
->bad_p
)
10369 if (complain
& tf_error
)
10372 convert_like (conv
, expr
, complain
);
10373 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
10374 && !TYPE_REF_IS_RVALUE (type
)
10375 && !lvalue_p (expr
))
10376 error_at (loc
, "invalid initialization of non-const reference of "
10377 "type %qT from an rvalue of type %qT",
10378 type
, TREE_TYPE (expr
));
10380 error_at (loc
, "invalid initialization of reference of type "
10381 "%qT from expression of type %qT", type
,
10384 return error_mark_node
;
10387 if (conv
->kind
== ck_ref_bind
)
10388 /* Perform the conversion. */
10389 expr
= convert_like (conv
, expr
, complain
);
10390 else if (conv
->kind
== ck_ambig
)
10391 /* We gave an error in build_user_type_conversion_1. */
10392 expr
= error_mark_node
;
10394 gcc_unreachable ();
10396 /* Free all the conversions we allocated. */
10397 obstack_free (&conversion_obstack
, p
);
10402 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
10403 which is bound either to a reference or a std::initializer_list. */
10406 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
10411 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
10413 TREE_OPERAND (sub
, 1)
10414 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
10417 if (TREE_CODE (sub
) != ADDR_EXPR
)
10419 /* Deal with binding to a subobject. */
10420 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
10421 p
= &TREE_OPERAND (*p
, 0);
10422 if (TREE_CODE (*p
) == TARGET_EXPR
)
10424 tree subinit
= NULL_TREE
;
10425 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
10426 recompute_tree_invariant_for_addr_expr (sub
);
10428 init
= fold_convert (TREE_TYPE (init
), sub
);
10430 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
10435 /* INIT is part of the initializer for DECL. If there are any
10436 reference or initializer lists being initialized, extend their
10437 lifetime to match that of DECL. */
10440 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
10442 tree type
= TREE_TYPE (init
);
10443 if (processing_template_decl
)
10445 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10446 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
10450 if (TREE_CODE (ctor
) == TARGET_EXPR
)
10451 ctor
= TARGET_EXPR_INITIAL (ctor
);
10452 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
10454 if (is_std_init_list (type
))
10456 /* The temporary array underlying a std::initializer_list
10457 is handled like a reference temporary. */
10458 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
10459 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
10460 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
10465 constructor_elt
*p
;
10466 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
10467 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
10468 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
10476 /* Returns true iff an initializer for TYPE could contain temporaries that
10477 need to be extended because they are bound to references or
10478 std::initializer_list. */
10481 type_has_extended_temps (tree type
)
10483 type
= strip_array_types (type
);
10484 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10486 if (CLASS_TYPE_P (type
))
10488 if (is_std_init_list (type
))
10490 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
10491 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
10492 if (type_has_extended_temps (TREE_TYPE (f
)))
10498 /* Returns true iff TYPE is some variant of std::initializer_list. */
10501 is_std_init_list (tree type
)
10503 /* Look through typedefs. */
10504 if (!TYPE_P (type
))
10506 if (cxx_dialect
== cxx98
)
10508 type
= TYPE_MAIN_VARIANT (type
);
10509 return (CLASS_TYPE_P (type
)
10510 && CP_TYPE_CONTEXT (type
) == std_node
10511 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
10514 /* Returns true iff DECL is a list constructor: i.e. a constructor which
10515 will accept an argument list of a single std::initializer_list<T>. */
10518 is_list_ctor (tree decl
)
10520 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
10523 if (!args
|| args
== void_list_node
)
10526 arg
= non_reference (TREE_VALUE (args
));
10527 if (!is_std_init_list (arg
))
10530 args
= TREE_CHAIN (args
);
10532 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
10533 /* There are more non-defaulted parms. */
10539 #include "gt-cp-call.h"