1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987-2014 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"
30 #include "stor-layout.h"
31 #include "trans-mem.h"
32 #include "stringpool.h"
36 #include "diagnostic-core.h"
40 #include "langhooks.h"
41 #include "c-family/c-objc.h"
45 #include "plugin-api.h"
50 #include "hard-reg-set.h"
57 /* The various kinds of conversion. */
59 typedef enum conversion_kind
{
75 /* The rank of the conversion. Order of the enumerals matters; better
76 conversions should come earlier in the list. */
78 typedef enum conversion_rank
{
89 /* An implicit conversion sequence, in the sense of [over.best.ics].
90 The first conversion to be performed is at the end of the chain.
91 That conversion is always a cr_identity conversion. */
93 typedef struct conversion conversion
;
95 /* The kind of conversion represented by this step. */
97 /* The rank of this conversion. */
99 BOOL_BITFIELD user_conv_p
: 1;
100 BOOL_BITFIELD ellipsis_p
: 1;
101 BOOL_BITFIELD this_p
: 1;
102 /* True if this conversion would be permitted with a bending of
103 language standards, e.g. disregarding pointer qualifiers or
104 converting integers to pointers. */
105 BOOL_BITFIELD bad_p
: 1;
106 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
107 temporary should be created to hold the result of the
109 BOOL_BITFIELD need_temporary_p
: 1;
110 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
111 from a pointer-to-derived to pointer-to-base is being performed. */
112 BOOL_BITFIELD base_p
: 1;
113 /* If KIND is ck_ref_bind, true when either an lvalue reference is
114 being bound to an lvalue expression or an rvalue reference is
115 being bound to an rvalue expression. If KIND is ck_rvalue,
116 true when we should treat an lvalue as an rvalue (12.8p33). If
117 KIND is ck_base, always false. */
118 BOOL_BITFIELD rvaluedness_matches_p
: 1;
119 BOOL_BITFIELD check_narrowing
: 1;
120 /* The type of the expression resulting from the conversion. */
123 /* The next conversion in the chain. Since the conversions are
124 arranged from outermost to innermost, the NEXT conversion will
125 actually be performed before this conversion. This variant is
126 used only when KIND is neither ck_identity, ck_ambig nor
127 ck_list. Please use the next_conversion function instead
128 of using this field directly. */
130 /* The expression at the beginning of the conversion chain. This
131 variant is used only if KIND is ck_identity or ck_ambig. */
133 /* The array of conversions for an initializer_list, so this
134 variant is used only when KIN D is ck_list. */
137 /* The function candidate corresponding to this conversion
138 sequence. This field is only used if KIND is ck_user. */
139 struct z_candidate
*cand
;
142 #define CONVERSION_RANK(NODE) \
143 ((NODE)->bad_p ? cr_bad \
144 : (NODE)->ellipsis_p ? cr_ellipsis \
145 : (NODE)->user_conv_p ? cr_user \
148 #define BAD_CONVERSION_RANK(NODE) \
149 ((NODE)->ellipsis_p ? cr_ellipsis \
150 : (NODE)->user_conv_p ? cr_user \
153 static struct obstack conversion_obstack
;
154 static bool conversion_obstack_initialized
;
155 struct rejection_reason
;
157 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
158 static int equal_functions (tree
, tree
);
159 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
161 static int compare_ics (conversion
*, conversion
*);
162 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
163 static tree
build_java_interface_fn_ref (tree
, tree
);
164 #define convert_like(CONV, EXPR, COMPLAIN) \
165 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
166 /*issue_conversion_warnings=*/true, \
167 /*c_cast_p=*/false, (COMPLAIN))
168 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
169 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
170 /*issue_conversion_warnings=*/true, \
171 /*c_cast_p=*/false, (COMPLAIN))
172 static tree
convert_like_real (conversion
*, tree
, tree
, int, int, bool,
173 bool, tsubst_flags_t
);
174 static void op_error (location_t
, enum tree_code
, enum tree_code
, tree
,
176 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
178 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
179 static void print_z_candidates (location_t
, struct z_candidate
*);
180 static tree
build_this (tree
);
181 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
182 static bool any_strictly_viable (struct z_candidate
*);
183 static struct z_candidate
*add_template_candidate
184 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
185 tree
, tree
, tree
, int, unification_kind_t
, tsubst_flags_t
);
186 static struct z_candidate
*add_template_candidate_real
187 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
188 tree
, tree
, tree
, int, tree
, unification_kind_t
, tsubst_flags_t
);
189 static struct z_candidate
*add_template_conv_candidate
190 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
191 tree
, tree
, tree
, tsubst_flags_t
);
192 static void add_builtin_candidates
193 (struct z_candidate
**, enum tree_code
, enum tree_code
,
194 tree
, tree
*, int, tsubst_flags_t
);
195 static void add_builtin_candidate
196 (struct z_candidate
**, enum tree_code
, enum tree_code
,
197 tree
, tree
, tree
, tree
*, tree
*, int, tsubst_flags_t
);
198 static bool is_complete (tree
);
199 static void build_builtin_candidate
200 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
201 int, tsubst_flags_t
);
202 static struct z_candidate
*add_conv_candidate
203 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
204 tree
, tsubst_flags_t
);
205 static struct z_candidate
*add_function_candidate
206 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
207 tree
, int, tsubst_flags_t
);
208 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
210 static conversion
*standard_conversion (tree
, tree
, tree
, bool, int);
211 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
213 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
214 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
215 static conversion
*next_conversion (conversion
*);
216 static bool is_subseq (conversion
*, conversion
*);
217 static conversion
*maybe_handle_ref_bind (conversion
**);
218 static void maybe_handle_implicit_object (conversion
**);
219 static struct z_candidate
*add_candidate
220 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
221 conversion
**, tree
, tree
, int, struct rejection_reason
*, int);
222 static tree
source_type (conversion
*);
223 static void add_warning (struct z_candidate
*, struct z_candidate
*);
224 static bool reference_compatible_p (tree
, tree
);
225 static conversion
*direct_reference_binding (tree
, conversion
*);
226 static bool promoted_arithmetic_type_p (tree
);
227 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
228 static char *name_as_c_string (tree
, tree
, bool *);
229 static tree
prep_operand (tree
);
230 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
231 bool, tree
, tree
, int, struct z_candidate
**,
233 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
234 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
236 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
237 NAME can take many forms... */
240 check_dtor_name (tree basetype
, tree name
)
242 /* Just accept something we've already complained about. */
243 if (name
== error_mark_node
)
246 if (TREE_CODE (name
) == TYPE_DECL
)
247 name
= TREE_TYPE (name
);
248 else if (TYPE_P (name
))
250 else if (identifier_p (name
))
252 if ((MAYBE_CLASS_TYPE_P (basetype
)
253 && name
== constructor_name (basetype
))
254 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
255 && name
== TYPE_IDENTIFIER (basetype
)))
258 name
= get_type_value (name
);
264 template <class T> struct S { ~S(); };
268 NAME will be a class template. */
269 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
273 if (!name
|| name
== error_mark_node
)
275 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
278 /* We want the address of a function or method. We avoid creating a
279 pointer-to-member function. */
282 build_addr_func (tree function
, tsubst_flags_t complain
)
284 tree type
= TREE_TYPE (function
);
286 /* We have to do these by hand to avoid real pointer to member
288 if (TREE_CODE (type
) == METHOD_TYPE
)
290 if (TREE_CODE (function
) == OFFSET_REF
)
292 tree object
= build_address (TREE_OPERAND (function
, 0));
293 return get_member_function_from_ptrfunc (&object
,
294 TREE_OPERAND (function
, 1),
297 function
= build_address (function
);
300 function
= decay_conversion (function
, complain
);
305 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
306 POINTER_TYPE to those. Note, pointer to member function types
307 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
308 two variants. build_call_a is the primitive taking an array of
309 arguments, while build_call_n is a wrapper that handles varargs. */
312 build_call_n (tree function
, int n
, ...)
315 return build_call_a (function
, 0, NULL
);
318 tree
*argarray
= XALLOCAVEC (tree
, n
);
323 for (i
= 0; i
< n
; i
++)
324 argarray
[i
] = va_arg (ap
, tree
);
326 return build_call_a (function
, n
, argarray
);
330 /* Update various flags in cfun and the call itself based on what is being
331 called. Split out of build_call_a so that bot_manip can use it too. */
334 set_flags_from_callee (tree call
)
337 tree decl
= get_callee_fndecl (call
);
339 /* We check both the decl and the type; a function may be known not to
340 throw without being declared throw(). */
341 nothrow
= ((decl
&& TREE_NOTHROW (decl
))
342 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call
)))));
344 if (!nothrow
&& at_function_scope_p () && cfun
&& cp_function_chain
)
345 cp_function_chain
->can_throw
= 1;
347 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
&& cp_function_chain
)
348 current_function_returns_abnormally
= 1;
350 TREE_NOTHROW (call
) = nothrow
;
354 build_call_a (tree function
, int n
, tree
*argarray
)
361 function
= build_addr_func (function
, tf_warning_or_error
);
363 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
364 fntype
= TREE_TYPE (TREE_TYPE (function
));
365 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
366 || TREE_CODE (fntype
) == METHOD_TYPE
);
367 result_type
= TREE_TYPE (fntype
);
368 /* An rvalue has no cv-qualifiers. */
369 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
370 result_type
= cv_unqualified (result_type
);
372 function
= build_call_array_loc (input_location
,
373 result_type
, function
, n
, argarray
);
374 set_flags_from_callee (function
);
376 decl
= get_callee_fndecl (function
);
378 if (decl
&& !TREE_USED (decl
))
380 /* We invoke build_call directly for several library
381 functions. These may have been declared normally if
382 we're building libgcc, so we can't just check
384 gcc_assert (DECL_ARTIFICIAL (decl
)
385 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
390 if (decl
&& TREE_DEPRECATED (decl
))
391 warn_deprecated_use (decl
, NULL_TREE
);
392 require_complete_eh_spec_types (fntype
, decl
);
394 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
396 /* Don't pass empty class objects by value. This is useful
397 for tags in STL, which are used to control overload resolution.
398 We don't need to handle other cases of copying empty classes. */
399 if (! decl
|| ! DECL_BUILT_IN (decl
))
400 for (i
= 0; i
< n
; i
++)
402 tree arg
= CALL_EXPR_ARG (function
, i
);
403 if (is_empty_class (TREE_TYPE (arg
))
404 && ! TREE_ADDRESSABLE (TREE_TYPE (arg
)))
406 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (arg
));
407 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (t
), arg
, t
);
408 CALL_EXPR_ARG (function
, i
) = arg
;
415 /* Build something of the form ptr->method (args)
416 or object.method (args). This can also build
417 calls to constructors, and find friends.
419 Member functions always take their class variable
422 INSTANCE is a class instance.
424 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
426 PARMS help to figure out what that NAME really refers to.
428 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
429 down to the real instance type to use for access checking. We need this
430 information to get protected accesses correct.
432 FLAGS is the logical disjunction of zero or more LOOKUP_
433 flags. See cp-tree.h for more info.
435 If this is all OK, calls build_function_call with the resolved
438 This function must also handle being called to perform
439 initialization, promotion/coercion of arguments, and
440 instantiation of default parameters.
442 Note that NAME may refer to an instance variable name. If
443 `operator()()' is defined for the type of that field, then we return
446 /* New overloading code. */
448 typedef struct z_candidate z_candidate
;
450 typedef struct candidate_warning candidate_warning
;
451 struct candidate_warning
{
453 candidate_warning
*next
;
456 /* Information for providing diagnostics about why overloading failed. */
458 enum rejection_reason_code
{
461 rr_explicit_conversion
,
462 rr_template_conversion
,
464 rr_bad_arg_conversion
,
465 rr_template_unification
,
469 struct conversion_info
{
470 /* The index of the argument, 0-based. */
472 /* The actual argument or its type. */
474 /* The type of the parameter. */
478 struct rejection_reason
{
479 enum rejection_reason_code code
;
481 /* Information about an arity mismatch. */
483 /* The expected number of arguments. */
485 /* The actual number of arguments in the call. */
487 /* Whether the call was a varargs call. */
490 /* Information about an argument conversion mismatch. */
491 struct conversion_info conversion
;
492 /* Same, but for bad argument conversions. */
493 struct conversion_info bad_conversion
;
494 /* Information about template unification failures. These are the
495 parameters passed to fn_type_unification. */
503 unification_kind_t strict
;
505 } template_unification
;
506 /* Information about template instantiation failures. These are the
507 parameters passed to instantiate_template. */
511 } template_instantiation
;
516 /* The FUNCTION_DECL that will be called if this candidate is
517 selected by overload resolution. */
519 /* If not NULL_TREE, the first argument to use when calling this
522 /* The rest of the arguments to use when calling this function. If
523 there are no further arguments this may be NULL or it may be an
525 const vec
<tree
, va_gc
> *args
;
526 /* The implicit conversion sequences for each of the arguments to
529 /* The number of implicit conversion sequences. */
531 /* If FN is a user-defined conversion, the standard conversion
532 sequence from the type returned by FN to the desired destination
534 conversion
*second_conv
;
535 struct rejection_reason
*reason
;
536 /* If FN is a member function, the binfo indicating the path used to
537 qualify the name of FN at the call site. This path is used to
538 determine whether or not FN is accessible if it is selected by
539 overload resolution. The DECL_CONTEXT of FN will always be a
540 (possibly improper) base of this binfo. */
542 /* If FN is a non-static member function, the binfo indicating the
543 subobject to which the `this' pointer should be converted if FN
544 is selected by overload resolution. The type pointed to by
545 the `this' pointer must correspond to the most derived class
546 indicated by the CONVERSION_PATH. */
547 tree conversion_path
;
550 candidate_warning
*warnings
;
554 /* The flags active in add_candidate. */
558 /* Returns true iff T is a null pointer constant in the sense of
562 null_ptr_cst_p (tree t
)
566 A null pointer constant is an integral constant expression
567 (_expr.const_) rvalue of integer type that evaluates to zero or
568 an rvalue of type std::nullptr_t. */
569 if (NULLPTR_TYPE_P (TREE_TYPE (t
)))
571 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t
)))
573 /* Core issue 903 says only literal 0 is a null pointer constant. */
574 if (cxx_dialect
< cxx11
)
575 t
= maybe_constant_value (fold_non_dependent_expr_sfinae (t
, tf_none
));
577 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
583 /* Returns true iff T is a null member pointer value (4.11). */
586 null_member_pointer_value_p (tree t
)
588 tree type
= TREE_TYPE (t
);
591 else if (TYPE_PTRMEMFUNC_P (type
))
592 return (TREE_CODE (t
) == CONSTRUCTOR
593 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
594 else if (TYPE_PTRDATAMEM_P (type
))
595 return integer_all_onesp (t
);
600 /* Returns nonzero if PARMLIST consists of only default parms,
601 ellipsis, and/or undeduced parameter packs. */
604 sufficient_parms_p (const_tree parmlist
)
606 for (; parmlist
&& parmlist
!= void_list_node
;
607 parmlist
= TREE_CHAIN (parmlist
))
608 if (!TREE_PURPOSE (parmlist
)
609 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
614 /* Allocate N bytes of memory from the conversion obstack. The memory
615 is zeroed before being returned. */
618 conversion_obstack_alloc (size_t n
)
621 if (!conversion_obstack_initialized
)
623 gcc_obstack_init (&conversion_obstack
);
624 conversion_obstack_initialized
= true;
626 p
= obstack_alloc (&conversion_obstack
, n
);
631 /* Allocate rejection reasons. */
633 static struct rejection_reason
*
634 alloc_rejection (enum rejection_reason_code code
)
636 struct rejection_reason
*p
;
637 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
642 static struct rejection_reason
*
643 arity_rejection (tree first_arg
, int expected
, int actual
)
645 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
646 int adjust
= first_arg
!= NULL_TREE
;
647 r
->u
.arity
.expected
= expected
- adjust
;
648 r
->u
.arity
.actual
= actual
- adjust
;
652 static struct rejection_reason
*
653 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
655 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
656 int adjust
= first_arg
!= NULL_TREE
;
657 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
658 r
->u
.conversion
.from
= from
;
659 r
->u
.conversion
.to_type
= to
;
663 static struct rejection_reason
*
664 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
666 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
667 int adjust
= first_arg
!= NULL_TREE
;
668 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
669 r
->u
.bad_conversion
.from
= from
;
670 r
->u
.bad_conversion
.to_type
= to
;
674 static struct rejection_reason
*
675 explicit_conversion_rejection (tree from
, tree to
)
677 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
678 r
->u
.conversion
.n_arg
= 0;
679 r
->u
.conversion
.from
= from
;
680 r
->u
.conversion
.to_type
= to
;
684 static struct rejection_reason
*
685 template_conversion_rejection (tree from
, tree to
)
687 struct rejection_reason
*r
= alloc_rejection (rr_template_conversion
);
688 r
->u
.conversion
.n_arg
= 0;
689 r
->u
.conversion
.from
= from
;
690 r
->u
.conversion
.to_type
= to
;
694 static struct rejection_reason
*
695 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
696 const tree
*args
, unsigned int nargs
,
697 tree return_type
, unification_kind_t strict
,
700 size_t args_n_bytes
= sizeof (*args
) * nargs
;
701 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
702 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
703 r
->u
.template_unification
.tmpl
= tmpl
;
704 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
705 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
706 /* Copy args to our own storage. */
707 memcpy (args1
, args
, args_n_bytes
);
708 r
->u
.template_unification
.args
= args1
;
709 r
->u
.template_unification
.nargs
= nargs
;
710 r
->u
.template_unification
.return_type
= return_type
;
711 r
->u
.template_unification
.strict
= strict
;
712 r
->u
.template_unification
.flags
= flags
;
716 static struct rejection_reason
*
717 template_unification_error_rejection (void)
719 return alloc_rejection (rr_template_unification
);
722 static struct rejection_reason
*
723 invalid_copy_with_fn_template_rejection (void)
725 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
729 /* Dynamically allocate a conversion. */
732 alloc_conversion (conversion_kind kind
)
735 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
740 #ifdef ENABLE_CHECKING
742 /* Make sure that all memory on the conversion obstack has been
746 validate_conversion_obstack (void)
748 if (conversion_obstack_initialized
)
749 gcc_assert ((obstack_next_free (&conversion_obstack
)
750 == obstack_base (&conversion_obstack
)));
753 #endif /* ENABLE_CHECKING */
755 /* Dynamically allocate an array of N conversions. */
758 alloc_conversions (size_t n
)
760 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
764 build_conv (conversion_kind code
, tree type
, conversion
*from
)
767 conversion_rank rank
= CONVERSION_RANK (from
);
769 /* Note that the caller is responsible for filling in t->cand for
770 user-defined conversions. */
771 t
= alloc_conversion (code
);
794 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
795 t
->bad_p
= from
->bad_p
;
800 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
801 specialization of std::initializer_list<T>, if such a conversion is
805 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
807 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
808 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
809 conversion
**subconvs
= alloc_conversions (len
);
814 /* Within a list-initialization we can have more user-defined
816 flags
&= ~LOOKUP_NO_CONVERSION
;
817 /* But no narrowing conversions. */
818 flags
|= LOOKUP_NO_NARROWING
;
820 /* Can't make an array of these types. */
821 if (TREE_CODE (elttype
) == REFERENCE_TYPE
822 || TREE_CODE (elttype
) == FUNCTION_TYPE
823 || VOID_TYPE_P (elttype
))
826 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
829 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
830 false, flags
, complain
);
837 t
= alloc_conversion (ck_list
);
839 t
->u
.list
= subconvs
;
842 for (i
= 0; i
< len
; ++i
)
844 conversion
*sub
= subconvs
[i
];
845 if (sub
->rank
> t
->rank
)
847 if (sub
->user_conv_p
)
848 t
->user_conv_p
= true;
856 /* Return the next conversion of the conversion chain (if applicable),
857 or NULL otherwise. Please use this function instead of directly
858 accessing fields of struct conversion. */
861 next_conversion (conversion
*conv
)
864 || conv
->kind
== ck_identity
865 || conv
->kind
== ck_ambig
866 || conv
->kind
== ck_list
)
871 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
872 is a valid aggregate initializer for array type ATYPE. */
875 can_convert_array (tree atype
, tree ctor
, int flags
, tsubst_flags_t complain
)
878 tree elttype
= TREE_TYPE (atype
);
879 for (i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
881 tree val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
883 if (TREE_CODE (elttype
) == ARRAY_TYPE
884 && TREE_CODE (val
) == CONSTRUCTOR
)
885 ok
= can_convert_array (elttype
, val
, flags
, complain
);
887 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
895 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
896 aggregate class, if such a conversion is possible. */
899 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
901 unsigned HOST_WIDE_INT i
= 0;
903 tree field
= next_initializable_field (TYPE_FIELDS (type
));
904 tree empty_ctor
= NULL_TREE
;
906 ctor
= reshape_init (type
, ctor
, tf_none
);
907 if (ctor
== error_mark_node
)
910 /* The conversions within the init-list aren't affected by the enclosing
911 context; they're always simple copy-initialization. */
912 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
914 for (; field
; field
= next_initializable_field (DECL_CHAIN (field
)))
916 tree ftype
= TREE_TYPE (field
);
920 if (i
< CONSTRUCTOR_NELTS (ctor
))
921 val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
922 else if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
923 /* Value-initialization of reference is ill-formed. */
927 if (empty_ctor
== NULL_TREE
)
928 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
933 if (TREE_CODE (ftype
) == ARRAY_TYPE
934 && TREE_CODE (val
) == CONSTRUCTOR
)
935 ok
= can_convert_array (ftype
, val
, flags
, complain
);
937 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
943 if (TREE_CODE (type
) == UNION_TYPE
)
947 if (i
< CONSTRUCTOR_NELTS (ctor
))
950 c
= alloc_conversion (ck_aggr
);
953 c
->user_conv_p
= true;
954 c
->check_narrowing
= true;
959 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
960 array type, if such a conversion is possible. */
963 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
966 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
967 tree elttype
= TREE_TYPE (type
);
972 enum conversion_rank rank
= cr_exact
;
974 /* We might need to propagate the size from the element to the array. */
975 complete_type (type
);
977 if (TYPE_DOMAIN (type
)
978 && !variably_modified_type_p (TYPE_DOMAIN (type
), NULL_TREE
))
980 unsigned HOST_WIDE_INT alen
= tree_to_uhwi (array_type_nelts_top (type
));
985 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
987 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
990 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
991 false, flags
, complain
);
995 if (sub
->rank
> rank
)
997 if (sub
->user_conv_p
)
1003 c
= alloc_conversion (ck_aggr
);
1006 c
->user_conv_p
= user
;
1012 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
1013 complex type, if such a conversion is possible. */
1016 build_complex_conv (tree type
, tree ctor
, int flags
,
1017 tsubst_flags_t complain
)
1020 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
1021 tree elttype
= TREE_TYPE (type
);
1026 enum conversion_rank rank
= cr_exact
;
1031 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
1033 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
1036 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
1037 false, flags
, complain
);
1041 if (sub
->rank
> rank
)
1043 if (sub
->user_conv_p
)
1049 c
= alloc_conversion (ck_aggr
);
1052 c
->user_conv_p
= user
;
1058 /* Build a representation of the identity conversion from EXPR to
1059 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1062 build_identity_conv (tree type
, tree expr
)
1066 c
= alloc_conversion (ck_identity
);
1073 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1074 were multiple user-defined conversions to accomplish the job.
1075 Build a conversion that indicates that ambiguity. */
1078 build_ambiguous_conv (tree type
, tree expr
)
1082 c
= alloc_conversion (ck_ambig
);
1090 strip_top_quals (tree t
)
1092 if (TREE_CODE (t
) == ARRAY_TYPE
)
1094 return cp_build_qualified_type (t
, 0);
1097 /* Returns the standard conversion path (see [conv]) from type FROM to type
1098 TO, if any. For proper handling of null pointer constants, you must
1099 also pass the expression EXPR to convert from. If C_CAST_P is true,
1100 this conversion is coming from a C-style cast. */
1103 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1106 enum tree_code fcode
, tcode
;
1108 bool fromref
= false;
1111 to
= non_reference (to
);
1112 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1115 from
= TREE_TYPE (from
);
1118 to
= strip_top_quals (to
);
1119 from
= strip_top_quals (from
);
1121 if (expr
&& type_unknown_p (expr
))
1123 if (TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1125 tsubst_flags_t tflags
= tf_conv
;
1126 expr
= instantiate_type (to
, expr
, tflags
);
1127 if (expr
== error_mark_node
)
1129 from
= TREE_TYPE (expr
);
1131 else if (TREE_CODE (to
) == BOOLEAN_TYPE
)
1133 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1134 expr
= resolve_nondeduced_context (expr
);
1135 from
= TREE_TYPE (expr
);
1139 fcode
= TREE_CODE (from
);
1140 tcode
= TREE_CODE (to
);
1142 conv
= build_identity_conv (from
, expr
);
1143 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1145 from
= type_decays_to (from
);
1146 fcode
= TREE_CODE (from
);
1147 conv
= build_conv (ck_lvalue
, from
, conv
);
1149 else if (fromref
|| (expr
&& lvalue_p (expr
)))
1154 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1157 from
= strip_top_quals (bitfield_type
);
1158 fcode
= TREE_CODE (from
);
1161 conv
= build_conv (ck_rvalue
, from
, conv
);
1162 if (flags
& LOOKUP_PREFER_RVALUE
)
1163 conv
->rvaluedness_matches_p
= true;
1166 /* Allow conversion between `__complex__' data types. */
1167 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1169 /* The standard conversion sequence to convert FROM to TO is
1170 the standard conversion sequence to perform componentwise
1172 conversion
*part_conv
= standard_conversion
1173 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
);
1177 conv
= build_conv (part_conv
->kind
, to
, conv
);
1178 conv
->rank
= part_conv
->rank
;
1186 if (same_type_p (from
, to
))
1188 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1189 conv
->type
= qualified_to
;
1194 A null pointer constant can be converted to a pointer type; ... A
1195 null pointer constant of integral type can be converted to an
1196 rvalue of type std::nullptr_t. */
1197 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1198 || NULLPTR_TYPE_P (to
))
1199 && expr
&& null_ptr_cst_p (expr
))
1200 conv
= build_conv (ck_std
, to
, conv
);
1201 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1202 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1204 /* For backwards brain damage compatibility, allow interconversion of
1205 pointers and integers with a pedwarn. */
1206 conv
= build_conv (ck_std
, to
, conv
);
1209 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1211 /* For backwards brain damage compatibility, allow interconversion of
1212 enums and integers with a pedwarn. */
1213 conv
= build_conv (ck_std
, to
, conv
);
1216 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1217 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1222 if (tcode
== POINTER_TYPE
1223 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from
),
1226 else if (VOID_TYPE_P (TREE_TYPE (to
))
1227 && !TYPE_PTRDATAMEM_P (from
)
1228 && TREE_CODE (TREE_TYPE (from
)) != FUNCTION_TYPE
)
1230 tree nfrom
= TREE_TYPE (from
);
1231 /* Don't try to apply restrict to void. */
1232 int quals
= cp_type_quals (nfrom
) & ~TYPE_QUAL_RESTRICT
;
1233 from
= build_pointer_type
1234 (cp_build_qualified_type (void_type_node
, quals
));
1235 conv
= build_conv (ck_ptr
, from
, conv
);
1237 else if (TYPE_PTRDATAMEM_P (from
))
1239 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1240 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1242 if (DERIVED_FROM_P (fbase
, tbase
)
1243 && (same_type_ignoring_top_level_qualifiers_p
1244 (TYPE_PTRMEM_POINTED_TO_TYPE (from
),
1245 TYPE_PTRMEM_POINTED_TO_TYPE (to
))))
1247 from
= build_ptrmem_type (tbase
,
1248 TYPE_PTRMEM_POINTED_TO_TYPE (from
));
1249 conv
= build_conv (ck_pmem
, from
, conv
);
1251 else if (!same_type_p (fbase
, tbase
))
1254 else if (CLASS_TYPE_P (TREE_TYPE (from
))
1255 && CLASS_TYPE_P (TREE_TYPE (to
))
1258 An rvalue of type "pointer to cv D," where D is a
1259 class type, can be converted to an rvalue of type
1260 "pointer to cv B," where B is a base class (clause
1261 _class.derived_) of D. If B is an inaccessible
1262 (clause _class.access_) or ambiguous
1263 (_class.member.lookup_) base class of D, a program
1264 that necessitates this conversion is ill-formed.
1265 Therefore, we use DERIVED_FROM_P, and do not check
1266 access or uniqueness. */
1267 && DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
1270 cp_build_qualified_type (TREE_TYPE (to
),
1271 cp_type_quals (TREE_TYPE (from
)));
1272 from
= build_pointer_type (from
);
1273 conv
= build_conv (ck_ptr
, from
, conv
);
1274 conv
->base_p
= true;
1277 if (tcode
== POINTER_TYPE
)
1279 to_pointee
= TREE_TYPE (to
);
1280 from_pointee
= TREE_TYPE (from
);
1284 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1285 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1288 if (same_type_p (from
, to
))
1290 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
1291 /* In a C-style cast, we ignore CV-qualification because we
1292 are allowed to perform a static_cast followed by a
1294 conv
= build_conv (ck_qual
, to
, conv
);
1295 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1296 conv
= build_conv (ck_qual
, to
, conv
);
1297 else if (expr
&& string_conv_p (to
, expr
, 0))
1298 /* converting from string constant to char *. */
1299 conv
= build_conv (ck_qual
, to
, conv
);
1300 /* Allow conversions among compatible ObjC pointer types (base
1301 conversions have been already handled above). */
1302 else if (c_dialect_objc ()
1303 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1304 conv
= build_conv (ck_ptr
, to
, conv
);
1305 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1307 conv
= build_conv (ck_ptr
, to
, conv
);
1315 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1317 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1318 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1319 tree fbase
= class_of_this_parm (fromfn
);
1320 tree tbase
= class_of_this_parm (tofn
);
1322 if (!DERIVED_FROM_P (fbase
, tbase
)
1323 || !same_type_p (static_fn_type (fromfn
),
1324 static_fn_type (tofn
)))
1327 from
= build_memfn_type (fromfn
,
1329 cp_type_quals (tbase
),
1330 type_memfn_rqual (tofn
));
1331 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1332 conv
= build_conv (ck_pmem
, from
, conv
);
1333 conv
->base_p
= true;
1335 else if (tcode
== BOOLEAN_TYPE
)
1339 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1340 to member type can be converted to a prvalue of type bool. ...
1341 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1342 std::nullptr_t can be converted to a prvalue of type bool; */
1343 if (ARITHMETIC_TYPE_P (from
)
1344 || UNSCOPED_ENUM_P (from
)
1345 || fcode
== POINTER_TYPE
1346 || TYPE_PTRMEM_P (from
)
1347 || NULLPTR_TYPE_P (from
))
1349 conv
= build_conv (ck_std
, to
, conv
);
1350 if (fcode
== POINTER_TYPE
1351 || TYPE_PTRDATAMEM_P (from
)
1352 || (TYPE_PTRMEMFUNC_P (from
)
1353 && conv
->rank
< cr_pbool
)
1354 || NULLPTR_TYPE_P (from
))
1355 conv
->rank
= cr_pbool
;
1356 if (NULLPTR_TYPE_P (from
) && (flags
& LOOKUP_ONLYCONVERTING
))
1363 /* We don't check for ENUMERAL_TYPE here because there are no standard
1364 conversions to enum type. */
1365 /* As an extension, allow conversion to complex type. */
1366 else if (ARITHMETIC_TYPE_P (to
))
1368 if (! (INTEGRAL_CODE_P (fcode
)
1369 || (fcode
== REAL_TYPE
&& !(flags
& LOOKUP_NO_NON_INTEGRAL
)))
1370 || SCOPED_ENUM_P (from
))
1372 conv
= build_conv (ck_std
, to
, conv
);
1374 /* Give this a better rank if it's a promotion. */
1375 if (same_type_p (to
, type_promotes_to (from
))
1376 && next_conversion (conv
)->rank
<= cr_promotion
)
1377 conv
->rank
= cr_promotion
;
1379 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1380 && vector_types_convertible_p (from
, to
, false))
1381 return build_conv (ck_std
, to
, conv
);
1382 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1383 && is_properly_derived_from (from
, to
))
1385 if (conv
->kind
== ck_rvalue
)
1386 conv
= next_conversion (conv
);
1387 conv
= build_conv (ck_base
, to
, conv
);
1388 /* The derived-to-base conversion indicates the initialization
1389 of a parameter with base type from an object of a derived
1390 type. A temporary object is created to hold the result of
1391 the conversion unless we're binding directly to a reference. */
1392 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1397 if (flags
& LOOKUP_NO_NARROWING
)
1398 conv
->check_narrowing
= true;
1403 /* Returns nonzero if T1 is reference-related to T2. */
1406 reference_related_p (tree t1
, tree t2
)
1408 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1411 t1
= TYPE_MAIN_VARIANT (t1
);
1412 t2
= TYPE_MAIN_VARIANT (t2
);
1416 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1417 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1419 return (same_type_p (t1
, t2
)
1420 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1421 && DERIVED_FROM_P (t1
, t2
)));
1424 /* Returns nonzero if T1 is reference-compatible with T2. */
1427 reference_compatible_p (tree t1
, tree t2
)
1431 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1432 reference-related to T2 and cv1 is the same cv-qualification as,
1433 or greater cv-qualification than, cv2. */
1434 return (reference_related_p (t1
, t2
)
1435 && at_least_as_qualified_p (t1
, t2
));
1438 /* A reference of the indicated TYPE is being bound directly to the
1439 expression represented by the implicit conversion sequence CONV.
1440 Return a conversion sequence for this binding. */
1443 direct_reference_binding (tree type
, conversion
*conv
)
1447 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1448 gcc_assert (TREE_CODE (conv
->type
) != REFERENCE_TYPE
);
1450 t
= TREE_TYPE (type
);
1454 When a parameter of reference type binds directly
1455 (_dcl.init.ref_) to an argument expression, the implicit
1456 conversion sequence is the identity conversion, unless the
1457 argument expression has a type that is a derived class of the
1458 parameter type, in which case the implicit conversion sequence is
1459 a derived-to-base Conversion.
1461 If the parameter binds directly to the result of applying a
1462 conversion function to the argument expression, the implicit
1463 conversion sequence is a user-defined conversion sequence
1464 (_over.ics.user_), with the second standard conversion sequence
1465 either an identity conversion or, if the conversion function
1466 returns an entity of a type that is a derived class of the
1467 parameter type, a derived-to-base conversion. */
1468 if (!same_type_ignoring_top_level_qualifiers_p (t
, conv
->type
))
1470 /* Represent the derived-to-base conversion. */
1471 conv
= build_conv (ck_base
, t
, conv
);
1472 /* We will actually be binding to the base-class subobject in
1473 the derived class, so we mark this conversion appropriately.
1474 That way, convert_like knows not to generate a temporary. */
1475 conv
->need_temporary_p
= false;
1477 return build_conv (ck_ref_bind
, type
, conv
);
1480 /* Returns the conversion path from type FROM to reference type TO for
1481 purposes of reference binding. For lvalue binding, either pass a
1482 reference type to FROM or an lvalue expression to EXPR. If the
1483 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1484 the conversion returned. If C_CAST_P is true, this
1485 conversion is coming from a C-style cast. */
1488 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1489 tsubst_flags_t complain
)
1491 conversion
*conv
= NULL
;
1492 tree to
= TREE_TYPE (rto
);
1497 cp_lvalue_kind gl_kind
;
1500 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1502 expr
= instantiate_type (to
, expr
, tf_none
);
1503 if (expr
== error_mark_node
)
1505 from
= TREE_TYPE (expr
);
1508 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1510 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1511 /* DR 1288: Otherwise, if the initializer list has a single element
1512 of type E and ... [T's] referenced type is reference-related to E,
1513 the object or reference is initialized from that element... */
1514 if (CONSTRUCTOR_NELTS (expr
) == 1)
1516 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1517 if (error_operand_p (elt
))
1519 tree etype
= TREE_TYPE (elt
);
1520 if (reference_related_p (to
, etype
))
1527 /* Otherwise, if T is a reference type, a prvalue temporary of the
1528 type referenced by T is copy-list-initialized or
1529 direct-list-initialized, depending on the kind of initialization
1530 for the reference, and the reference is bound to that temporary. */
1531 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1532 flags
|LOOKUP_NO_TEMP_BIND
, complain
);
1536 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1538 from
= TREE_TYPE (from
);
1539 if (!TYPE_REF_IS_RVALUE (rfrom
)
1540 || TREE_CODE (from
) == FUNCTION_TYPE
)
1541 gl_kind
= clk_ordinary
;
1543 gl_kind
= clk_rvalueref
;
1547 gl_kind
= lvalue_kind (expr
);
1548 if (gl_kind
& clk_class
)
1549 /* A class prvalue is not a glvalue. */
1554 is_lvalue
= gl_kind
&& !(gl_kind
& clk_rvalueref
);
1557 if ((gl_kind
& clk_bitfield
) != 0)
1558 tfrom
= unlowered_expr_type (expr
);
1560 /* Figure out whether or not the types are reference-related and
1561 reference compatible. We have do do this after stripping
1562 references from FROM. */
1563 related_p
= reference_related_p (to
, tfrom
);
1564 /* If this is a C cast, first convert to an appropriately qualified
1565 type, so that we can later do a const_cast to the desired type. */
1566 if (related_p
&& c_cast_p
1567 && !at_least_as_qualified_p (to
, tfrom
))
1568 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1569 compatible_p
= reference_compatible_p (to
, tfrom
);
1571 /* Directly bind reference when target expression's type is compatible with
1572 the reference and expression is an lvalue. In DR391, the wording in
1573 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1574 const and rvalue references to rvalues of compatible class type.
1575 We should also do direct bindings for non-class xvalues. */
1578 || (!(flags
& LOOKUP_NO_TEMP_BIND
)
1579 && (CLASS_TYPE_P (from
)
1580 || TREE_CODE (from
) == ARRAY_TYPE
))))
1584 If the initializer expression
1586 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1587 is reference-compatible with "cv2 T2,"
1589 the reference is bound directly to the initializer expression
1593 If the initializer expression is an rvalue, with T2 a class type,
1594 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1595 is bound to the object represented by the rvalue or to a sub-object
1596 within that object. */
1598 conv
= build_identity_conv (tfrom
, expr
);
1599 conv
= direct_reference_binding (rto
, conv
);
1601 if (flags
& LOOKUP_PREFER_RVALUE
)
1602 /* The top-level caller requested that we pretend that the lvalue
1603 be treated as an rvalue. */
1604 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1605 else if (TREE_CODE (rfrom
) == REFERENCE_TYPE
)
1606 /* Handle rvalue reference to function properly. */
1607 conv
->rvaluedness_matches_p
1608 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1610 conv
->rvaluedness_matches_p
1611 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1613 if ((gl_kind
& clk_bitfield
) != 0
1614 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1615 /* For the purposes of overload resolution, we ignore the fact
1616 this expression is a bitfield or packed field. (In particular,
1617 [over.ics.ref] says specifically that a function with a
1618 non-const reference parameter is viable even if the
1619 argument is a bitfield.)
1621 However, when we actually call the function we must create
1622 a temporary to which to bind the reference. If the
1623 reference is volatile, or isn't const, then we cannot make
1624 a temporary, so we just issue an error when the conversion
1626 conv
->need_temporary_p
= true;
1628 /* Don't allow binding of lvalues (other than function lvalues) to
1629 rvalue references. */
1630 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1631 && TREE_CODE (to
) != FUNCTION_TYPE
1632 && !(flags
& LOOKUP_PREFER_RVALUE
))
1635 /* Nor the reverse. */
1636 if (!is_lvalue
&& !TYPE_REF_IS_RVALUE (rto
)
1637 && (!CP_TYPE_CONST_NON_VOLATILE_P (to
)
1638 || (flags
& LOOKUP_NO_RVAL_BIND
))
1639 && TREE_CODE (to
) != FUNCTION_TYPE
)
1647 /* [class.conv.fct] A conversion function is never used to convert a
1648 (possibly cv-qualified) object to the (possibly cv-qualified) same
1649 object type (or a reference to it), to a (possibly cv-qualified) base
1650 class of that type (or a reference to it).... */
1651 else if (CLASS_TYPE_P (from
) && !related_p
1652 && !(flags
& LOOKUP_NO_CONVERSION
))
1656 If the initializer expression
1658 -- has a class type (i.e., T2 is a class type) can be
1659 implicitly converted to an lvalue of type "cv3 T3," where
1660 "cv1 T1" is reference-compatible with "cv3 T3". (this
1661 conversion is selected by enumerating the applicable
1662 conversion functions (_over.match.ref_) and choosing the
1663 best one through overload resolution. (_over.match_).
1665 the reference is bound to the lvalue result of the conversion
1666 in the second case. */
1667 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1670 return cand
->second_conv
;
1673 /* From this point on, we conceptually need temporaries, even if we
1674 elide them. Only the cases above are "direct bindings". */
1675 if (flags
& LOOKUP_NO_TEMP_BIND
)
1680 When a parameter of reference type is not bound directly to an
1681 argument expression, the conversion sequence is the one required
1682 to convert the argument expression to the underlying type of the
1683 reference according to _over.best.ics_. Conceptually, this
1684 conversion sequence corresponds to copy-initializing a temporary
1685 of the underlying type with the argument expression. Any
1686 difference in top-level cv-qualification is subsumed by the
1687 initialization itself and does not constitute a conversion. */
1689 /* We're generating a temporary now, but don't bind any more in the
1690 conversion (specifically, don't slice the temporary returned by a
1691 conversion operator). */
1692 flags
|= LOOKUP_NO_TEMP_BIND
;
1694 /* Core issue 899: When [copy-]initializing a temporary to be bound
1695 to the first parameter of a copy constructor (12.8) called with
1696 a single argument in the context of direct-initialization,
1697 explicit conversion functions are also considered.
1699 So don't set LOOKUP_ONLYCONVERTING in that case. */
1700 if (!(flags
& LOOKUP_COPY_PARM
))
1701 flags
|= LOOKUP_ONLYCONVERTING
;
1704 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1709 if (conv
->user_conv_p
)
1711 /* If initializing the temporary used a conversion function,
1712 recalculate the second conversion sequence. */
1713 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1714 if (t
->kind
== ck_user
1715 && DECL_CONV_FN_P (t
->cand
->fn
))
1717 tree ftype
= TREE_TYPE (TREE_TYPE (t
->cand
->fn
));
1718 int sflags
= (flags
|LOOKUP_NO_CONVERSION
)&~LOOKUP_NO_TEMP_BIND
;
1719 conversion
*new_second
1720 = reference_binding (rto
, ftype
, NULL_TREE
, c_cast_p
,
1724 return merge_conversion_sequences (t
, new_second
);
1728 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1729 /* This reference binding, unlike those above, requires the
1730 creation of a temporary. */
1731 conv
->need_temporary_p
= true;
1732 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1736 Otherwise, the reference shall be an lvalue reference to a
1737 non-volatile const type, or the reference shall be an rvalue
1739 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1744 Otherwise, a temporary of type "cv1 T1" is created and
1745 initialized from the initializer expression using the rules for a
1746 non-reference copy initialization. If T1 is reference-related to
1747 T2, cv1 must be the same cv-qualification as, or greater
1748 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1749 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1755 /* Returns the implicit conversion sequence (see [over.ics]) from type
1756 FROM to type TO. The optional expression EXPR may affect the
1757 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1758 true, this conversion is coming from a C-style cast. */
1761 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1762 int flags
, tsubst_flags_t complain
)
1766 if (from
== error_mark_node
|| to
== error_mark_node
1767 || expr
== error_mark_node
)
1770 /* Other flags only apply to the primary function in overload
1771 resolution, or after we've chosen one. */
1772 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
1773 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_PREFER_RVALUE
1774 |LOOKUP_NO_NARROWING
|LOOKUP_PROTECT
|LOOKUP_NO_NON_INTEGRAL
);
1776 /* FIXME: actually we don't want warnings either, but we can't just
1777 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1778 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1779 We really ought not to issue that warning until we've committed
1780 to that conversion. */
1781 complain
&= ~tf_error
;
1783 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1784 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
1786 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
);
1791 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1793 if (is_std_init_list (to
))
1794 return build_list_conv (to
, expr
, flags
, complain
);
1796 /* As an extension, allow list-initialization of _Complex. */
1797 if (TREE_CODE (to
) == COMPLEX_TYPE
)
1799 conv
= build_complex_conv (to
, expr
, flags
, complain
);
1804 /* Allow conversion from an initializer-list with one element to a
1806 if (SCALAR_TYPE_P (to
))
1808 int nelts
= CONSTRUCTOR_NELTS (expr
);
1812 elt
= build_value_init (to
, tf_none
);
1813 else if (nelts
== 1)
1814 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1816 elt
= error_mark_node
;
1818 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
1819 c_cast_p
, flags
, complain
);
1822 conv
->check_narrowing
= true;
1823 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
1824 /* Too many levels of braces, i.e. '{{1}}'. */
1829 else if (TREE_CODE (to
) == ARRAY_TYPE
)
1830 return build_array_conv (to
, expr
, flags
, complain
);
1833 if (expr
!= NULL_TREE
1834 && (MAYBE_CLASS_TYPE_P (from
)
1835 || MAYBE_CLASS_TYPE_P (to
))
1836 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1838 struct z_candidate
*cand
;
1840 if (CLASS_TYPE_P (to
)
1841 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
1842 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
1843 return build_aggr_conv (to
, expr
, flags
, complain
);
1845 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
1847 conv
= cand
->second_conv
;
1849 /* We used to try to bind a reference to a temporary here, but that
1850 is now handled after the recursive call to this function at the end
1851 of reference_binding. */
1858 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1859 functions. ARGS will not be changed until a single candidate is
1862 static struct z_candidate
*
1863 add_candidate (struct z_candidate
**candidates
,
1864 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
1865 size_t num_convs
, conversion
**convs
,
1866 tree access_path
, tree conversion_path
,
1867 int viable
, struct rejection_reason
*reason
,
1870 struct z_candidate
*cand
= (struct z_candidate
*)
1871 conversion_obstack_alloc (sizeof (struct z_candidate
));
1874 cand
->first_arg
= first_arg
;
1876 cand
->convs
= convs
;
1877 cand
->num_convs
= num_convs
;
1878 cand
->access_path
= access_path
;
1879 cand
->conversion_path
= conversion_path
;
1880 cand
->viable
= viable
;
1881 cand
->reason
= reason
;
1882 cand
->next
= *candidates
;
1883 cand
->flags
= flags
;
1889 /* Return the number of remaining arguments in the parameter list
1890 beginning with ARG. */
1893 remaining_arguments (tree arg
)
1897 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
1898 arg
= TREE_CHAIN (arg
))
1904 /* Create an overload candidate for the function or method FN called
1905 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1906 FLAGS is passed on to implicit_conversion.
1908 This does not change ARGS.
1910 CTYPE, if non-NULL, is the type we want to pretend this function
1911 comes from for purposes of overload resolution. */
1913 static struct z_candidate
*
1914 add_function_candidate (struct z_candidate
**candidates
,
1915 tree fn
, tree ctype
, tree first_arg
,
1916 const vec
<tree
, va_gc
> *args
, tree access_path
,
1917 tree conversion_path
, int flags
,
1918 tsubst_flags_t complain
)
1920 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1924 tree orig_first_arg
= first_arg
;
1927 struct rejection_reason
*reason
= NULL
;
1929 /* At this point we should not see any functions which haven't been
1930 explicitly declared, except for friend functions which will have
1931 been found using argument dependent lookup. */
1932 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
1934 /* The `this', `in_chrg' and VTT arguments to constructors are not
1935 considered in overload resolution. */
1936 if (DECL_CONSTRUCTOR_P (fn
))
1938 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1939 skip
= num_artificial_parms_for (fn
);
1940 if (skip
> 0 && first_arg
!= NULL_TREE
)
1943 first_arg
= NULL_TREE
;
1949 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
1950 convs
= alloc_conversions (len
);
1952 /* 13.3.2 - Viable functions [over.match.viable]
1953 First, to be a viable function, a candidate function shall have enough
1954 parameters to agree in number with the arguments in the list.
1956 We need to check this first; otherwise, checking the ICSes might cause
1957 us to produce an ill-formed template instantiation. */
1959 parmnode
= parmlist
;
1960 for (i
= 0; i
< len
; ++i
)
1962 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1964 parmnode
= TREE_CHAIN (parmnode
);
1967 if ((i
< len
&& parmnode
)
1968 || !sufficient_parms_p (parmnode
))
1970 int remaining
= remaining_arguments (parmnode
);
1972 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
1974 /* When looking for a function from a subobject from an implicit
1975 copy/move constructor/operator=, don't consider anything that takes (a
1976 reference to) an unrelated type. See c++/44909 and core 1092. */
1977 else if (parmlist
&& (flags
& LOOKUP_DEFAULTED
))
1979 if (DECL_CONSTRUCTOR_P (fn
))
1981 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
1982 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
1988 parmnode
= chain_index (i
-1, parmlist
);
1989 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
1994 /* This only applies at the top level. */
1995 flags
&= ~LOOKUP_DEFAULTED
;
2001 /* Second, for F to be a viable function, there shall exist for each
2002 argument an implicit conversion sequence that converts that argument
2003 to the corresponding parameter of F. */
2005 parmnode
= parmlist
;
2007 for (i
= 0; i
< len
; ++i
)
2009 tree argtype
, to_type
;
2014 if (parmnode
== void_list_node
)
2017 if (i
== 0 && first_arg
!= NULL_TREE
)
2020 arg
= CONST_CAST_TREE (
2021 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
2022 argtype
= lvalue_type (arg
);
2024 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2025 && ! DECL_CONSTRUCTOR_P (fn
));
2029 tree parmtype
= TREE_VALUE (parmnode
);
2032 parmnode
= TREE_CHAIN (parmnode
);
2034 /* The type of the implicit object parameter ('this') for
2035 overload resolution is not always the same as for the
2036 function itself; conversion functions are considered to
2037 be members of the class being converted, and functions
2038 introduced by a using-declaration are considered to be
2039 members of the class that uses them.
2041 Since build_over_call ignores the ICS for the `this'
2042 parameter, we can just change the parm type. */
2043 if (ctype
&& is_this
)
2045 parmtype
= cp_build_qualified_type
2046 (ctype
, cp_type_quals (TREE_TYPE (parmtype
)));
2047 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
2049 /* If the function has a ref-qualifier, the implicit
2050 object parameter has reference type. */
2051 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
2052 parmtype
= cp_build_reference_type (parmtype
, rv
);
2053 /* The special handling of 'this' conversions in compare_ics
2054 does not apply if there is a ref-qualifier. */
2059 parmtype
= build_pointer_type (parmtype
);
2060 arg
= build_this (arg
);
2061 argtype
= lvalue_type (arg
);
2065 /* Core issue 899: When [copy-]initializing a temporary to be bound
2066 to the first parameter of a copy constructor (12.8) called with
2067 a single argument in the context of direct-initialization,
2068 explicit conversion functions are also considered.
2070 So set LOOKUP_COPY_PARM to let reference_binding know that
2071 it's being called in that context. We generalize the above
2072 to handle move constructors and template constructors as well;
2073 the standardese should soon be updated similarly. */
2074 if (ctype
&& i
== 0 && (len
-skip
== 1)
2075 && DECL_CONSTRUCTOR_P (fn
)
2076 && parmtype
!= error_mark_node
2077 && (same_type_ignoring_top_level_qualifiers_p
2078 (non_reference (parmtype
), ctype
)))
2080 if (!(flags
& LOOKUP_ONLYCONVERTING
))
2081 lflags
|= LOOKUP_COPY_PARM
;
2082 /* We allow user-defined conversions within init-lists, but
2083 don't list-initialize the copy parm, as that would mean
2084 using two levels of braces for the same type. */
2085 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
2086 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
2087 lflags
|= LOOKUP_NO_CONVERSION
;
2090 lflags
|= LOOKUP_ONLYCONVERTING
;
2092 t
= implicit_conversion (parmtype
, argtype
, arg
,
2093 /*c_cast_p=*/false, lflags
, complain
);
2098 t
= build_identity_conv (argtype
, arg
);
2099 t
->ellipsis_p
= true;
2110 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
);
2117 reason
= bad_arg_conversion_rejection (first_arg
, i
, arg
, to_type
);
2122 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2123 access_path
, conversion_path
, viable
, reason
, flags
);
2126 /* Create an overload candidate for the conversion function FN which will
2127 be invoked for expression OBJ, producing a pointer-to-function which
2128 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2129 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2130 passed on to implicit_conversion.
2132 Actually, we don't really care about FN; we care about the type it
2133 converts to. There may be multiple conversion functions that will
2134 convert to that type, and we rely on build_user_type_conversion_1 to
2135 choose the best one; so when we create our candidate, we record the type
2136 instead of the function. */
2138 static struct z_candidate
*
2139 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2140 tree first_arg
, const vec
<tree
, va_gc
> *arglist
,
2141 tree access_path
, tree conversion_path
,
2142 tsubst_flags_t complain
)
2144 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2145 int i
, len
, viable
, flags
;
2146 tree parmlist
, parmnode
;
2148 struct rejection_reason
*reason
;
2150 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2151 parmlist
= TREE_TYPE (parmlist
);
2152 parmlist
= TYPE_ARG_TYPES (parmlist
);
2154 len
= vec_safe_length (arglist
) + (first_arg
!= NULL_TREE
? 1 : 0) + 1;
2155 convs
= alloc_conversions (len
);
2156 parmnode
= parmlist
;
2158 flags
= LOOKUP_IMPLICIT
;
2161 /* Don't bother looking up the same type twice. */
2162 if (*candidates
&& (*candidates
)->fn
== totype
)
2165 for (i
= 0; i
< len
; ++i
)
2167 tree arg
, argtype
, convert_type
= NULL_TREE
;
2172 else if (i
== 1 && first_arg
!= NULL_TREE
)
2175 arg
= (*arglist
)[i
- (first_arg
!= NULL_TREE
? 1 : 0) - 1];
2176 argtype
= lvalue_type (arg
);
2180 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
2182 convert_type
= totype
;
2184 else if (parmnode
== void_list_node
)
2188 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2189 /*c_cast_p=*/false, flags
, complain
);
2190 convert_type
= TREE_VALUE (parmnode
);
2194 t
= build_identity_conv (argtype
, arg
);
2195 t
->ellipsis_p
= true;
2196 convert_type
= argtype
;
2206 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, arg
, convert_type
);
2213 parmnode
= TREE_CHAIN (parmnode
);
2217 || ! sufficient_parms_p (parmnode
))
2219 int remaining
= remaining_arguments (parmnode
);
2221 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2224 return add_candidate (candidates
, totype
, first_arg
, arglist
, len
, convs
,
2225 access_path
, conversion_path
, viable
, reason
, flags
);
2229 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2230 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
2231 int flags
, tsubst_flags_t complain
)
2238 struct rejection_reason
*reason
= NULL
;
2243 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
2244 convs
= alloc_conversions (num_convs
);
2246 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2247 conversion ops are allowed. We handle that here by just checking for
2248 boolean_type_node because other operators don't ask for it. COND_EXPR
2249 also does contextual conversion to bool for the first operand, but we
2250 handle that in build_conditional_expr, and type1 here is operand 2. */
2251 if (type1
!= boolean_type_node
)
2252 flags
|= LOOKUP_ONLYCONVERTING
;
2254 for (i
= 0; i
< 2; ++i
)
2259 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2260 /*c_cast_p=*/false, flags
, complain
);
2264 /* We need something for printing the candidate. */
2265 t
= build_identity_conv (types
[i
], NULL_TREE
);
2266 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2272 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, args
[i
],
2278 /* For COND_EXPR we rearranged the arguments; undo that now. */
2281 convs
[2] = convs
[1];
2282 convs
[1] = convs
[0];
2283 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2284 /*c_cast_p=*/false, flags
,
2291 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2296 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2298 /*access_path=*/NULL_TREE
,
2299 /*conversion_path=*/NULL_TREE
,
2300 viable
, reason
, flags
);
2304 is_complete (tree t
)
2306 return COMPLETE_TYPE_P (complete_type (t
));
2309 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2312 promoted_arithmetic_type_p (tree type
)
2316 In this section, the term promoted integral type is used to refer
2317 to those integral types which are preserved by integral promotion
2318 (including e.g. int and long but excluding e.g. char).
2319 Similarly, the term promoted arithmetic type refers to promoted
2320 integral types plus floating types. */
2321 return ((CP_INTEGRAL_TYPE_P (type
)
2322 && same_type_p (type_promotes_to (type
), type
))
2323 || TREE_CODE (type
) == REAL_TYPE
);
2326 /* Create any builtin operator overload candidates for the operator in
2327 question given the converted operand types TYPE1 and TYPE2. The other
2328 args are passed through from add_builtin_candidates to
2329 build_builtin_candidate.
2331 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2332 If CODE is requires candidates operands of the same type of the kind
2333 of which TYPE1 and TYPE2 are, we add both candidates
2334 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2337 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2338 enum tree_code code2
, tree fnname
, tree type1
,
2339 tree type2
, tree
*args
, tree
*argtypes
, int flags
,
2340 tsubst_flags_t complain
)
2344 case POSTINCREMENT_EXPR
:
2345 case POSTDECREMENT_EXPR
:
2346 args
[1] = integer_zero_node
;
2347 type2
= integer_type_node
;
2356 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2357 and VQ is either volatile or empty, there exist candidate operator
2358 functions of the form
2359 VQ T& operator++(VQ T&);
2360 T operator++(VQ T&, int);
2361 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2362 type other than bool, and VQ is either volatile or empty, there exist
2363 candidate operator functions of the form
2364 VQ T& operator--(VQ T&);
2365 T operator--(VQ T&, int);
2366 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2367 complete object type, and VQ is either volatile or empty, there exist
2368 candidate operator functions of the form
2369 T*VQ& operator++(T*VQ&);
2370 T*VQ& operator--(T*VQ&);
2371 T* operator++(T*VQ&, int);
2372 T* operator--(T*VQ&, int); */
2374 case POSTDECREMENT_EXPR
:
2375 case PREDECREMENT_EXPR
:
2376 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2378 case POSTINCREMENT_EXPR
:
2379 case PREINCREMENT_EXPR
:
2380 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2382 type1
= build_reference_type (type1
);
2387 /* 7 For every cv-qualified or cv-unqualified object type T, there
2388 exist candidate operator functions of the form
2392 8 For every function type T, there exist candidate operator functions of
2394 T& operator*(T*); */
2397 if (TYPE_PTR_P (type1
)
2398 && (TYPE_PTROB_P (type1
)
2399 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2403 /* 9 For every type T, there exist candidate operator functions of the form
2406 10For every promoted arithmetic type T, there exist candidate operator
2407 functions of the form
2411 case UNARY_PLUS_EXPR
: /* unary + */
2412 if (TYPE_PTR_P (type1
))
2415 if (ARITHMETIC_TYPE_P (type1
))
2419 /* 11For every promoted integral type T, there exist candidate operator
2420 functions of the form
2424 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2428 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2429 is the same type as C2 or is a derived class of C2, T is a complete
2430 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2431 there exist candidate operator functions of the form
2432 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2433 where CV12 is the union of CV1 and CV2. */
2436 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2438 tree c1
= TREE_TYPE (type1
);
2439 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2441 if (MAYBE_CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2442 && (TYPE_PTRMEMFUNC_P (type2
)
2443 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2448 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2449 didate operator functions of the form
2454 bool operator<(L, R);
2455 bool operator>(L, R);
2456 bool operator<=(L, R);
2457 bool operator>=(L, R);
2458 bool operator==(L, R);
2459 bool operator!=(L, R);
2460 where LR is the result of the usual arithmetic conversions between
2463 14For every pair of types T and I, where T is a cv-qualified or cv-
2464 unqualified complete object type and I is a promoted integral type,
2465 there exist candidate operator functions of the form
2466 T* operator+(T*, I);
2467 T& operator[](T*, I);
2468 T* operator-(T*, I);
2469 T* operator+(I, T*);
2470 T& operator[](I, T*);
2472 15For every T, where T is a pointer to complete object type, there exist
2473 candidate operator functions of the form112)
2474 ptrdiff_t operator-(T, T);
2476 16For every pointer or enumeration type T, there exist candidate operator
2477 functions of the form
2478 bool operator<(T, T);
2479 bool operator>(T, T);
2480 bool operator<=(T, T);
2481 bool operator>=(T, T);
2482 bool operator==(T, T);
2483 bool operator!=(T, T);
2485 17For every pointer to member type T, there exist candidate operator
2486 functions of the form
2487 bool operator==(T, T);
2488 bool operator!=(T, T); */
2491 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2493 if (TYPE_PTROB_P (type1
)
2494 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2496 type2
= ptrdiff_type_node
;
2500 case TRUNC_DIV_EXPR
:
2501 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2507 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2508 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
2510 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
2515 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
2527 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2529 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2531 if (TREE_CODE (type1
) == ENUMERAL_TYPE
2532 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
2534 if (TYPE_PTR_P (type1
)
2535 && null_ptr_cst_p (args
[1]))
2540 if (null_ptr_cst_p (args
[0])
2541 && TYPE_PTR_P (type2
))
2549 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2552 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
2554 type1
= ptrdiff_type_node
;
2557 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2559 type2
= ptrdiff_type_node
;
2564 /* 18For every pair of promoted integral types L and R, there exist candi-
2565 date operator functions of the form
2572 where LR is the result of the usual arithmetic conversions between
2575 case TRUNC_MOD_EXPR
:
2581 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2585 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2586 type, VQ is either volatile or empty, and R is a promoted arithmetic
2587 type, there exist candidate operator functions of the form
2588 VQ L& operator=(VQ L&, R);
2589 VQ L& operator*=(VQ L&, R);
2590 VQ L& operator/=(VQ L&, R);
2591 VQ L& operator+=(VQ L&, R);
2592 VQ L& operator-=(VQ L&, R);
2594 20For every pair T, VQ), where T is any type and VQ is either volatile
2595 or empty, there exist candidate operator functions of the form
2596 T*VQ& operator=(T*VQ&, T*);
2598 21For every pair T, VQ), where T is a pointer to member type and VQ is
2599 either volatile or empty, there exist candidate operator functions of
2601 VQ T& operator=(VQ T&, T);
2603 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2604 unqualified complete object type, VQ is either volatile or empty, and
2605 I is a promoted integral type, there exist candidate operator func-
2607 T*VQ& operator+=(T*VQ&, I);
2608 T*VQ& operator-=(T*VQ&, I);
2610 23For every triple L, VQ, R), where L is an integral or enumeration
2611 type, VQ is either volatile or empty, and R is a promoted integral
2612 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);
2619 VQ L& operator|=(VQ L&, R); */
2626 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2628 type2
= ptrdiff_type_node
;
2632 case TRUNC_DIV_EXPR
:
2633 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2637 case TRUNC_MOD_EXPR
:
2643 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2648 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2650 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2651 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2652 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2653 || ((TYPE_PTRMEMFUNC_P (type1
)
2654 || TYPE_PTR_P (type1
))
2655 && null_ptr_cst_p (args
[1])))
2665 type1
= build_reference_type (type1
);
2671 For every pair of promoted arithmetic types L and R, there
2672 exist candidate operator functions of the form
2674 LR operator?(bool, L, R);
2676 where LR is the result of the usual arithmetic conversions
2677 between types L and R.
2679 For every type T, where T is a pointer or pointer-to-member
2680 type, there exist candidate operator functions of the form T
2681 operator?(bool, T, T); */
2683 if (promoted_arithmetic_type_p (type1
)
2684 && promoted_arithmetic_type_p (type2
))
2688 /* Otherwise, the types should be pointers. */
2689 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
2692 /* We don't check that the two types are the same; the logic
2693 below will actually create two candidates; one in which both
2694 parameter types are TYPE1, and one in which both parameter
2700 if (ARITHMETIC_TYPE_P (type1
))
2708 /* Make sure we don't create builtin candidates with dependent types. */
2709 bool u1
= uses_template_parms (type1
);
2710 bool u2
= type2
? uses_template_parms (type2
) : false;
2713 /* Try to recover if one of the types is non-dependent. But if
2714 there's only one type, there's nothing we can do. */
2717 /* And we lose if both are dependent. */
2720 /* Or if they have different forms. */
2721 if (TREE_CODE (type1
) != TREE_CODE (type2
))
2730 /* If we're dealing with two pointer types or two enumeral types,
2731 we need candidates for both of them. */
2732 if (type2
&& !same_type_p (type1
, type2
)
2733 && TREE_CODE (type1
) == TREE_CODE (type2
)
2734 && (TREE_CODE (type1
) == REFERENCE_TYPE
2735 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2736 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2737 || TYPE_PTRMEMFUNC_P (type1
)
2738 || MAYBE_CLASS_TYPE_P (type1
)
2739 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2741 if (TYPE_PTR_OR_PTRMEM_P (type1
))
2743 tree cptype
= composite_pointer_type (type1
, type2
,
2748 if (cptype
!= error_mark_node
)
2750 build_builtin_candidate
2751 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
2757 build_builtin_candidate
2758 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
2759 build_builtin_candidate
2760 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
2764 build_builtin_candidate
2765 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
2769 type_decays_to (tree type
)
2771 if (TREE_CODE (type
) == ARRAY_TYPE
)
2772 return build_pointer_type (TREE_TYPE (type
));
2773 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2774 return build_pointer_type (type
);
2778 /* There are three conditions of builtin candidates:
2780 1) bool-taking candidates. These are the same regardless of the input.
2781 2) pointer-pair taking candidates. These are generated for each type
2782 one of the input types converts to.
2783 3) arithmetic candidates. According to the standard, we should generate
2784 all of these, but I'm trying not to...
2786 Here we generate a superset of the possible candidates for this particular
2787 case. That is a subset of the full set the standard defines, plus some
2788 other cases which the standard disallows. add_builtin_candidate will
2789 filter out the invalid set. */
2792 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2793 enum tree_code code2
, tree fnname
, tree
*args
,
2794 int flags
, tsubst_flags_t complain
)
2798 tree type
, argtypes
[3], t
;
2799 /* TYPES[i] is the set of possible builtin-operator parameter types
2800 we will consider for the Ith argument. */
2801 vec
<tree
, va_gc
> *types
[2];
2804 for (i
= 0; i
< 3; ++i
)
2807 argtypes
[i
] = unlowered_expr_type (args
[i
]);
2809 argtypes
[i
] = NULL_TREE
;
2814 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2815 and VQ is either volatile or empty, there exist candidate operator
2816 functions of the form
2817 VQ T& operator++(VQ T&); */
2819 case POSTINCREMENT_EXPR
:
2820 case PREINCREMENT_EXPR
:
2821 case POSTDECREMENT_EXPR
:
2822 case PREDECREMENT_EXPR
:
2827 /* 24There also exist candidate operator functions of the form
2828 bool operator!(bool);
2829 bool operator&&(bool, bool);
2830 bool operator||(bool, bool); */
2832 case TRUTH_NOT_EXPR
:
2833 build_builtin_candidate
2834 (candidates
, fnname
, boolean_type_node
,
2835 NULL_TREE
, args
, argtypes
, flags
, complain
);
2838 case TRUTH_ORIF_EXPR
:
2839 case TRUTH_ANDIF_EXPR
:
2840 build_builtin_candidate
2841 (candidates
, fnname
, boolean_type_node
,
2842 boolean_type_node
, args
, argtypes
, flags
, complain
);
2864 types
[0] = make_tree_vector ();
2865 types
[1] = make_tree_vector ();
2867 for (i
= 0; i
< 2; ++i
)
2871 else if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
2875 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2878 convs
= lookup_conversions (argtypes
[i
]);
2880 if (code
== COND_EXPR
)
2882 if (real_lvalue_p (args
[i
]))
2883 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2885 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
2891 for (; convs
; convs
= TREE_CHAIN (convs
))
2893 type
= TREE_TYPE (convs
);
2896 && (TREE_CODE (type
) != REFERENCE_TYPE
2897 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2900 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2901 vec_safe_push (types
[i
], type
);
2903 type
= non_reference (type
);
2904 if (i
!= 0 || ! ref1
)
2906 type
= cv_unqualified (type_decays_to (type
));
2907 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2908 vec_safe_push (types
[i
], type
);
2909 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2910 type
= type_promotes_to (type
);
2913 if (! vec_member (type
, types
[i
]))
2914 vec_safe_push (types
[i
], type
);
2919 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2920 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2921 type
= non_reference (argtypes
[i
]);
2922 if (i
!= 0 || ! ref1
)
2924 type
= cv_unqualified (type_decays_to (type
));
2925 if (enum_p
&& UNSCOPED_ENUM_P (type
))
2926 vec_safe_push (types
[i
], type
);
2927 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2928 type
= type_promotes_to (type
);
2930 vec_safe_push (types
[i
], type
);
2934 /* Run through the possible parameter types of both arguments,
2935 creating candidates with those parameter types. */
2936 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
2941 if (!types
[1]->is_empty ())
2942 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
2943 add_builtin_candidate
2944 (candidates
, code
, code2
, fnname
, t
,
2945 u
, args
, argtypes
, flags
, complain
);
2947 add_builtin_candidate
2948 (candidates
, code
, code2
, fnname
, t
,
2949 NULL_TREE
, args
, argtypes
, flags
, complain
);
2952 release_tree_vector (types
[0]);
2953 release_tree_vector (types
[1]);
2957 /* If TMPL can be successfully instantiated as indicated by
2958 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2960 TMPL is the template. EXPLICIT_TARGS are any explicit template
2961 arguments. ARGLIST is the arguments provided at the call-site.
2962 This does not change ARGLIST. The RETURN_TYPE is the desired type
2963 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2964 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2965 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2967 static struct z_candidate
*
2968 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
2969 tree ctype
, tree explicit_targs
, tree first_arg
,
2970 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
2971 tree access_path
, tree conversion_path
,
2972 int flags
, tree obj
, unification_kind_t strict
,
2973 tsubst_flags_t complain
)
2975 int ntparms
= DECL_NTPARMS (tmpl
);
2976 tree targs
= make_tree_vec (ntparms
);
2977 unsigned int len
= vec_safe_length (arglist
);
2978 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
2979 unsigned int skip_without_in_chrg
= 0;
2980 tree first_arg_without_in_chrg
= first_arg
;
2981 tree
*args_without_in_chrg
;
2982 unsigned int nargs_without_in_chrg
;
2983 unsigned int ia
, ix
;
2985 struct z_candidate
*cand
;
2987 struct rejection_reason
*reason
= NULL
;
2990 /* We don't do deduction on the in-charge parameter, the VTT
2991 parameter or 'this'. */
2992 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
2994 if (first_arg_without_in_chrg
!= NULL_TREE
)
2995 first_arg_without_in_chrg
= NULL_TREE
;
2997 ++skip_without_in_chrg
;
3000 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
3001 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
3002 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
3004 if (first_arg_without_in_chrg
!= NULL_TREE
)
3005 first_arg_without_in_chrg
= NULL_TREE
;
3007 ++skip_without_in_chrg
;
3010 if (len
< skip_without_in_chrg
)
3013 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
3014 + (len
- skip_without_in_chrg
));
3015 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
3017 if (first_arg_without_in_chrg
!= NULL_TREE
)
3019 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
3022 for (ix
= skip_without_in_chrg
;
3023 vec_safe_iterate (arglist
, ix
, &arg
);
3026 args_without_in_chrg
[ia
] = arg
;
3029 gcc_assert (ia
== nargs_without_in_chrg
);
3031 errs
= errorcount
+sorrycount
;
3032 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
3033 args_without_in_chrg
,
3034 nargs_without_in_chrg
,
3035 return_type
, strict
, flags
, false,
3036 complain
& tf_decltype
);
3038 if (fn
== error_mark_node
)
3040 /* Don't repeat unification later if it already resulted in errors. */
3041 if (errorcount
+sorrycount
== errs
)
3042 reason
= template_unification_rejection (tmpl
, explicit_targs
,
3043 targs
, args_without_in_chrg
,
3044 nargs_without_in_chrg
,
3045 return_type
, strict
, flags
);
3047 reason
= template_unification_error_rejection ();
3053 A member function template is never instantiated to perform the
3054 copy of a class object to an object of its class type.
3056 It's a little unclear what this means; the standard explicitly
3057 does allow a template to be used to copy a class. For example,
3062 template <class T> A(const T&);
3065 void g () { A a (f ()); }
3067 the member template will be used to make the copy. The section
3068 quoted above appears in the paragraph that forbids constructors
3069 whose only parameter is (a possibly cv-qualified variant of) the
3070 class type, and a logical interpretation is that the intent was
3071 to forbid the instantiation of member templates which would then
3073 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
3075 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3076 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
3079 reason
= invalid_copy_with_fn_template_rejection ();
3084 if (obj
!= NULL_TREE
)
3085 /* Aha, this is a conversion function. */
3086 cand
= add_conv_candidate (candidates
, fn
, obj
, first_arg
, arglist
,
3087 access_path
, conversion_path
, complain
);
3089 cand
= add_function_candidate (candidates
, fn
, ctype
,
3090 first_arg
, arglist
, access_path
,
3091 conversion_path
, flags
, complain
);
3092 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
3093 /* This situation can occur if a member template of a template
3094 class is specialized. Then, instantiate_template might return
3095 an instantiation of the specialization, in which case the
3096 DECL_TI_TEMPLATE field will point at the original
3097 specialization. For example:
3099 template <class T> struct S { template <class U> void f(U);
3100 template <> void f(int) {}; };
3104 Here, TMPL will be template <class U> S<double>::f(U).
3105 And, instantiate template will give us the specialization
3106 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3107 for this will point at template <class T> template <> S<T>::f(int),
3108 so that we can find the definition. For the purposes of
3109 overload resolution, however, we want the original TMPL. */
3110 cand
->template_decl
= build_template_info (tmpl
, targs
);
3112 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3113 cand
->explicit_targs
= explicit_targs
;
3117 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, NULL
,
3118 access_path
, conversion_path
, 0, reason
, flags
);
3122 static struct z_candidate
*
3123 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3124 tree explicit_targs
, tree first_arg
,
3125 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3126 tree access_path
, tree conversion_path
, int flags
,
3127 unification_kind_t strict
, tsubst_flags_t complain
)
3130 add_template_candidate_real (candidates
, tmpl
, ctype
,
3131 explicit_targs
, first_arg
, arglist
,
3132 return_type
, access_path
, conversion_path
,
3133 flags
, NULL_TREE
, strict
, complain
);
3137 static struct z_candidate
*
3138 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3139 tree obj
, tree first_arg
,
3140 const vec
<tree
, va_gc
> *arglist
,
3141 tree return_type
, tree access_path
,
3142 tree conversion_path
, tsubst_flags_t complain
)
3145 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3146 first_arg
, arglist
, return_type
, access_path
,
3147 conversion_path
, 0, obj
, DEDUCE_CONV
,
3151 /* The CANDS are the set of candidates that were considered for
3152 overload resolution. Return the set of viable candidates, or CANDS
3153 if none are viable. If any of the candidates were viable, set
3154 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3155 considered viable only if it is strictly viable. */
3157 static struct z_candidate
*
3158 splice_viable (struct z_candidate
*cands
,
3162 struct z_candidate
*viable
;
3163 struct z_candidate
**last_viable
;
3164 struct z_candidate
**cand
;
3165 bool found_strictly_viable
= false;
3167 /* Be strict inside templates, since build_over_call won't actually
3168 do the conversions to get pedwarns. */
3169 if (processing_template_decl
)
3173 last_viable
= &viable
;
3174 *any_viable_p
= false;
3179 struct z_candidate
*c
= *cand
;
3181 && (c
->viable
== 1 || TREE_CODE (c
->fn
) == TEMPLATE_DECL
))
3183 /* Be strict in the presence of a viable candidate. Also if
3184 there are template candidates, so that we get deduction errors
3185 for them instead of silently preferring a bad conversion. */
3187 if (viable
&& !found_strictly_viable
)
3189 /* Put any spliced near matches back onto the main list so
3190 that we see them if there is no strict match. */
3191 *any_viable_p
= false;
3192 *last_viable
= cands
;
3195 last_viable
= &viable
;
3199 if (strict_p
? c
->viable
== 1 : c
->viable
)
3204 last_viable
= &c
->next
;
3205 *any_viable_p
= true;
3207 found_strictly_viable
= true;
3213 return viable
? viable
: cands
;
3217 any_strictly_viable (struct z_candidate
*cands
)
3219 for (; cands
; cands
= cands
->next
)
3220 if (cands
->viable
== 1)
3225 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3226 words, it is about to become the "this" pointer for a member
3227 function call. Take the address of the object. */
3230 build_this (tree obj
)
3232 /* In a template, we are only concerned about the type of the
3233 expression, so we can take a shortcut. */
3234 if (processing_template_decl
)
3235 return build_address (obj
);
3237 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3240 /* Returns true iff functions are equivalent. Equivalent functions are
3241 not '==' only if one is a function-local extern function or if
3242 both are extern "C". */
3245 equal_functions (tree fn1
, tree fn2
)
3247 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3249 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3251 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
3252 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3253 return decls_match (fn1
, fn2
);
3257 /* Print information about a candidate being rejected due to INFO. */
3260 print_conversion_rejection (location_t loc
, struct conversion_info
*info
)
3262 tree from
= info
->from
;
3264 from
= lvalue_type (from
);
3265 if (info
->n_arg
== -1)
3267 /* Conversion of implicit `this' argument failed. */
3268 if (!TYPE_P (info
->from
))
3269 /* A bad conversion for 'this' must be discarding cv-quals. */
3270 inform (loc
, " passing %qT as %<this%> "
3271 "argument discards qualifiers",
3274 inform (loc
, " no known conversion for implicit "
3275 "%<this%> parameter from %qT to %qT",
3276 from
, info
->to_type
);
3278 else if (!TYPE_P (info
->from
))
3280 if (info
->n_arg
>= 0)
3281 inform (loc
, " conversion of argument %d would be ill-formed:",
3283 perform_implicit_conversion (info
->to_type
, info
->from
,
3284 tf_warning_or_error
);
3286 else if (info
->n_arg
== -2)
3287 /* Conversion of conversion function return value failed. */
3288 inform (loc
, " no known conversion from %qT to %qT",
3289 from
, info
->to_type
);
3291 inform (loc
, " no known conversion for argument %d from %qT to %qT",
3292 info
->n_arg
+ 1, from
, info
->to_type
);
3295 /* Print information about a candidate with WANT parameters and we found
3299 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
)
3301 inform_n (loc
, want
,
3302 " candidate expects %d argument, %d provided",
3303 " candidate expects %d arguments, %d provided",
3307 /* Print information about one overload candidate CANDIDATE. MSGSTR
3308 is the text to print before the candidate itself.
3310 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3311 to have been run through gettext by the caller. This wart makes
3312 life simpler in print_z_candidates and for the translators. */
3315 print_z_candidate (location_t loc
, const char *msgstr
,
3316 struct z_candidate
*candidate
)
3318 const char *msg
= (msgstr
== NULL
3320 : ACONCAT ((msgstr
, " ", NULL
)));
3321 location_t cloc
= location_of (candidate
->fn
);
3323 if (identifier_p (candidate
->fn
))
3326 if (candidate
->num_convs
== 3)
3327 inform (cloc
, "%s%D(%T, %T, %T) <built-in>", msg
, candidate
->fn
,
3328 candidate
->convs
[0]->type
,
3329 candidate
->convs
[1]->type
,
3330 candidate
->convs
[2]->type
);
3331 else if (candidate
->num_convs
== 2)
3332 inform (cloc
, "%s%D(%T, %T) <built-in>", msg
, candidate
->fn
,
3333 candidate
->convs
[0]->type
,
3334 candidate
->convs
[1]->type
);
3336 inform (cloc
, "%s%D(%T) <built-in>", msg
, candidate
->fn
,
3337 candidate
->convs
[0]->type
);
3339 else if (TYPE_P (candidate
->fn
))
3340 inform (cloc
, "%s%T <conversion>", msg
, candidate
->fn
);
3341 else if (candidate
->viable
== -1)
3342 inform (cloc
, "%s%#D <near match>", msg
, candidate
->fn
);
3343 else if (DECL_DELETED_FN (candidate
->fn
))
3344 inform (cloc
, "%s%#D <deleted>", msg
, candidate
->fn
);
3346 inform (cloc
, "%s%#D", msg
, candidate
->fn
);
3347 /* Give the user some information about why this candidate failed. */
3348 if (candidate
->reason
!= NULL
)
3350 struct rejection_reason
*r
= candidate
->reason
;
3355 print_arity_information (cloc
, r
->u
.arity
.actual
,
3356 r
->u
.arity
.expected
);
3358 case rr_arg_conversion
:
3359 print_conversion_rejection (cloc
, &r
->u
.conversion
);
3361 case rr_bad_arg_conversion
:
3362 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
);
3364 case rr_explicit_conversion
:
3365 inform (cloc
, " return type %qT of explicit conversion function "
3366 "cannot be converted to %qT with a qualification "
3367 "conversion", r
->u
.conversion
.from
,
3368 r
->u
.conversion
.to_type
);
3370 case rr_template_conversion
:
3371 inform (cloc
, " conversion from return type %qT of template "
3372 "conversion function specialization to %qT is not an "
3373 "exact match", r
->u
.conversion
.from
,
3374 r
->u
.conversion
.to_type
);
3376 case rr_template_unification
:
3377 /* We use template_unification_error_rejection if unification caused
3378 actual non-SFINAE errors, in which case we don't need to repeat
3380 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
3382 inform (cloc
, " substitution of deduced template arguments "
3383 "resulted in errors seen above");
3386 /* Re-run template unification with diagnostics. */
3387 inform (cloc
, " template argument deduction/substitution failed:");
3388 fn_type_unification (r
->u
.template_unification
.tmpl
,
3389 r
->u
.template_unification
.explicit_targs
,
3391 (r
->u
.template_unification
.num_targs
)),
3392 r
->u
.template_unification
.args
,
3393 r
->u
.template_unification
.nargs
,
3394 r
->u
.template_unification
.return_type
,
3395 r
->u
.template_unification
.strict
,
3396 r
->u
.template_unification
.flags
,
3399 case rr_invalid_copy
:
3401 " a constructor taking a single argument of its own "
3402 "class type is invalid");
3406 /* This candidate didn't have any issues or we failed to
3407 handle a particular code. Either way... */
3414 print_z_candidates (location_t loc
, struct z_candidate
*candidates
)
3416 struct z_candidate
*cand1
;
3417 struct z_candidate
**cand2
;
3423 /* Remove non-viable deleted candidates. */
3425 for (cand2
= &cand1
; *cand2
; )
3427 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
3428 && !(*cand2
)->viable
3429 && DECL_DELETED_FN ((*cand2
)->fn
))
3430 *cand2
= (*cand2
)->next
;
3432 cand2
= &(*cand2
)->next
;
3434 /* ...if there are any non-deleted ones. */
3438 /* There may be duplicates in the set of candidates. We put off
3439 checking this condition as long as possible, since we have no way
3440 to eliminate duplicates from a set of functions in less than n^2
3441 time. Now we are about to emit an error message, so it is more
3442 permissible to go slowly. */
3443 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3445 tree fn
= cand1
->fn
;
3446 /* Skip builtin candidates and conversion functions. */
3449 cand2
= &cand1
->next
;
3452 if (DECL_P ((*cand2
)->fn
)
3453 && equal_functions (fn
, (*cand2
)->fn
))
3454 *cand2
= (*cand2
)->next
;
3456 cand2
= &(*cand2
)->next
;
3460 for (n_candidates
= 0, cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3463 for (; candidates
; candidates
= candidates
->next
)
3464 print_z_candidate (loc
, "candidate:", candidates
);
3467 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3468 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3469 the result of the conversion function to convert it to the final
3470 desired type. Merge the two sequences into a single sequence,
3471 and return the merged sequence. */
3474 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
3477 bool bad
= user_seq
->bad_p
;
3479 gcc_assert (user_seq
->kind
== ck_user
);
3481 /* Find the end of the second conversion sequence. */
3482 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
3484 /* The entire sequence is a user-conversion sequence. */
3485 (*t
)->user_conv_p
= true;
3490 /* Replace the identity conversion with the user conversion
3497 /* Handle overload resolution for initializing an object of class type from
3498 an initializer list. First we look for a suitable constructor that
3499 takes a std::initializer_list; if we don't find one, we then look for a
3500 non-list constructor.
3502 Parameters are as for add_candidates, except that the arguments are in
3503 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3504 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3507 add_list_candidates (tree fns
, tree first_arg
,
3508 tree init_list
, tree totype
,
3509 tree explicit_targs
, bool template_only
,
3510 tree conversion_path
, tree access_path
,
3512 struct z_candidate
**candidates
,
3513 tsubst_flags_t complain
)
3515 vec
<tree
, va_gc
> *args
;
3517 gcc_assert (*candidates
== NULL
);
3519 /* We're looking for a ctor for list-initialization. */
3520 flags
|= LOOKUP_LIST_INIT_CTOR
;
3521 /* And we don't allow narrowing conversions. We also use this flag to
3522 avoid the copy constructor call for copy-list-initialization. */
3523 flags
|= LOOKUP_NO_NARROWING
;
3525 /* Always use the default constructor if the list is empty (DR 990). */
3526 if (CONSTRUCTOR_NELTS (init_list
) == 0
3527 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
3529 /* If the class has a list ctor, try passing the list as a single
3530 argument first, but only consider list ctors. */
3531 else if (TYPE_HAS_LIST_CTOR (totype
))
3533 flags
|= LOOKUP_LIST_ONLY
;
3534 args
= make_tree_vector_single (init_list
);
3535 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3536 explicit_targs
, template_only
, conversion_path
,
3537 access_path
, flags
, candidates
, complain
);
3538 if (any_strictly_viable (*candidates
))
3542 args
= ctor_to_vec (init_list
);
3544 /* We aren't looking for list-ctors anymore. */
3545 flags
&= ~LOOKUP_LIST_ONLY
;
3546 /* We allow more user-defined conversions within an init-list. */
3547 flags
&= ~LOOKUP_NO_CONVERSION
;
3549 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3550 explicit_targs
, template_only
, conversion_path
,
3551 access_path
, flags
, candidates
, complain
);
3554 /* Returns the best overload candidate to perform the requested
3555 conversion. This function is used for three the overloading situations
3556 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3557 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3558 per [dcl.init.ref], so we ignore temporary bindings. */
3560 static struct z_candidate
*
3561 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
3562 tsubst_flags_t complain
)
3564 struct z_candidate
*candidates
, *cand
;
3566 tree ctors
= NULL_TREE
;
3567 tree conv_fns
= NULL_TREE
;
3568 conversion
*conv
= NULL
;
3569 tree first_arg
= NULL_TREE
;
3570 vec
<tree
, va_gc
> *args
= NULL
;
3577 fromtype
= TREE_TYPE (expr
);
3579 /* We represent conversion within a hierarchy using RVALUE_CONV and
3580 BASE_CONV, as specified by [over.best.ics]; these become plain
3581 constructor calls, as specified in [dcl.init]. */
3582 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
3583 || !DERIVED_FROM_P (totype
, fromtype
));
3585 if (MAYBE_CLASS_TYPE_P (totype
))
3586 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3587 creating a garbage BASELINK; constructors can't be inherited. */
3588 ctors
= lookup_fnfields_slot (totype
, complete_ctor_identifier
);
3590 if (MAYBE_CLASS_TYPE_P (fromtype
))
3592 tree to_nonref
= non_reference (totype
);
3593 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
3594 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
3595 && DERIVED_FROM_P (to_nonref
, fromtype
)))
3597 /* [class.conv.fct] A conversion function is never used to
3598 convert a (possibly cv-qualified) object to the (possibly
3599 cv-qualified) same object type (or a reference to it), to a
3600 (possibly cv-qualified) base class of that type (or a
3601 reference to it)... */
3604 conv_fns
= lookup_conversions (fromtype
);
3608 flags
|= LOOKUP_NO_CONVERSION
;
3609 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3610 flags
|= LOOKUP_NO_NARROWING
;
3612 /* It's OK to bind a temporary for converting constructor arguments, but
3613 not in converting the return value of a conversion operator. */
3614 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
3615 | (flags
& LOOKUP_NO_NARROWING
));
3616 flags
&= ~LOOKUP_NO_TEMP_BIND
;
3620 int ctorflags
= flags
;
3622 first_arg
= build_dummy_object (totype
);
3624 /* We should never try to call the abstract or base constructor
3626 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
3627 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
3629 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3631 /* List-initialization. */
3632 add_list_candidates (ctors
, first_arg
, expr
, totype
, NULL_TREE
,
3633 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3634 ctorflags
, &candidates
, complain
);
3638 args
= make_tree_vector_single (expr
);
3639 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
3640 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3641 ctorflags
, &candidates
, complain
);
3644 for (cand
= candidates
; cand
; cand
= cand
->next
)
3646 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
3648 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3649 set, then this is copy-initialization. In that case, "The
3650 result of the call is then used to direct-initialize the
3651 object that is the destination of the copy-initialization."
3654 We represent this in the conversion sequence with an
3655 rvalue conversion, which means a constructor call. */
3656 if (TREE_CODE (totype
) != REFERENCE_TYPE
3657 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3659 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
3666 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
3668 tree conversion_path
= TREE_PURPOSE (conv_fns
);
3669 struct z_candidate
*old_candidates
;
3671 /* If we are called to convert to a reference type, we are trying to
3672 find a direct binding, so don't even consider temporaries. If
3673 we don't find a direct binding, the caller will try again to
3674 look for a temporary binding. */
3675 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
3676 convflags
|= LOOKUP_NO_TEMP_BIND
;
3678 old_candidates
= candidates
;
3679 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
3681 conversion_path
, TYPE_BINFO (fromtype
),
3682 flags
, &candidates
, complain
);
3684 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
3686 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
3688 = implicit_conversion (totype
,
3691 /*c_cast_p=*/false, convflags
,
3694 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3695 copy-initialization. In that case, "The result of the
3696 call is then used to direct-initialize the object that is
3697 the destination of the copy-initialization." [dcl.init]
3699 We represent this in the conversion sequence with an
3700 rvalue conversion, which means a constructor call. But
3701 don't add a second rvalue conversion if there's already
3702 one there. Which there really shouldn't be, but it's
3703 harmless since we'd add it here anyway. */
3704 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
3705 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3706 ics
= build_conv (ck_rvalue
, totype
, ics
);
3708 cand
->second_conv
= ics
;
3713 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -2,
3716 else if (DECL_NONCONVERTING_P (cand
->fn
)
3717 && ics
->rank
> cr_exact
)
3719 /* 13.3.1.5: For direct-initialization, those explicit
3720 conversion functions that are not hidden within S and
3721 yield type T or a type that can be converted to type T
3722 with a qualification conversion (4.4) are also candidate
3724 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3725 I've raised this issue with the committee. --jason 9/2011 */
3727 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
3729 else if (cand
->viable
== 1 && ics
->bad_p
)
3733 = bad_arg_conversion_rejection (NULL_TREE
, -2,
3736 else if (primary_template_instantiation_p (cand
->fn
)
3737 && ics
->rank
> cr_exact
)
3739 /* 13.3.3.1.2: If the user-defined conversion is specified by
3740 a specialization of a conversion function template, the
3741 second standard conversion sequence shall have exact match
3744 cand
->reason
= template_conversion_rejection (rettype
, totype
);
3749 candidates
= splice_viable (candidates
, false, &any_viable_p
);
3753 release_tree_vector (args
);
3757 cand
= tourney (candidates
, complain
);
3760 if (complain
& tf_error
)
3762 error ("conversion from %qT to %qT is ambiguous",
3764 print_z_candidates (location_of (expr
), candidates
);
3767 cand
= candidates
; /* any one will do */
3768 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
3769 cand
->second_conv
->user_conv_p
= true;
3770 if (!any_strictly_viable (candidates
))
3771 cand
->second_conv
->bad_p
= true;
3772 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3773 ambiguous conversion is no worse than another user-defined
3780 if (!DECL_CONSTRUCTOR_P (cand
->fn
))
3781 convtype
= non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)));
3782 else if (cand
->second_conv
->kind
== ck_rvalue
)
3783 /* DR 5: [in the first step of copy-initialization]...if the function
3784 is a constructor, the call initializes a temporary of the
3785 cv-unqualified version of the destination type. */
3786 convtype
= cv_unqualified (totype
);
3789 /* Build the user conversion sequence. */
3793 build_identity_conv (TREE_TYPE (expr
), expr
));
3795 if (cand
->viable
== -1)
3798 /* Remember that this was a list-initialization. */
3799 if (flags
& LOOKUP_NO_NARROWING
)
3800 conv
->check_narrowing
= true;
3802 /* Combine it with the second conversion sequence. */
3803 cand
->second_conv
= merge_conversion_sequences (conv
,
3809 /* Wrapper for above. */
3812 build_user_type_conversion (tree totype
, tree expr
, int flags
,
3813 tsubst_flags_t complain
)
3815 struct z_candidate
*cand
;
3818 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3819 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
3823 if (cand
->second_conv
->kind
== ck_ambig
)
3824 ret
= error_mark_node
;
3827 expr
= convert_like (cand
->second_conv
, expr
, complain
);
3828 ret
= convert_from_reference (expr
);
3834 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3838 /* Subroutine of convert_nontype_argument.
3840 EXPR is an argument for a template non-type parameter of integral or
3841 enumeration type. Do any necessary conversions (that are permitted for
3842 non-type arguments) to convert it to the parameter type.
3844 If conversion is successful, returns the converted expression;
3845 otherwise, returns error_mark_node. */
3848 build_integral_nontype_arg_conv (tree type
, tree expr
, tsubst_flags_t complain
)
3853 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
3855 if (error_operand_p (expr
))
3856 return error_mark_node
;
3858 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
3860 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3861 p
= conversion_obstack_alloc (0);
3863 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
3865 LOOKUP_IMPLICIT
, complain
);
3867 /* for a non-type template-parameter of integral or
3868 enumeration type, integral promotions (4.5) and integral
3869 conversions (4.7) are applied. */
3870 /* It should be sufficient to check the outermost conversion step, since
3871 there are no qualification conversions to integer type. */
3875 /* A conversion function is OK. If it isn't constexpr, we'll
3876 complain later that the argument isn't constant. */
3878 /* The lvalue-to-rvalue conversion is OK. */
3884 t
= next_conversion (conv
)->type
;
3885 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
3888 if (complain
& tf_error
)
3889 error_at (loc
, "conversion from %qT to %qT not considered for "
3890 "non-type template argument", t
, type
);
3891 /* and fall through. */
3899 expr
= convert_like (conv
, expr
, complain
);
3901 expr
= error_mark_node
;
3903 /* Free all the conversions we allocated. */
3904 obstack_free (&conversion_obstack
, p
);
3909 /* Do any initial processing on the arguments to a function call. */
3911 static vec
<tree
, va_gc
> *
3912 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
3917 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
3919 if (error_operand_p (arg
))
3921 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
3923 if (complain
& tf_error
)
3924 error ("invalid use of void expression");
3927 else if (invalid_nonstatic_memfn_p (arg
, complain
))
3933 /* Perform overload resolution on FN, which is called with the ARGS.
3935 Return the candidate function selected by overload resolution, or
3936 NULL if the event that overload resolution failed. In the case
3937 that overload resolution fails, *CANDIDATES will be the set of
3938 candidates considered, and ANY_VIABLE_P will be set to true or
3939 false to indicate whether or not any of the candidates were
3942 The ARGS should already have gone through RESOLVE_ARGS before this
3943 function is called. */
3945 static struct z_candidate
*
3946 perform_overload_resolution (tree fn
,
3947 const vec
<tree
, va_gc
> *args
,
3948 struct z_candidate
**candidates
,
3949 bool *any_viable_p
, tsubst_flags_t complain
)
3951 struct z_candidate
*cand
;
3952 tree explicit_targs
;
3955 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3957 explicit_targs
= NULL_TREE
;
3961 *any_viable_p
= true;
3964 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
3965 || TREE_CODE (fn
) == TEMPLATE_DECL
3966 || TREE_CODE (fn
) == OVERLOAD
3967 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
3969 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
3971 explicit_targs
= TREE_OPERAND (fn
, 1);
3972 fn
= TREE_OPERAND (fn
, 0);
3976 /* Add the various candidate functions. */
3977 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
3978 explicit_targs
, template_only
,
3979 /*conversion_path=*/NULL_TREE
,
3980 /*access_path=*/NULL_TREE
,
3982 candidates
, complain
);
3984 *candidates
= splice_viable (*candidates
, false, any_viable_p
);
3986 cand
= tourney (*candidates
, complain
);
3990 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3994 /* Print an error message about being unable to build a call to FN with
3995 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
3996 be located; CANDIDATES is a possibly empty list of such
4000 print_error_for_call_failure (tree fn
, vec
<tree
, va_gc
> *args
,
4001 struct z_candidate
*candidates
)
4003 tree name
= DECL_NAME (OVL_CURRENT (fn
));
4004 location_t loc
= location_of (name
);
4006 if (!any_strictly_viable (candidates
))
4007 error_at (loc
, "no matching function for call to %<%D(%A)%>",
4008 name
, build_tree_list_vec (args
));
4010 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
4011 name
, build_tree_list_vec (args
));
4013 print_z_candidates (loc
, candidates
);
4016 /* Return an expression for a call to FN (a namespace-scope function,
4017 or a static member function) with the ARGS. This may change
4021 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
, bool koenig_p
,
4022 tsubst_flags_t complain
)
4024 struct z_candidate
*candidates
, *cand
;
4029 if (args
!= NULL
&& *args
!= NULL
)
4031 *args
= resolve_args (*args
, complain
);
4033 return error_mark_node
;
4037 tm_malloc_replacement (fn
);
4039 /* If this function was found without using argument dependent
4040 lookup, then we want to ignore any undeclared friend
4046 fn
= remove_hidden_names (fn
);
4049 if (complain
& tf_error
)
4050 print_error_for_call_failure (orig_fn
, *args
, NULL
);
4051 return error_mark_node
;
4055 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4056 p
= conversion_obstack_alloc (0);
4058 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
4063 if (complain
& tf_error
)
4065 if (!any_viable_p
&& candidates
&& ! candidates
->next
4066 && (TREE_CODE (candidates
->fn
) == FUNCTION_DECL
))
4067 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
4068 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4069 fn
= TREE_OPERAND (fn
, 0);
4070 print_error_for_call_failure (fn
, *args
, candidates
);
4072 result
= error_mark_node
;
4076 int flags
= LOOKUP_NORMAL
;
4077 /* If fn is template_id_expr, the call has explicit template arguments
4078 (e.g. func<int>(5)), communicate this info to build_over_call
4079 through flags so that later we can use it to decide whether to warn
4080 about peculiar null pointer conversion. */
4081 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4082 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
4083 result
= build_over_call (cand
, flags
, complain
);
4086 /* Free all the conversions we allocated. */
4087 obstack_free (&conversion_obstack
, p
);
4092 /* Build a call to a global operator new. FNNAME is the name of the
4093 operator (either "operator new" or "operator new[]") and ARGS are
4094 the arguments provided. This may change ARGS. *SIZE points to the
4095 total number of bytes required by the allocation, and is updated if
4096 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
4097 be used. If this function determines that no cookie should be
4098 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
4099 is not NULL_TREE, it is evaluated before calculating the final
4100 array size, and if it fails, the array size is replaced with
4101 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
4102 is non-NULL, it will be set, upon return, to the allocation
4106 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
4107 tree
*size
, tree
*cookie_size
, tree size_check
,
4108 tree
*fn
, tsubst_flags_t complain
)
4110 tree original_size
= *size
;
4112 struct z_candidate
*candidates
;
4113 struct z_candidate
*cand
;
4118 /* Set to (size_t)-1 if the size check fails. */
4119 if (size_check
!= NULL_TREE
)
4121 tree errval
= TYPE_MAX_VALUE (sizetype
);
4122 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
4123 errval
= throw_bad_array_new_length ();
4124 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4125 original_size
, errval
);
4127 vec_safe_insert (*args
, 0, *size
);
4128 *args
= resolve_args (*args
, complain
);
4130 return error_mark_node
;
4136 If this lookup fails to find the name, or if the allocated type
4137 is not a class type, the allocation function's name is looked
4138 up in the global scope.
4140 we disregard block-scope declarations of "operator new". */
4141 fns
= lookup_function_nonclass (fnname
, *args
, /*block_p=*/false);
4143 /* Figure out what function is being called. */
4144 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
4147 /* If no suitable function could be found, issue an error message
4151 if (complain
& tf_error
)
4152 print_error_for_call_failure (fns
, *args
, candidates
);
4153 return error_mark_node
;
4156 /* If a cookie is required, add some extra space. Whether
4157 or not a cookie is required cannot be determined until
4158 after we know which function was called. */
4161 bool use_cookie
= true;
4164 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
4165 /* Skip the size_t parameter. */
4166 arg_types
= TREE_CHAIN (arg_types
);
4167 /* Check the remaining parameters (if any). */
4169 && TREE_CHAIN (arg_types
) == void_list_node
4170 && same_type_p (TREE_VALUE (arg_types
),
4173 /* If we need a cookie, adjust the number of bytes allocated. */
4176 /* Update the total size. */
4177 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
4178 /* Set to (size_t)-1 if the size check fails. */
4179 gcc_assert (size_check
!= NULL_TREE
);
4180 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4181 *size
, TYPE_MAX_VALUE (sizetype
));
4182 /* Update the argument list to reflect the adjusted size. */
4183 (**args
)[0] = *size
;
4186 *cookie_size
= NULL_TREE
;
4189 /* Tell our caller which function we decided to call. */
4193 /* Build the CALL_EXPR. */
4194 return build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4197 /* Build a new call to operator(). This may change ARGS. */
4200 build_op_call_1 (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4202 struct z_candidate
*candidates
= 0, *cand
;
4203 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
4204 tree type
= TREE_TYPE (obj
);
4206 tree result
= NULL_TREE
;
4209 if (error_operand_p (obj
))
4210 return error_mark_node
;
4212 obj
= prep_operand (obj
);
4214 if (TYPE_PTRMEMFUNC_P (type
))
4216 if (complain
& tf_error
)
4217 /* It's no good looking for an overloaded operator() on a
4218 pointer-to-member-function. */
4219 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
4220 return error_mark_node
;
4223 if (TYPE_BINFO (type
))
4225 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
4226 if (fns
== error_mark_node
)
4227 return error_mark_node
;
4232 if (args
!= NULL
&& *args
!= NULL
)
4234 *args
= resolve_args (*args
, complain
);
4236 return error_mark_node
;
4239 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4240 p
= conversion_obstack_alloc (0);
4244 first_mem_arg
= obj
;
4246 add_candidates (BASELINK_FUNCTIONS (fns
),
4247 first_mem_arg
, *args
, NULL_TREE
,
4249 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
4250 LOOKUP_NORMAL
, &candidates
, complain
);
4253 convs
= lookup_conversions (type
);
4255 for (; convs
; convs
= TREE_CHAIN (convs
))
4257 tree fns
= TREE_VALUE (convs
);
4258 tree totype
= TREE_TYPE (convs
);
4260 if (TYPE_PTRFN_P (totype
)
4261 || TYPE_REFFN_P (totype
)
4262 || (TREE_CODE (totype
) == REFERENCE_TYPE
4263 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
4264 for (; fns
; fns
= OVL_NEXT (fns
))
4266 tree fn
= OVL_CURRENT (fns
);
4268 if (DECL_NONCONVERTING_P (fn
))
4271 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4272 add_template_conv_candidate
4273 (&candidates
, fn
, obj
, NULL_TREE
, *args
, totype
,
4274 /*access_path=*/NULL_TREE
,
4275 /*conversion_path=*/NULL_TREE
, complain
);
4277 add_conv_candidate (&candidates
, fn
, obj
, NULL_TREE
,
4278 *args
, /*conversion_path=*/NULL_TREE
,
4279 /*access_path=*/NULL_TREE
, complain
);
4283 /* Be strict here because if we choose a bad conversion candidate, the
4284 errors we get won't mention the call context. */
4285 candidates
= splice_viable (candidates
, true, &any_viable_p
);
4288 if (complain
& tf_error
)
4290 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
4291 build_tree_list_vec (*args
));
4292 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4294 result
= error_mark_node
;
4298 cand
= tourney (candidates
, complain
);
4301 if (complain
& tf_error
)
4303 error ("call of %<(%T) (%A)%> is ambiguous",
4304 TREE_TYPE (obj
), build_tree_list_vec (*args
));
4305 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4307 result
= error_mark_node
;
4309 /* Since cand->fn will be a type, not a function, for a conversion
4310 function, we must be careful not to unconditionally look at
4312 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
4313 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
4314 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4317 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
, -1,
4319 obj
= convert_from_reference (obj
);
4320 result
= cp_build_function_call_vec (obj
, args
, complain
);
4324 /* Free all the conversions we allocated. */
4325 obstack_free (&conversion_obstack
, p
);
4330 /* Wrapper for above. */
4333 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4336 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4337 ret
= build_op_call_1 (obj
, args
, complain
);
4338 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4342 /* Called by op_error to prepare format strings suitable for the error
4343 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4344 and a suffix (controlled by NTYPES). */
4347 op_error_string (const char *errmsg
, int ntypes
, bool match
)
4351 const char *msgp
= concat (match
? G_("ambiguous overload for ")
4352 : G_("no match for "), errmsg
, NULL
);
4355 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
4356 else if (ntypes
== 2)
4357 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
4359 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
4365 op_error (location_t loc
, enum tree_code code
, enum tree_code code2
,
4366 tree arg1
, tree arg2
, tree arg3
, bool match
)
4370 if (code
== MODIFY_EXPR
)
4371 opname
= assignment_operator_name_info
[code2
].name
;
4373 opname
= operator_name_info
[code
].name
;
4378 if (flag_diagnostics_show_caret
)
4379 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
4381 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4383 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
4384 "in %<%E ? %E : %E%>"), 3, match
),
4386 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4389 case POSTINCREMENT_EXPR
:
4390 case POSTDECREMENT_EXPR
:
4391 if (flag_diagnostics_show_caret
)
4392 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4393 opname
, TREE_TYPE (arg1
));
4395 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4397 opname
, arg1
, opname
, TREE_TYPE (arg1
));
4401 if (flag_diagnostics_show_caret
)
4402 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
4403 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4405 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4407 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4412 if (flag_diagnostics_show_caret
)
4413 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
4414 opname
, TREE_TYPE (arg1
));
4416 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
4417 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4422 if (flag_diagnostics_show_caret
)
4423 error_at (loc
, op_error_string (G_("%<operator%s%>"), 2, match
),
4424 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4426 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4428 opname
, arg1
, opname
, arg2
,
4429 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4431 if (flag_diagnostics_show_caret
)
4432 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4433 opname
, TREE_TYPE (arg1
));
4435 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4437 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4442 /* Return the implicit conversion sequence that could be used to
4443 convert E1 to E2 in [expr.cond]. */
4446 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
4448 tree t1
= non_reference (TREE_TYPE (e1
));
4449 tree t2
= non_reference (TREE_TYPE (e2
));
4455 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4456 implicitly converted (clause _conv_) to the type "lvalue reference to
4457 T2", subject to the constraint that in the conversion the
4458 reference must bind directly (_dcl.init.ref_) to an lvalue.
4460 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
4461 implicitly converted to the type "rvalue reference to T2", subject to
4462 the constraint that the reference must bind directly. */
4463 if (lvalue_or_rvalue_with_address_p (e2
))
4465 tree rtype
= cp_build_reference_type (t2
, !real_lvalue_p (e2
));
4466 conv
= implicit_conversion (rtype
,
4470 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
4471 |LOOKUP_ONLYCONVERTING
,
4473 if (conv
&& !conv
->bad_p
)
4477 /* If E2 is a prvalue or if neither of the conversions above can be done
4478 and at least one of the operands has (possibly cv-qualified) class
4480 if (!CLASS_TYPE_P (t1
) && !CLASS_TYPE_P (t2
))
4485 If E1 and E2 have class type, and the underlying class types are
4486 the same or one is a base class of the other: E1 can be converted
4487 to match E2 if the class of T2 is the same type as, or a base
4488 class of, the class of T1, and the cv-qualification of T2 is the
4489 same cv-qualification as, or a greater cv-qualification than, the
4490 cv-qualification of T1. If the conversion is applied, E1 is
4491 changed to an rvalue of type T2 that still refers to the original
4492 source class object (or the appropriate subobject thereof). */
4493 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
4494 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
4496 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
4498 conv
= build_identity_conv (t1
, e1
);
4499 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
4500 TYPE_MAIN_VARIANT (t2
)))
4501 conv
= build_conv (ck_base
, t2
, conv
);
4503 conv
= build_conv (ck_rvalue
, t2
, conv
);
4512 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4513 converted to the type that expression E2 would have if E2 were
4514 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4515 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
4516 LOOKUP_IMPLICIT
, complain
);
4519 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4520 arguments to the conditional expression. */
4523 build_conditional_expr_1 (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
4524 tsubst_flags_t complain
)
4528 tree result
= NULL_TREE
;
4529 tree result_type
= NULL_TREE
;
4530 bool lvalue_p
= true;
4531 struct z_candidate
*candidates
= 0;
4532 struct z_candidate
*cand
;
4534 tree orig_arg2
, orig_arg3
;
4536 /* As a G++ extension, the second argument to the conditional can be
4537 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4538 c'.) If the second operand is omitted, make sure it is
4539 calculated only once. */
4542 if (complain
& tf_error
)
4543 pedwarn (loc
, OPT_Wpedantic
,
4544 "ISO C++ forbids omitting the middle term of a ?: expression");
4546 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4547 if (real_lvalue_p (arg1
))
4548 arg2
= arg1
= stabilize_reference (arg1
);
4550 arg2
= arg1
= save_expr (arg1
);
4553 /* If something has already gone wrong, just pass that fact up the
4555 if (error_operand_p (arg1
)
4556 || error_operand_p (arg2
)
4557 || error_operand_p (arg3
))
4558 return error_mark_node
;
4563 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
4565 arg1
= force_rvalue (arg1
, complain
);
4566 arg2
= force_rvalue (arg2
, complain
);
4567 arg3
= force_rvalue (arg3
, complain
);
4569 /* force_rvalue can return error_mark on valid arguments. */
4570 if (error_operand_p (arg1
)
4571 || error_operand_p (arg2
)
4572 || error_operand_p (arg3
))
4573 return error_mark_node
;
4575 tree arg1_type
= TREE_TYPE (arg1
);
4576 arg2_type
= TREE_TYPE (arg2
);
4577 arg3_type
= TREE_TYPE (arg3
);
4579 if (TREE_CODE (arg2_type
) != VECTOR_TYPE
4580 && TREE_CODE (arg3_type
) != VECTOR_TYPE
)
4582 /* Rely on the error messages of the scalar version. */
4583 tree scal
= build_conditional_expr_1 (loc
, integer_one_node
,
4584 orig_arg2
, orig_arg3
, complain
);
4585 if (scal
== error_mark_node
)
4586 return error_mark_node
;
4587 tree stype
= TREE_TYPE (scal
);
4588 tree ctype
= TREE_TYPE (arg1_type
);
4589 if (TYPE_SIZE (stype
) != TYPE_SIZE (ctype
)
4590 || (!INTEGRAL_TYPE_P (stype
) && !SCALAR_FLOAT_TYPE_P (stype
)))
4592 if (complain
& tf_error
)
4593 error_at (loc
, "inferred scalar type %qT is not an integer or "
4594 "floating point type of the same size as %qT", stype
,
4595 COMPARISON_CLASS_P (arg1
)
4596 ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
4598 return error_mark_node
;
4601 tree vtype
= build_opaque_vector_type (stype
,
4602 TYPE_VECTOR_SUBPARTS (arg1_type
));
4603 /* We could pass complain & tf_warning to unsafe_conversion_p,
4604 but the warnings (like Wsign-conversion) have already been
4605 given by the scalar build_conditional_expr_1. We still check
4606 unsafe_conversion_p to forbid truncating long long -> float. */
4607 if (unsafe_conversion_p (loc
, stype
, arg2
, false))
4609 if (complain
& tf_error
)
4610 error_at (loc
, "conversion of scalar %qT to vector %qT "
4611 "involves truncation", arg2_type
, vtype
);
4612 return error_mark_node
;
4614 if (unsafe_conversion_p (loc
, stype
, arg3
, false))
4616 if (complain
& tf_error
)
4617 error_at (loc
, "conversion of scalar %qT to vector %qT "
4618 "involves truncation", arg3_type
, vtype
);
4619 return error_mark_node
;
4622 arg2
= cp_convert (stype
, arg2
, complain
);
4623 arg2
= save_expr (arg2
);
4624 arg2
= build_vector_from_val (vtype
, arg2
);
4626 arg3
= cp_convert (stype
, arg3
, complain
);
4627 arg3
= save_expr (arg3
);
4628 arg3
= build_vector_from_val (vtype
, arg3
);
4632 if ((TREE_CODE (arg2_type
) == VECTOR_TYPE
)
4633 != (TREE_CODE (arg3_type
) == VECTOR_TYPE
))
4635 enum stv_conv convert_flag
=
4636 scalar_to_vector (loc
, VEC_COND_EXPR
, arg2
, arg3
,
4637 complain
& tf_error
);
4639 switch (convert_flag
)
4642 return error_mark_node
;
4645 arg2
= save_expr (arg2
);
4646 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
4647 arg2
= build_vector_from_val (arg3_type
, arg2
);
4648 arg2_type
= TREE_TYPE (arg2
);
4653 arg3
= save_expr (arg3
);
4654 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
4655 arg3
= build_vector_from_val (arg2_type
, arg3
);
4656 arg3_type
= TREE_TYPE (arg3
);
4664 if (!same_type_p (arg2_type
, arg3_type
)
4665 || TYPE_VECTOR_SUBPARTS (arg1_type
)
4666 != TYPE_VECTOR_SUBPARTS (arg2_type
)
4667 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
4669 if (complain
& tf_error
)
4671 "incompatible vector types in conditional expression: "
4672 "%qT, %qT and %qT", TREE_TYPE (arg1
),
4673 TREE_TYPE (orig_arg2
), TREE_TYPE (orig_arg3
));
4674 return error_mark_node
;
4677 if (!COMPARISON_CLASS_P (arg1
))
4678 arg1
= cp_build_binary_op (loc
, NE_EXPR
, arg1
,
4679 build_zero_cst (arg1_type
), complain
);
4680 return fold_build3 (VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
4685 The first expression is implicitly converted to bool (clause
4687 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
4689 if (error_operand_p (arg1
))
4690 return error_mark_node
;
4694 If either the second or the third operand has type (possibly
4695 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4696 array-to-pointer (_conv.array_), and function-to-pointer
4697 (_conv.func_) standard conversions are performed on the second
4698 and third operands. */
4699 arg2_type
= unlowered_expr_type (arg2
);
4700 arg3_type
= unlowered_expr_type (arg3
);
4701 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
4703 /* Do the conversions. We don't these for `void' type arguments
4704 since it can't have any effect and since decay_conversion
4705 does not handle that case gracefully. */
4706 if (!VOID_TYPE_P (arg2_type
))
4707 arg2
= decay_conversion (arg2
, complain
);
4708 if (!VOID_TYPE_P (arg3_type
))
4709 arg3
= decay_conversion (arg3
, complain
);
4710 arg2_type
= TREE_TYPE (arg2
);
4711 arg3_type
= TREE_TYPE (arg3
);
4715 One of the following shall hold:
4717 --The second or the third operand (but not both) is a
4718 throw-expression (_except.throw_); the result is of the
4719 type of the other and is an rvalue.
4721 --Both the second and the third operands have type void; the
4722 result is of type void and is an rvalue.
4724 We must avoid calling force_rvalue for expressions of type
4725 "void" because it will complain that their value is being
4727 if (TREE_CODE (arg2
) == THROW_EXPR
4728 && TREE_CODE (arg3
) != THROW_EXPR
)
4730 if (!VOID_TYPE_P (arg3_type
))
4732 arg3
= force_rvalue (arg3
, complain
);
4733 if (arg3
== error_mark_node
)
4734 return error_mark_node
;
4736 arg3_type
= TREE_TYPE (arg3
);
4737 result_type
= arg3_type
;
4739 else if (TREE_CODE (arg2
) != THROW_EXPR
4740 && TREE_CODE (arg3
) == THROW_EXPR
)
4742 if (!VOID_TYPE_P (arg2_type
))
4744 arg2
= force_rvalue (arg2
, complain
);
4745 if (arg2
== error_mark_node
)
4746 return error_mark_node
;
4748 arg2_type
= TREE_TYPE (arg2
);
4749 result_type
= arg2_type
;
4751 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
4752 result_type
= void_type_node
;
4755 if (complain
& tf_error
)
4757 if (VOID_TYPE_P (arg2_type
))
4758 error_at (EXPR_LOC_OR_LOC (arg3
, loc
),
4759 "second operand to the conditional operator "
4760 "is of type %<void%>, but the third operand is "
4761 "neither a throw-expression nor of type %<void%>");
4763 error_at (EXPR_LOC_OR_LOC (arg2
, loc
),
4764 "third operand to the conditional operator "
4765 "is of type %<void%>, but the second operand is "
4766 "neither a throw-expression nor of type %<void%>");
4768 return error_mark_node
;
4772 goto valid_operands
;
4776 Otherwise, if the second and third operand have different types,
4777 and either has (possibly cv-qualified) class type, or if both are
4778 glvalues of the same value category and the same type except for
4779 cv-qualification, an attempt is made to convert each of those operands
4780 to the type of the other. */
4781 else if (!same_type_p (arg2_type
, arg3_type
)
4782 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)
4783 || (same_type_ignoring_top_level_qualifiers_p (arg2_type
,
4785 && lvalue_or_rvalue_with_address_p (arg2
)
4786 && lvalue_or_rvalue_with_address_p (arg3
)
4787 && real_lvalue_p (arg2
) == real_lvalue_p (arg3
))))
4791 bool converted
= false;
4793 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4794 p
= conversion_obstack_alloc (0);
4796 conv2
= conditional_conversion (arg2
, arg3
, complain
);
4797 conv3
= conditional_conversion (arg3
, arg2
, complain
);
4801 If both can be converted, or one can be converted but the
4802 conversion is ambiguous, the program is ill-formed. If
4803 neither can be converted, the operands are left unchanged and
4804 further checking is performed as described below. If exactly
4805 one conversion is possible, that conversion is applied to the
4806 chosen operand and the converted operand is used in place of
4807 the original operand for the remainder of this section. */
4808 if ((conv2
&& !conv2
->bad_p
4809 && conv3
&& !conv3
->bad_p
)
4810 || (conv2
&& conv2
->kind
== ck_ambig
)
4811 || (conv3
&& conv3
->kind
== ck_ambig
))
4813 if (complain
& tf_error
)
4815 error_at (loc
, "operands to ?: have different types %qT and %qT",
4816 arg2_type
, arg3_type
);
4817 if (conv2
&& !conv2
->bad_p
&& conv3
&& !conv3
->bad_p
)
4818 inform (loc
, " and each type can be converted to the other");
4819 else if (conv2
&& conv2
->kind
== ck_ambig
)
4820 convert_like (conv2
, arg2
, complain
);
4822 convert_like (conv3
, arg3
, complain
);
4824 result
= error_mark_node
;
4826 else if (conv2
&& !conv2
->bad_p
)
4828 arg2
= convert_like (conv2
, arg2
, complain
);
4829 arg2
= convert_from_reference (arg2
);
4830 arg2_type
= TREE_TYPE (arg2
);
4831 /* Even if CONV2 is a valid conversion, the result of the
4832 conversion may be invalid. For example, if ARG3 has type
4833 "volatile X", and X does not have a copy constructor
4834 accepting a "volatile X&", then even if ARG2 can be
4835 converted to X, the conversion will fail. */
4836 if (error_operand_p (arg2
))
4837 result
= error_mark_node
;
4840 else if (conv3
&& !conv3
->bad_p
)
4842 arg3
= convert_like (conv3
, arg3
, complain
);
4843 arg3
= convert_from_reference (arg3
);
4844 arg3_type
= TREE_TYPE (arg3
);
4845 if (error_operand_p (arg3
))
4846 result
= error_mark_node
;
4850 /* Free all the conversions we allocated. */
4851 obstack_free (&conversion_obstack
, p
);
4856 /* If, after the conversion, both operands have class type,
4857 treat the cv-qualification of both operands as if it were the
4858 union of the cv-qualification of the operands.
4860 The standard is not clear about what to do in this
4861 circumstance. For example, if the first operand has type
4862 "const X" and the second operand has a user-defined
4863 conversion to "volatile X", what is the type of the second
4864 operand after this step? Making it be "const X" (matching
4865 the first operand) seems wrong, as that discards the
4866 qualification without actually performing a copy. Leaving it
4867 as "volatile X" seems wrong as that will result in the
4868 conditional expression failing altogether, even though,
4869 according to this step, the one operand could be converted to
4870 the type of the other. */
4872 && CLASS_TYPE_P (arg2_type
)
4873 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
4874 arg2_type
= arg3_type
=
4875 cp_build_qualified_type (arg2_type
,
4876 cp_type_quals (arg2_type
)
4877 | cp_type_quals (arg3_type
));
4882 If the second and third operands are glvalues of the same value
4883 category and have the same type, the result is of that type and
4885 if (((real_lvalue_p (arg2
) && real_lvalue_p (arg3
))
4886 || (xvalue_p (arg2
) && xvalue_p (arg3
)))
4887 && same_type_p (arg2_type
, arg3_type
))
4889 result_type
= arg2_type
;
4890 arg2
= mark_lvalue_use (arg2
);
4891 arg3
= mark_lvalue_use (arg3
);
4892 goto valid_operands
;
4897 Otherwise, the result is an rvalue. If the second and third
4898 operand do not have the same type, and either has (possibly
4899 cv-qualified) class type, overload resolution is used to
4900 determine the conversions (if any) to be applied to the operands
4901 (_over.match.oper_, _over.built_). */
4903 if (!same_type_p (arg2_type
, arg3_type
)
4904 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
4910 /* Rearrange the arguments so that add_builtin_candidate only has
4911 to know about two args. In build_builtin_candidate, the
4912 arguments are unscrambled. */
4916 add_builtin_candidates (&candidates
,
4919 ansi_opname (COND_EXPR
),
4921 LOOKUP_NORMAL
, complain
);
4925 If the overload resolution fails, the program is
4927 candidates
= splice_viable (candidates
, false, &any_viable_p
);
4930 if (complain
& tf_error
)
4931 error_at (loc
, "operands to ?: have different types %qT and %qT",
4932 arg2_type
, arg3_type
);
4933 return error_mark_node
;
4935 cand
= tourney (candidates
, complain
);
4938 if (complain
& tf_error
)
4940 op_error (loc
, COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, FALSE
);
4941 print_z_candidates (loc
, candidates
);
4943 return error_mark_node
;
4948 Otherwise, the conversions thus determined are applied, and
4949 the converted operands are used in place of the original
4950 operands for the remainder of this section. */
4951 conv
= cand
->convs
[0];
4952 arg1
= convert_like (conv
, arg1
, complain
);
4953 conv
= cand
->convs
[1];
4954 arg2
= convert_like (conv
, arg2
, complain
);
4955 arg2_type
= TREE_TYPE (arg2
);
4956 conv
= cand
->convs
[2];
4957 arg3
= convert_like (conv
, arg3
, complain
);
4958 arg3_type
= TREE_TYPE (arg3
);
4963 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
4964 and function-to-pointer (_conv.func_) standard conversions are
4965 performed on the second and third operands.
4967 We need to force the lvalue-to-rvalue conversion here for class types,
4968 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
4969 that isn't wrapped with a TARGET_EXPR plays havoc with exception
4972 arg2
= force_rvalue (arg2
, complain
);
4973 if (!CLASS_TYPE_P (arg2_type
))
4974 arg2_type
= TREE_TYPE (arg2
);
4976 arg3
= force_rvalue (arg3
, complain
);
4977 if (!CLASS_TYPE_P (arg3_type
))
4978 arg3_type
= TREE_TYPE (arg3
);
4980 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
4981 return error_mark_node
;
4985 After those conversions, one of the following shall hold:
4987 --The second and third operands have the same type; the result is of
4989 if (same_type_p (arg2_type
, arg3_type
))
4990 result_type
= arg2_type
;
4993 --The second and third operands have arithmetic or enumeration
4994 type; the usual arithmetic conversions are performed to bring
4995 them to a common type, and the result is of that type. */
4996 else if ((ARITHMETIC_TYPE_P (arg2_type
)
4997 || UNSCOPED_ENUM_P (arg2_type
))
4998 && (ARITHMETIC_TYPE_P (arg3_type
)
4999 || UNSCOPED_ENUM_P (arg3_type
)))
5001 /* In this case, there is always a common type. */
5002 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
5004 if (complain
& tf_warning
)
5005 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
5006 "implicit conversion from %qT to %qT to "
5007 "match other result of conditional",
5010 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5011 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
5013 if (TREE_CODE (orig_arg2
) == CONST_DECL
5014 && TREE_CODE (orig_arg3
) == CONST_DECL
5015 && DECL_CONTEXT (orig_arg2
) == DECL_CONTEXT (orig_arg3
))
5016 /* Two enumerators from the same enumeration can have different
5017 types when the enumeration is still being defined. */;
5018 else if (complain
& tf_warning
)
5019 warning_at (loc
, OPT_Wenum_compare
, "enumeral mismatch in "
5020 "conditional expression: %qT vs %qT",
5021 arg2_type
, arg3_type
);
5023 else if (extra_warnings
5024 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5025 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
5026 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
5027 && !same_type_p (arg2_type
,
5028 type_promotes_to (arg3_type
)))))
5030 if (complain
& tf_warning
)
5031 warning_at (loc
, OPT_Wextra
, "enumeral and non-enumeral type in "
5032 "conditional expression");
5035 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5036 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5040 --The second and third operands have pointer type, or one has
5041 pointer type and the other is a null pointer constant; pointer
5042 conversions (_conv.ptr_) and qualification conversions
5043 (_conv.qual_) are performed to bring them to their composite
5044 pointer type (_expr.rel_). The result is of the composite
5047 --The second and third operands have pointer to member type, or
5048 one has pointer to member type and the other is a null pointer
5049 constant; pointer to member conversions (_conv.mem_) and
5050 qualification conversions (_conv.qual_) are performed to bring
5051 them to a common type, whose cv-qualification shall match the
5052 cv-qualification of either the second or the third operand.
5053 The result is of the common type. */
5054 else if ((null_ptr_cst_p (arg2
)
5055 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
5056 || (null_ptr_cst_p (arg3
)
5057 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
5058 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
5059 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
5060 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
5062 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
5063 arg3
, CPO_CONDITIONAL_EXPR
,
5065 if (result_type
== error_mark_node
)
5066 return error_mark_node
;
5067 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5068 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5073 if (complain
& tf_error
)
5074 error_at (loc
, "operands to ?: have different types %qT and %qT",
5075 arg2_type
, arg3_type
);
5076 return error_mark_node
;
5079 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5080 return error_mark_node
;
5083 result
= build3 (COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
5084 if (!cp_unevaluated_operand
)
5085 /* Avoid folding within decltype (c++/42013) and noexcept. */
5086 result
= fold_if_not_in_template (result
);
5088 /* We can't use result_type below, as fold might have returned a
5093 /* Expand both sides into the same slot, hopefully the target of
5094 the ?: expression. We used to check for TARGET_EXPRs here,
5095 but now we sometimes wrap them in NOP_EXPRs so the test would
5097 if (CLASS_TYPE_P (TREE_TYPE (result
)))
5098 result
= get_target_expr_sfinae (result
, complain
);
5099 /* If this expression is an rvalue, but might be mistaken for an
5100 lvalue, we must add a NON_LVALUE_EXPR. */
5101 result
= rvalue (result
);
5104 result
= force_paren_expr (result
);
5109 /* Wrapper for above. */
5112 build_conditional_expr (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
5113 tsubst_flags_t complain
)
5116 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5117 ret
= build_conditional_expr_1 (loc
, arg1
, arg2
, arg3
, complain
);
5118 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5122 /* OPERAND is an operand to an expression. Perform necessary steps
5123 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
5127 prep_operand (tree operand
)
5131 if (CLASS_TYPE_P (TREE_TYPE (operand
))
5132 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
5133 /* Make sure the template type is instantiated now. */
5134 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
5140 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
5141 OVERLOAD) to the CANDIDATES, returning an updated list of
5142 CANDIDATES. The ARGS are the arguments provided to the call;
5143 if FIRST_ARG is non-null it is the implicit object argument,
5144 otherwise the first element of ARGS is used if needed. The
5145 EXPLICIT_TARGS are explicit template arguments provided.
5146 TEMPLATE_ONLY is true if only template functions should be
5147 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
5148 add_function_candidate. */
5151 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
5153 tree explicit_targs
, bool template_only
,
5154 tree conversion_path
, tree access_path
,
5156 struct z_candidate
**candidates
,
5157 tsubst_flags_t complain
)
5160 const vec
<tree
, va_gc
> *non_static_args
;
5161 bool check_list_ctor
;
5162 bool check_converting
;
5163 unification_kind_t strict
;
5169 /* Precalculate special handling of constructors and conversion ops. */
5170 fn
= OVL_CURRENT (fns
);
5171 if (DECL_CONV_FN_P (fn
))
5173 check_list_ctor
= false;
5174 check_converting
= !!(flags
& LOOKUP_ONLYCONVERTING
);
5175 if (flags
& LOOKUP_NO_CONVERSION
)
5176 /* We're doing return_type(x). */
5177 strict
= DEDUCE_CONV
;
5179 /* We're doing x.operator return_type(). */
5180 strict
= DEDUCE_EXACT
;
5181 /* [over.match.funcs] For conversion functions, the function
5182 is considered to be a member of the class of the implicit
5183 object argument for the purpose of defining the type of
5184 the implicit object parameter. */
5185 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
5189 if (DECL_CONSTRUCTOR_P (fn
))
5191 check_list_ctor
= !!(flags
& LOOKUP_LIST_ONLY
);
5192 /* For list-initialization we consider explicit constructors
5193 and complain if one is chosen. */
5195 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
5196 == LOOKUP_ONLYCONVERTING
);
5200 check_list_ctor
= false;
5201 check_converting
= false;
5203 strict
= DEDUCE_CALL
;
5204 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
5208 non_static_args
= args
;
5210 /* Delay creating the implicit this parameter until it is needed. */
5211 non_static_args
= NULL
;
5213 for (; fns
; fns
= OVL_NEXT (fns
))
5216 const vec
<tree
, va_gc
> *fn_args
;
5218 fn
= OVL_CURRENT (fns
);
5220 if (check_converting
&& DECL_NONCONVERTING_P (fn
))
5222 if (check_list_ctor
&& !is_list_ctor (fn
))
5225 /* Figure out which set of arguments to use. */
5226 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
5228 /* If this function is a non-static member and we didn't get an
5229 implicit object argument, move it out of args. */
5230 if (first_arg
== NULL_TREE
)
5234 vec
<tree
, va_gc
> *tempvec
;
5235 vec_alloc (tempvec
, args
->length () - 1);
5236 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
5237 tempvec
->quick_push (arg
);
5238 non_static_args
= tempvec
;
5239 first_arg
= (*args
)[0];
5242 fn_first_arg
= first_arg
;
5243 fn_args
= non_static_args
;
5247 /* Otherwise, just use the list of arguments provided. */
5248 fn_first_arg
= NULL_TREE
;
5252 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5253 add_template_candidate (candidates
,
5265 else if (!template_only
)
5266 add_function_candidate (candidates
,
5279 build_new_op_1 (location_t loc
, enum tree_code code
, int flags
, tree arg1
,
5280 tree arg2
, tree arg3
, tree
*overload
, tsubst_flags_t complain
)
5282 struct z_candidate
*candidates
= 0, *cand
;
5283 vec
<tree
, va_gc
> *arglist
;
5286 tree result
= NULL_TREE
;
5287 bool result_valid_p
= false;
5288 enum tree_code code2
= NOP_EXPR
;
5289 enum tree_code code_orig_arg1
= ERROR_MARK
;
5290 enum tree_code code_orig_arg2
= ERROR_MARK
;
5296 if (error_operand_p (arg1
)
5297 || error_operand_p (arg2
)
5298 || error_operand_p (arg3
))
5299 return error_mark_node
;
5301 if (code
== MODIFY_EXPR
)
5303 code2
= TREE_CODE (arg3
);
5305 fnname
= ansi_assopname (code2
);
5308 fnname
= ansi_opname (code
);
5310 arg1
= prep_operand (arg1
);
5316 case VEC_DELETE_EXPR
:
5318 /* Use build_op_new_call and build_op_delete_call instead. */
5322 /* Use build_op_call instead. */
5325 case TRUTH_ORIF_EXPR
:
5326 case TRUTH_ANDIF_EXPR
:
5327 case TRUTH_AND_EXPR
:
5329 /* These are saved for the sake of warn_logical_operator. */
5330 code_orig_arg1
= TREE_CODE (arg1
);
5331 code_orig_arg2
= TREE_CODE (arg2
);
5339 /* These are saved for the sake of maybe_warn_bool_compare. */
5340 code_orig_arg1
= TREE_CODE (TREE_TYPE (arg1
));
5341 code_orig_arg2
= TREE_CODE (TREE_TYPE (arg2
));
5347 arg2
= prep_operand (arg2
);
5348 arg3
= prep_operand (arg3
);
5350 if (code
== COND_EXPR
)
5351 /* Use build_conditional_expr instead. */
5353 else if (! OVERLOAD_TYPE_P (TREE_TYPE (arg1
))
5354 && (! arg2
|| ! OVERLOAD_TYPE_P (TREE_TYPE (arg2
))))
5357 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5358 arg2
= integer_zero_node
;
5360 vec_alloc (arglist
, 3);
5361 arglist
->quick_push (arg1
);
5362 if (arg2
!= NULL_TREE
)
5363 arglist
->quick_push (arg2
);
5364 if (arg3
!= NULL_TREE
)
5365 arglist
->quick_push (arg3
);
5367 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5368 p
= conversion_obstack_alloc (0);
5370 /* Add namespace-scope operators to the list of functions to
5372 add_candidates (lookup_function_nonclass (fnname
, arglist
, /*block_p=*/true),
5373 NULL_TREE
, arglist
, NULL_TREE
,
5374 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5375 flags
, &candidates
, complain
);
5379 args
[2] = NULL_TREE
;
5381 /* Add class-member operators to the candidate set. */
5382 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
5386 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
5387 if (fns
== error_mark_node
)
5389 result
= error_mark_node
;
5390 goto user_defined_result_ready
;
5393 add_candidates (BASELINK_FUNCTIONS (fns
),
5394 NULL_TREE
, arglist
, NULL_TREE
,
5396 BASELINK_BINFO (fns
),
5397 BASELINK_ACCESS_BINFO (fns
),
5398 flags
, &candidates
, complain
);
5400 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5401 only non-member functions that have type T1 or reference to
5402 cv-qualified-opt T1 for the first argument, if the first argument
5403 has an enumeration type, or T2 or reference to cv-qualified-opt
5404 T2 for the second argument, if the the second argument has an
5405 enumeration type. Filter out those that don't match. */
5406 else if (! arg2
|| ! CLASS_TYPE_P (TREE_TYPE (arg2
)))
5408 struct z_candidate
**candp
, **next
;
5410 for (candp
= &candidates
; *candp
; candp
= next
)
5412 tree parmlist
, parmtype
;
5413 int i
, nargs
= (arg2
? 2 : 1);
5418 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5420 for (i
= 0; i
< nargs
; ++i
)
5422 parmtype
= TREE_VALUE (parmlist
);
5424 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
5425 parmtype
= TREE_TYPE (parmtype
);
5426 if (TREE_CODE (TREE_TYPE (args
[i
])) == ENUMERAL_TYPE
5427 && (same_type_ignoring_top_level_qualifiers_p
5428 (TREE_TYPE (args
[i
]), parmtype
)))
5431 parmlist
= TREE_CHAIN (parmlist
);
5434 /* No argument has an appropriate type, so remove this
5435 candidate function from the list. */
5438 *candp
= cand
->next
;
5444 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
5451 /* For these, the built-in candidates set is empty
5452 [over.match.oper]/3. We don't want non-strict matches
5453 because exact matches are always possible with built-in
5454 operators. The built-in candidate set for COMPONENT_REF
5455 would be empty too, but since there are no such built-in
5456 operators, we accept non-strict matches for them. */
5465 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
5470 case POSTINCREMENT_EXPR
:
5471 case POSTDECREMENT_EXPR
:
5472 /* Don't try anything fancy if we're not allowed to produce
5474 if (!(complain
& tf_error
))
5475 return error_mark_node
;
5477 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5478 distinguish between prefix and postfix ++ and
5479 operator++() was used for both, so we allow this with
5483 const char *msg
= (flag_permissive
)
5484 ? G_("no %<%D(int)%> declared for postfix %qs,"
5485 " trying prefix operator instead")
5486 : G_("no %<%D(int)%> declared for postfix %qs");
5487 permerror (loc
, msg
, fnname
, operator_name_info
[code
].name
);
5490 if (!flag_permissive
)
5491 return error_mark_node
;
5493 if (code
== POSTINCREMENT_EXPR
)
5494 code
= PREINCREMENT_EXPR
;
5496 code
= PREDECREMENT_EXPR
;
5497 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
5498 NULL_TREE
, overload
, complain
);
5501 /* The caller will deal with these. */
5506 result_valid_p
= true;
5510 if (complain
& tf_error
)
5512 /* If one of the arguments of the operator represents
5513 an invalid use of member function pointer, try to report
5514 a meaningful error ... */
5515 if (invalid_nonstatic_memfn_p (arg1
, tf_error
)
5516 || invalid_nonstatic_memfn_p (arg2
, tf_error
)
5517 || invalid_nonstatic_memfn_p (arg3
, tf_error
))
5518 /* We displayed the error message. */;
5521 /* ... Otherwise, report the more generic
5522 "no matching operator found" error */
5523 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
5524 print_z_candidates (loc
, candidates
);
5527 result
= error_mark_node
;
5533 cand
= tourney (candidates
, complain
);
5536 if (complain
& tf_error
)
5538 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
5539 print_z_candidates (loc
, candidates
);
5541 result
= error_mark_node
;
5543 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5546 *overload
= cand
->fn
;
5548 if (resolve_args (arglist
, complain
) == NULL
)
5549 result
= error_mark_node
;
5551 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5555 /* Give any warnings we noticed during overload resolution. */
5556 if (cand
->warnings
&& (complain
& tf_warning
))
5558 struct candidate_warning
*w
;
5559 for (w
= cand
->warnings
; w
; w
= w
->next
)
5560 joust (cand
, w
->loser
, 1, complain
);
5563 /* Check for comparison of different enum types. */
5572 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
5573 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
5574 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
5575 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
)))
5576 && (complain
& tf_warning
))
5578 warning (OPT_Wenum_compare
,
5579 "comparison between %q#T and %q#T",
5580 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5587 /* We need to strip any leading REF_BIND so that bitfields
5588 don't cause errors. This should not remove any important
5589 conversions, because builtins don't apply to class
5590 objects directly. */
5591 conv
= cand
->convs
[0];
5592 if (conv
->kind
== ck_ref_bind
)
5593 conv
= next_conversion (conv
);
5594 arg1
= convert_like (conv
, arg1
, complain
);
5598 conv
= cand
->convs
[1];
5599 if (conv
->kind
== ck_ref_bind
)
5600 conv
= next_conversion (conv
);
5602 arg2
= decay_conversion (arg2
, complain
);
5604 /* We need to call warn_logical_operator before
5605 converting arg2 to a boolean_type, but after
5606 decaying an enumerator to its value. */
5607 if (complain
& tf_warning
)
5608 warn_logical_operator (loc
, code
, boolean_type_node
,
5609 code_orig_arg1
, arg1
,
5610 code_orig_arg2
, arg2
);
5612 arg2
= convert_like (conv
, arg2
, complain
);
5616 conv
= cand
->convs
[2];
5617 if (conv
->kind
== ck_ref_bind
)
5618 conv
= next_conversion (conv
);
5619 arg3
= convert_like (conv
, arg3
, complain
);
5625 user_defined_result_ready
:
5627 /* Free all the conversions we allocated. */
5628 obstack_free (&conversion_obstack
, p
);
5630 if (result
|| result_valid_p
)
5637 return cp_build_modify_expr (arg1
, code2
, arg2
, complain
);
5640 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
5642 case TRUTH_ANDIF_EXPR
:
5643 case TRUTH_ORIF_EXPR
:
5644 case TRUTH_AND_EXPR
:
5646 warn_logical_operator (loc
, code
, boolean_type_node
,
5647 code_orig_arg1
, arg1
, code_orig_arg2
, arg2
);
5655 if ((code_orig_arg1
== BOOLEAN_TYPE
)
5656 ^ (code_orig_arg2
== BOOLEAN_TYPE
))
5657 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
5662 case TRUNC_DIV_EXPR
:
5667 case TRUNC_MOD_EXPR
:
5671 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
5673 case UNARY_PLUS_EXPR
:
5676 case TRUTH_NOT_EXPR
:
5677 case PREINCREMENT_EXPR
:
5678 case POSTINCREMENT_EXPR
:
5679 case PREDECREMENT_EXPR
:
5680 case POSTDECREMENT_EXPR
:
5684 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5687 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5690 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
5694 /* The caller will deal with these. */
5706 /* Wrapper for above. */
5709 build_new_op (location_t loc
, enum tree_code code
, int flags
,
5710 tree arg1
, tree arg2
, tree arg3
,
5711 tree
*overload
, tsubst_flags_t complain
)
5714 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5715 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
5716 overload
, complain
);
5717 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5721 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5722 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5725 non_placement_deallocation_fn_p (tree t
)
5727 /* A template instance is never a usual deallocation function,
5728 regardless of its signature. */
5729 if (TREE_CODE (t
) == TEMPLATE_DECL
5730 || primary_template_instantiation_p (t
))
5733 /* If a class T has a member deallocation function named operator delete
5734 with exactly one parameter, then that function is a usual
5735 (non-placement) deallocation function. If class T does not declare
5736 such an operator delete but does declare a member deallocation
5737 function named operator delete with exactly two parameters, the second
5738 of which has type std::size_t (18.2), then this function is a usual
5739 deallocation function. */
5740 t
= FUNCTION_ARG_CHAIN (t
);
5741 if (t
== void_list_node
5742 || (t
&& same_type_p (TREE_VALUE (t
), size_type_node
)
5743 && TREE_CHAIN (t
) == void_list_node
))
5748 /* Build a call to operator delete. This has to be handled very specially,
5749 because the restrictions on what signatures match are different from all
5750 other call instances. For a normal delete, only a delete taking (void *)
5751 or (void *, size_t) is accepted. For a placement delete, only an exact
5752 match with the placement new is accepted.
5754 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5755 ADDR is the pointer to be deleted.
5756 SIZE is the size of the memory block to be deleted.
5757 GLOBAL_P is true if the delete-expression should not consider
5758 class-specific delete operators.
5759 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5761 If this call to "operator delete" is being generated as part to
5762 deallocate memory allocated via a new-expression (as per [expr.new]
5763 which requires that if the initialization throws an exception then
5764 we call a deallocation function), then ALLOC_FN is the allocation
5768 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
5769 bool global_p
, tree placement
,
5770 tree alloc_fn
, tsubst_flags_t complain
)
5772 tree fn
= NULL_TREE
;
5773 tree fns
, fnname
, type
, t
;
5775 if (addr
== error_mark_node
)
5776 return error_mark_node
;
5778 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
5780 fnname
= ansi_opname (code
);
5782 if (CLASS_TYPE_P (type
)
5783 && COMPLETE_TYPE_P (complete_type (type
))
5787 If the result of the lookup is ambiguous or inaccessible, or if
5788 the lookup selects a placement deallocation function, the
5789 program is ill-formed.
5791 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5793 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
5794 if (fns
== error_mark_node
)
5795 return error_mark_node
;
5800 if (fns
== NULL_TREE
)
5801 fns
= lookup_name_nonclass (fnname
);
5803 /* Strip const and volatile from addr. */
5804 addr
= cp_convert (ptr_type_node
, addr
, complain
);
5808 /* "A declaration of a placement deallocation function matches the
5809 declaration of a placement allocation function if it has the same
5810 number of parameters and, after parameter transformations (8.3.5),
5811 all parameter types except the first are identical."
5813 So we build up the function type we want and ask instantiate_type
5814 to get it for us. */
5815 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
5816 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
5817 t
= build_function_type (void_type_node
, t
);
5819 fn
= instantiate_type (t
, fns
, tf_none
);
5820 if (fn
== error_mark_node
)
5823 if (BASELINK_P (fn
))
5824 fn
= BASELINK_FUNCTIONS (fn
);
5826 /* "If the lookup finds the two-parameter form of a usual deallocation
5827 function (3.7.4.2) and that function, considered as a placement
5828 deallocation function, would have been selected as a match for the
5829 allocation function, the program is ill-formed." */
5830 if (non_placement_deallocation_fn_p (fn
))
5832 /* But if the class has an operator delete (void *), then that is
5833 the usual deallocation function, so we shouldn't complain
5834 about using the operator delete (void *, size_t). */
5835 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5836 t
; t
= OVL_NEXT (t
))
5838 tree elt
= OVL_CURRENT (t
);
5839 if (non_placement_deallocation_fn_p (elt
)
5840 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
5843 if (complain
& tf_error
)
5845 permerror (0, "non-placement deallocation function %q+D", fn
);
5846 permerror (input_location
, "selected for placement delete");
5849 return error_mark_node
;
5854 /* "Any non-placement deallocation function matches a non-placement
5855 allocation function. If the lookup finds a single matching
5856 deallocation function, that function will be called; otherwise, no
5857 deallocation function will be called." */
5858 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5859 t
; t
= OVL_NEXT (t
))
5861 tree elt
= OVL_CURRENT (t
);
5862 if (non_placement_deallocation_fn_p (elt
))
5865 /* "If a class T has a member deallocation function named
5866 operator delete with exactly one parameter, then that
5867 function is a usual (non-placement) deallocation
5868 function. If class T does not declare such an operator
5869 delete but does declare a member deallocation function named
5870 operator delete with exactly two parameters, the second of
5871 which has type std::size_t (18.2), then this function is a
5872 usual deallocation function."
5874 So (void*) beats (void*, size_t). */
5875 if (FUNCTION_ARG_CHAIN (fn
) == void_list_node
)
5880 /* If we have a matching function, call it. */
5883 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
5885 /* If the FN is a member function, make sure that it is
5887 if (BASELINK_P (fns
))
5888 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
5891 /* Core issue 901: It's ok to new a type with deleted delete. */
5892 if (DECL_DELETED_FN (fn
) && alloc_fn
)
5897 /* The placement args might not be suitable for overload
5898 resolution at this point, so build the call directly. */
5899 int nargs
= call_expr_nargs (placement
);
5900 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
5903 for (i
= 1; i
< nargs
; i
++)
5904 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
5906 return build_cxx_call (fn
, nargs
, argarray
, complain
);
5911 vec
<tree
, va_gc
> *args
= make_tree_vector ();
5912 args
->quick_push (addr
);
5913 if (FUNCTION_ARG_CHAIN (fn
) != void_list_node
)
5914 args
->quick_push (size
);
5915 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
5916 release_tree_vector (args
);
5923 If no unambiguous matching deallocation function can be found,
5924 propagating the exception does not cause the object's memory to
5928 if ((complain
& tf_warning
)
5930 warning (0, "no corresponding deallocation function for %qD",
5935 if (complain
& tf_error
)
5936 error ("no suitable %<operator %s%> for %qT",
5937 operator_name_info
[(int)code
].name
, type
);
5938 return error_mark_node
;
5941 /* If the current scope isn't allowed to access DECL along
5942 BASETYPE_PATH, give an error. The most derived class in
5943 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
5944 the declaration to use in the error diagnostic. */
5947 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
5948 tsubst_flags_t complain
)
5950 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
5952 if (!accessible_p (basetype_path
, decl
, true))
5954 if (complain
& tf_error
)
5956 if (TREE_PRIVATE (decl
))
5957 error ("%q+#D is private", diag_decl
);
5958 else if (TREE_PROTECTED (decl
))
5959 error ("%q+#D is protected", diag_decl
);
5961 error ("%q+#D is inaccessible", diag_decl
);
5962 error ("within this context");
5970 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
5971 bitwise or of LOOKUP_* values. If any errors are warnings are
5972 generated, set *DIAGNOSTIC_FN to "error" or "warning",
5973 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
5977 build_temp (tree expr
, tree type
, int flags
,
5978 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
5981 vec
<tree
, va_gc
> *args
;
5983 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
5984 args
= make_tree_vector_single (expr
);
5985 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
5986 &args
, type
, flags
, complain
);
5987 release_tree_vector (args
);
5988 if (warningcount
+ werrorcount
> savew
)
5989 *diagnostic_kind
= DK_WARNING
;
5990 else if (errorcount
> savee
)
5991 *diagnostic_kind
= DK_ERROR
;
5993 *diagnostic_kind
= DK_UNSPECIFIED
;
5997 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
5998 EXPR is implicitly converted to type TOTYPE.
5999 FN and ARGNUM are used for diagnostics. */
6002 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6004 /* Issue warnings about peculiar, but valid, uses of NULL. */
6005 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
6006 && ARITHMETIC_TYPE_P (totype
))
6008 source_location loc
=
6009 expansion_point_location_if_in_system_header (input_location
);
6012 warning_at (loc
, OPT_Wconversion_null
,
6013 "passing NULL to non-pointer argument %P of %qD",
6016 warning_at (loc
, OPT_Wconversion_null
,
6017 "converting to non-pointer type %qT from NULL", totype
);
6020 /* Issue warnings if "false" is converted to a NULL pointer */
6021 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6022 && TYPE_PTR_P (totype
))
6025 warning_at (input_location
, OPT_Wconversion_null
,
6026 "converting %<false%> to pointer type for argument %P "
6027 "of %qD", argnum
, fn
);
6029 warning_at (input_location
, OPT_Wconversion_null
,
6030 "converting %<false%> to pointer type %qT", totype
);
6034 /* We gave a diagnostic during a conversion. If this was in the second
6035 standard conversion sequence of a user-defined conversion sequence, say
6036 which user-defined conversion. */
6039 maybe_print_user_conv_context (conversion
*convs
)
6041 if (convs
->user_conv_p
)
6042 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6043 if (t
->kind
== ck_user
)
6045 print_z_candidate (0, " after user-defined conversion:",
6051 /* Perform the conversions in CONVS on the expression EXPR. FN and
6052 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6053 indicates the `this' argument of a method. INNER is nonzero when
6054 being called to continue a conversion chain. It is negative when a
6055 reference binding will be applied, positive otherwise. If
6056 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6057 conversions will be emitted if appropriate. If C_CAST_P is true,
6058 this conversion is coming from a C-style cast; in that case,
6059 conversions to inaccessible bases are permitted. */
6062 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6063 int inner
, bool issue_conversion_warnings
,
6064 bool c_cast_p
, tsubst_flags_t complain
)
6066 tree totype
= convs
->type
;
6067 diagnostic_t diag_kind
;
6069 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6071 if (convs
->bad_p
&& !(complain
& tf_error
))
6072 return error_mark_node
;
6075 && convs
->kind
!= ck_user
6076 && convs
->kind
!= ck_list
6077 && convs
->kind
!= ck_ambig
6078 && (convs
->kind
!= ck_ref_bind
6079 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
6080 && (convs
->kind
!= ck_rvalue
6081 || SCALAR_TYPE_P (totype
))
6082 && convs
->kind
!= ck_base
)
6084 bool complained
= false;
6085 conversion
*t
= convs
;
6087 /* Give a helpful error if this is bad because of excess braces. */
6088 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6089 && SCALAR_TYPE_P (totype
)
6090 && CONSTRUCTOR_NELTS (expr
) > 0
6091 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
6093 complained
= permerror (loc
, "too many braces around initializer "
6095 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6096 && CONSTRUCTOR_NELTS (expr
) == 1)
6097 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6100 /* Give a helpful error if this is bad because a conversion to bool
6101 from std::nullptr_t requires direct-initialization. */
6102 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
6103 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
6104 complained
= permerror (loc
, "converting to %qT from %qT requires "
6105 "direct-initialization",
6106 totype
, TREE_TYPE (expr
));
6108 for (; t
; t
= next_conversion (t
))
6110 if (t
->kind
== ck_user
&& t
->cand
->reason
)
6112 complained
= permerror (loc
, "invalid user-defined conversion "
6113 "from %qT to %qT", TREE_TYPE (expr
),
6116 print_z_candidate (loc
, "candidate is:", t
->cand
);
6117 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6118 /*issue_conversion_warnings=*/false,
6121 if (convs
->kind
== ck_ref_bind
)
6122 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
6123 LOOKUP_NORMAL
, NULL_TREE
,
6126 expr
= cp_convert (totype
, expr
, complain
);
6127 if (complained
&& fn
)
6128 inform (DECL_SOURCE_LOCATION (fn
),
6129 " initializing argument %P of %qD", argnum
, fn
);
6132 else if (t
->kind
== ck_user
|| !t
->bad_p
)
6134 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6135 /*issue_conversion_warnings=*/false,
6140 else if (t
->kind
== ck_ambig
)
6141 return convert_like_real (t
, expr
, fn
, argnum
, 1,
6142 /*issue_conversion_warnings=*/false,
6145 else if (t
->kind
== ck_identity
)
6149 complained
= permerror (loc
, "invalid conversion from %qT to %qT",
6150 TREE_TYPE (expr
), totype
);
6151 if (complained
&& fn
)
6152 inform (DECL_SOURCE_LOCATION (fn
),
6153 " initializing argument %P of %qD", argnum
, fn
);
6155 return cp_convert (totype
, expr
, complain
);
6158 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6159 conversion_null_warnings (totype
, expr
, fn
, argnum
);
6161 switch (convs
->kind
)
6165 struct z_candidate
*cand
= convs
->cand
;
6166 tree convfn
= cand
->fn
;
6169 /* When converting from an init list we consider explicit
6170 constructors, but actually trying to call one is an error. */
6171 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
6172 /* Unless this is for direct-list-initialization. */
6173 && !DIRECT_LIST_INIT_P (expr
))
6175 if (!(complain
& tf_error
))
6176 return error_mark_node
;
6177 error ("converting to %qT from initializer list would use "
6178 "explicit constructor %qD", totype
, convfn
);
6181 /* If we're initializing from {}, it's value-initialization. */
6182 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6183 && CONSTRUCTOR_NELTS (expr
) == 0
6184 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
6186 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
6187 expr
= build_value_init (totype
, complain
);
6188 expr
= get_target_expr_sfinae (expr
, complain
);
6189 if (expr
!= error_mark_node
)
6191 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6192 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
6197 expr
= mark_rvalue_use (expr
);
6199 /* Set user_conv_p on the argument conversions, so rvalue/base
6200 handling knows not to allow any more UDCs. */
6201 for (i
= 0; i
< cand
->num_convs
; ++i
)
6202 cand
->convs
[i
]->user_conv_p
= true;
6204 expr
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
6206 /* If this is a constructor or a function returning an aggr type,
6207 we need to build up a TARGET_EXPR. */
6208 if (DECL_CONSTRUCTOR_P (convfn
))
6210 expr
= build_cplus_new (totype
, expr
, complain
);
6212 /* Remember that this was list-initialization. */
6213 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
6214 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6220 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
6222 int nelts
= CONSTRUCTOR_NELTS (expr
);
6224 expr
= build_value_init (totype
, complain
);
6225 else if (nelts
== 1)
6226 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6230 expr
= mark_rvalue_use (expr
);
6232 if (type_unknown_p (expr
))
6233 expr
= instantiate_type (totype
, expr
, complain
);
6234 /* Convert a constant to its underlying value, unless we are
6235 about to bind it to a reference, in which case we need to
6236 leave it as an lvalue. */
6239 expr
= decl_constant_value_safe (expr
);
6240 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
6241 /* If __null has been converted to an integer type, we do not
6242 want to warn about uses of EXPR as an integer, rather than
6244 expr
= build_int_cst (totype
, 0);
6248 /* We leave bad_p off ck_ambig because overload resolution considers
6249 it valid, it just fails when we try to perform it. So we need to
6250 check complain here, too. */
6251 if (complain
& tf_error
)
6253 /* Call build_user_type_conversion again for the error. */
6254 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
6257 inform (input_location
, " initializing argument %P of %q+D",
6260 return error_mark_node
;
6264 /* Conversion to std::initializer_list<T>. */
6265 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
6266 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
6267 unsigned len
= CONSTRUCTOR_NELTS (expr
);
6268 tree array
, val
, field
;
6269 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6272 /* Convert all the elements. */
6273 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
6275 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
6276 1, false, false, complain
);
6277 if (sub
== error_mark_node
)
6279 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
6280 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
6281 return error_mark_node
;
6282 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
6283 if (!TREE_CONSTANT (sub
))
6284 TREE_CONSTANT (new_ctor
) = false;
6286 /* Build up the array. */
6287 elttype
= cp_build_qualified_type
6288 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
6289 array
= build_array_of_n_type (elttype
, len
);
6290 array
= finish_compound_literal (array
, new_ctor
, complain
);
6291 /* Take the address explicitly rather than via decay_conversion
6292 to avoid the error about taking the address of a temporary. */
6293 array
= cp_build_addr_expr (array
, complain
);
6294 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
6295 if (array
== error_mark_node
)
6296 return error_mark_node
;
6298 /* Build up the initializer_list object. */
6299 totype
= complete_type (totype
);
6300 field
= next_initializable_field (TYPE_FIELDS (totype
));
6301 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6302 field
= next_initializable_field (DECL_CHAIN (field
));
6303 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6304 new_ctor
= build_constructor (totype
, vec
);
6305 return get_target_expr_sfinae (new_ctor
, complain
);
6309 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6311 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6312 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6313 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6315 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6317 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6318 return fold_if_not_in_template (expr
);
6320 expr
= reshape_init (totype
, expr
, complain
);
6321 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6323 if (expr
!= error_mark_node
)
6324 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6331 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6332 convs
->kind
== ck_ref_bind
? -1 : 1,
6333 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6336 if (expr
== error_mark_node
)
6337 return error_mark_node
;
6339 switch (convs
->kind
)
6342 expr
= decay_conversion (expr
, complain
);
6343 if (expr
== error_mark_node
)
6344 return error_mark_node
;
6346 if (! MAYBE_CLASS_TYPE_P (totype
))
6348 /* Else fall through. */
6350 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6352 /* We are going to bind a reference directly to a base-class
6353 subobject of EXPR. */
6354 /* Build an expression for `*((base*) &expr)'. */
6355 expr
= convert_to_base (expr
, totype
,
6356 !c_cast_p
, /*nonnull=*/true, complain
);
6360 /* Copy-initialization where the cv-unqualified version of the source
6361 type is the same class as, or a derived class of, the class of the
6362 destination [is treated as direct-initialization]. [dcl.init] */
6363 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
6364 if (convs
->user_conv_p
)
6365 /* This conversion is being done in the context of a user-defined
6366 conversion (i.e. the second step of copy-initialization), so
6367 don't allow any more. */
6368 flags
|= LOOKUP_NO_CONVERSION
;
6369 if (convs
->rvaluedness_matches_p
)
6370 flags
|= LOOKUP_PREFER_RVALUE
;
6371 if (TREE_CODE (expr
) == TARGET_EXPR
6372 && TARGET_EXPR_LIST_INIT_P (expr
))
6373 /* Copy-list-initialization doesn't actually involve a copy. */
6375 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6376 if (diag_kind
&& complain
)
6378 maybe_print_user_conv_context (convs
);
6380 inform (DECL_SOURCE_LOCATION (fn
),
6381 " initializing argument %P of %qD", argnum
, fn
);
6384 return build_cplus_new (totype
, expr
, complain
);
6388 tree ref_type
= totype
;
6390 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6392 tree extype
= TREE_TYPE (expr
);
6393 if (TYPE_REF_IS_RVALUE (ref_type
)
6394 && real_lvalue_p (expr
))
6395 error_at (loc
, "cannot bind %qT lvalue to %qT",
6397 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !real_lvalue_p (expr
)
6398 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
6399 error_at (loc
, "invalid initialization of non-const reference of "
6400 "type %qT from an rvalue of type %qT", totype
, extype
);
6401 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
6402 error_at (loc
, "binding %qT to reference of type %qT "
6403 "discards qualifiers", extype
, totype
);
6406 maybe_print_user_conv_context (convs
);
6408 inform (input_location
,
6409 " initializing argument %P of %q+D", argnum
, fn
);
6410 return error_mark_node
;
6413 /* If necessary, create a temporary.
6415 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6416 that need temporaries, even when their types are reference
6417 compatible with the type of reference being bound, so the
6418 upcoming call to cp_build_addr_expr doesn't fail. */
6419 if (convs
->need_temporary_p
6420 || TREE_CODE (expr
) == CONSTRUCTOR
6421 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6423 /* Otherwise, a temporary of type "cv1 T1" is created and
6424 initialized from the initializer expression using the rules
6425 for a non-reference copy-initialization (8.5). */
6427 tree type
= TREE_TYPE (ref_type
);
6428 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
6430 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6431 (type
, next_conversion (convs
)->type
));
6432 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6433 && !TYPE_REF_IS_RVALUE (ref_type
))
6435 /* If the reference is volatile or non-const, we
6436 cannot create a temporary. */
6437 if (lvalue
& clk_bitfield
)
6438 error_at (loc
, "cannot bind bitfield %qE to %qT",
6440 else if (lvalue
& clk_packed
)
6441 error_at (loc
, "cannot bind packed field %qE to %qT",
6444 error_at (loc
, "cannot bind rvalue %qE to %qT",
6446 return error_mark_node
;
6448 /* If the source is a packed field, and we must use a copy
6449 constructor, then building the target expr will require
6450 binding the field to the reference parameter to the
6451 copy constructor, and we'll end up with an infinite
6452 loop. If we can use a bitwise copy, then we'll be
6454 if ((lvalue
& clk_packed
)
6455 && CLASS_TYPE_P (type
)
6456 && type_has_nontrivial_copy_init (type
))
6458 error_at (loc
, "cannot bind packed field %qE to %qT",
6460 return error_mark_node
;
6462 if (lvalue
& clk_bitfield
)
6464 expr
= convert_bitfield_to_declared_type (expr
);
6465 expr
= fold_convert (type
, expr
);
6467 expr
= build_target_expr_with_type (expr
, type
, complain
);
6470 /* Take the address of the thing to which we will bind the
6472 expr
= cp_build_addr_expr (expr
, complain
);
6473 if (expr
== error_mark_node
)
6474 return error_mark_node
;
6476 /* Convert it to a pointer to the type referred to by the
6477 reference. This will adjust the pointer if a derived to
6478 base conversion is being performed. */
6479 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
6481 /* Convert the pointer to the desired reference type. */
6482 return build_nop (ref_type
, expr
);
6486 return decay_conversion (expr
, complain
);
6489 /* Warn about deprecated conversion if appropriate. */
6490 string_conv_p (totype
, expr
, 1);
6495 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
6496 /*nonnull=*/false, complain
);
6497 return build_nop (totype
, expr
);
6500 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
6501 c_cast_p
, complain
);
6507 if (convs
->check_narrowing
6508 && !check_narrowing (totype
, expr
, complain
))
6509 return error_mark_node
;
6511 if (issue_conversion_warnings
)
6512 expr
= cp_convert_and_check (totype
, expr
, complain
);
6514 expr
= cp_convert (totype
, expr
, complain
);
6519 /* ARG is being passed to a varargs function. Perform any conversions
6520 required. Return the converted value. */
6523 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
6526 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
6530 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6531 standard conversions are performed. */
6532 arg
= decay_conversion (arg
, complain
);
6533 arg_type
= TREE_TYPE (arg
);
6536 If the argument has integral or enumeration type that is subject
6537 to the integral promotions (_conv.prom_), or a floating point
6538 type that is subject to the floating point promotion
6539 (_conv.fpprom_), the value of the argument is converted to the
6540 promoted type before the call. */
6541 if (TREE_CODE (arg_type
) == REAL_TYPE
6542 && (TYPE_PRECISION (arg_type
)
6543 < TYPE_PRECISION (double_type_node
))
6544 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
6546 if ((complain
& tf_warning
)
6547 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
6548 warning_at (loc
, OPT_Wdouble_promotion
,
6549 "implicit conversion from %qT to %qT when passing "
6550 "argument to function",
6551 arg_type
, double_type_node
);
6552 arg
= convert_to_real (double_type_node
, arg
);
6554 else if (NULLPTR_TYPE_P (arg_type
))
6555 arg
= null_pointer_node
;
6556 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
6558 if (SCOPED_ENUM_P (arg_type
))
6560 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
6562 prom
= cp_perform_integral_promotions (prom
, complain
);
6563 if (abi_version_crosses (6)
6564 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
6565 && (complain
& tf_warning
))
6566 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through ... as "
6567 "%qT before -fabi-version=6, %qT after", arg_type
,
6568 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
6569 if (!abi_version_at_least (6))
6573 arg
= cp_perform_integral_promotions (arg
, complain
);
6576 arg
= require_complete_type_sfinae (arg
, complain
);
6577 arg_type
= TREE_TYPE (arg
);
6579 if (arg
!= error_mark_node
6580 /* In a template (or ill-formed code), we can have an incomplete type
6581 even after require_complete_type_sfinae, in which case we don't know
6582 whether it has trivial copy or not. */
6583 && COMPLETE_TYPE_P (arg_type
))
6585 /* Build up a real lvalue-to-rvalue conversion in case the
6586 copy constructor is trivial but not callable. */
6587 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
6588 force_rvalue (arg
, complain
);
6590 /* [expr.call] 5.2.2/7:
6591 Passing a potentially-evaluated argument of class type (Clause 9)
6592 with a non-trivial copy constructor or a non-trivial destructor
6593 with no corresponding parameter is conditionally-supported, with
6594 implementation-defined semantics.
6596 We support it as pass-by-invisible-reference, just like a normal
6599 If the call appears in the context of a sizeof expression,
6600 it is not potentially-evaluated. */
6601 if (cp_unevaluated_operand
== 0
6602 && (type_has_nontrivial_copy_init (arg_type
)
6603 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
6605 if (complain
& tf_warning
)
6606 warning (OPT_Wconditionally_supported
,
6607 "passing objects of non-trivially-copyable "
6608 "type %q#T through %<...%> is conditionally supported",
6610 return cp_build_addr_expr (arg
, complain
);
6617 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6620 build_x_va_arg (source_location loc
, tree expr
, tree type
)
6622 if (processing_template_decl
)
6624 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
6625 SET_EXPR_LOCATION (r
, loc
);
6629 type
= complete_type_or_else (type
, NULL_TREE
);
6631 if (expr
== error_mark_node
|| !type
)
6632 return error_mark_node
;
6634 expr
= mark_lvalue_use (expr
);
6636 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6638 error ("cannot receive reference type %qT through %<...%>", type
);
6639 return error_mark_node
;
6642 if (type_has_nontrivial_copy_init (type
)
6643 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6645 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
6646 it as pass by invisible reference. */
6647 warning_at (loc
, OPT_Wconditionally_supported
,
6648 "receiving objects of non-trivially-copyable type %q#T "
6649 "through %<...%> is conditionally-supported", type
);
6651 tree ref
= cp_build_reference_type (type
, false);
6652 expr
= build_va_arg (loc
, expr
, ref
);
6653 return convert_from_reference (expr
);
6656 return build_va_arg (loc
, expr
, type
);
6659 /* TYPE has been given to va_arg. Apply the default conversions which
6660 would have happened when passed via ellipsis. Return the promoted
6661 type, or the passed type if there is no change. */
6664 cxx_type_promotes_to (tree type
)
6668 /* Perform the array-to-pointer and function-to-pointer
6670 type
= type_decays_to (type
);
6672 promote
= type_promotes_to (type
);
6673 if (same_type_p (type
, promote
))
6679 /* ARG is a default argument expression being passed to a parameter of
6680 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6681 zero-based argument number. Do any required conversions. Return
6682 the converted value. */
6684 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
6686 push_defarg_context (tree fn
)
6687 { vec_safe_push (default_arg_context
, fn
); }
6690 pop_defarg_context (void)
6691 { default_arg_context
->pop (); }
6694 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
6695 tsubst_flags_t complain
)
6700 /* See through clones. */
6701 fn
= DECL_ORIGIN (fn
);
6703 /* Detect recursion. */
6704 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
6707 if (complain
& tf_error
)
6708 error ("recursive evaluation of default argument for %q#D", fn
);
6709 return error_mark_node
;
6712 /* If the ARG is an unparsed default argument expression, the
6713 conversion cannot be performed. */
6714 if (TREE_CODE (arg
) == DEFAULT_ARG
)
6716 if (complain
& tf_error
)
6717 error ("call to %qD uses the default argument for parameter %P, which "
6718 "is not yet defined", fn
, parmnum
);
6719 return error_mark_node
;
6722 push_defarg_context (fn
);
6724 if (fn
&& DECL_TEMPLATE_INFO (fn
))
6725 arg
= tsubst_default_argument (fn
, type
, arg
, complain
);
6731 The names in the expression are bound, and the semantic
6732 constraints are checked, at the point where the default
6733 expressions appears.
6735 we must not perform access checks here. */
6736 push_deferring_access_checks (dk_no_check
);
6737 /* We must make a copy of ARG, in case subsequent processing
6738 alters any part of it. */
6739 arg
= break_out_target_exprs (arg
);
6740 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6741 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6743 arg
= convert_for_arg_passing (type
, arg
, complain
);
6744 pop_deferring_access_checks();
6746 pop_defarg_context ();
6751 /* Returns the type which will really be used for passing an argument of
6755 type_passed_as (tree type
)
6757 /* Pass classes with copy ctors by invisible reference. */
6758 if (TREE_ADDRESSABLE (type
))
6760 type
= build_reference_type (type
);
6761 /* There are no other pointers to this temporary. */
6762 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
6764 else if (targetm
.calls
.promote_prototypes (type
)
6765 && INTEGRAL_TYPE_P (type
)
6766 && COMPLETE_TYPE_P (type
)
6767 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6768 type
= integer_type_node
;
6773 /* Actually perform the appropriate conversion. */
6776 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
6780 /* If VAL is a bitfield, then -- since it has already been converted
6781 to TYPE -- it cannot have a precision greater than TYPE.
6783 If it has a smaller precision, we must widen it here. For
6784 example, passing "int f:3;" to a function expecting an "int" will
6785 not result in any conversion before this point.
6787 If the precision is the same we must not risk widening. For
6788 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6789 often have type "int", even though the C++ type for the field is
6790 "long long". If the value is being passed to a function
6791 expecting an "int", then no conversions will be required. But,
6792 if we call convert_bitfield_to_declared_type, the bitfield will
6793 be converted to "long long". */
6794 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
6796 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
6797 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
6799 if (val
== error_mark_node
)
6801 /* Pass classes with copy ctors by invisible reference. */
6802 else if (TREE_ADDRESSABLE (type
))
6803 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
6804 else if (targetm
.calls
.promote_prototypes (type
)
6805 && INTEGRAL_TYPE_P (type
)
6806 && COMPLETE_TYPE_P (type
)
6807 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6808 val
= cp_perform_integral_promotions (val
, complain
);
6809 if ((complain
& tf_warning
)
6810 && warn_suggest_attribute_format
)
6812 tree rhstype
= TREE_TYPE (val
);
6813 const enum tree_code coder
= TREE_CODE (rhstype
);
6814 const enum tree_code codel
= TREE_CODE (type
);
6815 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6817 && check_missing_format_attribute (type
, rhstype
))
6818 warning (OPT_Wsuggest_attribute_format
,
6819 "argument of function call might be a candidate for a format attribute");
6824 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6825 which no conversions at all should be done. This is true for some
6826 builtins which don't act like normal functions. */
6829 magic_varargs_p (tree fn
)
6831 if (flag_cilkplus
&& is_cilkplus_reduce_builtin (fn
) != BUILT_IN_NONE
)
6834 if (DECL_BUILT_IN (fn
))
6835 switch (DECL_FUNCTION_CODE (fn
))
6837 case BUILT_IN_CLASSIFY_TYPE
:
6838 case BUILT_IN_CONSTANT_P
:
6839 case BUILT_IN_NEXT_ARG
:
6840 case BUILT_IN_VA_START
:
6844 return lookup_attribute ("type generic",
6845 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
6851 /* Returns the decl of the dispatcher function if FN is a function version. */
6854 get_function_version_dispatcher (tree fn
)
6856 tree dispatcher_decl
= NULL
;
6858 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6859 && DECL_FUNCTION_VERSIONED (fn
));
6861 gcc_assert (targetm
.get_function_versions_dispatcher
);
6862 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
6864 if (dispatcher_decl
== NULL
)
6866 error_at (input_location
, "use of multiversioned function "
6867 "without a default");
6871 retrofit_lang_decl (dispatcher_decl
);
6872 gcc_assert (dispatcher_decl
!= NULL
);
6873 return dispatcher_decl
;
6876 /* fn is a function version dispatcher that is marked used. Mark all the
6877 semantically identical function versions it will dispatch as used. */
6880 mark_versions_used (tree fn
)
6882 struct cgraph_node
*node
;
6883 struct cgraph_function_version_info
*node_v
;
6884 struct cgraph_function_version_info
*it_v
;
6886 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6888 node
= cgraph_node::get (fn
);
6892 gcc_assert (node
->dispatcher_function
);
6894 node_v
= node
->function_version ();
6898 /* All semantically identical versions are chained. Traverse and mark each
6899 one of them as used. */
6900 it_v
= node_v
->next
;
6901 while (it_v
!= NULL
)
6903 mark_used (it_v
->this_node
->decl
);
6908 /* Build a call to "the copy constructor" for the type of A, even if it
6909 wouldn't be selected by normal overload resolution. Used for
6913 call_copy_ctor (tree a
, tsubst_flags_t complain
)
6915 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
6916 tree binfo
= TYPE_BINFO (ctype
);
6917 tree copy
= get_copy_ctor (ctype
, complain
);
6918 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
6919 tree ob
= build_dummy_object (ctype
);
6920 vec
<tree
, va_gc
>* args
= make_tree_vector_single (a
);
6921 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
6922 LOOKUP_NORMAL
, NULL
, complain
);
6923 release_tree_vector (args
);
6927 /* Subroutine of the various build_*_call functions. Overload resolution
6928 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
6929 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
6930 bitmask of various LOOKUP_* flags which apply to the call itself. */
6933 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
6936 const vec
<tree
, va_gc
> *args
= cand
->args
;
6937 tree first_arg
= cand
->first_arg
;
6938 conversion
**convs
= cand
->convs
;
6940 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6945 unsigned int arg_index
= 0;
6949 bool already_used
= false;
6951 /* In a template, there is no need to perform all of the work that
6952 is normally done. We are only interested in the type of the call
6953 expression, i.e., the return type of the function. Any semantic
6954 errors will be deferred until the template is instantiated. */
6955 if (processing_template_decl
)
6959 const tree
*argarray
;
6962 return_type
= TREE_TYPE (TREE_TYPE (fn
));
6963 nargs
= vec_safe_length (args
);
6964 if (first_arg
== NULL_TREE
)
6965 argarray
= args
->address ();
6973 alcarray
= XALLOCAVEC (tree
, nargs
);
6974 alcarray
[0] = build_this (first_arg
);
6975 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
6976 alcarray
[ix
+ 1] = arg
;
6977 argarray
= alcarray
;
6980 addr
= build_addr_func (fn
, complain
);
6981 if (addr
== error_mark_node
)
6982 return error_mark_node
;
6983 expr
= build_call_array_loc (input_location
, return_type
,
6984 addr
, nargs
, argarray
);
6985 if (TREE_THIS_VOLATILE (fn
) && cfun
)
6986 current_function_returns_abnormally
= 1;
6987 return convert_from_reference (expr
);
6990 /* Give any warnings we noticed during overload resolution. */
6991 if (cand
->warnings
&& (complain
& tf_warning
))
6993 struct candidate_warning
*w
;
6994 for (w
= cand
->warnings
; w
; w
= w
->next
)
6995 joust (cand
, w
->loser
, 1, complain
);
6998 /* Make =delete work with SFINAE. */
6999 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7000 return error_mark_node
;
7002 if (DECL_FUNCTION_MEMBER_P (fn
))
7005 /* If FN is a template function, two cases must be considered.
7010 template <class T> void f();
7012 template <class T> struct B {
7016 struct C : A, B<int> {
7018 using B<int>::g; // #2
7021 In case #1 where `A::f' is a member template, DECL_ACCESS is
7022 recorded in the primary template but not in its specialization.
7023 We check access of FN using its primary template.
7025 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
7026 because it is a member of class template B, DECL_ACCESS is
7027 recorded in the specialization `B<int>::g'. We cannot use its
7028 primary template because `B<T>::g' and `B<int>::g' may have
7029 different access. */
7030 if (DECL_TEMPLATE_INFO (fn
)
7031 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
7032 access_fn
= DECL_TI_TEMPLATE (fn
);
7035 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
7037 return error_mark_node
;
7040 /* If we're checking for implicit delete, don't bother with argument
7042 if (flags
& LOOKUP_SPECULATIVE
)
7044 if (DECL_DELETED_FN (fn
))
7046 if (complain
& tf_error
)
7048 return error_mark_node
;
7050 if (cand
->viable
== 1)
7052 else if (!(complain
& tf_error
))
7053 /* Reject bad conversions now. */
7054 return error_mark_node
;
7055 /* else continue to get conversion error. */
7058 /* N3276 magic doesn't apply to nested calls. */
7059 int decltype_flag
= (complain
& tf_decltype
);
7060 complain
&= ~tf_decltype
;
7062 /* Find maximum size of vector to hold converted arguments. */
7063 parmlen
= list_length (parm
);
7064 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
7065 if (parmlen
> nargs
)
7067 argarray
= XALLOCAVEC (tree
, nargs
);
7069 /* The implicit parameters to a constructor are not considered by overload
7070 resolution, and must be of the proper type. */
7071 if (DECL_CONSTRUCTOR_P (fn
))
7074 if (first_arg
!= NULL_TREE
)
7076 object_arg
= first_arg
;
7077 first_arg
= NULL_TREE
;
7081 object_arg
= (*args
)[arg_index
];
7084 argarray
[j
++] = build_this (object_arg
);
7085 parm
= TREE_CHAIN (parm
);
7086 /* We should never try to call the abstract constructor. */
7087 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
7089 if (DECL_HAS_VTT_PARM_P (fn
))
7091 argarray
[j
++] = (*args
)[arg_index
];
7093 parm
= TREE_CHAIN (parm
);
7096 /* Bypass access control for 'this' parameter. */
7097 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7099 tree parmtype
= TREE_VALUE (parm
);
7100 tree arg
= build_this (first_arg
!= NULL_TREE
7102 : (*args
)[arg_index
]);
7103 tree argtype
= TREE_TYPE (arg
);
7107 if (convs
[i
]->bad_p
)
7109 if (complain
& tf_error
)
7111 if (permerror (input_location
, "passing %qT as %<this%> "
7112 "argument discards qualifiers",
7113 TREE_TYPE (argtype
)))
7114 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
7117 return error_mark_node
;
7120 /* See if the function member or the whole class type is declared
7121 final and the call can be devirtualized. */
7122 if (DECL_FINAL_P (fn
)
7123 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
7124 flags
|= LOOKUP_NONVIRTUAL
;
7126 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
7127 X is called for an object that is not of type X, or of a type
7128 derived from X, the behavior is undefined.
7130 So we can assume that anything passed as 'this' is non-null, and
7131 optimize accordingly. */
7132 gcc_assert (TYPE_PTR_P (parmtype
));
7133 /* Convert to the base in which the function was declared. */
7134 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
7135 converted_arg
= build_base_path (PLUS_EXPR
,
7137 cand
->conversion_path
,
7139 /* Check that the base class is accessible. */
7140 if (!accessible_base_p (TREE_TYPE (argtype
),
7141 BINFO_TYPE (cand
->conversion_path
), true))
7143 if (complain
& tf_error
)
7144 error ("%qT is not an accessible base of %qT",
7145 BINFO_TYPE (cand
->conversion_path
),
7146 TREE_TYPE (argtype
));
7148 return error_mark_node
;
7150 /* If fn was found by a using declaration, the conversion path
7151 will be to the derived class, not the base declaring fn. We
7152 must convert from derived to base. */
7153 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
7154 TREE_TYPE (parmtype
), ba_unique
,
7156 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
7157 base_binfo
, 1, complain
);
7159 argarray
[j
++] = converted_arg
;
7160 parm
= TREE_CHAIN (parm
);
7161 if (first_arg
!= NULL_TREE
)
7162 first_arg
= NULL_TREE
;
7169 gcc_assert (first_arg
== NULL_TREE
);
7170 for (; arg_index
< vec_safe_length (args
) && parm
;
7171 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
7173 tree type
= TREE_VALUE (parm
);
7174 tree arg
= (*args
)[arg_index
];
7175 bool conversion_warning
= true;
7179 /* If the argument is NULL and used to (implicitly) instantiate a
7180 template function (and bind one of the template arguments to
7181 the type of 'long int'), we don't want to warn about passing NULL
7182 to non-pointer argument.
7183 For example, if we have this template function:
7185 template<typename T> void func(T x) {}
7187 we want to warn (when -Wconversion is enabled) in this case:
7193 but not in this case:
7199 if (arg
== null_node
7200 && DECL_TEMPLATE_INFO (fn
)
7201 && cand
->template_decl
7202 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
7203 conversion_warning
= false;
7205 /* Warn about initializer_list deduction that isn't currently in the
7207 if (cxx_dialect
> cxx98
7208 && flag_deduce_init_list
7209 && cand
->template_decl
7210 && is_std_init_list (non_reference (type
))
7211 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
7213 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
7214 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
7215 tree patparm
= get_pattern_parm (realparm
, tmpl
);
7216 tree pattype
= TREE_TYPE (patparm
);
7217 if (PACK_EXPANSION_P (pattype
))
7218 pattype
= PACK_EXPANSION_PATTERN (pattype
);
7219 pattype
= non_reference (pattype
);
7221 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
7222 && (cand
->explicit_targs
== NULL_TREE
7223 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
7224 <= TEMPLATE_TYPE_IDX (pattype
))))
7226 pedwarn (input_location
, 0, "deducing %qT as %qT",
7227 non_reference (TREE_TYPE (patparm
)),
7228 non_reference (type
));
7229 pedwarn (input_location
, 0, " in call to %q+D", cand
->fn
);
7230 pedwarn (input_location
, 0,
7231 " (you can disable this with -fno-deduce-init-list)");
7234 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
7237 : complain
& (~tf_warning
));
7239 val
= convert_for_arg_passing (type
, val
, complain
);
7241 if (val
== error_mark_node
)
7242 return error_mark_node
;
7244 argarray
[j
++] = val
;
7247 /* Default arguments */
7248 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
7250 if (TREE_VALUE (parm
) == error_mark_node
)
7251 return error_mark_node
;
7252 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
7253 TREE_PURPOSE (parm
),
7259 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
7261 tree a
= (*args
)[arg_index
];
7262 if (magic_varargs_p (fn
))
7263 /* Do no conversions for magic varargs. */
7264 a
= mark_type_use (a
);
7265 else if (DECL_CONSTRUCTOR_P (fn
)
7266 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
7269 /* Avoid infinite recursion trying to call A(...). */
7270 if (complain
& tf_error
)
7271 /* Try to call the actual copy constructor for a good error. */
7272 call_copy_ctor (a
, complain
);
7273 return error_mark_node
;
7276 a
= convert_arg_to_ellipsis (a
, complain
);
7280 gcc_assert (j
<= nargs
);
7283 check_function_arguments (TREE_TYPE (fn
), nargs
, argarray
);
7285 /* Avoid actually calling copy constructors and copy assignment operators,
7288 if (! flag_elide_constructors
)
7289 /* Do things the hard way. */;
7290 else if (cand
->num_convs
== 1
7291 && (DECL_COPY_CONSTRUCTOR_P (fn
)
7292 || DECL_MOVE_CONSTRUCTOR_P (fn
))
7293 /* It's unsafe to elide the constructor when handling
7294 a noexcept-expression, it may evaluate to the wrong
7295 value (c++/53025). */
7296 && cp_noexcept_operand
== 0)
7299 tree arg
= argarray
[num_artificial_parms_for (fn
)];
7301 bool trivial
= trivial_fn_p (fn
);
7303 /* Pull out the real argument, disregarding const-correctness. */
7305 while (CONVERT_EXPR_P (targ
)
7306 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
7307 targ
= TREE_OPERAND (targ
, 0);
7308 if (TREE_CODE (targ
) == ADDR_EXPR
)
7310 targ
= TREE_OPERAND (targ
, 0);
7311 if (!same_type_ignoring_top_level_qualifiers_p
7312 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
7321 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7323 /* [class.copy]: the copy constructor is implicitly defined even if
7324 the implementation elided its use. */
7325 if (!trivial
|| DECL_DELETED_FN (fn
))
7328 already_used
= true;
7331 /* If we're creating a temp and we already have one, don't create a
7332 new one. If we're not creating a temp but we get one, use
7333 INIT_EXPR to collapse the temp into our target. Otherwise, if the
7334 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
7335 temp or an INIT_EXPR otherwise. */
7337 if (is_dummy_object (fa
))
7339 if (TREE_CODE (arg
) == TARGET_EXPR
)
7342 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
7344 else if (TREE_CODE (arg
) == TARGET_EXPR
|| trivial
)
7346 tree to
= stabilize_reference (cp_build_indirect_ref (fa
, RO_NULL
,
7349 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
7353 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
7354 && trivial_fn_p (fn
)
7355 && !DECL_DELETED_FN (fn
))
7357 tree to
= stabilize_reference
7358 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
7359 tree type
= TREE_TYPE (to
);
7360 tree as_base
= CLASSTYPE_AS_BASE (type
);
7361 tree arg
= argarray
[1];
7363 if (is_really_empty_class (type
))
7365 /* Avoid copying empty classes. */
7366 val
= build2 (COMPOUND_EXPR
, void_type_node
, to
, arg
);
7367 TREE_NO_WARNING (val
) = 1;
7368 val
= build2 (COMPOUND_EXPR
, type
, val
, to
);
7369 TREE_NO_WARNING (val
) = 1;
7371 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
7373 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7374 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
7378 /* We must only copy the non-tail padding parts. */
7380 tree array_type
, alias_set
;
7382 arg2
= TYPE_SIZE_UNIT (as_base
);
7383 arg0
= cp_build_addr_expr (to
, complain
);
7385 array_type
= build_array_type (char_type_node
,
7387 (size_binop (MINUS_EXPR
,
7388 arg2
, size_int (1))));
7389 alias_set
= build_int_cst (build_pointer_type (type
), 0);
7390 t
= build2 (MODIFY_EXPR
, void_type_node
,
7391 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
7392 build2 (MEM_REF
, array_type
, arg
, alias_set
));
7393 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
7394 TREE_NO_WARNING (val
) = 1;
7399 else if (DECL_DESTRUCTOR_P (fn
)
7400 && trivial_fn_p (fn
)
7401 && !DECL_DELETED_FN (fn
))
7402 return fold_convert (void_type_node
, argarray
[0]);
7403 /* FIXME handle trivial default constructor, too. */
7405 /* For calls to a multi-versioned function, overload resolution
7406 returns the function with the highest target priority, that is,
7407 the version that will checked for dispatching first. If this
7408 version is inlinable, a direct call to this version can be made
7409 otherwise the call should go through the dispatcher. */
7411 if (DECL_FUNCTION_VERSIONED (fn
)
7412 && (current_function_decl
== NULL
7413 || !targetm
.target_option
.can_inline_p (current_function_decl
, fn
)))
7415 fn
= get_function_version_dispatcher (fn
);
7419 mark_versions_used (fn
);
7424 return error_mark_node
;
7426 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
7427 /* Don't mess with virtual lookup in fold_non_dependent_expr; virtual
7428 functions can't be constexpr. */
7429 && !in_template_function ())
7432 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
7434 ba_any
, NULL
, complain
);
7435 gcc_assert (binfo
&& binfo
!= error_mark_node
);
7437 /* Warn about deprecated virtual functions now, since we're about
7438 to throw away the decl. */
7439 if (TREE_DEPRECATED (fn
))
7440 warn_deprecated_use (fn
, NULL_TREE
);
7442 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
7444 if (TREE_SIDE_EFFECTS (argarray
[0]))
7445 argarray
[0] = save_expr (argarray
[0]);
7446 t
= build_pointer_type (TREE_TYPE (fn
));
7447 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
7448 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
7450 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
7455 fn
= build_addr_func (fn
, complain
);
7456 if (fn
== error_mark_node
)
7457 return error_mark_node
;
7460 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
7461 if (TREE_CODE (call
) == CALL_EXPR
7462 && (cand
->flags
& LOOKUP_LIST_INIT_CTOR
))
7463 CALL_EXPR_LIST_INIT_P (call
) = true;
7467 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7468 This function performs no overload resolution, conversion, or other
7469 high-level operations. */
7472 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
7473 tsubst_flags_t complain
)
7478 /* Remember roughly where this call is. */
7479 location_t loc
= EXPR_LOC_OR_LOC (fn
, input_location
);
7480 fn
= build_call_a (fn
, nargs
, argarray
);
7481 SET_EXPR_LOCATION (fn
, loc
);
7483 fndecl
= get_callee_fndecl (fn
);
7485 /* Check that arguments to builtin functions match the expectations. */
7487 && DECL_BUILT_IN (fndecl
)
7488 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7489 && !check_builtin_function_arguments (fndecl
, nargs
, argarray
))
7490 return error_mark_node
;
7492 /* If it is a built-in array notation function, then the return type of
7493 the function is the element type of the array passed in as array
7494 notation (i.e. the first parameter of the function). */
7495 if (flag_cilkplus
&& TREE_CODE (fn
) == CALL_EXPR
)
7497 enum built_in_function bif
=
7498 is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn
));
7499 if (bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
7500 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
7501 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
7502 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
7503 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE
7504 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
7506 if (call_expr_nargs (fn
) == 0)
7508 error_at (EXPR_LOCATION (fn
), "Invalid builtin arguments");
7509 return error_mark_node
;
7511 /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or
7512 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or
7513 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or
7514 BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or
7515 BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or
7516 BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
7517 The pre-defined return-type is the correct one. */
7518 tree array_ntn
= CALL_EXPR_ARG (fn
, 0);
7519 TREE_TYPE (fn
) = TREE_TYPE (array_ntn
);
7524 /* Some built-in function calls will be evaluated at compile-time in
7525 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7526 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7527 optimize_sav
= optimize
;
7528 if (!optimize
&& fndecl
&& DECL_IS_BUILTIN_CONSTANT_P (fndecl
)
7529 && current_function_decl
7530 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
7532 fn
= fold_if_not_in_template (fn
);
7533 optimize
= optimize_sav
;
7535 if (VOID_TYPE_P (TREE_TYPE (fn
)))
7538 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7539 function call is either the operand of a decltype-specifier or the
7540 right operand of a comma operator that is the operand of a
7541 decltype-specifier, a temporary object is not introduced for the
7542 prvalue. The type of the prvalue may be incomplete. */
7543 if (!(complain
& tf_decltype
))
7545 fn
= require_complete_type_sfinae (fn
, complain
);
7546 if (fn
== error_mark_node
)
7547 return error_mark_node
;
7549 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
7550 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
7552 return convert_from_reference (fn
);
7555 static GTY(()) tree java_iface_lookup_fn
;
7557 /* Make an expression which yields the address of the Java interface
7558 method FN. This is achieved by generating a call to libjava's
7559 _Jv_LookupInterfaceMethodIdx(). */
7562 build_java_interface_fn_ref (tree fn
, tree instance
)
7564 tree lookup_fn
, method
, idx
;
7565 tree klass_ref
, iface
, iface_ref
;
7568 if (!java_iface_lookup_fn
)
7570 tree ftype
= build_function_type_list (ptr_type_node
,
7571 ptr_type_node
, ptr_type_node
,
7572 java_int_type_node
, NULL_TREE
);
7573 java_iface_lookup_fn
7574 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype
,
7575 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
7578 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7579 This is the first entry in the vtable. */
7580 klass_ref
= build_vtbl_ref (cp_build_indirect_ref (instance
, RO_NULL
,
7581 tf_warning_or_error
),
7584 /* Get the java.lang.Class pointer for the interface being called. */
7585 iface
= DECL_CONTEXT (fn
);
7586 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
7587 if (!iface_ref
|| !VAR_P (iface_ref
)
7588 || DECL_CONTEXT (iface_ref
) != iface
)
7590 error ("could not find class$ field in java interface type %qT",
7592 return error_mark_node
;
7594 iface_ref
= build_address (iface_ref
);
7595 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
7597 /* Determine the itable index of FN. */
7599 for (method
= TYPE_METHODS (iface
); method
; method
= DECL_CHAIN (method
))
7601 if (!DECL_VIRTUAL_P (method
))
7607 idx
= build_int_cst (NULL_TREE
, i
);
7609 lookup_fn
= build1 (ADDR_EXPR
,
7610 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
7611 java_iface_lookup_fn
);
7612 return build_call_nary (ptr_type_node
, lookup_fn
,
7613 3, klass_ref
, iface_ref
, idx
);
7616 /* Returns the value to use for the in-charge parameter when making a
7617 call to a function with the indicated NAME.
7619 FIXME:Can't we find a neater way to do this mapping? */
7622 in_charge_arg_for_name (tree name
)
7624 if (name
== base_ctor_identifier
7625 || name
== base_dtor_identifier
)
7626 return integer_zero_node
;
7627 else if (name
== complete_ctor_identifier
)
7628 return integer_one_node
;
7629 else if (name
== complete_dtor_identifier
)
7630 return integer_two_node
;
7631 else if (name
== deleting_dtor_identifier
)
7632 return integer_three_node
;
7634 /* This function should only be called with one of the names listed
7640 /* Build a call to a constructor, destructor, or an assignment
7641 operator for INSTANCE, an expression with class type. NAME
7642 indicates the special member function to call; *ARGS are the
7643 arguments. ARGS may be NULL. This may change ARGS. BINFO
7644 indicates the base of INSTANCE that is to be passed as the `this'
7645 parameter to the member function called.
7647 FLAGS are the LOOKUP_* flags to use when processing the call.
7649 If NAME indicates a complete object constructor, INSTANCE may be
7650 NULL_TREE. In this case, the caller will call build_cplus_new to
7651 store the newly constructed object into a VAR_DECL. */
7654 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
7655 tree binfo
, int flags
, tsubst_flags_t complain
)
7658 /* The type of the subobject to be constructed or destroyed. */
7660 vec
<tree
, va_gc
> *allocated
= NULL
;
7663 gcc_assert (name
== complete_ctor_identifier
7664 || name
== base_ctor_identifier
7665 || name
== complete_dtor_identifier
7666 || name
== base_dtor_identifier
7667 || name
== deleting_dtor_identifier
7668 || name
== ansi_assopname (NOP_EXPR
));
7671 /* Resolve the name. */
7672 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
7673 return error_mark_node
;
7675 binfo
= TYPE_BINFO (binfo
);
7678 gcc_assert (binfo
!= NULL_TREE
);
7680 class_type
= BINFO_TYPE (binfo
);
7682 /* Handle the special case where INSTANCE is NULL_TREE. */
7683 if (name
== complete_ctor_identifier
&& !instance
)
7684 instance
= build_dummy_object (class_type
);
7687 if (name
== complete_dtor_identifier
7688 || name
== base_dtor_identifier
7689 || name
== deleting_dtor_identifier
)
7690 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
7692 /* Convert to the base class, if necessary. */
7693 if (!same_type_ignoring_top_level_qualifiers_p
7694 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
7696 if (name
!= ansi_assopname (NOP_EXPR
))
7697 /* For constructors and destructors, either the base is
7698 non-virtual, or it is virtual but we are doing the
7699 conversion from a constructor or destructor for the
7700 complete object. In either case, we can convert
7702 instance
= convert_to_base_statically (instance
, binfo
);
7704 /* However, for assignment operators, we must convert
7705 dynamically if the base is virtual. */
7706 instance
= build_base_path (PLUS_EXPR
, instance
,
7707 binfo
, /*nonnull=*/1, complain
);
7711 gcc_assert (instance
!= NULL_TREE
);
7713 fns
= lookup_fnfields (binfo
, name
, 1);
7715 /* When making a call to a constructor or destructor for a subobject
7716 that uses virtual base classes, pass down a pointer to a VTT for
7718 if ((name
== base_ctor_identifier
7719 || name
== base_dtor_identifier
)
7720 && CLASSTYPE_VBASECLASSES (class_type
))
7725 /* If the current function is a complete object constructor
7726 or destructor, then we fetch the VTT directly.
7727 Otherwise, we look it up using the VTT we were given. */
7728 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
7729 vtt
= decay_conversion (vtt
, complain
);
7730 if (vtt
== error_mark_node
)
7731 return error_mark_node
;
7732 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
7733 build2 (EQ_EXPR
, boolean_type_node
,
7734 current_in_charge_parm
, integer_zero_node
),
7737 if (BINFO_SUBVTT_INDEX (binfo
))
7738 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
7744 allocated
= make_tree_vector ();
7748 vec_safe_insert (*args
, 0, sub_vtt
);
7751 ret
= build_new_method_call (instance
, fns
, args
,
7752 TYPE_BINFO (BINFO_TYPE (binfo
)),
7756 if (allocated
!= NULL
)
7757 release_tree_vector (allocated
);
7759 if ((complain
& tf_error
)
7760 && (flags
& LOOKUP_DELEGATING_CONS
)
7761 && name
== complete_ctor_identifier
7762 && TREE_CODE (ret
) == CALL_EXPR
7763 && (DECL_ABSTRACT_ORIGIN (TREE_OPERAND (CALL_EXPR_FN (ret
), 0))
7764 == current_function_decl
))
7765 error ("constructor delegates to itself");
7770 /* Return the NAME, as a C string. The NAME indicates a function that
7771 is a member of TYPE. *FREE_P is set to true if the caller must
7772 free the memory returned.
7774 Rather than go through all of this, we should simply set the names
7775 of constructors and destructors appropriately, and dispense with
7776 ctor_identifier, dtor_identifier, etc. */
7779 name_as_c_string (tree name
, tree type
, bool *free_p
)
7783 /* Assume that we will not allocate memory. */
7785 /* Constructors and destructors are special. */
7786 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7789 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
7790 /* For a destructor, add the '~'. */
7791 if (name
== complete_dtor_identifier
7792 || name
== base_dtor_identifier
7793 || name
== deleting_dtor_identifier
)
7795 pretty_name
= concat ("~", pretty_name
, NULL
);
7796 /* Remember that we need to free the memory allocated. */
7800 else if (IDENTIFIER_TYPENAME_P (name
))
7802 pretty_name
= concat ("operator ",
7803 type_as_string_translate (TREE_TYPE (name
),
7804 TFF_PLAIN_IDENTIFIER
),
7806 /* Remember that we need to free the memory allocated. */
7810 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
7815 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
7816 be set, upon return, to the function called. ARGS may be NULL.
7817 This may change ARGS. */
7820 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
7821 tree conversion_path
, int flags
,
7822 tree
*fn_p
, tsubst_flags_t complain
)
7824 struct z_candidate
*candidates
= 0, *cand
;
7825 tree explicit_targs
= NULL_TREE
;
7826 tree basetype
= NULL_TREE
;
7827 tree access_binfo
, binfo
;
7829 tree first_mem_arg
= NULL_TREE
;
7831 bool skip_first_for_error
;
7832 vec
<tree
, va_gc
> *user_args
;
7835 int template_only
= 0;
7839 vec
<tree
, va_gc
> *orig_args
= NULL
;
7842 gcc_assert (instance
!= NULL_TREE
);
7844 /* We don't know what function we're going to call, yet. */
7848 if (error_operand_p (instance
)
7849 || !fns
|| error_operand_p (fns
))
7850 return error_mark_node
;
7852 if (!BASELINK_P (fns
))
7854 if (complain
& tf_error
)
7855 error ("call to non-function %qD", fns
);
7856 return error_mark_node
;
7859 orig_instance
= instance
;
7862 /* Dismantle the baselink to collect all the information we need. */
7863 if (!conversion_path
)
7864 conversion_path
= BASELINK_BINFO (fns
);
7865 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
7866 binfo
= BASELINK_BINFO (fns
);
7867 optype
= BASELINK_OPTYPE (fns
);
7868 fns
= BASELINK_FUNCTIONS (fns
);
7869 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
7871 explicit_targs
= TREE_OPERAND (fns
, 1);
7872 fns
= TREE_OPERAND (fns
, 0);
7875 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
7876 || TREE_CODE (fns
) == TEMPLATE_DECL
7877 || TREE_CODE (fns
) == OVERLOAD
);
7878 fn
= get_first_fn (fns
);
7879 name
= DECL_NAME (fn
);
7881 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
7882 gcc_assert (CLASS_TYPE_P (basetype
));
7884 if (processing_template_decl
)
7886 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
7887 instance
= build_non_dependent_expr (instance
);
7889 make_args_non_dependent (*args
);
7892 user_args
= args
== NULL
? NULL
: *args
;
7893 /* Under DR 147 A::A() is an invalid constructor call,
7894 not a functional cast. */
7895 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
7897 if (! (complain
& tf_error
))
7898 return error_mark_node
;
7900 if (permerror (input_location
,
7901 "cannot call constructor %<%T::%D%> directly",
7903 inform (input_location
, "for a function-style cast, remove the "
7904 "redundant %<::%D%>", name
);
7905 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
7910 /* Figure out whether to skip the first argument for the error
7911 message we will display to users if an error occurs. We don't
7912 want to display any compiler-generated arguments. The "this"
7913 pointer hasn't been added yet. However, we must remove the VTT
7914 pointer if this is a call to a base-class constructor or
7916 skip_first_for_error
= false;
7917 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7919 /* Callers should explicitly indicate whether they want to construct
7920 the complete object or just the part without virtual bases. */
7921 gcc_assert (name
!= ctor_identifier
);
7922 /* Similarly for destructors. */
7923 gcc_assert (name
!= dtor_identifier
);
7924 /* Remove the VTT pointer, if present. */
7925 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
7926 && CLASSTYPE_VBASECLASSES (basetype
))
7927 skip_first_for_error
= true;
7930 /* Process the argument list. */
7931 if (args
!= NULL
&& *args
!= NULL
)
7933 *args
= resolve_args (*args
, complain
);
7935 return error_mark_node
;
7938 /* Consider the object argument to be used even if we end up selecting a
7939 static member function. */
7940 instance
= mark_type_use (instance
);
7942 /* It's OK to call destructors and constructors on cv-qualified objects.
7943 Therefore, convert the INSTANCE to the unqualified type, if
7945 if (DECL_DESTRUCTOR_P (fn
)
7946 || DECL_CONSTRUCTOR_P (fn
))
7948 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
7950 instance
= build_this (instance
);
7951 instance
= build_nop (build_pointer_type (basetype
), instance
);
7952 instance
= build_fold_indirect_ref (instance
);
7955 if (DECL_DESTRUCTOR_P (fn
))
7956 name
= complete_dtor_identifier
;
7958 /* For the overload resolution we need to find the actual `this`
7959 that would be captured if the call turns out to be to a
7960 non-static member function. Do not actually capture it at this
7962 first_mem_arg
= maybe_resolve_dummy (instance
, false);
7964 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7965 p
= conversion_obstack_alloc (0);
7967 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
7968 initializer, not T({ }). */
7969 if (DECL_CONSTRUCTOR_P (fn
) && args
!= NULL
&& !vec_safe_is_empty (*args
)
7970 && DIRECT_LIST_INIT_P ((**args
)[0]))
7972 tree init_list
= (**args
)[0];
7973 tree init
= NULL_TREE
;
7975 gcc_assert ((*args
)->length () == 1
7976 && !(flags
& LOOKUP_ONLYCONVERTING
));
7978 /* If the initializer list has no elements and T is a class type with
7979 a default constructor, the object is value-initialized. Handle
7980 this here so we don't need to handle it wherever we use
7981 build_special_member_call. */
7982 if (CONSTRUCTOR_NELTS (init_list
) == 0
7983 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
7984 /* For a user-provided default constructor, use the normal
7985 mechanisms so that protected access works. */
7986 && type_has_non_user_provided_default_constructor (basetype
)
7987 && !processing_template_decl
)
7988 init
= build_value_init (basetype
, complain
);
7990 /* If BASETYPE is an aggregate, we need to do aggregate
7992 else if (CP_AGGREGATE_TYPE_P (basetype
))
7993 init
= digest_init (basetype
, init_list
, complain
);
7997 if (is_dummy_object (instance
))
7998 return get_target_expr_sfinae (init
, complain
);
7999 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
8000 TREE_SIDE_EFFECTS (init
) = true;
8004 /* Otherwise go ahead with overload resolution. */
8005 add_list_candidates (fns
, first_mem_arg
, init_list
,
8006 basetype
, explicit_targs
, template_only
,
8007 conversion_path
, access_binfo
, flags
,
8008 &candidates
, complain
);
8012 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
8013 explicit_targs
, template_only
, conversion_path
,
8014 access_binfo
, flags
, &candidates
, complain
);
8016 any_viable_p
= false;
8017 candidates
= splice_viable (candidates
, false, &any_viable_p
);
8021 if (complain
& tf_error
)
8023 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
8024 cxx_incomplete_type_error (instance
, basetype
);
8026 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
8027 basetype
, optype
, build_tree_list_vec (user_args
),
8028 TREE_TYPE (instance
));
8035 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8036 arglist
= build_tree_list_vec (user_args
);
8037 if (skip_first_for_error
)
8038 arglist
= TREE_CHAIN (arglist
);
8039 error ("no matching function for call to %<%T::%s(%A)%#V%>",
8040 basetype
, pretty_name
, arglist
,
8041 TREE_TYPE (instance
));
8045 print_z_candidates (location_of (name
), candidates
);
8047 call
= error_mark_node
;
8051 cand
= tourney (candidates
, complain
);
8058 if (complain
& tf_error
)
8060 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8061 arglist
= build_tree_list_vec (user_args
);
8062 if (skip_first_for_error
)
8063 arglist
= TREE_CHAIN (arglist
);
8064 if (!any_strictly_viable (candidates
))
8065 error ("no matching function for call to %<%s(%A)%>",
8066 pretty_name
, arglist
);
8068 error ("call of overloaded %<%s(%A)%> is ambiguous",
8069 pretty_name
, arglist
);
8070 print_z_candidates (location_of (name
), candidates
);
8074 call
= error_mark_node
;
8081 if (!(flags
& LOOKUP_NONVIRTUAL
)
8082 && DECL_PURE_VIRTUAL_P (fn
)
8083 && instance
== current_class_ref
8084 && (complain
& tf_warning
))
8086 /* This is not an error, it is runtime undefined
8088 if (!current_function_decl
)
8089 warning (0, "pure virtual %q#D called from "
8090 "non-static data member initializer", fn
);
8091 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
8092 || DECL_DESTRUCTOR_P (current_function_decl
))
8093 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
8094 ? "pure virtual %q#D called from constructor"
8095 : "pure virtual %q#D called from destructor"),
8099 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
8100 && !DECL_CONSTRUCTOR_P (fn
)
8101 && is_dummy_object (instance
))
8103 instance
= maybe_resolve_dummy (instance
, true);
8104 if (instance
== error_mark_node
)
8105 call
= error_mark_node
;
8106 else if (!is_dummy_object (instance
))
8108 /* We captured 'this' in the current lambda now that
8109 we know we really need it. */
8110 cand
->first_arg
= instance
;
8114 if (complain
& tf_error
)
8115 error ("cannot call member function %qD without object",
8117 call
= error_mark_node
;
8121 if (call
!= error_mark_node
)
8123 /* Optimize away vtable lookup if we know that this
8124 function can't be overridden. We need to check if
8125 the context and the type where we found fn are the same,
8126 actually FN might be defined in a different class
8127 type because of a using-declaration. In this case, we
8128 do not want to perform a non-virtual call. */
8129 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
8130 && same_type_ignoring_top_level_qualifiers_p
8131 (DECL_CONTEXT (fn
), BINFO_TYPE (binfo
))
8132 && resolves_to_fixed_type_p (instance
, 0))
8133 flags
|= LOOKUP_NONVIRTUAL
;
8135 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
8136 /* Now we know what function is being called. */
8139 /* Build the actual CALL_EXPR. */
8140 call
= build_over_call (cand
, flags
, complain
);
8141 /* In an expression of the form `a->f()' where `f' turns
8142 out to be a static member function, `a' is
8143 none-the-less evaluated. */
8144 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
8145 && !is_dummy_object (instance
)
8146 && TREE_SIDE_EFFECTS (instance
))
8147 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
8149 else if (call
!= error_mark_node
8150 && DECL_DESTRUCTOR_P (cand
->fn
)
8151 && !VOID_TYPE_P (TREE_TYPE (call
)))
8152 /* An explicit call of the form "x->~X()" has type
8153 "void". However, on platforms where destructors
8154 return "this" (i.e., those where
8155 targetm.cxx.cdtor_returns_this is true), such calls
8156 will appear to have a return value of pointer type
8157 to the low-level call machinery. We do not want to
8158 change the low-level machinery, since we want to be
8159 able to optimize "delete f()" on such platforms as
8160 "operator delete(~X(f()))" (rather than generating
8161 "t = f(), ~X(t), operator delete (t)"). */
8162 call
= build_nop (void_type_node
, call
);
8167 if (processing_template_decl
&& call
!= error_mark_node
)
8169 bool cast_to_void
= false;
8171 if (TREE_CODE (call
) == COMPOUND_EXPR
)
8172 call
= TREE_OPERAND (call
, 1);
8173 else if (TREE_CODE (call
) == NOP_EXPR
)
8175 cast_to_void
= true;
8176 call
= TREE_OPERAND (call
, 0);
8178 if (INDIRECT_REF_P (call
))
8179 call
= TREE_OPERAND (call
, 0);
8180 call
= (build_min_non_dep_call_vec
8182 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
8183 orig_instance
, orig_fns
, NULL_TREE
),
8185 SET_EXPR_LOCATION (call
, input_location
);
8186 call
= convert_from_reference (call
);
8188 call
= build_nop (void_type_node
, call
);
8191 /* Free all the conversions we allocated. */
8192 obstack_free (&conversion_obstack
, p
);
8194 if (orig_args
!= NULL
)
8195 release_tree_vector (orig_args
);
8200 /* Wrapper for above. */
8203 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8204 tree conversion_path
, int flags
,
8205 tree
*fn_p
, tsubst_flags_t complain
)
8208 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
8209 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
8211 timevar_cond_stop (TV_OVERLOAD
, subtime
);
8215 /* Returns true iff standard conversion sequence ICS1 is a proper
8216 subsequence of ICS2. */
8219 is_subseq (conversion
*ics1
, conversion
*ics2
)
8221 /* We can assume that a conversion of the same code
8222 between the same types indicates a subsequence since we only get
8223 here if the types we are converting from are the same. */
8225 while (ics1
->kind
== ck_rvalue
8226 || ics1
->kind
== ck_lvalue
)
8227 ics1
= next_conversion (ics1
);
8231 while (ics2
->kind
== ck_rvalue
8232 || ics2
->kind
== ck_lvalue
)
8233 ics2
= next_conversion (ics2
);
8235 if (ics2
->kind
== ck_user
8236 || ics2
->kind
== ck_ambig
8237 || ics2
->kind
== ck_aggr
8238 || ics2
->kind
== ck_list
8239 || ics2
->kind
== ck_identity
)
8240 /* At this point, ICS1 cannot be a proper subsequence of
8241 ICS2. We can get a USER_CONV when we are comparing the
8242 second standard conversion sequence of two user conversion
8246 ics2
= next_conversion (ics2
);
8248 if (ics2
->kind
== ics1
->kind
8249 && same_type_p (ics2
->type
, ics1
->type
)
8250 && same_type_p (next_conversion (ics2
)->type
,
8251 next_conversion (ics1
)->type
))
8256 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
8257 be any _TYPE nodes. */
8260 is_properly_derived_from (tree derived
, tree base
)
8262 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
8265 /* We only allow proper derivation here. The DERIVED_FROM_P macro
8266 considers every class derived from itself. */
8267 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
8268 && DERIVED_FROM_P (base
, derived
));
8271 /* We build the ICS for an implicit object parameter as a pointer
8272 conversion sequence. However, such a sequence should be compared
8273 as if it were a reference conversion sequence. If ICS is the
8274 implicit conversion sequence for an implicit object parameter,
8275 modify it accordingly. */
8278 maybe_handle_implicit_object (conversion
**ics
)
8282 /* [over.match.funcs]
8284 For non-static member functions, the type of the
8285 implicit object parameter is "reference to cv X"
8286 where X is the class of which the function is a
8287 member and cv is the cv-qualification on the member
8288 function declaration. */
8289 conversion
*t
= *ics
;
8290 tree reference_type
;
8292 /* The `this' parameter is a pointer to a class type. Make the
8293 implicit conversion talk about a reference to that same class
8295 reference_type
= TREE_TYPE (t
->type
);
8296 reference_type
= build_reference_type (reference_type
);
8298 if (t
->kind
== ck_qual
)
8299 t
= next_conversion (t
);
8300 if (t
->kind
== ck_ptr
)
8301 t
= next_conversion (t
);
8302 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
8303 t
= direct_reference_binding (reference_type
, t
);
8305 t
->rvaluedness_matches_p
= 0;
8310 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
8311 and return the initial reference binding conversion. Otherwise,
8312 leave *ICS unchanged and return NULL. */
8315 maybe_handle_ref_bind (conversion
**ics
)
8317 if ((*ics
)->kind
== ck_ref_bind
)
8319 conversion
*old_ics
= *ics
;
8320 *ics
= next_conversion (old_ics
);
8321 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
8328 /* Compare two implicit conversion sequences according to the rules set out in
8329 [over.ics.rank]. Return values:
8331 1: ics1 is better than ics2
8332 -1: ics2 is better than ics1
8333 0: ics1 and ics2 are indistinguishable */
8336 compare_ics (conversion
*ics1
, conversion
*ics2
)
8342 tree deref_from_type1
= NULL_TREE
;
8343 tree deref_from_type2
= NULL_TREE
;
8344 tree deref_to_type1
= NULL_TREE
;
8345 tree deref_to_type2
= NULL_TREE
;
8346 conversion_rank rank1
, rank2
;
8348 /* REF_BINDING is nonzero if the result of the conversion sequence
8349 is a reference type. In that case REF_CONV is the reference
8350 binding conversion. */
8351 conversion
*ref_conv1
;
8352 conversion
*ref_conv2
;
8354 /* Compare badness before stripping the reference conversion. */
8355 if (ics1
->bad_p
> ics2
->bad_p
)
8357 else if (ics1
->bad_p
< ics2
->bad_p
)
8360 /* Handle implicit object parameters. */
8361 maybe_handle_implicit_object (&ics1
);
8362 maybe_handle_implicit_object (&ics2
);
8364 /* Handle reference parameters. */
8365 ref_conv1
= maybe_handle_ref_bind (&ics1
);
8366 ref_conv2
= maybe_handle_ref_bind (&ics2
);
8368 /* List-initialization sequence L1 is a better conversion sequence than
8369 list-initialization sequence L2 if L1 converts to
8370 std::initializer_list<X> for some X and L2 does not. */
8371 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
8373 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
8378 When comparing the basic forms of implicit conversion sequences (as
8379 defined in _over.best.ics_)
8381 --a standard conversion sequence (_over.ics.scs_) is a better
8382 conversion sequence than a user-defined conversion sequence
8383 or an ellipsis conversion sequence, and
8385 --a user-defined conversion sequence (_over.ics.user_) is a
8386 better conversion sequence than an ellipsis conversion sequence
8387 (_over.ics.ellipsis_). */
8388 /* Use BAD_CONVERSION_RANK because we already checked for a badness
8389 mismatch. If both ICS are bad, we try to make a decision based on
8390 what would have happened if they'd been good. This is not an
8391 extension, we'll still give an error when we build up the call; this
8392 just helps us give a more helpful error message. */
8393 rank1
= BAD_CONVERSION_RANK (ics1
);
8394 rank2
= BAD_CONVERSION_RANK (ics2
);
8398 else if (rank1
< rank2
)
8401 if (ics1
->ellipsis_p
)
8402 /* Both conversions are ellipsis conversions. */
8405 /* User-defined conversion sequence U1 is a better conversion sequence
8406 than another user-defined conversion sequence U2 if they contain the
8407 same user-defined conversion operator or constructor and if the sec-
8408 ond standard conversion sequence of U1 is better than the second
8409 standard conversion sequence of U2. */
8411 /* Handle list-conversion with the same code even though it isn't always
8412 ranked as a user-defined conversion and it doesn't have a second
8413 standard conversion sequence; it will still have the desired effect.
8414 Specifically, we need to do the reference binding comparison at the
8415 end of this function. */
8417 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
8422 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
8423 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
8424 || t1
->kind
== ck_list
)
8426 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
8427 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
8428 || t2
->kind
== ck_list
)
8431 if (t1
->kind
!= t2
->kind
)
8433 else if (t1
->kind
== ck_user
)
8435 if (t1
->cand
->fn
!= t2
->cand
->fn
)
8440 /* For ambiguous or aggregate conversions, use the target type as
8441 a proxy for the conversion function. */
8442 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
8446 /* We can just fall through here, after setting up
8447 FROM_TYPE1 and FROM_TYPE2. */
8448 from_type1
= t1
->type
;
8449 from_type2
= t2
->type
;
8456 /* We're dealing with two standard conversion sequences.
8460 Standard conversion sequence S1 is a better conversion
8461 sequence than standard conversion sequence S2 if
8463 --S1 is a proper subsequence of S2 (comparing the conversion
8464 sequences in the canonical form defined by _over.ics.scs_,
8465 excluding any Lvalue Transformation; the identity
8466 conversion sequence is considered to be a subsequence of
8467 any non-identity conversion sequence */
8470 while (t1
->kind
!= ck_identity
)
8471 t1
= next_conversion (t1
);
8472 from_type1
= t1
->type
;
8475 while (t2
->kind
!= ck_identity
)
8476 t2
= next_conversion (t2
);
8477 from_type2
= t2
->type
;
8480 /* One sequence can only be a subsequence of the other if they start with
8481 the same type. They can start with different types when comparing the
8482 second standard conversion sequence in two user-defined conversion
8484 if (same_type_p (from_type1
, from_type2
))
8486 if (is_subseq (ics1
, ics2
))
8488 if (is_subseq (ics2
, ics1
))
8496 --the rank of S1 is better than the rank of S2 (by the rules
8499 Standard conversion sequences are ordered by their ranks: an Exact
8500 Match is a better conversion than a Promotion, which is a better
8501 conversion than a Conversion.
8503 Two conversion sequences with the same rank are indistinguishable
8504 unless one of the following rules applies:
8506 --A conversion that does not a convert a pointer, pointer to member,
8507 or std::nullptr_t to bool is better than one that does.
8509 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8510 so that we do not have to check it explicitly. */
8511 if (ics1
->rank
< ics2
->rank
)
8513 else if (ics2
->rank
< ics1
->rank
)
8516 to_type1
= ics1
->type
;
8517 to_type2
= ics2
->type
;
8519 /* A conversion from scalar arithmetic type to complex is worse than a
8520 conversion between scalar arithmetic types. */
8521 if (same_type_p (from_type1
, from_type2
)
8522 && ARITHMETIC_TYPE_P (from_type1
)
8523 && ARITHMETIC_TYPE_P (to_type1
)
8524 && ARITHMETIC_TYPE_P (to_type2
)
8525 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8526 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
8528 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8534 if (TYPE_PTR_P (from_type1
)
8535 && TYPE_PTR_P (from_type2
)
8536 && TYPE_PTR_P (to_type1
)
8537 && TYPE_PTR_P (to_type2
))
8539 deref_from_type1
= TREE_TYPE (from_type1
);
8540 deref_from_type2
= TREE_TYPE (from_type2
);
8541 deref_to_type1
= TREE_TYPE (to_type1
);
8542 deref_to_type2
= TREE_TYPE (to_type2
);
8544 /* The rules for pointers to members A::* are just like the rules
8545 for pointers A*, except opposite: if B is derived from A then
8546 A::* converts to B::*, not vice versa. For that reason, we
8547 switch the from_ and to_ variables here. */
8548 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
8549 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
8550 || (TYPE_PTRMEMFUNC_P (from_type1
)
8551 && TYPE_PTRMEMFUNC_P (from_type2
)
8552 && TYPE_PTRMEMFUNC_P (to_type1
)
8553 && TYPE_PTRMEMFUNC_P (to_type2
)))
8555 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
8556 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
8557 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
8558 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
8561 if (deref_from_type1
!= NULL_TREE
8562 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
8563 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
8565 /* This was one of the pointer or pointer-like conversions.
8569 --If class B is derived directly or indirectly from class A,
8570 conversion of B* to A* is better than conversion of B* to
8571 void*, and conversion of A* to void* is better than
8572 conversion of B* to void*. */
8573 if (VOID_TYPE_P (deref_to_type1
)
8574 && VOID_TYPE_P (deref_to_type2
))
8576 if (is_properly_derived_from (deref_from_type1
,
8579 else if (is_properly_derived_from (deref_from_type2
,
8583 else if (VOID_TYPE_P (deref_to_type1
)
8584 || VOID_TYPE_P (deref_to_type2
))
8586 if (same_type_p (deref_from_type1
, deref_from_type2
))
8588 if (VOID_TYPE_P (deref_to_type2
))
8590 if (is_properly_derived_from (deref_from_type1
,
8594 /* We know that DEREF_TO_TYPE1 is `void' here. */
8595 else if (is_properly_derived_from (deref_from_type1
,
8600 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
8601 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
8605 --If class B is derived directly or indirectly from class A
8606 and class C is derived directly or indirectly from B,
8608 --conversion of C* to B* is better than conversion of C* to
8611 --conversion of B* to A* is better than conversion of C* to
8613 if (same_type_p (deref_from_type1
, deref_from_type2
))
8615 if (is_properly_derived_from (deref_to_type1
,
8618 else if (is_properly_derived_from (deref_to_type2
,
8622 else if (same_type_p (deref_to_type1
, deref_to_type2
))
8624 if (is_properly_derived_from (deref_from_type2
,
8627 else if (is_properly_derived_from (deref_from_type1
,
8633 else if (CLASS_TYPE_P (non_reference (from_type1
))
8634 && same_type_p (from_type1
, from_type2
))
8636 tree from
= non_reference (from_type1
);
8640 --binding of an expression of type C to a reference of type
8641 B& is better than binding an expression of type C to a
8642 reference of type A&
8644 --conversion of C to B is better than conversion of C to A, */
8645 if (is_properly_derived_from (from
, to_type1
)
8646 && is_properly_derived_from (from
, to_type2
))
8648 if (is_properly_derived_from (to_type1
, to_type2
))
8650 else if (is_properly_derived_from (to_type2
, to_type1
))
8654 else if (CLASS_TYPE_P (non_reference (to_type1
))
8655 && same_type_p (to_type1
, to_type2
))
8657 tree to
= non_reference (to_type1
);
8661 --binding of an expression of type B to a reference of type
8662 A& is better than binding an expression of type C to a
8663 reference of type A&,
8665 --conversion of B to A is better than conversion of C to A */
8666 if (is_properly_derived_from (from_type1
, to
)
8667 && is_properly_derived_from (from_type2
, to
))
8669 if (is_properly_derived_from (from_type2
, from_type1
))
8671 else if (is_properly_derived_from (from_type1
, from_type2
))
8678 --S1 and S2 differ only in their qualification conversion and yield
8679 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8680 qualification signature of type T1 is a proper subset of the cv-
8681 qualification signature of type T2 */
8682 if (ics1
->kind
== ck_qual
8683 && ics2
->kind
== ck_qual
8684 && same_type_p (from_type1
, from_type2
))
8686 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
8693 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8694 to an implicit object parameter of a non-static member function
8695 declared without a ref-qualifier, and either S1 binds an lvalue
8696 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
8697 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
8698 draft standard, 13.3.3.2)
8700 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8701 types to which the references refer are the same type except for
8702 top-level cv-qualifiers, and the type to which the reference
8703 initialized by S2 refers is more cv-qualified than the type to
8704 which the reference initialized by S1 refers.
8706 DR 1328 [over.match.best]: the context is an initialization by
8707 conversion function for direct reference binding (13.3.1.6) of a
8708 reference to function type, the return type of F1 is the same kind of
8709 reference (i.e. lvalue or rvalue) as the reference being initialized,
8710 and the return type of F2 is not. */
8712 if (ref_conv1
&& ref_conv2
)
8714 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
8715 && (ref_conv1
->rvaluedness_matches_p
8716 != ref_conv2
->rvaluedness_matches_p
)
8717 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
8718 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
8719 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
8721 if (ref_conv1
->bad_p
8722 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
8723 TREE_TYPE (ref_conv2
->type
)))
8724 /* Don't prefer a bad conversion that drops cv-quals to a bad
8725 conversion with the wrong rvalueness. */
8727 return (ref_conv1
->rvaluedness_matches_p
8728 - ref_conv2
->rvaluedness_matches_p
);
8731 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
8733 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
8734 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
8735 if (ref_conv1
->bad_p
)
8737 /* Prefer the one that drops fewer cv-quals. */
8738 tree ftype
= next_conversion (ref_conv1
)->type
;
8739 int fquals
= cp_type_quals (ftype
);
8743 return comp_cv_qualification (q2
, q1
);
8747 /* Neither conversion sequence is better than the other. */
8751 /* The source type for this standard conversion sequence. */
8754 source_type (conversion
*t
)
8756 for (;; t
= next_conversion (t
))
8758 if (t
->kind
== ck_user
8759 || t
->kind
== ck_ambig
8760 || t
->kind
== ck_identity
)
8766 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8767 a pointer to LOSER and re-running joust to produce the warning if WINNER
8768 is actually used. */
8771 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
8773 candidate_warning
*cw
= (candidate_warning
*)
8774 conversion_obstack_alloc (sizeof (candidate_warning
));
8776 cw
->next
= winner
->warnings
;
8777 winner
->warnings
= cw
;
8780 /* Compare two candidates for overloading as described in
8781 [over.match.best]. Return values:
8783 1: cand1 is better than cand2
8784 -1: cand2 is better than cand1
8785 0: cand1 and cand2 are indistinguishable */
8788 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
8789 tsubst_flags_t complain
)
8792 int off1
= 0, off2
= 0;
8796 /* Candidates that involve bad conversions are always worse than those
8798 if (cand1
->viable
> cand2
->viable
)
8800 if (cand1
->viable
< cand2
->viable
)
8803 /* If we have two pseudo-candidates for conversions to the same type,
8804 or two candidates for the same function, arbitrarily pick one. */
8805 if (cand1
->fn
== cand2
->fn
8806 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
8809 /* Prefer a non-deleted function over an implicitly deleted move
8810 constructor or assignment operator. This differs slightly from the
8811 wording for issue 1402 (which says the move op is ignored by overload
8812 resolution), but this way produces better error messages. */
8813 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
8814 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
8815 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
8817 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
8818 && move_fn_p (cand1
->fn
))
8820 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
8821 && move_fn_p (cand2
->fn
))
8825 /* a viable function F1
8826 is defined to be a better function than another viable function F2 if
8827 for all arguments i, ICSi(F1) is not a worse conversion sequence than
8828 ICSi(F2), and then */
8830 /* for some argument j, ICSj(F1) is a better conversion sequence than
8833 /* For comparing static and non-static member functions, we ignore
8834 the implicit object parameter of the non-static function. The
8835 standard says to pretend that the static function has an object
8836 parm, but that won't work with operator overloading. */
8837 len
= cand1
->num_convs
;
8838 if (len
!= cand2
->num_convs
)
8840 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
8841 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
8843 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
8844 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
8845 /* We're comparing a near-match list constructor and a near-match
8846 non-list constructor. Just treat them as unordered. */
8849 gcc_assert (static_1
!= static_2
);
8860 for (i
= 0; i
< len
; ++i
)
8862 conversion
*t1
= cand1
->convs
[i
+ off1
];
8863 conversion
*t2
= cand2
->convs
[i
+ off2
];
8864 int comp
= compare_ics (t1
, t2
);
8868 if ((complain
& tf_warning
)
8870 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
8871 == cr_std
+ cr_promotion
)
8872 && t1
->kind
== ck_std
8873 && t2
->kind
== ck_std
8874 && TREE_CODE (t1
->type
) == INTEGER_TYPE
8875 && TREE_CODE (t2
->type
) == INTEGER_TYPE
8876 && (TYPE_PRECISION (t1
->type
)
8877 == TYPE_PRECISION (t2
->type
))
8878 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
8879 || (TREE_CODE (next_conversion (t1
)->type
)
8882 tree type
= next_conversion (t1
)->type
;
8884 struct z_candidate
*w
, *l
;
8886 type1
= t1
->type
, type2
= t2
->type
,
8887 w
= cand1
, l
= cand2
;
8889 type1
= t2
->type
, type2
= t1
->type
,
8890 w
= cand2
, l
= cand1
;
8894 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
8895 type
, type1
, type2
);
8896 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
8902 if (winner
&& comp
!= winner
)
8911 /* warn about confusing overload resolution for user-defined conversions,
8912 either between a constructor and a conversion op, or between two
8914 if ((complain
& tf_warning
)
8915 && winner
&& warn_conversion
&& cand1
->second_conv
8916 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
8917 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
8919 struct z_candidate
*w
, *l
;
8920 bool give_warning
= false;
8923 w
= cand1
, l
= cand2
;
8925 w
= cand2
, l
= cand1
;
8927 /* We don't want to complain about `X::operator T1 ()'
8928 beating `X::operator T2 () const', when T2 is a no less
8929 cv-qualified version of T1. */
8930 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
8931 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
8933 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
8934 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
8936 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
8941 if (!comp_ptr_ttypes (t
, f
))
8942 give_warning
= true;
8945 give_warning
= true;
8951 tree source
= source_type (w
->convs
[0]);
8952 if (! DECL_CONSTRUCTOR_P (w
->fn
))
8953 source
= TREE_TYPE (source
);
8954 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
8955 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
8956 source
, w
->second_conv
->type
))
8958 inform (input_location
, " because conversion sequence for the argument is better");
8968 /* DR 495 moved this tiebreaker above the template ones. */
8970 the context is an initialization by user-defined conversion (see
8971 _dcl.init_ and _over.match.user_) and the standard conversion
8972 sequence from the return type of F1 to the destination type (i.e.,
8973 the type of the entity being initialized) is a better conversion
8974 sequence than the standard conversion sequence from the return type
8975 of F2 to the destination type. */
8977 if (cand1
->second_conv
)
8979 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
8985 F1 is a non-template function and F2 is a template function
8988 if (!cand1
->template_decl
&& cand2
->template_decl
)
8990 else if (cand1
->template_decl
&& !cand2
->template_decl
)
8994 F1 and F2 are template functions and the function template for F1 is
8995 more specialized than the template for F2 according to the partial
8998 if (cand1
->template_decl
&& cand2
->template_decl
)
9000 winner
= more_specialized_fn
9001 (TI_TEMPLATE (cand1
->template_decl
),
9002 TI_TEMPLATE (cand2
->template_decl
),
9003 /* [temp.func.order]: The presence of unused ellipsis and default
9004 arguments has no effect on the partial ordering of function
9005 templates. add_function_candidate() will not have
9006 counted the "this" argument for constructors. */
9007 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
9012 /* Check whether we can discard a builtin candidate, either because we
9013 have two identical ones or matching builtin and non-builtin candidates.
9015 (Pedantically in the latter case the builtin which matched the user
9016 function should not be added to the overload set, but we spot it here.
9019 ... the builtin candidates include ...
9020 - do not have the same parameter type list as any non-template
9021 non-member candidate. */
9023 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
9025 for (i
= 0; i
< len
; ++i
)
9026 if (!same_type_p (cand1
->convs
[i
]->type
,
9027 cand2
->convs
[i
]->type
))
9029 if (i
== cand1
->num_convs
)
9031 if (cand1
->fn
== cand2
->fn
)
9032 /* Two built-in candidates; arbitrarily pick one. */
9034 else if (identifier_p (cand1
->fn
))
9035 /* cand1 is built-in; prefer cand2. */
9038 /* cand2 is built-in; prefer cand1. */
9043 /* For candidates of a multi-versioned function, make the version with
9044 the highest priority win. This version will be checked for dispatching
9045 first. If this version can be inlined into the caller, the front-end
9046 will simply make a direct call to this function. */
9048 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9049 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
9050 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9051 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
9053 tree f1
= TREE_TYPE (cand1
->fn
);
9054 tree f2
= TREE_TYPE (cand2
->fn
);
9055 tree p1
= TYPE_ARG_TYPES (f1
);
9056 tree p2
= TYPE_ARG_TYPES (f2
);
9058 /* Check if cand1->fn and cand2->fn are versions of the same function. It
9059 is possible that cand1->fn and cand2->fn are function versions but of
9060 different functions. Check types to see if they are versions of the same
9062 if (compparms (p1
, p2
)
9063 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
9065 /* Always make the version with the higher priority, more
9066 specialized, win. */
9067 gcc_assert (targetm
.compare_version_priority
);
9068 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
9075 /* If the two function declarations represent the same function (this can
9076 happen with declarations in multiple scopes and arg-dependent lookup),
9077 arbitrarily choose one. But first make sure the default args we're
9079 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
9080 && equal_functions (cand1
->fn
, cand2
->fn
))
9082 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
9083 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
9085 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
9087 for (i
= 0; i
< len
; ++i
)
9089 /* Don't crash if the fn is variadic. */
9092 parms1
= TREE_CHAIN (parms1
);
9093 parms2
= TREE_CHAIN (parms2
);
9097 parms1
= TREE_CHAIN (parms1
);
9099 parms2
= TREE_CHAIN (parms2
);
9103 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
9104 TREE_PURPOSE (parms2
)))
9108 if (complain
& tf_error
)
9110 if (permerror (input_location
,
9111 "default argument mismatch in "
9112 "overload resolution"))
9114 inform (input_location
,
9115 " candidate 1: %q+#F", cand1
->fn
);
9116 inform (input_location
,
9117 " candidate 2: %q+#F", cand2
->fn
);
9124 add_warning (cand1
, cand2
);
9127 parms1
= TREE_CHAIN (parms1
);
9128 parms2
= TREE_CHAIN (parms2
);
9136 /* Extension: If the worst conversion for one candidate is worse than the
9137 worst conversion for the other, take the first. */
9138 if (!pedantic
&& (complain
& tf_warning_or_error
))
9140 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
9141 struct z_candidate
*w
= 0, *l
= 0;
9143 for (i
= 0; i
< len
; ++i
)
9145 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
9146 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
9147 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
9148 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
9151 winner
= 1, w
= cand1
, l
= cand2
;
9153 winner
= -1, w
= cand2
, l
= cand1
;
9156 /* Don't choose a deleted function over ambiguity. */
9157 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
9161 pedwarn (input_location
, 0,
9162 "ISO C++ says that these are ambiguous, even "
9163 "though the worst conversion for the first is better than "
9164 "the worst conversion for the second:");
9165 print_z_candidate (input_location
, _("candidate 1:"), w
);
9166 print_z_candidate (input_location
, _("candidate 2:"), l
);
9174 gcc_assert (!winner
);
9178 /* Given a list of candidates for overloading, find the best one, if any.
9179 This algorithm has a worst case of O(2n) (winner is last), and a best
9180 case of O(n/2) (totally ambiguous); much better than a sorting
9183 static struct z_candidate
*
9184 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
9186 struct z_candidate
*champ
= candidates
, *challenger
;
9188 int champ_compared_to_predecessor
= 0;
9190 /* Walk through the list once, comparing each current champ to the next
9191 candidate, knocking out a candidate or two with each comparison. */
9193 for (challenger
= champ
->next
; challenger
; )
9195 fate
= joust (champ
, challenger
, 0, complain
);
9197 challenger
= challenger
->next
;
9202 champ
= challenger
->next
;
9205 champ_compared_to_predecessor
= 0;
9210 champ_compared_to_predecessor
= 1;
9213 challenger
= champ
->next
;
9217 /* Make sure the champ is better than all the candidates it hasn't yet
9218 been compared to. */
9220 for (challenger
= candidates
;
9222 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
9223 challenger
= challenger
->next
)
9225 fate
= joust (champ
, challenger
, 0, complain
);
9233 /* Returns nonzero if things of type FROM can be converted to TO. */
9236 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
9238 tree arg
= NULL_TREE
;
9239 /* implicit_conversion only considers user-defined conversions
9240 if it has an expression for the call argument list. */
9241 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
9242 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
9243 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
9246 /* Returns nonzero if things of type FROM can be converted to TO with a
9247 standard conversion. */
9250 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
9252 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
9255 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
9258 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
9259 tsubst_flags_t complain
)
9265 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9266 p
= conversion_obstack_alloc (0);
9267 /* We want to discard any access checks done for this test,
9268 as we might not be in the appropriate access context and
9269 we'll do the check again when we actually perform the
9271 push_deferring_access_checks (dk_deferred
);
9273 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9275 ok_p
= (t
&& !t
->bad_p
);
9277 /* Discard the access checks now. */
9278 pop_deferring_access_checks ();
9279 /* Free all the conversions we allocated. */
9280 obstack_free (&conversion_obstack
, p
);
9285 /* Like can_convert_arg, but allows dubious conversions as well. */
9288 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
9289 tsubst_flags_t complain
)
9294 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9295 p
= conversion_obstack_alloc (0);
9296 /* Try to perform the conversion. */
9297 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9299 /* Free all the conversions we allocated. */
9300 obstack_free (&conversion_obstack
, p
);
9305 /* Convert EXPR to TYPE. Return the converted expression.
9307 Note that we allow bad conversions here because by the time we get to
9308 this point we are committed to doing the conversion. If we end up
9309 doing a bad conversion, convert_like will complain. */
9312 perform_implicit_conversion_flags (tree type
, tree expr
,
9313 tsubst_flags_t complain
, int flags
)
9317 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9319 if (error_operand_p (expr
))
9320 return error_mark_node
;
9322 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9323 p
= conversion_obstack_alloc (0);
9325 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9331 if (complain
& tf_error
)
9333 /* If expr has unknown type, then it is an overloaded function.
9334 Call instantiate_type to get good error messages. */
9335 if (TREE_TYPE (expr
) == unknown_type_node
)
9336 instantiate_type (type
, expr
, complain
);
9337 else if (invalid_nonstatic_memfn_p (expr
, complain
))
9338 /* We gave an error. */;
9340 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
9341 TREE_TYPE (expr
), type
);
9343 expr
= error_mark_node
;
9345 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
9347 /* In a template, we are only concerned about determining the
9348 type of non-dependent expressions, so we do not have to
9349 perform the actual conversion. But for initializers, we
9350 need to be able to perform it at instantiation
9351 (or fold_non_dependent_expr) time. */
9352 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
9353 if (!(flags
& LOOKUP_ONLYCONVERTING
))
9354 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
9357 expr
= convert_like (conv
, expr
, complain
);
9359 /* Free all the conversions we allocated. */
9360 obstack_free (&conversion_obstack
, p
);
9366 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
9368 return perform_implicit_conversion_flags (type
, expr
, complain
,
9372 /* Convert EXPR to TYPE (as a direct-initialization) if that is
9373 permitted. If the conversion is valid, the converted expression is
9374 returned. Otherwise, NULL_TREE is returned, except in the case
9375 that TYPE is a class type; in that case, an error is issued. If
9376 C_CAST_P is true, then this direct-initialization is taking
9377 place as part of a static_cast being attempted as part of a C-style
9381 perform_direct_initialization_if_possible (tree type
,
9384 tsubst_flags_t complain
)
9389 if (type
== error_mark_node
|| error_operand_p (expr
))
9390 return error_mark_node
;
9393 If the destination type is a (possibly cv-qualified) class type:
9395 -- If the initialization is direct-initialization ...,
9396 constructors are considered. ... If no constructor applies, or
9397 the overload resolution is ambiguous, the initialization is
9399 if (CLASS_TYPE_P (type
))
9401 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
9402 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
9403 &args
, type
, LOOKUP_NORMAL
, complain
);
9404 release_tree_vector (args
);
9405 return build_cplus_new (type
, expr
, complain
);
9408 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9409 p
= conversion_obstack_alloc (0);
9411 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9413 LOOKUP_NORMAL
, complain
);
9414 if (!conv
|| conv
->bad_p
)
9417 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
9418 /*issue_conversion_warnings=*/false,
9422 /* Free all the conversions we allocated. */
9423 obstack_free (&conversion_obstack
, p
);
9428 /* When initializing a reference that lasts longer than a full-expression,
9429 this special rule applies:
9433 The temporary to which the reference is bound or the temporary
9434 that is the complete object to which the reference is bound
9435 persists for the lifetime of the reference.
9437 The temporaries created during the evaluation of the expression
9438 initializing the reference, except the temporary to which the
9439 reference is bound, are destroyed at the end of the
9440 full-expression in which they are created.
9442 In that case, we store the converted expression into a new
9443 VAR_DECL in a new scope.
9445 However, we want to be careful not to create temporaries when
9446 they are not required. For example, given:
9449 struct D : public B {};
9453 there is no need to copy the return value from "f"; we can just
9454 extend its lifetime. Similarly, given:
9457 struct T { operator S(); };
9461 we can extend the lifetime of the return value of the conversion
9464 The next several functions are involved in this lifetime extension. */
9466 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9467 reference is being bound to a temporary. Create and return a new
9468 VAR_DECL with the indicated TYPE; this variable will store the value to
9469 which the reference is bound. */
9472 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
9476 /* Create the variable. */
9477 var
= create_temporary_var (type
);
9479 /* Register the variable. */
9481 && (TREE_STATIC (decl
) || DECL_THREAD_LOCAL_P (decl
)))
9483 /* Namespace-scope or local static; give it a mangled name. */
9484 /* FIXME share comdat with decl? */
9487 TREE_STATIC (var
) = TREE_STATIC (decl
);
9488 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
9489 name
= mangle_ref_init_variable (decl
);
9490 DECL_NAME (var
) = name
;
9491 SET_DECL_ASSEMBLER_NAME (var
, name
);
9492 var
= pushdecl_top_level (var
);
9495 /* Create a new cleanup level if necessary. */
9496 maybe_push_cleanup_level (type
);
9501 /* EXPR is the initializer for a variable DECL of reference or
9502 std::initializer_list type. Create, push and return a new VAR_DECL
9503 for the initializer so that it will live as long as DECL. Any
9504 cleanup for the new variable is returned through CLEANUP, and the
9505 code to initialize the new variable is returned through INITP. */
9508 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
9515 /* Create the temporary variable. */
9516 type
= TREE_TYPE (expr
);
9517 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
9518 layout_decl (var
, 0);
9519 /* If the rvalue is the result of a function call it will be
9520 a TARGET_EXPR. If it is some other construct (such as a
9521 member access expression where the underlying object is
9522 itself the result of a function call), turn it into a
9523 TARGET_EXPR here. It is important that EXPR be a
9524 TARGET_EXPR below since otherwise the INIT_EXPR will
9525 attempt to make a bitwise copy of EXPR to initialize
9527 if (TREE_CODE (expr
) != TARGET_EXPR
)
9528 expr
= get_target_expr (expr
);
9530 if (TREE_CODE (decl
) == FIELD_DECL
9531 && extra_warnings
&& !TREE_NO_WARNING (decl
))
9533 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
9534 "until the constructor exits", decl
);
9535 TREE_NO_WARNING (decl
) = true;
9538 /* Recursively extend temps in this initializer. */
9539 TARGET_EXPR_INITIAL (expr
)
9540 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
9542 /* Any reference temp has a non-trivial initializer. */
9543 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
9545 /* If the initializer is constant, put it in DECL_INITIAL so we get
9546 static initialization and use in constant expressions. */
9547 init
= maybe_constant_init (expr
);
9548 if (TREE_CONSTANT (init
))
9550 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
9552 /* 5.19 says that a constant expression can include an
9553 lvalue-rvalue conversion applied to "a glvalue of literal type
9554 that refers to a non-volatile temporary object initialized
9555 with a constant expression". Rather than try to communicate
9556 that this VAR_DECL is a temporary, just mark it constexpr.
9558 Currently this is only useful for initializer_list temporaries,
9559 since reference vars can't appear in constant expressions. */
9560 DECL_DECLARED_CONSTEXPR_P (var
) = true;
9561 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
9562 TREE_CONSTANT (var
) = true;
9564 DECL_INITIAL (var
) = init
;
9568 /* Create the INIT_EXPR that will initialize the temporary
9570 init
= build2 (INIT_EXPR
, type
, var
, expr
);
9571 if (at_function_scope_p ())
9573 add_decl_expr (var
);
9575 if (TREE_STATIC (var
))
9576 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
9579 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9581 vec_safe_push (*cleanups
, cleanup
);
9584 /* We must be careful to destroy the temporary only
9585 after its initialization has taken place. If the
9586 initialization throws an exception, then the
9587 destructor should not be run. We cannot simply
9588 transform INIT into something like:
9590 (INIT, ({ CLEANUP_STMT; }))
9592 because emit_local_var always treats the
9593 initializer as a full-expression. Thus, the
9594 destructor would run too early; it would run at the
9595 end of initializing the reference variable, rather
9596 than at the end of the block enclosing the
9599 The solution is to pass back a cleanup expression
9600 which the caller is responsible for attaching to
9601 the statement tree. */
9605 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
9606 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9608 if (DECL_THREAD_LOCAL_P (var
))
9609 tls_aggregates
= tree_cons (NULL_TREE
, var
,
9612 static_aggregates
= tree_cons (NULL_TREE
, var
,
9616 /* Check whether the dtor is callable. */
9617 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9624 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9625 initializing a variable of that TYPE. */
9628 initialize_reference (tree type
, tree expr
,
9629 int flags
, tsubst_flags_t complain
)
9633 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9635 if (type
== error_mark_node
|| error_operand_p (expr
))
9636 return error_mark_node
;
9638 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9639 p
= conversion_obstack_alloc (0);
9641 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
9643 if (!conv
|| conv
->bad_p
)
9645 if (complain
& tf_error
)
9648 convert_like (conv
, expr
, complain
);
9649 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
9650 && !TYPE_REF_IS_RVALUE (type
)
9651 && !real_lvalue_p (expr
))
9652 error_at (loc
, "invalid initialization of non-const reference of "
9653 "type %qT from an rvalue of type %qT",
9654 type
, TREE_TYPE (expr
));
9656 error_at (loc
, "invalid initialization of reference of type "
9657 "%qT from expression of type %qT", type
,
9660 return error_mark_node
;
9663 if (conv
->kind
== ck_ref_bind
)
9664 /* Perform the conversion. */
9665 expr
= convert_like (conv
, expr
, complain
);
9666 else if (conv
->kind
== ck_ambig
)
9667 /* We gave an error in build_user_type_conversion_1. */
9668 expr
= error_mark_node
;
9672 /* Free all the conversions we allocated. */
9673 obstack_free (&conversion_obstack
, p
);
9678 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9679 which is bound either to a reference or a std::initializer_list. */
9682 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9687 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
9689 TREE_OPERAND (sub
, 1)
9690 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
9693 if (TREE_CODE (sub
) != ADDR_EXPR
)
9695 /* Deal with binding to a subobject. */
9696 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
9697 p
= &TREE_OPERAND (*p
, 0);
9698 if (TREE_CODE (*p
) == TARGET_EXPR
)
9700 tree subinit
= NULL_TREE
;
9701 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
9703 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
9704 recompute_tree_invariant_for_addr_expr (sub
);
9709 /* INIT is part of the initializer for DECL. If there are any
9710 reference or initializer lists being initialized, extend their
9711 lifetime to match that of DECL. */
9714 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9716 tree type
= TREE_TYPE (init
);
9717 if (processing_template_decl
)
9719 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9720 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
9721 else if (is_std_init_list (type
))
9723 /* The temporary array underlying a std::initializer_list
9724 is handled like a reference temporary. */
9726 if (TREE_CODE (ctor
) == TARGET_EXPR
)
9727 ctor
= TARGET_EXPR_INITIAL (ctor
);
9728 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
9730 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
9731 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
9732 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
9735 else if (TREE_CODE (init
) == CONSTRUCTOR
)
9739 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
9740 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
9741 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
9747 /* Returns true iff an initializer for TYPE could contain temporaries that
9748 need to be extended because they are bound to references or
9749 std::initializer_list. */
9752 type_has_extended_temps (tree type
)
9754 type
= strip_array_types (type
);
9755 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9757 if (CLASS_TYPE_P (type
))
9759 if (is_std_init_list (type
))
9761 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
9762 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
9763 if (type_has_extended_temps (TREE_TYPE (f
)))
9769 /* Returns true iff TYPE is some variant of std::initializer_list. */
9772 is_std_init_list (tree type
)
9774 /* Look through typedefs. */
9777 if (cxx_dialect
== cxx98
)
9779 type
= TYPE_MAIN_VARIANT (type
);
9780 return (CLASS_TYPE_P (type
)
9781 && CP_TYPE_CONTEXT (type
) == std_node
9782 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
9785 /* Returns true iff DECL is a list constructor: i.e. a constructor which
9786 will accept an argument list of a single std::initializer_list<T>. */
9789 is_list_ctor (tree decl
)
9791 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
9794 if (!args
|| args
== void_list_node
)
9797 arg
= non_reference (TREE_VALUE (args
));
9798 if (!is_std_init_list (arg
))
9801 args
= TREE_CHAIN (args
);
9803 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9804 /* There are more non-defaulted parms. */
9810 #include "gt-cp-call.h"