1 /* Functions related to invoking -*- C++ -*- methods and overloaded functions.
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 modified by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
31 #include "stringpool.h"
33 #include "stor-layout.h"
34 #include "trans-mem.h"
39 #include "langhooks.h"
40 #include "c-family/c-objc.h"
41 #include "internal-fn.h"
43 /* The various kinds of conversion. */
45 enum conversion_kind
{
62 /* The rank of the conversion. Order of the enumerals matters; better
63 conversions should come earlier in the list. */
65 enum conversion_rank
{
76 /* An implicit conversion sequence, in the sense of [over.best.ics].
77 The first conversion to be performed is at the end of the chain.
78 That conversion is always a cr_identity conversion. */
81 /* The kind of conversion represented by this step. */
83 /* The rank of this conversion. */
85 BOOL_BITFIELD user_conv_p
: 1;
86 BOOL_BITFIELD ellipsis_p
: 1;
87 BOOL_BITFIELD this_p
: 1;
88 /* True if this conversion would be permitted with a bending of
89 language standards, e.g. disregarding pointer qualifiers or
90 converting integers to pointers. */
91 BOOL_BITFIELD bad_p
: 1;
92 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
93 temporary should be created to hold the result of the
95 BOOL_BITFIELD need_temporary_p
: 1;
96 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
97 from a pointer-to-derived to pointer-to-base is being performed. */
98 BOOL_BITFIELD base_p
: 1;
99 /* If KIND is ck_ref_bind, true when either an lvalue reference is
100 being bound to an lvalue expression or an rvalue reference is
101 being bound to an rvalue expression. If KIND is ck_rvalue,
102 true when we should treat an lvalue as an rvalue (12.8p33). If
103 KIND is ck_base, always false. */
104 BOOL_BITFIELD rvaluedness_matches_p
: 1;
105 BOOL_BITFIELD check_narrowing
: 1;
106 /* The type of the expression resulting from the conversion. */
109 /* The next conversion in the chain. Since the conversions are
110 arranged from outermost to innermost, the NEXT conversion will
111 actually be performed before this conversion. This variant is
112 used only when KIND is neither ck_identity, ck_ambig nor
113 ck_list. Please use the next_conversion function instead
114 of using this field directly. */
116 /* The expression at the beginning of the conversion chain. This
117 variant is used only if KIND is ck_identity or ck_ambig. */
119 /* The array of conversions for an initializer_list, so this
120 variant is used only when KIN D is ck_list. */
123 /* The function candidate corresponding to this conversion
124 sequence. This field is only used if KIND is ck_user. */
125 struct z_candidate
*cand
;
128 #define CONVERSION_RANK(NODE) \
129 ((NODE)->bad_p ? cr_bad \
130 : (NODE)->ellipsis_p ? cr_ellipsis \
131 : (NODE)->user_conv_p ? cr_user \
134 #define BAD_CONVERSION_RANK(NODE) \
135 ((NODE)->ellipsis_p ? cr_ellipsis \
136 : (NODE)->user_conv_p ? cr_user \
139 static struct obstack conversion_obstack
;
140 static bool conversion_obstack_initialized
;
141 struct rejection_reason
;
143 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
144 static int equal_functions (tree
, tree
);
145 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
147 static int compare_ics (conversion
*, conversion
*);
148 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
149 static tree
build_java_interface_fn_ref (tree
, tree
);
150 #define convert_like(CONV, EXPR, COMPLAIN) \
151 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
152 /*issue_conversion_warnings=*/true, \
153 /*c_cast_p=*/false, (COMPLAIN))
154 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
155 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
156 /*issue_conversion_warnings=*/true, \
157 /*c_cast_p=*/false, (COMPLAIN))
158 static tree
convert_like_real (conversion
*, tree
, tree
, int, int, bool,
159 bool, tsubst_flags_t
);
160 static void op_error (location_t
, enum tree_code
, enum tree_code
, tree
,
162 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
164 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
165 static void print_z_candidates (location_t
, struct z_candidate
*);
166 static tree
build_this (tree
);
167 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
168 static bool any_strictly_viable (struct z_candidate
*);
169 static struct z_candidate
*add_template_candidate
170 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
171 tree
, tree
, tree
, int, unification_kind_t
, tsubst_flags_t
);
172 static struct z_candidate
*add_template_candidate_real
173 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
174 tree
, tree
, tree
, int, tree
, unification_kind_t
, tsubst_flags_t
);
175 static void add_builtin_candidates
176 (struct z_candidate
**, enum tree_code
, enum tree_code
,
177 tree
, tree
*, int, tsubst_flags_t
);
178 static void add_builtin_candidate
179 (struct z_candidate
**, enum tree_code
, enum tree_code
,
180 tree
, tree
, tree
, tree
*, tree
*, int, tsubst_flags_t
);
181 static bool is_complete (tree
);
182 static void build_builtin_candidate
183 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
184 int, tsubst_flags_t
);
185 static struct z_candidate
*add_conv_candidate
186 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
187 tree
, tsubst_flags_t
);
188 static struct z_candidate
*add_function_candidate
189 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
190 tree
, int, tsubst_flags_t
);
191 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
193 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
195 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
196 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
197 static conversion
*next_conversion (conversion
*);
198 static bool is_subseq (conversion
*, conversion
*);
199 static conversion
*maybe_handle_ref_bind (conversion
**);
200 static void maybe_handle_implicit_object (conversion
**);
201 static struct z_candidate
*add_candidate
202 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
203 conversion
**, tree
, tree
, int, struct rejection_reason
*, int);
204 static tree
source_type (conversion
*);
205 static void add_warning (struct z_candidate
*, struct z_candidate
*);
206 static bool reference_compatible_p (tree
, tree
);
207 static conversion
*direct_reference_binding (tree
, conversion
*);
208 static bool promoted_arithmetic_type_p (tree
);
209 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
210 static char *name_as_c_string (tree
, tree
, bool *);
211 static tree
prep_operand (tree
);
212 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
213 bool, tree
, tree
, int, struct z_candidate
**,
215 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
216 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
218 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
219 NAME can take many forms... */
222 check_dtor_name (tree basetype
, tree name
)
224 /* Just accept something we've already complained about. */
225 if (name
== error_mark_node
)
228 if (TREE_CODE (name
) == TYPE_DECL
)
229 name
= TREE_TYPE (name
);
230 else if (TYPE_P (name
))
232 else if (identifier_p (name
))
234 if ((MAYBE_CLASS_TYPE_P (basetype
)
235 && name
== constructor_name (basetype
))
236 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
237 && name
== TYPE_IDENTIFIER (basetype
)))
240 name
= get_type_value (name
);
246 template <class T> struct S { ~S(); };
250 NAME will be a class template. */
251 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
255 if (!name
|| name
== error_mark_node
)
257 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
260 /* We want the address of a function or method. We avoid creating a
261 pointer-to-member function. */
264 build_addr_func (tree function
, tsubst_flags_t complain
)
266 tree type
= TREE_TYPE (function
);
268 /* We have to do these by hand to avoid real pointer to member
270 if (TREE_CODE (type
) == METHOD_TYPE
)
272 if (TREE_CODE (function
) == OFFSET_REF
)
274 tree object
= build_address (TREE_OPERAND (function
, 0));
275 return get_member_function_from_ptrfunc (&object
,
276 TREE_OPERAND (function
, 1),
279 function
= build_address (function
);
282 function
= decay_conversion (function
, complain
, /*reject_builtin=*/false);
287 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
288 POINTER_TYPE to those. Note, pointer to member function types
289 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
290 two variants. build_call_a is the primitive taking an array of
291 arguments, while build_call_n is a wrapper that handles varargs. */
294 build_call_n (tree function
, int n
, ...)
297 return build_call_a (function
, 0, NULL
);
300 tree
*argarray
= XALLOCAVEC (tree
, n
);
305 for (i
= 0; i
< n
; i
++)
306 argarray
[i
] = va_arg (ap
, tree
);
308 return build_call_a (function
, n
, argarray
);
312 /* Update various flags in cfun and the call itself based on what is being
313 called. Split out of build_call_a so that bot_manip can use it too. */
316 set_flags_from_callee (tree call
)
319 tree decl
= get_callee_fndecl (call
);
321 /* We check both the decl and the type; a function may be known not to
322 throw without being declared throw(). */
323 nothrow
= decl
&& TREE_NOTHROW (decl
);
324 if (CALL_EXPR_FN (call
))
325 nothrow
|= TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call
))));
326 else if (internal_fn_flags (CALL_EXPR_IFN (call
)) & ECF_NOTHROW
)
329 if (!nothrow
&& at_function_scope_p () && cfun
&& cp_function_chain
)
330 cp_function_chain
->can_throw
= 1;
332 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
&& cp_function_chain
)
333 current_function_returns_abnormally
= 1;
335 TREE_NOTHROW (call
) = nothrow
;
339 build_call_a (tree function
, int n
, tree
*argarray
)
346 function
= build_addr_func (function
, tf_warning_or_error
);
348 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
349 fntype
= TREE_TYPE (TREE_TYPE (function
));
350 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
351 || TREE_CODE (fntype
) == METHOD_TYPE
);
352 result_type
= TREE_TYPE (fntype
);
353 /* An rvalue has no cv-qualifiers. */
354 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
355 result_type
= cv_unqualified (result_type
);
357 function
= build_call_array_loc (input_location
,
358 result_type
, function
, n
, argarray
);
359 set_flags_from_callee (function
);
361 decl
= get_callee_fndecl (function
);
363 if (decl
&& !TREE_USED (decl
))
365 /* We invoke build_call directly for several library
366 functions. These may have been declared normally if
367 we're building libgcc, so we can't just check
369 gcc_assert (DECL_ARTIFICIAL (decl
)
370 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
375 require_complete_eh_spec_types (fntype
, decl
);
377 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
379 /* Don't pass empty class objects by value. This is useful
380 for tags in STL, which are used to control overload resolution.
381 We don't need to handle other cases of copying empty classes. */
382 if (! decl
|| ! DECL_BUILT_IN (decl
))
383 for (i
= 0; i
< n
; i
++)
385 tree arg
= CALL_EXPR_ARG (function
, i
);
386 if (is_empty_class (TREE_TYPE (arg
))
387 && ! TREE_ADDRESSABLE (TREE_TYPE (arg
)))
389 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (arg
));
390 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (t
), arg
, t
);
391 CALL_EXPR_ARG (function
, i
) = arg
;
398 /* New overloading code. */
402 struct candidate_warning
{
404 candidate_warning
*next
;
407 /* Information for providing diagnostics about why overloading failed. */
409 enum rejection_reason_code
{
412 rr_explicit_conversion
,
413 rr_template_conversion
,
415 rr_bad_arg_conversion
,
416 rr_template_unification
,
418 rr_constraint_failure
421 struct conversion_info
{
422 /* The index of the argument, 0-based. */
424 /* The actual argument or its type. */
426 /* The type of the parameter. */
430 struct rejection_reason
{
431 enum rejection_reason_code code
;
433 /* Information about an arity mismatch. */
435 /* The expected number of arguments. */
437 /* The actual number of arguments in the call. */
439 /* Whether the call was a varargs call. */
442 /* Information about an argument conversion mismatch. */
443 struct conversion_info conversion
;
444 /* Same, but for bad argument conversions. */
445 struct conversion_info bad_conversion
;
446 /* Information about template unification failures. These are the
447 parameters passed to fn_type_unification. */
455 unification_kind_t strict
;
457 } template_unification
;
458 /* Information about template instantiation failures. These are the
459 parameters passed to instantiate_template. */
463 } template_instantiation
;
468 /* The FUNCTION_DECL that will be called if this candidate is
469 selected by overload resolution. */
471 /* If not NULL_TREE, the first argument to use when calling this
474 /* The rest of the arguments to use when calling this function. If
475 there are no further arguments this may be NULL or it may be an
477 const vec
<tree
, va_gc
> *args
;
478 /* The implicit conversion sequences for each of the arguments to
481 /* The number of implicit conversion sequences. */
483 /* If FN is a user-defined conversion, the standard conversion
484 sequence from the type returned by FN to the desired destination
486 conversion
*second_conv
;
487 struct rejection_reason
*reason
;
488 /* If FN is a member function, the binfo indicating the path used to
489 qualify the name of FN at the call site. This path is used to
490 determine whether or not FN is accessible if it is selected by
491 overload resolution. The DECL_CONTEXT of FN will always be a
492 (possibly improper) base of this binfo. */
494 /* If FN is a non-static member function, the binfo indicating the
495 subobject to which the `this' pointer should be converted if FN
496 is selected by overload resolution. The type pointed to by
497 the `this' pointer must correspond to the most derived class
498 indicated by the CONVERSION_PATH. */
499 tree conversion_path
;
502 candidate_warning
*warnings
;
506 /* The flags active in add_candidate. */
510 /* Returns true iff T is a null pointer constant in the sense of
514 null_ptr_cst_p (tree t
)
516 tree type
= TREE_TYPE (t
);
520 A null pointer constant is an integral constant expression
521 (_expr.const_) rvalue of integer type that evaluates to zero or
522 an rvalue of type std::nullptr_t. */
523 if (NULLPTR_TYPE_P (type
))
526 if (cxx_dialect
>= cxx11
)
528 /* Core issue 903 says only literal 0 is a null pointer constant. */
529 if (TREE_CODE (type
) == INTEGER_TYPE
530 && TREE_CODE (t
) == INTEGER_CST
532 && !TREE_OVERFLOW (t
))
535 else if (CP_INTEGRAL_TYPE_P (type
))
537 t
= fold_non_dependent_expr (t
);
539 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
546 /* Returns true iff T is a null member pointer value (4.11). */
549 null_member_pointer_value_p (tree t
)
551 tree type
= TREE_TYPE (t
);
554 else if (TYPE_PTRMEMFUNC_P (type
))
555 return (TREE_CODE (t
) == CONSTRUCTOR
556 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
557 else if (TYPE_PTRDATAMEM_P (type
))
558 return integer_all_onesp (t
);
563 /* Returns nonzero if PARMLIST consists of only default parms,
564 ellipsis, and/or undeduced parameter packs. */
567 sufficient_parms_p (const_tree parmlist
)
569 for (; parmlist
&& parmlist
!= void_list_node
;
570 parmlist
= TREE_CHAIN (parmlist
))
571 if (!TREE_PURPOSE (parmlist
)
572 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
577 /* Allocate N bytes of memory from the conversion obstack. The memory
578 is zeroed before being returned. */
581 conversion_obstack_alloc (size_t n
)
584 if (!conversion_obstack_initialized
)
586 gcc_obstack_init (&conversion_obstack
);
587 conversion_obstack_initialized
= true;
589 p
= obstack_alloc (&conversion_obstack
, n
);
594 /* Allocate rejection reasons. */
596 static struct rejection_reason
*
597 alloc_rejection (enum rejection_reason_code code
)
599 struct rejection_reason
*p
;
600 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
605 static struct rejection_reason
*
606 arity_rejection (tree first_arg
, int expected
, int actual
)
608 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
609 int adjust
= first_arg
!= NULL_TREE
;
610 r
->u
.arity
.expected
= expected
- adjust
;
611 r
->u
.arity
.actual
= actual
- adjust
;
615 static struct rejection_reason
*
616 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
618 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
619 int adjust
= first_arg
!= NULL_TREE
;
620 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
621 r
->u
.conversion
.from
= from
;
622 r
->u
.conversion
.to_type
= to
;
626 static struct rejection_reason
*
627 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
629 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
630 int adjust
= first_arg
!= NULL_TREE
;
631 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
632 r
->u
.bad_conversion
.from
= from
;
633 r
->u
.bad_conversion
.to_type
= to
;
637 static struct rejection_reason
*
638 explicit_conversion_rejection (tree from
, tree to
)
640 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
641 r
->u
.conversion
.n_arg
= 0;
642 r
->u
.conversion
.from
= from
;
643 r
->u
.conversion
.to_type
= to
;
647 static struct rejection_reason
*
648 template_conversion_rejection (tree from
, tree to
)
650 struct rejection_reason
*r
= alloc_rejection (rr_template_conversion
);
651 r
->u
.conversion
.n_arg
= 0;
652 r
->u
.conversion
.from
= from
;
653 r
->u
.conversion
.to_type
= to
;
657 static struct rejection_reason
*
658 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
659 const tree
*args
, unsigned int nargs
,
660 tree return_type
, unification_kind_t strict
,
663 size_t args_n_bytes
= sizeof (*args
) * nargs
;
664 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
665 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
666 r
->u
.template_unification
.tmpl
= tmpl
;
667 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
668 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
669 /* Copy args to our own storage. */
670 memcpy (args1
, args
, args_n_bytes
);
671 r
->u
.template_unification
.args
= args1
;
672 r
->u
.template_unification
.nargs
= nargs
;
673 r
->u
.template_unification
.return_type
= return_type
;
674 r
->u
.template_unification
.strict
= strict
;
675 r
->u
.template_unification
.flags
= flags
;
679 static struct rejection_reason
*
680 template_unification_error_rejection (void)
682 return alloc_rejection (rr_template_unification
);
685 static struct rejection_reason
*
686 invalid_copy_with_fn_template_rejection (void)
688 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
692 // Build a constraint failure record, saving information into the
693 // template_instantiation field of the rejection. If FN is not a template
694 // declaration, the TMPL member is the FN declaration and TARGS is empty.
696 static struct rejection_reason
*
697 constraint_failure (tree fn
)
699 struct rejection_reason
*r
= alloc_rejection (rr_constraint_failure
);
700 if (tree ti
= DECL_TEMPLATE_INFO (fn
))
702 r
->u
.template_instantiation
.tmpl
= TI_TEMPLATE (ti
);
703 r
->u
.template_instantiation
.targs
= TI_ARGS (ti
);
707 r
->u
.template_instantiation
.tmpl
= fn
;
708 r
->u
.template_instantiation
.targs
= NULL_TREE
;
713 /* Dynamically allocate a conversion. */
716 alloc_conversion (conversion_kind kind
)
719 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
724 /* Make sure that all memory on the conversion obstack has been
728 validate_conversion_obstack (void)
730 if (conversion_obstack_initialized
)
731 gcc_assert ((obstack_next_free (&conversion_obstack
)
732 == obstack_base (&conversion_obstack
)));
735 /* Dynamically allocate an array of N conversions. */
738 alloc_conversions (size_t n
)
740 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
744 build_conv (conversion_kind code
, tree type
, conversion
*from
)
747 conversion_rank rank
= CONVERSION_RANK (from
);
749 /* Note that the caller is responsible for filling in t->cand for
750 user-defined conversions. */
751 t
= alloc_conversion (code
);
774 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
775 t
->bad_p
= from
->bad_p
;
780 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
781 specialization of std::initializer_list<T>, if such a conversion is
785 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
787 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
788 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
789 conversion
**subconvs
= alloc_conversions (len
);
794 /* Within a list-initialization we can have more user-defined
796 flags
&= ~LOOKUP_NO_CONVERSION
;
797 /* But no narrowing conversions. */
798 flags
|= LOOKUP_NO_NARROWING
;
800 /* Can't make an array of these types. */
801 if (TREE_CODE (elttype
) == REFERENCE_TYPE
802 || TREE_CODE (elttype
) == FUNCTION_TYPE
803 || VOID_TYPE_P (elttype
))
806 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
809 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
810 false, flags
, complain
);
817 t
= alloc_conversion (ck_list
);
819 t
->u
.list
= subconvs
;
822 for (i
= 0; i
< len
; ++i
)
824 conversion
*sub
= subconvs
[i
];
825 if (sub
->rank
> t
->rank
)
827 if (sub
->user_conv_p
)
828 t
->user_conv_p
= true;
836 /* Return the next conversion of the conversion chain (if applicable),
837 or NULL otherwise. Please use this function instead of directly
838 accessing fields of struct conversion. */
841 next_conversion (conversion
*conv
)
844 || conv
->kind
== ck_identity
845 || conv
->kind
== ck_ambig
846 || conv
->kind
== ck_list
)
851 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
852 is a valid aggregate initializer for array type ATYPE. */
855 can_convert_array (tree atype
, tree ctor
, int flags
, tsubst_flags_t complain
)
858 tree elttype
= TREE_TYPE (atype
);
859 for (i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
861 tree val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
863 if (TREE_CODE (elttype
) == ARRAY_TYPE
864 && TREE_CODE (val
) == CONSTRUCTOR
)
865 ok
= can_convert_array (elttype
, val
, flags
, complain
);
867 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
875 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
876 aggregate class, if such a conversion is possible. */
879 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
881 unsigned HOST_WIDE_INT i
= 0;
883 tree field
= next_initializable_field (TYPE_FIELDS (type
));
884 tree empty_ctor
= NULL_TREE
;
886 /* We already called reshape_init in implicit_conversion. */
888 /* The conversions within the init-list aren't affected by the enclosing
889 context; they're always simple copy-initialization. */
890 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
892 for (; field
; field
= next_initializable_field (DECL_CHAIN (field
)))
894 tree ftype
= TREE_TYPE (field
);
898 if (i
< CONSTRUCTOR_NELTS (ctor
))
899 val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
900 else if (DECL_INITIAL (field
))
901 val
= get_nsdmi (field
, /*ctor*/false);
902 else if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
903 /* Value-initialization of reference is ill-formed. */
907 if (empty_ctor
== NULL_TREE
)
908 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
913 if (TREE_CODE (ftype
) == ARRAY_TYPE
914 && TREE_CODE (val
) == CONSTRUCTOR
)
915 ok
= can_convert_array (ftype
, val
, flags
, complain
);
917 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
923 if (TREE_CODE (type
) == UNION_TYPE
)
927 if (i
< CONSTRUCTOR_NELTS (ctor
))
930 c
= alloc_conversion (ck_aggr
);
933 c
->user_conv_p
= true;
934 c
->check_narrowing
= true;
939 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
940 array type, if such a conversion is possible. */
943 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
946 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
947 tree elttype
= TREE_TYPE (type
);
952 enum conversion_rank rank
= cr_exact
;
954 /* We might need to propagate the size from the element to the array. */
955 complete_type (type
);
957 if (TYPE_DOMAIN (type
)
958 && !variably_modified_type_p (TYPE_DOMAIN (type
), NULL_TREE
))
960 unsigned HOST_WIDE_INT alen
= tree_to_uhwi (array_type_nelts_top (type
));
965 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
967 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
970 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
971 false, flags
, complain
);
975 if (sub
->rank
> rank
)
977 if (sub
->user_conv_p
)
983 c
= alloc_conversion (ck_aggr
);
986 c
->user_conv_p
= user
;
992 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
993 complex type, if such a conversion is possible. */
996 build_complex_conv (tree type
, tree ctor
, int flags
,
997 tsubst_flags_t complain
)
1000 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1001 tree elttype
= TREE_TYPE (type
);
1006 enum conversion_rank rank
= cr_exact
;
1011 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1013 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
1016 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
1017 false, flags
, complain
);
1021 if (sub
->rank
> rank
)
1023 if (sub
->user_conv_p
)
1029 c
= alloc_conversion (ck_aggr
);
1032 c
->user_conv_p
= user
;
1038 /* Build a representation of the identity conversion from EXPR to
1039 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1042 build_identity_conv (tree type
, tree expr
)
1046 c
= alloc_conversion (ck_identity
);
1053 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1054 were multiple user-defined conversions to accomplish the job.
1055 Build a conversion that indicates that ambiguity. */
1058 build_ambiguous_conv (tree type
, tree expr
)
1062 c
= alloc_conversion (ck_ambig
);
1070 strip_top_quals (tree t
)
1072 if (TREE_CODE (t
) == ARRAY_TYPE
)
1074 return cp_build_qualified_type (t
, 0);
1077 /* Returns the standard conversion path (see [conv]) from type FROM to type
1078 TO, if any. For proper handling of null pointer constants, you must
1079 also pass the expression EXPR to convert from. If C_CAST_P is true,
1080 this conversion is coming from a C-style cast. */
1083 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1084 int flags
, tsubst_flags_t complain
)
1086 enum tree_code fcode
, tcode
;
1088 bool fromref
= false;
1091 to
= non_reference (to
);
1092 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1095 from
= TREE_TYPE (from
);
1098 to
= strip_top_quals (to
);
1099 from
= strip_top_quals (from
);
1101 if (expr
&& type_unknown_p (expr
))
1103 if (TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1105 tsubst_flags_t tflags
= tf_conv
;
1106 expr
= instantiate_type (to
, expr
, tflags
);
1107 if (expr
== error_mark_node
)
1109 from
= TREE_TYPE (expr
);
1111 else if (TREE_CODE (to
) == BOOLEAN_TYPE
)
1113 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1114 expr
= resolve_nondeduced_context (expr
, complain
);
1115 from
= TREE_TYPE (expr
);
1119 fcode
= TREE_CODE (from
);
1120 tcode
= TREE_CODE (to
);
1122 conv
= build_identity_conv (from
, expr
);
1123 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1125 from
= type_decays_to (from
);
1126 fcode
= TREE_CODE (from
);
1127 conv
= build_conv (ck_lvalue
, from
, conv
);
1129 else if (fromref
|| (expr
&& lvalue_p (expr
)))
1134 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1137 from
= strip_top_quals (bitfield_type
);
1138 fcode
= TREE_CODE (from
);
1141 conv
= build_conv (ck_rvalue
, from
, conv
);
1142 if (flags
& LOOKUP_PREFER_RVALUE
)
1143 conv
->rvaluedness_matches_p
= true;
1146 /* Allow conversion between `__complex__' data types. */
1147 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1149 /* The standard conversion sequence to convert FROM to TO is
1150 the standard conversion sequence to perform componentwise
1152 conversion
*part_conv
= standard_conversion
1153 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
,
1158 conv
= build_conv (part_conv
->kind
, to
, conv
);
1159 conv
->rank
= part_conv
->rank
;
1167 if (same_type_p (from
, to
))
1169 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1170 conv
->type
= qualified_to
;
1175 A null pointer constant can be converted to a pointer type; ... A
1176 null pointer constant of integral type can be converted to an
1177 rvalue of type std::nullptr_t. */
1178 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1179 || NULLPTR_TYPE_P (to
))
1180 && ((expr
&& null_ptr_cst_p (expr
))
1181 || NULLPTR_TYPE_P (from
)))
1182 conv
= build_conv (ck_std
, to
, conv
);
1183 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1184 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1186 /* For backwards brain damage compatibility, allow interconversion of
1187 pointers and integers with a pedwarn. */
1188 conv
= build_conv (ck_std
, to
, conv
);
1191 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1193 /* For backwards brain damage compatibility, allow interconversion of
1194 enums and integers with a pedwarn. */
1195 conv
= build_conv (ck_std
, to
, conv
);
1198 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1199 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1204 if (tcode
== POINTER_TYPE
1205 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from
),
1208 else if (VOID_TYPE_P (TREE_TYPE (to
))
1209 && !TYPE_PTRDATAMEM_P (from
)
1210 && TREE_CODE (TREE_TYPE (from
)) != FUNCTION_TYPE
)
1212 tree nfrom
= TREE_TYPE (from
);
1213 /* Don't try to apply restrict to void. */
1214 int quals
= cp_type_quals (nfrom
) & ~TYPE_QUAL_RESTRICT
;
1215 from
= build_pointer_type
1216 (cp_build_qualified_type (void_type_node
, quals
));
1217 conv
= build_conv (ck_ptr
, from
, conv
);
1219 else if (TYPE_PTRDATAMEM_P (from
))
1221 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1222 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1224 if (DERIVED_FROM_P (fbase
, tbase
)
1225 && (same_type_ignoring_top_level_qualifiers_p
1226 (TYPE_PTRMEM_POINTED_TO_TYPE (from
),
1227 TYPE_PTRMEM_POINTED_TO_TYPE (to
))))
1229 from
= build_ptrmem_type (tbase
,
1230 TYPE_PTRMEM_POINTED_TO_TYPE (from
));
1231 conv
= build_conv (ck_pmem
, from
, conv
);
1233 else if (!same_type_p (fbase
, tbase
))
1236 else if (CLASS_TYPE_P (TREE_TYPE (from
))
1237 && CLASS_TYPE_P (TREE_TYPE (to
))
1240 An rvalue of type "pointer to cv D," where D is a
1241 class type, can be converted to an rvalue of type
1242 "pointer to cv B," where B is a base class (clause
1243 _class.derived_) of D. If B is an inaccessible
1244 (clause _class.access_) or ambiguous
1245 (_class.member.lookup_) base class of D, a program
1246 that necessitates this conversion is ill-formed.
1247 Therefore, we use DERIVED_FROM_P, and do not check
1248 access or uniqueness. */
1249 && DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
1252 cp_build_qualified_type (TREE_TYPE (to
),
1253 cp_type_quals (TREE_TYPE (from
)));
1254 from
= build_pointer_type (from
);
1255 conv
= build_conv (ck_ptr
, from
, conv
);
1256 conv
->base_p
= true;
1258 else if (tx_safe_fn_type_p (TREE_TYPE (from
)))
1260 /* A prvalue of type "pointer to transaction_safe function" can be
1261 converted to a prvalue of type "pointer to function". */
1262 tree unsafe
= tx_unsafe_fn_variant (TREE_TYPE (from
));
1263 if (same_type_p (unsafe
, TREE_TYPE (to
)))
1265 from
= build_pointer_type (unsafe
);
1266 conv
= build_conv (ck_tsafe
, from
, conv
);
1270 if (tcode
== POINTER_TYPE
)
1272 to_pointee
= TREE_TYPE (to
);
1273 from_pointee
= TREE_TYPE (from
);
1277 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1278 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1281 if (same_type_p (from
, to
))
1283 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
1284 /* In a C-style cast, we ignore CV-qualification because we
1285 are allowed to perform a static_cast followed by a
1287 conv
= build_conv (ck_qual
, to
, conv
);
1288 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1289 conv
= build_conv (ck_qual
, to
, conv
);
1290 else if (expr
&& string_conv_p (to
, expr
, 0))
1291 /* converting from string constant to char *. */
1292 conv
= build_conv (ck_qual
, to
, conv
);
1293 /* Allow conversions among compatible ObjC pointer types (base
1294 conversions have been already handled above). */
1295 else if (c_dialect_objc ()
1296 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1297 conv
= build_conv (ck_ptr
, to
, conv
);
1298 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1300 conv
= build_conv (ck_ptr
, to
, conv
);
1308 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1310 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1311 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1312 tree fbase
= class_of_this_parm (fromfn
);
1313 tree tbase
= class_of_this_parm (tofn
);
1315 if (!DERIVED_FROM_P (fbase
, tbase
)
1316 || !same_type_p (static_fn_type (fromfn
),
1317 static_fn_type (tofn
)))
1320 from
= build_memfn_type (fromfn
,
1322 cp_type_quals (tbase
),
1323 type_memfn_rqual (tofn
));
1324 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1325 conv
= build_conv (ck_pmem
, from
, conv
);
1326 conv
->base_p
= true;
1328 else if (tcode
== BOOLEAN_TYPE
)
1332 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1333 to member type can be converted to a prvalue of type bool. ...
1334 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1335 std::nullptr_t can be converted to a prvalue of type bool; */
1336 if (ARITHMETIC_TYPE_P (from
)
1337 || UNSCOPED_ENUM_P (from
)
1338 || fcode
== POINTER_TYPE
1339 || TYPE_PTRMEM_P (from
)
1340 || NULLPTR_TYPE_P (from
))
1342 conv
= build_conv (ck_std
, to
, conv
);
1343 if (fcode
== POINTER_TYPE
1344 || TYPE_PTRDATAMEM_P (from
)
1345 || (TYPE_PTRMEMFUNC_P (from
)
1346 && conv
->rank
< cr_pbool
)
1347 || NULLPTR_TYPE_P (from
))
1348 conv
->rank
= cr_pbool
;
1349 if (NULLPTR_TYPE_P (from
) && (flags
& LOOKUP_ONLYCONVERTING
))
1356 /* We don't check for ENUMERAL_TYPE here because there are no standard
1357 conversions to enum type. */
1358 /* As an extension, allow conversion to complex type. */
1359 else if (ARITHMETIC_TYPE_P (to
))
1361 if (! (INTEGRAL_CODE_P (fcode
)
1362 || (fcode
== REAL_TYPE
&& !(flags
& LOOKUP_NO_NON_INTEGRAL
)))
1363 || SCOPED_ENUM_P (from
))
1365 conv
= build_conv (ck_std
, to
, conv
);
1367 /* Give this a better rank if it's a promotion. */
1368 if (same_type_p (to
, type_promotes_to (from
))
1369 && next_conversion (conv
)->rank
<= cr_promotion
)
1370 conv
->rank
= cr_promotion
;
1372 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1373 && vector_types_convertible_p (from
, to
, false))
1374 return build_conv (ck_std
, to
, conv
);
1375 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1376 && is_properly_derived_from (from
, to
))
1378 if (conv
->kind
== ck_rvalue
)
1379 conv
= next_conversion (conv
);
1380 conv
= build_conv (ck_base
, to
, conv
);
1381 /* The derived-to-base conversion indicates the initialization
1382 of a parameter with base type from an object of a derived
1383 type. A temporary object is created to hold the result of
1384 the conversion unless we're binding directly to a reference. */
1385 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1390 if (flags
& LOOKUP_NO_NARROWING
)
1391 conv
->check_narrowing
= true;
1396 /* Returns nonzero if T1 is reference-related to T2. */
1399 reference_related_p (tree t1
, tree t2
)
1401 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1404 t1
= TYPE_MAIN_VARIANT (t1
);
1405 t2
= TYPE_MAIN_VARIANT (t2
);
1409 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1410 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1412 return (same_type_p (t1
, t2
)
1413 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1414 && DERIVED_FROM_P (t1
, t2
)));
1417 /* Returns nonzero if T1 is reference-compatible with T2. */
1420 reference_compatible_p (tree t1
, tree t2
)
1424 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1425 reference-related to T2 and cv1 is the same cv-qualification as,
1426 or greater cv-qualification than, cv2. */
1427 return (reference_related_p (t1
, t2
)
1428 && at_least_as_qualified_p (t1
, t2
));
1431 /* A reference of the indicated TYPE is being bound directly to the
1432 expression represented by the implicit conversion sequence CONV.
1433 Return a conversion sequence for this binding. */
1436 direct_reference_binding (tree type
, conversion
*conv
)
1440 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1441 gcc_assert (TREE_CODE (conv
->type
) != REFERENCE_TYPE
);
1443 t
= TREE_TYPE (type
);
1447 When a parameter of reference type binds directly
1448 (_dcl.init.ref_) to an argument expression, the implicit
1449 conversion sequence is the identity conversion, unless the
1450 argument expression has a type that is a derived class of the
1451 parameter type, in which case the implicit conversion sequence is
1452 a derived-to-base Conversion.
1454 If the parameter binds directly to the result of applying a
1455 conversion function to the argument expression, the implicit
1456 conversion sequence is a user-defined conversion sequence
1457 (_over.ics.user_), with the second standard conversion sequence
1458 either an identity conversion or, if the conversion function
1459 returns an entity of a type that is a derived class of the
1460 parameter type, a derived-to-base conversion. */
1461 if (!same_type_ignoring_top_level_qualifiers_p (t
, conv
->type
))
1463 /* Represent the derived-to-base conversion. */
1464 conv
= build_conv (ck_base
, t
, conv
);
1465 /* We will actually be binding to the base-class subobject in
1466 the derived class, so we mark this conversion appropriately.
1467 That way, convert_like knows not to generate a temporary. */
1468 conv
->need_temporary_p
= false;
1470 return build_conv (ck_ref_bind
, type
, conv
);
1473 /* Returns the conversion path from type FROM to reference type TO for
1474 purposes of reference binding. For lvalue binding, either pass a
1475 reference type to FROM or an lvalue expression to EXPR. If the
1476 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1477 the conversion returned. If C_CAST_P is true, this
1478 conversion is coming from a C-style cast. */
1481 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1482 tsubst_flags_t complain
)
1484 conversion
*conv
= NULL
;
1485 tree to
= TREE_TYPE (rto
);
1490 cp_lvalue_kind gl_kind
;
1493 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1495 expr
= instantiate_type (to
, expr
, tf_none
);
1496 if (expr
== error_mark_node
)
1498 from
= TREE_TYPE (expr
);
1501 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1503 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1504 /* DR 1288: Otherwise, if the initializer list has a single element
1505 of type E and ... [T's] referenced type is reference-related to E,
1506 the object or reference is initialized from that element... */
1507 if (CONSTRUCTOR_NELTS (expr
) == 1)
1509 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1510 if (error_operand_p (elt
))
1512 tree etype
= TREE_TYPE (elt
);
1513 if (reference_related_p (to
, etype
))
1520 /* Otherwise, if T is a reference type, a prvalue temporary of the
1521 type referenced by T is copy-list-initialized or
1522 direct-list-initialized, depending on the kind of initialization
1523 for the reference, and the reference is bound to that temporary. */
1524 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1525 flags
|LOOKUP_NO_TEMP_BIND
, complain
);
1529 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1531 from
= TREE_TYPE (from
);
1532 if (!TYPE_REF_IS_RVALUE (rfrom
)
1533 || TREE_CODE (from
) == FUNCTION_TYPE
)
1534 gl_kind
= clk_ordinary
;
1536 gl_kind
= clk_rvalueref
;
1540 gl_kind
= lvalue_kind (expr
);
1541 if (gl_kind
& clk_class
)
1542 /* A class prvalue is not a glvalue. */
1547 is_lvalue
= gl_kind
&& !(gl_kind
& clk_rvalueref
);
1550 if ((gl_kind
& clk_bitfield
) != 0)
1551 tfrom
= unlowered_expr_type (expr
);
1553 /* Figure out whether or not the types are reference-related and
1554 reference compatible. We have to do this after stripping
1555 references from FROM. */
1556 related_p
= reference_related_p (to
, tfrom
);
1557 /* If this is a C cast, first convert to an appropriately qualified
1558 type, so that we can later do a const_cast to the desired type. */
1559 if (related_p
&& c_cast_p
1560 && !at_least_as_qualified_p (to
, tfrom
))
1561 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1562 compatible_p
= reference_compatible_p (to
, tfrom
);
1564 /* Directly bind reference when target expression's type is compatible with
1565 the reference and expression is an lvalue. In DR391, the wording in
1566 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1567 const and rvalue references to rvalues of compatible class type.
1568 We should also do direct bindings for non-class xvalues. */
1571 || (!(flags
& LOOKUP_NO_TEMP_BIND
)
1572 && (CLASS_TYPE_P (from
)
1573 || TREE_CODE (from
) == ARRAY_TYPE
))))
1577 If the initializer expression
1579 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1580 is reference-compatible with "cv2 T2,"
1582 the reference is bound directly to the initializer expression
1586 If the initializer expression is an rvalue, with T2 a class type,
1587 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1588 is bound to the object represented by the rvalue or to a sub-object
1589 within that object. */
1591 conv
= build_identity_conv (tfrom
, expr
);
1592 conv
= direct_reference_binding (rto
, conv
);
1594 if (flags
& LOOKUP_PREFER_RVALUE
)
1595 /* The top-level caller requested that we pretend that the lvalue
1596 be treated as an rvalue. */
1597 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1598 else if (TREE_CODE (rfrom
) == REFERENCE_TYPE
)
1599 /* Handle rvalue reference to function properly. */
1600 conv
->rvaluedness_matches_p
1601 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1603 conv
->rvaluedness_matches_p
1604 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1606 if ((gl_kind
& clk_bitfield
) != 0
1607 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1608 /* For the purposes of overload resolution, we ignore the fact
1609 this expression is a bitfield or packed field. (In particular,
1610 [over.ics.ref] says specifically that a function with a
1611 non-const reference parameter is viable even if the
1612 argument is a bitfield.)
1614 However, when we actually call the function we must create
1615 a temporary to which to bind the reference. If the
1616 reference is volatile, or isn't const, then we cannot make
1617 a temporary, so we just issue an error when the conversion
1619 conv
->need_temporary_p
= true;
1621 /* Don't allow binding of lvalues (other than function lvalues) to
1622 rvalue references. */
1623 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1624 && TREE_CODE (to
) != FUNCTION_TYPE
1625 && !(flags
& LOOKUP_PREFER_RVALUE
))
1628 /* Nor the reverse. */
1629 if (!is_lvalue
&& !TYPE_REF_IS_RVALUE (rto
)
1630 && (!CP_TYPE_CONST_NON_VOLATILE_P (to
)
1631 || (flags
& LOOKUP_NO_RVAL_BIND
))
1632 && TREE_CODE (to
) != FUNCTION_TYPE
)
1640 /* [class.conv.fct] A conversion function is never used to convert a
1641 (possibly cv-qualified) object to the (possibly cv-qualified) same
1642 object type (or a reference to it), to a (possibly cv-qualified) base
1643 class of that type (or a reference to it).... */
1644 else if (CLASS_TYPE_P (from
) && !related_p
1645 && !(flags
& LOOKUP_NO_CONVERSION
))
1649 If the initializer expression
1651 -- has a class type (i.e., T2 is a class type) can be
1652 implicitly converted to an lvalue of type "cv3 T3," where
1653 "cv1 T1" is reference-compatible with "cv3 T3". (this
1654 conversion is selected by enumerating the applicable
1655 conversion functions (_over.match.ref_) and choosing the
1656 best one through overload resolution. (_over.match_).
1658 the reference is bound to the lvalue result of the conversion
1659 in the second case. */
1660 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1663 return cand
->second_conv
;
1666 /* From this point on, we conceptually need temporaries, even if we
1667 elide them. Only the cases above are "direct bindings". */
1668 if (flags
& LOOKUP_NO_TEMP_BIND
)
1673 When a parameter of reference type is not bound directly to an
1674 argument expression, the conversion sequence is the one required
1675 to convert the argument expression to the underlying type of the
1676 reference according to _over.best.ics_. Conceptually, this
1677 conversion sequence corresponds to copy-initializing a temporary
1678 of the underlying type with the argument expression. Any
1679 difference in top-level cv-qualification is subsumed by the
1680 initialization itself and does not constitute a conversion. */
1684 Otherwise, the reference shall be an lvalue reference to a
1685 non-volatile const type, or the reference shall be an rvalue
1688 We try below to treat this as a bad conversion to improve diagnostics,
1689 but if TO is an incomplete class, we need to reject this conversion
1690 now to avoid unnecessary instantiation. */
1691 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
)
1692 && !COMPLETE_TYPE_P (to
))
1695 /* We're generating a temporary now, but don't bind any more in the
1696 conversion (specifically, don't slice the temporary returned by a
1697 conversion operator). */
1698 flags
|= LOOKUP_NO_TEMP_BIND
;
1700 /* Core issue 899: When [copy-]initializing a temporary to be bound
1701 to the first parameter of a copy constructor (12.8) called with
1702 a single argument in the context of direct-initialization,
1703 explicit conversion functions are also considered.
1705 So don't set LOOKUP_ONLYCONVERTING in that case. */
1706 if (!(flags
& LOOKUP_COPY_PARM
))
1707 flags
|= LOOKUP_ONLYCONVERTING
;
1710 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1715 if (conv
->user_conv_p
)
1717 /* If initializing the temporary used a conversion function,
1718 recalculate the second conversion sequence. */
1719 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1720 if (t
->kind
== ck_user
1721 && DECL_CONV_FN_P (t
->cand
->fn
))
1723 tree ftype
= TREE_TYPE (TREE_TYPE (t
->cand
->fn
));
1724 int sflags
= (flags
|LOOKUP_NO_CONVERSION
)&~LOOKUP_NO_TEMP_BIND
;
1725 conversion
*new_second
1726 = reference_binding (rto
, ftype
, NULL_TREE
, c_cast_p
,
1730 return merge_conversion_sequences (t
, new_second
);
1734 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1735 /* This reference binding, unlike those above, requires the
1736 creation of a temporary. */
1737 conv
->need_temporary_p
= true;
1738 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1742 Otherwise, the reference shall be an lvalue reference to a
1743 non-volatile const type, or the reference shall be an rvalue
1745 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1750 Otherwise, a temporary of type "cv1 T1" is created and
1751 initialized from the initializer expression using the rules for a
1752 non-reference copy initialization. If T1 is reference-related to
1753 T2, cv1 must be the same cv-qualification as, or greater
1754 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1755 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1761 /* Returns the implicit conversion sequence (see [over.ics]) from type
1762 FROM to type TO. The optional expression EXPR may affect the
1763 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1764 true, this conversion is coming from a C-style cast. */
1767 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1768 int flags
, tsubst_flags_t complain
)
1772 if (from
== error_mark_node
|| to
== error_mark_node
1773 || expr
== error_mark_node
)
1776 /* Other flags only apply to the primary function in overload
1777 resolution, or after we've chosen one. */
1778 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
1779 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_PREFER_RVALUE
1780 |LOOKUP_NO_NARROWING
|LOOKUP_PROTECT
|LOOKUP_NO_NON_INTEGRAL
);
1782 /* FIXME: actually we don't want warnings either, but we can't just
1783 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1784 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1785 We really ought not to issue that warning until we've committed
1786 to that conversion. */
1787 complain
&= ~tf_error
;
1789 /* Call reshape_init early to remove redundant braces. */
1790 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
)
1791 && CLASS_TYPE_P (to
)
1792 && COMPLETE_TYPE_P (complete_type (to
))
1793 && !CLASSTYPE_NON_AGGREGATE (to
))
1795 expr
= reshape_init (to
, expr
, complain
);
1796 if (expr
== error_mark_node
)
1798 from
= TREE_TYPE (expr
);
1801 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1802 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
1804 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
, complain
);
1809 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1811 if (is_std_init_list (to
))
1812 return build_list_conv (to
, expr
, flags
, complain
);
1814 /* As an extension, allow list-initialization of _Complex. */
1815 if (TREE_CODE (to
) == COMPLEX_TYPE
)
1817 conv
= build_complex_conv (to
, expr
, flags
, complain
);
1822 /* Allow conversion from an initializer-list with one element to a
1824 if (SCALAR_TYPE_P (to
))
1826 int nelts
= CONSTRUCTOR_NELTS (expr
);
1830 elt
= build_value_init (to
, tf_none
);
1831 else if (nelts
== 1)
1832 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1834 elt
= error_mark_node
;
1836 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
1837 c_cast_p
, flags
, complain
);
1840 conv
->check_narrowing
= true;
1841 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
1842 /* Too many levels of braces, i.e. '{{1}}'. */
1847 else if (TREE_CODE (to
) == ARRAY_TYPE
)
1848 return build_array_conv (to
, expr
, flags
, complain
);
1851 if (expr
!= NULL_TREE
1852 && (MAYBE_CLASS_TYPE_P (from
)
1853 || MAYBE_CLASS_TYPE_P (to
))
1854 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1856 struct z_candidate
*cand
;
1858 if (CLASS_TYPE_P (to
)
1859 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
1860 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
1861 return build_aggr_conv (to
, expr
, flags
, complain
);
1863 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
1865 conv
= cand
->second_conv
;
1867 /* We used to try to bind a reference to a temporary here, but that
1868 is now handled after the recursive call to this function at the end
1869 of reference_binding. */
1876 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1877 functions. ARGS will not be changed until a single candidate is
1880 static struct z_candidate
*
1881 add_candidate (struct z_candidate
**candidates
,
1882 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
1883 size_t num_convs
, conversion
**convs
,
1884 tree access_path
, tree conversion_path
,
1885 int viable
, struct rejection_reason
*reason
,
1888 struct z_candidate
*cand
= (struct z_candidate
*)
1889 conversion_obstack_alloc (sizeof (struct z_candidate
));
1892 cand
->first_arg
= first_arg
;
1894 cand
->convs
= convs
;
1895 cand
->num_convs
= num_convs
;
1896 cand
->access_path
= access_path
;
1897 cand
->conversion_path
= conversion_path
;
1898 cand
->viable
= viable
;
1899 cand
->reason
= reason
;
1900 cand
->next
= *candidates
;
1901 cand
->flags
= flags
;
1907 /* Return the number of remaining arguments in the parameter list
1908 beginning with ARG. */
1911 remaining_arguments (tree arg
)
1915 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
1916 arg
= TREE_CHAIN (arg
))
1922 /* Create an overload candidate for the function or method FN called
1923 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1924 FLAGS is passed on to implicit_conversion.
1926 This does not change ARGS.
1928 CTYPE, if non-NULL, is the type we want to pretend this function
1929 comes from for purposes of overload resolution. */
1931 static struct z_candidate
*
1932 add_function_candidate (struct z_candidate
**candidates
,
1933 tree fn
, tree ctype
, tree first_arg
,
1934 const vec
<tree
, va_gc
> *args
, tree access_path
,
1935 tree conversion_path
, int flags
,
1936 tsubst_flags_t complain
)
1938 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1942 tree orig_first_arg
= first_arg
;
1945 struct rejection_reason
*reason
= NULL
;
1947 /* At this point we should not see any functions which haven't been
1948 explicitly declared, except for friend functions which will have
1949 been found using argument dependent lookup. */
1950 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
1952 /* The `this', `in_chrg' and VTT arguments to constructors are not
1953 considered in overload resolution. */
1954 if (DECL_CONSTRUCTOR_P (fn
))
1956 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1957 skip
= num_artificial_parms_for (fn
);
1958 if (skip
> 0 && first_arg
!= NULL_TREE
)
1961 first_arg
= NULL_TREE
;
1967 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
1968 convs
= alloc_conversions (len
);
1970 /* 13.3.2 - Viable functions [over.match.viable]
1971 First, to be a viable function, a candidate function shall have enough
1972 parameters to agree in number with the arguments in the list.
1974 We need to check this first; otherwise, checking the ICSes might cause
1975 us to produce an ill-formed template instantiation. */
1977 parmnode
= parmlist
;
1978 for (i
= 0; i
< len
; ++i
)
1980 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1982 parmnode
= TREE_CHAIN (parmnode
);
1985 if ((i
< len
&& parmnode
)
1986 || !sufficient_parms_p (parmnode
))
1988 int remaining
= remaining_arguments (parmnode
);
1990 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
1993 /* Second, for a function to be viable, its constraints must be
1995 if (flag_concepts
&& viable
1996 && !constraints_satisfied_p (fn
))
1998 reason
= constraint_failure (fn
);
2002 /* When looking for a function from a subobject from an implicit
2003 copy/move constructor/operator=, don't consider anything that takes (a
2004 reference to) an unrelated type. See c++/44909 and core 1092. */
2005 if (viable
&& parmlist
&& (flags
& LOOKUP_DEFAULTED
))
2007 if (DECL_CONSTRUCTOR_P (fn
))
2009 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
2010 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
2016 parmnode
= chain_index (i
-1, parmlist
);
2017 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
2022 /* This only applies at the top level. */
2023 flags
&= ~LOOKUP_DEFAULTED
;
2029 /* Third, for F to be a viable function, there shall exist for each
2030 argument an implicit conversion sequence that converts that argument
2031 to the corresponding parameter of F. */
2033 parmnode
= parmlist
;
2035 for (i
= 0; i
< len
; ++i
)
2037 tree argtype
, to_type
;
2042 if (parmnode
== void_list_node
)
2045 if (i
== 0 && first_arg
!= NULL_TREE
)
2048 arg
= CONST_CAST_TREE (
2049 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
2050 argtype
= lvalue_type (arg
);
2052 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2053 && ! DECL_CONSTRUCTOR_P (fn
));
2057 tree parmtype
= TREE_VALUE (parmnode
);
2060 parmnode
= TREE_CHAIN (parmnode
);
2062 /* The type of the implicit object parameter ('this') for
2063 overload resolution is not always the same as for the
2064 function itself; conversion functions are considered to
2065 be members of the class being converted, and functions
2066 introduced by a using-declaration are considered to be
2067 members of the class that uses them.
2069 Since build_over_call ignores the ICS for the `this'
2070 parameter, we can just change the parm type. */
2071 if (ctype
&& is_this
)
2073 parmtype
= cp_build_qualified_type
2074 (ctype
, cp_type_quals (TREE_TYPE (parmtype
)));
2075 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
2077 /* If the function has a ref-qualifier, the implicit
2078 object parameter has reference type. */
2079 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
2080 parmtype
= cp_build_reference_type (parmtype
, rv
);
2081 /* The special handling of 'this' conversions in compare_ics
2082 does not apply if there is a ref-qualifier. */
2087 parmtype
= build_pointer_type (parmtype
);
2088 arg
= build_this (arg
);
2089 argtype
= lvalue_type (arg
);
2093 /* Core issue 899: When [copy-]initializing a temporary to be bound
2094 to the first parameter of a copy constructor (12.8) called with
2095 a single argument in the context of direct-initialization,
2096 explicit conversion functions are also considered.
2098 So set LOOKUP_COPY_PARM to let reference_binding know that
2099 it's being called in that context. We generalize the above
2100 to handle move constructors and template constructors as well;
2101 the standardese should soon be updated similarly. */
2102 if (ctype
&& i
== 0 && (len
-skip
== 1)
2103 && DECL_CONSTRUCTOR_P (fn
)
2104 && parmtype
!= error_mark_node
2105 && (same_type_ignoring_top_level_qualifiers_p
2106 (non_reference (parmtype
), ctype
)))
2108 if (!(flags
& LOOKUP_ONLYCONVERTING
))
2109 lflags
|= LOOKUP_COPY_PARM
;
2110 /* We allow user-defined conversions within init-lists, but
2111 don't list-initialize the copy parm, as that would mean
2112 using two levels of braces for the same type. */
2113 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
2114 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
2115 lflags
|= LOOKUP_NO_CONVERSION
;
2118 lflags
|= LOOKUP_ONLYCONVERTING
;
2120 t
= implicit_conversion (parmtype
, argtype
, arg
,
2121 /*c_cast_p=*/false, lflags
, complain
);
2126 t
= build_identity_conv (argtype
, arg
);
2127 t
->ellipsis_p
= true;
2138 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
);
2145 reason
= bad_arg_conversion_rejection (first_arg
, i
, arg
, to_type
);
2150 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2151 access_path
, conversion_path
, viable
, reason
, flags
);
2154 /* Create an overload candidate for the conversion function FN which will
2155 be invoked for expression OBJ, producing a pointer-to-function which
2156 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2157 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2158 passed on to implicit_conversion.
2160 Actually, we don't really care about FN; we care about the type it
2161 converts to. There may be multiple conversion functions that will
2162 convert to that type, and we rely on build_user_type_conversion_1 to
2163 choose the best one; so when we create our candidate, we record the type
2164 instead of the function. */
2166 static struct z_candidate
*
2167 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2168 const vec
<tree
, va_gc
> *arglist
,
2169 tree access_path
, tree conversion_path
,
2170 tsubst_flags_t complain
)
2172 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2173 int i
, len
, viable
, flags
;
2174 tree parmlist
, parmnode
;
2176 struct rejection_reason
*reason
;
2178 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2179 parmlist
= TREE_TYPE (parmlist
);
2180 parmlist
= TYPE_ARG_TYPES (parmlist
);
2182 len
= vec_safe_length (arglist
) + 1;
2183 convs
= alloc_conversions (len
);
2184 parmnode
= parmlist
;
2186 flags
= LOOKUP_IMPLICIT
;
2189 /* Don't bother looking up the same type twice. */
2190 if (*candidates
&& (*candidates
)->fn
== totype
)
2193 for (i
= 0; i
< len
; ++i
)
2195 tree arg
, argtype
, convert_type
= NULL_TREE
;
2201 arg
= (*arglist
)[i
- 1];
2202 argtype
= lvalue_type (arg
);
2206 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
2208 convert_type
= totype
;
2210 else if (parmnode
== void_list_node
)
2214 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2215 /*c_cast_p=*/false, flags
, complain
);
2216 convert_type
= TREE_VALUE (parmnode
);
2220 t
= build_identity_conv (argtype
, arg
);
2221 t
->ellipsis_p
= true;
2222 convert_type
= argtype
;
2232 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, arg
, convert_type
);
2239 parmnode
= TREE_CHAIN (parmnode
);
2243 || ! sufficient_parms_p (parmnode
))
2245 int remaining
= remaining_arguments (parmnode
);
2247 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2250 return add_candidate (candidates
, totype
, obj
, arglist
, len
, convs
,
2251 access_path
, conversion_path
, viable
, reason
, flags
);
2255 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2256 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
2257 int flags
, tsubst_flags_t complain
)
2264 struct rejection_reason
*reason
= NULL
;
2269 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
2270 convs
= alloc_conversions (num_convs
);
2272 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2273 conversion ops are allowed. We handle that here by just checking for
2274 boolean_type_node because other operators don't ask for it. COND_EXPR
2275 also does contextual conversion to bool for the first operand, but we
2276 handle that in build_conditional_expr, and type1 here is operand 2. */
2277 if (type1
!= boolean_type_node
)
2278 flags
|= LOOKUP_ONLYCONVERTING
;
2280 for (i
= 0; i
< 2; ++i
)
2285 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2286 /*c_cast_p=*/false, flags
, complain
);
2290 /* We need something for printing the candidate. */
2291 t
= build_identity_conv (types
[i
], NULL_TREE
);
2292 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2298 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, args
[i
],
2304 /* For COND_EXPR we rearranged the arguments; undo that now. */
2307 convs
[2] = convs
[1];
2308 convs
[1] = convs
[0];
2309 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2310 /*c_cast_p=*/false, flags
,
2317 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2322 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2324 /*access_path=*/NULL_TREE
,
2325 /*conversion_path=*/NULL_TREE
,
2326 viable
, reason
, flags
);
2330 is_complete (tree t
)
2332 return COMPLETE_TYPE_P (complete_type (t
));
2335 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2338 promoted_arithmetic_type_p (tree type
)
2342 In this section, the term promoted integral type is used to refer
2343 to those integral types which are preserved by integral promotion
2344 (including e.g. int and long but excluding e.g. char).
2345 Similarly, the term promoted arithmetic type refers to promoted
2346 integral types plus floating types. */
2347 return ((CP_INTEGRAL_TYPE_P (type
)
2348 && same_type_p (type_promotes_to (type
), type
))
2349 || TREE_CODE (type
) == REAL_TYPE
);
2352 /* Create any builtin operator overload candidates for the operator in
2353 question given the converted operand types TYPE1 and TYPE2. The other
2354 args are passed through from add_builtin_candidates to
2355 build_builtin_candidate.
2357 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2358 If CODE is requires candidates operands of the same type of the kind
2359 of which TYPE1 and TYPE2 are, we add both candidates
2360 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2363 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2364 enum tree_code code2
, tree fnname
, tree type1
,
2365 tree type2
, tree
*args
, tree
*argtypes
, int flags
,
2366 tsubst_flags_t complain
)
2370 case POSTINCREMENT_EXPR
:
2371 case POSTDECREMENT_EXPR
:
2372 args
[1] = integer_zero_node
;
2373 type2
= integer_type_node
;
2382 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2383 and VQ is either volatile or empty, there exist candidate operator
2384 functions of the form
2385 VQ T& operator++(VQ T&);
2386 T operator++(VQ T&, int);
2387 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2388 type other than bool, and VQ is either volatile or empty, there exist
2389 candidate operator functions of the form
2390 VQ T& operator--(VQ T&);
2391 T operator--(VQ T&, int);
2392 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2393 complete object type, and VQ is either volatile or empty, there exist
2394 candidate operator functions of the form
2395 T*VQ& operator++(T*VQ&);
2396 T*VQ& operator--(T*VQ&);
2397 T* operator++(T*VQ&, int);
2398 T* operator--(T*VQ&, int); */
2400 case POSTDECREMENT_EXPR
:
2401 case PREDECREMENT_EXPR
:
2402 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2404 case POSTINCREMENT_EXPR
:
2405 case PREINCREMENT_EXPR
:
2406 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2408 type1
= build_reference_type (type1
);
2413 /* 7 For every cv-qualified or cv-unqualified object type T, there
2414 exist candidate operator functions of the form
2418 8 For every function type T, there exist candidate operator functions of
2420 T& operator*(T*); */
2423 if (TYPE_PTR_P (type1
)
2424 && (TYPE_PTROB_P (type1
)
2425 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2429 /* 9 For every type T, there exist candidate operator functions of the form
2432 10For every promoted arithmetic type T, there exist candidate operator
2433 functions of the form
2437 case UNARY_PLUS_EXPR
: /* unary + */
2438 if (TYPE_PTR_P (type1
))
2441 if (ARITHMETIC_TYPE_P (type1
))
2445 /* 11For every promoted integral type T, there exist candidate operator
2446 functions of the form
2450 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2454 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2455 is the same type as C2 or is a derived class of C2, T is a complete
2456 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2457 there exist candidate operator functions of the form
2458 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2459 where CV12 is the union of CV1 and CV2. */
2462 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2464 tree c1
= TREE_TYPE (type1
);
2465 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2467 if (MAYBE_CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2468 && (TYPE_PTRMEMFUNC_P (type2
)
2469 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2474 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2475 didate operator functions of the form
2480 bool operator<(L, R);
2481 bool operator>(L, R);
2482 bool operator<=(L, R);
2483 bool operator>=(L, R);
2484 bool operator==(L, R);
2485 bool operator!=(L, R);
2486 where LR is the result of the usual arithmetic conversions between
2489 14For every pair of types T and I, where T is a cv-qualified or cv-
2490 unqualified complete object type and I is a promoted integral type,
2491 there exist candidate operator functions of the form
2492 T* operator+(T*, I);
2493 T& operator[](T*, I);
2494 T* operator-(T*, I);
2495 T* operator+(I, T*);
2496 T& operator[](I, T*);
2498 15For every T, where T is a pointer to complete object type, there exist
2499 candidate operator functions of the form112)
2500 ptrdiff_t operator-(T, T);
2502 16For every pointer or enumeration type T, there exist candidate operator
2503 functions of the form
2504 bool operator<(T, T);
2505 bool operator>(T, T);
2506 bool operator<=(T, T);
2507 bool operator>=(T, T);
2508 bool operator==(T, T);
2509 bool operator!=(T, T);
2511 17For every pointer to member type T, there exist candidate operator
2512 functions of the form
2513 bool operator==(T, T);
2514 bool operator!=(T, T); */
2517 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2519 if (TYPE_PTROB_P (type1
)
2520 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2522 type2
= ptrdiff_type_node
;
2526 case TRUNC_DIV_EXPR
:
2527 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2533 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2534 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
2536 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
2541 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
2553 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2555 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2557 if (TREE_CODE (type1
) == ENUMERAL_TYPE
2558 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
2560 if (TYPE_PTR_P (type1
)
2561 && null_ptr_cst_p (args
[1]))
2566 if (null_ptr_cst_p (args
[0])
2567 && TYPE_PTR_P (type2
))
2575 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2578 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
2580 type1
= ptrdiff_type_node
;
2583 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2585 type2
= ptrdiff_type_node
;
2590 /* 18For every pair of promoted integral types L and R, there exist candi-
2591 date operator functions of the form
2598 where LR is the result of the usual arithmetic conversions between
2601 case TRUNC_MOD_EXPR
:
2607 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2611 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2612 type, VQ is either volatile or empty, and R is a promoted arithmetic
2613 type, there exist candidate operator functions of the form
2614 VQ L& operator=(VQ L&, R);
2615 VQ L& operator*=(VQ L&, R);
2616 VQ L& operator/=(VQ L&, R);
2617 VQ L& operator+=(VQ L&, R);
2618 VQ L& operator-=(VQ L&, R);
2620 20For every pair T, VQ), where T is any type and VQ is either volatile
2621 or empty, there exist candidate operator functions of the form
2622 T*VQ& operator=(T*VQ&, T*);
2624 21For every pair T, VQ), where T is a pointer to member type and VQ is
2625 either volatile or empty, there exist candidate operator functions of
2627 VQ T& operator=(VQ T&, T);
2629 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2630 unqualified complete object type, VQ is either volatile or empty, and
2631 I is a promoted integral type, there exist candidate operator func-
2633 T*VQ& operator+=(T*VQ&, I);
2634 T*VQ& operator-=(T*VQ&, I);
2636 23For every triple L, VQ, R), where L is an integral or enumeration
2637 type, VQ is either volatile or empty, and R is a promoted integral
2638 type, there exist candidate operator functions of the form
2640 VQ L& operator%=(VQ L&, R);
2641 VQ L& operator<<=(VQ L&, R);
2642 VQ L& operator>>=(VQ L&, R);
2643 VQ L& operator&=(VQ L&, R);
2644 VQ L& operator^=(VQ L&, R);
2645 VQ L& operator|=(VQ L&, R); */
2652 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2654 type2
= ptrdiff_type_node
;
2658 case TRUNC_DIV_EXPR
:
2659 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2663 case TRUNC_MOD_EXPR
:
2669 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2674 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2676 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2677 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2678 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2679 || ((TYPE_PTRMEMFUNC_P (type1
)
2680 || TYPE_PTR_P (type1
))
2681 && null_ptr_cst_p (args
[1])))
2691 type1
= build_reference_type (type1
);
2697 For every pair of promoted arithmetic types L and R, there
2698 exist candidate operator functions of the form
2700 LR operator?(bool, L, R);
2702 where LR is the result of the usual arithmetic conversions
2703 between types L and R.
2705 For every type T, where T is a pointer or pointer-to-member
2706 type, there exist candidate operator functions of the form T
2707 operator?(bool, T, T); */
2709 if (promoted_arithmetic_type_p (type1
)
2710 && promoted_arithmetic_type_p (type2
))
2714 /* Otherwise, the types should be pointers. */
2715 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
2718 /* We don't check that the two types are the same; the logic
2719 below will actually create two candidates; one in which both
2720 parameter types are TYPE1, and one in which both parameter
2726 if (ARITHMETIC_TYPE_P (type1
))
2734 /* Make sure we don't create builtin candidates with dependent types. */
2735 bool u1
= uses_template_parms (type1
);
2736 bool u2
= type2
? uses_template_parms (type2
) : false;
2739 /* Try to recover if one of the types is non-dependent. But if
2740 there's only one type, there's nothing we can do. */
2743 /* And we lose if both are dependent. */
2746 /* Or if they have different forms. */
2747 if (TREE_CODE (type1
) != TREE_CODE (type2
))
2756 /* If we're dealing with two pointer types or two enumeral types,
2757 we need candidates for both of them. */
2758 if (type2
&& !same_type_p (type1
, type2
)
2759 && TREE_CODE (type1
) == TREE_CODE (type2
)
2760 && (TREE_CODE (type1
) == REFERENCE_TYPE
2761 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2762 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2763 || TYPE_PTRMEMFUNC_P (type1
)
2764 || MAYBE_CLASS_TYPE_P (type1
)
2765 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2767 if (TYPE_PTR_OR_PTRMEM_P (type1
))
2769 tree cptype
= composite_pointer_type (type1
, type2
,
2774 if (cptype
!= error_mark_node
)
2776 build_builtin_candidate
2777 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
2783 build_builtin_candidate
2784 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
2785 build_builtin_candidate
2786 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
2790 build_builtin_candidate
2791 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
2795 type_decays_to (tree type
)
2797 if (TREE_CODE (type
) == ARRAY_TYPE
)
2798 return build_pointer_type (TREE_TYPE (type
));
2799 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2800 return build_pointer_type (type
);
2804 /* There are three conditions of builtin candidates:
2806 1) bool-taking candidates. These are the same regardless of the input.
2807 2) pointer-pair taking candidates. These are generated for each type
2808 one of the input types converts to.
2809 3) arithmetic candidates. According to the standard, we should generate
2810 all of these, but I'm trying not to...
2812 Here we generate a superset of the possible candidates for this particular
2813 case. That is a subset of the full set the standard defines, plus some
2814 other cases which the standard disallows. add_builtin_candidate will
2815 filter out the invalid set. */
2818 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2819 enum tree_code code2
, tree fnname
, tree
*args
,
2820 int flags
, tsubst_flags_t complain
)
2824 tree type
, argtypes
[3], t
;
2825 /* TYPES[i] is the set of possible builtin-operator parameter types
2826 we will consider for the Ith argument. */
2827 vec
<tree
, va_gc
> *types
[2];
2830 for (i
= 0; i
< 3; ++i
)
2833 argtypes
[i
] = unlowered_expr_type (args
[i
]);
2835 argtypes
[i
] = NULL_TREE
;
2840 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2841 and VQ is either volatile or empty, there exist candidate operator
2842 functions of the form
2843 VQ T& operator++(VQ T&); */
2845 case POSTINCREMENT_EXPR
:
2846 case PREINCREMENT_EXPR
:
2847 case POSTDECREMENT_EXPR
:
2848 case PREDECREMENT_EXPR
:
2853 /* 24There also exist candidate operator functions of the form
2854 bool operator!(bool);
2855 bool operator&&(bool, bool);
2856 bool operator||(bool, bool); */
2858 case TRUTH_NOT_EXPR
:
2859 build_builtin_candidate
2860 (candidates
, fnname
, boolean_type_node
,
2861 NULL_TREE
, args
, argtypes
, flags
, complain
);
2864 case TRUTH_ORIF_EXPR
:
2865 case TRUTH_ANDIF_EXPR
:
2866 build_builtin_candidate
2867 (candidates
, fnname
, boolean_type_node
,
2868 boolean_type_node
, args
, argtypes
, flags
, complain
);
2890 types
[0] = make_tree_vector ();
2891 types
[1] = make_tree_vector ();
2893 for (i
= 0; i
< 2; ++i
)
2897 else if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
2901 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2904 convs
= lookup_conversions (argtypes
[i
]);
2906 if (code
== COND_EXPR
)
2908 if (real_lvalue_p (args
[i
]))
2909 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2911 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
2917 for (; convs
; convs
= TREE_CHAIN (convs
))
2919 type
= TREE_TYPE (convs
);
2922 && (TREE_CODE (type
) != REFERENCE_TYPE
2923 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2926 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2927 vec_safe_push (types
[i
], type
);
2929 type
= non_reference (type
);
2930 if (i
!= 0 || ! ref1
)
2932 type
= cv_unqualified (type_decays_to (type
));
2933 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2934 vec_safe_push (types
[i
], type
);
2935 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2936 type
= type_promotes_to (type
);
2939 if (! vec_member (type
, types
[i
]))
2940 vec_safe_push (types
[i
], type
);
2945 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2946 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2947 type
= non_reference (argtypes
[i
]);
2948 if (i
!= 0 || ! ref1
)
2950 type
= cv_unqualified (type_decays_to (type
));
2951 if (enum_p
&& UNSCOPED_ENUM_P (type
))
2952 vec_safe_push (types
[i
], type
);
2953 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2954 type
= type_promotes_to (type
);
2956 vec_safe_push (types
[i
], type
);
2960 /* Run through the possible parameter types of both arguments,
2961 creating candidates with those parameter types. */
2962 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
2967 if (!types
[1]->is_empty ())
2968 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
2969 add_builtin_candidate
2970 (candidates
, code
, code2
, fnname
, t
,
2971 u
, args
, argtypes
, flags
, complain
);
2973 add_builtin_candidate
2974 (candidates
, code
, code2
, fnname
, t
,
2975 NULL_TREE
, args
, argtypes
, flags
, complain
);
2978 release_tree_vector (types
[0]);
2979 release_tree_vector (types
[1]);
2983 /* If TMPL can be successfully instantiated as indicated by
2984 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2986 TMPL is the template. EXPLICIT_TARGS are any explicit template
2987 arguments. ARGLIST is the arguments provided at the call-site.
2988 This does not change ARGLIST. The RETURN_TYPE is the desired type
2989 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2990 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2991 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2993 static struct z_candidate
*
2994 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
2995 tree ctype
, tree explicit_targs
, tree first_arg
,
2996 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
2997 tree access_path
, tree conversion_path
,
2998 int flags
, tree obj
, unification_kind_t strict
,
2999 tsubst_flags_t complain
)
3001 int ntparms
= DECL_NTPARMS (tmpl
);
3002 tree targs
= make_tree_vec (ntparms
);
3003 unsigned int len
= vec_safe_length (arglist
);
3004 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
3005 unsigned int skip_without_in_chrg
= 0;
3006 tree first_arg_without_in_chrg
= first_arg
;
3007 tree
*args_without_in_chrg
;
3008 unsigned int nargs_without_in_chrg
;
3009 unsigned int ia
, ix
;
3011 struct z_candidate
*cand
;
3013 struct rejection_reason
*reason
= NULL
;
3016 /* We don't do deduction on the in-charge parameter, the VTT
3017 parameter or 'this'. */
3018 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
3020 if (first_arg_without_in_chrg
!= NULL_TREE
)
3021 first_arg_without_in_chrg
= NULL_TREE
;
3022 else if (return_type
&& strict
== DEDUCE_CALL
)
3023 /* We're deducing for a call to the result of a template conversion
3024 function, so the args don't contain 'this'; leave them alone. */;
3026 ++skip_without_in_chrg
;
3029 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
3030 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
3031 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
3033 if (first_arg_without_in_chrg
!= NULL_TREE
)
3034 first_arg_without_in_chrg
= NULL_TREE
;
3036 ++skip_without_in_chrg
;
3039 if (len
< skip_without_in_chrg
)
3042 if (DECL_CONSTRUCTOR_P (tmpl
) && nargs
== 2
3043 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (first_arg
),
3044 TREE_TYPE ((*arglist
)[0])))
3046 /* 12.8/6 says, "A declaration of a constructor for a class X is
3047 ill-formed if its first parameter is of type (optionally cv-qualified)
3048 X and either there are no other parameters or else all other
3049 parameters have default arguments. A member function template is never
3050 instantiated to produce such a constructor signature."
3052 So if we're trying to copy an object of the containing class, don't
3053 consider a template constructor that has a first parameter type that
3054 is just a template parameter, as we would deduce a signature that we
3055 would then reject in the code below. */
3056 if (tree firstparm
= FUNCTION_FIRST_USER_PARMTYPE (tmpl
))
3058 firstparm
= TREE_VALUE (firstparm
);
3059 if (PACK_EXPANSION_P (firstparm
))
3060 firstparm
= PACK_EXPANSION_PATTERN (firstparm
);
3061 if (TREE_CODE (firstparm
) == TEMPLATE_TYPE_PARM
)
3063 gcc_assert (!explicit_targs
);
3064 reason
= invalid_copy_with_fn_template_rejection ();
3070 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
3071 + (len
- skip_without_in_chrg
));
3072 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
3074 if (first_arg_without_in_chrg
!= NULL_TREE
)
3076 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
3079 for (ix
= skip_without_in_chrg
;
3080 vec_safe_iterate (arglist
, ix
, &arg
);
3083 args_without_in_chrg
[ia
] = arg
;
3086 gcc_assert (ia
== nargs_without_in_chrg
);
3088 errs
= errorcount
+sorrycount
;
3089 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
3090 args_without_in_chrg
,
3091 nargs_without_in_chrg
,
3092 return_type
, strict
, flags
, false,
3093 complain
& tf_decltype
);
3095 if (fn
== error_mark_node
)
3097 /* Don't repeat unification later if it already resulted in errors. */
3098 if (errorcount
+sorrycount
== errs
)
3099 reason
= template_unification_rejection (tmpl
, explicit_targs
,
3100 targs
, args_without_in_chrg
,
3101 nargs_without_in_chrg
,
3102 return_type
, strict
, flags
);
3104 reason
= template_unification_error_rejection ();
3108 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
3110 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3111 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
3114 /* We're trying to produce a constructor with a prohibited signature,
3115 as discussed above; handle here any cases we didn't catch then,
3117 reason
= invalid_copy_with_fn_template_rejection ();
3122 if (obj
!= NULL_TREE
)
3123 /* Aha, this is a conversion function. */
3124 cand
= add_conv_candidate (candidates
, fn
, obj
, arglist
,
3125 access_path
, conversion_path
, complain
);
3127 cand
= add_function_candidate (candidates
, fn
, ctype
,
3128 first_arg
, arglist
, access_path
,
3129 conversion_path
, flags
, complain
);
3130 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
3131 /* This situation can occur if a member template of a template
3132 class is specialized. Then, instantiate_template might return
3133 an instantiation of the specialization, in which case the
3134 DECL_TI_TEMPLATE field will point at the original
3135 specialization. For example:
3137 template <class T> struct S { template <class U> void f(U);
3138 template <> void f(int) {}; };
3142 Here, TMPL will be template <class U> S<double>::f(U).
3143 And, instantiate template will give us the specialization
3144 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3145 for this will point at template <class T> template <> S<T>::f(int),
3146 so that we can find the definition. For the purposes of
3147 overload resolution, however, we want the original TMPL. */
3148 cand
->template_decl
= build_template_info (tmpl
, targs
);
3150 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3151 cand
->explicit_targs
= explicit_targs
;
3155 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, NULL
,
3156 access_path
, conversion_path
, 0, reason
, flags
);
3160 static struct z_candidate
*
3161 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3162 tree explicit_targs
, tree first_arg
,
3163 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3164 tree access_path
, tree conversion_path
, int flags
,
3165 unification_kind_t strict
, tsubst_flags_t complain
)
3168 add_template_candidate_real (candidates
, tmpl
, ctype
,
3169 explicit_targs
, first_arg
, arglist
,
3170 return_type
, access_path
, conversion_path
,
3171 flags
, NULL_TREE
, strict
, complain
);
3174 /* Create an overload candidate for the conversion function template TMPL,
3175 returning RETURN_TYPE, which will be invoked for expression OBJ to produce a
3176 pointer-to-function which will in turn be called with the argument list
3177 ARGLIST, and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
3178 passed on to implicit_conversion. */
3180 static struct z_candidate
*
3181 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3183 const vec
<tree
, va_gc
> *arglist
,
3184 tree return_type
, tree access_path
,
3185 tree conversion_path
, tsubst_flags_t complain
)
3188 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3189 NULL_TREE
, arglist
, return_type
, access_path
,
3190 conversion_path
, 0, obj
, DEDUCE_CALL
,
3194 /* The CANDS are the set of candidates that were considered for
3195 overload resolution. Return the set of viable candidates, or CANDS
3196 if none are viable. If any of the candidates were viable, set
3197 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3198 considered viable only if it is strictly viable. */
3200 static struct z_candidate
*
3201 splice_viable (struct z_candidate
*cands
,
3205 struct z_candidate
*viable
;
3206 struct z_candidate
**last_viable
;
3207 struct z_candidate
**cand
;
3208 bool found_strictly_viable
= false;
3210 /* Be strict inside templates, since build_over_call won't actually
3211 do the conversions to get pedwarns. */
3212 if (processing_template_decl
)
3216 last_viable
= &viable
;
3217 *any_viable_p
= false;
3222 struct z_candidate
*c
= *cand
;
3224 && (c
->viable
== 1 || TREE_CODE (c
->fn
) == TEMPLATE_DECL
))
3226 /* Be strict in the presence of a viable candidate. Also if
3227 there are template candidates, so that we get deduction errors
3228 for them instead of silently preferring a bad conversion. */
3230 if (viable
&& !found_strictly_viable
)
3232 /* Put any spliced near matches back onto the main list so
3233 that we see them if there is no strict match. */
3234 *any_viable_p
= false;
3235 *last_viable
= cands
;
3238 last_viable
= &viable
;
3242 if (strict_p
? c
->viable
== 1 : c
->viable
)
3247 last_viable
= &c
->next
;
3248 *any_viable_p
= true;
3250 found_strictly_viable
= true;
3256 return viable
? viable
: cands
;
3260 any_strictly_viable (struct z_candidate
*cands
)
3262 for (; cands
; cands
= cands
->next
)
3263 if (cands
->viable
== 1)
3268 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3269 words, it is about to become the "this" pointer for a member
3270 function call. Take the address of the object. */
3273 build_this (tree obj
)
3275 /* In a template, we are only concerned about the type of the
3276 expression, so we can take a shortcut. */
3277 if (processing_template_decl
)
3278 return build_address (obj
);
3280 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3283 /* Returns true iff functions are equivalent. Equivalent functions are
3284 not '==' only if one is a function-local extern function or if
3285 both are extern "C". */
3288 equal_functions (tree fn1
, tree fn2
)
3290 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3292 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3294 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
3295 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3296 return decls_match (fn1
, fn2
);
3300 /* Print information about a candidate being rejected due to INFO. */
3303 print_conversion_rejection (location_t loc
, struct conversion_info
*info
)
3305 tree from
= info
->from
;
3307 from
= lvalue_type (from
);
3308 if (info
->n_arg
== -1)
3310 /* Conversion of implicit `this' argument failed. */
3311 if (!TYPE_P (info
->from
))
3312 /* A bad conversion for 'this' must be discarding cv-quals. */
3313 inform (loc
, " passing %qT as %<this%> "
3314 "argument discards qualifiers",
3317 inform (loc
, " no known conversion for implicit "
3318 "%<this%> parameter from %qT to %qT",
3319 from
, info
->to_type
);
3321 else if (!TYPE_P (info
->from
))
3323 if (info
->n_arg
>= 0)
3324 inform (loc
, " conversion of argument %d would be ill-formed:",
3326 perform_implicit_conversion (info
->to_type
, info
->from
,
3327 tf_warning_or_error
);
3329 else if (info
->n_arg
== -2)
3330 /* Conversion of conversion function return value failed. */
3331 inform (loc
, " no known conversion from %qT to %qT",
3332 from
, info
->to_type
);
3334 inform (loc
, " no known conversion for argument %d from %qT to %qT",
3335 info
->n_arg
+ 1, from
, info
->to_type
);
3338 /* Print information about a candidate with WANT parameters and we found
3342 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
)
3344 inform_n (loc
, want
,
3345 " candidate expects %d argument, %d provided",
3346 " candidate expects %d arguments, %d provided",
3350 /* Print information about one overload candidate CANDIDATE. MSGSTR
3351 is the text to print before the candidate itself.
3353 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3354 to have been run through gettext by the caller. This wart makes
3355 life simpler in print_z_candidates and for the translators. */
3358 print_z_candidate (location_t loc
, const char *msgstr
,
3359 struct z_candidate
*candidate
)
3361 const char *msg
= (msgstr
== NULL
3363 : ACONCAT ((msgstr
, " ", NULL
)));
3364 location_t cloc
= location_of (candidate
->fn
);
3366 if (identifier_p (candidate
->fn
))
3369 if (candidate
->num_convs
== 3)
3370 inform (cloc
, "%s%D(%T, %T, %T) <built-in>", msg
, candidate
->fn
,
3371 candidate
->convs
[0]->type
,
3372 candidate
->convs
[1]->type
,
3373 candidate
->convs
[2]->type
);
3374 else if (candidate
->num_convs
== 2)
3375 inform (cloc
, "%s%D(%T, %T) <built-in>", msg
, candidate
->fn
,
3376 candidate
->convs
[0]->type
,
3377 candidate
->convs
[1]->type
);
3379 inform (cloc
, "%s%D(%T) <built-in>", msg
, candidate
->fn
,
3380 candidate
->convs
[0]->type
);
3382 else if (TYPE_P (candidate
->fn
))
3383 inform (cloc
, "%s%T <conversion>", msg
, candidate
->fn
);
3384 else if (candidate
->viable
== -1)
3385 inform (cloc
, "%s%#D <near match>", msg
, candidate
->fn
);
3386 else if (DECL_DELETED_FN (candidate
->fn
))
3387 inform (cloc
, "%s%#D <deleted>", msg
, candidate
->fn
);
3389 inform (cloc
, "%s%#D", msg
, candidate
->fn
);
3390 /* Give the user some information about why this candidate failed. */
3391 if (candidate
->reason
!= NULL
)
3393 struct rejection_reason
*r
= candidate
->reason
;
3398 print_arity_information (cloc
, r
->u
.arity
.actual
,
3399 r
->u
.arity
.expected
);
3401 case rr_arg_conversion
:
3402 print_conversion_rejection (cloc
, &r
->u
.conversion
);
3404 case rr_bad_arg_conversion
:
3405 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
);
3407 case rr_explicit_conversion
:
3408 inform (cloc
, " return type %qT of explicit conversion function "
3409 "cannot be converted to %qT with a qualification "
3410 "conversion", r
->u
.conversion
.from
,
3411 r
->u
.conversion
.to_type
);
3413 case rr_template_conversion
:
3414 inform (cloc
, " conversion from return type %qT of template "
3415 "conversion function specialization to %qT is not an "
3416 "exact match", r
->u
.conversion
.from
,
3417 r
->u
.conversion
.to_type
);
3419 case rr_template_unification
:
3420 /* We use template_unification_error_rejection if unification caused
3421 actual non-SFINAE errors, in which case we don't need to repeat
3423 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
3425 inform (cloc
, " substitution of deduced template arguments "
3426 "resulted in errors seen above");
3429 /* Re-run template unification with diagnostics. */
3430 inform (cloc
, " template argument deduction/substitution failed:");
3431 fn_type_unification (r
->u
.template_unification
.tmpl
,
3432 r
->u
.template_unification
.explicit_targs
,
3434 (r
->u
.template_unification
.num_targs
)),
3435 r
->u
.template_unification
.args
,
3436 r
->u
.template_unification
.nargs
,
3437 r
->u
.template_unification
.return_type
,
3438 r
->u
.template_unification
.strict
,
3439 r
->u
.template_unification
.flags
,
3442 case rr_invalid_copy
:
3444 " a constructor taking a single argument of its own "
3445 "class type is invalid");
3447 case rr_constraint_failure
:
3449 tree tmpl
= r
->u
.template_instantiation
.tmpl
;
3450 tree args
= r
->u
.template_instantiation
.targs
;
3451 diagnose_constraints (cloc
, tmpl
, args
);
3456 /* This candidate didn't have any issues or we failed to
3457 handle a particular code. Either way... */
3464 print_z_candidates (location_t loc
, struct z_candidate
*candidates
)
3466 struct z_candidate
*cand1
;
3467 struct z_candidate
**cand2
;
3472 /* Remove non-viable deleted candidates. */
3474 for (cand2
= &cand1
; *cand2
; )
3476 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
3477 && !(*cand2
)->viable
3478 && DECL_DELETED_FN ((*cand2
)->fn
))
3479 *cand2
= (*cand2
)->next
;
3481 cand2
= &(*cand2
)->next
;
3483 /* ...if there are any non-deleted ones. */
3487 /* There may be duplicates in the set of candidates. We put off
3488 checking this condition as long as possible, since we have no way
3489 to eliminate duplicates from a set of functions in less than n^2
3490 time. Now we are about to emit an error message, so it is more
3491 permissible to go slowly. */
3492 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3494 tree fn
= cand1
->fn
;
3495 /* Skip builtin candidates and conversion functions. */
3498 cand2
= &cand1
->next
;
3501 if (DECL_P ((*cand2
)->fn
)
3502 && equal_functions (fn
, (*cand2
)->fn
))
3503 *cand2
= (*cand2
)->next
;
3505 cand2
= &(*cand2
)->next
;
3509 for (; candidates
; candidates
= candidates
->next
)
3510 print_z_candidate (loc
, "candidate:", candidates
);
3513 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3514 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3515 the result of the conversion function to convert it to the final
3516 desired type. Merge the two sequences into a single sequence,
3517 and return the merged sequence. */
3520 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
3523 bool bad
= user_seq
->bad_p
;
3525 gcc_assert (user_seq
->kind
== ck_user
);
3527 /* Find the end of the second conversion sequence. */
3528 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
3530 /* The entire sequence is a user-conversion sequence. */
3531 (*t
)->user_conv_p
= true;
3536 /* Replace the identity conversion with the user conversion
3543 /* Handle overload resolution for initializing an object of class type from
3544 an initializer list. First we look for a suitable constructor that
3545 takes a std::initializer_list; if we don't find one, we then look for a
3546 non-list constructor.
3548 Parameters are as for add_candidates, except that the arguments are in
3549 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3550 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3553 add_list_candidates (tree fns
, tree first_arg
,
3554 tree init_list
, tree totype
,
3555 tree explicit_targs
, bool template_only
,
3556 tree conversion_path
, tree access_path
,
3558 struct z_candidate
**candidates
,
3559 tsubst_flags_t complain
)
3561 vec
<tree
, va_gc
> *args
;
3563 gcc_assert (*candidates
== NULL
);
3565 /* We're looking for a ctor for list-initialization. */
3566 flags
|= LOOKUP_LIST_INIT_CTOR
;
3567 /* And we don't allow narrowing conversions. We also use this flag to
3568 avoid the copy constructor call for copy-list-initialization. */
3569 flags
|= LOOKUP_NO_NARROWING
;
3571 /* Always use the default constructor if the list is empty (DR 990). */
3572 if (CONSTRUCTOR_NELTS (init_list
) == 0
3573 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
3575 /* If the class has a list ctor, try passing the list as a single
3576 argument first, but only consider list ctors. */
3577 else if (TYPE_HAS_LIST_CTOR (totype
))
3579 flags
|= LOOKUP_LIST_ONLY
;
3580 args
= make_tree_vector_single (init_list
);
3581 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3582 explicit_targs
, template_only
, conversion_path
,
3583 access_path
, flags
, candidates
, complain
);
3584 if (any_strictly_viable (*candidates
))
3588 args
= ctor_to_vec (init_list
);
3590 /* We aren't looking for list-ctors anymore. */
3591 flags
&= ~LOOKUP_LIST_ONLY
;
3592 /* We allow more user-defined conversions within an init-list. */
3593 flags
&= ~LOOKUP_NO_CONVERSION
;
3595 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3596 explicit_targs
, template_only
, conversion_path
,
3597 access_path
, flags
, candidates
, complain
);
3600 /* Returns the best overload candidate to perform the requested
3601 conversion. This function is used for three the overloading situations
3602 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3603 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3604 per [dcl.init.ref], so we ignore temporary bindings. */
3606 static struct z_candidate
*
3607 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
3608 tsubst_flags_t complain
)
3610 struct z_candidate
*candidates
, *cand
;
3612 tree ctors
= NULL_TREE
;
3613 tree conv_fns
= NULL_TREE
;
3614 conversion
*conv
= NULL
;
3615 tree first_arg
= NULL_TREE
;
3616 vec
<tree
, va_gc
> *args
= NULL
;
3623 fromtype
= TREE_TYPE (expr
);
3625 /* We represent conversion within a hierarchy using RVALUE_CONV and
3626 BASE_CONV, as specified by [over.best.ics]; these become plain
3627 constructor calls, as specified in [dcl.init]. */
3628 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
3629 || !DERIVED_FROM_P (totype
, fromtype
));
3631 if (MAYBE_CLASS_TYPE_P (totype
))
3632 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3633 creating a garbage BASELINK; constructors can't be inherited. */
3634 ctors
= lookup_fnfields_slot (totype
, complete_ctor_identifier
);
3636 if (MAYBE_CLASS_TYPE_P (fromtype
))
3638 tree to_nonref
= non_reference (totype
);
3639 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
3640 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
3641 && DERIVED_FROM_P (to_nonref
, fromtype
)))
3643 /* [class.conv.fct] A conversion function is never used to
3644 convert a (possibly cv-qualified) object to the (possibly
3645 cv-qualified) same object type (or a reference to it), to a
3646 (possibly cv-qualified) base class of that type (or a
3647 reference to it)... */
3650 conv_fns
= lookup_conversions (fromtype
);
3654 flags
|= LOOKUP_NO_CONVERSION
;
3655 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3656 flags
|= LOOKUP_NO_NARROWING
;
3658 /* It's OK to bind a temporary for converting constructor arguments, but
3659 not in converting the return value of a conversion operator. */
3660 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
3661 | (flags
& LOOKUP_NO_NARROWING
));
3662 flags
&= ~LOOKUP_NO_TEMP_BIND
;
3666 int ctorflags
= flags
;
3668 first_arg
= build_dummy_object (totype
);
3670 /* We should never try to call the abstract or base constructor
3672 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
3673 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
3675 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3677 /* List-initialization. */
3678 add_list_candidates (ctors
, first_arg
, expr
, totype
, NULL_TREE
,
3679 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3680 ctorflags
, &candidates
, complain
);
3684 args
= make_tree_vector_single (expr
);
3685 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
3686 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3687 ctorflags
, &candidates
, complain
);
3690 for (cand
= candidates
; cand
; cand
= cand
->next
)
3692 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
3694 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3695 set, then this is copy-initialization. In that case, "The
3696 result of the call is then used to direct-initialize the
3697 object that is the destination of the copy-initialization."
3700 We represent this in the conversion sequence with an
3701 rvalue conversion, which means a constructor call. */
3702 if (TREE_CODE (totype
) != REFERENCE_TYPE
3703 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3705 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
3712 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
3714 tree conversion_path
= TREE_PURPOSE (conv_fns
);
3715 struct z_candidate
*old_candidates
;
3717 /* If we are called to convert to a reference type, we are trying to
3718 find a direct binding, so don't even consider temporaries. If
3719 we don't find a direct binding, the caller will try again to
3720 look for a temporary binding. */
3721 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
3722 convflags
|= LOOKUP_NO_TEMP_BIND
;
3724 old_candidates
= candidates
;
3725 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
3727 conversion_path
, TYPE_BINFO (fromtype
),
3728 flags
, &candidates
, complain
);
3730 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
3732 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
3734 = implicit_conversion (totype
,
3737 /*c_cast_p=*/false, convflags
,
3740 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3741 copy-initialization. In that case, "The result of the
3742 call is then used to direct-initialize the object that is
3743 the destination of the copy-initialization." [dcl.init]
3745 We represent this in the conversion sequence with an
3746 rvalue conversion, which means a constructor call. But
3747 don't add a second rvalue conversion if there's already
3748 one there. Which there really shouldn't be, but it's
3749 harmless since we'd add it here anyway. */
3750 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
3751 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3752 ics
= build_conv (ck_rvalue
, totype
, ics
);
3754 cand
->second_conv
= ics
;
3759 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -2,
3762 else if (DECL_NONCONVERTING_P (cand
->fn
)
3763 && ics
->rank
> cr_exact
)
3765 /* 13.3.1.5: For direct-initialization, those explicit
3766 conversion functions that are not hidden within S and
3767 yield type T or a type that can be converted to type T
3768 with a qualification conversion (4.4) are also candidate
3770 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3771 I've raised this issue with the committee. --jason 9/2011 */
3773 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
3775 else if (cand
->viable
== 1 && ics
->bad_p
)
3779 = bad_arg_conversion_rejection (NULL_TREE
, -2,
3782 else if (primary_template_instantiation_p (cand
->fn
)
3783 && ics
->rank
> cr_exact
)
3785 /* 13.3.3.1.2: If the user-defined conversion is specified by
3786 a specialization of a conversion function template, the
3787 second standard conversion sequence shall have exact match
3790 cand
->reason
= template_conversion_rejection (rettype
, totype
);
3795 candidates
= splice_viable (candidates
, false, &any_viable_p
);
3799 release_tree_vector (args
);
3803 cand
= tourney (candidates
, complain
);
3806 if (complain
& tf_error
)
3808 error ("conversion from %qT to %qT is ambiguous",
3810 print_z_candidates (location_of (expr
), candidates
);
3813 cand
= candidates
; /* any one will do */
3814 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
3815 cand
->second_conv
->user_conv_p
= true;
3816 if (!any_strictly_viable (candidates
))
3817 cand
->second_conv
->bad_p
= true;
3818 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3819 ambiguous conversion is no worse than another user-defined
3826 if (!DECL_CONSTRUCTOR_P (cand
->fn
))
3827 convtype
= non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)));
3828 else if (cand
->second_conv
->kind
== ck_rvalue
)
3829 /* DR 5: [in the first step of copy-initialization]...if the function
3830 is a constructor, the call initializes a temporary of the
3831 cv-unqualified version of the destination type. */
3832 convtype
= cv_unqualified (totype
);
3835 /* Build the user conversion sequence. */
3839 build_identity_conv (TREE_TYPE (expr
), expr
));
3841 if (cand
->viable
== -1)
3844 /* Remember that this was a list-initialization. */
3845 if (flags
& LOOKUP_NO_NARROWING
)
3846 conv
->check_narrowing
= true;
3848 /* Combine it with the second conversion sequence. */
3849 cand
->second_conv
= merge_conversion_sequences (conv
,
3855 /* Wrapper for above. */
3858 build_user_type_conversion (tree totype
, tree expr
, int flags
,
3859 tsubst_flags_t complain
)
3861 struct z_candidate
*cand
;
3864 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3865 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
3869 if (cand
->second_conv
->kind
== ck_ambig
)
3870 ret
= error_mark_node
;
3873 expr
= convert_like (cand
->second_conv
, expr
, complain
);
3874 ret
= convert_from_reference (expr
);
3880 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3884 /* Subroutine of convert_nontype_argument.
3886 EXPR is an argument for a template non-type parameter of integral or
3887 enumeration type. Do any necessary conversions (that are permitted for
3888 non-type arguments) to convert it to the parameter type.
3890 If conversion is successful, returns the converted expression;
3891 otherwise, returns error_mark_node. */
3894 build_integral_nontype_arg_conv (tree type
, tree expr
, tsubst_flags_t complain
)
3899 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
3901 if (error_operand_p (expr
))
3902 return error_mark_node
;
3904 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
3906 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3907 p
= conversion_obstack_alloc (0);
3909 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
3911 LOOKUP_IMPLICIT
, complain
);
3913 /* for a non-type template-parameter of integral or
3914 enumeration type, integral promotions (4.5) and integral
3915 conversions (4.7) are applied. */
3916 /* It should be sufficient to check the outermost conversion step, since
3917 there are no qualification conversions to integer type. */
3921 /* A conversion function is OK. If it isn't constexpr, we'll
3922 complain later that the argument isn't constant. */
3924 /* The lvalue-to-rvalue conversion is OK. */
3930 t
= next_conversion (conv
)->type
;
3931 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
3934 if (complain
& tf_error
)
3935 error_at (loc
, "conversion from %qT to %qT not considered for "
3936 "non-type template argument", t
, type
);
3937 /* and fall through. */
3945 expr
= convert_like (conv
, expr
, complain
);
3947 expr
= error_mark_node
;
3949 /* Free all the conversions we allocated. */
3950 obstack_free (&conversion_obstack
, p
);
3955 /* Do any initial processing on the arguments to a function call. */
3957 static vec
<tree
, va_gc
> *
3958 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
3963 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
3965 if (error_operand_p (arg
))
3967 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
3969 if (complain
& tf_error
)
3970 error ("invalid use of void expression");
3973 else if (invalid_nonstatic_memfn_p (input_location
, arg
, complain
))
3979 /* Perform overload resolution on FN, which is called with the ARGS.
3981 Return the candidate function selected by overload resolution, or
3982 NULL if the event that overload resolution failed. In the case
3983 that overload resolution fails, *CANDIDATES will be the set of
3984 candidates considered, and ANY_VIABLE_P will be set to true or
3985 false to indicate whether or not any of the candidates were
3988 The ARGS should already have gone through RESOLVE_ARGS before this
3989 function is called. */
3991 static struct z_candidate
*
3992 perform_overload_resolution (tree fn
,
3993 const vec
<tree
, va_gc
> *args
,
3994 struct z_candidate
**candidates
,
3995 bool *any_viable_p
, tsubst_flags_t complain
)
3997 struct z_candidate
*cand
;
3998 tree explicit_targs
;
4001 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4003 explicit_targs
= NULL_TREE
;
4007 *any_viable_p
= true;
4010 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
4011 || TREE_CODE (fn
) == TEMPLATE_DECL
4012 || TREE_CODE (fn
) == OVERLOAD
4013 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
4015 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4017 explicit_targs
= TREE_OPERAND (fn
, 1);
4018 fn
= TREE_OPERAND (fn
, 0);
4022 /* Add the various candidate functions. */
4023 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
4024 explicit_targs
, template_only
,
4025 /*conversion_path=*/NULL_TREE
,
4026 /*access_path=*/NULL_TREE
,
4028 candidates
, complain
);
4030 *candidates
= splice_viable (*candidates
, false, any_viable_p
);
4032 cand
= tourney (*candidates
, complain
);
4036 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4040 /* Print an error message about being unable to build a call to FN with
4041 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
4042 be located; CANDIDATES is a possibly empty list of such
4046 print_error_for_call_failure (tree fn
, vec
<tree
, va_gc
> *args
,
4047 struct z_candidate
*candidates
)
4049 tree name
= DECL_NAME (OVL_CURRENT (fn
));
4050 location_t loc
= location_of (name
);
4052 if (!any_strictly_viable (candidates
))
4053 error_at (loc
, "no matching function for call to %<%D(%A)%>",
4054 name
, build_tree_list_vec (args
));
4056 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
4057 name
, build_tree_list_vec (args
));
4059 print_z_candidates (loc
, candidates
);
4062 /* Return an expression for a call to FN (a namespace-scope function,
4063 or a static member function) with the ARGS. This may change
4067 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
, bool koenig_p
,
4068 tsubst_flags_t complain
)
4070 struct z_candidate
*candidates
, *cand
;
4075 if (args
!= NULL
&& *args
!= NULL
)
4077 *args
= resolve_args (*args
, complain
);
4079 return error_mark_node
;
4083 tm_malloc_replacement (fn
);
4085 /* If this function was found without using argument dependent
4086 lookup, then we want to ignore any undeclared friend
4092 fn
= remove_hidden_names (fn
);
4095 if (complain
& tf_error
)
4096 print_error_for_call_failure (orig_fn
, *args
, NULL
);
4097 return error_mark_node
;
4101 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4102 p
= conversion_obstack_alloc (0);
4104 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
4109 if (complain
& tf_error
)
4111 // If there is a single (non-viable) function candidate,
4112 // let the error be diagnosed by cp_build_function_call_vec.
4113 if (!any_viable_p
&& candidates
&& ! candidates
->next
4114 && (TREE_CODE (candidates
->fn
) == FUNCTION_DECL
))
4115 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
4117 // Otherwise, emit notes for non-viable candidates.
4118 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4119 fn
= TREE_OPERAND (fn
, 0);
4120 print_error_for_call_failure (fn
, *args
, candidates
);
4122 result
= error_mark_node
;
4126 int flags
= LOOKUP_NORMAL
;
4127 /* If fn is template_id_expr, the call has explicit template arguments
4128 (e.g. func<int>(5)), communicate this info to build_over_call
4129 through flags so that later we can use it to decide whether to warn
4130 about peculiar null pointer conversion. */
4131 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4133 /* If overload resolution selects a specialization of a
4134 function concept for non-dependent template arguments,
4135 the expression is true if the constraints are satisfied
4136 and false otherwise.
4138 NOTE: This is an extension of Concepts Lite TS that
4139 allows constraints to be used in expressions. */
4140 if (flag_concepts
&& !processing_template_decl
)
4142 tree tmpl
= DECL_TI_TEMPLATE (cand
->fn
);
4143 tree targs
= DECL_TI_ARGS (cand
->fn
);
4144 tree decl
= DECL_TEMPLATE_RESULT (tmpl
);
4145 if (DECL_DECLARED_CONCEPT_P (decl
))
4146 return evaluate_function_concept (decl
, targs
);
4149 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
4152 result
= build_over_call (cand
, flags
, complain
);
4155 /* Free all the conversions we allocated. */
4156 obstack_free (&conversion_obstack
, p
);
4161 /* Build a call to a global operator new. FNNAME is the name of the
4162 operator (either "operator new" or "operator new[]") and ARGS are
4163 the arguments provided. This may change ARGS. *SIZE points to the
4164 total number of bytes required by the allocation, and is updated if
4165 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
4166 be used. If this function determines that no cookie should be
4167 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
4168 is not NULL_TREE, it is evaluated before calculating the final
4169 array size, and if it fails, the array size is replaced with
4170 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
4171 is non-NULL, it will be set, upon return, to the allocation
4175 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
4176 tree
*size
, tree
*cookie_size
, tree size_check
,
4177 tree
*fn
, tsubst_flags_t complain
)
4179 tree original_size
= *size
;
4181 struct z_candidate
*candidates
;
4182 struct z_candidate
*cand
;
4187 /* Set to (size_t)-1 if the size check fails. */
4188 if (size_check
!= NULL_TREE
)
4190 tree errval
= TYPE_MAX_VALUE (sizetype
);
4191 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
4192 errval
= throw_bad_array_new_length ();
4193 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4194 original_size
, errval
);
4196 vec_safe_insert (*args
, 0, *size
);
4197 *args
= resolve_args (*args
, complain
);
4199 return error_mark_node
;
4205 If this lookup fails to find the name, or if the allocated type
4206 is not a class type, the allocation function's name is looked
4207 up in the global scope.
4209 we disregard block-scope declarations of "operator new". */
4210 fns
= lookup_function_nonclass (fnname
, *args
, /*block_p=*/false);
4212 /* Figure out what function is being called. */
4213 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
4216 /* If no suitable function could be found, issue an error message
4220 if (complain
& tf_error
)
4221 print_error_for_call_failure (fns
, *args
, candidates
);
4222 return error_mark_node
;
4225 /* If a cookie is required, add some extra space. Whether
4226 or not a cookie is required cannot be determined until
4227 after we know which function was called. */
4230 bool use_cookie
= true;
4233 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
4234 /* Skip the size_t parameter. */
4235 arg_types
= TREE_CHAIN (arg_types
);
4236 /* Check the remaining parameters (if any). */
4238 && TREE_CHAIN (arg_types
) == void_list_node
4239 && same_type_p (TREE_VALUE (arg_types
),
4242 /* If we need a cookie, adjust the number of bytes allocated. */
4245 /* Update the total size. */
4246 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
4249 /* Set to (size_t)-1 if the size check fails. */
4250 gcc_assert (size_check
!= NULL_TREE
);
4251 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4252 *size
, TYPE_MAX_VALUE (sizetype
));
4254 /* Update the argument list to reflect the adjusted size. */
4255 (**args
)[0] = *size
;
4258 *cookie_size
= NULL_TREE
;
4261 /* Tell our caller which function we decided to call. */
4265 /* Build the CALL_EXPR. */
4266 return build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4269 /* Build a new call to operator(). This may change ARGS. */
4272 build_op_call_1 (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4274 struct z_candidate
*candidates
= 0, *cand
;
4275 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
4276 tree type
= TREE_TYPE (obj
);
4278 tree result
= NULL_TREE
;
4281 if (error_operand_p (obj
))
4282 return error_mark_node
;
4284 obj
= prep_operand (obj
);
4286 if (TYPE_PTRMEMFUNC_P (type
))
4288 if (complain
& tf_error
)
4289 /* It's no good looking for an overloaded operator() on a
4290 pointer-to-member-function. */
4291 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
4292 return error_mark_node
;
4295 if (TYPE_BINFO (type
))
4297 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
4298 if (fns
== error_mark_node
)
4299 return error_mark_node
;
4304 if (args
!= NULL
&& *args
!= NULL
)
4306 *args
= resolve_args (*args
, complain
);
4308 return error_mark_node
;
4311 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4312 p
= conversion_obstack_alloc (0);
4316 first_mem_arg
= obj
;
4318 add_candidates (BASELINK_FUNCTIONS (fns
),
4319 first_mem_arg
, *args
, NULL_TREE
,
4321 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
4322 LOOKUP_NORMAL
, &candidates
, complain
);
4325 convs
= lookup_conversions (type
);
4327 for (; convs
; convs
= TREE_CHAIN (convs
))
4329 tree fns
= TREE_VALUE (convs
);
4330 tree totype
= TREE_TYPE (convs
);
4332 if (TYPE_PTRFN_P (totype
)
4333 || TYPE_REFFN_P (totype
)
4334 || (TREE_CODE (totype
) == REFERENCE_TYPE
4335 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
4336 for (; fns
; fns
= OVL_NEXT (fns
))
4338 tree fn
= OVL_CURRENT (fns
);
4340 if (DECL_NONCONVERTING_P (fn
))
4343 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4344 add_template_conv_candidate
4345 (&candidates
, fn
, obj
, *args
, totype
,
4346 /*access_path=*/NULL_TREE
,
4347 /*conversion_path=*/NULL_TREE
, complain
);
4349 add_conv_candidate (&candidates
, fn
, obj
,
4350 *args
, /*conversion_path=*/NULL_TREE
,
4351 /*access_path=*/NULL_TREE
, complain
);
4355 /* Be strict here because if we choose a bad conversion candidate, the
4356 errors we get won't mention the call context. */
4357 candidates
= splice_viable (candidates
, true, &any_viable_p
);
4360 if (complain
& tf_error
)
4362 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
4363 build_tree_list_vec (*args
));
4364 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4366 result
= error_mark_node
;
4370 cand
= tourney (candidates
, complain
);
4373 if (complain
& tf_error
)
4375 error ("call of %<(%T) (%A)%> is ambiguous",
4376 TREE_TYPE (obj
), build_tree_list_vec (*args
));
4377 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4379 result
= error_mark_node
;
4381 /* Since cand->fn will be a type, not a function, for a conversion
4382 function, we must be careful not to unconditionally look at
4384 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
4385 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
4386 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4389 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
, -1,
4391 obj
= convert_from_reference (obj
);
4392 result
= cp_build_function_call_vec (obj
, args
, complain
);
4396 /* Free all the conversions we allocated. */
4397 obstack_free (&conversion_obstack
, p
);
4402 /* Wrapper for above. */
4405 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4408 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4409 ret
= build_op_call_1 (obj
, args
, complain
);
4410 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4414 /* Called by op_error to prepare format strings suitable for the error
4415 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4416 and a suffix (controlled by NTYPES). */
4419 op_error_string (const char *errmsg
, int ntypes
, bool match
)
4423 const char *msgp
= concat (match
? G_("ambiguous overload for ")
4424 : G_("no match for "), errmsg
, NULL
);
4427 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
4428 else if (ntypes
== 2)
4429 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
4431 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
4437 op_error (location_t loc
, enum tree_code code
, enum tree_code code2
,
4438 tree arg1
, tree arg2
, tree arg3
, bool match
)
4442 if (code
== MODIFY_EXPR
)
4443 opname
= assignment_operator_name_info
[code2
].name
;
4445 opname
= operator_name_info
[code
].name
;
4450 if (flag_diagnostics_show_caret
)
4451 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
4453 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4455 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
4456 "in %<%E ? %E : %E%>"), 3, match
),
4458 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4461 case POSTINCREMENT_EXPR
:
4462 case POSTDECREMENT_EXPR
:
4463 if (flag_diagnostics_show_caret
)
4464 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4465 opname
, TREE_TYPE (arg1
));
4467 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4469 opname
, arg1
, opname
, TREE_TYPE (arg1
));
4473 if (flag_diagnostics_show_caret
)
4474 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
4475 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4477 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4479 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4484 if (flag_diagnostics_show_caret
)
4485 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
4486 opname
, TREE_TYPE (arg1
));
4488 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
4489 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4494 if (flag_diagnostics_show_caret
)
4495 error_at (loc
, op_error_string (G_("%<operator%s%>"), 2, match
),
4496 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4498 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4500 opname
, arg1
, opname
, arg2
,
4501 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4503 if (flag_diagnostics_show_caret
)
4504 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4505 opname
, TREE_TYPE (arg1
));
4507 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4509 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4514 /* Return the implicit conversion sequence that could be used to
4515 convert E1 to E2 in [expr.cond]. */
4518 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
4520 tree t1
= non_reference (TREE_TYPE (e1
));
4521 tree t2
= non_reference (TREE_TYPE (e2
));
4527 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4528 implicitly converted (clause _conv_) to the type "lvalue reference to
4529 T2", subject to the constraint that in the conversion the
4530 reference must bind directly (_dcl.init.ref_) to an lvalue.
4532 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
4533 implicitly converted to the type "rvalue reference to T2", subject to
4534 the constraint that the reference must bind directly. */
4535 if (lvalue_or_rvalue_with_address_p (e2
))
4537 tree rtype
= cp_build_reference_type (t2
, !real_lvalue_p (e2
));
4538 conv
= implicit_conversion (rtype
,
4542 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
4543 |LOOKUP_ONLYCONVERTING
,
4545 if (conv
&& !conv
->bad_p
)
4549 /* If E2 is a prvalue or if neither of the conversions above can be done
4550 and at least one of the operands has (possibly cv-qualified) class
4552 if (!CLASS_TYPE_P (t1
) && !CLASS_TYPE_P (t2
))
4557 If E1 and E2 have class type, and the underlying class types are
4558 the same or one is a base class of the other: E1 can be converted
4559 to match E2 if the class of T2 is the same type as, or a base
4560 class of, the class of T1, and the cv-qualification of T2 is the
4561 same cv-qualification as, or a greater cv-qualification than, the
4562 cv-qualification of T1. If the conversion is applied, E1 is
4563 changed to an rvalue of type T2 that still refers to the original
4564 source class object (or the appropriate subobject thereof). */
4565 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
4566 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
4568 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
4570 conv
= build_identity_conv (t1
, e1
);
4571 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
4572 TYPE_MAIN_VARIANT (t2
)))
4573 conv
= build_conv (ck_base
, t2
, conv
);
4575 conv
= build_conv (ck_rvalue
, t2
, conv
);
4584 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4585 converted to the type that expression E2 would have if E2 were
4586 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4587 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
4588 LOOKUP_IMPLICIT
, complain
);
4591 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4592 arguments to the conditional expression. */
4595 build_conditional_expr_1 (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
4596 tsubst_flags_t complain
)
4600 tree result
= NULL_TREE
;
4601 tree result_type
= NULL_TREE
;
4602 bool lvalue_p
= true;
4603 struct z_candidate
*candidates
= 0;
4604 struct z_candidate
*cand
;
4606 tree orig_arg2
, orig_arg3
;
4608 /* As a G++ extension, the second argument to the conditional can be
4609 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4610 c'.) If the second operand is omitted, make sure it is
4611 calculated only once. */
4614 if (complain
& tf_error
)
4615 pedwarn (loc
, OPT_Wpedantic
,
4616 "ISO C++ forbids omitting the middle term of a ?: expression");
4618 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4619 if (real_lvalue_p (arg1
))
4620 arg2
= arg1
= stabilize_reference (arg1
);
4622 arg2
= arg1
= save_expr (arg1
);
4625 /* If something has already gone wrong, just pass that fact up the
4627 if (error_operand_p (arg1
)
4628 || error_operand_p (arg2
)
4629 || error_operand_p (arg3
))
4630 return error_mark_node
;
4635 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
4637 tree arg1_type
= TREE_TYPE (arg1
);
4639 /* If arg1 is another cond_expr choosing between -1 and 0,
4640 then we can use its comparison. It may help to avoid
4641 additional comparison, produce more accurate diagnostics
4642 and enables folding. */
4643 if (TREE_CODE (arg1
) == VEC_COND_EXPR
4644 && integer_minus_onep (TREE_OPERAND (arg1
, 1))
4645 && integer_zerop (TREE_OPERAND (arg1
, 2)))
4646 arg1
= TREE_OPERAND (arg1
, 0);
4648 arg1
= force_rvalue (arg1
, complain
);
4649 arg2
= force_rvalue (arg2
, complain
);
4650 arg3
= force_rvalue (arg3
, complain
);
4652 /* force_rvalue can return error_mark on valid arguments. */
4653 if (error_operand_p (arg1
)
4654 || error_operand_p (arg2
)
4655 || error_operand_p (arg3
))
4656 return error_mark_node
;
4658 arg2_type
= TREE_TYPE (arg2
);
4659 arg3_type
= TREE_TYPE (arg3
);
4661 if (!VECTOR_TYPE_P (arg2_type
)
4662 && !VECTOR_TYPE_P (arg3_type
))
4664 /* Rely on the error messages of the scalar version. */
4665 tree scal
= build_conditional_expr_1 (loc
, integer_one_node
,
4666 orig_arg2
, orig_arg3
, complain
);
4667 if (scal
== error_mark_node
)
4668 return error_mark_node
;
4669 tree stype
= TREE_TYPE (scal
);
4670 tree ctype
= TREE_TYPE (arg1_type
);
4671 if (TYPE_SIZE (stype
) != TYPE_SIZE (ctype
)
4672 || (!INTEGRAL_TYPE_P (stype
) && !SCALAR_FLOAT_TYPE_P (stype
)))
4674 if (complain
& tf_error
)
4675 error_at (loc
, "inferred scalar type %qT is not an integer or "
4676 "floating point type of the same size as %qT", stype
,
4677 COMPARISON_CLASS_P (arg1
)
4678 ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
4680 return error_mark_node
;
4683 tree vtype
= build_opaque_vector_type (stype
,
4684 TYPE_VECTOR_SUBPARTS (arg1_type
));
4685 /* We could pass complain & tf_warning to unsafe_conversion_p,
4686 but the warnings (like Wsign-conversion) have already been
4687 given by the scalar build_conditional_expr_1. We still check
4688 unsafe_conversion_p to forbid truncating long long -> float. */
4689 if (unsafe_conversion_p (loc
, stype
, arg2
, false))
4691 if (complain
& tf_error
)
4692 error_at (loc
, "conversion of scalar %qT to vector %qT "
4693 "involves truncation", arg2_type
, vtype
);
4694 return error_mark_node
;
4696 if (unsafe_conversion_p (loc
, stype
, arg3
, false))
4698 if (complain
& tf_error
)
4699 error_at (loc
, "conversion of scalar %qT to vector %qT "
4700 "involves truncation", arg3_type
, vtype
);
4701 return error_mark_node
;
4704 arg2
= cp_convert (stype
, arg2
, complain
);
4705 arg2
= save_expr (arg2
);
4706 arg2
= build_vector_from_val (vtype
, arg2
);
4708 arg3
= cp_convert (stype
, arg3
, complain
);
4709 arg3
= save_expr (arg3
);
4710 arg3
= build_vector_from_val (vtype
, arg3
);
4714 if (VECTOR_TYPE_P (arg2_type
) != VECTOR_TYPE_P (arg3_type
))
4716 enum stv_conv convert_flag
=
4717 scalar_to_vector (loc
, VEC_COND_EXPR
, arg2
, arg3
,
4718 complain
& tf_error
);
4720 switch (convert_flag
)
4723 return error_mark_node
;
4726 arg2
= save_expr (arg2
);
4727 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
4728 arg2
= build_vector_from_val (arg3_type
, arg2
);
4729 arg2_type
= TREE_TYPE (arg2
);
4734 arg3
= save_expr (arg3
);
4735 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
4736 arg3
= build_vector_from_val (arg2_type
, arg3
);
4737 arg3_type
= TREE_TYPE (arg3
);
4745 if (!same_type_p (arg2_type
, arg3_type
)
4746 || TYPE_VECTOR_SUBPARTS (arg1_type
)
4747 != TYPE_VECTOR_SUBPARTS (arg2_type
)
4748 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
4750 if (complain
& tf_error
)
4752 "incompatible vector types in conditional expression: "
4753 "%qT, %qT and %qT", TREE_TYPE (arg1
),
4754 TREE_TYPE (orig_arg2
), TREE_TYPE (orig_arg3
));
4755 return error_mark_node
;
4758 if (!COMPARISON_CLASS_P (arg1
))
4760 tree cmp_type
= build_same_sized_truth_vector_type (arg1_type
);
4761 arg1
= build2 (NE_EXPR
, cmp_type
, arg1
, build_zero_cst (arg1_type
));
4763 return build3_loc (loc
, VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
4768 The first expression is implicitly converted to bool (clause
4770 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
4772 if (error_operand_p (arg1
))
4773 return error_mark_node
;
4777 If either the second or the third operand has type (possibly
4778 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4779 array-to-pointer (_conv.array_), and function-to-pointer
4780 (_conv.func_) standard conversions are performed on the second
4781 and third operands. */
4782 arg2_type
= unlowered_expr_type (arg2
);
4783 arg3_type
= unlowered_expr_type (arg3
);
4784 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
4786 /* Do the conversions. We don't these for `void' type arguments
4787 since it can't have any effect and since decay_conversion
4788 does not handle that case gracefully. */
4789 if (!VOID_TYPE_P (arg2_type
))
4790 arg2
= decay_conversion (arg2
, complain
);
4791 if (!VOID_TYPE_P (arg3_type
))
4792 arg3
= decay_conversion (arg3
, complain
);
4793 arg2_type
= TREE_TYPE (arg2
);
4794 arg3_type
= TREE_TYPE (arg3
);
4798 One of the following shall hold:
4800 --The second or the third operand (but not both) is a
4801 throw-expression (_except.throw_); the result is of the
4802 type of the other and is an rvalue.
4804 --Both the second and the third operands have type void; the
4805 result is of type void and is an rvalue.
4807 We must avoid calling force_rvalue for expressions of type
4808 "void" because it will complain that their value is being
4810 if (TREE_CODE (arg2
) == THROW_EXPR
4811 && TREE_CODE (arg3
) != THROW_EXPR
)
4813 if (!VOID_TYPE_P (arg3_type
))
4815 arg3
= force_rvalue (arg3
, complain
);
4816 if (arg3
== error_mark_node
)
4817 return error_mark_node
;
4819 arg3_type
= TREE_TYPE (arg3
);
4820 result_type
= arg3_type
;
4822 else if (TREE_CODE (arg2
) != THROW_EXPR
4823 && TREE_CODE (arg3
) == THROW_EXPR
)
4825 if (!VOID_TYPE_P (arg2_type
))
4827 arg2
= force_rvalue (arg2
, complain
);
4828 if (arg2
== error_mark_node
)
4829 return error_mark_node
;
4831 arg2_type
= TREE_TYPE (arg2
);
4832 result_type
= arg2_type
;
4834 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
4835 result_type
= void_type_node
;
4838 if (complain
& tf_error
)
4840 if (VOID_TYPE_P (arg2_type
))
4841 error_at (EXPR_LOC_OR_LOC (arg3
, loc
),
4842 "second operand to the conditional operator "
4843 "is of type %<void%>, but the third operand is "
4844 "neither a throw-expression nor of type %<void%>");
4846 error_at (EXPR_LOC_OR_LOC (arg2
, loc
),
4847 "third operand to the conditional operator "
4848 "is of type %<void%>, but the second operand is "
4849 "neither a throw-expression nor of type %<void%>");
4851 return error_mark_node
;
4855 goto valid_operands
;
4859 Otherwise, if the second and third operand have different types,
4860 and either has (possibly cv-qualified) class type, or if both are
4861 glvalues of the same value category and the same type except for
4862 cv-qualification, an attempt is made to convert each of those operands
4863 to the type of the other. */
4864 else if (!same_type_p (arg2_type
, arg3_type
)
4865 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)
4866 || (same_type_ignoring_top_level_qualifiers_p (arg2_type
,
4868 && lvalue_or_rvalue_with_address_p (arg2
)
4869 && lvalue_or_rvalue_with_address_p (arg3
)
4870 && real_lvalue_p (arg2
) == real_lvalue_p (arg3
))))
4874 bool converted
= false;
4876 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4877 p
= conversion_obstack_alloc (0);
4879 conv2
= conditional_conversion (arg2
, arg3
, complain
);
4880 conv3
= conditional_conversion (arg3
, arg2
, complain
);
4884 If both can be converted, or one can be converted but the
4885 conversion is ambiguous, the program is ill-formed. If
4886 neither can be converted, the operands are left unchanged and
4887 further checking is performed as described below. If exactly
4888 one conversion is possible, that conversion is applied to the
4889 chosen operand and the converted operand is used in place of
4890 the original operand for the remainder of this section. */
4891 if ((conv2
&& !conv2
->bad_p
4892 && conv3
&& !conv3
->bad_p
)
4893 || (conv2
&& conv2
->kind
== ck_ambig
)
4894 || (conv3
&& conv3
->kind
== ck_ambig
))
4896 if (complain
& tf_error
)
4898 error_at (loc
, "operands to ?: have different types %qT and %qT",
4899 arg2_type
, arg3_type
);
4900 if (conv2
&& !conv2
->bad_p
&& conv3
&& !conv3
->bad_p
)
4901 inform (loc
, " and each type can be converted to the other");
4902 else if (conv2
&& conv2
->kind
== ck_ambig
)
4903 convert_like (conv2
, arg2
, complain
);
4905 convert_like (conv3
, arg3
, complain
);
4907 result
= error_mark_node
;
4909 else if (conv2
&& !conv2
->bad_p
)
4911 arg2
= convert_like (conv2
, arg2
, complain
);
4912 arg2
= convert_from_reference (arg2
);
4913 arg2_type
= TREE_TYPE (arg2
);
4914 /* Even if CONV2 is a valid conversion, the result of the
4915 conversion may be invalid. For example, if ARG3 has type
4916 "volatile X", and X does not have a copy constructor
4917 accepting a "volatile X&", then even if ARG2 can be
4918 converted to X, the conversion will fail. */
4919 if (error_operand_p (arg2
))
4920 result
= error_mark_node
;
4923 else if (conv3
&& !conv3
->bad_p
)
4925 arg3
= convert_like (conv3
, arg3
, complain
);
4926 arg3
= convert_from_reference (arg3
);
4927 arg3_type
= TREE_TYPE (arg3
);
4928 if (error_operand_p (arg3
))
4929 result
= error_mark_node
;
4933 /* Free all the conversions we allocated. */
4934 obstack_free (&conversion_obstack
, p
);
4939 /* If, after the conversion, both operands have class type,
4940 treat the cv-qualification of both operands as if it were the
4941 union of the cv-qualification of the operands.
4943 The standard is not clear about what to do in this
4944 circumstance. For example, if the first operand has type
4945 "const X" and the second operand has a user-defined
4946 conversion to "volatile X", what is the type of the second
4947 operand after this step? Making it be "const X" (matching
4948 the first operand) seems wrong, as that discards the
4949 qualification without actually performing a copy. Leaving it
4950 as "volatile X" seems wrong as that will result in the
4951 conditional expression failing altogether, even though,
4952 according to this step, the one operand could be converted to
4953 the type of the other. */
4955 && CLASS_TYPE_P (arg2_type
)
4956 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
4957 arg2_type
= arg3_type
=
4958 cp_build_qualified_type (arg2_type
,
4959 cp_type_quals (arg2_type
)
4960 | cp_type_quals (arg3_type
));
4965 If the second and third operands are glvalues of the same value
4966 category and have the same type, the result is of that type and
4968 if (((real_lvalue_p (arg2
) && real_lvalue_p (arg3
))
4969 || (xvalue_p (arg2
) && xvalue_p (arg3
)))
4970 && same_type_p (arg2_type
, arg3_type
))
4972 result_type
= arg2_type
;
4973 arg2
= mark_lvalue_use (arg2
);
4974 arg3
= mark_lvalue_use (arg3
);
4975 goto valid_operands
;
4980 Otherwise, the result is an rvalue. If the second and third
4981 operand do not have the same type, and either has (possibly
4982 cv-qualified) class type, overload resolution is used to
4983 determine the conversions (if any) to be applied to the operands
4984 (_over.match.oper_, _over.built_). */
4986 if (!same_type_p (arg2_type
, arg3_type
)
4987 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
4993 /* Rearrange the arguments so that add_builtin_candidate only has
4994 to know about two args. In build_builtin_candidate, the
4995 arguments are unscrambled. */
4999 add_builtin_candidates (&candidates
,
5002 ansi_opname (COND_EXPR
),
5004 LOOKUP_NORMAL
, complain
);
5008 If the overload resolution fails, the program is
5010 candidates
= splice_viable (candidates
, false, &any_viable_p
);
5013 if (complain
& tf_error
)
5014 error_at (loc
, "operands to ?: have different types %qT and %qT",
5015 arg2_type
, arg3_type
);
5016 return error_mark_node
;
5018 cand
= tourney (candidates
, complain
);
5021 if (complain
& tf_error
)
5023 op_error (loc
, COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, FALSE
);
5024 print_z_candidates (loc
, candidates
);
5026 return error_mark_node
;
5031 Otherwise, the conversions thus determined are applied, and
5032 the converted operands are used in place of the original
5033 operands for the remainder of this section. */
5034 conv
= cand
->convs
[0];
5035 arg1
= convert_like (conv
, arg1
, complain
);
5036 conv
= cand
->convs
[1];
5037 arg2
= convert_like (conv
, arg2
, complain
);
5038 arg2_type
= TREE_TYPE (arg2
);
5039 conv
= cand
->convs
[2];
5040 arg3
= convert_like (conv
, arg3
, complain
);
5041 arg3_type
= TREE_TYPE (arg3
);
5046 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
5047 and function-to-pointer (_conv.func_) standard conversions are
5048 performed on the second and third operands.
5050 We need to force the lvalue-to-rvalue conversion here for class types,
5051 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
5052 that isn't wrapped with a TARGET_EXPR plays havoc with exception
5055 arg2
= force_rvalue (arg2
, complain
);
5056 if (!CLASS_TYPE_P (arg2_type
))
5057 arg2_type
= TREE_TYPE (arg2
);
5059 arg3
= force_rvalue (arg3
, complain
);
5060 if (!CLASS_TYPE_P (arg3_type
))
5061 arg3_type
= TREE_TYPE (arg3
);
5063 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5064 return error_mark_node
;
5068 After those conversions, one of the following shall hold:
5070 --The second and third operands have the same type; the result is of
5072 if (same_type_p (arg2_type
, arg3_type
))
5073 result_type
= arg2_type
;
5076 --The second and third operands have arithmetic or enumeration
5077 type; the usual arithmetic conversions are performed to bring
5078 them to a common type, and the result is of that type. */
5079 else if ((ARITHMETIC_TYPE_P (arg2_type
)
5080 || UNSCOPED_ENUM_P (arg2_type
))
5081 && (ARITHMETIC_TYPE_P (arg3_type
)
5082 || UNSCOPED_ENUM_P (arg3_type
)))
5084 /* In this case, there is always a common type. */
5085 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
5087 if (complain
& tf_warning
)
5088 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
5089 "implicit conversion from %qT to %qT to "
5090 "match other result of conditional",
5093 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5094 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
5096 if (TREE_CODE (orig_arg2
) == CONST_DECL
5097 && TREE_CODE (orig_arg3
) == CONST_DECL
5098 && DECL_CONTEXT (orig_arg2
) == DECL_CONTEXT (orig_arg3
))
5099 /* Two enumerators from the same enumeration can have different
5100 types when the enumeration is still being defined. */;
5101 else if (complain
& tf_warning
)
5102 warning_at (loc
, OPT_Wenum_compare
, "enumeral mismatch in "
5103 "conditional expression: %qT vs %qT",
5104 arg2_type
, arg3_type
);
5106 else if (extra_warnings
5107 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5108 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
5109 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
5110 && !same_type_p (arg2_type
,
5111 type_promotes_to (arg3_type
)))))
5113 if (complain
& tf_warning
)
5114 warning_at (loc
, OPT_Wextra
, "enumeral and non-enumeral type in "
5115 "conditional expression");
5118 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5119 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5123 --The second and third operands have pointer type, or one has
5124 pointer type and the other is a null pointer constant; pointer
5125 conversions (_conv.ptr_) and qualification conversions
5126 (_conv.qual_) are performed to bring them to their composite
5127 pointer type (_expr.rel_). The result is of the composite
5130 --The second and third operands have pointer to member type, or
5131 one has pointer to member type and the other is a null pointer
5132 constant; pointer to member conversions (_conv.mem_) and
5133 qualification conversions (_conv.qual_) are performed to bring
5134 them to a common type, whose cv-qualification shall match the
5135 cv-qualification of either the second or the third operand.
5136 The result is of the common type. */
5137 else if ((null_ptr_cst_p (arg2
)
5138 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
5139 || (null_ptr_cst_p (arg3
)
5140 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
5141 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
5142 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
5143 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
5145 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
5146 arg3
, CPO_CONDITIONAL_EXPR
,
5148 if (result_type
== error_mark_node
)
5149 return error_mark_node
;
5150 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5151 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5156 if (complain
& tf_error
)
5157 error_at (loc
, "operands to ?: have different types %qT and %qT",
5158 arg2_type
, arg3_type
);
5159 return error_mark_node
;
5162 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5163 return error_mark_node
;
5166 result
= build3_loc (loc
, COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
5168 /* We can't use result_type below, as fold might have returned a
5173 /* Expand both sides into the same slot, hopefully the target of
5174 the ?: expression. We used to check for TARGET_EXPRs here,
5175 but now we sometimes wrap them in NOP_EXPRs so the test would
5177 if (CLASS_TYPE_P (TREE_TYPE (result
)))
5178 result
= get_target_expr_sfinae (result
, complain
);
5179 /* If this expression is an rvalue, but might be mistaken for an
5180 lvalue, we must add a NON_LVALUE_EXPR. */
5181 result
= rvalue (result
);
5184 result
= force_paren_expr (result
);
5189 /* Wrapper for above. */
5192 build_conditional_expr (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
5193 tsubst_flags_t complain
)
5196 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5197 ret
= build_conditional_expr_1 (loc
, arg1
, arg2
, arg3
, complain
);
5198 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5202 /* OPERAND is an operand to an expression. Perform necessary steps
5203 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
5207 prep_operand (tree operand
)
5211 if (CLASS_TYPE_P (TREE_TYPE (operand
))
5212 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
5213 /* Make sure the template type is instantiated now. */
5214 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
5220 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
5221 OVERLOAD) to the CANDIDATES, returning an updated list of
5222 CANDIDATES. The ARGS are the arguments provided to the call;
5223 if FIRST_ARG is non-null it is the implicit object argument,
5224 otherwise the first element of ARGS is used if needed. The
5225 EXPLICIT_TARGS are explicit template arguments provided.
5226 TEMPLATE_ONLY is true if only template functions should be
5227 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
5228 add_function_candidate. */
5231 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
5233 tree explicit_targs
, bool template_only
,
5234 tree conversion_path
, tree access_path
,
5236 struct z_candidate
**candidates
,
5237 tsubst_flags_t complain
)
5240 const vec
<tree
, va_gc
> *non_static_args
;
5241 bool check_list_ctor
;
5242 bool check_converting
;
5243 unification_kind_t strict
;
5249 /* Precalculate special handling of constructors and conversion ops. */
5250 fn
= OVL_CURRENT (fns
);
5251 if (DECL_CONV_FN_P (fn
))
5253 check_list_ctor
= false;
5254 check_converting
= !!(flags
& LOOKUP_ONLYCONVERTING
);
5255 if (flags
& LOOKUP_NO_CONVERSION
)
5256 /* We're doing return_type(x). */
5257 strict
= DEDUCE_CONV
;
5259 /* We're doing x.operator return_type(). */
5260 strict
= DEDUCE_EXACT
;
5261 /* [over.match.funcs] For conversion functions, the function
5262 is considered to be a member of the class of the implicit
5263 object argument for the purpose of defining the type of
5264 the implicit object parameter. */
5265 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
5269 if (DECL_CONSTRUCTOR_P (fn
))
5271 check_list_ctor
= !!(flags
& LOOKUP_LIST_ONLY
);
5272 /* For list-initialization we consider explicit constructors
5273 and complain if one is chosen. */
5275 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
5276 == LOOKUP_ONLYCONVERTING
);
5280 check_list_ctor
= false;
5281 check_converting
= false;
5283 strict
= DEDUCE_CALL
;
5284 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
5288 non_static_args
= args
;
5290 /* Delay creating the implicit this parameter until it is needed. */
5291 non_static_args
= NULL
;
5293 for (; fns
; fns
= OVL_NEXT (fns
))
5296 const vec
<tree
, va_gc
> *fn_args
;
5298 fn
= OVL_CURRENT (fns
);
5300 if (check_converting
&& DECL_NONCONVERTING_P (fn
))
5302 if (check_list_ctor
&& !is_list_ctor (fn
))
5305 /* Figure out which set of arguments to use. */
5306 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
5308 /* If this function is a non-static member and we didn't get an
5309 implicit object argument, move it out of args. */
5310 if (first_arg
== NULL_TREE
)
5314 vec
<tree
, va_gc
> *tempvec
;
5315 vec_alloc (tempvec
, args
->length () - 1);
5316 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
5317 tempvec
->quick_push (arg
);
5318 non_static_args
= tempvec
;
5319 first_arg
= (*args
)[0];
5322 fn_first_arg
= first_arg
;
5323 fn_args
= non_static_args
;
5327 /* Otherwise, just use the list of arguments provided. */
5328 fn_first_arg
= NULL_TREE
;
5332 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5333 add_template_candidate (candidates
,
5345 else if (!template_only
)
5346 add_function_candidate (candidates
,
5359 build_new_op_1 (location_t loc
, enum tree_code code
, int flags
, tree arg1
,
5360 tree arg2
, tree arg3
, tree
*overload
, tsubst_flags_t complain
)
5362 struct z_candidate
*candidates
= 0, *cand
;
5363 vec
<tree
, va_gc
> *arglist
;
5366 tree result
= NULL_TREE
;
5367 bool result_valid_p
= false;
5368 enum tree_code code2
= NOP_EXPR
;
5369 enum tree_code code_orig_arg1
= ERROR_MARK
;
5370 enum tree_code code_orig_arg2
= ERROR_MARK
;
5376 if (error_operand_p (arg1
)
5377 || error_operand_p (arg2
)
5378 || error_operand_p (arg3
))
5379 return error_mark_node
;
5381 if (code
== MODIFY_EXPR
)
5383 code2
= TREE_CODE (arg3
);
5385 fnname
= ansi_assopname (code2
);
5388 fnname
= ansi_opname (code
);
5390 arg1
= prep_operand (arg1
);
5392 bool memonly
= false;
5397 case VEC_DELETE_EXPR
:
5399 /* Use build_op_new_call and build_op_delete_call instead. */
5403 /* Use build_op_call instead. */
5406 case TRUTH_ORIF_EXPR
:
5407 case TRUTH_ANDIF_EXPR
:
5408 case TRUTH_AND_EXPR
:
5410 /* These are saved for the sake of warn_logical_operator. */
5411 code_orig_arg1
= TREE_CODE (arg1
);
5412 code_orig_arg2
= TREE_CODE (arg2
);
5420 /* These are saved for the sake of maybe_warn_bool_compare. */
5421 code_orig_arg1
= TREE_CODE (TREE_TYPE (arg1
));
5422 code_orig_arg2
= TREE_CODE (TREE_TYPE (arg2
));
5425 /* =, ->, [], () must be non-static member functions. */
5427 if (code2
!= NOP_EXPR
)
5438 arg2
= prep_operand (arg2
);
5439 arg3
= prep_operand (arg3
);
5441 if (code
== COND_EXPR
)
5442 /* Use build_conditional_expr instead. */
5444 else if (! OVERLOAD_TYPE_P (TREE_TYPE (arg1
))
5445 && (! arg2
|| ! OVERLOAD_TYPE_P (TREE_TYPE (arg2
))))
5448 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5449 arg2
= integer_zero_node
;
5451 vec_alloc (arglist
, 3);
5452 arglist
->quick_push (arg1
);
5453 if (arg2
!= NULL_TREE
)
5454 arglist
->quick_push (arg2
);
5455 if (arg3
!= NULL_TREE
)
5456 arglist
->quick_push (arg3
);
5458 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5459 p
= conversion_obstack_alloc (0);
5461 /* Add namespace-scope operators to the list of functions to
5464 add_candidates (lookup_function_nonclass (fnname
, arglist
,
5466 NULL_TREE
, arglist
, NULL_TREE
,
5467 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5468 flags
, &candidates
, complain
);
5472 args
[2] = NULL_TREE
;
5474 /* Add class-member operators to the candidate set. */
5475 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
5479 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
5480 if (fns
== error_mark_node
)
5482 result
= error_mark_node
;
5483 goto user_defined_result_ready
;
5486 add_candidates (BASELINK_FUNCTIONS (fns
),
5487 NULL_TREE
, arglist
, NULL_TREE
,
5489 BASELINK_BINFO (fns
),
5490 BASELINK_ACCESS_BINFO (fns
),
5491 flags
, &candidates
, complain
);
5493 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5494 only non-member functions that have type T1 or reference to
5495 cv-qualified-opt T1 for the first argument, if the first argument
5496 has an enumeration type, or T2 or reference to cv-qualified-opt
5497 T2 for the second argument, if the second argument has an
5498 enumeration type. Filter out those that don't match. */
5499 else if (! arg2
|| ! CLASS_TYPE_P (TREE_TYPE (arg2
)))
5501 struct z_candidate
**candp
, **next
;
5503 for (candp
= &candidates
; *candp
; candp
= next
)
5505 tree parmlist
, parmtype
;
5506 int i
, nargs
= (arg2
? 2 : 1);
5511 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5513 for (i
= 0; i
< nargs
; ++i
)
5515 parmtype
= TREE_VALUE (parmlist
);
5517 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
5518 parmtype
= TREE_TYPE (parmtype
);
5519 if (TREE_CODE (TREE_TYPE (args
[i
])) == ENUMERAL_TYPE
5520 && (same_type_ignoring_top_level_qualifiers_p
5521 (TREE_TYPE (args
[i
]), parmtype
)))
5524 parmlist
= TREE_CHAIN (parmlist
);
5527 /* No argument has an appropriate type, so remove this
5528 candidate function from the list. */
5531 *candp
= cand
->next
;
5537 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
5544 /* For these, the built-in candidates set is empty
5545 [over.match.oper]/3. We don't want non-strict matches
5546 because exact matches are always possible with built-in
5547 operators. The built-in candidate set for COMPONENT_REF
5548 would be empty too, but since there are no such built-in
5549 operators, we accept non-strict matches for them. */
5558 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
5563 case POSTINCREMENT_EXPR
:
5564 case POSTDECREMENT_EXPR
:
5565 /* Don't try anything fancy if we're not allowed to produce
5567 if (!(complain
& tf_error
))
5568 return error_mark_node
;
5570 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5571 distinguish between prefix and postfix ++ and
5572 operator++() was used for both, so we allow this with
5576 const char *msg
= (flag_permissive
)
5577 ? G_("no %<%D(int)%> declared for postfix %qs,"
5578 " trying prefix operator instead")
5579 : G_("no %<%D(int)%> declared for postfix %qs");
5580 permerror (loc
, msg
, fnname
, operator_name_info
[code
].name
);
5583 if (!flag_permissive
)
5584 return error_mark_node
;
5586 if (code
== POSTINCREMENT_EXPR
)
5587 code
= PREINCREMENT_EXPR
;
5589 code
= PREDECREMENT_EXPR
;
5590 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
5591 NULL_TREE
, overload
, complain
);
5594 /* The caller will deal with these. */
5599 result_valid_p
= true;
5603 if (complain
& tf_error
)
5605 /* If one of the arguments of the operator represents
5606 an invalid use of member function pointer, try to report
5607 a meaningful error ... */
5608 if (invalid_nonstatic_memfn_p (loc
, arg1
, tf_error
)
5609 || invalid_nonstatic_memfn_p (loc
, arg2
, tf_error
)
5610 || invalid_nonstatic_memfn_p (loc
, arg3
, tf_error
))
5611 /* We displayed the error message. */;
5614 /* ... Otherwise, report the more generic
5615 "no matching operator found" error */
5616 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
5617 print_z_candidates (loc
, candidates
);
5620 result
= error_mark_node
;
5626 cand
= tourney (candidates
, complain
);
5629 if (complain
& tf_error
)
5631 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
5632 print_z_candidates (loc
, candidates
);
5634 result
= error_mark_node
;
5636 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5639 *overload
= cand
->fn
;
5641 if (resolve_args (arglist
, complain
) == NULL
)
5642 result
= error_mark_node
;
5644 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5646 if (processing_template_decl
5647 && result
!= NULL_TREE
5648 && result
!= error_mark_node
5649 && DECL_HIDDEN_FRIEND_P (cand
->fn
))
5652 if (REFERENCE_REF_P (call
))
5653 call
= TREE_OPERAND (call
, 0);
5654 /* This prevents build_new_function_call from discarding this
5655 function during instantiation of the enclosing template. */
5656 KOENIG_LOOKUP_P (call
) = 1;
5661 /* Give any warnings we noticed during overload resolution. */
5662 if (cand
->warnings
&& (complain
& tf_warning
))
5664 struct candidate_warning
*w
;
5665 for (w
= cand
->warnings
; w
; w
= w
->next
)
5666 joust (cand
, w
->loser
, 1, complain
);
5669 /* Check for comparison of different enum types. */
5678 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
5679 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
5680 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
5681 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
)))
5682 && (complain
& tf_warning
))
5684 warning (OPT_Wenum_compare
,
5685 "comparison between %q#T and %q#T",
5686 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5693 /* We need to strip any leading REF_BIND so that bitfields
5694 don't cause errors. This should not remove any important
5695 conversions, because builtins don't apply to class
5696 objects directly. */
5697 conv
= cand
->convs
[0];
5698 if (conv
->kind
== ck_ref_bind
)
5699 conv
= next_conversion (conv
);
5700 arg1
= convert_like (conv
, arg1
, complain
);
5704 conv
= cand
->convs
[1];
5705 if (conv
->kind
== ck_ref_bind
)
5706 conv
= next_conversion (conv
);
5708 arg2
= decay_conversion (arg2
, complain
);
5710 /* We need to call warn_logical_operator before
5711 converting arg2 to a boolean_type, but after
5712 decaying an enumerator to its value. */
5713 if (complain
& tf_warning
)
5714 warn_logical_operator (loc
, code
, boolean_type_node
,
5715 code_orig_arg1
, arg1
,
5716 code_orig_arg2
, arg2
);
5718 arg2
= convert_like (conv
, arg2
, complain
);
5722 conv
= cand
->convs
[2];
5723 if (conv
->kind
== ck_ref_bind
)
5724 conv
= next_conversion (conv
);
5725 arg3
= convert_like (conv
, arg3
, complain
);
5731 user_defined_result_ready
:
5733 /* Free all the conversions we allocated. */
5734 obstack_free (&conversion_obstack
, p
);
5736 if (result
|| result_valid_p
)
5743 return cp_build_modify_expr (arg1
, code2
, arg2
, complain
);
5746 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
5748 case TRUTH_ANDIF_EXPR
:
5749 case TRUTH_ORIF_EXPR
:
5750 case TRUTH_AND_EXPR
:
5752 if (complain
& tf_warning
)
5753 warn_logical_operator (loc
, code
, boolean_type_node
,
5754 code_orig_arg1
, arg1
,
5755 code_orig_arg2
, arg2
);
5763 if ((complain
& tf_warning
)
5764 && ((code_orig_arg1
== BOOLEAN_TYPE
)
5765 ^ (code_orig_arg2
== BOOLEAN_TYPE
)))
5766 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
5767 if (complain
& tf_warning
&& warn_tautological_compare
)
5768 warn_tautological_cmp (loc
, code
, arg1
, arg2
);
5773 case TRUNC_DIV_EXPR
:
5778 case TRUNC_MOD_EXPR
:
5782 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
5784 case UNARY_PLUS_EXPR
:
5787 case TRUTH_NOT_EXPR
:
5788 case PREINCREMENT_EXPR
:
5789 case POSTINCREMENT_EXPR
:
5790 case PREDECREMENT_EXPR
:
5791 case POSTDECREMENT_EXPR
:
5795 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5798 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5801 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
5805 /* The caller will deal with these. */
5817 /* Wrapper for above. */
5820 build_new_op (location_t loc
, enum tree_code code
, int flags
,
5821 tree arg1
, tree arg2
, tree arg3
,
5822 tree
*overload
, tsubst_flags_t complain
)
5825 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5826 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
5827 overload
, complain
);
5828 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5832 /* Returns true if FN has two parameters, of which the second has type
5836 second_parm_is_size_t (tree fn
)
5838 tree t
= FUNCTION_ARG_CHAIN (fn
);
5840 && same_type_p (TREE_VALUE (t
), size_type_node
)
5841 && TREE_CHAIN (t
) == void_list_node
);
5844 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5845 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5848 non_placement_deallocation_fn_p (tree t
)
5850 /* A template instance is never a usual deallocation function,
5851 regardless of its signature. */
5852 if (TREE_CODE (t
) == TEMPLATE_DECL
5853 || primary_template_instantiation_p (t
))
5856 /* If a class T has a member deallocation function named operator delete
5857 with exactly one parameter, then that function is a usual
5858 (non-placement) deallocation function. If class T does not declare
5859 such an operator delete but does declare a member deallocation
5860 function named operator delete with exactly two parameters, the second
5861 of which has type std::size_t (18.2), then this function is a usual
5862 deallocation function. */
5863 bool global
= DECL_NAMESPACE_SCOPE_P (t
);
5864 if (FUNCTION_ARG_CHAIN (t
) == void_list_node
5865 || ((!global
|| flag_sized_deallocation
)
5866 && second_parm_is_size_t (t
)))
5871 /* Build a call to operator delete. This has to be handled very specially,
5872 because the restrictions on what signatures match are different from all
5873 other call instances. For a normal delete, only a delete taking (void *)
5874 or (void *, size_t) is accepted. For a placement delete, only an exact
5875 match with the placement new is accepted.
5877 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5878 ADDR is the pointer to be deleted.
5879 SIZE is the size of the memory block to be deleted.
5880 GLOBAL_P is true if the delete-expression should not consider
5881 class-specific delete operators.
5882 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5884 If this call to "operator delete" is being generated as part to
5885 deallocate memory allocated via a new-expression (as per [expr.new]
5886 which requires that if the initialization throws an exception then
5887 we call a deallocation function), then ALLOC_FN is the allocation
5891 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
5892 bool global_p
, tree placement
,
5893 tree alloc_fn
, tsubst_flags_t complain
)
5895 tree fn
= NULL_TREE
;
5896 tree fns
, fnname
, type
, t
;
5898 if (addr
== error_mark_node
)
5899 return error_mark_node
;
5901 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
5903 fnname
= ansi_opname (code
);
5905 if (CLASS_TYPE_P (type
)
5906 && COMPLETE_TYPE_P (complete_type (type
))
5910 If the result of the lookup is ambiguous or inaccessible, or if
5911 the lookup selects a placement deallocation function, the
5912 program is ill-formed.
5914 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5916 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
5917 if (fns
== error_mark_node
)
5918 return error_mark_node
;
5923 if (fns
== NULL_TREE
)
5924 fns
= lookup_name_nonclass (fnname
);
5926 /* Strip const and volatile from addr. */
5927 addr
= cp_convert (ptr_type_node
, addr
, complain
);
5931 /* "A declaration of a placement deallocation function matches the
5932 declaration of a placement allocation function if it has the same
5933 number of parameters and, after parameter transformations (8.3.5),
5934 all parameter types except the first are identical."
5936 So we build up the function type we want and ask instantiate_type
5937 to get it for us. */
5938 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
5939 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
5940 t
= build_function_type (void_type_node
, t
);
5942 fn
= instantiate_type (t
, fns
, tf_none
);
5943 if (fn
== error_mark_node
)
5946 if (BASELINK_P (fn
))
5947 fn
= BASELINK_FUNCTIONS (fn
);
5949 /* "If the lookup finds the two-parameter form of a usual deallocation
5950 function (3.7.4.2) and that function, considered as a placement
5951 deallocation function, would have been selected as a match for the
5952 allocation function, the program is ill-formed." */
5953 if (second_parm_is_size_t (fn
))
5956 = G_("exception cleanup for this placement new selects "
5957 "non-placement operator delete");
5959 = G_("%qD is a usual (non-placement) deallocation "
5960 "function in C++14 (or with -fsized-deallocation)");
5962 /* But if the class has an operator delete (void *), then that is
5963 the usual deallocation function, so we shouldn't complain
5964 about using the operator delete (void *, size_t). */
5965 if (DECL_CLASS_SCOPE_P (fn
))
5966 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5967 t
; t
= OVL_NEXT (t
))
5969 tree elt
= OVL_CURRENT (t
);
5970 if (non_placement_deallocation_fn_p (elt
)
5971 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
5974 /* Before C++14 a two-parameter global deallocation function is
5975 always a placement deallocation function, but warn if
5977 else if (!flag_sized_deallocation
)
5979 if ((complain
& tf_warning
)
5980 && warning (OPT_Wc__14_compat
, msg1
))
5981 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
5985 if (complain
& tf_warning_or_error
)
5987 if (permerror (input_location
, msg1
))
5989 /* Only mention C++14 for namespace-scope delete. */
5990 if (DECL_NAMESPACE_SCOPE_P (fn
))
5991 inform (DECL_SOURCE_LOCATION (fn
), msg2
, fn
);
5993 inform (DECL_SOURCE_LOCATION (fn
),
5994 "%qD is a usual (non-placement) deallocation "
5999 return error_mark_node
;
6004 /* "Any non-placement deallocation function matches a non-placement
6005 allocation function. If the lookup finds a single matching
6006 deallocation function, that function will be called; otherwise, no
6007 deallocation function will be called." */
6008 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
6009 t
; t
= OVL_NEXT (t
))
6011 tree elt
= OVL_CURRENT (t
);
6012 if (non_placement_deallocation_fn_p (elt
))
6015 /* "If a class T has a member deallocation function named
6016 operator delete with exactly one parameter, then that
6017 function is a usual (non-placement) deallocation
6018 function. If class T does not declare such an operator
6019 delete but does declare a member deallocation function named
6020 operator delete with exactly two parameters, the second of
6021 which has type std::size_t (18.2), then this function is a
6022 usual deallocation function."
6024 So in a class (void*) beats (void*, size_t). */
6025 if (DECL_CLASS_SCOPE_P (fn
))
6027 if (FUNCTION_ARG_CHAIN (fn
) == void_list_node
)
6030 /* At global scope (in C++14 and above) the rules are different:
6032 If deallocation function lookup finds both a usual
6033 deallocation function with only a pointer parameter and a
6034 usual deallocation function with both a pointer parameter
6035 and a size parameter, the function to be called is selected
6038 * If the type is complete and if, for the second alternative
6039 (delete array) only, the operand is a pointer to a class
6040 type with a non-trivial destructor or a (possibly
6041 multi-dimensional) array thereof, the function with two
6042 parameters is selected.
6044 * Otherwise, it is unspecified which of the two deallocation
6045 functions is selected. */
6048 bool want_size
= COMPLETE_TYPE_P (type
);
6049 if (code
== VEC_DELETE_EXPR
6050 && !TYPE_VEC_NEW_USES_COOKIE (type
))
6051 /* We need a cookie to determine the array size. */
6053 bool have_size
= (FUNCTION_ARG_CHAIN (fn
) != void_list_node
);
6054 if (want_size
== have_size
)
6060 /* If we have a matching function, call it. */
6063 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6065 /* If the FN is a member function, make sure that it is
6067 if (BASELINK_P (fns
))
6068 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
6071 /* Core issue 901: It's ok to new a type with deleted delete. */
6072 if (DECL_DELETED_FN (fn
) && alloc_fn
)
6077 /* The placement args might not be suitable for overload
6078 resolution at this point, so build the call directly. */
6079 int nargs
= call_expr_nargs (placement
);
6080 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
6083 for (i
= 1; i
< nargs
; i
++)
6084 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
6085 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6086 return error_mark_node
;
6087 return build_cxx_call (fn
, nargs
, argarray
, complain
);
6092 vec
<tree
, va_gc
> *args
= make_tree_vector ();
6093 args
->quick_push (addr
);
6094 if (FUNCTION_ARG_CHAIN (fn
) != void_list_node
)
6095 args
->quick_push (size
);
6096 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
6097 release_tree_vector (args
);
6104 If no unambiguous matching deallocation function can be found,
6105 propagating the exception does not cause the object's memory to
6109 if ((complain
& tf_warning
)
6111 warning (0, "no corresponding deallocation function for %qD",
6116 if (complain
& tf_error
)
6117 error ("no suitable %<operator %s%> for %qT",
6118 operator_name_info
[(int)code
].name
, type
);
6119 return error_mark_node
;
6122 /* If the current scope isn't allowed to access DECL along
6123 BASETYPE_PATH, give an error. The most derived class in
6124 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
6125 the declaration to use in the error diagnostic. */
6128 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
6129 tsubst_flags_t complain
)
6131 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
6133 if (!accessible_p (basetype_path
, decl
, true))
6135 if (complain
& tf_error
)
6137 if (TREE_PRIVATE (decl
))
6139 error ("%q#D is private within this context", diag_decl
);
6140 inform (DECL_SOURCE_LOCATION (diag_decl
),
6141 "declared private here");
6143 else if (TREE_PROTECTED (decl
))
6145 error ("%q#D is protected within this context", diag_decl
);
6146 inform (DECL_SOURCE_LOCATION (diag_decl
),
6147 "declared protected here");
6151 error ("%q#D is inaccessible within this context", diag_decl
);
6152 inform (DECL_SOURCE_LOCATION (diag_decl
), "declared here");
6161 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
6162 bitwise or of LOOKUP_* values. If any errors are warnings are
6163 generated, set *DIAGNOSTIC_FN to "error" or "warning",
6164 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
6168 build_temp (tree expr
, tree type
, int flags
,
6169 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
6172 vec
<tree
, va_gc
> *args
;
6174 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
6175 args
= make_tree_vector_single (expr
);
6176 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6177 &args
, type
, flags
, complain
);
6178 release_tree_vector (args
);
6179 if (warningcount
+ werrorcount
> savew
)
6180 *diagnostic_kind
= DK_WARNING
;
6181 else if (errorcount
> savee
)
6182 *diagnostic_kind
= DK_ERROR
;
6184 *diagnostic_kind
= DK_UNSPECIFIED
;
6188 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
6189 EXPR is implicitly converted to type TOTYPE.
6190 FN and ARGNUM are used for diagnostics. */
6193 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6195 /* Issue warnings about peculiar, but valid, uses of NULL. */
6196 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
6197 && ARITHMETIC_TYPE_P (totype
))
6199 source_location loc
=
6200 expansion_point_location_if_in_system_header (input_location
);
6203 warning_at (loc
, OPT_Wconversion_null
,
6204 "passing NULL to non-pointer argument %P of %qD",
6207 warning_at (loc
, OPT_Wconversion_null
,
6208 "converting to non-pointer type %qT from NULL", totype
);
6211 /* Issue warnings if "false" is converted to a NULL pointer */
6212 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6213 && TYPE_PTR_P (totype
))
6216 warning_at (input_location
, OPT_Wconversion_null
,
6217 "converting %<false%> to pointer type for argument %P "
6218 "of %qD", argnum
, fn
);
6220 warning_at (input_location
, OPT_Wconversion_null
,
6221 "converting %<false%> to pointer type %qT", totype
);
6225 /* We gave a diagnostic during a conversion. If this was in the second
6226 standard conversion sequence of a user-defined conversion sequence, say
6227 which user-defined conversion. */
6230 maybe_print_user_conv_context (conversion
*convs
)
6232 if (convs
->user_conv_p
)
6233 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6234 if (t
->kind
== ck_user
)
6236 print_z_candidate (0, " after user-defined conversion:",
6242 /* Perform the conversions in CONVS on the expression EXPR. FN and
6243 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6244 indicates the `this' argument of a method. INNER is nonzero when
6245 being called to continue a conversion chain. It is negative when a
6246 reference binding will be applied, positive otherwise. If
6247 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6248 conversions will be emitted if appropriate. If C_CAST_P is true,
6249 this conversion is coming from a C-style cast; in that case,
6250 conversions to inaccessible bases are permitted. */
6253 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6254 int inner
, bool issue_conversion_warnings
,
6255 bool c_cast_p
, tsubst_flags_t complain
)
6257 tree totype
= convs
->type
;
6258 diagnostic_t diag_kind
;
6260 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6262 if (convs
->bad_p
&& !(complain
& tf_error
))
6263 return error_mark_node
;
6266 && convs
->kind
!= ck_user
6267 && convs
->kind
!= ck_list
6268 && convs
->kind
!= ck_ambig
6269 && (convs
->kind
!= ck_ref_bind
6270 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
6271 && (convs
->kind
!= ck_rvalue
6272 || SCALAR_TYPE_P (totype
))
6273 && convs
->kind
!= ck_base
)
6275 bool complained
= false;
6276 conversion
*t
= convs
;
6278 /* Give a helpful error if this is bad because of excess braces. */
6279 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6280 && SCALAR_TYPE_P (totype
)
6281 && CONSTRUCTOR_NELTS (expr
) > 0
6282 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
6284 complained
= permerror (loc
, "too many braces around initializer "
6286 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6287 && CONSTRUCTOR_NELTS (expr
) == 1)
6288 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6291 /* Give a helpful error if this is bad because a conversion to bool
6292 from std::nullptr_t requires direct-initialization. */
6293 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
6294 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
6295 complained
= permerror (loc
, "converting to %qT from %qT requires "
6296 "direct-initialization",
6297 totype
, TREE_TYPE (expr
));
6299 for (; t
; t
= next_conversion (t
))
6301 if (t
->kind
== ck_user
&& t
->cand
->reason
)
6303 complained
= permerror (loc
, "invalid user-defined conversion "
6304 "from %qT to %qT", TREE_TYPE (expr
),
6307 print_z_candidate (loc
, "candidate is:", t
->cand
);
6308 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6309 /*issue_conversion_warnings=*/false,
6312 if (convs
->kind
== ck_ref_bind
)
6313 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
6314 LOOKUP_NORMAL
, NULL_TREE
,
6317 expr
= cp_convert (totype
, expr
, complain
);
6318 if (complained
&& fn
)
6319 inform (DECL_SOURCE_LOCATION (fn
),
6320 " initializing argument %P of %qD", argnum
, fn
);
6323 else if (t
->kind
== ck_user
|| !t
->bad_p
)
6325 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6326 /*issue_conversion_warnings=*/false,
6331 else if (t
->kind
== ck_ambig
)
6332 return convert_like_real (t
, expr
, fn
, argnum
, 1,
6333 /*issue_conversion_warnings=*/false,
6336 else if (t
->kind
== ck_identity
)
6340 complained
= permerror (loc
, "invalid conversion from %qT to %qT",
6341 TREE_TYPE (expr
), totype
);
6342 if (complained
&& fn
)
6343 inform (DECL_SOURCE_LOCATION (fn
),
6344 " initializing argument %P of %qD", argnum
, fn
);
6346 return cp_convert (totype
, expr
, complain
);
6349 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6350 conversion_null_warnings (totype
, expr
, fn
, argnum
);
6352 switch (convs
->kind
)
6356 struct z_candidate
*cand
= convs
->cand
;
6357 tree convfn
= cand
->fn
;
6360 /* When converting from an init list we consider explicit
6361 constructors, but actually trying to call one is an error. */
6362 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
6363 /* Unless this is for direct-list-initialization. */
6364 && !DIRECT_LIST_INIT_P (expr
)
6365 /* And in C++98 a default constructor can't be explicit. */
6366 && cxx_dialect
>= cxx11
)
6368 if (!(complain
& tf_error
))
6369 return error_mark_node
;
6370 location_t loc
= location_of (expr
);
6371 if (CONSTRUCTOR_NELTS (expr
) == 0
6372 && FUNCTION_FIRST_USER_PARMTYPE (convfn
) != void_list_node
)
6374 if (pedwarn (loc
, 0, "converting to %qT from initializer list "
6375 "would use explicit constructor %qD",
6377 inform (loc
, "in C++11 and above a default constructor "
6381 error ("converting to %qT from initializer list would use "
6382 "explicit constructor %qD", totype
, convfn
);
6385 /* If we're initializing from {}, it's value-initialization. */
6386 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6387 && CONSTRUCTOR_NELTS (expr
) == 0
6388 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
6390 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
6391 expr
= build_value_init (totype
, complain
);
6392 expr
= get_target_expr_sfinae (expr
, complain
);
6393 if (expr
!= error_mark_node
)
6395 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6396 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
6401 expr
= mark_rvalue_use (expr
);
6403 /* Set user_conv_p on the argument conversions, so rvalue/base
6404 handling knows not to allow any more UDCs. */
6405 for (i
= 0; i
< cand
->num_convs
; ++i
)
6406 cand
->convs
[i
]->user_conv_p
= true;
6408 expr
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
6410 /* If this is a constructor or a function returning an aggr type,
6411 we need to build up a TARGET_EXPR. */
6412 if (DECL_CONSTRUCTOR_P (convfn
))
6414 expr
= build_cplus_new (totype
, expr
, complain
);
6416 /* Remember that this was list-initialization. */
6417 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
6418 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6424 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
6426 int nelts
= CONSTRUCTOR_NELTS (expr
);
6428 expr
= build_value_init (totype
, complain
);
6429 else if (nelts
== 1)
6430 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6434 expr
= mark_rvalue_use (expr
);
6436 if (type_unknown_p (expr
))
6437 expr
= instantiate_type (totype
, expr
, complain
);
6438 /* Convert a constant to its underlying value, unless we are
6439 about to bind it to a reference, in which case we need to
6440 leave it as an lvalue. */
6443 expr
= scalar_constant_value (expr
);
6444 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
6445 /* If __null has been converted to an integer type, we do not
6446 want to warn about uses of EXPR as an integer, rather than
6448 expr
= build_int_cst (totype
, 0);
6452 /* We leave bad_p off ck_ambig because overload resolution considers
6453 it valid, it just fails when we try to perform it. So we need to
6454 check complain here, too. */
6455 if (complain
& tf_error
)
6457 /* Call build_user_type_conversion again for the error. */
6458 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
6461 inform (DECL_SOURCE_LOCATION (fn
),
6462 " initializing argument %P of %qD", argnum
, fn
);
6464 return error_mark_node
;
6468 /* Conversion to std::initializer_list<T>. */
6469 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
6470 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
6471 unsigned len
= CONSTRUCTOR_NELTS (expr
);
6472 tree array
, val
, field
;
6473 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6476 /* Convert all the elements. */
6477 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
6479 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
6480 1, false, false, complain
);
6481 if (sub
== error_mark_node
)
6483 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
6484 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
6485 return error_mark_node
;
6486 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
6487 if (!TREE_CONSTANT (sub
))
6488 TREE_CONSTANT (new_ctor
) = false;
6490 /* Build up the array. */
6491 elttype
= cp_build_qualified_type
6492 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
6493 array
= build_array_of_n_type (elttype
, len
);
6494 array
= finish_compound_literal (array
, new_ctor
, complain
);
6495 /* Take the address explicitly rather than via decay_conversion
6496 to avoid the error about taking the address of a temporary. */
6497 array
= cp_build_addr_expr (array
, complain
);
6498 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
6499 if (array
== error_mark_node
)
6500 return error_mark_node
;
6502 /* Build up the initializer_list object. */
6503 totype
= complete_type (totype
);
6504 field
= next_initializable_field (TYPE_FIELDS (totype
));
6505 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6506 field
= next_initializable_field (DECL_CHAIN (field
));
6507 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6508 new_ctor
= build_constructor (totype
, vec
);
6509 return get_target_expr_sfinae (new_ctor
, complain
);
6513 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6515 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6516 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6517 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6519 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6521 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6524 expr
= reshape_init (totype
, expr
, complain
);
6525 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6527 if (expr
!= error_mark_node
)
6528 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6535 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6536 convs
->kind
== ck_ref_bind
? -1 : 1,
6537 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6540 if (expr
== error_mark_node
)
6541 return error_mark_node
;
6543 switch (convs
->kind
)
6546 expr
= decay_conversion (expr
, complain
);
6547 if (expr
== error_mark_node
)
6551 maybe_print_user_conv_context (convs
);
6553 inform (DECL_SOURCE_LOCATION (fn
),
6554 " initializing argument %P of %qD", argnum
, fn
);
6556 return error_mark_node
;
6559 if (! MAYBE_CLASS_TYPE_P (totype
))
6561 /* Else fall through. */
6563 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6565 /* We are going to bind a reference directly to a base-class
6566 subobject of EXPR. */
6567 /* Build an expression for `*((base*) &expr)'. */
6568 expr
= convert_to_base (expr
, totype
,
6569 !c_cast_p
, /*nonnull=*/true, complain
);
6573 /* Copy-initialization where the cv-unqualified version of the source
6574 type is the same class as, or a derived class of, the class of the
6575 destination [is treated as direct-initialization]. [dcl.init] */
6576 flags
= LOOKUP_NORMAL
;
6577 if (convs
->user_conv_p
)
6578 /* This conversion is being done in the context of a user-defined
6579 conversion (i.e. the second step of copy-initialization), so
6580 don't allow any more. */
6581 flags
|= LOOKUP_NO_CONVERSION
;
6583 flags
|= LOOKUP_ONLYCONVERTING
;
6584 if (convs
->rvaluedness_matches_p
)
6585 flags
|= LOOKUP_PREFER_RVALUE
;
6586 if (TREE_CODE (expr
) == TARGET_EXPR
6587 && TARGET_EXPR_LIST_INIT_P (expr
))
6588 /* Copy-list-initialization doesn't actually involve a copy. */
6590 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6591 if (diag_kind
&& complain
)
6593 maybe_print_user_conv_context (convs
);
6595 inform (DECL_SOURCE_LOCATION (fn
),
6596 " initializing argument %P of %qD", argnum
, fn
);
6599 return build_cplus_new (totype
, expr
, complain
);
6603 tree ref_type
= totype
;
6605 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6607 tree extype
= TREE_TYPE (expr
);
6608 if (TYPE_REF_IS_RVALUE (ref_type
)
6609 && real_lvalue_p (expr
))
6610 error_at (loc
, "cannot bind %qT lvalue to %qT",
6612 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !real_lvalue_p (expr
)
6613 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
6614 error_at (loc
, "invalid initialization of non-const reference of "
6615 "type %qT from an rvalue of type %qT", totype
, extype
);
6616 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
6617 error_at (loc
, "binding %qT to reference of type %qT "
6618 "discards qualifiers", extype
, totype
);
6621 maybe_print_user_conv_context (convs
);
6623 inform (DECL_SOURCE_LOCATION (fn
),
6624 " initializing argument %P of %qD", argnum
, fn
);
6625 return error_mark_node
;
6628 /* If necessary, create a temporary.
6630 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6631 that need temporaries, even when their types are reference
6632 compatible with the type of reference being bound, so the
6633 upcoming call to cp_build_addr_expr doesn't fail. */
6634 if (convs
->need_temporary_p
6635 || TREE_CODE (expr
) == CONSTRUCTOR
6636 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6638 /* Otherwise, a temporary of type "cv1 T1" is created and
6639 initialized from the initializer expression using the rules
6640 for a non-reference copy-initialization (8.5). */
6642 tree type
= TREE_TYPE (ref_type
);
6643 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
6645 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6646 (type
, next_conversion (convs
)->type
));
6647 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6648 && !TYPE_REF_IS_RVALUE (ref_type
))
6650 /* If the reference is volatile or non-const, we
6651 cannot create a temporary. */
6652 if (lvalue
& clk_bitfield
)
6653 error_at (loc
, "cannot bind bitfield %qE to %qT",
6655 else if (lvalue
& clk_packed
)
6656 error_at (loc
, "cannot bind packed field %qE to %qT",
6659 error_at (loc
, "cannot bind rvalue %qE to %qT",
6661 return error_mark_node
;
6663 /* If the source is a packed field, and we must use a copy
6664 constructor, then building the target expr will require
6665 binding the field to the reference parameter to the
6666 copy constructor, and we'll end up with an infinite
6667 loop. If we can use a bitwise copy, then we'll be
6669 if ((lvalue
& clk_packed
)
6670 && CLASS_TYPE_P (type
)
6671 && type_has_nontrivial_copy_init (type
))
6673 error_at (loc
, "cannot bind packed field %qE to %qT",
6675 return error_mark_node
;
6677 if (lvalue
& clk_bitfield
)
6679 expr
= convert_bitfield_to_declared_type (expr
);
6680 expr
= fold_convert (type
, expr
);
6682 expr
= build_target_expr_with_type (expr
, type
, complain
);
6685 /* Take the address of the thing to which we will bind the
6687 expr
= cp_build_addr_expr (expr
, complain
);
6688 if (expr
== error_mark_node
)
6689 return error_mark_node
;
6691 /* Convert it to a pointer to the type referred to by the
6692 reference. This will adjust the pointer if a derived to
6693 base conversion is being performed. */
6694 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
6696 /* Convert the pointer to the desired reference type. */
6697 return build_nop (ref_type
, expr
);
6701 return decay_conversion (expr
, complain
);
6704 /* ??? Should the address of a transaction-safe pointer point to the TM
6705 clone, and this conversion look up the primary function? */
6706 return build_nop (totype
, expr
);
6709 /* Warn about deprecated conversion if appropriate. */
6710 string_conv_p (totype
, expr
, 1);
6715 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
6716 /*nonnull=*/false, complain
);
6717 return build_nop (totype
, expr
);
6720 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
6721 c_cast_p
, complain
);
6727 if (convs
->check_narrowing
6728 && !check_narrowing (totype
, expr
, complain
))
6729 return error_mark_node
;
6731 if (issue_conversion_warnings
)
6732 expr
= cp_convert_and_check (totype
, expr
, complain
);
6734 expr
= cp_convert (totype
, expr
, complain
);
6739 /* ARG is being passed to a varargs function. Perform any conversions
6740 required. Return the converted value. */
6743 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
6746 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
6750 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6751 standard conversions are performed. */
6752 arg
= decay_conversion (arg
, complain
);
6753 arg_type
= TREE_TYPE (arg
);
6756 If the argument has integral or enumeration type that is subject
6757 to the integral promotions (_conv.prom_), or a floating point
6758 type that is subject to the floating point promotion
6759 (_conv.fpprom_), the value of the argument is converted to the
6760 promoted type before the call. */
6761 if (TREE_CODE (arg_type
) == REAL_TYPE
6762 && (TYPE_PRECISION (arg_type
)
6763 < TYPE_PRECISION (double_type_node
))
6764 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
6766 if ((complain
& tf_warning
)
6767 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
6768 warning_at (loc
, OPT_Wdouble_promotion
,
6769 "implicit conversion from %qT to %qT when passing "
6770 "argument to function",
6771 arg_type
, double_type_node
);
6772 arg
= convert_to_real_nofold (double_type_node
, arg
);
6774 else if (NULLPTR_TYPE_P (arg_type
))
6775 arg
= null_pointer_node
;
6776 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
6778 if (SCOPED_ENUM_P (arg_type
))
6780 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
6782 prom
= cp_perform_integral_promotions (prom
, complain
);
6783 if (abi_version_crosses (6)
6784 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
6785 && (complain
& tf_warning
))
6786 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through ... as "
6787 "%qT before -fabi-version=6, %qT after", arg_type
,
6788 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
6789 if (!abi_version_at_least (6))
6793 arg
= cp_perform_integral_promotions (arg
, complain
);
6796 arg
= require_complete_type_sfinae (arg
, complain
);
6797 arg_type
= TREE_TYPE (arg
);
6799 if (arg
!= error_mark_node
6800 /* In a template (or ill-formed code), we can have an incomplete type
6801 even after require_complete_type_sfinae, in which case we don't know
6802 whether it has trivial copy or not. */
6803 && COMPLETE_TYPE_P (arg_type
))
6805 /* Build up a real lvalue-to-rvalue conversion in case the
6806 copy constructor is trivial but not callable. */
6807 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
6808 force_rvalue (arg
, complain
);
6810 /* [expr.call] 5.2.2/7:
6811 Passing a potentially-evaluated argument of class type (Clause 9)
6812 with a non-trivial copy constructor or a non-trivial destructor
6813 with no corresponding parameter is conditionally-supported, with
6814 implementation-defined semantics.
6816 We support it as pass-by-invisible-reference, just like a normal
6819 If the call appears in the context of a sizeof expression,
6820 it is not potentially-evaluated. */
6821 if (cp_unevaluated_operand
== 0
6822 && (type_has_nontrivial_copy_init (arg_type
)
6823 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
6825 if (complain
& tf_warning
)
6826 warning (OPT_Wconditionally_supported
,
6827 "passing objects of non-trivially-copyable "
6828 "type %q#T through %<...%> is conditionally supported",
6830 return cp_build_addr_expr (arg
, complain
);
6837 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6840 build_x_va_arg (source_location loc
, tree expr
, tree type
)
6842 if (processing_template_decl
)
6844 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
6845 SET_EXPR_LOCATION (r
, loc
);
6849 type
= complete_type_or_else (type
, NULL_TREE
);
6851 if (expr
== error_mark_node
|| !type
)
6852 return error_mark_node
;
6854 expr
= mark_lvalue_use (expr
);
6856 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6858 error ("cannot receive reference type %qT through %<...%>", type
);
6859 return error_mark_node
;
6862 if (type_has_nontrivial_copy_init (type
)
6863 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6865 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
6866 it as pass by invisible reference. */
6867 warning_at (loc
, OPT_Wconditionally_supported
,
6868 "receiving objects of non-trivially-copyable type %q#T "
6869 "through %<...%> is conditionally-supported", type
);
6871 tree ref
= cp_build_reference_type (type
, false);
6872 expr
= build_va_arg (loc
, expr
, ref
);
6873 return convert_from_reference (expr
);
6876 return build_va_arg (loc
, expr
, type
);
6879 /* TYPE has been given to va_arg. Apply the default conversions which
6880 would have happened when passed via ellipsis. Return the promoted
6881 type, or the passed type if there is no change. */
6884 cxx_type_promotes_to (tree type
)
6888 /* Perform the array-to-pointer and function-to-pointer
6890 type
= type_decays_to (type
);
6892 promote
= type_promotes_to (type
);
6893 if (same_type_p (type
, promote
))
6899 /* ARG is a default argument expression being passed to a parameter of
6900 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6901 zero-based argument number. Do any required conversions. Return
6902 the converted value. */
6904 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
6906 push_defarg_context (tree fn
)
6907 { vec_safe_push (default_arg_context
, fn
); }
6910 pop_defarg_context (void)
6911 { default_arg_context
->pop (); }
6914 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
6915 tsubst_flags_t complain
)
6920 /* See through clones. */
6921 fn
= DECL_ORIGIN (fn
);
6923 /* Detect recursion. */
6924 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
6927 if (complain
& tf_error
)
6928 error ("recursive evaluation of default argument for %q#D", fn
);
6929 return error_mark_node
;
6932 /* If the ARG is an unparsed default argument expression, the
6933 conversion cannot be performed. */
6934 if (TREE_CODE (arg
) == DEFAULT_ARG
)
6936 if (complain
& tf_error
)
6937 error ("call to %qD uses the default argument for parameter %P, which "
6938 "is not yet defined", fn
, parmnum
);
6939 return error_mark_node
;
6942 push_defarg_context (fn
);
6944 if (fn
&& DECL_TEMPLATE_INFO (fn
))
6945 arg
= tsubst_default_argument (fn
, type
, arg
, complain
);
6951 The names in the expression are bound, and the semantic
6952 constraints are checked, at the point where the default
6953 expressions appears.
6955 we must not perform access checks here. */
6956 push_deferring_access_checks (dk_no_check
);
6957 /* We must make a copy of ARG, in case subsequent processing
6958 alters any part of it. */
6959 arg
= break_out_target_exprs (arg
);
6960 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6961 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6963 arg
= convert_for_arg_passing (type
, arg
, complain
);
6964 pop_deferring_access_checks();
6966 pop_defarg_context ();
6971 /* Returns the type which will really be used for passing an argument of
6975 type_passed_as (tree type
)
6977 /* Pass classes with copy ctors by invisible reference. */
6978 if (TREE_ADDRESSABLE (type
))
6980 type
= build_reference_type (type
);
6981 /* There are no other pointers to this temporary. */
6982 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
6984 else if (targetm
.calls
.promote_prototypes (type
)
6985 && INTEGRAL_TYPE_P (type
)
6986 && COMPLETE_TYPE_P (type
)
6987 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6988 type
= integer_type_node
;
6993 /* Actually perform the appropriate conversion. */
6996 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
7000 /* If VAL is a bitfield, then -- since it has already been converted
7001 to TYPE -- it cannot have a precision greater than TYPE.
7003 If it has a smaller precision, we must widen it here. For
7004 example, passing "int f:3;" to a function expecting an "int" will
7005 not result in any conversion before this point.
7007 If the precision is the same we must not risk widening. For
7008 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
7009 often have type "int", even though the C++ type for the field is
7010 "long long". If the value is being passed to a function
7011 expecting an "int", then no conversions will be required. But,
7012 if we call convert_bitfield_to_declared_type, the bitfield will
7013 be converted to "long long". */
7014 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
7016 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
7017 val
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
), val
);
7019 if (val
== error_mark_node
)
7021 /* Pass classes with copy ctors by invisible reference. */
7022 else if (TREE_ADDRESSABLE (type
))
7023 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
7024 else if (targetm
.calls
.promote_prototypes (type
)
7025 && INTEGRAL_TYPE_P (type
)
7026 && COMPLETE_TYPE_P (type
)
7027 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
7028 val
= cp_perform_integral_promotions (val
, complain
);
7029 if ((complain
& tf_warning
)
7030 && warn_suggest_attribute_format
)
7032 tree rhstype
= TREE_TYPE (val
);
7033 const enum tree_code coder
= TREE_CODE (rhstype
);
7034 const enum tree_code codel
= TREE_CODE (type
);
7035 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
7037 && check_missing_format_attribute (type
, rhstype
))
7038 warning (OPT_Wsuggest_attribute_format
,
7039 "argument of function call might be a candidate for a format attribute");
7044 /* Returns non-zero iff FN is a function with magic varargs, i.e. ones for
7045 which just decay_conversion or no conversions at all should be done.
7046 This is true for some builtins which don't act like normal functions.
7047 Return 2 if no conversions at all should be done, 1 if just
7048 decay_conversion. */
7051 magic_varargs_p (tree fn
)
7053 if (flag_cilkplus
&& is_cilkplus_reduce_builtin (fn
) != BUILT_IN_NONE
)
7056 if (DECL_BUILT_IN (fn
))
7057 switch (DECL_FUNCTION_CODE (fn
))
7059 case BUILT_IN_CLASSIFY_TYPE
:
7060 case BUILT_IN_CONSTANT_P
:
7061 case BUILT_IN_NEXT_ARG
:
7062 case BUILT_IN_VA_START
:
7066 return lookup_attribute ("type generic",
7067 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
7073 /* Returns the decl of the dispatcher function if FN is a function version. */
7076 get_function_version_dispatcher (tree fn
)
7078 tree dispatcher_decl
= NULL
;
7080 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
7081 && DECL_FUNCTION_VERSIONED (fn
));
7083 gcc_assert (targetm
.get_function_versions_dispatcher
);
7084 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
7086 if (dispatcher_decl
== NULL
)
7088 error_at (input_location
, "use of multiversioned function "
7089 "without a default");
7093 retrofit_lang_decl (dispatcher_decl
);
7094 gcc_assert (dispatcher_decl
!= NULL
);
7095 return dispatcher_decl
;
7098 /* fn is a function version dispatcher that is marked used. Mark all the
7099 semantically identical function versions it will dispatch as used. */
7102 mark_versions_used (tree fn
)
7104 struct cgraph_node
*node
;
7105 struct cgraph_function_version_info
*node_v
;
7106 struct cgraph_function_version_info
*it_v
;
7108 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
7110 node
= cgraph_node::get (fn
);
7114 gcc_assert (node
->dispatcher_function
);
7116 node_v
= node
->function_version ();
7120 /* All semantically identical versions are chained. Traverse and mark each
7121 one of them as used. */
7122 it_v
= node_v
->next
;
7123 while (it_v
!= NULL
)
7125 mark_used (it_v
->this_node
->decl
);
7130 /* Build a call to "the copy constructor" for the type of A, even if it
7131 wouldn't be selected by normal overload resolution. Used for
7135 call_copy_ctor (tree a
, tsubst_flags_t complain
)
7137 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
7138 tree binfo
= TYPE_BINFO (ctype
);
7139 tree copy
= get_copy_ctor (ctype
, complain
);
7140 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
7141 tree ob
= build_dummy_object (ctype
);
7142 vec
<tree
, va_gc
>* args
= make_tree_vector_single (a
);
7143 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
7144 LOOKUP_NORMAL
, NULL
, complain
);
7145 release_tree_vector (args
);
7149 /* Return true iff T refers to a base field. */
7152 is_base_field_ref (tree t
)
7155 if (TREE_CODE (t
) == ADDR_EXPR
)
7156 t
= TREE_OPERAND (t
, 0);
7157 if (TREE_CODE (t
) == COMPONENT_REF
)
7158 t
= TREE_OPERAND (t
, 1);
7159 if (TREE_CODE (t
) == FIELD_DECL
)
7160 return DECL_FIELD_IS_BASE (t
);
7164 /* We can't elide a copy from a function returning by value to a base
7165 subobject, as the callee might clobber tail padding. Return true iff this
7166 could be that case. */
7169 unsafe_copy_elision_p (tree target
, tree exp
)
7171 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
7172 if (type
== CLASSTYPE_AS_BASE (type
))
7174 if (!is_base_field_ref (target
)
7175 && resolves_to_fixed_type_p (target
, NULL
))
7177 tree init
= TARGET_EXPR_INITIAL (exp
);
7178 /* build_compound_expr pushes COMPOUND_EXPR inside TARGET_EXPR. */
7179 while (TREE_CODE (init
) == COMPOUND_EXPR
)
7180 init
= TREE_OPERAND (init
, 1);
7181 return (TREE_CODE (init
) == AGGR_INIT_EXPR
7182 && !AGGR_INIT_VIA_CTOR_P (init
));
7185 /* Subroutine of the various build_*_call functions. Overload resolution
7186 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
7187 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
7188 bitmask of various LOOKUP_* flags which apply to the call itself. */
7191 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
7194 const vec
<tree
, va_gc
> *args
= cand
->args
;
7195 tree first_arg
= cand
->first_arg
;
7196 conversion
**convs
= cand
->convs
;
7198 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7203 unsigned int arg_index
= 0;
7207 bool already_used
= false;
7209 /* In a template, there is no need to perform all of the work that
7210 is normally done. We are only interested in the type of the call
7211 expression, i.e., the return type of the function. Any semantic
7212 errors will be deferred until the template is instantiated. */
7213 if (processing_template_decl
)
7217 const tree
*argarray
;
7220 return_type
= TREE_TYPE (TREE_TYPE (fn
));
7221 nargs
= vec_safe_length (args
);
7222 if (first_arg
== NULL_TREE
)
7223 argarray
= args
->address ();
7231 alcarray
= XALLOCAVEC (tree
, nargs
);
7232 alcarray
[0] = build_this (first_arg
);
7233 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
7234 alcarray
[ix
+ 1] = arg
;
7235 argarray
= alcarray
;
7238 addr
= build_addr_func (fn
, complain
);
7239 if (addr
== error_mark_node
)
7240 return error_mark_node
;
7241 expr
= build_call_array_loc (input_location
, return_type
,
7242 addr
, nargs
, argarray
);
7243 if (TREE_THIS_VOLATILE (fn
) && cfun
)
7244 current_function_returns_abnormally
= 1;
7245 return convert_from_reference (expr
);
7248 /* Give any warnings we noticed during overload resolution. */
7249 if (cand
->warnings
&& (complain
& tf_warning
))
7251 struct candidate_warning
*w
;
7252 for (w
= cand
->warnings
; w
; w
= w
->next
)
7253 joust (cand
, w
->loser
, 1, complain
);
7256 /* Make =delete work with SFINAE. */
7257 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7258 return error_mark_node
;
7260 if (DECL_FUNCTION_MEMBER_P (fn
))
7263 /* If FN is a template function, two cases must be considered.
7268 template <class T> void f();
7270 template <class T> struct B {
7274 struct C : A, B<int> {
7276 using B<int>::g; // #2
7279 In case #1 where `A::f' is a member template, DECL_ACCESS is
7280 recorded in the primary template but not in its specialization.
7281 We check access of FN using its primary template.
7283 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
7284 because it is a member of class template B, DECL_ACCESS is
7285 recorded in the specialization `B<int>::g'. We cannot use its
7286 primary template because `B<T>::g' and `B<int>::g' may have
7287 different access. */
7288 if (DECL_TEMPLATE_INFO (fn
)
7289 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
7290 access_fn
= DECL_TI_TEMPLATE (fn
);
7293 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
7295 return error_mark_node
;
7298 /* If we're checking for implicit delete, don't bother with argument
7300 if (flags
& LOOKUP_SPECULATIVE
)
7302 if (DECL_DELETED_FN (fn
))
7304 if (complain
& tf_error
)
7306 return error_mark_node
;
7308 if (cand
->viable
== 1)
7310 else if (!(complain
& tf_error
))
7311 /* Reject bad conversions now. */
7312 return error_mark_node
;
7313 /* else continue to get conversion error. */
7316 /* N3276 magic doesn't apply to nested calls. */
7317 int decltype_flag
= (complain
& tf_decltype
);
7318 complain
&= ~tf_decltype
;
7320 /* Find maximum size of vector to hold converted arguments. */
7321 parmlen
= list_length (parm
);
7322 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
7323 if (parmlen
> nargs
)
7325 argarray
= XALLOCAVEC (tree
, nargs
);
7327 /* The implicit parameters to a constructor are not considered by overload
7328 resolution, and must be of the proper type. */
7329 if (DECL_CONSTRUCTOR_P (fn
))
7332 if (first_arg
!= NULL_TREE
)
7334 object_arg
= first_arg
;
7335 first_arg
= NULL_TREE
;
7339 object_arg
= (*args
)[arg_index
];
7342 argarray
[j
++] = build_this (object_arg
);
7343 parm
= TREE_CHAIN (parm
);
7344 /* We should never try to call the abstract constructor. */
7345 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
7347 if (DECL_HAS_VTT_PARM_P (fn
))
7349 argarray
[j
++] = (*args
)[arg_index
];
7351 parm
= TREE_CHAIN (parm
);
7354 /* Bypass access control for 'this' parameter. */
7355 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7357 tree parmtype
= TREE_VALUE (parm
);
7358 tree arg
= build_this (first_arg
!= NULL_TREE
7360 : (*args
)[arg_index
]);
7361 tree argtype
= TREE_TYPE (arg
);
7365 if (convs
[i
]->bad_p
)
7367 if (complain
& tf_error
)
7369 if (permerror (input_location
, "passing %qT as %<this%> "
7370 "argument discards qualifiers",
7371 TREE_TYPE (argtype
)))
7372 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
7375 return error_mark_node
;
7378 /* See if the function member or the whole class type is declared
7379 final and the call can be devirtualized. */
7380 if (DECL_FINAL_P (fn
)
7381 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
7382 flags
|= LOOKUP_NONVIRTUAL
;
7384 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
7385 X is called for an object that is not of type X, or of a type
7386 derived from X, the behavior is undefined.
7388 So we can assume that anything passed as 'this' is non-null, and
7389 optimize accordingly. */
7390 gcc_assert (TYPE_PTR_P (parmtype
));
7391 /* Convert to the base in which the function was declared. */
7392 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
7393 converted_arg
= build_base_path (PLUS_EXPR
,
7395 cand
->conversion_path
,
7397 /* Check that the base class is accessible. */
7398 if (!accessible_base_p (TREE_TYPE (argtype
),
7399 BINFO_TYPE (cand
->conversion_path
), true))
7401 if (complain
& tf_error
)
7402 error ("%qT is not an accessible base of %qT",
7403 BINFO_TYPE (cand
->conversion_path
),
7404 TREE_TYPE (argtype
));
7406 return error_mark_node
;
7408 /* If fn was found by a using declaration, the conversion path
7409 will be to the derived class, not the base declaring fn. We
7410 must convert from derived to base. */
7411 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
7412 TREE_TYPE (parmtype
), ba_unique
,
7414 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
7415 base_binfo
, 1, complain
);
7417 argarray
[j
++] = converted_arg
;
7418 parm
= TREE_CHAIN (parm
);
7419 if (first_arg
!= NULL_TREE
)
7420 first_arg
= NULL_TREE
;
7427 gcc_assert (first_arg
== NULL_TREE
);
7428 for (; arg_index
< vec_safe_length (args
) && parm
;
7429 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
7431 tree type
= TREE_VALUE (parm
);
7432 tree arg
= (*args
)[arg_index
];
7433 bool conversion_warning
= true;
7437 /* If the argument is NULL and used to (implicitly) instantiate a
7438 template function (and bind one of the template arguments to
7439 the type of 'long int'), we don't want to warn about passing NULL
7440 to non-pointer argument.
7441 For example, if we have this template function:
7443 template<typename T> void func(T x) {}
7445 we want to warn (when -Wconversion is enabled) in this case:
7451 but not in this case:
7457 if (arg
== null_node
7458 && DECL_TEMPLATE_INFO (fn
)
7459 && cand
->template_decl
7460 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
7461 conversion_warning
= false;
7463 /* Warn about initializer_list deduction that isn't currently in the
7465 if (cxx_dialect
> cxx98
7466 && flag_deduce_init_list
7467 && cand
->template_decl
7468 && is_std_init_list (non_reference (type
))
7469 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
7471 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
7472 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
7473 tree patparm
= get_pattern_parm (realparm
, tmpl
);
7474 tree pattype
= TREE_TYPE (patparm
);
7475 if (PACK_EXPANSION_P (pattype
))
7476 pattype
= PACK_EXPANSION_PATTERN (pattype
);
7477 pattype
= non_reference (pattype
);
7479 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
7480 && (cand
->explicit_targs
== NULL_TREE
7481 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
7482 <= TEMPLATE_TYPE_IDX (pattype
))))
7484 pedwarn (input_location
, 0, "deducing %qT as %qT",
7485 non_reference (TREE_TYPE (patparm
)),
7486 non_reference (type
));
7487 pedwarn (DECL_SOURCE_LOCATION (cand
->fn
), 0,
7488 " in call to %qD", cand
->fn
);
7489 pedwarn (input_location
, 0,
7490 " (you can disable this with -fno-deduce-init-list)");
7493 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
7496 : complain
& (~tf_warning
));
7498 val
= convert_for_arg_passing (type
, val
, complain
);
7500 if (val
== error_mark_node
)
7501 return error_mark_node
;
7503 argarray
[j
++] = val
;
7506 /* Default arguments */
7507 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
7509 if (TREE_VALUE (parm
) == error_mark_node
)
7510 return error_mark_node
;
7511 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
7512 TREE_PURPOSE (parm
),
7518 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
7520 tree a
= (*args
)[arg_index
];
7521 int magic
= magic_varargs_p (fn
);
7524 /* Do no conversions for certain magic varargs. */
7525 a
= mark_type_use (a
);
7526 if (TREE_CODE (a
) == FUNCTION_DECL
&& reject_gcc_builtin (a
))
7527 return error_mark_node
;
7529 else if (magic
== 1)
7530 /* For other magic varargs only do decay_conversion. */
7531 a
= decay_conversion (a
, complain
);
7532 else if (DECL_CONSTRUCTOR_P (fn
)
7533 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
7536 /* Avoid infinite recursion trying to call A(...). */
7537 if (complain
& tf_error
)
7538 /* Try to call the actual copy constructor for a good error. */
7539 call_copy_ctor (a
, complain
);
7540 return error_mark_node
;
7543 a
= convert_arg_to_ellipsis (a
, complain
);
7544 if (a
== error_mark_node
)
7545 return error_mark_node
;
7549 gcc_assert (j
<= nargs
);
7552 /* Avoid to do argument-transformation, if warnings for format, and for
7553 nonnull are disabled. Just in case that at least one of them is active
7554 the check_function_arguments function might warn about something. */
7556 if (warn_nonnull
|| warn_format
|| warn_suggest_attribute_format
)
7558 tree
*fargs
= (!nargs
? argarray
7559 : (tree
*) alloca (nargs
* sizeof (tree
)));
7560 for (j
= 0; j
< nargs
; j
++)
7561 fargs
[j
] = maybe_constant_value (argarray
[j
]);
7563 check_function_arguments (input_location
, TREE_TYPE (fn
), nargs
, fargs
);
7566 /* Avoid actually calling copy constructors and copy assignment operators,
7569 if (! flag_elide_constructors
)
7570 /* Do things the hard way. */;
7571 else if (cand
->num_convs
== 1
7572 && (DECL_COPY_CONSTRUCTOR_P (fn
)
7573 || DECL_MOVE_CONSTRUCTOR_P (fn
))
7574 /* It's unsafe to elide the constructor when handling
7575 a noexcept-expression, it may evaluate to the wrong
7576 value (c++/53025). */
7577 && cp_noexcept_operand
== 0)
7580 tree arg
= argarray
[num_artificial_parms_for (fn
)];
7582 bool trivial
= trivial_fn_p (fn
);
7584 /* Pull out the real argument, disregarding const-correctness. */
7586 while (CONVERT_EXPR_P (targ
)
7587 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
7588 targ
= TREE_OPERAND (targ
, 0);
7589 if (TREE_CODE (targ
) == ADDR_EXPR
)
7591 targ
= TREE_OPERAND (targ
, 0);
7592 if (!same_type_ignoring_top_level_qualifiers_p
7593 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
7602 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7604 /* [class.copy]: the copy constructor is implicitly defined even if
7605 the implementation elided its use. */
7606 if (!trivial
|| DECL_DELETED_FN (fn
))
7608 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7609 return error_mark_node
;
7610 already_used
= true;
7613 /* If we're creating a temp and we already have one, don't create a
7614 new one. If we're not creating a temp but we get one, use
7615 INIT_EXPR to collapse the temp into our target. Otherwise, if the
7616 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
7617 temp or an INIT_EXPR otherwise. */
7619 if (is_dummy_object (fa
))
7621 if (TREE_CODE (arg
) == TARGET_EXPR
)
7624 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
7627 || (TREE_CODE (arg
) == TARGET_EXPR
7628 && !unsafe_copy_elision_p (fa
, arg
)))
7630 tree to
= stabilize_reference (cp_build_indirect_ref (fa
, RO_NULL
,
7633 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
7637 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
7638 && trivial_fn_p (fn
)
7639 && !DECL_DELETED_FN (fn
))
7641 tree to
= stabilize_reference
7642 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
7643 tree type
= TREE_TYPE (to
);
7644 tree as_base
= CLASSTYPE_AS_BASE (type
);
7645 tree arg
= argarray
[1];
7647 if (is_really_empty_class (type
))
7649 /* Avoid copying empty classes. */
7650 val
= build2 (COMPOUND_EXPR
, void_type_node
, to
, arg
);
7651 TREE_NO_WARNING (val
) = 1;
7652 val
= build2 (COMPOUND_EXPR
, type
, val
, to
);
7653 TREE_NO_WARNING (val
) = 1;
7655 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
7657 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7658 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
7662 /* We must only copy the non-tail padding parts. */
7664 tree array_type
, alias_set
;
7666 arg2
= TYPE_SIZE_UNIT (as_base
);
7667 arg0
= cp_build_addr_expr (to
, complain
);
7669 array_type
= build_array_type (char_type_node
,
7671 (size_binop (MINUS_EXPR
,
7672 arg2
, size_int (1))));
7673 alias_set
= build_int_cst (build_pointer_type (type
), 0);
7674 t
= build2 (MODIFY_EXPR
, void_type_node
,
7675 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
7676 build2 (MEM_REF
, array_type
, arg
, alias_set
));
7677 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
7678 TREE_NO_WARNING (val
) = 1;
7683 else if (DECL_DESTRUCTOR_P (fn
)
7684 && trivial_fn_p (fn
)
7685 && !DECL_DELETED_FN (fn
))
7686 return fold_convert (void_type_node
, argarray
[0]);
7687 /* FIXME handle trivial default constructor, too. */
7689 /* For calls to a multi-versioned function, overload resolution
7690 returns the function with the highest target priority, that is,
7691 the version that will checked for dispatching first. If this
7692 version is inlinable, a direct call to this version can be made
7693 otherwise the call should go through the dispatcher. */
7695 if (DECL_FUNCTION_VERSIONED (fn
)
7696 && (current_function_decl
== NULL
7697 || !targetm
.target_option
.can_inline_p (current_function_decl
, fn
)))
7699 fn
= get_function_version_dispatcher (fn
);
7703 mark_versions_used (fn
);
7707 && !mark_used (fn
, complain
))
7708 return error_mark_node
;
7710 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
7711 /* Don't mess with virtual lookup in instantiate_non_dependent_expr;
7712 virtual functions can't be constexpr. */
7713 && !in_template_function ())
7716 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
7718 ba_any
, NULL
, complain
);
7719 gcc_assert (binfo
&& binfo
!= error_mark_node
);
7721 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
7723 if (TREE_SIDE_EFFECTS (argarray
[0]))
7724 argarray
[0] = save_expr (argarray
[0]);
7725 t
= build_pointer_type (TREE_TYPE (fn
));
7726 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
7727 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
7729 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
7734 fn
= build_addr_func (fn
, complain
);
7735 if (fn
== error_mark_node
)
7736 return error_mark_node
;
7739 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
7740 if (TREE_CODE (call
) == CALL_EXPR
7741 && (cand
->flags
& LOOKUP_LIST_INIT_CTOR
))
7742 CALL_EXPR_LIST_INIT_P (call
) = true;
7746 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7747 This function performs no overload resolution, conversion, or other
7748 high-level operations. */
7751 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
7752 tsubst_flags_t complain
)
7756 /* Remember roughly where this call is. */
7757 location_t loc
= EXPR_LOC_OR_LOC (fn
, input_location
);
7758 fn
= build_call_a (fn
, nargs
, argarray
);
7759 SET_EXPR_LOCATION (fn
, loc
);
7761 fndecl
= get_callee_fndecl (fn
);
7763 /* Check that arguments to builtin functions match the expectations. */
7765 && DECL_BUILT_IN (fndecl
)
7766 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
7770 /* We need to take care that values to BUILT_IN_NORMAL
7772 for (i
= 0; i
< nargs
; i
++)
7773 argarray
[i
] = fold_non_dependent_expr (argarray
[i
]);
7775 if (!check_builtin_function_arguments (fndecl
, nargs
, argarray
))
7776 return error_mark_node
;
7779 /* If it is a built-in array notation function, then the return type of
7780 the function is the element type of the array passed in as array
7781 notation (i.e. the first parameter of the function). */
7782 if (flag_cilkplus
&& TREE_CODE (fn
) == CALL_EXPR
)
7784 enum built_in_function bif
=
7785 is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn
));
7786 if (bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
7787 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
7788 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
7789 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
7790 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE
7791 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
7793 if (call_expr_nargs (fn
) == 0)
7795 error_at (EXPR_LOCATION (fn
), "Invalid builtin arguments");
7796 return error_mark_node
;
7798 /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or
7799 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or
7800 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or
7801 BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or
7802 BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or
7803 BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
7804 The pre-defined return-type is the correct one. */
7805 tree array_ntn
= CALL_EXPR_ARG (fn
, 0);
7806 TREE_TYPE (fn
) = TREE_TYPE (array_ntn
);
7811 if (VOID_TYPE_P (TREE_TYPE (fn
)))
7814 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7815 function call is either the operand of a decltype-specifier or the
7816 right operand of a comma operator that is the operand of a
7817 decltype-specifier, a temporary object is not introduced for the
7818 prvalue. The type of the prvalue may be incomplete. */
7819 if (!(complain
& tf_decltype
))
7821 fn
= require_complete_type_sfinae (fn
, complain
);
7822 if (fn
== error_mark_node
)
7823 return error_mark_node
;
7825 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
7826 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
7828 return convert_from_reference (fn
);
7831 static GTY(()) tree java_iface_lookup_fn
;
7833 /* Make an expression which yields the address of the Java interface
7834 method FN. This is achieved by generating a call to libjava's
7835 _Jv_LookupInterfaceMethodIdx(). */
7838 build_java_interface_fn_ref (tree fn
, tree instance
)
7840 tree lookup_fn
, method
, idx
;
7841 tree klass_ref
, iface
, iface_ref
;
7844 if (!java_iface_lookup_fn
)
7846 tree ftype
= build_function_type_list (ptr_type_node
,
7847 ptr_type_node
, ptr_type_node
,
7848 java_int_type_node
, NULL_TREE
);
7849 java_iface_lookup_fn
7850 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype
,
7851 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
7854 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7855 This is the first entry in the vtable. */
7856 klass_ref
= build_vtbl_ref (cp_build_indirect_ref (instance
, RO_NULL
,
7857 tf_warning_or_error
),
7860 /* Get the java.lang.Class pointer for the interface being called. */
7861 iface
= DECL_CONTEXT (fn
);
7862 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
7863 if (!iface_ref
|| !VAR_P (iface_ref
)
7864 || DECL_CONTEXT (iface_ref
) != iface
)
7866 error ("could not find class$ field in java interface type %qT",
7868 return error_mark_node
;
7870 iface_ref
= build_address (iface_ref
);
7871 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
7873 /* Determine the itable index of FN. */
7875 for (method
= TYPE_METHODS (iface
); method
; method
= DECL_CHAIN (method
))
7877 if (!DECL_VIRTUAL_P (method
))
7883 idx
= build_int_cst (NULL_TREE
, i
);
7885 lookup_fn
= build1 (ADDR_EXPR
,
7886 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
7887 java_iface_lookup_fn
);
7888 return build_call_nary (ptr_type_node
, lookup_fn
,
7889 3, klass_ref
, iface_ref
, idx
);
7892 /* Returns the value to use for the in-charge parameter when making a
7893 call to a function with the indicated NAME.
7895 FIXME:Can't we find a neater way to do this mapping? */
7898 in_charge_arg_for_name (tree name
)
7900 if (name
== base_ctor_identifier
7901 || name
== base_dtor_identifier
)
7902 return integer_zero_node
;
7903 else if (name
== complete_ctor_identifier
)
7904 return integer_one_node
;
7905 else if (name
== complete_dtor_identifier
)
7906 return integer_two_node
;
7907 else if (name
== deleting_dtor_identifier
)
7908 return integer_three_node
;
7910 /* This function should only be called with one of the names listed
7916 /* Build a call to a constructor, destructor, or an assignment
7917 operator for INSTANCE, an expression with class type. NAME
7918 indicates the special member function to call; *ARGS are the
7919 arguments. ARGS may be NULL. This may change ARGS. BINFO
7920 indicates the base of INSTANCE that is to be passed as the `this'
7921 parameter to the member function called.
7923 FLAGS are the LOOKUP_* flags to use when processing the call.
7925 If NAME indicates a complete object constructor, INSTANCE may be
7926 NULL_TREE. In this case, the caller will call build_cplus_new to
7927 store the newly constructed object into a VAR_DECL. */
7930 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
7931 tree binfo
, int flags
, tsubst_flags_t complain
)
7934 /* The type of the subobject to be constructed or destroyed. */
7936 vec
<tree
, va_gc
> *allocated
= NULL
;
7939 gcc_assert (name
== complete_ctor_identifier
7940 || name
== base_ctor_identifier
7941 || name
== complete_dtor_identifier
7942 || name
== base_dtor_identifier
7943 || name
== deleting_dtor_identifier
7944 || name
== ansi_assopname (NOP_EXPR
));
7947 /* Resolve the name. */
7948 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
7949 return error_mark_node
;
7951 binfo
= TYPE_BINFO (binfo
);
7954 gcc_assert (binfo
!= NULL_TREE
);
7956 class_type
= BINFO_TYPE (binfo
);
7958 /* Handle the special case where INSTANCE is NULL_TREE. */
7959 if (name
== complete_ctor_identifier
&& !instance
)
7960 instance
= build_dummy_object (class_type
);
7963 if (name
== complete_dtor_identifier
7964 || name
== base_dtor_identifier
7965 || name
== deleting_dtor_identifier
)
7966 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
7968 /* Convert to the base class, if necessary. */
7969 if (!same_type_ignoring_top_level_qualifiers_p
7970 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
7972 if (name
!= ansi_assopname (NOP_EXPR
))
7973 /* For constructors and destructors, either the base is
7974 non-virtual, or it is virtual but we are doing the
7975 conversion from a constructor or destructor for the
7976 complete object. In either case, we can convert
7978 instance
= convert_to_base_statically (instance
, binfo
);
7980 /* However, for assignment operators, we must convert
7981 dynamically if the base is virtual. */
7982 instance
= build_base_path (PLUS_EXPR
, instance
,
7983 binfo
, /*nonnull=*/1, complain
);
7987 gcc_assert (instance
!= NULL_TREE
);
7989 fns
= lookup_fnfields (binfo
, name
, 1);
7991 /* When making a call to a constructor or destructor for a subobject
7992 that uses virtual base classes, pass down a pointer to a VTT for
7994 if ((name
== base_ctor_identifier
7995 || name
== base_dtor_identifier
)
7996 && CLASSTYPE_VBASECLASSES (class_type
))
8001 /* If the current function is a complete object constructor
8002 or destructor, then we fetch the VTT directly.
8003 Otherwise, we look it up using the VTT we were given. */
8004 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
8005 vtt
= decay_conversion (vtt
, complain
);
8006 if (vtt
== error_mark_node
)
8007 return error_mark_node
;
8008 vtt
= build_if_in_charge (vtt
, current_vtt_parm
);
8009 if (BINFO_SUBVTT_INDEX (binfo
))
8010 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
8016 allocated
= make_tree_vector ();
8020 vec_safe_insert (*args
, 0, sub_vtt
);
8023 ret
= build_new_method_call (instance
, fns
, args
,
8024 TYPE_BINFO (BINFO_TYPE (binfo
)),
8028 if (allocated
!= NULL
)
8029 release_tree_vector (allocated
);
8031 if ((complain
& tf_error
)
8032 && (flags
& LOOKUP_DELEGATING_CONS
)
8033 && name
== complete_ctor_identifier
8034 && TREE_CODE (ret
) == CALL_EXPR
8035 && (DECL_ABSTRACT_ORIGIN (TREE_OPERAND (CALL_EXPR_FN (ret
), 0))
8036 == current_function_decl
))
8037 error ("constructor delegates to itself");
8042 /* Return the NAME, as a C string. The NAME indicates a function that
8043 is a member of TYPE. *FREE_P is set to true if the caller must
8044 free the memory returned.
8046 Rather than go through all of this, we should simply set the names
8047 of constructors and destructors appropriately, and dispense with
8048 ctor_identifier, dtor_identifier, etc. */
8051 name_as_c_string (tree name
, tree type
, bool *free_p
)
8055 /* Assume that we will not allocate memory. */
8057 /* Constructors and destructors are special. */
8058 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
8061 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
8062 /* For a destructor, add the '~'. */
8063 if (name
== complete_dtor_identifier
8064 || name
== base_dtor_identifier
8065 || name
== deleting_dtor_identifier
)
8067 pretty_name
= concat ("~", pretty_name
, NULL
);
8068 /* Remember that we need to free the memory allocated. */
8072 else if (IDENTIFIER_TYPENAME_P (name
))
8074 pretty_name
= concat ("operator ",
8075 type_as_string_translate (TREE_TYPE (name
),
8076 TFF_PLAIN_IDENTIFIER
),
8078 /* Remember that we need to free the memory allocated. */
8082 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
8087 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
8088 be set, upon return, to the function called. ARGS may be NULL.
8089 This may change ARGS. */
8092 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8093 tree conversion_path
, int flags
,
8094 tree
*fn_p
, tsubst_flags_t complain
)
8096 struct z_candidate
*candidates
= 0, *cand
;
8097 tree explicit_targs
= NULL_TREE
;
8098 tree basetype
= NULL_TREE
;
8099 tree access_binfo
, binfo
;
8101 tree first_mem_arg
= NULL_TREE
;
8103 bool skip_first_for_error
;
8104 vec
<tree
, va_gc
> *user_args
;
8107 int template_only
= 0;
8111 vec
<tree
, va_gc
> *orig_args
= NULL
;
8114 gcc_assert (instance
!= NULL_TREE
);
8116 /* We don't know what function we're going to call, yet. */
8120 if (error_operand_p (instance
)
8121 || !fns
|| error_operand_p (fns
))
8122 return error_mark_node
;
8124 if (!BASELINK_P (fns
))
8126 if (complain
& tf_error
)
8127 error ("call to non-function %qD", fns
);
8128 return error_mark_node
;
8131 orig_instance
= instance
;
8134 /* Dismantle the baselink to collect all the information we need. */
8135 if (!conversion_path
)
8136 conversion_path
= BASELINK_BINFO (fns
);
8137 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
8138 binfo
= BASELINK_BINFO (fns
);
8139 optype
= BASELINK_OPTYPE (fns
);
8140 fns
= BASELINK_FUNCTIONS (fns
);
8141 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
8143 explicit_targs
= TREE_OPERAND (fns
, 1);
8144 fns
= TREE_OPERAND (fns
, 0);
8147 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
8148 || TREE_CODE (fns
) == TEMPLATE_DECL
8149 || TREE_CODE (fns
) == OVERLOAD
);
8150 fn
= get_first_fn (fns
);
8151 name
= DECL_NAME (fn
);
8153 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
8154 gcc_assert (CLASS_TYPE_P (basetype
));
8156 if (processing_template_decl
)
8158 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
8159 instance
= build_non_dependent_expr (instance
);
8161 make_args_non_dependent (*args
);
8164 user_args
= args
== NULL
? NULL
: *args
;
8165 /* Under DR 147 A::A() is an invalid constructor call,
8166 not a functional cast. */
8167 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
8169 if (! (complain
& tf_error
))
8170 return error_mark_node
;
8172 if (permerror (input_location
,
8173 "cannot call constructor %<%T::%D%> directly",
8175 inform (input_location
, "for a function-style cast, remove the "
8176 "redundant %<::%D%>", name
);
8177 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
8182 /* Figure out whether to skip the first argument for the error
8183 message we will display to users if an error occurs. We don't
8184 want to display any compiler-generated arguments. The "this"
8185 pointer hasn't been added yet. However, we must remove the VTT
8186 pointer if this is a call to a base-class constructor or
8188 skip_first_for_error
= false;
8189 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
8191 /* Callers should explicitly indicate whether they want to construct
8192 the complete object or just the part without virtual bases. */
8193 gcc_assert (name
!= ctor_identifier
);
8194 /* Similarly for destructors. */
8195 gcc_assert (name
!= dtor_identifier
);
8196 /* Remove the VTT pointer, if present. */
8197 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
8198 && CLASSTYPE_VBASECLASSES (basetype
))
8199 skip_first_for_error
= true;
8202 /* Process the argument list. */
8203 if (args
!= NULL
&& *args
!= NULL
)
8205 *args
= resolve_args (*args
, complain
);
8207 return error_mark_node
;
8210 /* Consider the object argument to be used even if we end up selecting a
8211 static member function. */
8212 instance
= mark_type_use (instance
);
8214 /* It's OK to call destructors and constructors on cv-qualified objects.
8215 Therefore, convert the INSTANCE to the unqualified type, if
8217 if (DECL_DESTRUCTOR_P (fn
)
8218 || DECL_CONSTRUCTOR_P (fn
))
8220 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
8222 instance
= build_this (instance
);
8223 instance
= build_nop (build_pointer_type (basetype
), instance
);
8224 instance
= build_fold_indirect_ref (instance
);
8227 if (DECL_DESTRUCTOR_P (fn
))
8228 name
= complete_dtor_identifier
;
8230 /* For the overload resolution we need to find the actual `this`
8231 that would be captured if the call turns out to be to a
8232 non-static member function. Do not actually capture it at this
8234 if (DECL_CONSTRUCTOR_P (fn
))
8235 /* Constructors don't use the enclosing 'this'. */
8236 first_mem_arg
= instance
;
8238 first_mem_arg
= maybe_resolve_dummy (instance
, false);
8240 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8241 p
= conversion_obstack_alloc (0);
8243 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
8244 initializer, not T({ }). */
8245 if (DECL_CONSTRUCTOR_P (fn
) && args
!= NULL
&& !vec_safe_is_empty (*args
)
8246 && DIRECT_LIST_INIT_P ((**args
)[0]))
8248 tree init_list
= (**args
)[0];
8249 tree init
= NULL_TREE
;
8251 gcc_assert ((*args
)->length () == 1
8252 && !(flags
& LOOKUP_ONLYCONVERTING
));
8254 /* If the initializer list has no elements and T is a class type with
8255 a default constructor, the object is value-initialized. Handle
8256 this here so we don't need to handle it wherever we use
8257 build_special_member_call. */
8258 if (CONSTRUCTOR_NELTS (init_list
) == 0
8259 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
8260 /* For a user-provided default constructor, use the normal
8261 mechanisms so that protected access works. */
8262 && type_has_non_user_provided_default_constructor (basetype
)
8263 && !processing_template_decl
)
8264 init
= build_value_init (basetype
, complain
);
8266 /* If BASETYPE is an aggregate, we need to do aggregate
8268 else if (CP_AGGREGATE_TYPE_P (basetype
))
8270 init
= reshape_init (basetype
, init_list
, complain
);
8271 init
= digest_init (basetype
, init
, complain
);
8276 if (is_dummy_object (instance
))
8277 return get_target_expr_sfinae (init
, complain
);
8278 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
8279 TREE_SIDE_EFFECTS (init
) = true;
8283 /* Otherwise go ahead with overload resolution. */
8284 add_list_candidates (fns
, first_mem_arg
, init_list
,
8285 basetype
, explicit_targs
, template_only
,
8286 conversion_path
, access_binfo
, flags
,
8287 &candidates
, complain
);
8291 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
8292 explicit_targs
, template_only
, conversion_path
,
8293 access_binfo
, flags
, &candidates
, complain
);
8295 any_viable_p
= false;
8296 candidates
= splice_viable (candidates
, false, &any_viable_p
);
8300 if (complain
& tf_error
)
8302 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
8303 cxx_incomplete_type_error (instance
, basetype
);
8305 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
8306 basetype
, optype
, build_tree_list_vec (user_args
),
8307 TREE_TYPE (instance
));
8314 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8315 arglist
= build_tree_list_vec (user_args
);
8316 if (skip_first_for_error
)
8317 arglist
= TREE_CHAIN (arglist
);
8318 error ("no matching function for call to %<%T::%s(%A)%#V%>",
8319 basetype
, pretty_name
, arglist
,
8320 TREE_TYPE (instance
));
8324 print_z_candidates (location_of (name
), candidates
);
8326 call
= error_mark_node
;
8330 cand
= tourney (candidates
, complain
);
8337 if (complain
& tf_error
)
8339 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8340 arglist
= build_tree_list_vec (user_args
);
8341 if (skip_first_for_error
)
8342 arglist
= TREE_CHAIN (arglist
);
8343 if (!any_strictly_viable (candidates
))
8344 error ("no matching function for call to %<%s(%A)%>",
8345 pretty_name
, arglist
);
8347 error ("call of overloaded %<%s(%A)%> is ambiguous",
8348 pretty_name
, arglist
);
8349 print_z_candidates (location_of (name
), candidates
);
8353 call
= error_mark_node
;
8360 if (!(flags
& LOOKUP_NONVIRTUAL
)
8361 && DECL_PURE_VIRTUAL_P (fn
)
8362 && instance
== current_class_ref
8363 && (complain
& tf_warning
))
8365 /* This is not an error, it is runtime undefined
8367 if (!current_function_decl
)
8368 warning (0, "pure virtual %q#D called from "
8369 "non-static data member initializer", fn
);
8370 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
8371 || DECL_DESTRUCTOR_P (current_function_decl
))
8372 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
8373 ? "pure virtual %q#D called from constructor"
8374 : "pure virtual %q#D called from destructor"),
8378 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
8379 && !DECL_CONSTRUCTOR_P (fn
)
8380 && is_dummy_object (instance
))
8382 instance
= maybe_resolve_dummy (instance
, true);
8383 if (instance
== error_mark_node
)
8384 call
= error_mark_node
;
8385 else if (!is_dummy_object (instance
))
8387 /* We captured 'this' in the current lambda now that
8388 we know we really need it. */
8389 cand
->first_arg
= instance
;
8393 if (complain
& tf_error
)
8394 error ("cannot call member function %qD without object",
8396 call
= error_mark_node
;
8400 if (call
!= error_mark_node
)
8402 /* Optimize away vtable lookup if we know that this
8403 function can't be overridden. We need to check if
8404 the context and the type where we found fn are the same,
8405 actually FN might be defined in a different class
8406 type because of a using-declaration. In this case, we
8407 do not want to perform a non-virtual call. */
8408 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
8409 && same_type_ignoring_top_level_qualifiers_p
8410 (DECL_CONTEXT (fn
), BINFO_TYPE (binfo
))
8411 && resolves_to_fixed_type_p (instance
, 0))
8412 flags
|= LOOKUP_NONVIRTUAL
;
8414 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
8415 /* Now we know what function is being called. */
8418 /* Build the actual CALL_EXPR. */
8419 call
= build_over_call (cand
, flags
, complain
);
8420 /* In an expression of the form `a->f()' where `f' turns
8421 out to be a static member function, `a' is
8422 none-the-less evaluated. */
8423 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
8424 && !is_dummy_object (instance
)
8425 && TREE_SIDE_EFFECTS (instance
))
8426 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
8428 else if (call
!= error_mark_node
8429 && DECL_DESTRUCTOR_P (cand
->fn
)
8430 && !VOID_TYPE_P (TREE_TYPE (call
)))
8431 /* An explicit call of the form "x->~X()" has type
8432 "void". However, on platforms where destructors
8433 return "this" (i.e., those where
8434 targetm.cxx.cdtor_returns_this is true), such calls
8435 will appear to have a return value of pointer type
8436 to the low-level call machinery. We do not want to
8437 change the low-level machinery, since we want to be
8438 able to optimize "delete f()" on such platforms as
8439 "operator delete(~X(f()))" (rather than generating
8440 "t = f(), ~X(t), operator delete (t)"). */
8441 call
= build_nop (void_type_node
, call
);
8446 if (processing_template_decl
&& call
!= error_mark_node
)
8448 bool cast_to_void
= false;
8450 if (TREE_CODE (call
) == COMPOUND_EXPR
)
8451 call
= TREE_OPERAND (call
, 1);
8452 else if (TREE_CODE (call
) == NOP_EXPR
)
8454 cast_to_void
= true;
8455 call
= TREE_OPERAND (call
, 0);
8457 if (INDIRECT_REF_P (call
))
8458 call
= TREE_OPERAND (call
, 0);
8459 call
= (build_min_non_dep_call_vec
8461 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
8462 orig_instance
, orig_fns
, NULL_TREE
),
8464 SET_EXPR_LOCATION (call
, input_location
);
8465 call
= convert_from_reference (call
);
8467 call
= build_nop (void_type_node
, call
);
8470 /* Free all the conversions we allocated. */
8471 obstack_free (&conversion_obstack
, p
);
8473 if (orig_args
!= NULL
)
8474 release_tree_vector (orig_args
);
8479 /* Wrapper for above. */
8482 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8483 tree conversion_path
, int flags
,
8484 tree
*fn_p
, tsubst_flags_t complain
)
8487 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
8488 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
8490 timevar_cond_stop (TV_OVERLOAD
, subtime
);
8494 /* Returns true iff standard conversion sequence ICS1 is a proper
8495 subsequence of ICS2. */
8498 is_subseq (conversion
*ics1
, conversion
*ics2
)
8500 /* We can assume that a conversion of the same code
8501 between the same types indicates a subsequence since we only get
8502 here if the types we are converting from are the same. */
8504 while (ics1
->kind
== ck_rvalue
8505 || ics1
->kind
== ck_lvalue
)
8506 ics1
= next_conversion (ics1
);
8510 while (ics2
->kind
== ck_rvalue
8511 || ics2
->kind
== ck_lvalue
)
8512 ics2
= next_conversion (ics2
);
8514 if (ics2
->kind
== ck_user
8515 || ics2
->kind
== ck_ambig
8516 || ics2
->kind
== ck_aggr
8517 || ics2
->kind
== ck_list
8518 || ics2
->kind
== ck_identity
)
8519 /* At this point, ICS1 cannot be a proper subsequence of
8520 ICS2. We can get a USER_CONV when we are comparing the
8521 second standard conversion sequence of two user conversion
8525 ics2
= next_conversion (ics2
);
8527 if (ics2
->kind
== ics1
->kind
8528 && same_type_p (ics2
->type
, ics1
->type
)
8529 && same_type_p (next_conversion (ics2
)->type
,
8530 next_conversion (ics1
)->type
))
8535 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
8536 be any _TYPE nodes. */
8539 is_properly_derived_from (tree derived
, tree base
)
8541 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
8544 /* We only allow proper derivation here. The DERIVED_FROM_P macro
8545 considers every class derived from itself. */
8546 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
8547 && DERIVED_FROM_P (base
, derived
));
8550 /* We build the ICS for an implicit object parameter as a pointer
8551 conversion sequence. However, such a sequence should be compared
8552 as if it were a reference conversion sequence. If ICS is the
8553 implicit conversion sequence for an implicit object parameter,
8554 modify it accordingly. */
8557 maybe_handle_implicit_object (conversion
**ics
)
8561 /* [over.match.funcs]
8563 For non-static member functions, the type of the
8564 implicit object parameter is "reference to cv X"
8565 where X is the class of which the function is a
8566 member and cv is the cv-qualification on the member
8567 function declaration. */
8568 conversion
*t
= *ics
;
8569 tree reference_type
;
8571 /* The `this' parameter is a pointer to a class type. Make the
8572 implicit conversion talk about a reference to that same class
8574 reference_type
= TREE_TYPE (t
->type
);
8575 reference_type
= build_reference_type (reference_type
);
8577 if (t
->kind
== ck_qual
)
8578 t
= next_conversion (t
);
8579 if (t
->kind
== ck_ptr
)
8580 t
= next_conversion (t
);
8581 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
8582 t
= direct_reference_binding (reference_type
, t
);
8584 t
->rvaluedness_matches_p
= 0;
8589 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
8590 and return the initial reference binding conversion. Otherwise,
8591 leave *ICS unchanged and return NULL. */
8594 maybe_handle_ref_bind (conversion
**ics
)
8596 if ((*ics
)->kind
== ck_ref_bind
)
8598 conversion
*old_ics
= *ics
;
8599 *ics
= next_conversion (old_ics
);
8600 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
8607 /* Compare two implicit conversion sequences according to the rules set out in
8608 [over.ics.rank]. Return values:
8610 1: ics1 is better than ics2
8611 -1: ics2 is better than ics1
8612 0: ics1 and ics2 are indistinguishable */
8615 compare_ics (conversion
*ics1
, conversion
*ics2
)
8621 tree deref_from_type1
= NULL_TREE
;
8622 tree deref_from_type2
= NULL_TREE
;
8623 tree deref_to_type1
= NULL_TREE
;
8624 tree deref_to_type2
= NULL_TREE
;
8625 conversion_rank rank1
, rank2
;
8627 /* REF_BINDING is nonzero if the result of the conversion sequence
8628 is a reference type. In that case REF_CONV is the reference
8629 binding conversion. */
8630 conversion
*ref_conv1
;
8631 conversion
*ref_conv2
;
8633 /* Compare badness before stripping the reference conversion. */
8634 if (ics1
->bad_p
> ics2
->bad_p
)
8636 else if (ics1
->bad_p
< ics2
->bad_p
)
8639 /* Handle implicit object parameters. */
8640 maybe_handle_implicit_object (&ics1
);
8641 maybe_handle_implicit_object (&ics2
);
8643 /* Handle reference parameters. */
8644 ref_conv1
= maybe_handle_ref_bind (&ics1
);
8645 ref_conv2
= maybe_handle_ref_bind (&ics2
);
8647 /* List-initialization sequence L1 is a better conversion sequence than
8648 list-initialization sequence L2 if L1 converts to
8649 std::initializer_list<X> for some X and L2 does not. */
8650 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
8652 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
8657 When comparing the basic forms of implicit conversion sequences (as
8658 defined in _over.best.ics_)
8660 --a standard conversion sequence (_over.ics.scs_) is a better
8661 conversion sequence than a user-defined conversion sequence
8662 or an ellipsis conversion sequence, and
8664 --a user-defined conversion sequence (_over.ics.user_) is a
8665 better conversion sequence than an ellipsis conversion sequence
8666 (_over.ics.ellipsis_). */
8667 /* Use BAD_CONVERSION_RANK because we already checked for a badness
8668 mismatch. If both ICS are bad, we try to make a decision based on
8669 what would have happened if they'd been good. This is not an
8670 extension, we'll still give an error when we build up the call; this
8671 just helps us give a more helpful error message. */
8672 rank1
= BAD_CONVERSION_RANK (ics1
);
8673 rank2
= BAD_CONVERSION_RANK (ics2
);
8677 else if (rank1
< rank2
)
8680 if (ics1
->ellipsis_p
)
8681 /* Both conversions are ellipsis conversions. */
8684 /* User-defined conversion sequence U1 is a better conversion sequence
8685 than another user-defined conversion sequence U2 if they contain the
8686 same user-defined conversion operator or constructor and if the sec-
8687 ond standard conversion sequence of U1 is better than the second
8688 standard conversion sequence of U2. */
8690 /* Handle list-conversion with the same code even though it isn't always
8691 ranked as a user-defined conversion and it doesn't have a second
8692 standard conversion sequence; it will still have the desired effect.
8693 Specifically, we need to do the reference binding comparison at the
8694 end of this function. */
8696 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
8701 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
8702 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
8703 || t1
->kind
== ck_list
)
8705 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
8706 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
8707 || t2
->kind
== ck_list
)
8710 if (t1
->kind
!= t2
->kind
)
8712 else if (t1
->kind
== ck_user
)
8714 if (t1
->cand
->fn
!= t2
->cand
->fn
)
8719 /* For ambiguous or aggregate conversions, use the target type as
8720 a proxy for the conversion function. */
8721 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
8725 /* We can just fall through here, after setting up
8726 FROM_TYPE1 and FROM_TYPE2. */
8727 from_type1
= t1
->type
;
8728 from_type2
= t2
->type
;
8735 /* We're dealing with two standard conversion sequences.
8739 Standard conversion sequence S1 is a better conversion
8740 sequence than standard conversion sequence S2 if
8742 --S1 is a proper subsequence of S2 (comparing the conversion
8743 sequences in the canonical form defined by _over.ics.scs_,
8744 excluding any Lvalue Transformation; the identity
8745 conversion sequence is considered to be a subsequence of
8746 any non-identity conversion sequence */
8749 while (t1
->kind
!= ck_identity
)
8750 t1
= next_conversion (t1
);
8751 from_type1
= t1
->type
;
8754 while (t2
->kind
!= ck_identity
)
8755 t2
= next_conversion (t2
);
8756 from_type2
= t2
->type
;
8759 /* One sequence can only be a subsequence of the other if they start with
8760 the same type. They can start with different types when comparing the
8761 second standard conversion sequence in two user-defined conversion
8763 if (same_type_p (from_type1
, from_type2
))
8765 if (is_subseq (ics1
, ics2
))
8767 if (is_subseq (ics2
, ics1
))
8775 --the rank of S1 is better than the rank of S2 (by the rules
8778 Standard conversion sequences are ordered by their ranks: an Exact
8779 Match is a better conversion than a Promotion, which is a better
8780 conversion than a Conversion.
8782 Two conversion sequences with the same rank are indistinguishable
8783 unless one of the following rules applies:
8785 --A conversion that does not a convert a pointer, pointer to member,
8786 or std::nullptr_t to bool is better than one that does.
8788 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8789 so that we do not have to check it explicitly. */
8790 if (ics1
->rank
< ics2
->rank
)
8792 else if (ics2
->rank
< ics1
->rank
)
8795 to_type1
= ics1
->type
;
8796 to_type2
= ics2
->type
;
8798 /* A conversion from scalar arithmetic type to complex is worse than a
8799 conversion between scalar arithmetic types. */
8800 if (same_type_p (from_type1
, from_type2
)
8801 && ARITHMETIC_TYPE_P (from_type1
)
8802 && ARITHMETIC_TYPE_P (to_type1
)
8803 && ARITHMETIC_TYPE_P (to_type2
)
8804 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8805 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
8807 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8813 if (TYPE_PTR_P (from_type1
)
8814 && TYPE_PTR_P (from_type2
)
8815 && TYPE_PTR_P (to_type1
)
8816 && TYPE_PTR_P (to_type2
))
8818 deref_from_type1
= TREE_TYPE (from_type1
);
8819 deref_from_type2
= TREE_TYPE (from_type2
);
8820 deref_to_type1
= TREE_TYPE (to_type1
);
8821 deref_to_type2
= TREE_TYPE (to_type2
);
8823 /* The rules for pointers to members A::* are just like the rules
8824 for pointers A*, except opposite: if B is derived from A then
8825 A::* converts to B::*, not vice versa. For that reason, we
8826 switch the from_ and to_ variables here. */
8827 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
8828 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
8829 || (TYPE_PTRMEMFUNC_P (from_type1
)
8830 && TYPE_PTRMEMFUNC_P (from_type2
)
8831 && TYPE_PTRMEMFUNC_P (to_type1
)
8832 && TYPE_PTRMEMFUNC_P (to_type2
)))
8834 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
8835 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
8836 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
8837 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
8840 if (deref_from_type1
!= NULL_TREE
8841 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
8842 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
8844 /* This was one of the pointer or pointer-like conversions.
8848 --If class B is derived directly or indirectly from class A,
8849 conversion of B* to A* is better than conversion of B* to
8850 void*, and conversion of A* to void* is better than
8851 conversion of B* to void*. */
8852 if (VOID_TYPE_P (deref_to_type1
)
8853 && VOID_TYPE_P (deref_to_type2
))
8855 if (is_properly_derived_from (deref_from_type1
,
8858 else if (is_properly_derived_from (deref_from_type2
,
8862 else if (VOID_TYPE_P (deref_to_type1
)
8863 || VOID_TYPE_P (deref_to_type2
))
8865 if (same_type_p (deref_from_type1
, deref_from_type2
))
8867 if (VOID_TYPE_P (deref_to_type2
))
8869 if (is_properly_derived_from (deref_from_type1
,
8873 /* We know that DEREF_TO_TYPE1 is `void' here. */
8874 else if (is_properly_derived_from (deref_from_type1
,
8879 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
8880 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
8884 --If class B is derived directly or indirectly from class A
8885 and class C is derived directly or indirectly from B,
8887 --conversion of C* to B* is better than conversion of C* to
8890 --conversion of B* to A* is better than conversion of C* to
8892 if (same_type_p (deref_from_type1
, deref_from_type2
))
8894 if (is_properly_derived_from (deref_to_type1
,
8897 else if (is_properly_derived_from (deref_to_type2
,
8901 else if (same_type_p (deref_to_type1
, deref_to_type2
))
8903 if (is_properly_derived_from (deref_from_type2
,
8906 else if (is_properly_derived_from (deref_from_type1
,
8912 else if (CLASS_TYPE_P (non_reference (from_type1
))
8913 && same_type_p (from_type1
, from_type2
))
8915 tree from
= non_reference (from_type1
);
8919 --binding of an expression of type C to a reference of type
8920 B& is better than binding an expression of type C to a
8921 reference of type A&
8923 --conversion of C to B is better than conversion of C to A, */
8924 if (is_properly_derived_from (from
, to_type1
)
8925 && is_properly_derived_from (from
, to_type2
))
8927 if (is_properly_derived_from (to_type1
, to_type2
))
8929 else if (is_properly_derived_from (to_type2
, to_type1
))
8933 else if (CLASS_TYPE_P (non_reference (to_type1
))
8934 && same_type_p (to_type1
, to_type2
))
8936 tree to
= non_reference (to_type1
);
8940 --binding of an expression of type B to a reference of type
8941 A& is better than binding an expression of type C to a
8942 reference of type A&,
8944 --conversion of B to A is better than conversion of C to A */
8945 if (is_properly_derived_from (from_type1
, to
)
8946 && is_properly_derived_from (from_type2
, to
))
8948 if (is_properly_derived_from (from_type2
, from_type1
))
8950 else if (is_properly_derived_from (from_type1
, from_type2
))
8957 --S1 and S2 differ only in their qualification conversion and yield
8958 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8959 qualification signature of type T1 is a proper subset of the cv-
8960 qualification signature of type T2 */
8961 if (ics1
->kind
== ck_qual
8962 && ics2
->kind
== ck_qual
8963 && same_type_p (from_type1
, from_type2
))
8965 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
8972 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8973 to an implicit object parameter of a non-static member function
8974 declared without a ref-qualifier, and either S1 binds an lvalue
8975 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
8976 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
8977 draft standard, 13.3.3.2)
8979 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8980 types to which the references refer are the same type except for
8981 top-level cv-qualifiers, and the type to which the reference
8982 initialized by S2 refers is more cv-qualified than the type to
8983 which the reference initialized by S1 refers.
8985 DR 1328 [over.match.best]: the context is an initialization by
8986 conversion function for direct reference binding (13.3.1.6) of a
8987 reference to function type, the return type of F1 is the same kind of
8988 reference (i.e. lvalue or rvalue) as the reference being initialized,
8989 and the return type of F2 is not. */
8991 if (ref_conv1
&& ref_conv2
)
8993 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
8994 && (ref_conv1
->rvaluedness_matches_p
8995 != ref_conv2
->rvaluedness_matches_p
)
8996 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
8997 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
8998 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
9000 if (ref_conv1
->bad_p
9001 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
9002 TREE_TYPE (ref_conv2
->type
)))
9003 /* Don't prefer a bad conversion that drops cv-quals to a bad
9004 conversion with the wrong rvalueness. */
9006 return (ref_conv1
->rvaluedness_matches_p
9007 - ref_conv2
->rvaluedness_matches_p
);
9010 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
9012 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
9013 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
9014 if (ref_conv1
->bad_p
)
9016 /* Prefer the one that drops fewer cv-quals. */
9017 tree ftype
= next_conversion (ref_conv1
)->type
;
9018 int fquals
= cp_type_quals (ftype
);
9022 return comp_cv_qualification (q2
, q1
);
9026 /* Neither conversion sequence is better than the other. */
9030 /* The source type for this standard conversion sequence. */
9033 source_type (conversion
*t
)
9035 for (;; t
= next_conversion (t
))
9037 if (t
->kind
== ck_user
9038 || t
->kind
== ck_ambig
9039 || t
->kind
== ck_identity
)
9045 /* Note a warning about preferring WINNER to LOSER. We do this by storing
9046 a pointer to LOSER and re-running joust to produce the warning if WINNER
9047 is actually used. */
9050 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
9052 candidate_warning
*cw
= (candidate_warning
*)
9053 conversion_obstack_alloc (sizeof (candidate_warning
));
9055 cw
->next
= winner
->warnings
;
9056 winner
->warnings
= cw
;
9059 /* Compare two candidates for overloading as described in
9060 [over.match.best]. Return values:
9062 1: cand1 is better than cand2
9063 -1: cand2 is better than cand1
9064 0: cand1 and cand2 are indistinguishable */
9067 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
9068 tsubst_flags_t complain
)
9071 int off1
= 0, off2
= 0;
9075 /* Candidates that involve bad conversions are always worse than those
9077 if (cand1
->viable
> cand2
->viable
)
9079 if (cand1
->viable
< cand2
->viable
)
9082 /* If we have two pseudo-candidates for conversions to the same type,
9083 or two candidates for the same function, arbitrarily pick one. */
9084 if (cand1
->fn
== cand2
->fn
9085 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
9088 /* Prefer a non-deleted function over an implicitly deleted move
9089 constructor or assignment operator. This differs slightly from the
9090 wording for issue 1402 (which says the move op is ignored by overload
9091 resolution), but this way produces better error messages. */
9092 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9093 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9094 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
9096 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
9097 && move_fn_p (cand1
->fn
))
9099 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
9100 && move_fn_p (cand2
->fn
))
9104 /* a viable function F1
9105 is defined to be a better function than another viable function F2 if
9106 for all arguments i, ICSi(F1) is not a worse conversion sequence than
9107 ICSi(F2), and then */
9109 /* for some argument j, ICSj(F1) is a better conversion sequence than
9112 /* For comparing static and non-static member functions, we ignore
9113 the implicit object parameter of the non-static function. The
9114 standard says to pretend that the static function has an object
9115 parm, but that won't work with operator overloading. */
9116 len
= cand1
->num_convs
;
9117 if (len
!= cand2
->num_convs
)
9119 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
9120 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
9122 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
9123 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
9124 /* We're comparing a near-match list constructor and a near-match
9125 non-list constructor. Just treat them as unordered. */
9128 gcc_assert (static_1
!= static_2
);
9139 for (i
= 0; i
< len
; ++i
)
9141 conversion
*t1
= cand1
->convs
[i
+ off1
];
9142 conversion
*t2
= cand2
->convs
[i
+ off2
];
9143 int comp
= compare_ics (t1
, t2
);
9147 if ((complain
& tf_warning
)
9149 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
9150 == cr_std
+ cr_promotion
)
9151 && t1
->kind
== ck_std
9152 && t2
->kind
== ck_std
9153 && TREE_CODE (t1
->type
) == INTEGER_TYPE
9154 && TREE_CODE (t2
->type
) == INTEGER_TYPE
9155 && (TYPE_PRECISION (t1
->type
)
9156 == TYPE_PRECISION (t2
->type
))
9157 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
9158 || (TREE_CODE (next_conversion (t1
)->type
)
9161 tree type
= next_conversion (t1
)->type
;
9163 struct z_candidate
*w
, *l
;
9165 type1
= t1
->type
, type2
= t2
->type
,
9166 w
= cand1
, l
= cand2
;
9168 type1
= t2
->type
, type2
= t1
->type
,
9169 w
= cand2
, l
= cand1
;
9173 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
9174 type
, type1
, type2
);
9175 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
9181 if (winner
&& comp
!= winner
)
9190 /* warn about confusing overload resolution for user-defined conversions,
9191 either between a constructor and a conversion op, or between two
9193 if ((complain
& tf_warning
)
9194 && winner
&& warn_conversion
&& cand1
->second_conv
9195 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
9196 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
9198 struct z_candidate
*w
, *l
;
9199 bool give_warning
= false;
9202 w
= cand1
, l
= cand2
;
9204 w
= cand2
, l
= cand1
;
9206 /* We don't want to complain about `X::operator T1 ()'
9207 beating `X::operator T2 () const', when T2 is a no less
9208 cv-qualified version of T1. */
9209 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
9210 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
9212 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
9213 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
9215 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
9220 if (!comp_ptr_ttypes (t
, f
))
9221 give_warning
= true;
9224 give_warning
= true;
9230 tree source
= source_type (w
->convs
[0]);
9231 if (! DECL_CONSTRUCTOR_P (w
->fn
))
9232 source
= TREE_TYPE (source
);
9233 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
9234 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
9235 source
, w
->second_conv
->type
))
9237 inform (input_location
, " because conversion sequence for the argument is better");
9247 /* DR 495 moved this tiebreaker above the template ones. */
9249 the context is an initialization by user-defined conversion (see
9250 _dcl.init_ and _over.match.user_) and the standard conversion
9251 sequence from the return type of F1 to the destination type (i.e.,
9252 the type of the entity being initialized) is a better conversion
9253 sequence than the standard conversion sequence from the return type
9254 of F2 to the destination type. */
9256 if (cand1
->second_conv
)
9258 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
9264 F1 is a non-template function and F2 is a template function
9267 if (!cand1
->template_decl
&& cand2
->template_decl
)
9269 else if (cand1
->template_decl
&& !cand2
->template_decl
)
9273 F1 and F2 are template functions and the function template for F1 is
9274 more specialized than the template for F2 according to the partial
9277 if (cand1
->template_decl
&& cand2
->template_decl
)
9279 winner
= more_specialized_fn
9280 (TI_TEMPLATE (cand1
->template_decl
),
9281 TI_TEMPLATE (cand2
->template_decl
),
9282 /* [temp.func.order]: The presence of unused ellipsis and default
9283 arguments has no effect on the partial ordering of function
9284 templates. add_function_candidate() will not have
9285 counted the "this" argument for constructors. */
9286 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
9292 // or, if not that, F1 is more constrained than F2.
9293 if (flag_concepts
&& DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
))
9295 winner
= more_constrained (cand1
->fn
, cand2
->fn
);
9300 /* Check whether we can discard a builtin candidate, either because we
9301 have two identical ones or matching builtin and non-builtin candidates.
9303 (Pedantically in the latter case the builtin which matched the user
9304 function should not be added to the overload set, but we spot it here.
9307 ... the builtin candidates include ...
9308 - do not have the same parameter type list as any non-template
9309 non-member candidate. */
9311 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
9313 for (i
= 0; i
< len
; ++i
)
9314 if (!same_type_p (cand1
->convs
[i
]->type
,
9315 cand2
->convs
[i
]->type
))
9317 if (i
== cand1
->num_convs
)
9319 if (cand1
->fn
== cand2
->fn
)
9320 /* Two built-in candidates; arbitrarily pick one. */
9322 else if (identifier_p (cand1
->fn
))
9323 /* cand1 is built-in; prefer cand2. */
9326 /* cand2 is built-in; prefer cand1. */
9331 /* For candidates of a multi-versioned function, make the version with
9332 the highest priority win. This version will be checked for dispatching
9333 first. If this version can be inlined into the caller, the front-end
9334 will simply make a direct call to this function. */
9336 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9337 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
9338 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9339 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
9341 tree f1
= TREE_TYPE (cand1
->fn
);
9342 tree f2
= TREE_TYPE (cand2
->fn
);
9343 tree p1
= TYPE_ARG_TYPES (f1
);
9344 tree p2
= TYPE_ARG_TYPES (f2
);
9346 /* Check if cand1->fn and cand2->fn are versions of the same function. It
9347 is possible that cand1->fn and cand2->fn are function versions but of
9348 different functions. Check types to see if they are versions of the same
9350 if (compparms (p1
, p2
)
9351 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
9353 /* Always make the version with the higher priority, more
9354 specialized, win. */
9355 gcc_assert (targetm
.compare_version_priority
);
9356 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
9363 /* If the two function declarations represent the same function (this can
9364 happen with declarations in multiple scopes and arg-dependent lookup),
9365 arbitrarily choose one. But first make sure the default args we're
9367 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
9368 && equal_functions (cand1
->fn
, cand2
->fn
))
9370 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
9371 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
9373 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
9375 for (i
= 0; i
< len
; ++i
)
9377 /* Don't crash if the fn is variadic. */
9380 parms1
= TREE_CHAIN (parms1
);
9381 parms2
= TREE_CHAIN (parms2
);
9385 parms1
= TREE_CHAIN (parms1
);
9387 parms2
= TREE_CHAIN (parms2
);
9391 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
9392 TREE_PURPOSE (parms2
)))
9396 if (complain
& tf_error
)
9398 if (permerror (input_location
,
9399 "default argument mismatch in "
9400 "overload resolution"))
9402 inform (input_location
,
9403 " candidate 1: %q+#F", cand1
->fn
);
9404 inform (input_location
,
9405 " candidate 2: %q+#F", cand2
->fn
);
9412 add_warning (cand1
, cand2
);
9415 parms1
= TREE_CHAIN (parms1
);
9416 parms2
= TREE_CHAIN (parms2
);
9424 /* Extension: If the worst conversion for one candidate is worse than the
9425 worst conversion for the other, take the first. */
9426 if (!pedantic
&& (complain
& tf_warning_or_error
))
9428 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
9429 struct z_candidate
*w
= 0, *l
= 0;
9431 for (i
= 0; i
< len
; ++i
)
9433 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
9434 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
9435 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
9436 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
9439 winner
= 1, w
= cand1
, l
= cand2
;
9441 winner
= -1, w
= cand2
, l
= cand1
;
9444 /* Don't choose a deleted function over ambiguity. */
9445 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
9449 pedwarn (input_location
, 0,
9450 "ISO C++ says that these are ambiguous, even "
9451 "though the worst conversion for the first is better than "
9452 "the worst conversion for the second:");
9453 print_z_candidate (input_location
, _("candidate 1:"), w
);
9454 print_z_candidate (input_location
, _("candidate 2:"), l
);
9462 gcc_assert (!winner
);
9466 /* Given a list of candidates for overloading, find the best one, if any.
9467 This algorithm has a worst case of O(2n) (winner is last), and a best
9468 case of O(n/2) (totally ambiguous); much better than a sorting
9471 static struct z_candidate
*
9472 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
9474 struct z_candidate
*champ
= candidates
, *challenger
;
9476 int champ_compared_to_predecessor
= 0;
9478 /* Walk through the list once, comparing each current champ to the next
9479 candidate, knocking out a candidate or two with each comparison. */
9481 for (challenger
= champ
->next
; challenger
; )
9483 fate
= joust (champ
, challenger
, 0, complain
);
9485 challenger
= challenger
->next
;
9490 champ
= challenger
->next
;
9493 champ_compared_to_predecessor
= 0;
9498 champ_compared_to_predecessor
= 1;
9501 challenger
= champ
->next
;
9505 /* Make sure the champ is better than all the candidates it hasn't yet
9506 been compared to. */
9508 for (challenger
= candidates
;
9510 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
9511 challenger
= challenger
->next
)
9513 fate
= joust (champ
, challenger
, 0, complain
);
9521 /* Returns nonzero if things of type FROM can be converted to TO. */
9524 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
9526 tree arg
= NULL_TREE
;
9527 /* implicit_conversion only considers user-defined conversions
9528 if it has an expression for the call argument list. */
9529 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
9530 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
9531 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
9534 /* Returns nonzero if things of type FROM can be converted to TO with a
9535 standard conversion. */
9538 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
9540 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
9543 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
9546 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
9547 tsubst_flags_t complain
)
9553 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9554 p
= conversion_obstack_alloc (0);
9555 /* We want to discard any access checks done for this test,
9556 as we might not be in the appropriate access context and
9557 we'll do the check again when we actually perform the
9559 push_deferring_access_checks (dk_deferred
);
9561 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9563 ok_p
= (t
&& !t
->bad_p
);
9565 /* Discard the access checks now. */
9566 pop_deferring_access_checks ();
9567 /* Free all the conversions we allocated. */
9568 obstack_free (&conversion_obstack
, p
);
9573 /* Like can_convert_arg, but allows dubious conversions as well. */
9576 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
9577 tsubst_flags_t complain
)
9582 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9583 p
= conversion_obstack_alloc (0);
9584 /* Try to perform the conversion. */
9585 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9587 /* Free all the conversions we allocated. */
9588 obstack_free (&conversion_obstack
, p
);
9593 /* Convert EXPR to TYPE. Return the converted expression.
9595 Note that we allow bad conversions here because by the time we get to
9596 this point we are committed to doing the conversion. If we end up
9597 doing a bad conversion, convert_like will complain. */
9600 perform_implicit_conversion_flags (tree type
, tree expr
,
9601 tsubst_flags_t complain
, int flags
)
9605 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9607 if (error_operand_p (expr
))
9608 return error_mark_node
;
9610 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9611 p
= conversion_obstack_alloc (0);
9613 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9619 if (complain
& tf_error
)
9621 /* If expr has unknown type, then it is an overloaded function.
9622 Call instantiate_type to get good error messages. */
9623 if (TREE_TYPE (expr
) == unknown_type_node
)
9624 instantiate_type (type
, expr
, complain
);
9625 else if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
9626 /* We gave an error. */;
9628 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
9629 TREE_TYPE (expr
), type
);
9631 expr
= error_mark_node
;
9633 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
9635 /* In a template, we are only concerned about determining the
9636 type of non-dependent expressions, so we do not have to
9637 perform the actual conversion. But for initializers, we
9638 need to be able to perform it at instantiation
9639 (or instantiate_non_dependent_expr) time. */
9640 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
9641 if (!(flags
& LOOKUP_ONLYCONVERTING
))
9642 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
9645 expr
= convert_like (conv
, expr
, complain
);
9647 /* Free all the conversions we allocated. */
9648 obstack_free (&conversion_obstack
, p
);
9654 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
9656 return perform_implicit_conversion_flags (type
, expr
, complain
,
9660 /* Convert EXPR to TYPE (as a direct-initialization) if that is
9661 permitted. If the conversion is valid, the converted expression is
9662 returned. Otherwise, NULL_TREE is returned, except in the case
9663 that TYPE is a class type; in that case, an error is issued. If
9664 C_CAST_P is true, then this direct-initialization is taking
9665 place as part of a static_cast being attempted as part of a C-style
9669 perform_direct_initialization_if_possible (tree type
,
9672 tsubst_flags_t complain
)
9677 if (type
== error_mark_node
|| error_operand_p (expr
))
9678 return error_mark_node
;
9681 If the destination type is a (possibly cv-qualified) class type:
9683 -- If the initialization is direct-initialization ...,
9684 constructors are considered. ... If no constructor applies, or
9685 the overload resolution is ambiguous, the initialization is
9687 if (CLASS_TYPE_P (type
))
9689 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
9690 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
9691 &args
, type
, LOOKUP_NORMAL
, complain
);
9692 release_tree_vector (args
);
9693 return build_cplus_new (type
, expr
, complain
);
9696 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9697 p
= conversion_obstack_alloc (0);
9699 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9701 LOOKUP_NORMAL
, complain
);
9702 if (!conv
|| conv
->bad_p
)
9705 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
9706 /*issue_conversion_warnings=*/false,
9710 /* Free all the conversions we allocated. */
9711 obstack_free (&conversion_obstack
, p
);
9716 /* When initializing a reference that lasts longer than a full-expression,
9717 this special rule applies:
9721 The temporary to which the reference is bound or the temporary
9722 that is the complete object to which the reference is bound
9723 persists for the lifetime of the reference.
9725 The temporaries created during the evaluation of the expression
9726 initializing the reference, except the temporary to which the
9727 reference is bound, are destroyed at the end of the
9728 full-expression in which they are created.
9730 In that case, we store the converted expression into a new
9731 VAR_DECL in a new scope.
9733 However, we want to be careful not to create temporaries when
9734 they are not required. For example, given:
9737 struct D : public B {};
9741 there is no need to copy the return value from "f"; we can just
9742 extend its lifetime. Similarly, given:
9745 struct T { operator S(); };
9749 we can extend the lifetime of the return value of the conversion
9752 The next several functions are involved in this lifetime extension. */
9754 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9755 reference is being bound to a temporary. Create and return a new
9756 VAR_DECL with the indicated TYPE; this variable will store the value to
9757 which the reference is bound. */
9760 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
9764 /* Create the variable. */
9765 var
= create_temporary_var (type
);
9767 /* Register the variable. */
9769 && (TREE_STATIC (decl
) || CP_DECL_THREAD_LOCAL_P (decl
)))
9771 /* Namespace-scope or local static; give it a mangled name. */
9772 /* FIXME share comdat with decl? */
9775 TREE_STATIC (var
) = TREE_STATIC (decl
);
9776 CP_DECL_THREAD_LOCAL_P (var
) = CP_DECL_THREAD_LOCAL_P (decl
);
9777 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
9778 name
= mangle_ref_init_variable (decl
);
9779 DECL_NAME (var
) = name
;
9780 SET_DECL_ASSEMBLER_NAME (var
, name
);
9781 var
= pushdecl_top_level (var
);
9784 /* Create a new cleanup level if necessary. */
9785 maybe_push_cleanup_level (type
);
9790 /* EXPR is the initializer for a variable DECL of reference or
9791 std::initializer_list type. Create, push and return a new VAR_DECL
9792 for the initializer so that it will live as long as DECL. Any
9793 cleanup for the new variable is returned through CLEANUP, and the
9794 code to initialize the new variable is returned through INITP. */
9797 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
9804 /* Create the temporary variable. */
9805 type
= TREE_TYPE (expr
);
9806 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
9807 layout_decl (var
, 0);
9808 /* If the rvalue is the result of a function call it will be
9809 a TARGET_EXPR. If it is some other construct (such as a
9810 member access expression where the underlying object is
9811 itself the result of a function call), turn it into a
9812 TARGET_EXPR here. It is important that EXPR be a
9813 TARGET_EXPR below since otherwise the INIT_EXPR will
9814 attempt to make a bitwise copy of EXPR to initialize
9816 if (TREE_CODE (expr
) != TARGET_EXPR
)
9817 expr
= get_target_expr (expr
);
9819 if (TREE_CODE (decl
) == FIELD_DECL
9820 && extra_warnings
&& !TREE_NO_WARNING (decl
))
9822 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
9823 "until the constructor exits", decl
);
9824 TREE_NO_WARNING (decl
) = true;
9827 /* Recursively extend temps in this initializer. */
9828 TARGET_EXPR_INITIAL (expr
)
9829 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
9831 /* Any reference temp has a non-trivial initializer. */
9832 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
9834 /* If the initializer is constant, put it in DECL_INITIAL so we get
9835 static initialization and use in constant expressions. */
9836 init
= maybe_constant_init (expr
);
9837 if (TREE_CONSTANT (init
))
9839 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
9841 /* 5.19 says that a constant expression can include an
9842 lvalue-rvalue conversion applied to "a glvalue of literal type
9843 that refers to a non-volatile temporary object initialized
9844 with a constant expression". Rather than try to communicate
9845 that this VAR_DECL is a temporary, just mark it constexpr.
9847 Currently this is only useful for initializer_list temporaries,
9848 since reference vars can't appear in constant expressions. */
9849 DECL_DECLARED_CONSTEXPR_P (var
) = true;
9850 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
9851 TREE_CONSTANT (var
) = true;
9853 DECL_INITIAL (var
) = init
;
9857 /* Create the INIT_EXPR that will initialize the temporary
9859 init
= split_nonconstant_init (var
, expr
);
9860 if (at_function_scope_p ())
9862 add_decl_expr (var
);
9864 if (TREE_STATIC (var
))
9865 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
9868 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9870 vec_safe_push (*cleanups
, cleanup
);
9873 /* We must be careful to destroy the temporary only
9874 after its initialization has taken place. If the
9875 initialization throws an exception, then the
9876 destructor should not be run. We cannot simply
9877 transform INIT into something like:
9879 (INIT, ({ CLEANUP_STMT; }))
9881 because emit_local_var always treats the
9882 initializer as a full-expression. Thus, the
9883 destructor would run too early; it would run at the
9884 end of initializing the reference variable, rather
9885 than at the end of the block enclosing the
9888 The solution is to pass back a cleanup expression
9889 which the caller is responsible for attaching to
9890 the statement tree. */
9894 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
9895 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9897 if (CP_DECL_THREAD_LOCAL_P (var
))
9898 tls_aggregates
= tree_cons (NULL_TREE
, var
,
9901 static_aggregates
= tree_cons (NULL_TREE
, var
,
9905 /* Check whether the dtor is callable. */
9906 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9908 /* Avoid -Wunused-variable warning (c++/38958). */
9909 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
9911 TREE_USED (decl
) = DECL_READ_P (decl
) = true;
9917 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9918 initializing a variable of that TYPE. */
9921 initialize_reference (tree type
, tree expr
,
9922 int flags
, tsubst_flags_t complain
)
9926 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9928 if (type
== error_mark_node
|| error_operand_p (expr
))
9929 return error_mark_node
;
9931 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9932 p
= conversion_obstack_alloc (0);
9934 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
9936 if (!conv
|| conv
->bad_p
)
9938 if (complain
& tf_error
)
9941 convert_like (conv
, expr
, complain
);
9942 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
9943 && !TYPE_REF_IS_RVALUE (type
)
9944 && !real_lvalue_p (expr
))
9945 error_at (loc
, "invalid initialization of non-const reference of "
9946 "type %qT from an rvalue of type %qT",
9947 type
, TREE_TYPE (expr
));
9949 error_at (loc
, "invalid initialization of reference of type "
9950 "%qT from expression of type %qT", type
,
9953 return error_mark_node
;
9956 if (conv
->kind
== ck_ref_bind
)
9957 /* Perform the conversion. */
9958 expr
= convert_like (conv
, expr
, complain
);
9959 else if (conv
->kind
== ck_ambig
)
9960 /* We gave an error in build_user_type_conversion_1. */
9961 expr
= error_mark_node
;
9965 /* Free all the conversions we allocated. */
9966 obstack_free (&conversion_obstack
, p
);
9971 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9972 which is bound either to a reference or a std::initializer_list. */
9975 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9980 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
9982 TREE_OPERAND (sub
, 1)
9983 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
9986 if (TREE_CODE (sub
) != ADDR_EXPR
)
9988 /* Deal with binding to a subobject. */
9989 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
9990 p
= &TREE_OPERAND (*p
, 0);
9991 if (TREE_CODE (*p
) == TARGET_EXPR
)
9993 tree subinit
= NULL_TREE
;
9994 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
9995 recompute_tree_invariant_for_addr_expr (sub
);
9997 init
= fold_convert (TREE_TYPE (init
), sub
);
9999 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
10004 /* INIT is part of the initializer for DECL. If there are any
10005 reference or initializer lists being initialized, extend their
10006 lifetime to match that of DECL. */
10009 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
10011 tree type
= TREE_TYPE (init
);
10012 if (processing_template_decl
)
10014 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10015 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
10016 else if (is_std_init_list (type
))
10018 /* The temporary array underlying a std::initializer_list
10019 is handled like a reference temporary. */
10021 if (TREE_CODE (ctor
) == TARGET_EXPR
)
10022 ctor
= TARGET_EXPR_INITIAL (ctor
);
10023 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
10025 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
10026 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
10027 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
10030 else if (TREE_CODE (init
) == CONSTRUCTOR
)
10033 constructor_elt
*p
;
10034 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
10035 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
10036 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
10042 /* Returns true iff an initializer for TYPE could contain temporaries that
10043 need to be extended because they are bound to references or
10044 std::initializer_list. */
10047 type_has_extended_temps (tree type
)
10049 type
= strip_array_types (type
);
10050 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10052 if (CLASS_TYPE_P (type
))
10054 if (is_std_init_list (type
))
10056 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
10057 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
10058 if (type_has_extended_temps (TREE_TYPE (f
)))
10064 /* Returns true iff TYPE is some variant of std::initializer_list. */
10067 is_std_init_list (tree type
)
10069 /* Look through typedefs. */
10070 if (!TYPE_P (type
))
10072 if (cxx_dialect
== cxx98
)
10074 type
= TYPE_MAIN_VARIANT (type
);
10075 return (CLASS_TYPE_P (type
)
10076 && CP_TYPE_CONTEXT (type
) == std_node
10077 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
10080 /* Returns true iff DECL is a list constructor: i.e. a constructor which
10081 will accept an argument list of a single std::initializer_list<T>. */
10084 is_list_ctor (tree decl
)
10086 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
10089 if (!args
|| args
== void_list_node
)
10092 arg
= non_reference (TREE_VALUE (args
));
10093 if (!is_std_init_list (arg
))
10096 args
= TREE_CHAIN (args
);
10098 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
10099 /* There are more non-defaulted parms. */
10105 #include "gt-cp-call.h"