1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987-2015 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 "stor-layout.h"
32 #include "trans-mem.h"
33 #include "stringpool.h"
37 #include "diagnostic-core.h"
41 #include "langhooks.h"
42 #include "c-family/c-objc.h"
44 #include "hard-reg-set.h"
47 #include "internal-fn.h"
49 /* The various kinds of conversion. */
51 enum conversion_kind
{
68 /* The rank of the conversion. Order of the enumerals matters; better
69 conversions should come earlier in the list. */
71 enum conversion_rank
{
82 /* An implicit conversion sequence, in the sense of [over.best.ics].
83 The first conversion to be performed is at the end of the chain.
84 That conversion is always a cr_identity conversion. */
87 /* The kind of conversion represented by this step. */
89 /* The rank of this conversion. */
91 BOOL_BITFIELD user_conv_p
: 1;
92 BOOL_BITFIELD ellipsis_p
: 1;
93 BOOL_BITFIELD this_p
: 1;
94 /* True if this conversion would be permitted with a bending of
95 language standards, e.g. disregarding pointer qualifiers or
96 converting integers to pointers. */
97 BOOL_BITFIELD bad_p
: 1;
98 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
99 temporary should be created to hold the result of the
101 BOOL_BITFIELD need_temporary_p
: 1;
102 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
103 from a pointer-to-derived to pointer-to-base is being performed. */
104 BOOL_BITFIELD base_p
: 1;
105 /* If KIND is ck_ref_bind, true when either an lvalue reference is
106 being bound to an lvalue expression or an rvalue reference is
107 being bound to an rvalue expression. If KIND is ck_rvalue,
108 true when we should treat an lvalue as an rvalue (12.8p33). If
109 KIND is ck_base, always false. */
110 BOOL_BITFIELD rvaluedness_matches_p
: 1;
111 BOOL_BITFIELD check_narrowing
: 1;
112 /* The type of the expression resulting from the conversion. */
115 /* The next conversion in the chain. Since the conversions are
116 arranged from outermost to innermost, the NEXT conversion will
117 actually be performed before this conversion. This variant is
118 used only when KIND is neither ck_identity, ck_ambig nor
119 ck_list. Please use the next_conversion function instead
120 of using this field directly. */
122 /* The expression at the beginning of the conversion chain. This
123 variant is used only if KIND is ck_identity or ck_ambig. */
125 /* The array of conversions for an initializer_list, so this
126 variant is used only when KIN D is ck_list. */
129 /* The function candidate corresponding to this conversion
130 sequence. This field is only used if KIND is ck_user. */
131 struct z_candidate
*cand
;
134 #define CONVERSION_RANK(NODE) \
135 ((NODE)->bad_p ? cr_bad \
136 : (NODE)->ellipsis_p ? cr_ellipsis \
137 : (NODE)->user_conv_p ? cr_user \
140 #define BAD_CONVERSION_RANK(NODE) \
141 ((NODE)->ellipsis_p ? cr_ellipsis \
142 : (NODE)->user_conv_p ? cr_user \
145 static struct obstack conversion_obstack
;
146 static bool conversion_obstack_initialized
;
147 struct rejection_reason
;
149 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
150 static int equal_functions (tree
, tree
);
151 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
153 static int compare_ics (conversion
*, conversion
*);
154 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
155 static tree
build_java_interface_fn_ref (tree
, tree
);
156 #define convert_like(CONV, EXPR, COMPLAIN) \
157 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
158 /*issue_conversion_warnings=*/true, \
159 /*c_cast_p=*/false, (COMPLAIN))
160 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
161 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
162 /*issue_conversion_warnings=*/true, \
163 /*c_cast_p=*/false, (COMPLAIN))
164 static tree
convert_like_real (conversion
*, tree
, tree
, int, int, bool,
165 bool, tsubst_flags_t
);
166 static void op_error (location_t
, enum tree_code
, enum tree_code
, tree
,
168 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
170 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
171 static void print_z_candidates (location_t
, struct z_candidate
*);
172 static tree
build_this (tree
);
173 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
174 static bool any_strictly_viable (struct z_candidate
*);
175 static struct z_candidate
*add_template_candidate
176 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
177 tree
, tree
, tree
, int, unification_kind_t
, tsubst_flags_t
);
178 static struct z_candidate
*add_template_candidate_real
179 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
180 tree
, tree
, tree
, int, tree
, unification_kind_t
, tsubst_flags_t
);
181 static void add_builtin_candidates
182 (struct z_candidate
**, enum tree_code
, enum tree_code
,
183 tree
, tree
*, int, tsubst_flags_t
);
184 static void add_builtin_candidate
185 (struct z_candidate
**, enum tree_code
, enum tree_code
,
186 tree
, tree
, tree
, tree
*, tree
*, int, tsubst_flags_t
);
187 static bool is_complete (tree
);
188 static void build_builtin_candidate
189 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
190 int, tsubst_flags_t
);
191 static struct z_candidate
*add_conv_candidate
192 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
193 tree
, tsubst_flags_t
);
194 static struct z_candidate
*add_function_candidate
195 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
196 tree
, int, tsubst_flags_t
);
197 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
199 static conversion
*standard_conversion (tree
, tree
, tree
, bool, int);
200 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
202 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
203 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
204 static conversion
*next_conversion (conversion
*);
205 static bool is_subseq (conversion
*, conversion
*);
206 static conversion
*maybe_handle_ref_bind (conversion
**);
207 static void maybe_handle_implicit_object (conversion
**);
208 static struct z_candidate
*add_candidate
209 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
210 conversion
**, tree
, tree
, int, struct rejection_reason
*, int);
211 static tree
source_type (conversion
*);
212 static void add_warning (struct z_candidate
*, struct z_candidate
*);
213 static bool reference_compatible_p (tree
, tree
);
214 static conversion
*direct_reference_binding (tree
, conversion
*);
215 static bool promoted_arithmetic_type_p (tree
);
216 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
217 static char *name_as_c_string (tree
, tree
, bool *);
218 static tree
prep_operand (tree
);
219 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
220 bool, tree
, tree
, int, struct z_candidate
**,
222 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
223 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
225 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
226 NAME can take many forms... */
229 check_dtor_name (tree basetype
, tree name
)
231 /* Just accept something we've already complained about. */
232 if (name
== error_mark_node
)
235 if (TREE_CODE (name
) == TYPE_DECL
)
236 name
= TREE_TYPE (name
);
237 else if (TYPE_P (name
))
239 else if (identifier_p (name
))
241 if ((MAYBE_CLASS_TYPE_P (basetype
)
242 && name
== constructor_name (basetype
))
243 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
244 && name
== TYPE_IDENTIFIER (basetype
)))
247 name
= get_type_value (name
);
253 template <class T> struct S { ~S(); };
257 NAME will be a class template. */
258 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
262 if (!name
|| name
== error_mark_node
)
264 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
267 /* We want the address of a function or method. We avoid creating a
268 pointer-to-member function. */
271 build_addr_func (tree function
, tsubst_flags_t complain
)
273 tree type
= TREE_TYPE (function
);
275 /* We have to do these by hand to avoid real pointer to member
277 if (TREE_CODE (type
) == METHOD_TYPE
)
279 if (TREE_CODE (function
) == OFFSET_REF
)
281 tree object
= build_address (TREE_OPERAND (function
, 0));
282 return get_member_function_from_ptrfunc (&object
,
283 TREE_OPERAND (function
, 1),
286 function
= build_address (function
);
289 function
= decay_conversion (function
, complain
, /*reject_builtin=*/false);
294 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
295 POINTER_TYPE to those. Note, pointer to member function types
296 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
297 two variants. build_call_a is the primitive taking an array of
298 arguments, while build_call_n is a wrapper that handles varargs. */
301 build_call_n (tree function
, int n
, ...)
304 return build_call_a (function
, 0, NULL
);
307 tree
*argarray
= XALLOCAVEC (tree
, n
);
312 for (i
= 0; i
< n
; i
++)
313 argarray
[i
] = va_arg (ap
, tree
);
315 return build_call_a (function
, n
, argarray
);
319 /* Update various flags in cfun and the call itself based on what is being
320 called. Split out of build_call_a so that bot_manip can use it too. */
323 set_flags_from_callee (tree call
)
326 tree decl
= get_callee_fndecl (call
);
328 /* We check both the decl and the type; a function may be known not to
329 throw without being declared throw(). */
330 nothrow
= decl
&& TREE_NOTHROW (decl
);
331 if (CALL_EXPR_FN (call
))
332 nothrow
|= TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call
))));
333 else if (internal_fn_flags (CALL_EXPR_IFN (call
)) & ECF_NOTHROW
)
336 if (!nothrow
&& at_function_scope_p () && cfun
&& cp_function_chain
)
337 cp_function_chain
->can_throw
= 1;
339 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
&& cp_function_chain
)
340 current_function_returns_abnormally
= 1;
342 TREE_NOTHROW (call
) = nothrow
;
346 build_call_a (tree function
, int n
, tree
*argarray
)
353 function
= build_addr_func (function
, tf_warning_or_error
);
355 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
356 fntype
= TREE_TYPE (TREE_TYPE (function
));
357 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
358 || TREE_CODE (fntype
) == METHOD_TYPE
);
359 result_type
= TREE_TYPE (fntype
);
360 /* An rvalue has no cv-qualifiers. */
361 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
362 result_type
= cv_unqualified (result_type
);
364 function
= build_call_array_loc (input_location
,
365 result_type
, function
, n
, argarray
);
366 set_flags_from_callee (function
);
368 decl
= get_callee_fndecl (function
);
370 if (decl
&& !TREE_USED (decl
))
372 /* We invoke build_call directly for several library
373 functions. These may have been declared normally if
374 we're building libgcc, so we can't just check
376 gcc_assert (DECL_ARTIFICIAL (decl
)
377 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
382 require_complete_eh_spec_types (fntype
, decl
);
384 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
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 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
,
425 rr_constraint_failure
428 struct conversion_info
{
429 /* The index of the argument, 0-based. */
431 /* The actual argument or its type. */
433 /* The type of the parameter. */
437 struct rejection_reason
{
438 enum rejection_reason_code code
;
440 /* Information about an arity mismatch. */
442 /* The expected number of arguments. */
444 /* The actual number of arguments in the call. */
446 /* Whether the call was a varargs call. */
449 /* Information about an argument conversion mismatch. */
450 struct conversion_info conversion
;
451 /* Same, but for bad argument conversions. */
452 struct conversion_info bad_conversion
;
453 /* Information about template unification failures. These are the
454 parameters passed to fn_type_unification. */
462 unification_kind_t strict
;
464 } template_unification
;
465 /* Information about template instantiation failures. These are the
466 parameters passed to instantiate_template. */
470 } template_instantiation
;
475 /* The FUNCTION_DECL that will be called if this candidate is
476 selected by overload resolution. */
478 /* If not NULL_TREE, the first argument to use when calling this
481 /* The rest of the arguments to use when calling this function. If
482 there are no further arguments this may be NULL or it may be an
484 const vec
<tree
, va_gc
> *args
;
485 /* The implicit conversion sequences for each of the arguments to
488 /* The number of implicit conversion sequences. */
490 /* If FN is a user-defined conversion, the standard conversion
491 sequence from the type returned by FN to the desired destination
493 conversion
*second_conv
;
494 struct rejection_reason
*reason
;
495 /* If FN is a member function, the binfo indicating the path used to
496 qualify the name of FN at the call site. This path is used to
497 determine whether or not FN is accessible if it is selected by
498 overload resolution. The DECL_CONTEXT of FN will always be a
499 (possibly improper) base of this binfo. */
501 /* If FN is a non-static member function, the binfo indicating the
502 subobject to which the `this' pointer should be converted if FN
503 is selected by overload resolution. The type pointed to by
504 the `this' pointer must correspond to the most derived class
505 indicated by the CONVERSION_PATH. */
506 tree conversion_path
;
509 candidate_warning
*warnings
;
513 /* The flags active in add_candidate. */
517 /* Returns true iff T is a null pointer constant in the sense of
521 null_ptr_cst_p (tree t
)
523 tree type
= TREE_TYPE (t
);
527 A null pointer constant is an integral constant expression
528 (_expr.const_) rvalue of integer type that evaluates to zero or
529 an rvalue of type std::nullptr_t. */
530 if (NULLPTR_TYPE_P (type
))
533 if (cxx_dialect
>= cxx11
)
535 /* Core issue 903 says only literal 0 is a null pointer constant. */
536 if (TREE_CODE (type
) == INTEGER_TYPE
537 && TREE_CODE (t
) == INTEGER_CST
539 && !TREE_OVERFLOW (t
))
542 else if (CP_INTEGRAL_TYPE_P (type
))
544 t
= fold_non_dependent_expr (t
);
546 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
553 /* Returns true iff T is a null member pointer value (4.11). */
556 null_member_pointer_value_p (tree t
)
558 tree type
= TREE_TYPE (t
);
561 else if (TYPE_PTRMEMFUNC_P (type
))
562 return (TREE_CODE (t
) == CONSTRUCTOR
563 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
564 else if (TYPE_PTRDATAMEM_P (type
))
565 return integer_all_onesp (t
);
570 /* Returns nonzero if PARMLIST consists of only default parms,
571 ellipsis, and/or undeduced parameter packs. */
574 sufficient_parms_p (const_tree parmlist
)
576 for (; parmlist
&& parmlist
!= void_list_node
;
577 parmlist
= TREE_CHAIN (parmlist
))
578 if (!TREE_PURPOSE (parmlist
)
579 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
584 /* Allocate N bytes of memory from the conversion obstack. The memory
585 is zeroed before being returned. */
588 conversion_obstack_alloc (size_t n
)
591 if (!conversion_obstack_initialized
)
593 gcc_obstack_init (&conversion_obstack
);
594 conversion_obstack_initialized
= true;
596 p
= obstack_alloc (&conversion_obstack
, n
);
601 /* Allocate rejection reasons. */
603 static struct rejection_reason
*
604 alloc_rejection (enum rejection_reason_code code
)
606 struct rejection_reason
*p
;
607 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
612 static struct rejection_reason
*
613 arity_rejection (tree first_arg
, int expected
, int actual
)
615 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
616 int adjust
= first_arg
!= NULL_TREE
;
617 r
->u
.arity
.expected
= expected
- adjust
;
618 r
->u
.arity
.actual
= actual
- adjust
;
622 static struct rejection_reason
*
623 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
625 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
626 int adjust
= first_arg
!= NULL_TREE
;
627 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
628 r
->u
.conversion
.from
= from
;
629 r
->u
.conversion
.to_type
= to
;
633 static struct rejection_reason
*
634 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
636 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
637 int adjust
= first_arg
!= NULL_TREE
;
638 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
639 r
->u
.bad_conversion
.from
= from
;
640 r
->u
.bad_conversion
.to_type
= to
;
644 static struct rejection_reason
*
645 explicit_conversion_rejection (tree from
, tree to
)
647 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
648 r
->u
.conversion
.n_arg
= 0;
649 r
->u
.conversion
.from
= from
;
650 r
->u
.conversion
.to_type
= to
;
654 static struct rejection_reason
*
655 template_conversion_rejection (tree from
, tree to
)
657 struct rejection_reason
*r
= alloc_rejection (rr_template_conversion
);
658 r
->u
.conversion
.n_arg
= 0;
659 r
->u
.conversion
.from
= from
;
660 r
->u
.conversion
.to_type
= to
;
664 static struct rejection_reason
*
665 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
666 const tree
*args
, unsigned int nargs
,
667 tree return_type
, unification_kind_t strict
,
670 size_t args_n_bytes
= sizeof (*args
) * nargs
;
671 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
672 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
673 r
->u
.template_unification
.tmpl
= tmpl
;
674 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
675 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
676 /* Copy args to our own storage. */
677 memcpy (args1
, args
, args_n_bytes
);
678 r
->u
.template_unification
.args
= args1
;
679 r
->u
.template_unification
.nargs
= nargs
;
680 r
->u
.template_unification
.return_type
= return_type
;
681 r
->u
.template_unification
.strict
= strict
;
682 r
->u
.template_unification
.flags
= flags
;
686 static struct rejection_reason
*
687 template_unification_error_rejection (void)
689 return alloc_rejection (rr_template_unification
);
692 static struct rejection_reason
*
693 invalid_copy_with_fn_template_rejection (void)
695 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
699 // Build a constraint failure record, saving information into the
700 // template_instantiation field of the rejection. If FN is not a template
701 // declaration, the TMPL member is the FN declaration and TARGS is empty.
703 static struct rejection_reason
*
704 constraint_failure (tree fn
)
706 struct rejection_reason
*r
= alloc_rejection (rr_constraint_failure
);
707 if (tree ti
= DECL_TEMPLATE_INFO (fn
))
709 r
->u
.template_instantiation
.tmpl
= TI_TEMPLATE (ti
);
710 r
->u
.template_instantiation
.targs
= TI_ARGS (ti
);
714 r
->u
.template_instantiation
.tmpl
= fn
;
715 r
->u
.template_instantiation
.targs
= NULL_TREE
;
720 /* Dynamically allocate a conversion. */
723 alloc_conversion (conversion_kind kind
)
726 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
731 #ifdef ENABLE_CHECKING
733 /* Make sure that all memory on the conversion obstack has been
737 validate_conversion_obstack (void)
739 if (conversion_obstack_initialized
)
740 gcc_assert ((obstack_next_free (&conversion_obstack
)
741 == obstack_base (&conversion_obstack
)));
744 #endif /* ENABLE_CHECKING */
746 /* Dynamically allocate an array of N conversions. */
749 alloc_conversions (size_t n
)
751 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
755 build_conv (conversion_kind code
, tree type
, conversion
*from
)
758 conversion_rank rank
= CONVERSION_RANK (from
);
760 /* Note that the caller is responsible for filling in t->cand for
761 user-defined conversions. */
762 t
= alloc_conversion (code
);
785 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
786 t
->bad_p
= from
->bad_p
;
791 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
792 specialization of std::initializer_list<T>, if such a conversion is
796 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
798 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
799 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
800 conversion
**subconvs
= alloc_conversions (len
);
805 /* Within a list-initialization we can have more user-defined
807 flags
&= ~LOOKUP_NO_CONVERSION
;
808 /* But no narrowing conversions. */
809 flags
|= LOOKUP_NO_NARROWING
;
811 /* Can't make an array of these types. */
812 if (TREE_CODE (elttype
) == REFERENCE_TYPE
813 || TREE_CODE (elttype
) == FUNCTION_TYPE
814 || VOID_TYPE_P (elttype
))
817 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
820 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
821 false, flags
, complain
);
828 t
= alloc_conversion (ck_list
);
830 t
->u
.list
= subconvs
;
833 for (i
= 0; i
< len
; ++i
)
835 conversion
*sub
= subconvs
[i
];
836 if (sub
->rank
> t
->rank
)
838 if (sub
->user_conv_p
)
839 t
->user_conv_p
= true;
847 /* Return the next conversion of the conversion chain (if applicable),
848 or NULL otherwise. Please use this function instead of directly
849 accessing fields of struct conversion. */
852 next_conversion (conversion
*conv
)
855 || conv
->kind
== ck_identity
856 || conv
->kind
== ck_ambig
857 || conv
->kind
== ck_list
)
862 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
863 is a valid aggregate initializer for array type ATYPE. */
866 can_convert_array (tree atype
, tree ctor
, int flags
, tsubst_flags_t complain
)
869 tree elttype
= TREE_TYPE (atype
);
870 for (i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
872 tree val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
874 if (TREE_CODE (elttype
) == ARRAY_TYPE
875 && TREE_CODE (val
) == CONSTRUCTOR
)
876 ok
= can_convert_array (elttype
, val
, flags
, complain
);
878 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
886 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
887 aggregate class, if such a conversion is possible. */
890 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
892 unsigned HOST_WIDE_INT i
= 0;
894 tree field
= next_initializable_field (TYPE_FIELDS (type
));
895 tree empty_ctor
= NULL_TREE
;
897 /* We already called reshape_init in implicit_conversion. */
899 /* The conversions within the init-list aren't affected by the enclosing
900 context; they're always simple copy-initialization. */
901 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
903 for (; field
; field
= next_initializable_field (DECL_CHAIN (field
)))
905 tree ftype
= TREE_TYPE (field
);
909 if (i
< CONSTRUCTOR_NELTS (ctor
))
910 val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
911 else if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
912 /* Value-initialization of reference is ill-formed. */
916 if (empty_ctor
== NULL_TREE
)
917 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
922 if (TREE_CODE (ftype
) == ARRAY_TYPE
923 && TREE_CODE (val
) == CONSTRUCTOR
)
924 ok
= can_convert_array (ftype
, val
, flags
, complain
);
926 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
932 if (TREE_CODE (type
) == UNION_TYPE
)
936 if (i
< CONSTRUCTOR_NELTS (ctor
))
939 c
= alloc_conversion (ck_aggr
);
942 c
->user_conv_p
= true;
943 c
->check_narrowing
= true;
948 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
949 array type, if such a conversion is possible. */
952 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
955 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
956 tree elttype
= TREE_TYPE (type
);
961 enum conversion_rank rank
= cr_exact
;
963 /* We might need to propagate the size from the element to the array. */
964 complete_type (type
);
966 if (TYPE_DOMAIN (type
)
967 && !variably_modified_type_p (TYPE_DOMAIN (type
), NULL_TREE
))
969 unsigned HOST_WIDE_INT alen
= tree_to_uhwi (array_type_nelts_top (type
));
974 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
976 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
979 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
980 false, flags
, complain
);
984 if (sub
->rank
> rank
)
986 if (sub
->user_conv_p
)
992 c
= alloc_conversion (ck_aggr
);
995 c
->user_conv_p
= user
;
1001 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
1002 complex type, if such a conversion is possible. */
1005 build_complex_conv (tree type
, tree ctor
, int flags
,
1006 tsubst_flags_t complain
)
1009 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1010 tree elttype
= TREE_TYPE (type
);
1015 enum conversion_rank rank
= cr_exact
;
1020 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1022 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
1025 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
1026 false, flags
, complain
);
1030 if (sub
->rank
> rank
)
1032 if (sub
->user_conv_p
)
1038 c
= alloc_conversion (ck_aggr
);
1041 c
->user_conv_p
= user
;
1047 /* Build a representation of the identity conversion from EXPR to
1048 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1051 build_identity_conv (tree type
, tree expr
)
1055 c
= alloc_conversion (ck_identity
);
1062 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1063 were multiple user-defined conversions to accomplish the job.
1064 Build a conversion that indicates that ambiguity. */
1067 build_ambiguous_conv (tree type
, tree expr
)
1071 c
= alloc_conversion (ck_ambig
);
1079 strip_top_quals (tree t
)
1081 if (TREE_CODE (t
) == ARRAY_TYPE
)
1083 return cp_build_qualified_type (t
, 0);
1086 /* Returns the standard conversion path (see [conv]) from type FROM to type
1087 TO, if any. For proper handling of null pointer constants, you must
1088 also pass the expression EXPR to convert from. If C_CAST_P is true,
1089 this conversion is coming from a C-style cast. */
1092 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1095 enum tree_code fcode
, tcode
;
1097 bool fromref
= false;
1100 to
= non_reference (to
);
1101 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1104 from
= TREE_TYPE (from
);
1107 to
= strip_top_quals (to
);
1108 from
= strip_top_quals (from
);
1110 if (expr
&& type_unknown_p (expr
))
1112 if (TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1114 tsubst_flags_t tflags
= tf_conv
;
1115 expr
= instantiate_type (to
, expr
, tflags
);
1116 if (expr
== error_mark_node
)
1118 from
= TREE_TYPE (expr
);
1120 else if (TREE_CODE (to
) == BOOLEAN_TYPE
)
1122 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1123 expr
= resolve_nondeduced_context (expr
);
1124 from
= TREE_TYPE (expr
);
1128 fcode
= TREE_CODE (from
);
1129 tcode
= TREE_CODE (to
);
1131 conv
= build_identity_conv (from
, expr
);
1132 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1134 from
= type_decays_to (from
);
1135 fcode
= TREE_CODE (from
);
1136 conv
= build_conv (ck_lvalue
, from
, conv
);
1138 else if (fromref
|| (expr
&& lvalue_p (expr
)))
1143 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1146 from
= strip_top_quals (bitfield_type
);
1147 fcode
= TREE_CODE (from
);
1150 conv
= build_conv (ck_rvalue
, from
, conv
);
1151 if (flags
& LOOKUP_PREFER_RVALUE
)
1152 conv
->rvaluedness_matches_p
= true;
1155 /* Allow conversion between `__complex__' data types. */
1156 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1158 /* The standard conversion sequence to convert FROM to TO is
1159 the standard conversion sequence to perform componentwise
1161 conversion
*part_conv
= standard_conversion
1162 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
);
1166 conv
= build_conv (part_conv
->kind
, to
, conv
);
1167 conv
->rank
= part_conv
->rank
;
1175 if (same_type_p (from
, to
))
1177 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1178 conv
->type
= qualified_to
;
1183 A null pointer constant can be converted to a pointer type; ... A
1184 null pointer constant of integral type can be converted to an
1185 rvalue of type std::nullptr_t. */
1186 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1187 || NULLPTR_TYPE_P (to
))
1188 && ((expr
&& null_ptr_cst_p (expr
))
1189 || NULLPTR_TYPE_P (from
)))
1190 conv
= build_conv (ck_std
, to
, conv
);
1191 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1192 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1194 /* For backwards brain damage compatibility, allow interconversion of
1195 pointers and integers with a pedwarn. */
1196 conv
= build_conv (ck_std
, to
, conv
);
1199 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1201 /* For backwards brain damage compatibility, allow interconversion of
1202 enums and integers with a pedwarn. */
1203 conv
= build_conv (ck_std
, to
, conv
);
1206 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1207 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1212 if (tcode
== POINTER_TYPE
1213 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from
),
1216 else if (VOID_TYPE_P (TREE_TYPE (to
))
1217 && !TYPE_PTRDATAMEM_P (from
)
1218 && TREE_CODE (TREE_TYPE (from
)) != FUNCTION_TYPE
)
1220 tree nfrom
= TREE_TYPE (from
);
1221 /* Don't try to apply restrict to void. */
1222 int quals
= cp_type_quals (nfrom
) & ~TYPE_QUAL_RESTRICT
;
1223 from
= build_pointer_type
1224 (cp_build_qualified_type (void_type_node
, quals
));
1225 conv
= build_conv (ck_ptr
, from
, conv
);
1227 else if (TYPE_PTRDATAMEM_P (from
))
1229 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1230 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1232 if (DERIVED_FROM_P (fbase
, tbase
)
1233 && (same_type_ignoring_top_level_qualifiers_p
1234 (TYPE_PTRMEM_POINTED_TO_TYPE (from
),
1235 TYPE_PTRMEM_POINTED_TO_TYPE (to
))))
1237 from
= build_ptrmem_type (tbase
,
1238 TYPE_PTRMEM_POINTED_TO_TYPE (from
));
1239 conv
= build_conv (ck_pmem
, from
, conv
);
1241 else if (!same_type_p (fbase
, tbase
))
1244 else if (CLASS_TYPE_P (TREE_TYPE (from
))
1245 && CLASS_TYPE_P (TREE_TYPE (to
))
1248 An rvalue of type "pointer to cv D," where D is a
1249 class type, can be converted to an rvalue of type
1250 "pointer to cv B," where B is a base class (clause
1251 _class.derived_) of D. If B is an inaccessible
1252 (clause _class.access_) or ambiguous
1253 (_class.member.lookup_) base class of D, a program
1254 that necessitates this conversion is ill-formed.
1255 Therefore, we use DERIVED_FROM_P, and do not check
1256 access or uniqueness. */
1257 && DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
1260 cp_build_qualified_type (TREE_TYPE (to
),
1261 cp_type_quals (TREE_TYPE (from
)));
1262 from
= build_pointer_type (from
);
1263 conv
= build_conv (ck_ptr
, from
, conv
);
1264 conv
->base_p
= true;
1266 else if (tx_safe_fn_type_p (TREE_TYPE (from
)))
1268 /* A prvalue of type "pointer to transaction_safe function" can be
1269 converted to a prvalue of type "pointer to function". */
1270 tree unsafe
= tx_unsafe_fn_variant (TREE_TYPE (from
));
1271 if (same_type_p (unsafe
, TREE_TYPE (to
)))
1273 from
= build_pointer_type (unsafe
);
1274 conv
= build_conv (ck_tsafe
, from
, conv
);
1278 if (tcode
== POINTER_TYPE
)
1280 to_pointee
= TREE_TYPE (to
);
1281 from_pointee
= TREE_TYPE (from
);
1285 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1286 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1289 if (same_type_p (from
, to
))
1291 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
1292 /* In a C-style cast, we ignore CV-qualification because we
1293 are allowed to perform a static_cast followed by a
1295 conv
= build_conv (ck_qual
, to
, conv
);
1296 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1297 conv
= build_conv (ck_qual
, to
, conv
);
1298 else if (expr
&& string_conv_p (to
, expr
, 0))
1299 /* converting from string constant to char *. */
1300 conv
= build_conv (ck_qual
, to
, conv
);
1301 /* Allow conversions among compatible ObjC pointer types (base
1302 conversions have been already handled above). */
1303 else if (c_dialect_objc ()
1304 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1305 conv
= build_conv (ck_ptr
, to
, conv
);
1306 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1308 conv
= build_conv (ck_ptr
, to
, conv
);
1316 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1318 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1319 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1320 tree fbase
= class_of_this_parm (fromfn
);
1321 tree tbase
= class_of_this_parm (tofn
);
1323 if (!DERIVED_FROM_P (fbase
, tbase
)
1324 || !same_type_p (static_fn_type (fromfn
),
1325 static_fn_type (tofn
)))
1328 from
= build_memfn_type (fromfn
,
1330 cp_type_quals (tbase
),
1331 type_memfn_rqual (tofn
));
1332 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1333 conv
= build_conv (ck_pmem
, from
, conv
);
1334 conv
->base_p
= true;
1336 else if (tcode
== BOOLEAN_TYPE
)
1340 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1341 to member type can be converted to a prvalue of type bool. ...
1342 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1343 std::nullptr_t can be converted to a prvalue of type bool; */
1344 if (ARITHMETIC_TYPE_P (from
)
1345 || UNSCOPED_ENUM_P (from
)
1346 || fcode
== POINTER_TYPE
1347 || TYPE_PTRMEM_P (from
)
1348 || NULLPTR_TYPE_P (from
))
1350 conv
= build_conv (ck_std
, to
, conv
);
1351 if (fcode
== POINTER_TYPE
1352 || TYPE_PTRDATAMEM_P (from
)
1353 || (TYPE_PTRMEMFUNC_P (from
)
1354 && conv
->rank
< cr_pbool
)
1355 || NULLPTR_TYPE_P (from
))
1356 conv
->rank
= cr_pbool
;
1357 if (NULLPTR_TYPE_P (from
) && (flags
& LOOKUP_ONLYCONVERTING
))
1364 /* We don't check for ENUMERAL_TYPE here because there are no standard
1365 conversions to enum type. */
1366 /* As an extension, allow conversion to complex type. */
1367 else if (ARITHMETIC_TYPE_P (to
))
1369 if (! (INTEGRAL_CODE_P (fcode
)
1370 || (fcode
== REAL_TYPE
&& !(flags
& LOOKUP_NO_NON_INTEGRAL
)))
1371 || SCOPED_ENUM_P (from
))
1373 conv
= build_conv (ck_std
, to
, conv
);
1375 /* Give this a better rank if it's a promotion. */
1376 if (same_type_p (to
, type_promotes_to (from
))
1377 && next_conversion (conv
)->rank
<= cr_promotion
)
1378 conv
->rank
= cr_promotion
;
1380 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1381 && vector_types_convertible_p (from
, to
, false))
1382 return build_conv (ck_std
, to
, conv
);
1383 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1384 && is_properly_derived_from (from
, to
))
1386 if (conv
->kind
== ck_rvalue
)
1387 conv
= next_conversion (conv
);
1388 conv
= build_conv (ck_base
, to
, conv
);
1389 /* The derived-to-base conversion indicates the initialization
1390 of a parameter with base type from an object of a derived
1391 type. A temporary object is created to hold the result of
1392 the conversion unless we're binding directly to a reference. */
1393 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1398 if (flags
& LOOKUP_NO_NARROWING
)
1399 conv
->check_narrowing
= true;
1404 /* Returns nonzero if T1 is reference-related to T2. */
1407 reference_related_p (tree t1
, tree t2
)
1409 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1412 t1
= TYPE_MAIN_VARIANT (t1
);
1413 t2
= TYPE_MAIN_VARIANT (t2
);
1417 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1418 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1420 return (same_type_p (t1
, t2
)
1421 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1422 && DERIVED_FROM_P (t1
, t2
)));
1425 /* Returns nonzero if T1 is reference-compatible with T2. */
1428 reference_compatible_p (tree t1
, tree t2
)
1432 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1433 reference-related to T2 and cv1 is the same cv-qualification as,
1434 or greater cv-qualification than, cv2. */
1435 return (reference_related_p (t1
, t2
)
1436 && at_least_as_qualified_p (t1
, t2
));
1439 /* A reference of the indicated TYPE is being bound directly to the
1440 expression represented by the implicit conversion sequence CONV.
1441 Return a conversion sequence for this binding. */
1444 direct_reference_binding (tree type
, conversion
*conv
)
1448 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1449 gcc_assert (TREE_CODE (conv
->type
) != REFERENCE_TYPE
);
1451 t
= TREE_TYPE (type
);
1455 When a parameter of reference type binds directly
1456 (_dcl.init.ref_) to an argument expression, the implicit
1457 conversion sequence is the identity conversion, unless the
1458 argument expression has a type that is a derived class of the
1459 parameter type, in which case the implicit conversion sequence is
1460 a derived-to-base Conversion.
1462 If the parameter binds directly to the result of applying a
1463 conversion function to the argument expression, the implicit
1464 conversion sequence is a user-defined conversion sequence
1465 (_over.ics.user_), with the second standard conversion sequence
1466 either an identity conversion or, if the conversion function
1467 returns an entity of a type that is a derived class of the
1468 parameter type, a derived-to-base conversion. */
1469 if (!same_type_ignoring_top_level_qualifiers_p (t
, conv
->type
))
1471 /* Represent the derived-to-base conversion. */
1472 conv
= build_conv (ck_base
, t
, conv
);
1473 /* We will actually be binding to the base-class subobject in
1474 the derived class, so we mark this conversion appropriately.
1475 That way, convert_like knows not to generate a temporary. */
1476 conv
->need_temporary_p
= false;
1478 return build_conv (ck_ref_bind
, type
, conv
);
1481 /* Returns the conversion path from type FROM to reference type TO for
1482 purposes of reference binding. For lvalue binding, either pass a
1483 reference type to FROM or an lvalue expression to EXPR. If the
1484 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1485 the conversion returned. If C_CAST_P is true, this
1486 conversion is coming from a C-style cast. */
1489 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1490 tsubst_flags_t complain
)
1492 conversion
*conv
= NULL
;
1493 tree to
= TREE_TYPE (rto
);
1498 cp_lvalue_kind gl_kind
;
1501 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1503 expr
= instantiate_type (to
, expr
, tf_none
);
1504 if (expr
== error_mark_node
)
1506 from
= TREE_TYPE (expr
);
1509 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1511 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1512 /* DR 1288: Otherwise, if the initializer list has a single element
1513 of type E and ... [T's] referenced type is reference-related to E,
1514 the object or reference is initialized from that element... */
1515 if (CONSTRUCTOR_NELTS (expr
) == 1)
1517 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1518 if (error_operand_p (elt
))
1520 tree etype
= TREE_TYPE (elt
);
1521 if (reference_related_p (to
, etype
))
1528 /* Otherwise, if T is a reference type, a prvalue temporary of the
1529 type referenced by T is copy-list-initialized or
1530 direct-list-initialized, depending on the kind of initialization
1531 for the reference, and the reference is bound to that temporary. */
1532 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1533 flags
|LOOKUP_NO_TEMP_BIND
, complain
);
1537 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1539 from
= TREE_TYPE (from
);
1540 if (!TYPE_REF_IS_RVALUE (rfrom
)
1541 || TREE_CODE (from
) == FUNCTION_TYPE
)
1542 gl_kind
= clk_ordinary
;
1544 gl_kind
= clk_rvalueref
;
1548 gl_kind
= lvalue_kind (expr
);
1549 if (gl_kind
& clk_class
)
1550 /* A class prvalue is not a glvalue. */
1555 is_lvalue
= gl_kind
&& !(gl_kind
& clk_rvalueref
);
1558 if ((gl_kind
& clk_bitfield
) != 0)
1559 tfrom
= unlowered_expr_type (expr
);
1561 /* Figure out whether or not the types are reference-related and
1562 reference compatible. We have to do this after stripping
1563 references from FROM. */
1564 related_p
= reference_related_p (to
, tfrom
);
1565 /* If this is a C cast, first convert to an appropriately qualified
1566 type, so that we can later do a const_cast to the desired type. */
1567 if (related_p
&& c_cast_p
1568 && !at_least_as_qualified_p (to
, tfrom
))
1569 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1570 compatible_p
= reference_compatible_p (to
, tfrom
);
1572 /* Directly bind reference when target expression's type is compatible with
1573 the reference and expression is an lvalue. In DR391, the wording in
1574 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1575 const and rvalue references to rvalues of compatible class type.
1576 We should also do direct bindings for non-class xvalues. */
1579 || (!(flags
& LOOKUP_NO_TEMP_BIND
)
1580 && (CLASS_TYPE_P (from
)
1581 || TREE_CODE (from
) == ARRAY_TYPE
))))
1585 If the initializer expression
1587 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1588 is reference-compatible with "cv2 T2,"
1590 the reference is bound directly to the initializer expression
1594 If the initializer expression is an rvalue, with T2 a class type,
1595 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1596 is bound to the object represented by the rvalue or to a sub-object
1597 within that object. */
1599 conv
= build_identity_conv (tfrom
, expr
);
1600 conv
= direct_reference_binding (rto
, conv
);
1602 if (flags
& LOOKUP_PREFER_RVALUE
)
1603 /* The top-level caller requested that we pretend that the lvalue
1604 be treated as an rvalue. */
1605 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1606 else if (TREE_CODE (rfrom
) == REFERENCE_TYPE
)
1607 /* Handle rvalue reference to function properly. */
1608 conv
->rvaluedness_matches_p
1609 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1611 conv
->rvaluedness_matches_p
1612 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1614 if ((gl_kind
& clk_bitfield
) != 0
1615 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1616 /* For the purposes of overload resolution, we ignore the fact
1617 this expression is a bitfield or packed field. (In particular,
1618 [over.ics.ref] says specifically that a function with a
1619 non-const reference parameter is viable even if the
1620 argument is a bitfield.)
1622 However, when we actually call the function we must create
1623 a temporary to which to bind the reference. If the
1624 reference is volatile, or isn't const, then we cannot make
1625 a temporary, so we just issue an error when the conversion
1627 conv
->need_temporary_p
= true;
1629 /* Don't allow binding of lvalues (other than function lvalues) to
1630 rvalue references. */
1631 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1632 && TREE_CODE (to
) != FUNCTION_TYPE
1633 && !(flags
& LOOKUP_PREFER_RVALUE
))
1636 /* Nor the reverse. */
1637 if (!is_lvalue
&& !TYPE_REF_IS_RVALUE (rto
)
1638 && (!CP_TYPE_CONST_NON_VOLATILE_P (to
)
1639 || (flags
& LOOKUP_NO_RVAL_BIND
))
1640 && TREE_CODE (to
) != FUNCTION_TYPE
)
1648 /* [class.conv.fct] A conversion function is never used to convert a
1649 (possibly cv-qualified) object to the (possibly cv-qualified) same
1650 object type (or a reference to it), to a (possibly cv-qualified) base
1651 class of that type (or a reference to it).... */
1652 else if (CLASS_TYPE_P (from
) && !related_p
1653 && !(flags
& LOOKUP_NO_CONVERSION
))
1657 If the initializer expression
1659 -- has a class type (i.e., T2 is a class type) can be
1660 implicitly converted to an lvalue of type "cv3 T3," where
1661 "cv1 T1" is reference-compatible with "cv3 T3". (this
1662 conversion is selected by enumerating the applicable
1663 conversion functions (_over.match.ref_) and choosing the
1664 best one through overload resolution. (_over.match_).
1666 the reference is bound to the lvalue result of the conversion
1667 in the second case. */
1668 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1671 return cand
->second_conv
;
1674 /* From this point on, we conceptually need temporaries, even if we
1675 elide them. Only the cases above are "direct bindings". */
1676 if (flags
& LOOKUP_NO_TEMP_BIND
)
1681 When a parameter of reference type is not bound directly to an
1682 argument expression, the conversion sequence is the one required
1683 to convert the argument expression to the underlying type of the
1684 reference according to _over.best.ics_. Conceptually, this
1685 conversion sequence corresponds to copy-initializing a temporary
1686 of the underlying type with the argument expression. Any
1687 difference in top-level cv-qualification is subsumed by the
1688 initialization itself and does not constitute a conversion. */
1692 Otherwise, the reference shall be an lvalue reference to a
1693 non-volatile const type, or the reference shall be an rvalue
1696 We try below to treat this as a bad conversion to improve diagnostics,
1697 but if TO is an incomplete class, we need to reject this conversion
1698 now to avoid unnecessary instantiation. */
1699 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
)
1700 && !COMPLETE_TYPE_P (to
))
1703 /* We're generating a temporary now, but don't bind any more in the
1704 conversion (specifically, don't slice the temporary returned by a
1705 conversion operator). */
1706 flags
|= LOOKUP_NO_TEMP_BIND
;
1708 /* Core issue 899: When [copy-]initializing a temporary to be bound
1709 to the first parameter of a copy constructor (12.8) called with
1710 a single argument in the context of direct-initialization,
1711 explicit conversion functions are also considered.
1713 So don't set LOOKUP_ONLYCONVERTING in that case. */
1714 if (!(flags
& LOOKUP_COPY_PARM
))
1715 flags
|= LOOKUP_ONLYCONVERTING
;
1718 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1723 if (conv
->user_conv_p
)
1725 /* If initializing the temporary used a conversion function,
1726 recalculate the second conversion sequence. */
1727 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1728 if (t
->kind
== ck_user
1729 && DECL_CONV_FN_P (t
->cand
->fn
))
1731 tree ftype
= TREE_TYPE (TREE_TYPE (t
->cand
->fn
));
1732 int sflags
= (flags
|LOOKUP_NO_CONVERSION
)&~LOOKUP_NO_TEMP_BIND
;
1733 conversion
*new_second
1734 = reference_binding (rto
, ftype
, NULL_TREE
, c_cast_p
,
1738 return merge_conversion_sequences (t
, new_second
);
1742 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1743 /* This reference binding, unlike those above, requires the
1744 creation of a temporary. */
1745 conv
->need_temporary_p
= true;
1746 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1750 Otherwise, the reference shall be an lvalue reference to a
1751 non-volatile const type, or the reference shall be an rvalue
1753 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1758 Otherwise, a temporary of type "cv1 T1" is created and
1759 initialized from the initializer expression using the rules for a
1760 non-reference copy initialization. If T1 is reference-related to
1761 T2, cv1 must be the same cv-qualification as, or greater
1762 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1763 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1769 /* Returns the implicit conversion sequence (see [over.ics]) from type
1770 FROM to type TO. The optional expression EXPR may affect the
1771 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1772 true, this conversion is coming from a C-style cast. */
1775 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1776 int flags
, tsubst_flags_t complain
)
1780 if (from
== error_mark_node
|| to
== error_mark_node
1781 || expr
== error_mark_node
)
1784 /* Other flags only apply to the primary function in overload
1785 resolution, or after we've chosen one. */
1786 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
1787 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_PREFER_RVALUE
1788 |LOOKUP_NO_NARROWING
|LOOKUP_PROTECT
|LOOKUP_NO_NON_INTEGRAL
);
1790 /* FIXME: actually we don't want warnings either, but we can't just
1791 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1792 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1793 We really ought not to issue that warning until we've committed
1794 to that conversion. */
1795 complain
&= ~tf_error
;
1797 /* Call reshape_init early to remove redundant braces. */
1798 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
)
1799 && CLASS_TYPE_P (to
)
1800 && COMPLETE_TYPE_P (complete_type (to
))
1801 && !CLASSTYPE_NON_AGGREGATE (to
))
1803 expr
= reshape_init (to
, expr
, complain
);
1804 if (expr
== error_mark_node
)
1806 from
= TREE_TYPE (expr
);
1809 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1810 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
1812 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
);
1817 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1819 if (is_std_init_list (to
))
1820 return build_list_conv (to
, expr
, flags
, complain
);
1822 /* As an extension, allow list-initialization of _Complex. */
1823 if (TREE_CODE (to
) == COMPLEX_TYPE
)
1825 conv
= build_complex_conv (to
, expr
, flags
, complain
);
1830 /* Allow conversion from an initializer-list with one element to a
1832 if (SCALAR_TYPE_P (to
))
1834 int nelts
= CONSTRUCTOR_NELTS (expr
);
1838 elt
= build_value_init (to
, tf_none
);
1839 else if (nelts
== 1)
1840 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1842 elt
= error_mark_node
;
1844 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
1845 c_cast_p
, flags
, complain
);
1848 conv
->check_narrowing
= true;
1849 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
1850 /* Too many levels of braces, i.e. '{{1}}'. */
1855 else if (TREE_CODE (to
) == ARRAY_TYPE
)
1856 return build_array_conv (to
, expr
, flags
, complain
);
1859 if (expr
!= NULL_TREE
1860 && (MAYBE_CLASS_TYPE_P (from
)
1861 || MAYBE_CLASS_TYPE_P (to
))
1862 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1864 struct z_candidate
*cand
;
1866 if (CLASS_TYPE_P (to
)
1867 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
1868 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
1869 return build_aggr_conv (to
, expr
, flags
, complain
);
1871 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
1873 conv
= cand
->second_conv
;
1875 /* We used to try to bind a reference to a temporary here, but that
1876 is now handled after the recursive call to this function at the end
1877 of reference_binding. */
1884 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1885 functions. ARGS will not be changed until a single candidate is
1888 static struct z_candidate
*
1889 add_candidate (struct z_candidate
**candidates
,
1890 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
1891 size_t num_convs
, conversion
**convs
,
1892 tree access_path
, tree conversion_path
,
1893 int viable
, struct rejection_reason
*reason
,
1896 struct z_candidate
*cand
= (struct z_candidate
*)
1897 conversion_obstack_alloc (sizeof (struct z_candidate
));
1900 cand
->first_arg
= first_arg
;
1902 cand
->convs
= convs
;
1903 cand
->num_convs
= num_convs
;
1904 cand
->access_path
= access_path
;
1905 cand
->conversion_path
= conversion_path
;
1906 cand
->viable
= viable
;
1907 cand
->reason
= reason
;
1908 cand
->next
= *candidates
;
1909 cand
->flags
= flags
;
1915 /* Return the number of remaining arguments in the parameter list
1916 beginning with ARG. */
1919 remaining_arguments (tree arg
)
1923 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
1924 arg
= TREE_CHAIN (arg
))
1930 /* Create an overload candidate for the function or method FN called
1931 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1932 FLAGS is passed on to implicit_conversion.
1934 This does not change ARGS.
1936 CTYPE, if non-NULL, is the type we want to pretend this function
1937 comes from for purposes of overload resolution. */
1939 static struct z_candidate
*
1940 add_function_candidate (struct z_candidate
**candidates
,
1941 tree fn
, tree ctype
, tree first_arg
,
1942 const vec
<tree
, va_gc
> *args
, tree access_path
,
1943 tree conversion_path
, int flags
,
1944 tsubst_flags_t complain
)
1946 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1950 tree orig_first_arg
= first_arg
;
1953 struct rejection_reason
*reason
= NULL
;
1955 /* At this point we should not see any functions which haven't been
1956 explicitly declared, except for friend functions which will have
1957 been found using argument dependent lookup. */
1958 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
1960 /* The `this', `in_chrg' and VTT arguments to constructors are not
1961 considered in overload resolution. */
1962 if (DECL_CONSTRUCTOR_P (fn
))
1964 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1965 skip
= num_artificial_parms_for (fn
);
1966 if (skip
> 0 && first_arg
!= NULL_TREE
)
1969 first_arg
= NULL_TREE
;
1975 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
1976 convs
= alloc_conversions (len
);
1978 /* 13.3.2 - Viable functions [over.match.viable]
1979 First, to be a viable function, a candidate function shall have enough
1980 parameters to agree in number with the arguments in the list.
1982 We need to check this first; otherwise, checking the ICSes might cause
1983 us to produce an ill-formed template instantiation. */
1985 parmnode
= parmlist
;
1986 for (i
= 0; i
< len
; ++i
)
1988 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1990 parmnode
= TREE_CHAIN (parmnode
);
1993 if ((i
< len
&& parmnode
)
1994 || !sufficient_parms_p (parmnode
))
1996 int remaining
= remaining_arguments (parmnode
);
1998 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
2001 /* Second, for a function to be viable, its constraints must be
2003 if (flag_concepts
&& viable
2004 && !constraints_satisfied_p (fn
))
2006 reason
= constraint_failure (fn
);
2010 /* When looking for a function from a subobject from an implicit
2011 copy/move constructor/operator=, don't consider anything that takes (a
2012 reference to) an unrelated type. See c++/44909 and core 1092. */
2013 if (viable
&& parmlist
&& (flags
& LOOKUP_DEFAULTED
))
2015 if (DECL_CONSTRUCTOR_P (fn
))
2017 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
2018 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
2024 parmnode
= chain_index (i
-1, parmlist
);
2025 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
2030 /* This only applies at the top level. */
2031 flags
&= ~LOOKUP_DEFAULTED
;
2037 /* Third, for F to be a viable function, there shall exist for each
2038 argument an implicit conversion sequence that converts that argument
2039 to the corresponding parameter of F. */
2041 parmnode
= parmlist
;
2043 for (i
= 0; i
< len
; ++i
)
2045 tree argtype
, to_type
;
2050 if (parmnode
== void_list_node
)
2053 if (i
== 0 && first_arg
!= NULL_TREE
)
2056 arg
= CONST_CAST_TREE (
2057 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
2058 argtype
= lvalue_type (arg
);
2060 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2061 && ! DECL_CONSTRUCTOR_P (fn
));
2065 tree parmtype
= TREE_VALUE (parmnode
);
2068 parmnode
= TREE_CHAIN (parmnode
);
2070 /* The type of the implicit object parameter ('this') for
2071 overload resolution is not always the same as for the
2072 function itself; conversion functions are considered to
2073 be members of the class being converted, and functions
2074 introduced by a using-declaration are considered to be
2075 members of the class that uses them.
2077 Since build_over_call ignores the ICS for the `this'
2078 parameter, we can just change the parm type. */
2079 if (ctype
&& is_this
)
2081 parmtype
= cp_build_qualified_type
2082 (ctype
, cp_type_quals (TREE_TYPE (parmtype
)));
2083 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
2085 /* If the function has a ref-qualifier, the implicit
2086 object parameter has reference type. */
2087 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
2088 parmtype
= cp_build_reference_type (parmtype
, rv
);
2089 /* The special handling of 'this' conversions in compare_ics
2090 does not apply if there is a ref-qualifier. */
2095 parmtype
= build_pointer_type (parmtype
);
2096 arg
= build_this (arg
);
2097 argtype
= lvalue_type (arg
);
2101 /* Core issue 899: When [copy-]initializing a temporary to be bound
2102 to the first parameter of a copy constructor (12.8) called with
2103 a single argument in the context of direct-initialization,
2104 explicit conversion functions are also considered.
2106 So set LOOKUP_COPY_PARM to let reference_binding know that
2107 it's being called in that context. We generalize the above
2108 to handle move constructors and template constructors as well;
2109 the standardese should soon be updated similarly. */
2110 if (ctype
&& i
== 0 && (len
-skip
== 1)
2111 && DECL_CONSTRUCTOR_P (fn
)
2112 && parmtype
!= error_mark_node
2113 && (same_type_ignoring_top_level_qualifiers_p
2114 (non_reference (parmtype
), ctype
)))
2116 if (!(flags
& LOOKUP_ONLYCONVERTING
))
2117 lflags
|= LOOKUP_COPY_PARM
;
2118 /* We allow user-defined conversions within init-lists, but
2119 don't list-initialize the copy parm, as that would mean
2120 using two levels of braces for the same type. */
2121 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
2122 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
2123 lflags
|= LOOKUP_NO_CONVERSION
;
2126 lflags
|= LOOKUP_ONLYCONVERTING
;
2128 t
= implicit_conversion (parmtype
, argtype
, arg
,
2129 /*c_cast_p=*/false, lflags
, complain
);
2134 t
= build_identity_conv (argtype
, arg
);
2135 t
->ellipsis_p
= true;
2146 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
);
2153 reason
= bad_arg_conversion_rejection (first_arg
, i
, arg
, to_type
);
2158 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2159 access_path
, conversion_path
, viable
, reason
, flags
);
2162 /* Create an overload candidate for the conversion function FN which will
2163 be invoked for expression OBJ, producing a pointer-to-function which
2164 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2165 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2166 passed on to implicit_conversion.
2168 Actually, we don't really care about FN; we care about the type it
2169 converts to. There may be multiple conversion functions that will
2170 convert to that type, and we rely on build_user_type_conversion_1 to
2171 choose the best one; so when we create our candidate, we record the type
2172 instead of the function. */
2174 static struct z_candidate
*
2175 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2176 const vec
<tree
, va_gc
> *arglist
,
2177 tree access_path
, tree conversion_path
,
2178 tsubst_flags_t complain
)
2180 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2181 int i
, len
, viable
, flags
;
2182 tree parmlist
, parmnode
;
2184 struct rejection_reason
*reason
;
2186 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2187 parmlist
= TREE_TYPE (parmlist
);
2188 parmlist
= TYPE_ARG_TYPES (parmlist
);
2190 len
= vec_safe_length (arglist
) + 1;
2191 convs
= alloc_conversions (len
);
2192 parmnode
= parmlist
;
2194 flags
= LOOKUP_IMPLICIT
;
2197 /* Don't bother looking up the same type twice. */
2198 if (*candidates
&& (*candidates
)->fn
== totype
)
2201 for (i
= 0; i
< len
; ++i
)
2203 tree arg
, argtype
, convert_type
= NULL_TREE
;
2209 arg
= (*arglist
)[i
- 1];
2210 argtype
= lvalue_type (arg
);
2214 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
2216 convert_type
= totype
;
2218 else if (parmnode
== void_list_node
)
2222 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2223 /*c_cast_p=*/false, flags
, complain
);
2224 convert_type
= TREE_VALUE (parmnode
);
2228 t
= build_identity_conv (argtype
, arg
);
2229 t
->ellipsis_p
= true;
2230 convert_type
= argtype
;
2240 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, arg
, convert_type
);
2247 parmnode
= TREE_CHAIN (parmnode
);
2251 || ! sufficient_parms_p (parmnode
))
2253 int remaining
= remaining_arguments (parmnode
);
2255 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2258 return add_candidate (candidates
, totype
, obj
, arglist
, len
, convs
,
2259 access_path
, conversion_path
, viable
, reason
, flags
);
2263 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2264 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
2265 int flags
, tsubst_flags_t complain
)
2272 struct rejection_reason
*reason
= NULL
;
2277 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
2278 convs
= alloc_conversions (num_convs
);
2280 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2281 conversion ops are allowed. We handle that here by just checking for
2282 boolean_type_node because other operators don't ask for it. COND_EXPR
2283 also does contextual conversion to bool for the first operand, but we
2284 handle that in build_conditional_expr, and type1 here is operand 2. */
2285 if (type1
!= boolean_type_node
)
2286 flags
|= LOOKUP_ONLYCONVERTING
;
2288 for (i
= 0; i
< 2; ++i
)
2293 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2294 /*c_cast_p=*/false, flags
, complain
);
2298 /* We need something for printing the candidate. */
2299 t
= build_identity_conv (types
[i
], NULL_TREE
);
2300 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2306 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, args
[i
],
2312 /* For COND_EXPR we rearranged the arguments; undo that now. */
2315 convs
[2] = convs
[1];
2316 convs
[1] = convs
[0];
2317 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2318 /*c_cast_p=*/false, flags
,
2325 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2330 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2332 /*access_path=*/NULL_TREE
,
2333 /*conversion_path=*/NULL_TREE
,
2334 viable
, reason
, flags
);
2338 is_complete (tree t
)
2340 return COMPLETE_TYPE_P (complete_type (t
));
2343 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2346 promoted_arithmetic_type_p (tree type
)
2350 In this section, the term promoted integral type is used to refer
2351 to those integral types which are preserved by integral promotion
2352 (including e.g. int and long but excluding e.g. char).
2353 Similarly, the term promoted arithmetic type refers to promoted
2354 integral types plus floating types. */
2355 return ((CP_INTEGRAL_TYPE_P (type
)
2356 && same_type_p (type_promotes_to (type
), type
))
2357 || TREE_CODE (type
) == REAL_TYPE
);
2360 /* Create any builtin operator overload candidates for the operator in
2361 question given the converted operand types TYPE1 and TYPE2. The other
2362 args are passed through from add_builtin_candidates to
2363 build_builtin_candidate.
2365 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2366 If CODE is requires candidates operands of the same type of the kind
2367 of which TYPE1 and TYPE2 are, we add both candidates
2368 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2371 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2372 enum tree_code code2
, tree fnname
, tree type1
,
2373 tree type2
, tree
*args
, tree
*argtypes
, int flags
,
2374 tsubst_flags_t complain
)
2378 case POSTINCREMENT_EXPR
:
2379 case POSTDECREMENT_EXPR
:
2380 args
[1] = integer_zero_node
;
2381 type2
= integer_type_node
;
2390 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2391 and VQ is either volatile or empty, there exist candidate operator
2392 functions of the form
2393 VQ T& operator++(VQ T&);
2394 T operator++(VQ T&, int);
2395 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2396 type other than bool, and VQ is either volatile or empty, there exist
2397 candidate operator functions of the form
2398 VQ T& operator--(VQ T&);
2399 T operator--(VQ T&, int);
2400 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2401 complete object type, and VQ is either volatile or empty, there exist
2402 candidate operator functions of the form
2403 T*VQ& operator++(T*VQ&);
2404 T*VQ& operator--(T*VQ&);
2405 T* operator++(T*VQ&, int);
2406 T* operator--(T*VQ&, int); */
2408 case POSTDECREMENT_EXPR
:
2409 case PREDECREMENT_EXPR
:
2410 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2412 case POSTINCREMENT_EXPR
:
2413 case PREINCREMENT_EXPR
:
2414 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2416 type1
= build_reference_type (type1
);
2421 /* 7 For every cv-qualified or cv-unqualified object type T, there
2422 exist candidate operator functions of the form
2426 8 For every function type T, there exist candidate operator functions of
2428 T& operator*(T*); */
2431 if (TYPE_PTR_P (type1
)
2432 && (TYPE_PTROB_P (type1
)
2433 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2437 /* 9 For every type T, there exist candidate operator functions of the form
2440 10For every promoted arithmetic type T, there exist candidate operator
2441 functions of the form
2445 case UNARY_PLUS_EXPR
: /* unary + */
2446 if (TYPE_PTR_P (type1
))
2449 if (ARITHMETIC_TYPE_P (type1
))
2453 /* 11For every promoted integral type T, there exist candidate operator
2454 functions of the form
2458 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2462 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2463 is the same type as C2 or is a derived class of C2, T is a complete
2464 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2465 there exist candidate operator functions of the form
2466 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2467 where CV12 is the union of CV1 and CV2. */
2470 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2472 tree c1
= TREE_TYPE (type1
);
2473 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2475 if (MAYBE_CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2476 && (TYPE_PTRMEMFUNC_P (type2
)
2477 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2482 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2483 didate operator functions of the form
2488 bool operator<(L, R);
2489 bool operator>(L, R);
2490 bool operator<=(L, R);
2491 bool operator>=(L, R);
2492 bool operator==(L, R);
2493 bool operator!=(L, R);
2494 where LR is the result of the usual arithmetic conversions between
2497 14For every pair of types T and I, where T is a cv-qualified or cv-
2498 unqualified complete object type and I is a promoted integral type,
2499 there exist candidate operator functions of the form
2500 T* operator+(T*, I);
2501 T& operator[](T*, I);
2502 T* operator-(T*, I);
2503 T* operator+(I, T*);
2504 T& operator[](I, T*);
2506 15For every T, where T is a pointer to complete object type, there exist
2507 candidate operator functions of the form112)
2508 ptrdiff_t operator-(T, T);
2510 16For every pointer or enumeration type T, there exist candidate operator
2511 functions of the form
2512 bool operator<(T, T);
2513 bool operator>(T, T);
2514 bool operator<=(T, T);
2515 bool operator>=(T, T);
2516 bool operator==(T, T);
2517 bool operator!=(T, T);
2519 17For every pointer to member type T, there exist candidate operator
2520 functions of the form
2521 bool operator==(T, T);
2522 bool operator!=(T, T); */
2525 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2527 if (TYPE_PTROB_P (type1
)
2528 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2530 type2
= ptrdiff_type_node
;
2534 case TRUNC_DIV_EXPR
:
2535 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2541 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2542 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
2544 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
2549 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
2561 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2563 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2565 if (TREE_CODE (type1
) == ENUMERAL_TYPE
2566 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
2568 if (TYPE_PTR_P (type1
)
2569 && null_ptr_cst_p (args
[1]))
2574 if (null_ptr_cst_p (args
[0])
2575 && TYPE_PTR_P (type2
))
2583 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2586 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
2588 type1
= ptrdiff_type_node
;
2591 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2593 type2
= ptrdiff_type_node
;
2598 /* 18For every pair of promoted integral types L and R, there exist candi-
2599 date operator functions of the form
2606 where LR is the result of the usual arithmetic conversions between
2609 case TRUNC_MOD_EXPR
:
2615 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2619 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2620 type, VQ is either volatile or empty, and R is a promoted arithmetic
2621 type, there exist candidate operator functions of the form
2622 VQ L& operator=(VQ L&, R);
2623 VQ L& operator*=(VQ L&, R);
2624 VQ L& operator/=(VQ L&, R);
2625 VQ L& operator+=(VQ L&, R);
2626 VQ L& operator-=(VQ L&, R);
2628 20For every pair T, VQ), where T is any type and VQ is either volatile
2629 or empty, there exist candidate operator functions of the form
2630 T*VQ& operator=(T*VQ&, T*);
2632 21For every pair T, VQ), where T is a pointer to member type and VQ is
2633 either volatile or empty, there exist candidate operator functions of
2635 VQ T& operator=(VQ T&, T);
2637 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2638 unqualified complete object type, VQ is either volatile or empty, and
2639 I is a promoted integral type, there exist candidate operator func-
2641 T*VQ& operator+=(T*VQ&, I);
2642 T*VQ& operator-=(T*VQ&, I);
2644 23For every triple L, VQ, R), where L is an integral or enumeration
2645 type, VQ is either volatile or empty, and R is a promoted integral
2646 type, there exist candidate operator functions of the form
2648 VQ L& operator%=(VQ L&, R);
2649 VQ L& operator<<=(VQ L&, R);
2650 VQ L& operator>>=(VQ L&, R);
2651 VQ L& operator&=(VQ L&, R);
2652 VQ L& operator^=(VQ L&, R);
2653 VQ L& operator|=(VQ L&, R); */
2660 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2662 type2
= ptrdiff_type_node
;
2666 case TRUNC_DIV_EXPR
:
2667 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2671 case TRUNC_MOD_EXPR
:
2677 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2682 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2684 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2685 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2686 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2687 || ((TYPE_PTRMEMFUNC_P (type1
)
2688 || TYPE_PTR_P (type1
))
2689 && null_ptr_cst_p (args
[1])))
2699 type1
= build_reference_type (type1
);
2705 For every pair of promoted arithmetic types L and R, there
2706 exist candidate operator functions of the form
2708 LR operator?(bool, L, R);
2710 where LR is the result of the usual arithmetic conversions
2711 between types L and R.
2713 For every type T, where T is a pointer or pointer-to-member
2714 type, there exist candidate operator functions of the form T
2715 operator?(bool, T, T); */
2717 if (promoted_arithmetic_type_p (type1
)
2718 && promoted_arithmetic_type_p (type2
))
2722 /* Otherwise, the types should be pointers. */
2723 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
2726 /* We don't check that the two types are the same; the logic
2727 below will actually create two candidates; one in which both
2728 parameter types are TYPE1, and one in which both parameter
2734 if (ARITHMETIC_TYPE_P (type1
))
2742 /* Make sure we don't create builtin candidates with dependent types. */
2743 bool u1
= uses_template_parms (type1
);
2744 bool u2
= type2
? uses_template_parms (type2
) : false;
2747 /* Try to recover if one of the types is non-dependent. But if
2748 there's only one type, there's nothing we can do. */
2751 /* And we lose if both are dependent. */
2754 /* Or if they have different forms. */
2755 if (TREE_CODE (type1
) != TREE_CODE (type2
))
2764 /* If we're dealing with two pointer types or two enumeral types,
2765 we need candidates for both of them. */
2766 if (type2
&& !same_type_p (type1
, type2
)
2767 && TREE_CODE (type1
) == TREE_CODE (type2
)
2768 && (TREE_CODE (type1
) == REFERENCE_TYPE
2769 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2770 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2771 || TYPE_PTRMEMFUNC_P (type1
)
2772 || MAYBE_CLASS_TYPE_P (type1
)
2773 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2775 if (TYPE_PTR_OR_PTRMEM_P (type1
))
2777 tree cptype
= composite_pointer_type (type1
, type2
,
2782 if (cptype
!= error_mark_node
)
2784 build_builtin_candidate
2785 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
2791 build_builtin_candidate
2792 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
2793 build_builtin_candidate
2794 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
2798 build_builtin_candidate
2799 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
2803 type_decays_to (tree type
)
2805 if (TREE_CODE (type
) == ARRAY_TYPE
)
2806 return build_pointer_type (TREE_TYPE (type
));
2807 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2808 return build_pointer_type (type
);
2812 /* There are three conditions of builtin candidates:
2814 1) bool-taking candidates. These are the same regardless of the input.
2815 2) pointer-pair taking candidates. These are generated for each type
2816 one of the input types converts to.
2817 3) arithmetic candidates. According to the standard, we should generate
2818 all of these, but I'm trying not to...
2820 Here we generate a superset of the possible candidates for this particular
2821 case. That is a subset of the full set the standard defines, plus some
2822 other cases which the standard disallows. add_builtin_candidate will
2823 filter out the invalid set. */
2826 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2827 enum tree_code code2
, tree fnname
, tree
*args
,
2828 int flags
, tsubst_flags_t complain
)
2832 tree type
, argtypes
[3], t
;
2833 /* TYPES[i] is the set of possible builtin-operator parameter types
2834 we will consider for the Ith argument. */
2835 vec
<tree
, va_gc
> *types
[2];
2838 for (i
= 0; i
< 3; ++i
)
2841 argtypes
[i
] = unlowered_expr_type (args
[i
]);
2843 argtypes
[i
] = NULL_TREE
;
2848 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2849 and VQ is either volatile or empty, there exist candidate operator
2850 functions of the form
2851 VQ T& operator++(VQ T&); */
2853 case POSTINCREMENT_EXPR
:
2854 case PREINCREMENT_EXPR
:
2855 case POSTDECREMENT_EXPR
:
2856 case PREDECREMENT_EXPR
:
2861 /* 24There also exist candidate operator functions of the form
2862 bool operator!(bool);
2863 bool operator&&(bool, bool);
2864 bool operator||(bool, bool); */
2866 case TRUTH_NOT_EXPR
:
2867 build_builtin_candidate
2868 (candidates
, fnname
, boolean_type_node
,
2869 NULL_TREE
, args
, argtypes
, flags
, complain
);
2872 case TRUTH_ORIF_EXPR
:
2873 case TRUTH_ANDIF_EXPR
:
2874 build_builtin_candidate
2875 (candidates
, fnname
, boolean_type_node
,
2876 boolean_type_node
, args
, argtypes
, flags
, complain
);
2898 types
[0] = make_tree_vector ();
2899 types
[1] = make_tree_vector ();
2901 for (i
= 0; i
< 2; ++i
)
2905 else if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
2909 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2912 convs
= lookup_conversions (argtypes
[i
]);
2914 if (code
== COND_EXPR
)
2916 if (real_lvalue_p (args
[i
]))
2917 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2919 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
2925 for (; convs
; convs
= TREE_CHAIN (convs
))
2927 type
= TREE_TYPE (convs
);
2930 && (TREE_CODE (type
) != REFERENCE_TYPE
2931 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2934 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2935 vec_safe_push (types
[i
], type
);
2937 type
= non_reference (type
);
2938 if (i
!= 0 || ! ref1
)
2940 type
= cv_unqualified (type_decays_to (type
));
2941 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2942 vec_safe_push (types
[i
], type
);
2943 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2944 type
= type_promotes_to (type
);
2947 if (! vec_member (type
, types
[i
]))
2948 vec_safe_push (types
[i
], type
);
2953 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2954 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2955 type
= non_reference (argtypes
[i
]);
2956 if (i
!= 0 || ! ref1
)
2958 type
= cv_unqualified (type_decays_to (type
));
2959 if (enum_p
&& UNSCOPED_ENUM_P (type
))
2960 vec_safe_push (types
[i
], type
);
2961 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2962 type
= type_promotes_to (type
);
2964 vec_safe_push (types
[i
], type
);
2968 /* Run through the possible parameter types of both arguments,
2969 creating candidates with those parameter types. */
2970 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
2975 if (!types
[1]->is_empty ())
2976 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
2977 add_builtin_candidate
2978 (candidates
, code
, code2
, fnname
, t
,
2979 u
, args
, argtypes
, flags
, complain
);
2981 add_builtin_candidate
2982 (candidates
, code
, code2
, fnname
, t
,
2983 NULL_TREE
, args
, argtypes
, flags
, complain
);
2986 release_tree_vector (types
[0]);
2987 release_tree_vector (types
[1]);
2991 /* If TMPL can be successfully instantiated as indicated by
2992 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2994 TMPL is the template. EXPLICIT_TARGS are any explicit template
2995 arguments. ARGLIST is the arguments provided at the call-site.
2996 This does not change ARGLIST. The RETURN_TYPE is the desired type
2997 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2998 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2999 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
3001 static struct z_candidate
*
3002 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
3003 tree ctype
, tree explicit_targs
, tree first_arg
,
3004 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3005 tree access_path
, tree conversion_path
,
3006 int flags
, tree obj
, unification_kind_t strict
,
3007 tsubst_flags_t complain
)
3009 int ntparms
= DECL_NTPARMS (tmpl
);
3010 tree targs
= make_tree_vec (ntparms
);
3011 unsigned int len
= vec_safe_length (arglist
);
3012 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
3013 unsigned int skip_without_in_chrg
= 0;
3014 tree first_arg_without_in_chrg
= first_arg
;
3015 tree
*args_without_in_chrg
;
3016 unsigned int nargs_without_in_chrg
;
3017 unsigned int ia
, ix
;
3019 struct z_candidate
*cand
;
3021 struct rejection_reason
*reason
= NULL
;
3024 /* We don't do deduction on the in-charge parameter, the VTT
3025 parameter or 'this'. */
3026 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
3028 if (first_arg_without_in_chrg
!= NULL_TREE
)
3029 first_arg_without_in_chrg
= NULL_TREE
;
3031 ++skip_without_in_chrg
;
3034 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
3035 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
3036 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
3038 if (first_arg_without_in_chrg
!= NULL_TREE
)
3039 first_arg_without_in_chrg
= NULL_TREE
;
3041 ++skip_without_in_chrg
;
3044 if (len
< skip_without_in_chrg
)
3047 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
3048 + (len
- skip_without_in_chrg
));
3049 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
3051 if (first_arg_without_in_chrg
!= NULL_TREE
)
3053 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
3056 for (ix
= skip_without_in_chrg
;
3057 vec_safe_iterate (arglist
, ix
, &arg
);
3060 args_without_in_chrg
[ia
] = arg
;
3063 gcc_assert (ia
== nargs_without_in_chrg
);
3065 errs
= errorcount
+sorrycount
;
3066 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
3067 args_without_in_chrg
,
3068 nargs_without_in_chrg
,
3069 return_type
, strict
, flags
, false,
3070 complain
& tf_decltype
);
3072 if (fn
== error_mark_node
)
3074 /* Don't repeat unification later if it already resulted in errors. */
3075 if (errorcount
+sorrycount
== errs
)
3076 reason
= template_unification_rejection (tmpl
, explicit_targs
,
3077 targs
, args_without_in_chrg
,
3078 nargs_without_in_chrg
,
3079 return_type
, strict
, flags
);
3081 reason
= template_unification_error_rejection ();
3087 A member function template is never instantiated to perform the
3088 copy of a class object to an object of its class type.
3090 It's a little unclear what this means; the standard explicitly
3091 does allow a template to be used to copy a class. For example,
3096 template <class T> A(const T&);
3099 void g () { A a (f ()); }
3101 the member template will be used to make the copy. The section
3102 quoted above appears in the paragraph that forbids constructors
3103 whose only parameter is (a possibly cv-qualified variant of) the
3104 class type, and a logical interpretation is that the intent was
3105 to forbid the instantiation of member templates which would then
3107 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
3109 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3110 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
3113 reason
= invalid_copy_with_fn_template_rejection ();
3118 if (obj
!= NULL_TREE
)
3119 /* Aha, this is a conversion function. */
3120 cand
= add_conv_candidate (candidates
, fn
, obj
, arglist
,
3121 access_path
, conversion_path
, complain
);
3123 cand
= add_function_candidate (candidates
, fn
, ctype
,
3124 first_arg
, arglist
, access_path
,
3125 conversion_path
, flags
, complain
);
3126 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
3127 /* This situation can occur if a member template of a template
3128 class is specialized. Then, instantiate_template might return
3129 an instantiation of the specialization, in which case the
3130 DECL_TI_TEMPLATE field will point at the original
3131 specialization. For example:
3133 template <class T> struct S { template <class U> void f(U);
3134 template <> void f(int) {}; };
3138 Here, TMPL will be template <class U> S<double>::f(U).
3139 And, instantiate template will give us the specialization
3140 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3141 for this will point at template <class T> template <> S<T>::f(int),
3142 so that we can find the definition. For the purposes of
3143 overload resolution, however, we want the original TMPL. */
3144 cand
->template_decl
= build_template_info (tmpl
, targs
);
3146 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3147 cand
->explicit_targs
= explicit_targs
;
3151 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, NULL
,
3152 access_path
, conversion_path
, 0, reason
, flags
);
3156 static struct z_candidate
*
3157 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3158 tree explicit_targs
, tree first_arg
,
3159 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3160 tree access_path
, tree conversion_path
, int flags
,
3161 unification_kind_t strict
, tsubst_flags_t complain
)
3164 add_template_candidate_real (candidates
, tmpl
, ctype
,
3165 explicit_targs
, first_arg
, arglist
,
3166 return_type
, access_path
, conversion_path
,
3167 flags
, NULL_TREE
, strict
, complain
);
3171 static struct z_candidate
*
3172 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3174 const vec
<tree
, va_gc
> *arglist
,
3175 tree return_type
, tree access_path
,
3176 tree conversion_path
, tsubst_flags_t complain
)
3179 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3180 NULL_TREE
, arglist
, return_type
, access_path
,
3181 conversion_path
, 0, obj
, DEDUCE_CONV
,
3185 /* The CANDS are the set of candidates that were considered for
3186 overload resolution. Return the set of viable candidates, or CANDS
3187 if none are viable. If any of the candidates were viable, set
3188 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3189 considered viable only if it is strictly viable. */
3191 static struct z_candidate
*
3192 splice_viable (struct z_candidate
*cands
,
3196 struct z_candidate
*viable
;
3197 struct z_candidate
**last_viable
;
3198 struct z_candidate
**cand
;
3199 bool found_strictly_viable
= false;
3201 /* Be strict inside templates, since build_over_call won't actually
3202 do the conversions to get pedwarns. */
3203 if (processing_template_decl
)
3207 last_viable
= &viable
;
3208 *any_viable_p
= false;
3213 struct z_candidate
*c
= *cand
;
3215 && (c
->viable
== 1 || TREE_CODE (c
->fn
) == TEMPLATE_DECL
))
3217 /* Be strict in the presence of a viable candidate. Also if
3218 there are template candidates, so that we get deduction errors
3219 for them instead of silently preferring a bad conversion. */
3221 if (viable
&& !found_strictly_viable
)
3223 /* Put any spliced near matches back onto the main list so
3224 that we see them if there is no strict match. */
3225 *any_viable_p
= false;
3226 *last_viable
= cands
;
3229 last_viable
= &viable
;
3233 if (strict_p
? c
->viable
== 1 : c
->viable
)
3238 last_viable
= &c
->next
;
3239 *any_viable_p
= true;
3241 found_strictly_viable
= true;
3247 return viable
? viable
: cands
;
3251 any_strictly_viable (struct z_candidate
*cands
)
3253 for (; cands
; cands
= cands
->next
)
3254 if (cands
->viable
== 1)
3259 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3260 words, it is about to become the "this" pointer for a member
3261 function call. Take the address of the object. */
3264 build_this (tree obj
)
3266 /* In a template, we are only concerned about the type of the
3267 expression, so we can take a shortcut. */
3268 if (processing_template_decl
)
3269 return build_address (obj
);
3271 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3274 /* Returns true iff functions are equivalent. Equivalent functions are
3275 not '==' only if one is a function-local extern function or if
3276 both are extern "C". */
3279 equal_functions (tree fn1
, tree fn2
)
3281 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3283 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3285 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
3286 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3287 return decls_match (fn1
, fn2
);
3291 /* Print information about a candidate being rejected due to INFO. */
3294 print_conversion_rejection (location_t loc
, struct conversion_info
*info
)
3296 tree from
= info
->from
;
3298 from
= lvalue_type (from
);
3299 if (info
->n_arg
== -1)
3301 /* Conversion of implicit `this' argument failed. */
3302 if (!TYPE_P (info
->from
))
3303 /* A bad conversion for 'this' must be discarding cv-quals. */
3304 inform (loc
, " passing %qT as %<this%> "
3305 "argument discards qualifiers",
3308 inform (loc
, " no known conversion for implicit "
3309 "%<this%> parameter from %qT to %qT",
3310 from
, info
->to_type
);
3312 else if (!TYPE_P (info
->from
))
3314 if (info
->n_arg
>= 0)
3315 inform (loc
, " conversion of argument %d would be ill-formed:",
3317 perform_implicit_conversion (info
->to_type
, info
->from
,
3318 tf_warning_or_error
);
3320 else if (info
->n_arg
== -2)
3321 /* Conversion of conversion function return value failed. */
3322 inform (loc
, " no known conversion from %qT to %qT",
3323 from
, info
->to_type
);
3325 inform (loc
, " no known conversion for argument %d from %qT to %qT",
3326 info
->n_arg
+ 1, from
, info
->to_type
);
3329 /* Print information about a candidate with WANT parameters and we found
3333 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
)
3335 inform_n (loc
, want
,
3336 " candidate expects %d argument, %d provided",
3337 " candidate expects %d arguments, %d provided",
3341 /* Print information about one overload candidate CANDIDATE. MSGSTR
3342 is the text to print before the candidate itself.
3344 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3345 to have been run through gettext by the caller. This wart makes
3346 life simpler in print_z_candidates and for the translators. */
3349 print_z_candidate (location_t loc
, const char *msgstr
,
3350 struct z_candidate
*candidate
)
3352 const char *msg
= (msgstr
== NULL
3354 : ACONCAT ((msgstr
, " ", NULL
)));
3355 location_t cloc
= location_of (candidate
->fn
);
3357 if (identifier_p (candidate
->fn
))
3360 if (candidate
->num_convs
== 3)
3361 inform (cloc
, "%s%D(%T, %T, %T) <built-in>", msg
, candidate
->fn
,
3362 candidate
->convs
[0]->type
,
3363 candidate
->convs
[1]->type
,
3364 candidate
->convs
[2]->type
);
3365 else if (candidate
->num_convs
== 2)
3366 inform (cloc
, "%s%D(%T, %T) <built-in>", msg
, candidate
->fn
,
3367 candidate
->convs
[0]->type
,
3368 candidate
->convs
[1]->type
);
3370 inform (cloc
, "%s%D(%T) <built-in>", msg
, candidate
->fn
,
3371 candidate
->convs
[0]->type
);
3373 else if (TYPE_P (candidate
->fn
))
3374 inform (cloc
, "%s%T <conversion>", msg
, candidate
->fn
);
3375 else if (candidate
->viable
== -1)
3376 inform (cloc
, "%s%#D <near match>", msg
, candidate
->fn
);
3377 else if (DECL_DELETED_FN (candidate
->fn
))
3378 inform (cloc
, "%s%#D <deleted>", msg
, candidate
->fn
);
3380 inform (cloc
, "%s%#D", msg
, candidate
->fn
);
3381 /* Give the user some information about why this candidate failed. */
3382 if (candidate
->reason
!= NULL
)
3384 struct rejection_reason
*r
= candidate
->reason
;
3389 print_arity_information (cloc
, r
->u
.arity
.actual
,
3390 r
->u
.arity
.expected
);
3392 case rr_arg_conversion
:
3393 print_conversion_rejection (cloc
, &r
->u
.conversion
);
3395 case rr_bad_arg_conversion
:
3396 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
);
3398 case rr_explicit_conversion
:
3399 inform (cloc
, " return type %qT of explicit conversion function "
3400 "cannot be converted to %qT with a qualification "
3401 "conversion", r
->u
.conversion
.from
,
3402 r
->u
.conversion
.to_type
);
3404 case rr_template_conversion
:
3405 inform (cloc
, " conversion from return type %qT of template "
3406 "conversion function specialization to %qT is not an "
3407 "exact match", r
->u
.conversion
.from
,
3408 r
->u
.conversion
.to_type
);
3410 case rr_template_unification
:
3411 /* We use template_unification_error_rejection if unification caused
3412 actual non-SFINAE errors, in which case we don't need to repeat
3414 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
3416 inform (cloc
, " substitution of deduced template arguments "
3417 "resulted in errors seen above");
3420 /* Re-run template unification with diagnostics. */
3421 inform (cloc
, " template argument deduction/substitution failed:");
3422 fn_type_unification (r
->u
.template_unification
.tmpl
,
3423 r
->u
.template_unification
.explicit_targs
,
3425 (r
->u
.template_unification
.num_targs
)),
3426 r
->u
.template_unification
.args
,
3427 r
->u
.template_unification
.nargs
,
3428 r
->u
.template_unification
.return_type
,
3429 r
->u
.template_unification
.strict
,
3430 r
->u
.template_unification
.flags
,
3433 case rr_invalid_copy
:
3435 " a constructor taking a single argument of its own "
3436 "class type is invalid");
3438 case rr_constraint_failure
:
3440 tree tmpl
= r
->u
.template_instantiation
.tmpl
;
3441 tree args
= r
->u
.template_instantiation
.targs
;
3442 diagnose_constraints (cloc
, tmpl
, args
);
3447 /* This candidate didn't have any issues or we failed to
3448 handle a particular code. Either way... */
3455 print_z_candidates (location_t loc
, struct z_candidate
*candidates
)
3457 struct z_candidate
*cand1
;
3458 struct z_candidate
**cand2
;
3463 /* Remove non-viable deleted candidates. */
3465 for (cand2
= &cand1
; *cand2
; )
3467 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
3468 && !(*cand2
)->viable
3469 && DECL_DELETED_FN ((*cand2
)->fn
))
3470 *cand2
= (*cand2
)->next
;
3472 cand2
= &(*cand2
)->next
;
3474 /* ...if there are any non-deleted ones. */
3478 /* There may be duplicates in the set of candidates. We put off
3479 checking this condition as long as possible, since we have no way
3480 to eliminate duplicates from a set of functions in less than n^2
3481 time. Now we are about to emit an error message, so it is more
3482 permissible to go slowly. */
3483 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3485 tree fn
= cand1
->fn
;
3486 /* Skip builtin candidates and conversion functions. */
3489 cand2
= &cand1
->next
;
3492 if (DECL_P ((*cand2
)->fn
)
3493 && equal_functions (fn
, (*cand2
)->fn
))
3494 *cand2
= (*cand2
)->next
;
3496 cand2
= &(*cand2
)->next
;
3500 for (; candidates
; candidates
= candidates
->next
)
3501 print_z_candidate (loc
, "candidate:", candidates
);
3504 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3505 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3506 the result of the conversion function to convert it to the final
3507 desired type. Merge the two sequences into a single sequence,
3508 and return the merged sequence. */
3511 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
3514 bool bad
= user_seq
->bad_p
;
3516 gcc_assert (user_seq
->kind
== ck_user
);
3518 /* Find the end of the second conversion sequence. */
3519 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
3521 /* The entire sequence is a user-conversion sequence. */
3522 (*t
)->user_conv_p
= true;
3527 /* Replace the identity conversion with the user conversion
3534 /* Handle overload resolution for initializing an object of class type from
3535 an initializer list. First we look for a suitable constructor that
3536 takes a std::initializer_list; if we don't find one, we then look for a
3537 non-list constructor.
3539 Parameters are as for add_candidates, except that the arguments are in
3540 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3541 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3544 add_list_candidates (tree fns
, tree first_arg
,
3545 tree init_list
, tree totype
,
3546 tree explicit_targs
, bool template_only
,
3547 tree conversion_path
, tree access_path
,
3549 struct z_candidate
**candidates
,
3550 tsubst_flags_t complain
)
3552 vec
<tree
, va_gc
> *args
;
3554 gcc_assert (*candidates
== NULL
);
3556 /* We're looking for a ctor for list-initialization. */
3557 flags
|= LOOKUP_LIST_INIT_CTOR
;
3558 /* And we don't allow narrowing conversions. We also use this flag to
3559 avoid the copy constructor call for copy-list-initialization. */
3560 flags
|= LOOKUP_NO_NARROWING
;
3562 /* Always use the default constructor if the list is empty (DR 990). */
3563 if (CONSTRUCTOR_NELTS (init_list
) == 0
3564 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
3566 /* If the class has a list ctor, try passing the list as a single
3567 argument first, but only consider list ctors. */
3568 else if (TYPE_HAS_LIST_CTOR (totype
))
3570 flags
|= LOOKUP_LIST_ONLY
;
3571 args
= make_tree_vector_single (init_list
);
3572 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3573 explicit_targs
, template_only
, conversion_path
,
3574 access_path
, flags
, candidates
, complain
);
3575 if (any_strictly_viable (*candidates
))
3579 args
= ctor_to_vec (init_list
);
3581 /* We aren't looking for list-ctors anymore. */
3582 flags
&= ~LOOKUP_LIST_ONLY
;
3583 /* We allow more user-defined conversions within an init-list. */
3584 flags
&= ~LOOKUP_NO_CONVERSION
;
3586 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3587 explicit_targs
, template_only
, conversion_path
,
3588 access_path
, flags
, candidates
, complain
);
3591 /* Returns the best overload candidate to perform the requested
3592 conversion. This function is used for three the overloading situations
3593 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3594 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3595 per [dcl.init.ref], so we ignore temporary bindings. */
3597 static struct z_candidate
*
3598 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
3599 tsubst_flags_t complain
)
3601 struct z_candidate
*candidates
, *cand
;
3603 tree ctors
= NULL_TREE
;
3604 tree conv_fns
= NULL_TREE
;
3605 conversion
*conv
= NULL
;
3606 tree first_arg
= NULL_TREE
;
3607 vec
<tree
, va_gc
> *args
= NULL
;
3614 fromtype
= TREE_TYPE (expr
);
3616 /* We represent conversion within a hierarchy using RVALUE_CONV and
3617 BASE_CONV, as specified by [over.best.ics]; these become plain
3618 constructor calls, as specified in [dcl.init]. */
3619 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
3620 || !DERIVED_FROM_P (totype
, fromtype
));
3622 if (MAYBE_CLASS_TYPE_P (totype
))
3623 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3624 creating a garbage BASELINK; constructors can't be inherited. */
3625 ctors
= lookup_fnfields_slot (totype
, complete_ctor_identifier
);
3627 if (MAYBE_CLASS_TYPE_P (fromtype
))
3629 tree to_nonref
= non_reference (totype
);
3630 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
3631 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
3632 && DERIVED_FROM_P (to_nonref
, fromtype
)))
3634 /* [class.conv.fct] A conversion function is never used to
3635 convert a (possibly cv-qualified) object to the (possibly
3636 cv-qualified) same object type (or a reference to it), to a
3637 (possibly cv-qualified) base class of that type (or a
3638 reference to it)... */
3641 conv_fns
= lookup_conversions (fromtype
);
3645 flags
|= LOOKUP_NO_CONVERSION
;
3646 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3647 flags
|= LOOKUP_NO_NARROWING
;
3649 /* It's OK to bind a temporary for converting constructor arguments, but
3650 not in converting the return value of a conversion operator. */
3651 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
3652 | (flags
& LOOKUP_NO_NARROWING
));
3653 flags
&= ~LOOKUP_NO_TEMP_BIND
;
3657 int ctorflags
= flags
;
3659 first_arg
= build_dummy_object (totype
);
3661 /* We should never try to call the abstract or base constructor
3663 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
3664 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
3666 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3668 /* List-initialization. */
3669 add_list_candidates (ctors
, first_arg
, expr
, totype
, NULL_TREE
,
3670 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3671 ctorflags
, &candidates
, complain
);
3675 args
= make_tree_vector_single (expr
);
3676 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
3677 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3678 ctorflags
, &candidates
, complain
);
3681 for (cand
= candidates
; cand
; cand
= cand
->next
)
3683 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
3685 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3686 set, then this is copy-initialization. In that case, "The
3687 result of the call is then used to direct-initialize the
3688 object that is the destination of the copy-initialization."
3691 We represent this in the conversion sequence with an
3692 rvalue conversion, which means a constructor call. */
3693 if (TREE_CODE (totype
) != REFERENCE_TYPE
3694 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3696 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
3703 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
3705 tree conversion_path
= TREE_PURPOSE (conv_fns
);
3706 struct z_candidate
*old_candidates
;
3708 /* If we are called to convert to a reference type, we are trying to
3709 find a direct binding, so don't even consider temporaries. If
3710 we don't find a direct binding, the caller will try again to
3711 look for a temporary binding. */
3712 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
3713 convflags
|= LOOKUP_NO_TEMP_BIND
;
3715 old_candidates
= candidates
;
3716 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
3718 conversion_path
, TYPE_BINFO (fromtype
),
3719 flags
, &candidates
, complain
);
3721 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
3723 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
3725 = implicit_conversion (totype
,
3728 /*c_cast_p=*/false, convflags
,
3731 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3732 copy-initialization. In that case, "The result of the
3733 call is then used to direct-initialize the object that is
3734 the destination of the copy-initialization." [dcl.init]
3736 We represent this in the conversion sequence with an
3737 rvalue conversion, which means a constructor call. But
3738 don't add a second rvalue conversion if there's already
3739 one there. Which there really shouldn't be, but it's
3740 harmless since we'd add it here anyway. */
3741 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
3742 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3743 ics
= build_conv (ck_rvalue
, totype
, ics
);
3745 cand
->second_conv
= ics
;
3750 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -2,
3753 else if (DECL_NONCONVERTING_P (cand
->fn
)
3754 && ics
->rank
> cr_exact
)
3756 /* 13.3.1.5: For direct-initialization, those explicit
3757 conversion functions that are not hidden within S and
3758 yield type T or a type that can be converted to type T
3759 with a qualification conversion (4.4) are also candidate
3761 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3762 I've raised this issue with the committee. --jason 9/2011 */
3764 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
3766 else if (cand
->viable
== 1 && ics
->bad_p
)
3770 = bad_arg_conversion_rejection (NULL_TREE
, -2,
3773 else if (primary_template_instantiation_p (cand
->fn
)
3774 && ics
->rank
> cr_exact
)
3776 /* 13.3.3.1.2: If the user-defined conversion is specified by
3777 a specialization of a conversion function template, the
3778 second standard conversion sequence shall have exact match
3781 cand
->reason
= template_conversion_rejection (rettype
, totype
);
3786 candidates
= splice_viable (candidates
, false, &any_viable_p
);
3790 release_tree_vector (args
);
3794 cand
= tourney (candidates
, complain
);
3797 if (complain
& tf_error
)
3799 error ("conversion from %qT to %qT is ambiguous",
3801 print_z_candidates (location_of (expr
), candidates
);
3804 cand
= candidates
; /* any one will do */
3805 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
3806 cand
->second_conv
->user_conv_p
= true;
3807 if (!any_strictly_viable (candidates
))
3808 cand
->second_conv
->bad_p
= true;
3809 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3810 ambiguous conversion is no worse than another user-defined
3817 if (!DECL_CONSTRUCTOR_P (cand
->fn
))
3818 convtype
= non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)));
3819 else if (cand
->second_conv
->kind
== ck_rvalue
)
3820 /* DR 5: [in the first step of copy-initialization]...if the function
3821 is a constructor, the call initializes a temporary of the
3822 cv-unqualified version of the destination type. */
3823 convtype
= cv_unqualified (totype
);
3826 /* Build the user conversion sequence. */
3830 build_identity_conv (TREE_TYPE (expr
), expr
));
3832 if (cand
->viable
== -1)
3835 /* Remember that this was a list-initialization. */
3836 if (flags
& LOOKUP_NO_NARROWING
)
3837 conv
->check_narrowing
= true;
3839 /* Combine it with the second conversion sequence. */
3840 cand
->second_conv
= merge_conversion_sequences (conv
,
3846 /* Wrapper for above. */
3849 build_user_type_conversion (tree totype
, tree expr
, int flags
,
3850 tsubst_flags_t complain
)
3852 struct z_candidate
*cand
;
3855 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3856 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
3860 if (cand
->second_conv
->kind
== ck_ambig
)
3861 ret
= error_mark_node
;
3864 expr
= convert_like (cand
->second_conv
, expr
, complain
);
3865 ret
= convert_from_reference (expr
);
3871 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3875 /* Subroutine of convert_nontype_argument.
3877 EXPR is an argument for a template non-type parameter of integral or
3878 enumeration type. Do any necessary conversions (that are permitted for
3879 non-type arguments) to convert it to the parameter type.
3881 If conversion is successful, returns the converted expression;
3882 otherwise, returns error_mark_node. */
3885 build_integral_nontype_arg_conv (tree type
, tree expr
, tsubst_flags_t complain
)
3890 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
3892 if (error_operand_p (expr
))
3893 return error_mark_node
;
3895 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
3897 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3898 p
= conversion_obstack_alloc (0);
3900 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
3902 LOOKUP_IMPLICIT
, complain
);
3904 /* for a non-type template-parameter of integral or
3905 enumeration type, integral promotions (4.5) and integral
3906 conversions (4.7) are applied. */
3907 /* It should be sufficient to check the outermost conversion step, since
3908 there are no qualification conversions to integer type. */
3912 /* A conversion function is OK. If it isn't constexpr, we'll
3913 complain later that the argument isn't constant. */
3915 /* The lvalue-to-rvalue conversion is OK. */
3921 t
= next_conversion (conv
)->type
;
3922 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
3925 if (complain
& tf_error
)
3926 error_at (loc
, "conversion from %qT to %qT not considered for "
3927 "non-type template argument", t
, type
);
3928 /* and fall through. */
3936 expr
= convert_like (conv
, expr
, complain
);
3938 expr
= error_mark_node
;
3940 /* Free all the conversions we allocated. */
3941 obstack_free (&conversion_obstack
, p
);
3946 /* Do any initial processing on the arguments to a function call. */
3948 static vec
<tree
, va_gc
> *
3949 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
3954 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
3956 if (error_operand_p (arg
))
3958 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
3960 if (complain
& tf_error
)
3961 error ("invalid use of void expression");
3964 else if (invalid_nonstatic_memfn_p (input_location
, arg
, complain
))
3970 /* Perform overload resolution on FN, which is called with the ARGS.
3972 Return the candidate function selected by overload resolution, or
3973 NULL if the event that overload resolution failed. In the case
3974 that overload resolution fails, *CANDIDATES will be the set of
3975 candidates considered, and ANY_VIABLE_P will be set to true or
3976 false to indicate whether or not any of the candidates were
3979 The ARGS should already have gone through RESOLVE_ARGS before this
3980 function is called. */
3982 static struct z_candidate
*
3983 perform_overload_resolution (tree fn
,
3984 const vec
<tree
, va_gc
> *args
,
3985 struct z_candidate
**candidates
,
3986 bool *any_viable_p
, tsubst_flags_t complain
)
3988 struct z_candidate
*cand
;
3989 tree explicit_targs
;
3992 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3994 explicit_targs
= NULL_TREE
;
3998 *any_viable_p
= true;
4001 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
4002 || TREE_CODE (fn
) == TEMPLATE_DECL
4003 || TREE_CODE (fn
) == OVERLOAD
4004 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
4006 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4008 explicit_targs
= TREE_OPERAND (fn
, 1);
4009 fn
= TREE_OPERAND (fn
, 0);
4013 /* Add the various candidate functions. */
4014 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
4015 explicit_targs
, template_only
,
4016 /*conversion_path=*/NULL_TREE
,
4017 /*access_path=*/NULL_TREE
,
4019 candidates
, complain
);
4021 *candidates
= splice_viable (*candidates
, false, any_viable_p
);
4023 cand
= tourney (*candidates
, complain
);
4027 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4031 /* Print an error message about being unable to build a call to FN with
4032 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
4033 be located; CANDIDATES is a possibly empty list of such
4037 print_error_for_call_failure (tree fn
, vec
<tree
, va_gc
> *args
,
4038 struct z_candidate
*candidates
)
4040 tree name
= DECL_NAME (OVL_CURRENT (fn
));
4041 location_t loc
= location_of (name
);
4043 if (!any_strictly_viable (candidates
))
4044 error_at (loc
, "no matching function for call to %<%D(%A)%>",
4045 name
, build_tree_list_vec (args
));
4047 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
4048 name
, build_tree_list_vec (args
));
4050 print_z_candidates (loc
, candidates
);
4053 /* Return an expression for a call to FN (a namespace-scope function,
4054 or a static member function) with the ARGS. This may change
4058 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
, bool koenig_p
,
4059 tsubst_flags_t complain
)
4061 struct z_candidate
*candidates
, *cand
;
4066 if (args
!= NULL
&& *args
!= NULL
)
4068 *args
= resolve_args (*args
, complain
);
4070 return error_mark_node
;
4074 tm_malloc_replacement (fn
);
4076 /* If this function was found without using argument dependent
4077 lookup, then we want to ignore any undeclared friend
4083 fn
= remove_hidden_names (fn
);
4086 if (complain
& tf_error
)
4087 print_error_for_call_failure (orig_fn
, *args
, NULL
);
4088 return error_mark_node
;
4092 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4093 p
= conversion_obstack_alloc (0);
4095 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
4100 if (complain
& tf_error
)
4102 // If there is a single (non-viable) function candidate,
4103 // let the error be diagnosed by cp_build_function_call_vec.
4104 if (!any_viable_p
&& candidates
&& ! candidates
->next
4105 && (TREE_CODE (candidates
->fn
) == FUNCTION_DECL
))
4106 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
4108 // Otherwise, emit notes for non-viable candidates.
4109 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4110 fn
= TREE_OPERAND (fn
, 0);
4111 print_error_for_call_failure (fn
, *args
, candidates
);
4113 result
= error_mark_node
;
4117 int flags
= LOOKUP_NORMAL
;
4118 /* If fn is template_id_expr, the call has explicit template arguments
4119 (e.g. func<int>(5)), communicate this info to build_over_call
4120 through flags so that later we can use it to decide whether to warn
4121 about peculiar null pointer conversion. */
4122 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4124 /* If overload resolution selects a specialization of a
4125 function concept for non-dependent template arguments,
4126 the expression is true if the constraints are satisfied
4127 and false otherwise.
4129 NOTE: This is an extension of Concepts Lite TS that
4130 allows constraints to be used in expressions. */
4131 if (flag_concepts
&& !processing_template_decl
)
4133 tree tmpl
= DECL_TI_TEMPLATE (cand
->fn
);
4134 tree targs
= DECL_TI_ARGS (cand
->fn
);
4135 tree decl
= DECL_TEMPLATE_RESULT (tmpl
);
4136 if (DECL_DECLARED_CONCEPT_P (decl
))
4137 return evaluate_function_concept (decl
, targs
);
4140 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
4143 result
= build_over_call (cand
, flags
, complain
);
4146 /* Free all the conversions we allocated. */
4147 obstack_free (&conversion_obstack
, p
);
4152 /* Build a call to a global operator new. FNNAME is the name of the
4153 operator (either "operator new" or "operator new[]") and ARGS are
4154 the arguments provided. This may change ARGS. *SIZE points to the
4155 total number of bytes required by the allocation, and is updated if
4156 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
4157 be used. If this function determines that no cookie should be
4158 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
4159 is not NULL_TREE, it is evaluated before calculating the final
4160 array size, and if it fails, the array size is replaced with
4161 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
4162 is non-NULL, it will be set, upon return, to the allocation
4166 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
4167 tree
*size
, tree
*cookie_size
, tree size_check
,
4168 tree
*fn
, tsubst_flags_t complain
)
4170 tree original_size
= *size
;
4172 struct z_candidate
*candidates
;
4173 struct z_candidate
*cand
;
4178 /* Set to (size_t)-1 if the size check fails. */
4179 if (size_check
!= NULL_TREE
)
4181 tree errval
= TYPE_MAX_VALUE (sizetype
);
4182 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
4183 errval
= throw_bad_array_new_length ();
4184 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4185 original_size
, errval
);
4187 vec_safe_insert (*args
, 0, *size
);
4188 *args
= resolve_args (*args
, complain
);
4190 return error_mark_node
;
4196 If this lookup fails to find the name, or if the allocated type
4197 is not a class type, the allocation function's name is looked
4198 up in the global scope.
4200 we disregard block-scope declarations of "operator new". */
4201 fns
= lookup_function_nonclass (fnname
, *args
, /*block_p=*/false);
4203 /* Figure out what function is being called. */
4204 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
4207 /* If no suitable function could be found, issue an error message
4211 if (complain
& tf_error
)
4212 print_error_for_call_failure (fns
, *args
, candidates
);
4213 return error_mark_node
;
4216 /* If a cookie is required, add some extra space. Whether
4217 or not a cookie is required cannot be determined until
4218 after we know which function was called. */
4221 bool use_cookie
= true;
4224 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
4225 /* Skip the size_t parameter. */
4226 arg_types
= TREE_CHAIN (arg_types
);
4227 /* Check the remaining parameters (if any). */
4229 && TREE_CHAIN (arg_types
) == void_list_node
4230 && same_type_p (TREE_VALUE (arg_types
),
4233 /* If we need a cookie, adjust the number of bytes allocated. */
4236 /* Update the total size. */
4237 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
4238 /* Set to (size_t)-1 if the size check fails. */
4239 gcc_assert (size_check
!= NULL_TREE
);
4240 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4241 *size
, TYPE_MAX_VALUE (sizetype
));
4242 /* Update the argument list to reflect the adjusted size. */
4243 (**args
)[0] = *size
;
4246 *cookie_size
= NULL_TREE
;
4249 /* Tell our caller which function we decided to call. */
4253 /* Build the CALL_EXPR. */
4254 return build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4257 /* Build a new call to operator(). This may change ARGS. */
4260 build_op_call_1 (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4262 struct z_candidate
*candidates
= 0, *cand
;
4263 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
4264 tree type
= TREE_TYPE (obj
);
4266 tree result
= NULL_TREE
;
4269 if (error_operand_p (obj
))
4270 return error_mark_node
;
4272 obj
= prep_operand (obj
);
4274 if (TYPE_PTRMEMFUNC_P (type
))
4276 if (complain
& tf_error
)
4277 /* It's no good looking for an overloaded operator() on a
4278 pointer-to-member-function. */
4279 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
4280 return error_mark_node
;
4283 if (TYPE_BINFO (type
))
4285 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
4286 if (fns
== error_mark_node
)
4287 return error_mark_node
;
4292 if (args
!= NULL
&& *args
!= NULL
)
4294 *args
= resolve_args (*args
, complain
);
4296 return error_mark_node
;
4299 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4300 p
= conversion_obstack_alloc (0);
4304 first_mem_arg
= obj
;
4306 add_candidates (BASELINK_FUNCTIONS (fns
),
4307 first_mem_arg
, *args
, NULL_TREE
,
4309 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
4310 LOOKUP_NORMAL
, &candidates
, complain
);
4313 convs
= lookup_conversions (type
);
4315 for (; convs
; convs
= TREE_CHAIN (convs
))
4317 tree fns
= TREE_VALUE (convs
);
4318 tree totype
= TREE_TYPE (convs
);
4320 if (TYPE_PTRFN_P (totype
)
4321 || TYPE_REFFN_P (totype
)
4322 || (TREE_CODE (totype
) == REFERENCE_TYPE
4323 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
4324 for (; fns
; fns
= OVL_NEXT (fns
))
4326 tree fn
= OVL_CURRENT (fns
);
4328 if (DECL_NONCONVERTING_P (fn
))
4331 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4332 add_template_conv_candidate
4333 (&candidates
, fn
, obj
, *args
, totype
,
4334 /*access_path=*/NULL_TREE
,
4335 /*conversion_path=*/NULL_TREE
, complain
);
4337 add_conv_candidate (&candidates
, fn
, obj
,
4338 *args
, /*conversion_path=*/NULL_TREE
,
4339 /*access_path=*/NULL_TREE
, complain
);
4343 /* Be strict here because if we choose a bad conversion candidate, the
4344 errors we get won't mention the call context. */
4345 candidates
= splice_viable (candidates
, true, &any_viable_p
);
4348 if (complain
& tf_error
)
4350 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
4351 build_tree_list_vec (*args
));
4352 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4354 result
= error_mark_node
;
4358 cand
= tourney (candidates
, complain
);
4361 if (complain
& tf_error
)
4363 error ("call of %<(%T) (%A)%> is ambiguous",
4364 TREE_TYPE (obj
), build_tree_list_vec (*args
));
4365 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4367 result
= error_mark_node
;
4369 /* Since cand->fn will be a type, not a function, for a conversion
4370 function, we must be careful not to unconditionally look at
4372 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
4373 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
4374 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4377 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
, -1,
4379 obj
= convert_from_reference (obj
);
4380 result
= cp_build_function_call_vec (obj
, args
, complain
);
4384 /* Free all the conversions we allocated. */
4385 obstack_free (&conversion_obstack
, p
);
4390 /* Wrapper for above. */
4393 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4396 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4397 ret
= build_op_call_1 (obj
, args
, complain
);
4398 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4402 /* Called by op_error to prepare format strings suitable for the error
4403 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4404 and a suffix (controlled by NTYPES). */
4407 op_error_string (const char *errmsg
, int ntypes
, bool match
)
4411 const char *msgp
= concat (match
? G_("ambiguous overload for ")
4412 : G_("no match for "), errmsg
, NULL
);
4415 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
4416 else if (ntypes
== 2)
4417 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
4419 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
4425 op_error (location_t loc
, enum tree_code code
, enum tree_code code2
,
4426 tree arg1
, tree arg2
, tree arg3
, bool match
)
4430 if (code
== MODIFY_EXPR
)
4431 opname
= assignment_operator_name_info
[code2
].name
;
4433 opname
= operator_name_info
[code
].name
;
4438 if (flag_diagnostics_show_caret
)
4439 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
4441 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4443 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
4444 "in %<%E ? %E : %E%>"), 3, match
),
4446 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4449 case POSTINCREMENT_EXPR
:
4450 case POSTDECREMENT_EXPR
:
4451 if (flag_diagnostics_show_caret
)
4452 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4453 opname
, TREE_TYPE (arg1
));
4455 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4457 opname
, arg1
, opname
, TREE_TYPE (arg1
));
4461 if (flag_diagnostics_show_caret
)
4462 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
4463 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4465 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4467 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4472 if (flag_diagnostics_show_caret
)
4473 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
4474 opname
, TREE_TYPE (arg1
));
4476 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
4477 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4482 if (flag_diagnostics_show_caret
)
4483 error_at (loc
, op_error_string (G_("%<operator%s%>"), 2, match
),
4484 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4486 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4488 opname
, arg1
, opname
, arg2
,
4489 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4491 if (flag_diagnostics_show_caret
)
4492 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4493 opname
, TREE_TYPE (arg1
));
4495 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4497 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4502 /* Return the implicit conversion sequence that could be used to
4503 convert E1 to E2 in [expr.cond]. */
4506 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
4508 tree t1
= non_reference (TREE_TYPE (e1
));
4509 tree t2
= non_reference (TREE_TYPE (e2
));
4515 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4516 implicitly converted (clause _conv_) to the type "lvalue reference to
4517 T2", subject to the constraint that in the conversion the
4518 reference must bind directly (_dcl.init.ref_) to an lvalue.
4520 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
4521 implicitly converted to the type "rvalue reference to T2", subject to
4522 the constraint that the reference must bind directly. */
4523 if (lvalue_or_rvalue_with_address_p (e2
))
4525 tree rtype
= cp_build_reference_type (t2
, !real_lvalue_p (e2
));
4526 conv
= implicit_conversion (rtype
,
4530 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
4531 |LOOKUP_ONLYCONVERTING
,
4533 if (conv
&& !conv
->bad_p
)
4537 /* If E2 is a prvalue or if neither of the conversions above can be done
4538 and at least one of the operands has (possibly cv-qualified) class
4540 if (!CLASS_TYPE_P (t1
) && !CLASS_TYPE_P (t2
))
4545 If E1 and E2 have class type, and the underlying class types are
4546 the same or one is a base class of the other: E1 can be converted
4547 to match E2 if the class of T2 is the same type as, or a base
4548 class of, the class of T1, and the cv-qualification of T2 is the
4549 same cv-qualification as, or a greater cv-qualification than, the
4550 cv-qualification of T1. If the conversion is applied, E1 is
4551 changed to an rvalue of type T2 that still refers to the original
4552 source class object (or the appropriate subobject thereof). */
4553 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
4554 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
4556 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
4558 conv
= build_identity_conv (t1
, e1
);
4559 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
4560 TYPE_MAIN_VARIANT (t2
)))
4561 conv
= build_conv (ck_base
, t2
, conv
);
4563 conv
= build_conv (ck_rvalue
, t2
, conv
);
4572 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4573 converted to the type that expression E2 would have if E2 were
4574 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4575 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
4576 LOOKUP_IMPLICIT
, complain
);
4579 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4580 arguments to the conditional expression. */
4583 build_conditional_expr_1 (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
4584 tsubst_flags_t complain
)
4588 tree result
= NULL_TREE
;
4589 tree result_type
= NULL_TREE
;
4590 bool lvalue_p
= true;
4591 struct z_candidate
*candidates
= 0;
4592 struct z_candidate
*cand
;
4594 tree orig_arg2
, orig_arg3
;
4596 /* As a G++ extension, the second argument to the conditional can be
4597 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4598 c'.) If the second operand is omitted, make sure it is
4599 calculated only once. */
4602 if (complain
& tf_error
)
4603 pedwarn (loc
, OPT_Wpedantic
,
4604 "ISO C++ forbids omitting the middle term of a ?: expression");
4606 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4607 if (real_lvalue_p (arg1
))
4608 arg2
= arg1
= stabilize_reference (arg1
);
4610 arg2
= arg1
= save_expr (arg1
);
4613 /* If something has already gone wrong, just pass that fact up the
4615 if (error_operand_p (arg1
)
4616 || error_operand_p (arg2
)
4617 || error_operand_p (arg3
))
4618 return error_mark_node
;
4623 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
4625 /* If arg1 is another cond_expr choosing between -1 and 0,
4626 then we can use its comparison. It may help to avoid
4627 additional comparison, produce more accurate diagnostics
4628 and enables folding. */
4629 if (TREE_CODE (arg1
) == VEC_COND_EXPR
4630 && integer_minus_onep (TREE_OPERAND (arg1
, 1))
4631 && integer_zerop (TREE_OPERAND (arg1
, 2)))
4632 arg1
= TREE_OPERAND (arg1
, 0);
4634 arg1
= force_rvalue (arg1
, complain
);
4635 arg2
= force_rvalue (arg2
, complain
);
4636 arg3
= force_rvalue (arg3
, complain
);
4638 /* force_rvalue can return error_mark on valid arguments. */
4639 if (error_operand_p (arg1
)
4640 || error_operand_p (arg2
)
4641 || error_operand_p (arg3
))
4642 return error_mark_node
;
4644 tree arg1_type
= TREE_TYPE (arg1
);
4645 arg2_type
= TREE_TYPE (arg2
);
4646 arg3_type
= TREE_TYPE (arg3
);
4648 if (!VECTOR_TYPE_P (arg2_type
)
4649 && !VECTOR_TYPE_P (arg3_type
))
4651 /* Rely on the error messages of the scalar version. */
4652 tree scal
= build_conditional_expr_1 (loc
, integer_one_node
,
4653 orig_arg2
, orig_arg3
, complain
);
4654 if (scal
== error_mark_node
)
4655 return error_mark_node
;
4656 tree stype
= TREE_TYPE (scal
);
4657 tree ctype
= TREE_TYPE (arg1_type
);
4658 if (TYPE_SIZE (stype
) != TYPE_SIZE (ctype
)
4659 || (!INTEGRAL_TYPE_P (stype
) && !SCALAR_FLOAT_TYPE_P (stype
)))
4661 if (complain
& tf_error
)
4662 error_at (loc
, "inferred scalar type %qT is not an integer or "
4663 "floating point type of the same size as %qT", stype
,
4664 COMPARISON_CLASS_P (arg1
)
4665 ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
4667 return error_mark_node
;
4670 tree vtype
= build_opaque_vector_type (stype
,
4671 TYPE_VECTOR_SUBPARTS (arg1_type
));
4672 /* We could pass complain & tf_warning to unsafe_conversion_p,
4673 but the warnings (like Wsign-conversion) have already been
4674 given by the scalar build_conditional_expr_1. We still check
4675 unsafe_conversion_p to forbid truncating long long -> float. */
4676 if (unsafe_conversion_p (loc
, stype
, arg2
, false))
4678 if (complain
& tf_error
)
4679 error_at (loc
, "conversion of scalar %qT to vector %qT "
4680 "involves truncation", arg2_type
, vtype
);
4681 return error_mark_node
;
4683 if (unsafe_conversion_p (loc
, stype
, arg3
, false))
4685 if (complain
& tf_error
)
4686 error_at (loc
, "conversion of scalar %qT to vector %qT "
4687 "involves truncation", arg3_type
, vtype
);
4688 return error_mark_node
;
4691 arg2
= cp_convert (stype
, arg2
, complain
);
4692 arg2
= save_expr (arg2
);
4693 arg2
= build_vector_from_val (vtype
, arg2
);
4695 arg3
= cp_convert (stype
, arg3
, complain
);
4696 arg3
= save_expr (arg3
);
4697 arg3
= build_vector_from_val (vtype
, arg3
);
4701 if (VECTOR_TYPE_P (arg2_type
) != VECTOR_TYPE_P (arg3_type
))
4703 enum stv_conv convert_flag
=
4704 scalar_to_vector (loc
, VEC_COND_EXPR
, arg2
, arg3
,
4705 complain
& tf_error
);
4707 switch (convert_flag
)
4710 return error_mark_node
;
4713 arg2
= save_expr (arg2
);
4714 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
4715 arg2
= build_vector_from_val (arg3_type
, arg2
);
4716 arg2_type
= TREE_TYPE (arg2
);
4721 arg3
= save_expr (arg3
);
4722 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
4723 arg3
= build_vector_from_val (arg2_type
, arg3
);
4724 arg3_type
= TREE_TYPE (arg3
);
4732 if (!same_type_p (arg2_type
, arg3_type
)
4733 || TYPE_VECTOR_SUBPARTS (arg1_type
)
4734 != TYPE_VECTOR_SUBPARTS (arg2_type
)
4735 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
4737 if (complain
& tf_error
)
4739 "incompatible vector types in conditional expression: "
4740 "%qT, %qT and %qT", TREE_TYPE (arg1
),
4741 TREE_TYPE (orig_arg2
), TREE_TYPE (orig_arg3
));
4742 return error_mark_node
;
4745 if (!COMPARISON_CLASS_P (arg1
))
4747 tree cmp_type
= build_same_sized_truth_vector_type (arg1_type
);
4748 arg1
= build2 (NE_EXPR
, cmp_type
, arg1
, build_zero_cst (arg1_type
));
4750 return fold_build3 (VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
4755 The first expression is implicitly converted to bool (clause
4757 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
4759 if (error_operand_p (arg1
))
4760 return error_mark_node
;
4764 If either the second or the third operand has type (possibly
4765 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4766 array-to-pointer (_conv.array_), and function-to-pointer
4767 (_conv.func_) standard conversions are performed on the second
4768 and third operands. */
4769 arg2_type
= unlowered_expr_type (arg2
);
4770 arg3_type
= unlowered_expr_type (arg3
);
4771 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
4773 /* Do the conversions. We don't these for `void' type arguments
4774 since it can't have any effect and since decay_conversion
4775 does not handle that case gracefully. */
4776 if (!VOID_TYPE_P (arg2_type
))
4777 arg2
= decay_conversion (arg2
, complain
);
4778 if (!VOID_TYPE_P (arg3_type
))
4779 arg3
= decay_conversion (arg3
, complain
);
4780 arg2_type
= TREE_TYPE (arg2
);
4781 arg3_type
= TREE_TYPE (arg3
);
4785 One of the following shall hold:
4787 --The second or the third operand (but not both) is a
4788 throw-expression (_except.throw_); the result is of the
4789 type of the other and is an rvalue.
4791 --Both the second and the third operands have type void; the
4792 result is of type void and is an rvalue.
4794 We must avoid calling force_rvalue for expressions of type
4795 "void" because it will complain that their value is being
4797 if (TREE_CODE (arg2
) == THROW_EXPR
4798 && TREE_CODE (arg3
) != THROW_EXPR
)
4800 if (!VOID_TYPE_P (arg3_type
))
4802 arg3
= force_rvalue (arg3
, complain
);
4803 if (arg3
== error_mark_node
)
4804 return error_mark_node
;
4806 arg3_type
= TREE_TYPE (arg3
);
4807 result_type
= arg3_type
;
4809 else if (TREE_CODE (arg2
) != THROW_EXPR
4810 && TREE_CODE (arg3
) == THROW_EXPR
)
4812 if (!VOID_TYPE_P (arg2_type
))
4814 arg2
= force_rvalue (arg2
, complain
);
4815 if (arg2
== error_mark_node
)
4816 return error_mark_node
;
4818 arg2_type
= TREE_TYPE (arg2
);
4819 result_type
= arg2_type
;
4821 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
4822 result_type
= void_type_node
;
4825 if (complain
& tf_error
)
4827 if (VOID_TYPE_P (arg2_type
))
4828 error_at (EXPR_LOC_OR_LOC (arg3
, loc
),
4829 "second operand to the conditional operator "
4830 "is of type %<void%>, but the third operand is "
4831 "neither a throw-expression nor of type %<void%>");
4833 error_at (EXPR_LOC_OR_LOC (arg2
, loc
),
4834 "third operand to the conditional operator "
4835 "is of type %<void%>, but the second operand is "
4836 "neither a throw-expression nor of type %<void%>");
4838 return error_mark_node
;
4842 goto valid_operands
;
4846 Otherwise, if the second and third operand have different types,
4847 and either has (possibly cv-qualified) class type, or if both are
4848 glvalues of the same value category and the same type except for
4849 cv-qualification, an attempt is made to convert each of those operands
4850 to the type of the other. */
4851 else if (!same_type_p (arg2_type
, arg3_type
)
4852 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)
4853 || (same_type_ignoring_top_level_qualifiers_p (arg2_type
,
4855 && lvalue_or_rvalue_with_address_p (arg2
)
4856 && lvalue_or_rvalue_with_address_p (arg3
)
4857 && real_lvalue_p (arg2
) == real_lvalue_p (arg3
))))
4861 bool converted
= false;
4863 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4864 p
= conversion_obstack_alloc (0);
4866 conv2
= conditional_conversion (arg2
, arg3
, complain
);
4867 conv3
= conditional_conversion (arg3
, arg2
, complain
);
4871 If both can be converted, or one can be converted but the
4872 conversion is ambiguous, the program is ill-formed. If
4873 neither can be converted, the operands are left unchanged and
4874 further checking is performed as described below. If exactly
4875 one conversion is possible, that conversion is applied to the
4876 chosen operand and the converted operand is used in place of
4877 the original operand for the remainder of this section. */
4878 if ((conv2
&& !conv2
->bad_p
4879 && conv3
&& !conv3
->bad_p
)
4880 || (conv2
&& conv2
->kind
== ck_ambig
)
4881 || (conv3
&& conv3
->kind
== ck_ambig
))
4883 if (complain
& tf_error
)
4885 error_at (loc
, "operands to ?: have different types %qT and %qT",
4886 arg2_type
, arg3_type
);
4887 if (conv2
&& !conv2
->bad_p
&& conv3
&& !conv3
->bad_p
)
4888 inform (loc
, " and each type can be converted to the other");
4889 else if (conv2
&& conv2
->kind
== ck_ambig
)
4890 convert_like (conv2
, arg2
, complain
);
4892 convert_like (conv3
, arg3
, complain
);
4894 result
= error_mark_node
;
4896 else if (conv2
&& !conv2
->bad_p
)
4898 arg2
= convert_like (conv2
, arg2
, complain
);
4899 arg2
= convert_from_reference (arg2
);
4900 arg2_type
= TREE_TYPE (arg2
);
4901 /* Even if CONV2 is a valid conversion, the result of the
4902 conversion may be invalid. For example, if ARG3 has type
4903 "volatile X", and X does not have a copy constructor
4904 accepting a "volatile X&", then even if ARG2 can be
4905 converted to X, the conversion will fail. */
4906 if (error_operand_p (arg2
))
4907 result
= error_mark_node
;
4910 else if (conv3
&& !conv3
->bad_p
)
4912 arg3
= convert_like (conv3
, arg3
, complain
);
4913 arg3
= convert_from_reference (arg3
);
4914 arg3_type
= TREE_TYPE (arg3
);
4915 if (error_operand_p (arg3
))
4916 result
= error_mark_node
;
4920 /* Free all the conversions we allocated. */
4921 obstack_free (&conversion_obstack
, p
);
4926 /* If, after the conversion, both operands have class type,
4927 treat the cv-qualification of both operands as if it were the
4928 union of the cv-qualification of the operands.
4930 The standard is not clear about what to do in this
4931 circumstance. For example, if the first operand has type
4932 "const X" and the second operand has a user-defined
4933 conversion to "volatile X", what is the type of the second
4934 operand after this step? Making it be "const X" (matching
4935 the first operand) seems wrong, as that discards the
4936 qualification without actually performing a copy. Leaving it
4937 as "volatile X" seems wrong as that will result in the
4938 conditional expression failing altogether, even though,
4939 according to this step, the one operand could be converted to
4940 the type of the other. */
4942 && CLASS_TYPE_P (arg2_type
)
4943 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
4944 arg2_type
= arg3_type
=
4945 cp_build_qualified_type (arg2_type
,
4946 cp_type_quals (arg2_type
)
4947 | cp_type_quals (arg3_type
));
4952 If the second and third operands are glvalues of the same value
4953 category and have the same type, the result is of that type and
4955 if (((real_lvalue_p (arg2
) && real_lvalue_p (arg3
))
4956 || (xvalue_p (arg2
) && xvalue_p (arg3
)))
4957 && same_type_p (arg2_type
, arg3_type
))
4959 result_type
= arg2_type
;
4960 arg2
= mark_lvalue_use (arg2
);
4961 arg3
= mark_lvalue_use (arg3
);
4962 goto valid_operands
;
4967 Otherwise, the result is an rvalue. If the second and third
4968 operand do not have the same type, and either has (possibly
4969 cv-qualified) class type, overload resolution is used to
4970 determine the conversions (if any) to be applied to the operands
4971 (_over.match.oper_, _over.built_). */
4973 if (!same_type_p (arg2_type
, arg3_type
)
4974 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
4980 /* Rearrange the arguments so that add_builtin_candidate only has
4981 to know about two args. In build_builtin_candidate, the
4982 arguments are unscrambled. */
4986 add_builtin_candidates (&candidates
,
4989 ansi_opname (COND_EXPR
),
4991 LOOKUP_NORMAL
, complain
);
4995 If the overload resolution fails, the program is
4997 candidates
= splice_viable (candidates
, false, &any_viable_p
);
5000 if (complain
& tf_error
)
5001 error_at (loc
, "operands to ?: have different types %qT and %qT",
5002 arg2_type
, arg3_type
);
5003 return error_mark_node
;
5005 cand
= tourney (candidates
, complain
);
5008 if (complain
& tf_error
)
5010 op_error (loc
, COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, FALSE
);
5011 print_z_candidates (loc
, candidates
);
5013 return error_mark_node
;
5018 Otherwise, the conversions thus determined are applied, and
5019 the converted operands are used in place of the original
5020 operands for the remainder of this section. */
5021 conv
= cand
->convs
[0];
5022 arg1
= convert_like (conv
, arg1
, complain
);
5023 conv
= cand
->convs
[1];
5024 arg2
= convert_like (conv
, arg2
, complain
);
5025 arg2_type
= TREE_TYPE (arg2
);
5026 conv
= cand
->convs
[2];
5027 arg3
= convert_like (conv
, arg3
, complain
);
5028 arg3_type
= TREE_TYPE (arg3
);
5033 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
5034 and function-to-pointer (_conv.func_) standard conversions are
5035 performed on the second and third operands.
5037 We need to force the lvalue-to-rvalue conversion here for class types,
5038 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
5039 that isn't wrapped with a TARGET_EXPR plays havoc with exception
5042 arg2
= force_rvalue (arg2
, complain
);
5043 if (!CLASS_TYPE_P (arg2_type
))
5044 arg2_type
= TREE_TYPE (arg2
);
5046 arg3
= force_rvalue (arg3
, complain
);
5047 if (!CLASS_TYPE_P (arg3_type
))
5048 arg3_type
= TREE_TYPE (arg3
);
5050 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5051 return error_mark_node
;
5055 After those conversions, one of the following shall hold:
5057 --The second and third operands have the same type; the result is of
5059 if (same_type_p (arg2_type
, arg3_type
))
5060 result_type
= arg2_type
;
5063 --The second and third operands have arithmetic or enumeration
5064 type; the usual arithmetic conversions are performed to bring
5065 them to a common type, and the result is of that type. */
5066 else if ((ARITHMETIC_TYPE_P (arg2_type
)
5067 || UNSCOPED_ENUM_P (arg2_type
))
5068 && (ARITHMETIC_TYPE_P (arg3_type
)
5069 || UNSCOPED_ENUM_P (arg3_type
)))
5071 /* In this case, there is always a common type. */
5072 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
5074 if (complain
& tf_warning
)
5075 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
5076 "implicit conversion from %qT to %qT to "
5077 "match other result of conditional",
5080 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5081 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
5083 if (TREE_CODE (orig_arg2
) == CONST_DECL
5084 && TREE_CODE (orig_arg3
) == CONST_DECL
5085 && DECL_CONTEXT (orig_arg2
) == DECL_CONTEXT (orig_arg3
))
5086 /* Two enumerators from the same enumeration can have different
5087 types when the enumeration is still being defined. */;
5088 else if (complain
& tf_warning
)
5089 warning_at (loc
, OPT_Wenum_compare
, "enumeral mismatch in "
5090 "conditional expression: %qT vs %qT",
5091 arg2_type
, arg3_type
);
5093 else if (extra_warnings
5094 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5095 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
5096 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
5097 && !same_type_p (arg2_type
,
5098 type_promotes_to (arg3_type
)))))
5100 if (complain
& tf_warning
)
5101 warning_at (loc
, OPT_Wextra
, "enumeral and non-enumeral type in "
5102 "conditional expression");
5105 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5106 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5110 --The second and third operands have pointer type, or one has
5111 pointer type and the other is a null pointer constant; pointer
5112 conversions (_conv.ptr_) and qualification conversions
5113 (_conv.qual_) are performed to bring them to their composite
5114 pointer type (_expr.rel_). The result is of the composite
5117 --The second and third operands have pointer to member type, or
5118 one has pointer to member type and the other is a null pointer
5119 constant; pointer to member conversions (_conv.mem_) and
5120 qualification conversions (_conv.qual_) are performed to bring
5121 them to a common type, whose cv-qualification shall match the
5122 cv-qualification of either the second or the third operand.
5123 The result is of the common type. */
5124 else if ((null_ptr_cst_p (arg2
)
5125 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
5126 || (null_ptr_cst_p (arg3
)
5127 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
5128 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
5129 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
5130 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
5132 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
5133 arg3
, CPO_CONDITIONAL_EXPR
,
5135 if (result_type
== error_mark_node
)
5136 return error_mark_node
;
5137 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5138 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5143 if (complain
& tf_error
)
5144 error_at (loc
, "operands to ?: have different types %qT and %qT",
5145 arg2_type
, arg3_type
);
5146 return error_mark_node
;
5149 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5150 return error_mark_node
;
5153 result
= build3_loc (loc
, COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
5154 if (!cp_unevaluated_operand
)
5155 /* Avoid folding within decltype (c++/42013) and noexcept. */
5156 result
= fold_if_not_in_template (result
);
5158 /* We can't use result_type below, as fold might have returned a
5163 /* Expand both sides into the same slot, hopefully the target of
5164 the ?: expression. We used to check for TARGET_EXPRs here,
5165 but now we sometimes wrap them in NOP_EXPRs so the test would
5167 if (CLASS_TYPE_P (TREE_TYPE (result
)))
5168 result
= get_target_expr_sfinae (result
, complain
);
5169 /* If this expression is an rvalue, but might be mistaken for an
5170 lvalue, we must add a NON_LVALUE_EXPR. */
5171 result
= rvalue (result
);
5174 result
= force_paren_expr (result
);
5179 /* Wrapper for above. */
5182 build_conditional_expr (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
5183 tsubst_flags_t complain
)
5186 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5187 ret
= build_conditional_expr_1 (loc
, arg1
, arg2
, arg3
, complain
);
5188 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5192 /* OPERAND is an operand to an expression. Perform necessary steps
5193 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
5197 prep_operand (tree operand
)
5201 if (CLASS_TYPE_P (TREE_TYPE (operand
))
5202 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
5203 /* Make sure the template type is instantiated now. */
5204 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
5210 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
5211 OVERLOAD) to the CANDIDATES, returning an updated list of
5212 CANDIDATES. The ARGS are the arguments provided to the call;
5213 if FIRST_ARG is non-null it is the implicit object argument,
5214 otherwise the first element of ARGS is used if needed. The
5215 EXPLICIT_TARGS are explicit template arguments provided.
5216 TEMPLATE_ONLY is true if only template functions should be
5217 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
5218 add_function_candidate. */
5221 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
5223 tree explicit_targs
, bool template_only
,
5224 tree conversion_path
, tree access_path
,
5226 struct z_candidate
**candidates
,
5227 tsubst_flags_t complain
)
5230 const vec
<tree
, va_gc
> *non_static_args
;
5231 bool check_list_ctor
;
5232 bool check_converting
;
5233 unification_kind_t strict
;
5239 /* Precalculate special handling of constructors and conversion ops. */
5240 fn
= OVL_CURRENT (fns
);
5241 if (DECL_CONV_FN_P (fn
))
5243 check_list_ctor
= false;
5244 check_converting
= !!(flags
& LOOKUP_ONLYCONVERTING
);
5245 if (flags
& LOOKUP_NO_CONVERSION
)
5246 /* We're doing return_type(x). */
5247 strict
= DEDUCE_CONV
;
5249 /* We're doing x.operator return_type(). */
5250 strict
= DEDUCE_EXACT
;
5251 /* [over.match.funcs] For conversion functions, the function
5252 is considered to be a member of the class of the implicit
5253 object argument for the purpose of defining the type of
5254 the implicit object parameter. */
5255 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
5259 if (DECL_CONSTRUCTOR_P (fn
))
5261 check_list_ctor
= !!(flags
& LOOKUP_LIST_ONLY
);
5262 /* For list-initialization we consider explicit constructors
5263 and complain if one is chosen. */
5265 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
5266 == LOOKUP_ONLYCONVERTING
);
5270 check_list_ctor
= false;
5271 check_converting
= false;
5273 strict
= DEDUCE_CALL
;
5274 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
5278 non_static_args
= args
;
5280 /* Delay creating the implicit this parameter until it is needed. */
5281 non_static_args
= NULL
;
5283 for (; fns
; fns
= OVL_NEXT (fns
))
5286 const vec
<tree
, va_gc
> *fn_args
;
5288 fn
= OVL_CURRENT (fns
);
5290 if (check_converting
&& DECL_NONCONVERTING_P (fn
))
5292 if (check_list_ctor
&& !is_list_ctor (fn
))
5295 /* Figure out which set of arguments to use. */
5296 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
5298 /* If this function is a non-static member and we didn't get an
5299 implicit object argument, move it out of args. */
5300 if (first_arg
== NULL_TREE
)
5304 vec
<tree
, va_gc
> *tempvec
;
5305 vec_alloc (tempvec
, args
->length () - 1);
5306 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
5307 tempvec
->quick_push (arg
);
5308 non_static_args
= tempvec
;
5309 first_arg
= (*args
)[0];
5312 fn_first_arg
= first_arg
;
5313 fn_args
= non_static_args
;
5317 /* Otherwise, just use the list of arguments provided. */
5318 fn_first_arg
= NULL_TREE
;
5322 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5323 add_template_candidate (candidates
,
5335 else if (!template_only
)
5336 add_function_candidate (candidates
,
5349 build_new_op_1 (location_t loc
, enum tree_code code
, int flags
, tree arg1
,
5350 tree arg2
, tree arg3
, tree
*overload
, tsubst_flags_t complain
)
5352 struct z_candidate
*candidates
= 0, *cand
;
5353 vec
<tree
, va_gc
> *arglist
;
5356 tree result
= NULL_TREE
;
5357 bool result_valid_p
= false;
5358 enum tree_code code2
= NOP_EXPR
;
5359 enum tree_code code_orig_arg1
= ERROR_MARK
;
5360 enum tree_code code_orig_arg2
= ERROR_MARK
;
5366 if (error_operand_p (arg1
)
5367 || error_operand_p (arg2
)
5368 || error_operand_p (arg3
))
5369 return error_mark_node
;
5371 if (code
== MODIFY_EXPR
)
5373 code2
= TREE_CODE (arg3
);
5375 fnname
= ansi_assopname (code2
);
5378 fnname
= ansi_opname (code
);
5380 arg1
= prep_operand (arg1
);
5382 bool memonly
= false;
5387 case VEC_DELETE_EXPR
:
5389 /* Use build_op_new_call and build_op_delete_call instead. */
5393 /* Use build_op_call instead. */
5396 case TRUTH_ORIF_EXPR
:
5397 case TRUTH_ANDIF_EXPR
:
5398 case TRUTH_AND_EXPR
:
5400 /* These are saved for the sake of warn_logical_operator. */
5401 code_orig_arg1
= TREE_CODE (arg1
);
5402 code_orig_arg2
= TREE_CODE (arg2
);
5410 /* These are saved for the sake of maybe_warn_bool_compare. */
5411 code_orig_arg1
= TREE_CODE (TREE_TYPE (arg1
));
5412 code_orig_arg2
= TREE_CODE (TREE_TYPE (arg2
));
5415 /* =, ->, [], () must be non-static member functions. */
5417 if (code2
!= NOP_EXPR
)
5428 arg2
= prep_operand (arg2
);
5429 arg3
= prep_operand (arg3
);
5431 if (code
== COND_EXPR
)
5432 /* Use build_conditional_expr instead. */
5434 else if (! OVERLOAD_TYPE_P (TREE_TYPE (arg1
))
5435 && (! arg2
|| ! OVERLOAD_TYPE_P (TREE_TYPE (arg2
))))
5438 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5439 arg2
= integer_zero_node
;
5441 vec_alloc (arglist
, 3);
5442 arglist
->quick_push (arg1
);
5443 if (arg2
!= NULL_TREE
)
5444 arglist
->quick_push (arg2
);
5445 if (arg3
!= NULL_TREE
)
5446 arglist
->quick_push (arg3
);
5448 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5449 p
= conversion_obstack_alloc (0);
5451 /* Add namespace-scope operators to the list of functions to
5454 add_candidates (lookup_function_nonclass (fnname
, arglist
,
5456 NULL_TREE
, arglist
, NULL_TREE
,
5457 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5458 flags
, &candidates
, complain
);
5462 args
[2] = NULL_TREE
;
5464 /* Add class-member operators to the candidate set. */
5465 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
5469 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
5470 if (fns
== error_mark_node
)
5472 result
= error_mark_node
;
5473 goto user_defined_result_ready
;
5476 add_candidates (BASELINK_FUNCTIONS (fns
),
5477 NULL_TREE
, arglist
, NULL_TREE
,
5479 BASELINK_BINFO (fns
),
5480 BASELINK_ACCESS_BINFO (fns
),
5481 flags
, &candidates
, complain
);
5483 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5484 only non-member functions that have type T1 or reference to
5485 cv-qualified-opt T1 for the first argument, if the first argument
5486 has an enumeration type, or T2 or reference to cv-qualified-opt
5487 T2 for the second argument, if the second argument has an
5488 enumeration type. Filter out those that don't match. */
5489 else if (! arg2
|| ! CLASS_TYPE_P (TREE_TYPE (arg2
)))
5491 struct z_candidate
**candp
, **next
;
5493 for (candp
= &candidates
; *candp
; candp
= next
)
5495 tree parmlist
, parmtype
;
5496 int i
, nargs
= (arg2
? 2 : 1);
5501 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5503 for (i
= 0; i
< nargs
; ++i
)
5505 parmtype
= TREE_VALUE (parmlist
);
5507 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
5508 parmtype
= TREE_TYPE (parmtype
);
5509 if (TREE_CODE (TREE_TYPE (args
[i
])) == ENUMERAL_TYPE
5510 && (same_type_ignoring_top_level_qualifiers_p
5511 (TREE_TYPE (args
[i
]), parmtype
)))
5514 parmlist
= TREE_CHAIN (parmlist
);
5517 /* No argument has an appropriate type, so remove this
5518 candidate function from the list. */
5521 *candp
= cand
->next
;
5527 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
5534 /* For these, the built-in candidates set is empty
5535 [over.match.oper]/3. We don't want non-strict matches
5536 because exact matches are always possible with built-in
5537 operators. The built-in candidate set for COMPONENT_REF
5538 would be empty too, but since there are no such built-in
5539 operators, we accept non-strict matches for them. */
5548 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
5553 case POSTINCREMENT_EXPR
:
5554 case POSTDECREMENT_EXPR
:
5555 /* Don't try anything fancy if we're not allowed to produce
5557 if (!(complain
& tf_error
))
5558 return error_mark_node
;
5560 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5561 distinguish between prefix and postfix ++ and
5562 operator++() was used for both, so we allow this with
5566 const char *msg
= (flag_permissive
)
5567 ? G_("no %<%D(int)%> declared for postfix %qs,"
5568 " trying prefix operator instead")
5569 : G_("no %<%D(int)%> declared for postfix %qs");
5570 permerror (loc
, msg
, fnname
, operator_name_info
[code
].name
);
5573 if (!flag_permissive
)
5574 return error_mark_node
;
5576 if (code
== POSTINCREMENT_EXPR
)
5577 code
= PREINCREMENT_EXPR
;
5579 code
= PREDECREMENT_EXPR
;
5580 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
5581 NULL_TREE
, overload
, complain
);
5584 /* The caller will deal with these. */
5589 result_valid_p
= true;
5593 if (complain
& tf_error
)
5595 /* If one of the arguments of the operator represents
5596 an invalid use of member function pointer, try to report
5597 a meaningful error ... */
5598 if (invalid_nonstatic_memfn_p (loc
, arg1
, tf_error
)
5599 || invalid_nonstatic_memfn_p (loc
, arg2
, tf_error
)
5600 || invalid_nonstatic_memfn_p (loc
, arg3
, tf_error
))
5601 /* We displayed the error message. */;
5604 /* ... Otherwise, report the more generic
5605 "no matching operator found" error */
5606 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
5607 print_z_candidates (loc
, candidates
);
5610 result
= error_mark_node
;
5616 cand
= tourney (candidates
, complain
);
5619 if (complain
& tf_error
)
5621 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
5622 print_z_candidates (loc
, candidates
);
5624 result
= error_mark_node
;
5626 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5629 *overload
= cand
->fn
;
5631 if (resolve_args (arglist
, complain
) == NULL
)
5632 result
= error_mark_node
;
5634 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5638 /* Give any warnings we noticed during overload resolution. */
5639 if (cand
->warnings
&& (complain
& tf_warning
))
5641 struct candidate_warning
*w
;
5642 for (w
= cand
->warnings
; w
; w
= w
->next
)
5643 joust (cand
, w
->loser
, 1, complain
);
5646 /* Check for comparison of different enum types. */
5655 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
5656 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
5657 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
5658 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
)))
5659 && (complain
& tf_warning
))
5661 warning (OPT_Wenum_compare
,
5662 "comparison between %q#T and %q#T",
5663 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5670 /* We need to strip any leading REF_BIND so that bitfields
5671 don't cause errors. This should not remove any important
5672 conversions, because builtins don't apply to class
5673 objects directly. */
5674 conv
= cand
->convs
[0];
5675 if (conv
->kind
== ck_ref_bind
)
5676 conv
= next_conversion (conv
);
5677 arg1
= convert_like (conv
, arg1
, complain
);
5681 conv
= cand
->convs
[1];
5682 if (conv
->kind
== ck_ref_bind
)
5683 conv
= next_conversion (conv
);
5685 arg2
= decay_conversion (arg2
, complain
);
5687 /* We need to call warn_logical_operator before
5688 converting arg2 to a boolean_type, but after
5689 decaying an enumerator to its value. */
5690 if (complain
& tf_warning
)
5691 warn_logical_operator (loc
, code
, boolean_type_node
,
5692 code_orig_arg1
, arg1
,
5693 code_orig_arg2
, arg2
);
5695 arg2
= convert_like (conv
, arg2
, complain
);
5699 conv
= cand
->convs
[2];
5700 if (conv
->kind
== ck_ref_bind
)
5701 conv
= next_conversion (conv
);
5702 arg3
= convert_like (conv
, arg3
, complain
);
5708 user_defined_result_ready
:
5710 /* Free all the conversions we allocated. */
5711 obstack_free (&conversion_obstack
, p
);
5713 if (result
|| result_valid_p
)
5720 return cp_build_modify_expr (arg1
, code2
, arg2
, complain
);
5723 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
5725 case TRUTH_ANDIF_EXPR
:
5726 case TRUTH_ORIF_EXPR
:
5727 case TRUTH_AND_EXPR
:
5729 if (complain
& tf_warning
)
5730 warn_logical_operator (loc
, code
, boolean_type_node
,
5731 code_orig_arg1
, arg1
, code_orig_arg2
, arg2
);
5739 if ((complain
& tf_warning
)
5740 && ((code_orig_arg1
== BOOLEAN_TYPE
)
5741 ^ (code_orig_arg2
== BOOLEAN_TYPE
)))
5742 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
5743 if (complain
& tf_warning
&& warn_tautological_compare
)
5744 warn_tautological_cmp (loc
, code
, arg1
, arg2
);
5749 case TRUNC_DIV_EXPR
:
5754 case TRUNC_MOD_EXPR
:
5758 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
5760 case UNARY_PLUS_EXPR
:
5763 case TRUTH_NOT_EXPR
:
5764 case PREINCREMENT_EXPR
:
5765 case POSTINCREMENT_EXPR
:
5766 case PREDECREMENT_EXPR
:
5767 case POSTDECREMENT_EXPR
:
5771 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5774 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5777 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
5781 /* The caller will deal with these. */
5793 /* Wrapper for above. */
5796 build_new_op (location_t loc
, enum tree_code code
, int flags
,
5797 tree arg1
, tree arg2
, tree arg3
,
5798 tree
*overload
, tsubst_flags_t complain
)
5801 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5802 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
5803 overload
, complain
);
5804 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5808 /* Returns true if FN has two parameters, of which the second has type
5812 second_parm_is_size_t (tree fn
)
5814 tree t
= FUNCTION_ARG_CHAIN (fn
);
5816 && same_type_p (TREE_VALUE (t
), size_type_node
)
5817 && TREE_CHAIN (t
) == void_list_node
);
5820 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5821 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5824 non_placement_deallocation_fn_p (tree t
)
5826 /* A template instance is never a usual deallocation function,
5827 regardless of its signature. */
5828 if (TREE_CODE (t
) == TEMPLATE_DECL
5829 || primary_template_instantiation_p (t
))
5832 /* If a class T has a member deallocation function named operator delete
5833 with exactly one parameter, then that function is a usual
5834 (non-placement) deallocation function. If class T does not declare
5835 such an operator delete but does declare a member deallocation
5836 function named operator delete with exactly two parameters, the second
5837 of which has type std::size_t (18.2), then this function is a usual
5838 deallocation function. */
5839 bool global
= DECL_NAMESPACE_SCOPE_P (t
);
5840 if (FUNCTION_ARG_CHAIN (t
) == void_list_node
5841 || ((!global
|| flag_sized_deallocation
)
5842 && second_parm_is_size_t (t
)))
5847 /* Build a call to operator delete. This has to be handled very specially,
5848 because the restrictions on what signatures match are different from all
5849 other call instances. For a normal delete, only a delete taking (void *)
5850 or (void *, size_t) is accepted. For a placement delete, only an exact
5851 match with the placement new is accepted.
5853 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5854 ADDR is the pointer to be deleted.
5855 SIZE is the size of the memory block to be deleted.
5856 GLOBAL_P is true if the delete-expression should not consider
5857 class-specific delete operators.
5858 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5860 If this call to "operator delete" is being generated as part to
5861 deallocate memory allocated via a new-expression (as per [expr.new]
5862 which requires that if the initialization throws an exception then
5863 we call a deallocation function), then ALLOC_FN is the allocation
5867 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
5868 bool global_p
, tree placement
,
5869 tree alloc_fn
, tsubst_flags_t complain
)
5871 tree fn
= NULL_TREE
;
5872 tree fns
, fnname
, type
, t
;
5874 if (addr
== error_mark_node
)
5875 return error_mark_node
;
5877 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
5879 fnname
= ansi_opname (code
);
5881 if (CLASS_TYPE_P (type
)
5882 && COMPLETE_TYPE_P (complete_type (type
))
5886 If the result of the lookup is ambiguous or inaccessible, or if
5887 the lookup selects a placement deallocation function, the
5888 program is ill-formed.
5890 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5892 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
5893 if (fns
== error_mark_node
)
5894 return error_mark_node
;
5899 if (fns
== NULL_TREE
)
5900 fns
= lookup_name_nonclass (fnname
);
5902 /* Strip const and volatile from addr. */
5903 addr
= cp_convert (ptr_type_node
, addr
, complain
);
5907 /* "A declaration of a placement deallocation function matches the
5908 declaration of a placement allocation function if it has the same
5909 number of parameters and, after parameter transformations (8.3.5),
5910 all parameter types except the first are identical."
5912 So we build up the function type we want and ask instantiate_type
5913 to get it for us. */
5914 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
5915 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
5916 t
= build_function_type (void_type_node
, t
);
5918 fn
= instantiate_type (t
, fns
, tf_none
);
5919 if (fn
== error_mark_node
)
5922 if (BASELINK_P (fn
))
5923 fn
= BASELINK_FUNCTIONS (fn
);
5925 /* "If the lookup finds the two-parameter form of a usual deallocation
5926 function (3.7.4.2) and that function, considered as a placement
5927 deallocation function, would have been selected as a match for the
5928 allocation function, the program is ill-formed." */
5929 if (second_parm_is_size_t (fn
))
5932 = G_("exception cleanup for this placement new selects "
5933 "non-placement operator delete");
5935 = G_("%qD is a usual (non-placement) deallocation "
5936 "function in C++14 (or with -fsized-deallocation)");
5938 /* But if the class has an operator delete (void *), then that is
5939 the usual deallocation function, so we shouldn't complain
5940 about using the operator delete (void *, size_t). */
5941 if (DECL_CLASS_SCOPE_P (fn
))
5942 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5943 t
; t
= OVL_NEXT (t
))
5945 tree elt
= OVL_CURRENT (t
);
5946 if (non_placement_deallocation_fn_p (elt
)
5947 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
5950 /* Before C++14 a two-parameter global deallocation function is
5951 always a placement deallocation function, but warn if
5953 else if (!flag_sized_deallocation
)
5955 if ((complain
& tf_warning
)
5956 && warning (OPT_Wc__14_compat
, msg1
))
5957 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
5961 if (complain
& tf_warning_or_error
)
5963 if (permerror (input_location
, msg1
))
5965 /* Only mention C++14 for namespace-scope delete. */
5966 if (DECL_NAMESPACE_SCOPE_P (fn
))
5967 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
5969 inform (DECL_SOURCE_LOCATION (fn
),
5970 "%qD is a usual (non-placement) deallocation "
5975 return error_mark_node
;
5980 /* "Any non-placement deallocation function matches a non-placement
5981 allocation function. If the lookup finds a single matching
5982 deallocation function, that function will be called; otherwise, no
5983 deallocation function will be called." */
5984 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5985 t
; t
= OVL_NEXT (t
))
5987 tree elt
= OVL_CURRENT (t
);
5988 if (non_placement_deallocation_fn_p (elt
))
5991 /* "If a class T has a member deallocation function named
5992 operator delete with exactly one parameter, then that
5993 function is a usual (non-placement) deallocation
5994 function. If class T does not declare such an operator
5995 delete but does declare a member deallocation function named
5996 operator delete with exactly two parameters, the second of
5997 which has type std::size_t (18.2), then this function is a
5998 usual deallocation function."
6000 So in a class (void*) beats (void*, size_t). */
6001 if (DECL_CLASS_SCOPE_P (fn
))
6003 if (FUNCTION_ARG_CHAIN (fn
) == void_list_node
)
6006 /* At global scope (in C++14 and above) the rules are different:
6008 If deallocation function lookup finds both a usual
6009 deallocation function with only a pointer parameter and a
6010 usual deallocation function with both a pointer parameter
6011 and a size parameter, the function to be called is selected
6014 * If the type is complete and if, for the second alternative
6015 (delete array) only, the operand is a pointer to a class
6016 type with a non-trivial destructor or a (possibly
6017 multi-dimensional) array thereof, the function with two
6018 parameters is selected.
6020 * Otherwise, it is unspecified which of the two deallocation
6021 functions is selected. */
6024 bool want_size
= COMPLETE_TYPE_P (type
);
6025 if (code
== VEC_DELETE_EXPR
6026 && !TYPE_VEC_NEW_USES_COOKIE (type
))
6027 /* We need a cookie to determine the array size. */
6029 bool have_size
= (FUNCTION_ARG_CHAIN (fn
) != void_list_node
);
6030 if (want_size
== have_size
)
6036 /* If we have a matching function, call it. */
6039 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6041 /* If the FN is a member function, make sure that it is
6043 if (BASELINK_P (fns
))
6044 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
6047 /* Core issue 901: It's ok to new a type with deleted delete. */
6048 if (DECL_DELETED_FN (fn
) && alloc_fn
)
6053 /* The placement args might not be suitable for overload
6054 resolution at this point, so build the call directly. */
6055 int nargs
= call_expr_nargs (placement
);
6056 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
6059 for (i
= 1; i
< nargs
; i
++)
6060 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
6061 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6062 return error_mark_node
;
6063 return build_cxx_call (fn
, nargs
, argarray
, complain
);
6068 vec
<tree
, va_gc
> *args
= make_tree_vector ();
6069 args
->quick_push (addr
);
6070 if (FUNCTION_ARG_CHAIN (fn
) != void_list_node
)
6071 args
->quick_push (size
);
6072 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
6073 release_tree_vector (args
);
6080 If no unambiguous matching deallocation function can be found,
6081 propagating the exception does not cause the object's memory to
6085 if ((complain
& tf_warning
)
6087 warning (0, "no corresponding deallocation function for %qD",
6092 if (complain
& tf_error
)
6093 error ("no suitable %<operator %s%> for %qT",
6094 operator_name_info
[(int)code
].name
, type
);
6095 return error_mark_node
;
6098 /* If the current scope isn't allowed to access DECL along
6099 BASETYPE_PATH, give an error. The most derived class in
6100 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
6101 the declaration to use in the error diagnostic. */
6104 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
6105 tsubst_flags_t complain
)
6107 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
6109 if (!accessible_p (basetype_path
, decl
, true))
6111 if (complain
& tf_error
)
6113 if (TREE_PRIVATE (decl
))
6115 error ("%q#D is private within this context", diag_decl
);
6116 inform (DECL_SOURCE_LOCATION (diag_decl
),
6117 "declared private here");
6119 else if (TREE_PROTECTED (decl
))
6121 error ("%q#D is protected within this context", diag_decl
);
6122 inform (DECL_SOURCE_LOCATION (diag_decl
),
6123 "declared protected here");
6127 error ("%q#D is inaccessible within this context", diag_decl
);
6128 inform (DECL_SOURCE_LOCATION (diag_decl
), "declared here");
6137 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
6138 bitwise or of LOOKUP_* values. If any errors are warnings are
6139 generated, set *DIAGNOSTIC_FN to "error" or "warning",
6140 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
6144 build_temp (tree expr
, tree type
, int flags
,
6145 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
6148 vec
<tree
, va_gc
> *args
;
6150 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
6151 args
= make_tree_vector_single (expr
);
6152 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6153 &args
, type
, flags
, complain
);
6154 release_tree_vector (args
);
6155 if (warningcount
+ werrorcount
> savew
)
6156 *diagnostic_kind
= DK_WARNING
;
6157 else if (errorcount
> savee
)
6158 *diagnostic_kind
= DK_ERROR
;
6160 *diagnostic_kind
= DK_UNSPECIFIED
;
6164 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
6165 EXPR is implicitly converted to type TOTYPE.
6166 FN and ARGNUM are used for diagnostics. */
6169 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6171 /* Issue warnings about peculiar, but valid, uses of NULL. */
6172 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
6173 && ARITHMETIC_TYPE_P (totype
))
6175 source_location loc
=
6176 expansion_point_location_if_in_system_header (input_location
);
6179 warning_at (loc
, OPT_Wconversion_null
,
6180 "passing NULL to non-pointer argument %P of %qD",
6183 warning_at (loc
, OPT_Wconversion_null
,
6184 "converting to non-pointer type %qT from NULL", totype
);
6187 /* Issue warnings if "false" is converted to a NULL pointer */
6188 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6189 && TYPE_PTR_P (totype
))
6192 warning_at (input_location
, OPT_Wconversion_null
,
6193 "converting %<false%> to pointer type for argument %P "
6194 "of %qD", argnum
, fn
);
6196 warning_at (input_location
, OPT_Wconversion_null
,
6197 "converting %<false%> to pointer type %qT", totype
);
6201 /* We gave a diagnostic during a conversion. If this was in the second
6202 standard conversion sequence of a user-defined conversion sequence, say
6203 which user-defined conversion. */
6206 maybe_print_user_conv_context (conversion
*convs
)
6208 if (convs
->user_conv_p
)
6209 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6210 if (t
->kind
== ck_user
)
6212 print_z_candidate (0, " after user-defined conversion:",
6218 /* Perform the conversions in CONVS on the expression EXPR. FN and
6219 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6220 indicates the `this' argument of a method. INNER is nonzero when
6221 being called to continue a conversion chain. It is negative when a
6222 reference binding will be applied, positive otherwise. If
6223 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6224 conversions will be emitted if appropriate. If C_CAST_P is true,
6225 this conversion is coming from a C-style cast; in that case,
6226 conversions to inaccessible bases are permitted. */
6229 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6230 int inner
, bool issue_conversion_warnings
,
6231 bool c_cast_p
, tsubst_flags_t complain
)
6233 tree totype
= convs
->type
;
6234 diagnostic_t diag_kind
;
6236 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6238 if (convs
->bad_p
&& !(complain
& tf_error
))
6239 return error_mark_node
;
6242 && convs
->kind
!= ck_user
6243 && convs
->kind
!= ck_list
6244 && convs
->kind
!= ck_ambig
6245 && (convs
->kind
!= ck_ref_bind
6246 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
6247 && (convs
->kind
!= ck_rvalue
6248 || SCALAR_TYPE_P (totype
))
6249 && convs
->kind
!= ck_base
)
6251 bool complained
= false;
6252 conversion
*t
= convs
;
6254 /* Give a helpful error if this is bad because of excess braces. */
6255 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6256 && SCALAR_TYPE_P (totype
)
6257 && CONSTRUCTOR_NELTS (expr
) > 0
6258 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
6260 complained
= permerror (loc
, "too many braces around initializer "
6262 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6263 && CONSTRUCTOR_NELTS (expr
) == 1)
6264 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6267 /* Give a helpful error if this is bad because a conversion to bool
6268 from std::nullptr_t requires direct-initialization. */
6269 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
6270 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
6271 complained
= permerror (loc
, "converting to %qT from %qT requires "
6272 "direct-initialization",
6273 totype
, TREE_TYPE (expr
));
6275 for (; t
; t
= next_conversion (t
))
6277 if (t
->kind
== ck_user
&& t
->cand
->reason
)
6279 complained
= permerror (loc
, "invalid user-defined conversion "
6280 "from %qT to %qT", TREE_TYPE (expr
),
6283 print_z_candidate (loc
, "candidate is:", t
->cand
);
6284 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6285 /*issue_conversion_warnings=*/false,
6288 if (convs
->kind
== ck_ref_bind
)
6289 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
6290 LOOKUP_NORMAL
, NULL_TREE
,
6293 expr
= cp_convert (totype
, expr
, complain
);
6294 if (complained
&& fn
)
6295 inform (DECL_SOURCE_LOCATION (fn
),
6296 " initializing argument %P of %qD", argnum
, fn
);
6299 else if (t
->kind
== ck_user
|| !t
->bad_p
)
6301 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6302 /*issue_conversion_warnings=*/false,
6307 else if (t
->kind
== ck_ambig
)
6308 return convert_like_real (t
, expr
, fn
, argnum
, 1,
6309 /*issue_conversion_warnings=*/false,
6312 else if (t
->kind
== ck_identity
)
6316 complained
= permerror (loc
, "invalid conversion from %qT to %qT",
6317 TREE_TYPE (expr
), totype
);
6318 if (complained
&& fn
)
6319 inform (DECL_SOURCE_LOCATION (fn
),
6320 " initializing argument %P of %qD", argnum
, fn
);
6322 return cp_convert (totype
, expr
, complain
);
6325 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6326 conversion_null_warnings (totype
, expr
, fn
, argnum
);
6328 switch (convs
->kind
)
6332 struct z_candidate
*cand
= convs
->cand
;
6333 tree convfn
= cand
->fn
;
6336 /* If we're initializing from {}, it's value-initialization. Note
6337 that under the resolution of core 1630, value-initialization can
6338 use explicit constructors. */
6339 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6340 && CONSTRUCTOR_NELTS (expr
) == 0
6341 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
6343 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
6344 expr
= build_value_init (totype
, complain
);
6345 expr
= get_target_expr_sfinae (expr
, complain
);
6346 if (expr
!= error_mark_node
)
6348 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6349 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
6354 /* When converting from an init list we consider explicit
6355 constructors, but actually trying to call one is an error. */
6356 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
6357 /* Unless this is for direct-list-initialization. */
6358 && !DIRECT_LIST_INIT_P (expr
))
6360 if (!(complain
& tf_error
))
6361 return error_mark_node
;
6362 error ("converting to %qT from initializer list would use "
6363 "explicit constructor %qD", totype
, convfn
);
6366 expr
= mark_rvalue_use (expr
);
6368 /* Set user_conv_p on the argument conversions, so rvalue/base
6369 handling knows not to allow any more UDCs. */
6370 for (i
= 0; i
< cand
->num_convs
; ++i
)
6371 cand
->convs
[i
]->user_conv_p
= true;
6373 expr
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
6375 /* If this is a constructor or a function returning an aggr type,
6376 we need to build up a TARGET_EXPR. */
6377 if (DECL_CONSTRUCTOR_P (convfn
))
6379 expr
= build_cplus_new (totype
, expr
, complain
);
6381 /* Remember that this was list-initialization. */
6382 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
6383 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6389 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
6391 int nelts
= CONSTRUCTOR_NELTS (expr
);
6393 expr
= build_value_init (totype
, complain
);
6394 else if (nelts
== 1)
6395 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6399 expr
= mark_rvalue_use (expr
);
6401 if (type_unknown_p (expr
))
6402 expr
= instantiate_type (totype
, expr
, complain
);
6403 /* Convert a constant to its underlying value, unless we are
6404 about to bind it to a reference, in which case we need to
6405 leave it as an lvalue. */
6408 expr
= scalar_constant_value (expr
);
6409 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
6410 /* If __null has been converted to an integer type, we do not
6411 want to warn about uses of EXPR as an integer, rather than
6413 expr
= build_int_cst (totype
, 0);
6417 /* We leave bad_p off ck_ambig because overload resolution considers
6418 it valid, it just fails when we try to perform it. So we need to
6419 check complain here, too. */
6420 if (complain
& tf_error
)
6422 /* Call build_user_type_conversion again for the error. */
6423 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
6426 inform (DECL_SOURCE_LOCATION (fn
),
6427 " initializing argument %P of %qD", argnum
, fn
);
6429 return error_mark_node
;
6433 /* Conversion to std::initializer_list<T>. */
6434 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
6435 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
6436 unsigned len
= CONSTRUCTOR_NELTS (expr
);
6437 tree array
, val
, field
;
6438 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6441 /* Convert all the elements. */
6442 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
6444 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
6445 1, false, false, complain
);
6446 if (sub
== error_mark_node
)
6448 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
6449 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
6450 return error_mark_node
;
6451 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
6452 if (!TREE_CONSTANT (sub
))
6453 TREE_CONSTANT (new_ctor
) = false;
6455 /* Build up the array. */
6456 elttype
= cp_build_qualified_type
6457 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
6458 array
= build_array_of_n_type (elttype
, len
);
6459 array
= finish_compound_literal (array
, new_ctor
, complain
);
6460 /* Take the address explicitly rather than via decay_conversion
6461 to avoid the error about taking the address of a temporary. */
6462 array
= cp_build_addr_expr (array
, complain
);
6463 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
6464 if (array
== error_mark_node
)
6465 return error_mark_node
;
6467 /* Build up the initializer_list object. */
6468 totype
= complete_type (totype
);
6469 field
= next_initializable_field (TYPE_FIELDS (totype
));
6470 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6471 field
= next_initializable_field (DECL_CHAIN (field
));
6472 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6473 new_ctor
= build_constructor (totype
, vec
);
6474 return get_target_expr_sfinae (new_ctor
, complain
);
6478 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6480 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6481 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6482 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6484 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6486 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6487 return fold_if_not_in_template (expr
);
6489 expr
= reshape_init (totype
, expr
, complain
);
6490 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6492 if (expr
!= error_mark_node
)
6493 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6500 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6501 convs
->kind
== ck_ref_bind
? -1 : 1,
6502 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6505 if (expr
== error_mark_node
)
6506 return error_mark_node
;
6508 switch (convs
->kind
)
6511 expr
= decay_conversion (expr
, complain
);
6512 if (expr
== error_mark_node
)
6513 return error_mark_node
;
6515 if (! MAYBE_CLASS_TYPE_P (totype
))
6517 /* Else fall through. */
6519 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6521 /* We are going to bind a reference directly to a base-class
6522 subobject of EXPR. */
6523 /* Build an expression for `*((base*) &expr)'. */
6524 expr
= convert_to_base (expr
, totype
,
6525 !c_cast_p
, /*nonnull=*/true, complain
);
6529 /* Copy-initialization where the cv-unqualified version of the source
6530 type is the same class as, or a derived class of, the class of the
6531 destination [is treated as direct-initialization]. [dcl.init] */
6532 flags
= LOOKUP_NORMAL
;
6533 if (convs
->user_conv_p
)
6534 /* This conversion is being done in the context of a user-defined
6535 conversion (i.e. the second step of copy-initialization), so
6536 don't allow any more. */
6537 flags
|= LOOKUP_NO_CONVERSION
;
6539 flags
|= LOOKUP_ONLYCONVERTING
;
6540 if (convs
->rvaluedness_matches_p
)
6541 flags
|= LOOKUP_PREFER_RVALUE
;
6542 if (TREE_CODE (expr
) == TARGET_EXPR
6543 && TARGET_EXPR_LIST_INIT_P (expr
))
6544 /* Copy-list-initialization doesn't actually involve a copy. */
6546 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6547 if (diag_kind
&& complain
)
6549 maybe_print_user_conv_context (convs
);
6551 inform (DECL_SOURCE_LOCATION (fn
),
6552 " initializing argument %P of %qD", argnum
, fn
);
6555 return build_cplus_new (totype
, expr
, complain
);
6559 tree ref_type
= totype
;
6561 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6563 tree extype
= TREE_TYPE (expr
);
6564 if (TYPE_REF_IS_RVALUE (ref_type
)
6565 && real_lvalue_p (expr
))
6566 error_at (loc
, "cannot bind %qT lvalue to %qT",
6568 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !real_lvalue_p (expr
)
6569 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
6570 error_at (loc
, "invalid initialization of non-const reference of "
6571 "type %qT from an rvalue of type %qT", totype
, extype
);
6572 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
6573 error_at (loc
, "binding %qT to reference of type %qT "
6574 "discards qualifiers", extype
, totype
);
6577 maybe_print_user_conv_context (convs
);
6579 inform (DECL_SOURCE_LOCATION (fn
),
6580 " initializing argument %P of %qD", argnum
, fn
);
6581 return error_mark_node
;
6584 /* If necessary, create a temporary.
6586 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6587 that need temporaries, even when their types are reference
6588 compatible with the type of reference being bound, so the
6589 upcoming call to cp_build_addr_expr doesn't fail. */
6590 if (convs
->need_temporary_p
6591 || TREE_CODE (expr
) == CONSTRUCTOR
6592 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6594 /* Otherwise, a temporary of type "cv1 T1" is created and
6595 initialized from the initializer expression using the rules
6596 for a non-reference copy-initialization (8.5). */
6598 tree type
= TREE_TYPE (ref_type
);
6599 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
6601 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6602 (type
, next_conversion (convs
)->type
));
6603 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6604 && !TYPE_REF_IS_RVALUE (ref_type
))
6606 /* If the reference is volatile or non-const, we
6607 cannot create a temporary. */
6608 if (lvalue
& clk_bitfield
)
6609 error_at (loc
, "cannot bind bitfield %qE to %qT",
6611 else if (lvalue
& clk_packed
)
6612 error_at (loc
, "cannot bind packed field %qE to %qT",
6615 error_at (loc
, "cannot bind rvalue %qE to %qT",
6617 return error_mark_node
;
6619 /* If the source is a packed field, and we must use a copy
6620 constructor, then building the target expr will require
6621 binding the field to the reference parameter to the
6622 copy constructor, and we'll end up with an infinite
6623 loop. If we can use a bitwise copy, then we'll be
6625 if ((lvalue
& clk_packed
)
6626 && CLASS_TYPE_P (type
)
6627 && type_has_nontrivial_copy_init (type
))
6629 error_at (loc
, "cannot bind packed field %qE to %qT",
6631 return error_mark_node
;
6633 if (lvalue
& clk_bitfield
)
6635 expr
= convert_bitfield_to_declared_type (expr
);
6636 expr
= fold_convert (type
, expr
);
6638 expr
= build_target_expr_with_type (expr
, type
, complain
);
6641 /* Take the address of the thing to which we will bind the
6643 expr
= cp_build_addr_expr (expr
, complain
);
6644 if (expr
== error_mark_node
)
6645 return error_mark_node
;
6647 /* Convert it to a pointer to the type referred to by the
6648 reference. This will adjust the pointer if a derived to
6649 base conversion is being performed. */
6650 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
6652 /* Convert the pointer to the desired reference type. */
6653 return build_nop (ref_type
, expr
);
6657 return decay_conversion (expr
, complain
);
6660 /* ??? Should the address of a transaction-safe pointer point to the TM
6661 clone, and this conversion look up the primary function? */
6662 return build_nop (totype
, expr
);
6665 /* Warn about deprecated conversion if appropriate. */
6666 string_conv_p (totype
, expr
, 1);
6671 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
6672 /*nonnull=*/false, complain
);
6673 return build_nop (totype
, expr
);
6676 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
6677 c_cast_p
, complain
);
6683 if (convs
->check_narrowing
6684 && !check_narrowing (totype
, expr
, complain
))
6685 return error_mark_node
;
6687 if (issue_conversion_warnings
)
6688 expr
= cp_convert_and_check (totype
, expr
, complain
);
6690 expr
= cp_convert (totype
, expr
, complain
);
6695 /* ARG is being passed to a varargs function. Perform any conversions
6696 required. Return the converted value. */
6699 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
6702 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
6706 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6707 standard conversions are performed. */
6708 arg
= decay_conversion (arg
, complain
);
6709 arg_type
= TREE_TYPE (arg
);
6712 If the argument has integral or enumeration type that is subject
6713 to the integral promotions (_conv.prom_), or a floating point
6714 type that is subject to the floating point promotion
6715 (_conv.fpprom_), the value of the argument is converted to the
6716 promoted type before the call. */
6717 if (TREE_CODE (arg_type
) == REAL_TYPE
6718 && (TYPE_PRECISION (arg_type
)
6719 < TYPE_PRECISION (double_type_node
))
6720 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
6722 if ((complain
& tf_warning
)
6723 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
6724 warning_at (loc
, OPT_Wdouble_promotion
,
6725 "implicit conversion from %qT to %qT when passing "
6726 "argument to function",
6727 arg_type
, double_type_node
);
6728 arg
= convert_to_real (double_type_node
, arg
);
6730 else if (NULLPTR_TYPE_P (arg_type
))
6731 arg
= null_pointer_node
;
6732 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
6734 if (SCOPED_ENUM_P (arg_type
))
6736 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
6738 prom
= cp_perform_integral_promotions (prom
, complain
);
6739 if (abi_version_crosses (6)
6740 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
6741 && (complain
& tf_warning
))
6742 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through ... as "
6743 "%qT before -fabi-version=6, %qT after", arg_type
,
6744 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
6745 if (!abi_version_at_least (6))
6749 arg
= cp_perform_integral_promotions (arg
, complain
);
6752 arg
= require_complete_type_sfinae (arg
, complain
);
6753 arg_type
= TREE_TYPE (arg
);
6755 if (arg
!= error_mark_node
6756 /* In a template (or ill-formed code), we can have an incomplete type
6757 even after require_complete_type_sfinae, in which case we don't know
6758 whether it has trivial copy or not. */
6759 && COMPLETE_TYPE_P (arg_type
))
6761 /* Build up a real lvalue-to-rvalue conversion in case the
6762 copy constructor is trivial but not callable. */
6763 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
6764 force_rvalue (arg
, complain
);
6766 /* [expr.call] 5.2.2/7:
6767 Passing a potentially-evaluated argument of class type (Clause 9)
6768 with a non-trivial copy constructor or a non-trivial destructor
6769 with no corresponding parameter is conditionally-supported, with
6770 implementation-defined semantics.
6772 We support it as pass-by-invisible-reference, just like a normal
6775 If the call appears in the context of a sizeof expression,
6776 it is not potentially-evaluated. */
6777 if (cp_unevaluated_operand
== 0
6778 && (type_has_nontrivial_copy_init (arg_type
)
6779 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
6781 if (complain
& tf_warning
)
6782 warning (OPT_Wconditionally_supported
,
6783 "passing objects of non-trivially-copyable "
6784 "type %q#T through %<...%> is conditionally supported",
6786 return cp_build_addr_expr (arg
, complain
);
6793 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6796 build_x_va_arg (source_location loc
, tree expr
, tree type
)
6798 if (processing_template_decl
)
6800 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
6801 SET_EXPR_LOCATION (r
, loc
);
6805 type
= complete_type_or_else (type
, NULL_TREE
);
6807 if (expr
== error_mark_node
|| !type
)
6808 return error_mark_node
;
6810 expr
= mark_lvalue_use (expr
);
6812 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6814 error ("cannot receive reference type %qT through %<...%>", type
);
6815 return error_mark_node
;
6818 if (type_has_nontrivial_copy_init (type
)
6819 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6821 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
6822 it as pass by invisible reference. */
6823 warning_at (loc
, OPT_Wconditionally_supported
,
6824 "receiving objects of non-trivially-copyable type %q#T "
6825 "through %<...%> is conditionally-supported", type
);
6827 tree ref
= cp_build_reference_type (type
, false);
6828 expr
= build_va_arg (loc
, expr
, ref
);
6829 return convert_from_reference (expr
);
6832 return build_va_arg (loc
, expr
, type
);
6835 /* TYPE has been given to va_arg. Apply the default conversions which
6836 would have happened when passed via ellipsis. Return the promoted
6837 type, or the passed type if there is no change. */
6840 cxx_type_promotes_to (tree type
)
6844 /* Perform the array-to-pointer and function-to-pointer
6846 type
= type_decays_to (type
);
6848 promote
= type_promotes_to (type
);
6849 if (same_type_p (type
, promote
))
6855 /* ARG is a default argument expression being passed to a parameter of
6856 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6857 zero-based argument number. Do any required conversions. Return
6858 the converted value. */
6860 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
6862 push_defarg_context (tree fn
)
6863 { vec_safe_push (default_arg_context
, fn
); }
6866 pop_defarg_context (void)
6867 { default_arg_context
->pop (); }
6870 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
6871 tsubst_flags_t complain
)
6876 /* See through clones. */
6877 fn
= DECL_ORIGIN (fn
);
6879 /* Detect recursion. */
6880 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
6883 if (complain
& tf_error
)
6884 error ("recursive evaluation of default argument for %q#D", fn
);
6885 return error_mark_node
;
6888 /* If the ARG is an unparsed default argument expression, the
6889 conversion cannot be performed. */
6890 if (TREE_CODE (arg
) == DEFAULT_ARG
)
6892 if (complain
& tf_error
)
6893 error ("call to %qD uses the default argument for parameter %P, which "
6894 "is not yet defined", fn
, parmnum
);
6895 return error_mark_node
;
6898 push_defarg_context (fn
);
6900 if (fn
&& DECL_TEMPLATE_INFO (fn
))
6901 arg
= tsubst_default_argument (fn
, type
, arg
, complain
);
6907 The names in the expression are bound, and the semantic
6908 constraints are checked, at the point where the default
6909 expressions appears.
6911 we must not perform access checks here. */
6912 push_deferring_access_checks (dk_no_check
);
6913 /* We must make a copy of ARG, in case subsequent processing
6914 alters any part of it. */
6915 arg
= break_out_target_exprs (arg
);
6916 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6917 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6919 arg
= convert_for_arg_passing (type
, arg
, complain
);
6920 pop_deferring_access_checks();
6922 pop_defarg_context ();
6927 /* Returns the type which will really be used for passing an argument of
6931 type_passed_as (tree type
)
6933 /* Pass classes with copy ctors by invisible reference. */
6934 if (TREE_ADDRESSABLE (type
))
6936 type
= build_reference_type (type
);
6937 /* There are no other pointers to this temporary. */
6938 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
6940 else if (targetm
.calls
.promote_prototypes (type
)
6941 && INTEGRAL_TYPE_P (type
)
6942 && COMPLETE_TYPE_P (type
)
6943 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6944 type
= integer_type_node
;
6949 /* Actually perform the appropriate conversion. */
6952 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
6956 /* If VAL is a bitfield, then -- since it has already been converted
6957 to TYPE -- it cannot have a precision greater than TYPE.
6959 If it has a smaller precision, we must widen it here. For
6960 example, passing "int f:3;" to a function expecting an "int" will
6961 not result in any conversion before this point.
6963 If the precision is the same we must not risk widening. For
6964 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6965 often have type "int", even though the C++ type for the field is
6966 "long long". If the value is being passed to a function
6967 expecting an "int", then no conversions will be required. But,
6968 if we call convert_bitfield_to_declared_type, the bitfield will
6969 be converted to "long long". */
6970 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
6972 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
6973 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
6975 if (val
== error_mark_node
)
6977 /* Pass classes with copy ctors by invisible reference. */
6978 else if (TREE_ADDRESSABLE (type
))
6979 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
6980 else if (targetm
.calls
.promote_prototypes (type
)
6981 && INTEGRAL_TYPE_P (type
)
6982 && COMPLETE_TYPE_P (type
)
6983 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6984 val
= cp_perform_integral_promotions (val
, complain
);
6985 if ((complain
& tf_warning
)
6986 && warn_suggest_attribute_format
)
6988 tree rhstype
= TREE_TYPE (val
);
6989 const enum tree_code coder
= TREE_CODE (rhstype
);
6990 const enum tree_code codel
= TREE_CODE (type
);
6991 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6993 && check_missing_format_attribute (type
, rhstype
))
6994 warning (OPT_Wsuggest_attribute_format
,
6995 "argument of function call might be a candidate for a format attribute");
7000 /* Returns true iff FN is a function with magic varargs, i.e. ones for
7001 which no conversions at all should be done. This is true for some
7002 builtins which don't act like normal functions. */
7005 magic_varargs_p (tree fn
)
7007 if (flag_cilkplus
&& is_cilkplus_reduce_builtin (fn
) != BUILT_IN_NONE
)
7010 if (DECL_BUILT_IN (fn
))
7011 switch (DECL_FUNCTION_CODE (fn
))
7013 case BUILT_IN_CLASSIFY_TYPE
:
7014 case BUILT_IN_CONSTANT_P
:
7015 case BUILT_IN_NEXT_ARG
:
7016 case BUILT_IN_VA_START
:
7020 return lookup_attribute ("type generic",
7021 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
7027 /* Returns the decl of the dispatcher function if FN is a function version. */
7030 get_function_version_dispatcher (tree fn
)
7032 tree dispatcher_decl
= NULL
;
7034 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
7035 && DECL_FUNCTION_VERSIONED (fn
));
7037 gcc_assert (targetm
.get_function_versions_dispatcher
);
7038 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
7040 if (dispatcher_decl
== NULL
)
7042 error_at (input_location
, "use of multiversioned function "
7043 "without a default");
7047 retrofit_lang_decl (dispatcher_decl
);
7048 gcc_assert (dispatcher_decl
!= NULL
);
7049 return dispatcher_decl
;
7052 /* fn is a function version dispatcher that is marked used. Mark all the
7053 semantically identical function versions it will dispatch as used. */
7056 mark_versions_used (tree fn
)
7058 struct cgraph_node
*node
;
7059 struct cgraph_function_version_info
*node_v
;
7060 struct cgraph_function_version_info
*it_v
;
7062 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
7064 node
= cgraph_node::get (fn
);
7068 gcc_assert (node
->dispatcher_function
);
7070 node_v
= node
->function_version ();
7074 /* All semantically identical versions are chained. Traverse and mark each
7075 one of them as used. */
7076 it_v
= node_v
->next
;
7077 while (it_v
!= NULL
)
7079 mark_used (it_v
->this_node
->decl
);
7084 /* Build a call to "the copy constructor" for the type of A, even if it
7085 wouldn't be selected by normal overload resolution. Used for
7089 call_copy_ctor (tree a
, tsubst_flags_t complain
)
7091 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
7092 tree binfo
= TYPE_BINFO (ctype
);
7093 tree copy
= get_copy_ctor (ctype
, complain
);
7094 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
7095 tree ob
= build_dummy_object (ctype
);
7096 vec
<tree
, va_gc
>* args
= make_tree_vector_single (a
);
7097 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
7098 LOOKUP_NORMAL
, NULL
, complain
);
7099 release_tree_vector (args
);
7103 /* Return true iff T refers to a base field. */
7106 is_base_field_ref (tree t
)
7109 if (TREE_CODE (t
) == ADDR_EXPR
)
7110 t
= TREE_OPERAND (t
, 0);
7111 if (TREE_CODE (t
) == COMPONENT_REF
)
7112 t
= TREE_OPERAND (t
, 1);
7113 if (TREE_CODE (t
) == FIELD_DECL
)
7114 return DECL_FIELD_IS_BASE (t
);
7118 /* We can't elide a copy from a function returning by value to a base
7119 subobject, as the callee might clobber tail padding. Return true iff this
7120 could be that case. */
7123 unsafe_copy_elision_p (tree target
, tree exp
)
7125 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
7126 if (type
== CLASSTYPE_AS_BASE (type
))
7128 if (!is_base_field_ref (target
)
7129 && resolves_to_fixed_type_p (target
, NULL
))
7131 tree init
= TARGET_EXPR_INITIAL (exp
);
7132 return (TREE_CODE (init
) == AGGR_INIT_EXPR
7133 && !AGGR_INIT_VIA_CTOR_P (init
));
7136 /* Subroutine of the various build_*_call functions. Overload resolution
7137 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
7138 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
7139 bitmask of various LOOKUP_* flags which apply to the call itself. */
7142 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
7145 const vec
<tree
, va_gc
> *args
= cand
->args
;
7146 tree first_arg
= cand
->first_arg
;
7147 conversion
**convs
= cand
->convs
;
7149 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7154 unsigned int arg_index
= 0;
7158 bool already_used
= false;
7160 /* In a template, there is no need to perform all of the work that
7161 is normally done. We are only interested in the type of the call
7162 expression, i.e., the return type of the function. Any semantic
7163 errors will be deferred until the template is instantiated. */
7164 if (processing_template_decl
)
7168 const tree
*argarray
;
7171 return_type
= TREE_TYPE (TREE_TYPE (fn
));
7172 nargs
= vec_safe_length (args
);
7173 if (first_arg
== NULL_TREE
)
7174 argarray
= args
->address ();
7182 alcarray
= XALLOCAVEC (tree
, nargs
);
7183 alcarray
[0] = build_this (first_arg
);
7184 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
7185 alcarray
[ix
+ 1] = arg
;
7186 argarray
= alcarray
;
7189 addr
= build_addr_func (fn
, complain
);
7190 if (addr
== error_mark_node
)
7191 return error_mark_node
;
7192 expr
= build_call_array_loc (input_location
, return_type
,
7193 addr
, nargs
, argarray
);
7194 if (TREE_THIS_VOLATILE (fn
) && cfun
)
7195 current_function_returns_abnormally
= 1;
7196 return convert_from_reference (expr
);
7199 /* Give any warnings we noticed during overload resolution. */
7200 if (cand
->warnings
&& (complain
& tf_warning
))
7202 struct candidate_warning
*w
;
7203 for (w
= cand
->warnings
; w
; w
= w
->next
)
7204 joust (cand
, w
->loser
, 1, complain
);
7207 /* Make =delete work with SFINAE. */
7208 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7209 return error_mark_node
;
7211 if (DECL_FUNCTION_MEMBER_P (fn
))
7214 /* If FN is a template function, two cases must be considered.
7219 template <class T> void f();
7221 template <class T> struct B {
7225 struct C : A, B<int> {
7227 using B<int>::g; // #2
7230 In case #1 where `A::f' is a member template, DECL_ACCESS is
7231 recorded in the primary template but not in its specialization.
7232 We check access of FN using its primary template.
7234 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
7235 because it is a member of class template B, DECL_ACCESS is
7236 recorded in the specialization `B<int>::g'. We cannot use its
7237 primary template because `B<T>::g' and `B<int>::g' may have
7238 different access. */
7239 if (DECL_TEMPLATE_INFO (fn
)
7240 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
7241 access_fn
= DECL_TI_TEMPLATE (fn
);
7244 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
7246 return error_mark_node
;
7249 /* If we're checking for implicit delete, don't bother with argument
7251 if (flags
& LOOKUP_SPECULATIVE
)
7253 if (DECL_DELETED_FN (fn
))
7255 if (complain
& tf_error
)
7257 return error_mark_node
;
7259 if (cand
->viable
== 1)
7261 else if (!(complain
& tf_error
))
7262 /* Reject bad conversions now. */
7263 return error_mark_node
;
7264 /* else continue to get conversion error. */
7267 /* N3276 magic doesn't apply to nested calls. */
7268 int decltype_flag
= (complain
& tf_decltype
);
7269 complain
&= ~tf_decltype
;
7271 /* Find maximum size of vector to hold converted arguments. */
7272 parmlen
= list_length (parm
);
7273 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
7274 if (parmlen
> nargs
)
7276 argarray
= XALLOCAVEC (tree
, nargs
);
7278 /* The implicit parameters to a constructor are not considered by overload
7279 resolution, and must be of the proper type. */
7280 if (DECL_CONSTRUCTOR_P (fn
))
7283 if (first_arg
!= NULL_TREE
)
7285 object_arg
= first_arg
;
7286 first_arg
= NULL_TREE
;
7290 object_arg
= (*args
)[arg_index
];
7293 argarray
[j
++] = build_this (object_arg
);
7294 parm
= TREE_CHAIN (parm
);
7295 /* We should never try to call the abstract constructor. */
7296 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
7298 if (DECL_HAS_VTT_PARM_P (fn
))
7300 argarray
[j
++] = (*args
)[arg_index
];
7302 parm
= TREE_CHAIN (parm
);
7305 /* Bypass access control for 'this' parameter. */
7306 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7308 tree parmtype
= TREE_VALUE (parm
);
7309 tree arg
= build_this (first_arg
!= NULL_TREE
7311 : (*args
)[arg_index
]);
7312 tree argtype
= TREE_TYPE (arg
);
7316 if (convs
[i
]->bad_p
)
7318 if (complain
& tf_error
)
7320 if (permerror (input_location
, "passing %qT as %<this%> "
7321 "argument discards qualifiers",
7322 TREE_TYPE (argtype
)))
7323 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
7326 return error_mark_node
;
7329 /* See if the function member or the whole class type is declared
7330 final and the call can be devirtualized. */
7331 if (DECL_FINAL_P (fn
)
7332 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
7333 flags
|= LOOKUP_NONVIRTUAL
;
7335 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
7336 X is called for an object that is not of type X, or of a type
7337 derived from X, the behavior is undefined.
7339 So we can assume that anything passed as 'this' is non-null, and
7340 optimize accordingly. */
7341 gcc_assert (TYPE_PTR_P (parmtype
));
7342 /* Convert to the base in which the function was declared. */
7343 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
7344 converted_arg
= build_base_path (PLUS_EXPR
,
7346 cand
->conversion_path
,
7348 /* Check that the base class is accessible. */
7349 if (!accessible_base_p (TREE_TYPE (argtype
),
7350 BINFO_TYPE (cand
->conversion_path
), true))
7352 if (complain
& tf_error
)
7353 error ("%qT is not an accessible base of %qT",
7354 BINFO_TYPE (cand
->conversion_path
),
7355 TREE_TYPE (argtype
));
7357 return error_mark_node
;
7359 /* If fn was found by a using declaration, the conversion path
7360 will be to the derived class, not the base declaring fn. We
7361 must convert from derived to base. */
7362 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
7363 TREE_TYPE (parmtype
), ba_unique
,
7365 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
7366 base_binfo
, 1, complain
);
7368 argarray
[j
++] = converted_arg
;
7369 parm
= TREE_CHAIN (parm
);
7370 if (first_arg
!= NULL_TREE
)
7371 first_arg
= NULL_TREE
;
7378 gcc_assert (first_arg
== NULL_TREE
);
7379 for (; arg_index
< vec_safe_length (args
) && parm
;
7380 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
7382 tree type
= TREE_VALUE (parm
);
7383 tree arg
= (*args
)[arg_index
];
7384 bool conversion_warning
= true;
7388 /* If the argument is NULL and used to (implicitly) instantiate a
7389 template function (and bind one of the template arguments to
7390 the type of 'long int'), we don't want to warn about passing NULL
7391 to non-pointer argument.
7392 For example, if we have this template function:
7394 template<typename T> void func(T x) {}
7396 we want to warn (when -Wconversion is enabled) in this case:
7402 but not in this case:
7408 if (arg
== null_node
7409 && DECL_TEMPLATE_INFO (fn
)
7410 && cand
->template_decl
7411 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
7412 conversion_warning
= false;
7414 /* Warn about initializer_list deduction that isn't currently in the
7416 if (cxx_dialect
> cxx98
7417 && flag_deduce_init_list
7418 && cand
->template_decl
7419 && is_std_init_list (non_reference (type
))
7420 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
7422 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
7423 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
7424 tree patparm
= get_pattern_parm (realparm
, tmpl
);
7425 tree pattype
= TREE_TYPE (patparm
);
7426 if (PACK_EXPANSION_P (pattype
))
7427 pattype
= PACK_EXPANSION_PATTERN (pattype
);
7428 pattype
= non_reference (pattype
);
7430 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
7431 && (cand
->explicit_targs
== NULL_TREE
7432 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
7433 <= TEMPLATE_TYPE_IDX (pattype
))))
7435 pedwarn (input_location
, 0, "deducing %qT as %qT",
7436 non_reference (TREE_TYPE (patparm
)),
7437 non_reference (type
));
7438 pedwarn (DECL_SOURCE_LOCATION (cand
->fn
), 0,
7439 " in call to %qD", cand
->fn
);
7440 pedwarn (input_location
, 0,
7441 " (you can disable this with -fno-deduce-init-list)");
7444 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
7447 : complain
& (~tf_warning
));
7449 val
= convert_for_arg_passing (type
, val
, complain
);
7451 if (val
== error_mark_node
)
7452 return error_mark_node
;
7454 argarray
[j
++] = val
;
7457 /* Default arguments */
7458 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
7460 if (TREE_VALUE (parm
) == error_mark_node
)
7461 return error_mark_node
;
7462 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
7463 TREE_PURPOSE (parm
),
7469 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
7471 tree a
= (*args
)[arg_index
];
7472 if (magic_varargs_p (fn
))
7473 /* Do no conversions for magic varargs. */
7474 a
= mark_type_use (a
);
7475 else if (DECL_CONSTRUCTOR_P (fn
)
7476 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
7479 /* Avoid infinite recursion trying to call A(...). */
7480 if (complain
& tf_error
)
7481 /* Try to call the actual copy constructor for a good error. */
7482 call_copy_ctor (a
, complain
);
7483 return error_mark_node
;
7486 a
= convert_arg_to_ellipsis (a
, complain
);
7490 gcc_assert (j
<= nargs
);
7493 check_function_arguments (TREE_TYPE (fn
), nargs
, argarray
);
7495 /* Avoid actually calling copy constructors and copy assignment operators,
7498 if (! flag_elide_constructors
)
7499 /* Do things the hard way. */;
7500 else if (cand
->num_convs
== 1
7501 && (DECL_COPY_CONSTRUCTOR_P (fn
)
7502 || DECL_MOVE_CONSTRUCTOR_P (fn
))
7503 /* It's unsafe to elide the constructor when handling
7504 a noexcept-expression, it may evaluate to the wrong
7505 value (c++/53025). */
7506 && cp_noexcept_operand
== 0)
7509 tree arg
= argarray
[num_artificial_parms_for (fn
)];
7511 bool trivial
= trivial_fn_p (fn
);
7513 /* Pull out the real argument, disregarding const-correctness. */
7515 while (CONVERT_EXPR_P (targ
)
7516 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
7517 targ
= TREE_OPERAND (targ
, 0);
7518 if (TREE_CODE (targ
) == ADDR_EXPR
)
7520 targ
= TREE_OPERAND (targ
, 0);
7521 if (!same_type_ignoring_top_level_qualifiers_p
7522 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
7531 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7533 /* [class.copy]: the copy constructor is implicitly defined even if
7534 the implementation elided its use. */
7535 if (!trivial
|| DECL_DELETED_FN (fn
))
7537 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7538 return error_mark_node
;
7539 already_used
= true;
7542 /* If we're creating a temp and we already have one, don't create a
7543 new one. If we're not creating a temp but we get one, use
7544 INIT_EXPR to collapse the temp into our target. Otherwise, if the
7545 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
7546 temp or an INIT_EXPR otherwise. */
7548 if (is_dummy_object (fa
))
7550 if (TREE_CODE (arg
) == TARGET_EXPR
)
7553 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
7556 || (TREE_CODE (arg
) == TARGET_EXPR
7557 && !unsafe_copy_elision_p (fa
, arg
)))
7559 tree to
= stabilize_reference (cp_build_indirect_ref (fa
, RO_NULL
,
7562 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
7566 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
7567 && trivial_fn_p (fn
)
7568 && !DECL_DELETED_FN (fn
))
7570 tree to
= stabilize_reference
7571 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
7572 tree type
= TREE_TYPE (to
);
7573 tree as_base
= CLASSTYPE_AS_BASE (type
);
7574 tree arg
= argarray
[1];
7576 if (is_really_empty_class (type
))
7578 /* Avoid copying empty classes. */
7579 val
= build2 (COMPOUND_EXPR
, void_type_node
, to
, arg
);
7580 TREE_NO_WARNING (val
) = 1;
7581 val
= build2 (COMPOUND_EXPR
, type
, val
, to
);
7582 TREE_NO_WARNING (val
) = 1;
7584 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
7586 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7587 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
7591 /* We must only copy the non-tail padding parts. */
7593 tree array_type
, alias_set
;
7595 arg2
= TYPE_SIZE_UNIT (as_base
);
7596 arg0
= cp_build_addr_expr (to
, complain
);
7598 array_type
= build_array_type (char_type_node
,
7600 (size_binop (MINUS_EXPR
,
7601 arg2
, size_int (1))));
7602 alias_set
= build_int_cst (build_pointer_type (type
), 0);
7603 t
= build2 (MODIFY_EXPR
, void_type_node
,
7604 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
7605 build2 (MEM_REF
, array_type
, arg
, alias_set
));
7606 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
7607 TREE_NO_WARNING (val
) = 1;
7612 else if (DECL_DESTRUCTOR_P (fn
)
7613 && trivial_fn_p (fn
)
7614 && !DECL_DELETED_FN (fn
))
7615 return fold_convert (void_type_node
, argarray
[0]);
7616 /* FIXME handle trivial default constructor, too. */
7618 /* For calls to a multi-versioned function, overload resolution
7619 returns the function with the highest target priority, that is,
7620 the version that will checked for dispatching first. If this
7621 version is inlinable, a direct call to this version can be made
7622 otherwise the call should go through the dispatcher. */
7624 if (DECL_FUNCTION_VERSIONED (fn
)
7625 && (current_function_decl
== NULL
7626 || !targetm
.target_option
.can_inline_p (current_function_decl
, fn
)))
7628 fn
= get_function_version_dispatcher (fn
);
7632 mark_versions_used (fn
);
7636 && !mark_used (fn
, complain
))
7637 return error_mark_node
;
7639 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
7640 /* Don't mess with virtual lookup in instantiate_non_dependent_expr;
7641 virtual functions can't be constexpr. */
7642 && !in_template_function ())
7645 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
7647 ba_any
, NULL
, complain
);
7648 gcc_assert (binfo
&& binfo
!= error_mark_node
);
7650 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
7652 if (TREE_SIDE_EFFECTS (argarray
[0]))
7653 argarray
[0] = save_expr (argarray
[0]);
7654 t
= build_pointer_type (TREE_TYPE (fn
));
7655 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
7656 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
7658 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
7663 fn
= build_addr_func (fn
, complain
);
7664 if (fn
== error_mark_node
)
7665 return error_mark_node
;
7668 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
7669 if (TREE_CODE (call
) == CALL_EXPR
7670 && (cand
->flags
& LOOKUP_LIST_INIT_CTOR
))
7671 CALL_EXPR_LIST_INIT_P (call
) = true;
7675 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7676 This function performs no overload resolution, conversion, or other
7677 high-level operations. */
7680 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
7681 tsubst_flags_t complain
)
7686 /* Remember roughly where this call is. */
7687 location_t loc
= EXPR_LOC_OR_LOC (fn
, input_location
);
7688 fn
= build_call_a (fn
, nargs
, argarray
);
7689 SET_EXPR_LOCATION (fn
, loc
);
7691 fndecl
= get_callee_fndecl (fn
);
7693 /* Check that arguments to builtin functions match the expectations. */
7695 && DECL_BUILT_IN (fndecl
)
7696 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7697 && !check_builtin_function_arguments (fndecl
, nargs
, argarray
))
7698 return error_mark_node
;
7700 /* If it is a built-in array notation function, then the return type of
7701 the function is the element type of the array passed in as array
7702 notation (i.e. the first parameter of the function). */
7703 if (flag_cilkplus
&& TREE_CODE (fn
) == CALL_EXPR
)
7705 enum built_in_function bif
=
7706 is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn
));
7707 if (bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
7708 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
7709 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
7710 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
7711 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE
7712 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
7714 if (call_expr_nargs (fn
) == 0)
7716 error_at (EXPR_LOCATION (fn
), "Invalid builtin arguments");
7717 return error_mark_node
;
7719 /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or
7720 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or
7721 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or
7722 BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or
7723 BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or
7724 BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
7725 The pre-defined return-type is the correct one. */
7726 tree array_ntn
= CALL_EXPR_ARG (fn
, 0);
7727 TREE_TYPE (fn
) = TREE_TYPE (array_ntn
);
7732 /* Some built-in function calls will be evaluated at compile-time in
7733 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7734 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7735 optimize_sav
= optimize
;
7736 if (!optimize
&& fndecl
&& DECL_IS_BUILTIN_CONSTANT_P (fndecl
)
7737 && current_function_decl
7738 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
7740 fn
= fold_if_not_in_template (fn
);
7741 optimize
= optimize_sav
;
7743 if (VOID_TYPE_P (TREE_TYPE (fn
)))
7746 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7747 function call is either the operand of a decltype-specifier or the
7748 right operand of a comma operator that is the operand of a
7749 decltype-specifier, a temporary object is not introduced for the
7750 prvalue. The type of the prvalue may be incomplete. */
7751 if (!(complain
& tf_decltype
))
7753 fn
= require_complete_type_sfinae (fn
, complain
);
7754 if (fn
== error_mark_node
)
7755 return error_mark_node
;
7757 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
7758 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
7760 return convert_from_reference (fn
);
7763 static GTY(()) tree java_iface_lookup_fn
;
7765 /* Make an expression which yields the address of the Java interface
7766 method FN. This is achieved by generating a call to libjava's
7767 _Jv_LookupInterfaceMethodIdx(). */
7770 build_java_interface_fn_ref (tree fn
, tree instance
)
7772 tree lookup_fn
, method
, idx
;
7773 tree klass_ref
, iface
, iface_ref
;
7776 if (!java_iface_lookup_fn
)
7778 tree ftype
= build_function_type_list (ptr_type_node
,
7779 ptr_type_node
, ptr_type_node
,
7780 java_int_type_node
, NULL_TREE
);
7781 java_iface_lookup_fn
7782 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype
,
7783 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
7786 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7787 This is the first entry in the vtable. */
7788 klass_ref
= build_vtbl_ref (cp_build_indirect_ref (instance
, RO_NULL
,
7789 tf_warning_or_error
),
7792 /* Get the java.lang.Class pointer for the interface being called. */
7793 iface
= DECL_CONTEXT (fn
);
7794 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
7795 if (!iface_ref
|| !VAR_P (iface_ref
)
7796 || DECL_CONTEXT (iface_ref
) != iface
)
7798 error ("could not find class$ field in java interface type %qT",
7800 return error_mark_node
;
7802 iface_ref
= build_address (iface_ref
);
7803 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
7805 /* Determine the itable index of FN. */
7807 for (method
= TYPE_METHODS (iface
); method
; method
= DECL_CHAIN (method
))
7809 if (!DECL_VIRTUAL_P (method
))
7815 idx
= build_int_cst (NULL_TREE
, i
);
7817 lookup_fn
= build1 (ADDR_EXPR
,
7818 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
7819 java_iface_lookup_fn
);
7820 return build_call_nary (ptr_type_node
, lookup_fn
,
7821 3, klass_ref
, iface_ref
, idx
);
7824 /* Returns the value to use for the in-charge parameter when making a
7825 call to a function with the indicated NAME.
7827 FIXME:Can't we find a neater way to do this mapping? */
7830 in_charge_arg_for_name (tree name
)
7832 if (name
== base_ctor_identifier
7833 || name
== base_dtor_identifier
)
7834 return integer_zero_node
;
7835 else if (name
== complete_ctor_identifier
)
7836 return integer_one_node
;
7837 else if (name
== complete_dtor_identifier
)
7838 return integer_two_node
;
7839 else if (name
== deleting_dtor_identifier
)
7840 return integer_three_node
;
7842 /* This function should only be called with one of the names listed
7848 /* Build a call to a constructor, destructor, or an assignment
7849 operator for INSTANCE, an expression with class type. NAME
7850 indicates the special member function to call; *ARGS are the
7851 arguments. ARGS may be NULL. This may change ARGS. BINFO
7852 indicates the base of INSTANCE that is to be passed as the `this'
7853 parameter to the member function called.
7855 FLAGS are the LOOKUP_* flags to use when processing the call.
7857 If NAME indicates a complete object constructor, INSTANCE may be
7858 NULL_TREE. In this case, the caller will call build_cplus_new to
7859 store the newly constructed object into a VAR_DECL. */
7862 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
7863 tree binfo
, int flags
, tsubst_flags_t complain
)
7866 /* The type of the subobject to be constructed or destroyed. */
7868 vec
<tree
, va_gc
> *allocated
= NULL
;
7871 gcc_assert (name
== complete_ctor_identifier
7872 || name
== base_ctor_identifier
7873 || name
== complete_dtor_identifier
7874 || name
== base_dtor_identifier
7875 || name
== deleting_dtor_identifier
7876 || name
== ansi_assopname (NOP_EXPR
));
7879 /* Resolve the name. */
7880 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
7881 return error_mark_node
;
7883 binfo
= TYPE_BINFO (binfo
);
7886 gcc_assert (binfo
!= NULL_TREE
);
7888 class_type
= BINFO_TYPE (binfo
);
7890 /* Handle the special case where INSTANCE is NULL_TREE. */
7891 if (name
== complete_ctor_identifier
&& !instance
)
7892 instance
= build_dummy_object (class_type
);
7895 if (name
== complete_dtor_identifier
7896 || name
== base_dtor_identifier
7897 || name
== deleting_dtor_identifier
)
7898 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
7900 /* Convert to the base class, if necessary. */
7901 if (!same_type_ignoring_top_level_qualifiers_p
7902 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
7904 if (name
!= ansi_assopname (NOP_EXPR
))
7905 /* For constructors and destructors, either the base is
7906 non-virtual, or it is virtual but we are doing the
7907 conversion from a constructor or destructor for the
7908 complete object. In either case, we can convert
7910 instance
= convert_to_base_statically (instance
, binfo
);
7912 /* However, for assignment operators, we must convert
7913 dynamically if the base is virtual. */
7914 instance
= build_base_path (PLUS_EXPR
, instance
,
7915 binfo
, /*nonnull=*/1, complain
);
7919 gcc_assert (instance
!= NULL_TREE
);
7921 fns
= lookup_fnfields (binfo
, name
, 1);
7923 /* When making a call to a constructor or destructor for a subobject
7924 that uses virtual base classes, pass down a pointer to a VTT for
7926 if ((name
== base_ctor_identifier
7927 || name
== base_dtor_identifier
)
7928 && CLASSTYPE_VBASECLASSES (class_type
))
7933 /* If the current function is a complete object constructor
7934 or destructor, then we fetch the VTT directly.
7935 Otherwise, we look it up using the VTT we were given. */
7936 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
7937 vtt
= decay_conversion (vtt
, complain
);
7938 if (vtt
== error_mark_node
)
7939 return error_mark_node
;
7940 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
7941 build2 (EQ_EXPR
, boolean_type_node
,
7942 current_in_charge_parm
, integer_zero_node
),
7945 if (BINFO_SUBVTT_INDEX (binfo
))
7946 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
7952 allocated
= make_tree_vector ();
7956 vec_safe_insert (*args
, 0, sub_vtt
);
7959 ret
= build_new_method_call (instance
, fns
, args
,
7960 TYPE_BINFO (BINFO_TYPE (binfo
)),
7964 if (allocated
!= NULL
)
7965 release_tree_vector (allocated
);
7967 if ((complain
& tf_error
)
7968 && (flags
& LOOKUP_DELEGATING_CONS
)
7969 && name
== complete_ctor_identifier
7970 && TREE_CODE (ret
) == CALL_EXPR
7971 && (DECL_ABSTRACT_ORIGIN (TREE_OPERAND (CALL_EXPR_FN (ret
), 0))
7972 == current_function_decl
))
7973 error ("constructor delegates to itself");
7978 /* Return the NAME, as a C string. The NAME indicates a function that
7979 is a member of TYPE. *FREE_P is set to true if the caller must
7980 free the memory returned.
7982 Rather than go through all of this, we should simply set the names
7983 of constructors and destructors appropriately, and dispense with
7984 ctor_identifier, dtor_identifier, etc. */
7987 name_as_c_string (tree name
, tree type
, bool *free_p
)
7991 /* Assume that we will not allocate memory. */
7993 /* Constructors and destructors are special. */
7994 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7997 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
7998 /* For a destructor, add the '~'. */
7999 if (name
== complete_dtor_identifier
8000 || name
== base_dtor_identifier
8001 || name
== deleting_dtor_identifier
)
8003 pretty_name
= concat ("~", pretty_name
, NULL
);
8004 /* Remember that we need to free the memory allocated. */
8008 else if (IDENTIFIER_TYPENAME_P (name
))
8010 pretty_name
= concat ("operator ",
8011 type_as_string_translate (TREE_TYPE (name
),
8012 TFF_PLAIN_IDENTIFIER
),
8014 /* Remember that we need to free the memory allocated. */
8018 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
8023 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
8024 be set, upon return, to the function called. ARGS may be NULL.
8025 This may change ARGS. */
8028 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8029 tree conversion_path
, int flags
,
8030 tree
*fn_p
, tsubst_flags_t complain
)
8032 struct z_candidate
*candidates
= 0, *cand
;
8033 tree explicit_targs
= NULL_TREE
;
8034 tree basetype
= NULL_TREE
;
8035 tree access_binfo
, binfo
;
8037 tree first_mem_arg
= NULL_TREE
;
8039 bool skip_first_for_error
;
8040 vec
<tree
, va_gc
> *user_args
;
8043 int template_only
= 0;
8047 vec
<tree
, va_gc
> *orig_args
= NULL
;
8050 gcc_assert (instance
!= NULL_TREE
);
8052 /* We don't know what function we're going to call, yet. */
8056 if (error_operand_p (instance
)
8057 || !fns
|| error_operand_p (fns
))
8058 return error_mark_node
;
8060 if (!BASELINK_P (fns
))
8062 if (complain
& tf_error
)
8063 error ("call to non-function %qD", fns
);
8064 return error_mark_node
;
8067 orig_instance
= instance
;
8070 /* Dismantle the baselink to collect all the information we need. */
8071 if (!conversion_path
)
8072 conversion_path
= BASELINK_BINFO (fns
);
8073 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
8074 binfo
= BASELINK_BINFO (fns
);
8075 optype
= BASELINK_OPTYPE (fns
);
8076 fns
= BASELINK_FUNCTIONS (fns
);
8077 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
8079 explicit_targs
= TREE_OPERAND (fns
, 1);
8080 fns
= TREE_OPERAND (fns
, 0);
8083 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
8084 || TREE_CODE (fns
) == TEMPLATE_DECL
8085 || TREE_CODE (fns
) == OVERLOAD
);
8086 fn
= get_first_fn (fns
);
8087 name
= DECL_NAME (fn
);
8089 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
8090 gcc_assert (CLASS_TYPE_P (basetype
));
8092 if (processing_template_decl
)
8094 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
8095 instance
= build_non_dependent_expr (instance
);
8097 make_args_non_dependent (*args
);
8100 user_args
= args
== NULL
? NULL
: *args
;
8101 /* Under DR 147 A::A() is an invalid constructor call,
8102 not a functional cast. */
8103 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
8105 if (! (complain
& tf_error
))
8106 return error_mark_node
;
8108 if (permerror (input_location
,
8109 "cannot call constructor %<%T::%D%> directly",
8111 inform (input_location
, "for a function-style cast, remove the "
8112 "redundant %<::%D%>", name
);
8113 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
8118 /* Figure out whether to skip the first argument for the error
8119 message we will display to users if an error occurs. We don't
8120 want to display any compiler-generated arguments. The "this"
8121 pointer hasn't been added yet. However, we must remove the VTT
8122 pointer if this is a call to a base-class constructor or
8124 skip_first_for_error
= false;
8125 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
8127 /* Callers should explicitly indicate whether they want to construct
8128 the complete object or just the part without virtual bases. */
8129 gcc_assert (name
!= ctor_identifier
);
8130 /* Similarly for destructors. */
8131 gcc_assert (name
!= dtor_identifier
);
8132 /* Remove the VTT pointer, if present. */
8133 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
8134 && CLASSTYPE_VBASECLASSES (basetype
))
8135 skip_first_for_error
= true;
8138 /* Process the argument list. */
8139 if (args
!= NULL
&& *args
!= NULL
)
8141 *args
= resolve_args (*args
, complain
);
8143 return error_mark_node
;
8146 /* Consider the object argument to be used even if we end up selecting a
8147 static member function. */
8148 instance
= mark_type_use (instance
);
8150 /* It's OK to call destructors and constructors on cv-qualified objects.
8151 Therefore, convert the INSTANCE to the unqualified type, if
8153 if (DECL_DESTRUCTOR_P (fn
)
8154 || DECL_CONSTRUCTOR_P (fn
))
8156 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
8158 instance
= build_this (instance
);
8159 instance
= build_nop (build_pointer_type (basetype
), instance
);
8160 instance
= build_fold_indirect_ref (instance
);
8163 if (DECL_DESTRUCTOR_P (fn
))
8164 name
= complete_dtor_identifier
;
8166 /* For the overload resolution we need to find the actual `this`
8167 that would be captured if the call turns out to be to a
8168 non-static member function. Do not actually capture it at this
8170 if (DECL_CONSTRUCTOR_P (fn
))
8171 /* Constructors don't use the enclosing 'this'. */
8172 first_mem_arg
= instance
;
8174 first_mem_arg
= maybe_resolve_dummy (instance
, false);
8176 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8177 p
= conversion_obstack_alloc (0);
8179 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
8180 initializer, not T({ }). */
8181 if (DECL_CONSTRUCTOR_P (fn
) && args
!= NULL
&& !vec_safe_is_empty (*args
)
8182 && DIRECT_LIST_INIT_P ((**args
)[0]))
8184 tree init_list
= (**args
)[0];
8185 tree init
= NULL_TREE
;
8187 gcc_assert ((*args
)->length () == 1
8188 && !(flags
& LOOKUP_ONLYCONVERTING
));
8190 /* If the initializer list has no elements and T is a class type with
8191 a default constructor, the object is value-initialized. Handle
8192 this here so we don't need to handle it wherever we use
8193 build_special_member_call. */
8194 if (CONSTRUCTOR_NELTS (init_list
) == 0
8195 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
8196 /* For a user-provided default constructor, use the normal
8197 mechanisms so that protected access works. */
8198 && type_has_non_user_provided_default_constructor (basetype
)
8199 && !processing_template_decl
)
8200 init
= build_value_init (basetype
, complain
);
8202 /* If BASETYPE is an aggregate, we need to do aggregate
8204 else if (CP_AGGREGATE_TYPE_P (basetype
))
8206 init
= reshape_init (basetype
, init_list
, complain
);
8207 init
= digest_init (basetype
, init
, complain
);
8212 if (is_dummy_object (instance
))
8213 return get_target_expr_sfinae (init
, complain
);
8214 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
8215 TREE_SIDE_EFFECTS (init
) = true;
8219 /* Otherwise go ahead with overload resolution. */
8220 add_list_candidates (fns
, first_mem_arg
, init_list
,
8221 basetype
, explicit_targs
, template_only
,
8222 conversion_path
, access_binfo
, flags
,
8223 &candidates
, complain
);
8227 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
8228 explicit_targs
, template_only
, conversion_path
,
8229 access_binfo
, flags
, &candidates
, complain
);
8231 any_viable_p
= false;
8232 candidates
= splice_viable (candidates
, false, &any_viable_p
);
8236 if (complain
& tf_error
)
8238 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
8239 cxx_incomplete_type_error (instance
, basetype
);
8241 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
8242 basetype
, optype
, build_tree_list_vec (user_args
),
8243 TREE_TYPE (instance
));
8250 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8251 arglist
= build_tree_list_vec (user_args
);
8252 if (skip_first_for_error
)
8253 arglist
= TREE_CHAIN (arglist
);
8254 error ("no matching function for call to %<%T::%s(%A)%#V%>",
8255 basetype
, pretty_name
, arglist
,
8256 TREE_TYPE (instance
));
8260 print_z_candidates (location_of (name
), candidates
);
8262 call
= error_mark_node
;
8266 cand
= tourney (candidates
, complain
);
8273 if (complain
& tf_error
)
8275 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8276 arglist
= build_tree_list_vec (user_args
);
8277 if (skip_first_for_error
)
8278 arglist
= TREE_CHAIN (arglist
);
8279 if (!any_strictly_viable (candidates
))
8280 error ("no matching function for call to %<%s(%A)%>",
8281 pretty_name
, arglist
);
8283 error ("call of overloaded %<%s(%A)%> is ambiguous",
8284 pretty_name
, arglist
);
8285 print_z_candidates (location_of (name
), candidates
);
8289 call
= error_mark_node
;
8296 if (!(flags
& LOOKUP_NONVIRTUAL
)
8297 && DECL_PURE_VIRTUAL_P (fn
)
8298 && instance
== current_class_ref
8299 && (complain
& tf_warning
))
8301 /* This is not an error, it is runtime undefined
8303 if (!current_function_decl
)
8304 warning (0, "pure virtual %q#D called from "
8305 "non-static data member initializer", fn
);
8306 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
8307 || DECL_DESTRUCTOR_P (current_function_decl
))
8308 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
8309 ? "pure virtual %q#D called from constructor"
8310 : "pure virtual %q#D called from destructor"),
8314 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
8315 && !DECL_CONSTRUCTOR_P (fn
)
8316 && is_dummy_object (instance
))
8318 instance
= maybe_resolve_dummy (instance
, true);
8319 if (instance
== error_mark_node
)
8320 call
= error_mark_node
;
8321 else if (!is_dummy_object (instance
))
8323 /* We captured 'this' in the current lambda now that
8324 we know we really need it. */
8325 cand
->first_arg
= instance
;
8329 if (complain
& tf_error
)
8330 error ("cannot call member function %qD without object",
8332 call
= error_mark_node
;
8336 if (call
!= error_mark_node
)
8338 /* Optimize away vtable lookup if we know that this
8339 function can't be overridden. We need to check if
8340 the context and the type where we found fn are the same,
8341 actually FN might be defined in a different class
8342 type because of a using-declaration. In this case, we
8343 do not want to perform a non-virtual call. */
8344 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
8345 && same_type_ignoring_top_level_qualifiers_p
8346 (DECL_CONTEXT (fn
), BINFO_TYPE (binfo
))
8347 && resolves_to_fixed_type_p (instance
, 0))
8348 flags
|= LOOKUP_NONVIRTUAL
;
8350 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
8351 /* Now we know what function is being called. */
8354 /* Build the actual CALL_EXPR. */
8355 call
= build_over_call (cand
, flags
, complain
);
8356 /* In an expression of the form `a->f()' where `f' turns
8357 out to be a static member function, `a' is
8358 none-the-less evaluated. */
8359 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
8360 && !is_dummy_object (instance
)
8361 && TREE_SIDE_EFFECTS (instance
))
8362 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
8364 else if (call
!= error_mark_node
8365 && DECL_DESTRUCTOR_P (cand
->fn
)
8366 && !VOID_TYPE_P (TREE_TYPE (call
)))
8367 /* An explicit call of the form "x->~X()" has type
8368 "void". However, on platforms where destructors
8369 return "this" (i.e., those where
8370 targetm.cxx.cdtor_returns_this is true), such calls
8371 will appear to have a return value of pointer type
8372 to the low-level call machinery. We do not want to
8373 change the low-level machinery, since we want to be
8374 able to optimize "delete f()" on such platforms as
8375 "operator delete(~X(f()))" (rather than generating
8376 "t = f(), ~X(t), operator delete (t)"). */
8377 call
= build_nop (void_type_node
, call
);
8382 if (processing_template_decl
&& call
!= error_mark_node
)
8384 bool cast_to_void
= false;
8386 if (TREE_CODE (call
) == COMPOUND_EXPR
)
8387 call
= TREE_OPERAND (call
, 1);
8388 else if (TREE_CODE (call
) == NOP_EXPR
)
8390 cast_to_void
= true;
8391 call
= TREE_OPERAND (call
, 0);
8393 if (INDIRECT_REF_P (call
))
8394 call
= TREE_OPERAND (call
, 0);
8395 call
= (build_min_non_dep_call_vec
8397 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
8398 orig_instance
, orig_fns
, NULL_TREE
),
8400 SET_EXPR_LOCATION (call
, input_location
);
8401 call
= convert_from_reference (call
);
8403 call
= build_nop (void_type_node
, call
);
8406 /* Free all the conversions we allocated. */
8407 obstack_free (&conversion_obstack
, p
);
8409 if (orig_args
!= NULL
)
8410 release_tree_vector (orig_args
);
8415 /* Wrapper for above. */
8418 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8419 tree conversion_path
, int flags
,
8420 tree
*fn_p
, tsubst_flags_t complain
)
8423 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
8424 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
8426 timevar_cond_stop (TV_OVERLOAD
, subtime
);
8430 /* Returns true iff standard conversion sequence ICS1 is a proper
8431 subsequence of ICS2. */
8434 is_subseq (conversion
*ics1
, conversion
*ics2
)
8436 /* We can assume that a conversion of the same code
8437 between the same types indicates a subsequence since we only get
8438 here if the types we are converting from are the same. */
8440 while (ics1
->kind
== ck_rvalue
8441 || ics1
->kind
== ck_lvalue
)
8442 ics1
= next_conversion (ics1
);
8446 while (ics2
->kind
== ck_rvalue
8447 || ics2
->kind
== ck_lvalue
)
8448 ics2
= next_conversion (ics2
);
8450 if (ics2
->kind
== ck_user
8451 || ics2
->kind
== ck_ambig
8452 || ics2
->kind
== ck_aggr
8453 || ics2
->kind
== ck_list
8454 || ics2
->kind
== ck_identity
)
8455 /* At this point, ICS1 cannot be a proper subsequence of
8456 ICS2. We can get a USER_CONV when we are comparing the
8457 second standard conversion sequence of two user conversion
8461 ics2
= next_conversion (ics2
);
8463 if (ics2
->kind
== ics1
->kind
8464 && same_type_p (ics2
->type
, ics1
->type
)
8465 && same_type_p (next_conversion (ics2
)->type
,
8466 next_conversion (ics1
)->type
))
8471 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
8472 be any _TYPE nodes. */
8475 is_properly_derived_from (tree derived
, tree base
)
8477 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
8480 /* We only allow proper derivation here. The DERIVED_FROM_P macro
8481 considers every class derived from itself. */
8482 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
8483 && DERIVED_FROM_P (base
, derived
));
8486 /* We build the ICS for an implicit object parameter as a pointer
8487 conversion sequence. However, such a sequence should be compared
8488 as if it were a reference conversion sequence. If ICS is the
8489 implicit conversion sequence for an implicit object parameter,
8490 modify it accordingly. */
8493 maybe_handle_implicit_object (conversion
**ics
)
8497 /* [over.match.funcs]
8499 For non-static member functions, the type of the
8500 implicit object parameter is "reference to cv X"
8501 where X is the class of which the function is a
8502 member and cv is the cv-qualification on the member
8503 function declaration. */
8504 conversion
*t
= *ics
;
8505 tree reference_type
;
8507 /* The `this' parameter is a pointer to a class type. Make the
8508 implicit conversion talk about a reference to that same class
8510 reference_type
= TREE_TYPE (t
->type
);
8511 reference_type
= build_reference_type (reference_type
);
8513 if (t
->kind
== ck_qual
)
8514 t
= next_conversion (t
);
8515 if (t
->kind
== ck_ptr
)
8516 t
= next_conversion (t
);
8517 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
8518 t
= direct_reference_binding (reference_type
, t
);
8520 t
->rvaluedness_matches_p
= 0;
8525 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
8526 and return the initial reference binding conversion. Otherwise,
8527 leave *ICS unchanged and return NULL. */
8530 maybe_handle_ref_bind (conversion
**ics
)
8532 if ((*ics
)->kind
== ck_ref_bind
)
8534 conversion
*old_ics
= *ics
;
8535 *ics
= next_conversion (old_ics
);
8536 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
8543 /* Compare two implicit conversion sequences according to the rules set out in
8544 [over.ics.rank]. Return values:
8546 1: ics1 is better than ics2
8547 -1: ics2 is better than ics1
8548 0: ics1 and ics2 are indistinguishable */
8551 compare_ics (conversion
*ics1
, conversion
*ics2
)
8557 tree deref_from_type1
= NULL_TREE
;
8558 tree deref_from_type2
= NULL_TREE
;
8559 tree deref_to_type1
= NULL_TREE
;
8560 tree deref_to_type2
= NULL_TREE
;
8561 conversion_rank rank1
, rank2
;
8563 /* REF_BINDING is nonzero if the result of the conversion sequence
8564 is a reference type. In that case REF_CONV is the reference
8565 binding conversion. */
8566 conversion
*ref_conv1
;
8567 conversion
*ref_conv2
;
8569 /* Compare badness before stripping the reference conversion. */
8570 if (ics1
->bad_p
> ics2
->bad_p
)
8572 else if (ics1
->bad_p
< ics2
->bad_p
)
8575 /* Handle implicit object parameters. */
8576 maybe_handle_implicit_object (&ics1
);
8577 maybe_handle_implicit_object (&ics2
);
8579 /* Handle reference parameters. */
8580 ref_conv1
= maybe_handle_ref_bind (&ics1
);
8581 ref_conv2
= maybe_handle_ref_bind (&ics2
);
8583 /* List-initialization sequence L1 is a better conversion sequence than
8584 list-initialization sequence L2 if L1 converts to
8585 std::initializer_list<X> for some X and L2 does not. */
8586 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
8588 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
8593 When comparing the basic forms of implicit conversion sequences (as
8594 defined in _over.best.ics_)
8596 --a standard conversion sequence (_over.ics.scs_) is a better
8597 conversion sequence than a user-defined conversion sequence
8598 or an ellipsis conversion sequence, and
8600 --a user-defined conversion sequence (_over.ics.user_) is a
8601 better conversion sequence than an ellipsis conversion sequence
8602 (_over.ics.ellipsis_). */
8603 /* Use BAD_CONVERSION_RANK because we already checked for a badness
8604 mismatch. If both ICS are bad, we try to make a decision based on
8605 what would have happened if they'd been good. This is not an
8606 extension, we'll still give an error when we build up the call; this
8607 just helps us give a more helpful error message. */
8608 rank1
= BAD_CONVERSION_RANK (ics1
);
8609 rank2
= BAD_CONVERSION_RANK (ics2
);
8613 else if (rank1
< rank2
)
8616 if (ics1
->ellipsis_p
)
8617 /* Both conversions are ellipsis conversions. */
8620 /* User-defined conversion sequence U1 is a better conversion sequence
8621 than another user-defined conversion sequence U2 if they contain the
8622 same user-defined conversion operator or constructor and if the sec-
8623 ond standard conversion sequence of U1 is better than the second
8624 standard conversion sequence of U2. */
8626 /* Handle list-conversion with the same code even though it isn't always
8627 ranked as a user-defined conversion and it doesn't have a second
8628 standard conversion sequence; it will still have the desired effect.
8629 Specifically, we need to do the reference binding comparison at the
8630 end of this function. */
8632 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
8637 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
8638 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
8639 || t1
->kind
== ck_list
)
8641 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
8642 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
8643 || t2
->kind
== ck_list
)
8646 if (t1
->kind
!= t2
->kind
)
8648 else if (t1
->kind
== ck_user
)
8650 if (t1
->cand
->fn
!= t2
->cand
->fn
)
8655 /* For ambiguous or aggregate conversions, use the target type as
8656 a proxy for the conversion function. */
8657 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
8661 /* We can just fall through here, after setting up
8662 FROM_TYPE1 and FROM_TYPE2. */
8663 from_type1
= t1
->type
;
8664 from_type2
= t2
->type
;
8671 /* We're dealing with two standard conversion sequences.
8675 Standard conversion sequence S1 is a better conversion
8676 sequence than standard conversion sequence S2 if
8678 --S1 is a proper subsequence of S2 (comparing the conversion
8679 sequences in the canonical form defined by _over.ics.scs_,
8680 excluding any Lvalue Transformation; the identity
8681 conversion sequence is considered to be a subsequence of
8682 any non-identity conversion sequence */
8685 while (t1
->kind
!= ck_identity
)
8686 t1
= next_conversion (t1
);
8687 from_type1
= t1
->type
;
8690 while (t2
->kind
!= ck_identity
)
8691 t2
= next_conversion (t2
);
8692 from_type2
= t2
->type
;
8695 /* One sequence can only be a subsequence of the other if they start with
8696 the same type. They can start with different types when comparing the
8697 second standard conversion sequence in two user-defined conversion
8699 if (same_type_p (from_type1
, from_type2
))
8701 if (is_subseq (ics1
, ics2
))
8703 if (is_subseq (ics2
, ics1
))
8711 --the rank of S1 is better than the rank of S2 (by the rules
8714 Standard conversion sequences are ordered by their ranks: an Exact
8715 Match is a better conversion than a Promotion, which is a better
8716 conversion than a Conversion.
8718 Two conversion sequences with the same rank are indistinguishable
8719 unless one of the following rules applies:
8721 --A conversion that does not a convert a pointer, pointer to member,
8722 or std::nullptr_t to bool is better than one that does.
8724 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8725 so that we do not have to check it explicitly. */
8726 if (ics1
->rank
< ics2
->rank
)
8728 else if (ics2
->rank
< ics1
->rank
)
8731 to_type1
= ics1
->type
;
8732 to_type2
= ics2
->type
;
8734 /* A conversion from scalar arithmetic type to complex is worse than a
8735 conversion between scalar arithmetic types. */
8736 if (same_type_p (from_type1
, from_type2
)
8737 && ARITHMETIC_TYPE_P (from_type1
)
8738 && ARITHMETIC_TYPE_P (to_type1
)
8739 && ARITHMETIC_TYPE_P (to_type2
)
8740 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8741 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
8743 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8749 if (TYPE_PTR_P (from_type1
)
8750 && TYPE_PTR_P (from_type2
)
8751 && TYPE_PTR_P (to_type1
)
8752 && TYPE_PTR_P (to_type2
))
8754 deref_from_type1
= TREE_TYPE (from_type1
);
8755 deref_from_type2
= TREE_TYPE (from_type2
);
8756 deref_to_type1
= TREE_TYPE (to_type1
);
8757 deref_to_type2
= TREE_TYPE (to_type2
);
8759 /* The rules for pointers to members A::* are just like the rules
8760 for pointers A*, except opposite: if B is derived from A then
8761 A::* converts to B::*, not vice versa. For that reason, we
8762 switch the from_ and to_ variables here. */
8763 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
8764 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
8765 || (TYPE_PTRMEMFUNC_P (from_type1
)
8766 && TYPE_PTRMEMFUNC_P (from_type2
)
8767 && TYPE_PTRMEMFUNC_P (to_type1
)
8768 && TYPE_PTRMEMFUNC_P (to_type2
)))
8770 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
8771 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
8772 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
8773 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
8776 if (deref_from_type1
!= NULL_TREE
8777 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
8778 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
8780 /* This was one of the pointer or pointer-like conversions.
8784 --If class B is derived directly or indirectly from class A,
8785 conversion of B* to A* is better than conversion of B* to
8786 void*, and conversion of A* to void* is better than
8787 conversion of B* to void*. */
8788 if (VOID_TYPE_P (deref_to_type1
)
8789 && VOID_TYPE_P (deref_to_type2
))
8791 if (is_properly_derived_from (deref_from_type1
,
8794 else if (is_properly_derived_from (deref_from_type2
,
8798 else if (VOID_TYPE_P (deref_to_type1
)
8799 || VOID_TYPE_P (deref_to_type2
))
8801 if (same_type_p (deref_from_type1
, deref_from_type2
))
8803 if (VOID_TYPE_P (deref_to_type2
))
8805 if (is_properly_derived_from (deref_from_type1
,
8809 /* We know that DEREF_TO_TYPE1 is `void' here. */
8810 else if (is_properly_derived_from (deref_from_type1
,
8815 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
8816 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
8820 --If class B is derived directly or indirectly from class A
8821 and class C is derived directly or indirectly from B,
8823 --conversion of C* to B* is better than conversion of C* to
8826 --conversion of B* to A* is better than conversion of C* to
8828 if (same_type_p (deref_from_type1
, deref_from_type2
))
8830 if (is_properly_derived_from (deref_to_type1
,
8833 else if (is_properly_derived_from (deref_to_type2
,
8837 else if (same_type_p (deref_to_type1
, deref_to_type2
))
8839 if (is_properly_derived_from (deref_from_type2
,
8842 else if (is_properly_derived_from (deref_from_type1
,
8848 else if (CLASS_TYPE_P (non_reference (from_type1
))
8849 && same_type_p (from_type1
, from_type2
))
8851 tree from
= non_reference (from_type1
);
8855 --binding of an expression of type C to a reference of type
8856 B& is better than binding an expression of type C to a
8857 reference of type A&
8859 --conversion of C to B is better than conversion of C to A, */
8860 if (is_properly_derived_from (from
, to_type1
)
8861 && is_properly_derived_from (from
, to_type2
))
8863 if (is_properly_derived_from (to_type1
, to_type2
))
8865 else if (is_properly_derived_from (to_type2
, to_type1
))
8869 else if (CLASS_TYPE_P (non_reference (to_type1
))
8870 && same_type_p (to_type1
, to_type2
))
8872 tree to
= non_reference (to_type1
);
8876 --binding of an expression of type B to a reference of type
8877 A& is better than binding an expression of type C to a
8878 reference of type A&,
8880 --conversion of B to A is better than conversion of C to A */
8881 if (is_properly_derived_from (from_type1
, to
)
8882 && is_properly_derived_from (from_type2
, to
))
8884 if (is_properly_derived_from (from_type2
, from_type1
))
8886 else if (is_properly_derived_from (from_type1
, from_type2
))
8893 --S1 and S2 differ only in their qualification conversion and yield
8894 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8895 qualification signature of type T1 is a proper subset of the cv-
8896 qualification signature of type T2 */
8897 if (ics1
->kind
== ck_qual
8898 && ics2
->kind
== ck_qual
8899 && same_type_p (from_type1
, from_type2
))
8901 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
8908 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8909 to an implicit object parameter of a non-static member function
8910 declared without a ref-qualifier, and either S1 binds an lvalue
8911 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
8912 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
8913 draft standard, 13.3.3.2)
8915 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8916 types to which the references refer are the same type except for
8917 top-level cv-qualifiers, and the type to which the reference
8918 initialized by S2 refers is more cv-qualified than the type to
8919 which the reference initialized by S1 refers.
8921 DR 1328 [over.match.best]: the context is an initialization by
8922 conversion function for direct reference binding (13.3.1.6) of a
8923 reference to function type, the return type of F1 is the same kind of
8924 reference (i.e. lvalue or rvalue) as the reference being initialized,
8925 and the return type of F2 is not. */
8927 if (ref_conv1
&& ref_conv2
)
8929 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
8930 && (ref_conv1
->rvaluedness_matches_p
8931 != ref_conv2
->rvaluedness_matches_p
)
8932 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
8933 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
8934 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
8936 if (ref_conv1
->bad_p
8937 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
8938 TREE_TYPE (ref_conv2
->type
)))
8939 /* Don't prefer a bad conversion that drops cv-quals to a bad
8940 conversion with the wrong rvalueness. */
8942 return (ref_conv1
->rvaluedness_matches_p
8943 - ref_conv2
->rvaluedness_matches_p
);
8946 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
8948 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
8949 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
8950 if (ref_conv1
->bad_p
)
8952 /* Prefer the one that drops fewer cv-quals. */
8953 tree ftype
= next_conversion (ref_conv1
)->type
;
8954 int fquals
= cp_type_quals (ftype
);
8958 return comp_cv_qualification (q2
, q1
);
8962 /* Neither conversion sequence is better than the other. */
8966 /* The source type for this standard conversion sequence. */
8969 source_type (conversion
*t
)
8971 for (;; t
= next_conversion (t
))
8973 if (t
->kind
== ck_user
8974 || t
->kind
== ck_ambig
8975 || t
->kind
== ck_identity
)
8981 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8982 a pointer to LOSER and re-running joust to produce the warning if WINNER
8983 is actually used. */
8986 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
8988 candidate_warning
*cw
= (candidate_warning
*)
8989 conversion_obstack_alloc (sizeof (candidate_warning
));
8991 cw
->next
= winner
->warnings
;
8992 winner
->warnings
= cw
;
8995 /* Compare two candidates for overloading as described in
8996 [over.match.best]. Return values:
8998 1: cand1 is better than cand2
8999 -1: cand2 is better than cand1
9000 0: cand1 and cand2 are indistinguishable */
9003 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
9004 tsubst_flags_t complain
)
9007 int off1
= 0, off2
= 0;
9011 /* Candidates that involve bad conversions are always worse than those
9013 if (cand1
->viable
> cand2
->viable
)
9015 if (cand1
->viable
< cand2
->viable
)
9018 /* If we have two pseudo-candidates for conversions to the same type,
9019 or two candidates for the same function, arbitrarily pick one. */
9020 if (cand1
->fn
== cand2
->fn
9021 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
9024 /* Prefer a non-deleted function over an implicitly deleted move
9025 constructor or assignment operator. This differs slightly from the
9026 wording for issue 1402 (which says the move op is ignored by overload
9027 resolution), but this way produces better error messages. */
9028 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9029 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9030 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
9032 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
9033 && move_fn_p (cand1
->fn
))
9035 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
9036 && move_fn_p (cand2
->fn
))
9040 /* a viable function F1
9041 is defined to be a better function than another viable function F2 if
9042 for all arguments i, ICSi(F1) is not a worse conversion sequence than
9043 ICSi(F2), and then */
9045 /* for some argument j, ICSj(F1) is a better conversion sequence than
9048 /* For comparing static and non-static member functions, we ignore
9049 the implicit object parameter of the non-static function. The
9050 standard says to pretend that the static function has an object
9051 parm, but that won't work with operator overloading. */
9052 len
= cand1
->num_convs
;
9053 if (len
!= cand2
->num_convs
)
9055 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
9056 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
9058 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
9059 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
9060 /* We're comparing a near-match list constructor and a near-match
9061 non-list constructor. Just treat them as unordered. */
9064 gcc_assert (static_1
!= static_2
);
9075 for (i
= 0; i
< len
; ++i
)
9077 conversion
*t1
= cand1
->convs
[i
+ off1
];
9078 conversion
*t2
= cand2
->convs
[i
+ off2
];
9079 int comp
= compare_ics (t1
, t2
);
9083 if ((complain
& tf_warning
)
9085 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
9086 == cr_std
+ cr_promotion
)
9087 && t1
->kind
== ck_std
9088 && t2
->kind
== ck_std
9089 && TREE_CODE (t1
->type
) == INTEGER_TYPE
9090 && TREE_CODE (t2
->type
) == INTEGER_TYPE
9091 && (TYPE_PRECISION (t1
->type
)
9092 == TYPE_PRECISION (t2
->type
))
9093 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
9094 || (TREE_CODE (next_conversion (t1
)->type
)
9097 tree type
= next_conversion (t1
)->type
;
9099 struct z_candidate
*w
, *l
;
9101 type1
= t1
->type
, type2
= t2
->type
,
9102 w
= cand1
, l
= cand2
;
9104 type1
= t2
->type
, type2
= t1
->type
,
9105 w
= cand2
, l
= cand1
;
9109 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
9110 type
, type1
, type2
);
9111 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
9117 if (winner
&& comp
!= winner
)
9126 /* warn about confusing overload resolution for user-defined conversions,
9127 either between a constructor and a conversion op, or between two
9129 if ((complain
& tf_warning
)
9130 && winner
&& warn_conversion
&& cand1
->second_conv
9131 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
9132 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
9134 struct z_candidate
*w
, *l
;
9135 bool give_warning
= false;
9138 w
= cand1
, l
= cand2
;
9140 w
= cand2
, l
= cand1
;
9142 /* We don't want to complain about `X::operator T1 ()'
9143 beating `X::operator T2 () const', when T2 is a no less
9144 cv-qualified version of T1. */
9145 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
9146 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
9148 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
9149 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
9151 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
9156 if (!comp_ptr_ttypes (t
, f
))
9157 give_warning
= true;
9160 give_warning
= true;
9166 tree source
= source_type (w
->convs
[0]);
9167 if (! DECL_CONSTRUCTOR_P (w
->fn
))
9168 source
= TREE_TYPE (source
);
9169 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
9170 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
9171 source
, w
->second_conv
->type
))
9173 inform (input_location
, " because conversion sequence for the argument is better");
9183 /* DR 495 moved this tiebreaker above the template ones. */
9185 the context is an initialization by user-defined conversion (see
9186 _dcl.init_ and _over.match.user_) and the standard conversion
9187 sequence from the return type of F1 to the destination type (i.e.,
9188 the type of the entity being initialized) is a better conversion
9189 sequence than the standard conversion sequence from the return type
9190 of F2 to the destination type. */
9192 if (cand1
->second_conv
)
9194 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
9200 F1 is a non-template function and F2 is a template function
9203 if (!cand1
->template_decl
&& cand2
->template_decl
)
9205 else if (cand1
->template_decl
&& !cand2
->template_decl
)
9209 F1 and F2 are template functions and the function template for F1 is
9210 more specialized than the template for F2 according to the partial
9213 if (cand1
->template_decl
&& cand2
->template_decl
)
9215 winner
= more_specialized_fn
9216 (TI_TEMPLATE (cand1
->template_decl
),
9217 TI_TEMPLATE (cand2
->template_decl
),
9218 /* [temp.func.order]: The presence of unused ellipsis and default
9219 arguments has no effect on the partial ordering of function
9220 templates. add_function_candidate() will not have
9221 counted the "this" argument for constructors. */
9222 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
9228 // or, if not that, F1 is more constrained than F2.
9229 if (flag_concepts
&& DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
))
9231 winner
= more_constrained (cand1
->fn
, cand2
->fn
);
9236 /* Check whether we can discard a builtin candidate, either because we
9237 have two identical ones or matching builtin and non-builtin candidates.
9239 (Pedantically in the latter case the builtin which matched the user
9240 function should not be added to the overload set, but we spot it here.
9243 ... the builtin candidates include ...
9244 - do not have the same parameter type list as any non-template
9245 non-member candidate. */
9247 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
9249 for (i
= 0; i
< len
; ++i
)
9250 if (!same_type_p (cand1
->convs
[i
]->type
,
9251 cand2
->convs
[i
]->type
))
9253 if (i
== cand1
->num_convs
)
9255 if (cand1
->fn
== cand2
->fn
)
9256 /* Two built-in candidates; arbitrarily pick one. */
9258 else if (identifier_p (cand1
->fn
))
9259 /* cand1 is built-in; prefer cand2. */
9262 /* cand2 is built-in; prefer cand1. */
9267 /* For candidates of a multi-versioned function, make the version with
9268 the highest priority win. This version will be checked for dispatching
9269 first. If this version can be inlined into the caller, the front-end
9270 will simply make a direct call to this function. */
9272 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9273 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
9274 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9275 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
9277 tree f1
= TREE_TYPE (cand1
->fn
);
9278 tree f2
= TREE_TYPE (cand2
->fn
);
9279 tree p1
= TYPE_ARG_TYPES (f1
);
9280 tree p2
= TYPE_ARG_TYPES (f2
);
9282 /* Check if cand1->fn and cand2->fn are versions of the same function. It
9283 is possible that cand1->fn and cand2->fn are function versions but of
9284 different functions. Check types to see if they are versions of the same
9286 if (compparms (p1
, p2
)
9287 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
9289 /* Always make the version with the higher priority, more
9290 specialized, win. */
9291 gcc_assert (targetm
.compare_version_priority
);
9292 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
9299 /* If the two function declarations represent the same function (this can
9300 happen with declarations in multiple scopes and arg-dependent lookup),
9301 arbitrarily choose one. But first make sure the default args we're
9303 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
9304 && equal_functions (cand1
->fn
, cand2
->fn
))
9306 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
9307 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
9309 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
9311 for (i
= 0; i
< len
; ++i
)
9313 /* Don't crash if the fn is variadic. */
9316 parms1
= TREE_CHAIN (parms1
);
9317 parms2
= TREE_CHAIN (parms2
);
9321 parms1
= TREE_CHAIN (parms1
);
9323 parms2
= TREE_CHAIN (parms2
);
9327 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
9328 TREE_PURPOSE (parms2
)))
9332 if (complain
& tf_error
)
9334 if (permerror (input_location
,
9335 "default argument mismatch in "
9336 "overload resolution"))
9338 inform (input_location
,
9339 " candidate 1: %q+#F", cand1
->fn
);
9340 inform (input_location
,
9341 " candidate 2: %q+#F", cand2
->fn
);
9348 add_warning (cand1
, cand2
);
9351 parms1
= TREE_CHAIN (parms1
);
9352 parms2
= TREE_CHAIN (parms2
);
9360 /* Extension: If the worst conversion for one candidate is worse than the
9361 worst conversion for the other, take the first. */
9362 if (!pedantic
&& (complain
& tf_warning_or_error
))
9364 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
9365 struct z_candidate
*w
= 0, *l
= 0;
9367 for (i
= 0; i
< len
; ++i
)
9369 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
9370 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
9371 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
9372 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
9375 winner
= 1, w
= cand1
, l
= cand2
;
9377 winner
= -1, w
= cand2
, l
= cand1
;
9380 /* Don't choose a deleted function over ambiguity. */
9381 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
9385 pedwarn (input_location
, 0,
9386 "ISO C++ says that these are ambiguous, even "
9387 "though the worst conversion for the first is better than "
9388 "the worst conversion for the second:");
9389 print_z_candidate (input_location
, _("candidate 1:"), w
);
9390 print_z_candidate (input_location
, _("candidate 2:"), l
);
9398 gcc_assert (!winner
);
9402 /* Given a list of candidates for overloading, find the best one, if any.
9403 This algorithm has a worst case of O(2n) (winner is last), and a best
9404 case of O(n/2) (totally ambiguous); much better than a sorting
9407 static struct z_candidate
*
9408 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
9410 struct z_candidate
*champ
= candidates
, *challenger
;
9412 int champ_compared_to_predecessor
= 0;
9414 /* Walk through the list once, comparing each current champ to the next
9415 candidate, knocking out a candidate or two with each comparison. */
9417 for (challenger
= champ
->next
; challenger
; )
9419 fate
= joust (champ
, challenger
, 0, complain
);
9421 challenger
= challenger
->next
;
9426 champ
= challenger
->next
;
9429 champ_compared_to_predecessor
= 0;
9434 champ_compared_to_predecessor
= 1;
9437 challenger
= champ
->next
;
9441 /* Make sure the champ is better than all the candidates it hasn't yet
9442 been compared to. */
9444 for (challenger
= candidates
;
9446 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
9447 challenger
= challenger
->next
)
9449 fate
= joust (champ
, challenger
, 0, complain
);
9457 /* Returns nonzero if things of type FROM can be converted to TO. */
9460 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
9462 tree arg
= NULL_TREE
;
9463 /* implicit_conversion only considers user-defined conversions
9464 if it has an expression for the call argument list. */
9465 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
9466 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
9467 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
9470 /* Returns nonzero if things of type FROM can be converted to TO with a
9471 standard conversion. */
9474 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
9476 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
9479 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
9482 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
9483 tsubst_flags_t complain
)
9489 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9490 p
= conversion_obstack_alloc (0);
9491 /* We want to discard any access checks done for this test,
9492 as we might not be in the appropriate access context and
9493 we'll do the check again when we actually perform the
9495 push_deferring_access_checks (dk_deferred
);
9497 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9499 ok_p
= (t
&& !t
->bad_p
);
9501 /* Discard the access checks now. */
9502 pop_deferring_access_checks ();
9503 /* Free all the conversions we allocated. */
9504 obstack_free (&conversion_obstack
, p
);
9509 /* Like can_convert_arg, but allows dubious conversions as well. */
9512 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
9513 tsubst_flags_t complain
)
9518 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9519 p
= conversion_obstack_alloc (0);
9520 /* Try to perform the conversion. */
9521 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9523 /* Free all the conversions we allocated. */
9524 obstack_free (&conversion_obstack
, p
);
9529 /* Convert EXPR to TYPE. Return the converted expression.
9531 Note that we allow bad conversions here because by the time we get to
9532 this point we are committed to doing the conversion. If we end up
9533 doing a bad conversion, convert_like will complain. */
9536 perform_implicit_conversion_flags (tree type
, tree expr
,
9537 tsubst_flags_t complain
, int flags
)
9541 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9543 if (error_operand_p (expr
))
9544 return error_mark_node
;
9546 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9547 p
= conversion_obstack_alloc (0);
9549 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9555 if (complain
& tf_error
)
9557 /* If expr has unknown type, then it is an overloaded function.
9558 Call instantiate_type to get good error messages. */
9559 if (TREE_TYPE (expr
) == unknown_type_node
)
9560 instantiate_type (type
, expr
, complain
);
9561 else if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
9562 /* We gave an error. */;
9564 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
9565 TREE_TYPE (expr
), type
);
9567 expr
= error_mark_node
;
9569 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
9571 /* In a template, we are only concerned about determining the
9572 type of non-dependent expressions, so we do not have to
9573 perform the actual conversion. But for initializers, we
9574 need to be able to perform it at instantiation
9575 (or instantiate_non_dependent_expr) time. */
9576 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
9577 if (!(flags
& LOOKUP_ONLYCONVERTING
))
9578 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
9581 expr
= convert_like (conv
, expr
, complain
);
9583 /* Free all the conversions we allocated. */
9584 obstack_free (&conversion_obstack
, p
);
9590 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
9592 return perform_implicit_conversion_flags (type
, expr
, complain
,
9596 /* Convert EXPR to TYPE (as a direct-initialization) if that is
9597 permitted. If the conversion is valid, the converted expression is
9598 returned. Otherwise, NULL_TREE is returned, except in the case
9599 that TYPE is a class type; in that case, an error is issued. If
9600 C_CAST_P is true, then this direct-initialization is taking
9601 place as part of a static_cast being attempted as part of a C-style
9605 perform_direct_initialization_if_possible (tree type
,
9608 tsubst_flags_t complain
)
9613 if (type
== error_mark_node
|| error_operand_p (expr
))
9614 return error_mark_node
;
9617 If the destination type is a (possibly cv-qualified) class type:
9619 -- If the initialization is direct-initialization ...,
9620 constructors are considered. ... If no constructor applies, or
9621 the overload resolution is ambiguous, the initialization is
9623 if (CLASS_TYPE_P (type
))
9625 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
9626 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
9627 &args
, type
, LOOKUP_NORMAL
, complain
);
9628 release_tree_vector (args
);
9629 return build_cplus_new (type
, expr
, complain
);
9632 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9633 p
= conversion_obstack_alloc (0);
9635 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9637 LOOKUP_NORMAL
, complain
);
9638 if (!conv
|| conv
->bad_p
)
9641 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
9642 /*issue_conversion_warnings=*/false,
9646 /* Free all the conversions we allocated. */
9647 obstack_free (&conversion_obstack
, p
);
9652 /* When initializing a reference that lasts longer than a full-expression,
9653 this special rule applies:
9657 The temporary to which the reference is bound or the temporary
9658 that is the complete object to which the reference is bound
9659 persists for the lifetime of the reference.
9661 The temporaries created during the evaluation of the expression
9662 initializing the reference, except the temporary to which the
9663 reference is bound, are destroyed at the end of the
9664 full-expression in which they are created.
9666 In that case, we store the converted expression into a new
9667 VAR_DECL in a new scope.
9669 However, we want to be careful not to create temporaries when
9670 they are not required. For example, given:
9673 struct D : public B {};
9677 there is no need to copy the return value from "f"; we can just
9678 extend its lifetime. Similarly, given:
9681 struct T { operator S(); };
9685 we can extend the lifetime of the return value of the conversion
9688 The next several functions are involved in this lifetime extension. */
9690 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9691 reference is being bound to a temporary. Create and return a new
9692 VAR_DECL with the indicated TYPE; this variable will store the value to
9693 which the reference is bound. */
9696 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
9700 /* Create the variable. */
9701 var
= create_temporary_var (type
);
9703 /* Register the variable. */
9705 && (TREE_STATIC (decl
) || CP_DECL_THREAD_LOCAL_P (decl
)))
9707 /* Namespace-scope or local static; give it a mangled name. */
9708 /* FIXME share comdat with decl? */
9711 TREE_STATIC (var
) = TREE_STATIC (decl
);
9712 CP_DECL_THREAD_LOCAL_P (var
) = CP_DECL_THREAD_LOCAL_P (decl
);
9713 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
9714 name
= mangle_ref_init_variable (decl
);
9715 DECL_NAME (var
) = name
;
9716 SET_DECL_ASSEMBLER_NAME (var
, name
);
9717 var
= pushdecl_top_level (var
);
9720 /* Create a new cleanup level if necessary. */
9721 maybe_push_cleanup_level (type
);
9726 /* EXPR is the initializer for a variable DECL of reference or
9727 std::initializer_list type. Create, push and return a new VAR_DECL
9728 for the initializer so that it will live as long as DECL. Any
9729 cleanup for the new variable is returned through CLEANUP, and the
9730 code to initialize the new variable is returned through INITP. */
9733 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
9740 /* Create the temporary variable. */
9741 type
= TREE_TYPE (expr
);
9742 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
9743 layout_decl (var
, 0);
9744 /* If the rvalue is the result of a function call it will be
9745 a TARGET_EXPR. If it is some other construct (such as a
9746 member access expression where the underlying object is
9747 itself the result of a function call), turn it into a
9748 TARGET_EXPR here. It is important that EXPR be a
9749 TARGET_EXPR below since otherwise the INIT_EXPR will
9750 attempt to make a bitwise copy of EXPR to initialize
9752 if (TREE_CODE (expr
) != TARGET_EXPR
)
9753 expr
= get_target_expr (expr
);
9755 if (TREE_CODE (decl
) == FIELD_DECL
9756 && extra_warnings
&& !TREE_NO_WARNING (decl
))
9758 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
9759 "until the constructor exits", decl
);
9760 TREE_NO_WARNING (decl
) = true;
9763 /* Recursively extend temps in this initializer. */
9764 TARGET_EXPR_INITIAL (expr
)
9765 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
9767 /* Any reference temp has a non-trivial initializer. */
9768 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
9770 /* If the initializer is constant, put it in DECL_INITIAL so we get
9771 static initialization and use in constant expressions. */
9772 init
= maybe_constant_init (expr
);
9773 if (TREE_CONSTANT (init
))
9775 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
9777 /* 5.19 says that a constant expression can include an
9778 lvalue-rvalue conversion applied to "a glvalue of literal type
9779 that refers to a non-volatile temporary object initialized
9780 with a constant expression". Rather than try to communicate
9781 that this VAR_DECL is a temporary, just mark it constexpr.
9783 Currently this is only useful for initializer_list temporaries,
9784 since reference vars can't appear in constant expressions. */
9785 DECL_DECLARED_CONSTEXPR_P (var
) = true;
9786 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
9787 TREE_CONSTANT (var
) = true;
9789 DECL_INITIAL (var
) = init
;
9793 /* Create the INIT_EXPR that will initialize the temporary
9795 init
= split_nonconstant_init (var
, expr
);
9796 if (at_function_scope_p ())
9798 add_decl_expr (var
);
9800 if (TREE_STATIC (var
))
9801 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
9804 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9806 vec_safe_push (*cleanups
, cleanup
);
9809 /* We must be careful to destroy the temporary only
9810 after its initialization has taken place. If the
9811 initialization throws an exception, then the
9812 destructor should not be run. We cannot simply
9813 transform INIT into something like:
9815 (INIT, ({ CLEANUP_STMT; }))
9817 because emit_local_var always treats the
9818 initializer as a full-expression. Thus, the
9819 destructor would run too early; it would run at the
9820 end of initializing the reference variable, rather
9821 than at the end of the block enclosing the
9824 The solution is to pass back a cleanup expression
9825 which the caller is responsible for attaching to
9826 the statement tree. */
9830 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
9831 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9833 if (CP_DECL_THREAD_LOCAL_P (var
))
9834 tls_aggregates
= tree_cons (NULL_TREE
, var
,
9837 static_aggregates
= tree_cons (NULL_TREE
, var
,
9841 /* Check whether the dtor is callable. */
9842 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9844 /* Avoid -Wunused-variable warning (c++/38958). */
9845 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
9847 TREE_USED (decl
) = DECL_READ_P (decl
) = true;
9853 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9854 initializing a variable of that TYPE. */
9857 initialize_reference (tree type
, tree expr
,
9858 int flags
, tsubst_flags_t complain
)
9862 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9864 if (type
== error_mark_node
|| error_operand_p (expr
))
9865 return error_mark_node
;
9867 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9868 p
= conversion_obstack_alloc (0);
9870 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
9872 if (!conv
|| conv
->bad_p
)
9874 if (complain
& tf_error
)
9877 convert_like (conv
, expr
, complain
);
9878 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
9879 && !TYPE_REF_IS_RVALUE (type
)
9880 && !real_lvalue_p (expr
))
9881 error_at (loc
, "invalid initialization of non-const reference of "
9882 "type %qT from an rvalue of type %qT",
9883 type
, TREE_TYPE (expr
));
9885 error_at (loc
, "invalid initialization of reference of type "
9886 "%qT from expression of type %qT", type
,
9889 return error_mark_node
;
9892 if (conv
->kind
== ck_ref_bind
)
9893 /* Perform the conversion. */
9894 expr
= convert_like (conv
, expr
, complain
);
9895 else if (conv
->kind
== ck_ambig
)
9896 /* We gave an error in build_user_type_conversion_1. */
9897 expr
= error_mark_node
;
9901 /* Free all the conversions we allocated. */
9902 obstack_free (&conversion_obstack
, p
);
9907 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9908 which is bound either to a reference or a std::initializer_list. */
9911 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9916 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
9918 TREE_OPERAND (sub
, 1)
9919 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
9922 if (TREE_CODE (sub
) != ADDR_EXPR
)
9924 /* Deal with binding to a subobject. */
9925 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
9926 p
= &TREE_OPERAND (*p
, 0);
9927 if (TREE_CODE (*p
) == TARGET_EXPR
)
9929 tree subinit
= NULL_TREE
;
9930 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
9931 recompute_tree_invariant_for_addr_expr (sub
);
9933 init
= fold_convert (TREE_TYPE (init
), sub
);
9935 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
9940 /* INIT is part of the initializer for DECL. If there are any
9941 reference or initializer lists being initialized, extend their
9942 lifetime to match that of DECL. */
9945 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9947 tree type
= TREE_TYPE (init
);
9948 if (processing_template_decl
)
9950 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9951 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
9952 else if (is_std_init_list (type
))
9954 /* The temporary array underlying a std::initializer_list
9955 is handled like a reference temporary. */
9957 if (TREE_CODE (ctor
) == TARGET_EXPR
)
9958 ctor
= TARGET_EXPR_INITIAL (ctor
);
9959 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
9961 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
9962 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
9963 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
9966 else if (TREE_CODE (init
) == CONSTRUCTOR
)
9970 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
9971 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
9972 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
9978 /* Returns true iff an initializer for TYPE could contain temporaries that
9979 need to be extended because they are bound to references or
9980 std::initializer_list. */
9983 type_has_extended_temps (tree type
)
9985 type
= strip_array_types (type
);
9986 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9988 if (CLASS_TYPE_P (type
))
9990 if (is_std_init_list (type
))
9992 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
9993 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
9994 if (type_has_extended_temps (TREE_TYPE (f
)))
10000 /* Returns true iff TYPE is some variant of std::initializer_list. */
10003 is_std_init_list (tree type
)
10005 /* Look through typedefs. */
10006 if (!TYPE_P (type
))
10008 if (cxx_dialect
== cxx98
)
10010 type
= TYPE_MAIN_VARIANT (type
);
10011 return (CLASS_TYPE_P (type
)
10012 && CP_TYPE_CONTEXT (type
) == std_node
10013 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
10016 /* Returns true iff DECL is a list constructor: i.e. a constructor which
10017 will accept an argument list of a single std::initializer_list<T>. */
10020 is_list_ctor (tree decl
)
10022 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
10025 if (!args
|| args
== void_list_node
)
10028 arg
= non_reference (TREE_VALUE (args
));
10029 if (!is_std_init_list (arg
))
10032 args
= TREE_CHAIN (args
);
10034 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
10035 /* There are more non-defaulted parms. */
10041 #include "gt-cp-call.h"