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
= fold_non_dependent_expr (t
);
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
);
5312 bool memonly
= false;
5317 case VEC_DELETE_EXPR
:
5319 /* Use build_op_new_call and build_op_delete_call instead. */
5323 /* Use build_op_call instead. */
5326 case TRUTH_ORIF_EXPR
:
5327 case TRUTH_ANDIF_EXPR
:
5328 case TRUTH_AND_EXPR
:
5330 /* These are saved for the sake of warn_logical_operator. */
5331 code_orig_arg1
= TREE_CODE (arg1
);
5332 code_orig_arg2
= TREE_CODE (arg2
);
5340 /* These are saved for the sake of maybe_warn_bool_compare. */
5341 code_orig_arg1
= TREE_CODE (TREE_TYPE (arg1
));
5342 code_orig_arg2
= TREE_CODE (TREE_TYPE (arg2
));
5345 /* =, ->, [], () must be non-static member functions. */
5347 if (code2
!= NOP_EXPR
)
5358 arg2
= prep_operand (arg2
);
5359 arg3
= prep_operand (arg3
);
5361 if (code
== COND_EXPR
)
5362 /* Use build_conditional_expr instead. */
5364 else if (! OVERLOAD_TYPE_P (TREE_TYPE (arg1
))
5365 && (! arg2
|| ! OVERLOAD_TYPE_P (TREE_TYPE (arg2
))))
5368 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5369 arg2
= integer_zero_node
;
5371 vec_alloc (arglist
, 3);
5372 arglist
->quick_push (arg1
);
5373 if (arg2
!= NULL_TREE
)
5374 arglist
->quick_push (arg2
);
5375 if (arg3
!= NULL_TREE
)
5376 arglist
->quick_push (arg3
);
5378 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5379 p
= conversion_obstack_alloc (0);
5381 /* Add namespace-scope operators to the list of functions to
5384 add_candidates (lookup_function_nonclass (fnname
, arglist
,
5386 NULL_TREE
, arglist
, NULL_TREE
,
5387 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5388 flags
, &candidates
, complain
);
5392 args
[2] = NULL_TREE
;
5394 /* Add class-member operators to the candidate set. */
5395 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
5399 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
5400 if (fns
== error_mark_node
)
5402 result
= error_mark_node
;
5403 goto user_defined_result_ready
;
5406 add_candidates (BASELINK_FUNCTIONS (fns
),
5407 NULL_TREE
, arglist
, NULL_TREE
,
5409 BASELINK_BINFO (fns
),
5410 BASELINK_ACCESS_BINFO (fns
),
5411 flags
, &candidates
, complain
);
5413 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5414 only non-member functions that have type T1 or reference to
5415 cv-qualified-opt T1 for the first argument, if the first argument
5416 has an enumeration type, or T2 or reference to cv-qualified-opt
5417 T2 for the second argument, if the the second argument has an
5418 enumeration type. Filter out those that don't match. */
5419 else if (! arg2
|| ! CLASS_TYPE_P (TREE_TYPE (arg2
)))
5421 struct z_candidate
**candp
, **next
;
5423 for (candp
= &candidates
; *candp
; candp
= next
)
5425 tree parmlist
, parmtype
;
5426 int i
, nargs
= (arg2
? 2 : 1);
5431 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5433 for (i
= 0; i
< nargs
; ++i
)
5435 parmtype
= TREE_VALUE (parmlist
);
5437 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
5438 parmtype
= TREE_TYPE (parmtype
);
5439 if (TREE_CODE (TREE_TYPE (args
[i
])) == ENUMERAL_TYPE
5440 && (same_type_ignoring_top_level_qualifiers_p
5441 (TREE_TYPE (args
[i
]), parmtype
)))
5444 parmlist
= TREE_CHAIN (parmlist
);
5447 /* No argument has an appropriate type, so remove this
5448 candidate function from the list. */
5451 *candp
= cand
->next
;
5457 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
5464 /* For these, the built-in candidates set is empty
5465 [over.match.oper]/3. We don't want non-strict matches
5466 because exact matches are always possible with built-in
5467 operators. The built-in candidate set for COMPONENT_REF
5468 would be empty too, but since there are no such built-in
5469 operators, we accept non-strict matches for them. */
5478 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
5483 case POSTINCREMENT_EXPR
:
5484 case POSTDECREMENT_EXPR
:
5485 /* Don't try anything fancy if we're not allowed to produce
5487 if (!(complain
& tf_error
))
5488 return error_mark_node
;
5490 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5491 distinguish between prefix and postfix ++ and
5492 operator++() was used for both, so we allow this with
5496 const char *msg
= (flag_permissive
)
5497 ? G_("no %<%D(int)%> declared for postfix %qs,"
5498 " trying prefix operator instead")
5499 : G_("no %<%D(int)%> declared for postfix %qs");
5500 permerror (loc
, msg
, fnname
, operator_name_info
[code
].name
);
5503 if (!flag_permissive
)
5504 return error_mark_node
;
5506 if (code
== POSTINCREMENT_EXPR
)
5507 code
= PREINCREMENT_EXPR
;
5509 code
= PREDECREMENT_EXPR
;
5510 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
5511 NULL_TREE
, overload
, complain
);
5514 /* The caller will deal with these. */
5519 result_valid_p
= true;
5523 if (complain
& tf_error
)
5525 /* If one of the arguments of the operator represents
5526 an invalid use of member function pointer, try to report
5527 a meaningful error ... */
5528 if (invalid_nonstatic_memfn_p (arg1
, tf_error
)
5529 || invalid_nonstatic_memfn_p (arg2
, tf_error
)
5530 || invalid_nonstatic_memfn_p (arg3
, tf_error
))
5531 /* We displayed the error message. */;
5534 /* ... Otherwise, report the more generic
5535 "no matching operator found" error */
5536 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
5537 print_z_candidates (loc
, candidates
);
5540 result
= error_mark_node
;
5546 cand
= tourney (candidates
, complain
);
5549 if (complain
& tf_error
)
5551 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
5552 print_z_candidates (loc
, candidates
);
5554 result
= error_mark_node
;
5556 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5559 *overload
= cand
->fn
;
5561 if (resolve_args (arglist
, complain
) == NULL
)
5562 result
= error_mark_node
;
5564 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5568 /* Give any warnings we noticed during overload resolution. */
5569 if (cand
->warnings
&& (complain
& tf_warning
))
5571 struct candidate_warning
*w
;
5572 for (w
= cand
->warnings
; w
; w
= w
->next
)
5573 joust (cand
, w
->loser
, 1, complain
);
5576 /* Check for comparison of different enum types. */
5585 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
5586 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
5587 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
5588 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
)))
5589 && (complain
& tf_warning
))
5591 warning (OPT_Wenum_compare
,
5592 "comparison between %q#T and %q#T",
5593 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5600 /* We need to strip any leading REF_BIND so that bitfields
5601 don't cause errors. This should not remove any important
5602 conversions, because builtins don't apply to class
5603 objects directly. */
5604 conv
= cand
->convs
[0];
5605 if (conv
->kind
== ck_ref_bind
)
5606 conv
= next_conversion (conv
);
5607 arg1
= convert_like (conv
, arg1
, complain
);
5611 conv
= cand
->convs
[1];
5612 if (conv
->kind
== ck_ref_bind
)
5613 conv
= next_conversion (conv
);
5615 arg2
= decay_conversion (arg2
, complain
);
5617 /* We need to call warn_logical_operator before
5618 converting arg2 to a boolean_type, but after
5619 decaying an enumerator to its value. */
5620 if (complain
& tf_warning
)
5621 warn_logical_operator (loc
, code
, boolean_type_node
,
5622 code_orig_arg1
, arg1
,
5623 code_orig_arg2
, arg2
);
5625 arg2
= convert_like (conv
, arg2
, complain
);
5629 conv
= cand
->convs
[2];
5630 if (conv
->kind
== ck_ref_bind
)
5631 conv
= next_conversion (conv
);
5632 arg3
= convert_like (conv
, arg3
, complain
);
5638 user_defined_result_ready
:
5640 /* Free all the conversions we allocated. */
5641 obstack_free (&conversion_obstack
, p
);
5643 if (result
|| result_valid_p
)
5650 return cp_build_modify_expr (arg1
, code2
, arg2
, complain
);
5653 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
5655 case TRUTH_ANDIF_EXPR
:
5656 case TRUTH_ORIF_EXPR
:
5657 case TRUTH_AND_EXPR
:
5659 warn_logical_operator (loc
, code
, boolean_type_node
,
5660 code_orig_arg1
, arg1
, code_orig_arg2
, arg2
);
5668 if ((code_orig_arg1
== BOOLEAN_TYPE
)
5669 ^ (code_orig_arg2
== BOOLEAN_TYPE
))
5670 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
5675 case TRUNC_DIV_EXPR
:
5680 case TRUNC_MOD_EXPR
:
5684 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
5686 case UNARY_PLUS_EXPR
:
5689 case TRUTH_NOT_EXPR
:
5690 case PREINCREMENT_EXPR
:
5691 case POSTINCREMENT_EXPR
:
5692 case PREDECREMENT_EXPR
:
5693 case POSTDECREMENT_EXPR
:
5697 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5700 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5703 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
5707 /* The caller will deal with these. */
5719 /* Wrapper for above. */
5722 build_new_op (location_t loc
, enum tree_code code
, int flags
,
5723 tree arg1
, tree arg2
, tree arg3
,
5724 tree
*overload
, tsubst_flags_t complain
)
5727 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5728 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
5729 overload
, complain
);
5730 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5734 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5735 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5738 non_placement_deallocation_fn_p (tree t
)
5740 /* A template instance is never a usual deallocation function,
5741 regardless of its signature. */
5742 if (TREE_CODE (t
) == TEMPLATE_DECL
5743 || primary_template_instantiation_p (t
))
5746 /* If a class T has a member deallocation function named operator delete
5747 with exactly one parameter, then that function is a usual
5748 (non-placement) deallocation function. If class T does not declare
5749 such an operator delete but does declare a member deallocation
5750 function named operator delete with exactly two parameters, the second
5751 of which has type std::size_t (18.2), then this function is a usual
5752 deallocation function. */
5753 t
= FUNCTION_ARG_CHAIN (t
);
5754 if (t
== void_list_node
5755 || (t
&& same_type_p (TREE_VALUE (t
), size_type_node
)
5756 && TREE_CHAIN (t
) == void_list_node
))
5761 /* Build a call to operator delete. This has to be handled very specially,
5762 because the restrictions on what signatures match are different from all
5763 other call instances. For a normal delete, only a delete taking (void *)
5764 or (void *, size_t) is accepted. For a placement delete, only an exact
5765 match with the placement new is accepted.
5767 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5768 ADDR is the pointer to be deleted.
5769 SIZE is the size of the memory block to be deleted.
5770 GLOBAL_P is true if the delete-expression should not consider
5771 class-specific delete operators.
5772 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5774 If this call to "operator delete" is being generated as part to
5775 deallocate memory allocated via a new-expression (as per [expr.new]
5776 which requires that if the initialization throws an exception then
5777 we call a deallocation function), then ALLOC_FN is the allocation
5781 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
5782 bool global_p
, tree placement
,
5783 tree alloc_fn
, tsubst_flags_t complain
)
5785 tree fn
= NULL_TREE
;
5786 tree fns
, fnname
, type
, t
;
5788 if (addr
== error_mark_node
)
5789 return error_mark_node
;
5791 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
5793 fnname
= ansi_opname (code
);
5795 if (CLASS_TYPE_P (type
)
5796 && COMPLETE_TYPE_P (complete_type (type
))
5800 If the result of the lookup is ambiguous or inaccessible, or if
5801 the lookup selects a placement deallocation function, the
5802 program is ill-formed.
5804 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5806 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
5807 if (fns
== error_mark_node
)
5808 return error_mark_node
;
5813 if (fns
== NULL_TREE
)
5814 fns
= lookup_name_nonclass (fnname
);
5816 /* Strip const and volatile from addr. */
5817 addr
= cp_convert (ptr_type_node
, addr
, complain
);
5821 /* "A declaration of a placement deallocation function matches the
5822 declaration of a placement allocation function if it has the same
5823 number of parameters and, after parameter transformations (8.3.5),
5824 all parameter types except the first are identical."
5826 So we build up the function type we want and ask instantiate_type
5827 to get it for us. */
5828 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
5829 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
5830 t
= build_function_type (void_type_node
, t
);
5832 fn
= instantiate_type (t
, fns
, tf_none
);
5833 if (fn
== error_mark_node
)
5836 if (BASELINK_P (fn
))
5837 fn
= BASELINK_FUNCTIONS (fn
);
5839 /* "If the lookup finds the two-parameter form of a usual deallocation
5840 function (3.7.4.2) and that function, considered as a placement
5841 deallocation function, would have been selected as a match for the
5842 allocation function, the program is ill-formed." */
5843 if (non_placement_deallocation_fn_p (fn
))
5845 /* But if the class has an operator delete (void *), then that is
5846 the usual deallocation function, so we shouldn't complain
5847 about using the operator delete (void *, size_t). */
5848 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5849 t
; t
= OVL_NEXT (t
))
5851 tree elt
= OVL_CURRENT (t
);
5852 if (non_placement_deallocation_fn_p (elt
)
5853 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
5856 if (complain
& tf_error
)
5858 permerror (0, "non-placement deallocation function %q+D", fn
);
5859 permerror (input_location
, "selected for placement delete");
5862 return error_mark_node
;
5867 /* "Any non-placement deallocation function matches a non-placement
5868 allocation function. If the lookup finds a single matching
5869 deallocation function, that function will be called; otherwise, no
5870 deallocation function will be called." */
5871 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5872 t
; t
= OVL_NEXT (t
))
5874 tree elt
= OVL_CURRENT (t
);
5875 if (non_placement_deallocation_fn_p (elt
))
5878 /* "If a class T has a member deallocation function named
5879 operator delete with exactly one parameter, then that
5880 function is a usual (non-placement) deallocation
5881 function. If class T does not declare such an operator
5882 delete but does declare a member deallocation function named
5883 operator delete with exactly two parameters, the second of
5884 which has type std::size_t (18.2), then this function is a
5885 usual deallocation function."
5887 So (void*) beats (void*, size_t). */
5888 if (FUNCTION_ARG_CHAIN (fn
) == void_list_node
)
5893 /* If we have a matching function, call it. */
5896 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
5898 /* If the FN is a member function, make sure that it is
5900 if (BASELINK_P (fns
))
5901 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
5904 /* Core issue 901: It's ok to new a type with deleted delete. */
5905 if (DECL_DELETED_FN (fn
) && alloc_fn
)
5910 /* The placement args might not be suitable for overload
5911 resolution at this point, so build the call directly. */
5912 int nargs
= call_expr_nargs (placement
);
5913 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
5916 for (i
= 1; i
< nargs
; i
++)
5917 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
5919 return build_cxx_call (fn
, nargs
, argarray
, complain
);
5924 vec
<tree
, va_gc
> *args
= make_tree_vector ();
5925 args
->quick_push (addr
);
5926 if (FUNCTION_ARG_CHAIN (fn
) != void_list_node
)
5927 args
->quick_push (size
);
5928 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
5929 release_tree_vector (args
);
5936 If no unambiguous matching deallocation function can be found,
5937 propagating the exception does not cause the object's memory to
5941 if ((complain
& tf_warning
)
5943 warning (0, "no corresponding deallocation function for %qD",
5948 if (complain
& tf_error
)
5949 error ("no suitable %<operator %s%> for %qT",
5950 operator_name_info
[(int)code
].name
, type
);
5951 return error_mark_node
;
5954 /* If the current scope isn't allowed to access DECL along
5955 BASETYPE_PATH, give an error. The most derived class in
5956 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
5957 the declaration to use in the error diagnostic. */
5960 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
5961 tsubst_flags_t complain
)
5963 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
5965 if (!accessible_p (basetype_path
, decl
, true))
5967 if (complain
& tf_error
)
5969 if (TREE_PRIVATE (decl
))
5970 error ("%q+#D is private", diag_decl
);
5971 else if (TREE_PROTECTED (decl
))
5972 error ("%q+#D is protected", diag_decl
);
5974 error ("%q+#D is inaccessible", diag_decl
);
5975 error ("within this context");
5983 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
5984 bitwise or of LOOKUP_* values. If any errors are warnings are
5985 generated, set *DIAGNOSTIC_FN to "error" or "warning",
5986 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
5990 build_temp (tree expr
, tree type
, int flags
,
5991 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
5994 vec
<tree
, va_gc
> *args
;
5996 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
5997 args
= make_tree_vector_single (expr
);
5998 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
5999 &args
, type
, flags
, complain
);
6000 release_tree_vector (args
);
6001 if (warningcount
+ werrorcount
> savew
)
6002 *diagnostic_kind
= DK_WARNING
;
6003 else if (errorcount
> savee
)
6004 *diagnostic_kind
= DK_ERROR
;
6006 *diagnostic_kind
= DK_UNSPECIFIED
;
6010 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
6011 EXPR is implicitly converted to type TOTYPE.
6012 FN and ARGNUM are used for diagnostics. */
6015 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6017 /* Issue warnings about peculiar, but valid, uses of NULL. */
6018 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
6019 && ARITHMETIC_TYPE_P (totype
))
6021 source_location loc
=
6022 expansion_point_location_if_in_system_header (input_location
);
6025 warning_at (loc
, OPT_Wconversion_null
,
6026 "passing NULL to non-pointer argument %P of %qD",
6029 warning_at (loc
, OPT_Wconversion_null
,
6030 "converting to non-pointer type %qT from NULL", totype
);
6033 /* Issue warnings if "false" is converted to a NULL pointer */
6034 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6035 && TYPE_PTR_P (totype
))
6038 warning_at (input_location
, OPT_Wconversion_null
,
6039 "converting %<false%> to pointer type for argument %P "
6040 "of %qD", argnum
, fn
);
6042 warning_at (input_location
, OPT_Wconversion_null
,
6043 "converting %<false%> to pointer type %qT", totype
);
6047 /* We gave a diagnostic during a conversion. If this was in the second
6048 standard conversion sequence of a user-defined conversion sequence, say
6049 which user-defined conversion. */
6052 maybe_print_user_conv_context (conversion
*convs
)
6054 if (convs
->user_conv_p
)
6055 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6056 if (t
->kind
== ck_user
)
6058 print_z_candidate (0, " after user-defined conversion:",
6064 /* Perform the conversions in CONVS on the expression EXPR. FN and
6065 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6066 indicates the `this' argument of a method. INNER is nonzero when
6067 being called to continue a conversion chain. It is negative when a
6068 reference binding will be applied, positive otherwise. If
6069 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6070 conversions will be emitted if appropriate. If C_CAST_P is true,
6071 this conversion is coming from a C-style cast; in that case,
6072 conversions to inaccessible bases are permitted. */
6075 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6076 int inner
, bool issue_conversion_warnings
,
6077 bool c_cast_p
, tsubst_flags_t complain
)
6079 tree totype
= convs
->type
;
6080 diagnostic_t diag_kind
;
6082 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6084 if (convs
->bad_p
&& !(complain
& tf_error
))
6085 return error_mark_node
;
6088 && convs
->kind
!= ck_user
6089 && convs
->kind
!= ck_list
6090 && convs
->kind
!= ck_ambig
6091 && (convs
->kind
!= ck_ref_bind
6092 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
6093 && (convs
->kind
!= ck_rvalue
6094 || SCALAR_TYPE_P (totype
))
6095 && convs
->kind
!= ck_base
)
6097 bool complained
= false;
6098 conversion
*t
= convs
;
6100 /* Give a helpful error if this is bad because of excess braces. */
6101 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6102 && SCALAR_TYPE_P (totype
)
6103 && CONSTRUCTOR_NELTS (expr
) > 0
6104 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
6106 complained
= permerror (loc
, "too many braces around initializer "
6108 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6109 && CONSTRUCTOR_NELTS (expr
) == 1)
6110 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6113 /* Give a helpful error if this is bad because a conversion to bool
6114 from std::nullptr_t requires direct-initialization. */
6115 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
6116 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
6117 complained
= permerror (loc
, "converting to %qT from %qT requires "
6118 "direct-initialization",
6119 totype
, TREE_TYPE (expr
));
6121 for (; t
; t
= next_conversion (t
))
6123 if (t
->kind
== ck_user
&& t
->cand
->reason
)
6125 complained
= permerror (loc
, "invalid user-defined conversion "
6126 "from %qT to %qT", TREE_TYPE (expr
),
6129 print_z_candidate (loc
, "candidate is:", t
->cand
);
6130 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6131 /*issue_conversion_warnings=*/false,
6134 if (convs
->kind
== ck_ref_bind
)
6135 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
6136 LOOKUP_NORMAL
, NULL_TREE
,
6139 expr
= cp_convert (totype
, expr
, complain
);
6140 if (complained
&& fn
)
6141 inform (DECL_SOURCE_LOCATION (fn
),
6142 " initializing argument %P of %qD", argnum
, fn
);
6145 else if (t
->kind
== ck_user
|| !t
->bad_p
)
6147 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6148 /*issue_conversion_warnings=*/false,
6153 else if (t
->kind
== ck_ambig
)
6154 return convert_like_real (t
, expr
, fn
, argnum
, 1,
6155 /*issue_conversion_warnings=*/false,
6158 else if (t
->kind
== ck_identity
)
6162 complained
= permerror (loc
, "invalid conversion from %qT to %qT",
6163 TREE_TYPE (expr
), totype
);
6164 if (complained
&& fn
)
6165 inform (DECL_SOURCE_LOCATION (fn
),
6166 " initializing argument %P of %qD", argnum
, fn
);
6168 return cp_convert (totype
, expr
, complain
);
6171 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6172 conversion_null_warnings (totype
, expr
, fn
, argnum
);
6174 switch (convs
->kind
)
6178 struct z_candidate
*cand
= convs
->cand
;
6179 tree convfn
= cand
->fn
;
6182 /* When converting from an init list we consider explicit
6183 constructors, but actually trying to call one is an error. */
6184 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
6185 /* Unless this is for direct-list-initialization. */
6186 && !DIRECT_LIST_INIT_P (expr
))
6188 if (!(complain
& tf_error
))
6189 return error_mark_node
;
6190 error ("converting to %qT from initializer list would use "
6191 "explicit constructor %qD", totype
, convfn
);
6194 /* If we're initializing from {}, it's value-initialization. */
6195 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6196 && CONSTRUCTOR_NELTS (expr
) == 0
6197 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
6199 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
6200 expr
= build_value_init (totype
, complain
);
6201 expr
= get_target_expr_sfinae (expr
, complain
);
6202 if (expr
!= error_mark_node
)
6204 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6205 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
6210 expr
= mark_rvalue_use (expr
);
6212 /* Set user_conv_p on the argument conversions, so rvalue/base
6213 handling knows not to allow any more UDCs. */
6214 for (i
= 0; i
< cand
->num_convs
; ++i
)
6215 cand
->convs
[i
]->user_conv_p
= true;
6217 expr
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
6219 /* If this is a constructor or a function returning an aggr type,
6220 we need to build up a TARGET_EXPR. */
6221 if (DECL_CONSTRUCTOR_P (convfn
))
6223 expr
= build_cplus_new (totype
, expr
, complain
);
6225 /* Remember that this was list-initialization. */
6226 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
6227 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6233 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
6235 int nelts
= CONSTRUCTOR_NELTS (expr
);
6237 expr
= build_value_init (totype
, complain
);
6238 else if (nelts
== 1)
6239 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6243 expr
= mark_rvalue_use (expr
);
6245 if (type_unknown_p (expr
))
6246 expr
= instantiate_type (totype
, expr
, complain
);
6247 /* Convert a constant to its underlying value, unless we are
6248 about to bind it to a reference, in which case we need to
6249 leave it as an lvalue. */
6252 expr
= decl_constant_value_safe (expr
);
6253 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
6254 /* If __null has been converted to an integer type, we do not
6255 want to warn about uses of EXPR as an integer, rather than
6257 expr
= build_int_cst (totype
, 0);
6261 /* We leave bad_p off ck_ambig because overload resolution considers
6262 it valid, it just fails when we try to perform it. So we need to
6263 check complain here, too. */
6264 if (complain
& tf_error
)
6266 /* Call build_user_type_conversion again for the error. */
6267 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
6270 inform (input_location
, " initializing argument %P of %q+D",
6273 return error_mark_node
;
6277 /* Conversion to std::initializer_list<T>. */
6278 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
6279 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
6280 unsigned len
= CONSTRUCTOR_NELTS (expr
);
6281 tree array
, val
, field
;
6282 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6285 /* Convert all the elements. */
6286 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
6288 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
6289 1, false, false, complain
);
6290 if (sub
== error_mark_node
)
6292 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
6293 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
6294 return error_mark_node
;
6295 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
6296 if (!TREE_CONSTANT (sub
))
6297 TREE_CONSTANT (new_ctor
) = false;
6299 /* Build up the array. */
6300 elttype
= cp_build_qualified_type
6301 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
6302 array
= build_array_of_n_type (elttype
, len
);
6303 array
= finish_compound_literal (array
, new_ctor
, complain
);
6304 /* Take the address explicitly rather than via decay_conversion
6305 to avoid the error about taking the address of a temporary. */
6306 array
= cp_build_addr_expr (array
, complain
);
6307 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
6308 if (array
== error_mark_node
)
6309 return error_mark_node
;
6311 /* Build up the initializer_list object. */
6312 totype
= complete_type (totype
);
6313 field
= next_initializable_field (TYPE_FIELDS (totype
));
6314 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6315 field
= next_initializable_field (DECL_CHAIN (field
));
6316 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6317 new_ctor
= build_constructor (totype
, vec
);
6318 return get_target_expr_sfinae (new_ctor
, complain
);
6322 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6324 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6325 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6326 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6328 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6330 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6331 return fold_if_not_in_template (expr
);
6333 expr
= reshape_init (totype
, expr
, complain
);
6334 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6336 if (expr
!= error_mark_node
)
6337 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6344 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6345 convs
->kind
== ck_ref_bind
? -1 : 1,
6346 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6349 if (expr
== error_mark_node
)
6350 return error_mark_node
;
6352 switch (convs
->kind
)
6355 expr
= decay_conversion (expr
, complain
);
6356 if (expr
== error_mark_node
)
6357 return error_mark_node
;
6359 if (! MAYBE_CLASS_TYPE_P (totype
))
6361 /* Else fall through. */
6363 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6365 /* We are going to bind a reference directly to a base-class
6366 subobject of EXPR. */
6367 /* Build an expression for `*((base*) &expr)'. */
6368 expr
= convert_to_base (expr
, totype
,
6369 !c_cast_p
, /*nonnull=*/true, complain
);
6373 /* Copy-initialization where the cv-unqualified version of the source
6374 type is the same class as, or a derived class of, the class of the
6375 destination [is treated as direct-initialization]. [dcl.init] */
6376 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
6377 if (convs
->user_conv_p
)
6378 /* This conversion is being done in the context of a user-defined
6379 conversion (i.e. the second step of copy-initialization), so
6380 don't allow any more. */
6381 flags
|= LOOKUP_NO_CONVERSION
;
6382 if (convs
->rvaluedness_matches_p
)
6383 flags
|= LOOKUP_PREFER_RVALUE
;
6384 if (TREE_CODE (expr
) == TARGET_EXPR
6385 && TARGET_EXPR_LIST_INIT_P (expr
))
6386 /* Copy-list-initialization doesn't actually involve a copy. */
6388 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6389 if (diag_kind
&& complain
)
6391 maybe_print_user_conv_context (convs
);
6393 inform (DECL_SOURCE_LOCATION (fn
),
6394 " initializing argument %P of %qD", argnum
, fn
);
6397 return build_cplus_new (totype
, expr
, complain
);
6401 tree ref_type
= totype
;
6403 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6405 tree extype
= TREE_TYPE (expr
);
6406 if (TYPE_REF_IS_RVALUE (ref_type
)
6407 && real_lvalue_p (expr
))
6408 error_at (loc
, "cannot bind %qT lvalue to %qT",
6410 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !real_lvalue_p (expr
)
6411 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
6412 error_at (loc
, "invalid initialization of non-const reference of "
6413 "type %qT from an rvalue of type %qT", totype
, extype
);
6414 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
6415 error_at (loc
, "binding %qT to reference of type %qT "
6416 "discards qualifiers", extype
, totype
);
6419 maybe_print_user_conv_context (convs
);
6421 inform (input_location
,
6422 " initializing argument %P of %q+D", argnum
, fn
);
6423 return error_mark_node
;
6426 /* If necessary, create a temporary.
6428 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6429 that need temporaries, even when their types are reference
6430 compatible with the type of reference being bound, so the
6431 upcoming call to cp_build_addr_expr doesn't fail. */
6432 if (convs
->need_temporary_p
6433 || TREE_CODE (expr
) == CONSTRUCTOR
6434 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6436 /* Otherwise, a temporary of type "cv1 T1" is created and
6437 initialized from the initializer expression using the rules
6438 for a non-reference copy-initialization (8.5). */
6440 tree type
= TREE_TYPE (ref_type
);
6441 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
6443 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6444 (type
, next_conversion (convs
)->type
));
6445 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6446 && !TYPE_REF_IS_RVALUE (ref_type
))
6448 /* If the reference is volatile or non-const, we
6449 cannot create a temporary. */
6450 if (lvalue
& clk_bitfield
)
6451 error_at (loc
, "cannot bind bitfield %qE to %qT",
6453 else if (lvalue
& clk_packed
)
6454 error_at (loc
, "cannot bind packed field %qE to %qT",
6457 error_at (loc
, "cannot bind rvalue %qE to %qT",
6459 return error_mark_node
;
6461 /* If the source is a packed field, and we must use a copy
6462 constructor, then building the target expr will require
6463 binding the field to the reference parameter to the
6464 copy constructor, and we'll end up with an infinite
6465 loop. If we can use a bitwise copy, then we'll be
6467 if ((lvalue
& clk_packed
)
6468 && CLASS_TYPE_P (type
)
6469 && type_has_nontrivial_copy_init (type
))
6471 error_at (loc
, "cannot bind packed field %qE to %qT",
6473 return error_mark_node
;
6475 if (lvalue
& clk_bitfield
)
6477 expr
= convert_bitfield_to_declared_type (expr
);
6478 expr
= fold_convert (type
, expr
);
6480 expr
= build_target_expr_with_type (expr
, type
, complain
);
6483 /* Take the address of the thing to which we will bind the
6485 expr
= cp_build_addr_expr (expr
, complain
);
6486 if (expr
== error_mark_node
)
6487 return error_mark_node
;
6489 /* Convert it to a pointer to the type referred to by the
6490 reference. This will adjust the pointer if a derived to
6491 base conversion is being performed. */
6492 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
6494 /* Convert the pointer to the desired reference type. */
6495 return build_nop (ref_type
, expr
);
6499 return decay_conversion (expr
, complain
);
6502 /* Warn about deprecated conversion if appropriate. */
6503 string_conv_p (totype
, expr
, 1);
6508 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
6509 /*nonnull=*/false, complain
);
6510 return build_nop (totype
, expr
);
6513 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
6514 c_cast_p
, complain
);
6520 if (convs
->check_narrowing
6521 && !check_narrowing (totype
, expr
, complain
))
6522 return error_mark_node
;
6524 if (issue_conversion_warnings
)
6525 expr
= cp_convert_and_check (totype
, expr
, complain
);
6527 expr
= cp_convert (totype
, expr
, complain
);
6532 /* ARG is being passed to a varargs function. Perform any conversions
6533 required. Return the converted value. */
6536 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
6539 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
6543 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6544 standard conversions are performed. */
6545 arg
= decay_conversion (arg
, complain
);
6546 arg_type
= TREE_TYPE (arg
);
6549 If the argument has integral or enumeration type that is subject
6550 to the integral promotions (_conv.prom_), or a floating point
6551 type that is subject to the floating point promotion
6552 (_conv.fpprom_), the value of the argument is converted to the
6553 promoted type before the call. */
6554 if (TREE_CODE (arg_type
) == REAL_TYPE
6555 && (TYPE_PRECISION (arg_type
)
6556 < TYPE_PRECISION (double_type_node
))
6557 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
6559 if ((complain
& tf_warning
)
6560 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
6561 warning_at (loc
, OPT_Wdouble_promotion
,
6562 "implicit conversion from %qT to %qT when passing "
6563 "argument to function",
6564 arg_type
, double_type_node
);
6565 arg
= convert_to_real (double_type_node
, arg
);
6567 else if (NULLPTR_TYPE_P (arg_type
))
6568 arg
= null_pointer_node
;
6569 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
6571 if (SCOPED_ENUM_P (arg_type
))
6573 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
6575 prom
= cp_perform_integral_promotions (prom
, complain
);
6576 if (abi_version_crosses (6)
6577 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
6578 && (complain
& tf_warning
))
6579 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through ... as "
6580 "%qT before -fabi-version=6, %qT after", arg_type
,
6581 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
6582 if (!abi_version_at_least (6))
6586 arg
= cp_perform_integral_promotions (arg
, complain
);
6589 arg
= require_complete_type_sfinae (arg
, complain
);
6590 arg_type
= TREE_TYPE (arg
);
6592 if (arg
!= error_mark_node
6593 /* In a template (or ill-formed code), we can have an incomplete type
6594 even after require_complete_type_sfinae, in which case we don't know
6595 whether it has trivial copy or not. */
6596 && COMPLETE_TYPE_P (arg_type
))
6598 /* Build up a real lvalue-to-rvalue conversion in case the
6599 copy constructor is trivial but not callable. */
6600 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
6601 force_rvalue (arg
, complain
);
6603 /* [expr.call] 5.2.2/7:
6604 Passing a potentially-evaluated argument of class type (Clause 9)
6605 with a non-trivial copy constructor or a non-trivial destructor
6606 with no corresponding parameter is conditionally-supported, with
6607 implementation-defined semantics.
6609 We support it as pass-by-invisible-reference, just like a normal
6612 If the call appears in the context of a sizeof expression,
6613 it is not potentially-evaluated. */
6614 if (cp_unevaluated_operand
== 0
6615 && (type_has_nontrivial_copy_init (arg_type
)
6616 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
6618 if (complain
& tf_warning
)
6619 warning (OPT_Wconditionally_supported
,
6620 "passing objects of non-trivially-copyable "
6621 "type %q#T through %<...%> is conditionally supported",
6623 return cp_build_addr_expr (arg
, complain
);
6630 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6633 build_x_va_arg (source_location loc
, tree expr
, tree type
)
6635 if (processing_template_decl
)
6637 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
6638 SET_EXPR_LOCATION (r
, loc
);
6642 type
= complete_type_or_else (type
, NULL_TREE
);
6644 if (expr
== error_mark_node
|| !type
)
6645 return error_mark_node
;
6647 expr
= mark_lvalue_use (expr
);
6649 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6651 error ("cannot receive reference type %qT through %<...%>", type
);
6652 return error_mark_node
;
6655 if (type_has_nontrivial_copy_init (type
)
6656 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6658 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
6659 it as pass by invisible reference. */
6660 warning_at (loc
, OPT_Wconditionally_supported
,
6661 "receiving objects of non-trivially-copyable type %q#T "
6662 "through %<...%> is conditionally-supported", type
);
6664 tree ref
= cp_build_reference_type (type
, false);
6665 expr
= build_va_arg (loc
, expr
, ref
);
6666 return convert_from_reference (expr
);
6669 return build_va_arg (loc
, expr
, type
);
6672 /* TYPE has been given to va_arg. Apply the default conversions which
6673 would have happened when passed via ellipsis. Return the promoted
6674 type, or the passed type if there is no change. */
6677 cxx_type_promotes_to (tree type
)
6681 /* Perform the array-to-pointer and function-to-pointer
6683 type
= type_decays_to (type
);
6685 promote
= type_promotes_to (type
);
6686 if (same_type_p (type
, promote
))
6692 /* ARG is a default argument expression being passed to a parameter of
6693 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6694 zero-based argument number. Do any required conversions. Return
6695 the converted value. */
6697 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
6699 push_defarg_context (tree fn
)
6700 { vec_safe_push (default_arg_context
, fn
); }
6703 pop_defarg_context (void)
6704 { default_arg_context
->pop (); }
6707 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
6708 tsubst_flags_t complain
)
6713 /* See through clones. */
6714 fn
= DECL_ORIGIN (fn
);
6716 /* Detect recursion. */
6717 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
6720 if (complain
& tf_error
)
6721 error ("recursive evaluation of default argument for %q#D", fn
);
6722 return error_mark_node
;
6725 /* If the ARG is an unparsed default argument expression, the
6726 conversion cannot be performed. */
6727 if (TREE_CODE (arg
) == DEFAULT_ARG
)
6729 if (complain
& tf_error
)
6730 error ("call to %qD uses the default argument for parameter %P, which "
6731 "is not yet defined", fn
, parmnum
);
6732 return error_mark_node
;
6735 push_defarg_context (fn
);
6737 if (fn
&& DECL_TEMPLATE_INFO (fn
))
6738 arg
= tsubst_default_argument (fn
, type
, arg
, complain
);
6744 The names in the expression are bound, and the semantic
6745 constraints are checked, at the point where the default
6746 expressions appears.
6748 we must not perform access checks here. */
6749 push_deferring_access_checks (dk_no_check
);
6750 /* We must make a copy of ARG, in case subsequent processing
6751 alters any part of it. */
6752 arg
= break_out_target_exprs (arg
);
6753 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6754 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6756 arg
= convert_for_arg_passing (type
, arg
, complain
);
6757 pop_deferring_access_checks();
6759 pop_defarg_context ();
6764 /* Returns the type which will really be used for passing an argument of
6768 type_passed_as (tree type
)
6770 /* Pass classes with copy ctors by invisible reference. */
6771 if (TREE_ADDRESSABLE (type
))
6773 type
= build_reference_type (type
);
6774 /* There are no other pointers to this temporary. */
6775 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
6777 else if (targetm
.calls
.promote_prototypes (type
)
6778 && INTEGRAL_TYPE_P (type
)
6779 && COMPLETE_TYPE_P (type
)
6780 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6781 type
= integer_type_node
;
6786 /* Actually perform the appropriate conversion. */
6789 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
6793 /* If VAL is a bitfield, then -- since it has already been converted
6794 to TYPE -- it cannot have a precision greater than TYPE.
6796 If it has a smaller precision, we must widen it here. For
6797 example, passing "int f:3;" to a function expecting an "int" will
6798 not result in any conversion before this point.
6800 If the precision is the same we must not risk widening. For
6801 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6802 often have type "int", even though the C++ type for the field is
6803 "long long". If the value is being passed to a function
6804 expecting an "int", then no conversions will be required. But,
6805 if we call convert_bitfield_to_declared_type, the bitfield will
6806 be converted to "long long". */
6807 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
6809 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
6810 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
6812 if (val
== error_mark_node
)
6814 /* Pass classes with copy ctors by invisible reference. */
6815 else if (TREE_ADDRESSABLE (type
))
6816 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
6817 else if (targetm
.calls
.promote_prototypes (type
)
6818 && INTEGRAL_TYPE_P (type
)
6819 && COMPLETE_TYPE_P (type
)
6820 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6821 val
= cp_perform_integral_promotions (val
, complain
);
6822 if ((complain
& tf_warning
)
6823 && warn_suggest_attribute_format
)
6825 tree rhstype
= TREE_TYPE (val
);
6826 const enum tree_code coder
= TREE_CODE (rhstype
);
6827 const enum tree_code codel
= TREE_CODE (type
);
6828 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6830 && check_missing_format_attribute (type
, rhstype
))
6831 warning (OPT_Wsuggest_attribute_format
,
6832 "argument of function call might be a candidate for a format attribute");
6837 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6838 which no conversions at all should be done. This is true for some
6839 builtins which don't act like normal functions. */
6842 magic_varargs_p (tree fn
)
6844 if (flag_cilkplus
&& is_cilkplus_reduce_builtin (fn
) != BUILT_IN_NONE
)
6847 if (DECL_BUILT_IN (fn
))
6848 switch (DECL_FUNCTION_CODE (fn
))
6850 case BUILT_IN_CLASSIFY_TYPE
:
6851 case BUILT_IN_CONSTANT_P
:
6852 case BUILT_IN_NEXT_ARG
:
6853 case BUILT_IN_VA_START
:
6857 return lookup_attribute ("type generic",
6858 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
6864 /* Returns the decl of the dispatcher function if FN is a function version. */
6867 get_function_version_dispatcher (tree fn
)
6869 tree dispatcher_decl
= NULL
;
6871 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6872 && DECL_FUNCTION_VERSIONED (fn
));
6874 gcc_assert (targetm
.get_function_versions_dispatcher
);
6875 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
6877 if (dispatcher_decl
== NULL
)
6879 error_at (input_location
, "use of multiversioned function "
6880 "without a default");
6884 retrofit_lang_decl (dispatcher_decl
);
6885 gcc_assert (dispatcher_decl
!= NULL
);
6886 return dispatcher_decl
;
6889 /* fn is a function version dispatcher that is marked used. Mark all the
6890 semantically identical function versions it will dispatch as used. */
6893 mark_versions_used (tree fn
)
6895 struct cgraph_node
*node
;
6896 struct cgraph_function_version_info
*node_v
;
6897 struct cgraph_function_version_info
*it_v
;
6899 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6901 node
= cgraph_node::get (fn
);
6905 gcc_assert (node
->dispatcher_function
);
6907 node_v
= node
->function_version ();
6911 /* All semantically identical versions are chained. Traverse and mark each
6912 one of them as used. */
6913 it_v
= node_v
->next
;
6914 while (it_v
!= NULL
)
6916 mark_used (it_v
->this_node
->decl
);
6921 /* Build a call to "the copy constructor" for the type of A, even if it
6922 wouldn't be selected by normal overload resolution. Used for
6926 call_copy_ctor (tree a
, tsubst_flags_t complain
)
6928 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
6929 tree binfo
= TYPE_BINFO (ctype
);
6930 tree copy
= get_copy_ctor (ctype
, complain
);
6931 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
6932 tree ob
= build_dummy_object (ctype
);
6933 vec
<tree
, va_gc
>* args
= make_tree_vector_single (a
);
6934 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
6935 LOOKUP_NORMAL
, NULL
, complain
);
6936 release_tree_vector (args
);
6940 /* Subroutine of the various build_*_call functions. Overload resolution
6941 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
6942 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
6943 bitmask of various LOOKUP_* flags which apply to the call itself. */
6946 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
6949 const vec
<tree
, va_gc
> *args
= cand
->args
;
6950 tree first_arg
= cand
->first_arg
;
6951 conversion
**convs
= cand
->convs
;
6953 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6958 unsigned int arg_index
= 0;
6962 bool already_used
= false;
6964 /* In a template, there is no need to perform all of the work that
6965 is normally done. We are only interested in the type of the call
6966 expression, i.e., the return type of the function. Any semantic
6967 errors will be deferred until the template is instantiated. */
6968 if (processing_template_decl
)
6972 const tree
*argarray
;
6975 return_type
= TREE_TYPE (TREE_TYPE (fn
));
6976 nargs
= vec_safe_length (args
);
6977 if (first_arg
== NULL_TREE
)
6978 argarray
= args
->address ();
6986 alcarray
= XALLOCAVEC (tree
, nargs
);
6987 alcarray
[0] = build_this (first_arg
);
6988 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
6989 alcarray
[ix
+ 1] = arg
;
6990 argarray
= alcarray
;
6993 addr
= build_addr_func (fn
, complain
);
6994 if (addr
== error_mark_node
)
6995 return error_mark_node
;
6996 expr
= build_call_array_loc (input_location
, return_type
,
6997 addr
, nargs
, argarray
);
6998 if (TREE_THIS_VOLATILE (fn
) && cfun
)
6999 current_function_returns_abnormally
= 1;
7000 return convert_from_reference (expr
);
7003 /* Give any warnings we noticed during overload resolution. */
7004 if (cand
->warnings
&& (complain
& tf_warning
))
7006 struct candidate_warning
*w
;
7007 for (w
= cand
->warnings
; w
; w
= w
->next
)
7008 joust (cand
, w
->loser
, 1, complain
);
7011 /* Make =delete work with SFINAE. */
7012 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7013 return error_mark_node
;
7015 if (DECL_FUNCTION_MEMBER_P (fn
))
7018 /* If FN is a template function, two cases must be considered.
7023 template <class T> void f();
7025 template <class T> struct B {
7029 struct C : A, B<int> {
7031 using B<int>::g; // #2
7034 In case #1 where `A::f' is a member template, DECL_ACCESS is
7035 recorded in the primary template but not in its specialization.
7036 We check access of FN using its primary template.
7038 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
7039 because it is a member of class template B, DECL_ACCESS is
7040 recorded in the specialization `B<int>::g'. We cannot use its
7041 primary template because `B<T>::g' and `B<int>::g' may have
7042 different access. */
7043 if (DECL_TEMPLATE_INFO (fn
)
7044 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
7045 access_fn
= DECL_TI_TEMPLATE (fn
);
7048 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
7050 return error_mark_node
;
7053 /* If we're checking for implicit delete, don't bother with argument
7055 if (flags
& LOOKUP_SPECULATIVE
)
7057 if (DECL_DELETED_FN (fn
))
7059 if (complain
& tf_error
)
7061 return error_mark_node
;
7063 if (cand
->viable
== 1)
7065 else if (!(complain
& tf_error
))
7066 /* Reject bad conversions now. */
7067 return error_mark_node
;
7068 /* else continue to get conversion error. */
7071 /* N3276 magic doesn't apply to nested calls. */
7072 int decltype_flag
= (complain
& tf_decltype
);
7073 complain
&= ~tf_decltype
;
7075 /* Find maximum size of vector to hold converted arguments. */
7076 parmlen
= list_length (parm
);
7077 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
7078 if (parmlen
> nargs
)
7080 argarray
= XALLOCAVEC (tree
, nargs
);
7082 /* The implicit parameters to a constructor are not considered by overload
7083 resolution, and must be of the proper type. */
7084 if (DECL_CONSTRUCTOR_P (fn
))
7087 if (first_arg
!= NULL_TREE
)
7089 object_arg
= first_arg
;
7090 first_arg
= NULL_TREE
;
7094 object_arg
= (*args
)[arg_index
];
7097 argarray
[j
++] = build_this (object_arg
);
7098 parm
= TREE_CHAIN (parm
);
7099 /* We should never try to call the abstract constructor. */
7100 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
7102 if (DECL_HAS_VTT_PARM_P (fn
))
7104 argarray
[j
++] = (*args
)[arg_index
];
7106 parm
= TREE_CHAIN (parm
);
7109 /* Bypass access control for 'this' parameter. */
7110 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7112 tree parmtype
= TREE_VALUE (parm
);
7113 tree arg
= build_this (first_arg
!= NULL_TREE
7115 : (*args
)[arg_index
]);
7116 tree argtype
= TREE_TYPE (arg
);
7120 if (convs
[i
]->bad_p
)
7122 if (complain
& tf_error
)
7124 if (permerror (input_location
, "passing %qT as %<this%> "
7125 "argument discards qualifiers",
7126 TREE_TYPE (argtype
)))
7127 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
7130 return error_mark_node
;
7133 /* See if the function member or the whole class type is declared
7134 final and the call can be devirtualized. */
7135 if (DECL_FINAL_P (fn
)
7136 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
7137 flags
|= LOOKUP_NONVIRTUAL
;
7139 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
7140 X is called for an object that is not of type X, or of a type
7141 derived from X, the behavior is undefined.
7143 So we can assume that anything passed as 'this' is non-null, and
7144 optimize accordingly. */
7145 gcc_assert (TYPE_PTR_P (parmtype
));
7146 /* Convert to the base in which the function was declared. */
7147 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
7148 converted_arg
= build_base_path (PLUS_EXPR
,
7150 cand
->conversion_path
,
7152 /* Check that the base class is accessible. */
7153 if (!accessible_base_p (TREE_TYPE (argtype
),
7154 BINFO_TYPE (cand
->conversion_path
), true))
7156 if (complain
& tf_error
)
7157 error ("%qT is not an accessible base of %qT",
7158 BINFO_TYPE (cand
->conversion_path
),
7159 TREE_TYPE (argtype
));
7161 return error_mark_node
;
7163 /* If fn was found by a using declaration, the conversion path
7164 will be to the derived class, not the base declaring fn. We
7165 must convert from derived to base. */
7166 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
7167 TREE_TYPE (parmtype
), ba_unique
,
7169 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
7170 base_binfo
, 1, complain
);
7172 argarray
[j
++] = converted_arg
;
7173 parm
= TREE_CHAIN (parm
);
7174 if (first_arg
!= NULL_TREE
)
7175 first_arg
= NULL_TREE
;
7182 gcc_assert (first_arg
== NULL_TREE
);
7183 for (; arg_index
< vec_safe_length (args
) && parm
;
7184 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
7186 tree type
= TREE_VALUE (parm
);
7187 tree arg
= (*args
)[arg_index
];
7188 bool conversion_warning
= true;
7192 /* If the argument is NULL and used to (implicitly) instantiate a
7193 template function (and bind one of the template arguments to
7194 the type of 'long int'), we don't want to warn about passing NULL
7195 to non-pointer argument.
7196 For example, if we have this template function:
7198 template<typename T> void func(T x) {}
7200 we want to warn (when -Wconversion is enabled) in this case:
7206 but not in this case:
7212 if (arg
== null_node
7213 && DECL_TEMPLATE_INFO (fn
)
7214 && cand
->template_decl
7215 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
7216 conversion_warning
= false;
7218 /* Warn about initializer_list deduction that isn't currently in the
7220 if (cxx_dialect
> cxx98
7221 && flag_deduce_init_list
7222 && cand
->template_decl
7223 && is_std_init_list (non_reference (type
))
7224 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
7226 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
7227 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
7228 tree patparm
= get_pattern_parm (realparm
, tmpl
);
7229 tree pattype
= TREE_TYPE (patparm
);
7230 if (PACK_EXPANSION_P (pattype
))
7231 pattype
= PACK_EXPANSION_PATTERN (pattype
);
7232 pattype
= non_reference (pattype
);
7234 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
7235 && (cand
->explicit_targs
== NULL_TREE
7236 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
7237 <= TEMPLATE_TYPE_IDX (pattype
))))
7239 pedwarn (input_location
, 0, "deducing %qT as %qT",
7240 non_reference (TREE_TYPE (patparm
)),
7241 non_reference (type
));
7242 pedwarn (input_location
, 0, " in call to %q+D", cand
->fn
);
7243 pedwarn (input_location
, 0,
7244 " (you can disable this with -fno-deduce-init-list)");
7247 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
7250 : complain
& (~tf_warning
));
7252 val
= convert_for_arg_passing (type
, val
, complain
);
7254 if (val
== error_mark_node
)
7255 return error_mark_node
;
7257 argarray
[j
++] = val
;
7260 /* Default arguments */
7261 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
7263 if (TREE_VALUE (parm
) == error_mark_node
)
7264 return error_mark_node
;
7265 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
7266 TREE_PURPOSE (parm
),
7272 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
7274 tree a
= (*args
)[arg_index
];
7275 if (magic_varargs_p (fn
))
7276 /* Do no conversions for magic varargs. */
7277 a
= mark_type_use (a
);
7278 else if (DECL_CONSTRUCTOR_P (fn
)
7279 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
7282 /* Avoid infinite recursion trying to call A(...). */
7283 if (complain
& tf_error
)
7284 /* Try to call the actual copy constructor for a good error. */
7285 call_copy_ctor (a
, complain
);
7286 return error_mark_node
;
7289 a
= convert_arg_to_ellipsis (a
, complain
);
7293 gcc_assert (j
<= nargs
);
7296 check_function_arguments (TREE_TYPE (fn
), nargs
, argarray
);
7298 /* Avoid actually calling copy constructors and copy assignment operators,
7301 if (! flag_elide_constructors
)
7302 /* Do things the hard way. */;
7303 else if (cand
->num_convs
== 1
7304 && (DECL_COPY_CONSTRUCTOR_P (fn
)
7305 || DECL_MOVE_CONSTRUCTOR_P (fn
))
7306 /* It's unsafe to elide the constructor when handling
7307 a noexcept-expression, it may evaluate to the wrong
7308 value (c++/53025). */
7309 && cp_noexcept_operand
== 0)
7312 tree arg
= argarray
[num_artificial_parms_for (fn
)];
7314 bool trivial
= trivial_fn_p (fn
);
7316 /* Pull out the real argument, disregarding const-correctness. */
7318 while (CONVERT_EXPR_P (targ
)
7319 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
7320 targ
= TREE_OPERAND (targ
, 0);
7321 if (TREE_CODE (targ
) == ADDR_EXPR
)
7323 targ
= TREE_OPERAND (targ
, 0);
7324 if (!same_type_ignoring_top_level_qualifiers_p
7325 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
7334 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7336 /* [class.copy]: the copy constructor is implicitly defined even if
7337 the implementation elided its use. */
7338 if (!trivial
|| DECL_DELETED_FN (fn
))
7341 already_used
= true;
7344 /* If we're creating a temp and we already have one, don't create a
7345 new one. If we're not creating a temp but we get one, use
7346 INIT_EXPR to collapse the temp into our target. Otherwise, if the
7347 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
7348 temp or an INIT_EXPR otherwise. */
7350 if (is_dummy_object (fa
))
7352 if (TREE_CODE (arg
) == TARGET_EXPR
)
7355 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
7357 else if (TREE_CODE (arg
) == TARGET_EXPR
|| trivial
)
7359 tree to
= stabilize_reference (cp_build_indirect_ref (fa
, RO_NULL
,
7362 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
7366 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
7367 && trivial_fn_p (fn
)
7368 && !DECL_DELETED_FN (fn
))
7370 tree to
= stabilize_reference
7371 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
7372 tree type
= TREE_TYPE (to
);
7373 tree as_base
= CLASSTYPE_AS_BASE (type
);
7374 tree arg
= argarray
[1];
7376 if (is_really_empty_class (type
))
7378 /* Avoid copying empty classes. */
7379 val
= build2 (COMPOUND_EXPR
, void_type_node
, to
, arg
);
7380 TREE_NO_WARNING (val
) = 1;
7381 val
= build2 (COMPOUND_EXPR
, type
, val
, to
);
7382 TREE_NO_WARNING (val
) = 1;
7384 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
7386 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7387 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
7391 /* We must only copy the non-tail padding parts. */
7393 tree array_type
, alias_set
;
7395 arg2
= TYPE_SIZE_UNIT (as_base
);
7396 arg0
= cp_build_addr_expr (to
, complain
);
7398 array_type
= build_array_type (char_type_node
,
7400 (size_binop (MINUS_EXPR
,
7401 arg2
, size_int (1))));
7402 alias_set
= build_int_cst (build_pointer_type (type
), 0);
7403 t
= build2 (MODIFY_EXPR
, void_type_node
,
7404 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
7405 build2 (MEM_REF
, array_type
, arg
, alias_set
));
7406 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
7407 TREE_NO_WARNING (val
) = 1;
7412 else if (DECL_DESTRUCTOR_P (fn
)
7413 && trivial_fn_p (fn
)
7414 && !DECL_DELETED_FN (fn
))
7415 return fold_convert (void_type_node
, argarray
[0]);
7416 /* FIXME handle trivial default constructor, too. */
7418 /* For calls to a multi-versioned function, overload resolution
7419 returns the function with the highest target priority, that is,
7420 the version that will checked for dispatching first. If this
7421 version is inlinable, a direct call to this version can be made
7422 otherwise the call should go through the dispatcher. */
7424 if (DECL_FUNCTION_VERSIONED (fn
)
7425 && (current_function_decl
== NULL
7426 || !targetm
.target_option
.can_inline_p (current_function_decl
, fn
)))
7428 fn
= get_function_version_dispatcher (fn
);
7432 mark_versions_used (fn
);
7437 return error_mark_node
;
7439 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
7440 /* Don't mess with virtual lookup in instantiate_non_dependent_expr;
7441 virtual functions can't be constexpr. */
7442 && !in_template_function ())
7445 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
7447 ba_any
, NULL
, complain
);
7448 gcc_assert (binfo
&& binfo
!= error_mark_node
);
7450 /* Warn about deprecated virtual functions now, since we're about
7451 to throw away the decl. */
7452 if (TREE_DEPRECATED (fn
))
7453 warn_deprecated_use (fn
, NULL_TREE
);
7455 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
7457 if (TREE_SIDE_EFFECTS (argarray
[0]))
7458 argarray
[0] = save_expr (argarray
[0]);
7459 t
= build_pointer_type (TREE_TYPE (fn
));
7460 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
7461 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
7463 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
7468 fn
= build_addr_func (fn
, complain
);
7469 if (fn
== error_mark_node
)
7470 return error_mark_node
;
7473 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
7474 if (TREE_CODE (call
) == CALL_EXPR
7475 && (cand
->flags
& LOOKUP_LIST_INIT_CTOR
))
7476 CALL_EXPR_LIST_INIT_P (call
) = true;
7480 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7481 This function performs no overload resolution, conversion, or other
7482 high-level operations. */
7485 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
7486 tsubst_flags_t complain
)
7491 /* Remember roughly where this call is. */
7492 location_t loc
= EXPR_LOC_OR_LOC (fn
, input_location
);
7493 fn
= build_call_a (fn
, nargs
, argarray
);
7494 SET_EXPR_LOCATION (fn
, loc
);
7496 fndecl
= get_callee_fndecl (fn
);
7498 /* Check that arguments to builtin functions match the expectations. */
7500 && DECL_BUILT_IN (fndecl
)
7501 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7502 && !check_builtin_function_arguments (fndecl
, nargs
, argarray
))
7503 return error_mark_node
;
7505 /* If it is a built-in array notation function, then the return type of
7506 the function is the element type of the array passed in as array
7507 notation (i.e. the first parameter of the function). */
7508 if (flag_cilkplus
&& TREE_CODE (fn
) == CALL_EXPR
)
7510 enum built_in_function bif
=
7511 is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn
));
7512 if (bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
7513 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
7514 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
7515 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
7516 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE
7517 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
7519 if (call_expr_nargs (fn
) == 0)
7521 error_at (EXPR_LOCATION (fn
), "Invalid builtin arguments");
7522 return error_mark_node
;
7524 /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or
7525 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or
7526 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or
7527 BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or
7528 BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or
7529 BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
7530 The pre-defined return-type is the correct one. */
7531 tree array_ntn
= CALL_EXPR_ARG (fn
, 0);
7532 TREE_TYPE (fn
) = TREE_TYPE (array_ntn
);
7537 /* Some built-in function calls will be evaluated at compile-time in
7538 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7539 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7540 optimize_sav
= optimize
;
7541 if (!optimize
&& fndecl
&& DECL_IS_BUILTIN_CONSTANT_P (fndecl
)
7542 && current_function_decl
7543 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
7545 fn
= fold_if_not_in_template (fn
);
7546 optimize
= optimize_sav
;
7548 if (VOID_TYPE_P (TREE_TYPE (fn
)))
7551 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7552 function call is either the operand of a decltype-specifier or the
7553 right operand of a comma operator that is the operand of a
7554 decltype-specifier, a temporary object is not introduced for the
7555 prvalue. The type of the prvalue may be incomplete. */
7556 if (!(complain
& tf_decltype
))
7558 fn
= require_complete_type_sfinae (fn
, complain
);
7559 if (fn
== error_mark_node
)
7560 return error_mark_node
;
7562 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
7563 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
7565 return convert_from_reference (fn
);
7568 static GTY(()) tree java_iface_lookup_fn
;
7570 /* Make an expression which yields the address of the Java interface
7571 method FN. This is achieved by generating a call to libjava's
7572 _Jv_LookupInterfaceMethodIdx(). */
7575 build_java_interface_fn_ref (tree fn
, tree instance
)
7577 tree lookup_fn
, method
, idx
;
7578 tree klass_ref
, iface
, iface_ref
;
7581 if (!java_iface_lookup_fn
)
7583 tree ftype
= build_function_type_list (ptr_type_node
,
7584 ptr_type_node
, ptr_type_node
,
7585 java_int_type_node
, NULL_TREE
);
7586 java_iface_lookup_fn
7587 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype
,
7588 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
7591 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7592 This is the first entry in the vtable. */
7593 klass_ref
= build_vtbl_ref (cp_build_indirect_ref (instance
, RO_NULL
,
7594 tf_warning_or_error
),
7597 /* Get the java.lang.Class pointer for the interface being called. */
7598 iface
= DECL_CONTEXT (fn
);
7599 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
7600 if (!iface_ref
|| !VAR_P (iface_ref
)
7601 || DECL_CONTEXT (iface_ref
) != iface
)
7603 error ("could not find class$ field in java interface type %qT",
7605 return error_mark_node
;
7607 iface_ref
= build_address (iface_ref
);
7608 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
7610 /* Determine the itable index of FN. */
7612 for (method
= TYPE_METHODS (iface
); method
; method
= DECL_CHAIN (method
))
7614 if (!DECL_VIRTUAL_P (method
))
7620 idx
= build_int_cst (NULL_TREE
, i
);
7622 lookup_fn
= build1 (ADDR_EXPR
,
7623 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
7624 java_iface_lookup_fn
);
7625 return build_call_nary (ptr_type_node
, lookup_fn
,
7626 3, klass_ref
, iface_ref
, idx
);
7629 /* Returns the value to use for the in-charge parameter when making a
7630 call to a function with the indicated NAME.
7632 FIXME:Can't we find a neater way to do this mapping? */
7635 in_charge_arg_for_name (tree name
)
7637 if (name
== base_ctor_identifier
7638 || name
== base_dtor_identifier
)
7639 return integer_zero_node
;
7640 else if (name
== complete_ctor_identifier
)
7641 return integer_one_node
;
7642 else if (name
== complete_dtor_identifier
)
7643 return integer_two_node
;
7644 else if (name
== deleting_dtor_identifier
)
7645 return integer_three_node
;
7647 /* This function should only be called with one of the names listed
7653 /* Build a call to a constructor, destructor, or an assignment
7654 operator for INSTANCE, an expression with class type. NAME
7655 indicates the special member function to call; *ARGS are the
7656 arguments. ARGS may be NULL. This may change ARGS. BINFO
7657 indicates the base of INSTANCE that is to be passed as the `this'
7658 parameter to the member function called.
7660 FLAGS are the LOOKUP_* flags to use when processing the call.
7662 If NAME indicates a complete object constructor, INSTANCE may be
7663 NULL_TREE. In this case, the caller will call build_cplus_new to
7664 store the newly constructed object into a VAR_DECL. */
7667 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
7668 tree binfo
, int flags
, tsubst_flags_t complain
)
7671 /* The type of the subobject to be constructed or destroyed. */
7673 vec
<tree
, va_gc
> *allocated
= NULL
;
7676 gcc_assert (name
== complete_ctor_identifier
7677 || name
== base_ctor_identifier
7678 || name
== complete_dtor_identifier
7679 || name
== base_dtor_identifier
7680 || name
== deleting_dtor_identifier
7681 || name
== ansi_assopname (NOP_EXPR
));
7684 /* Resolve the name. */
7685 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
7686 return error_mark_node
;
7688 binfo
= TYPE_BINFO (binfo
);
7691 gcc_assert (binfo
!= NULL_TREE
);
7693 class_type
= BINFO_TYPE (binfo
);
7695 /* Handle the special case where INSTANCE is NULL_TREE. */
7696 if (name
== complete_ctor_identifier
&& !instance
)
7697 instance
= build_dummy_object (class_type
);
7700 if (name
== complete_dtor_identifier
7701 || name
== base_dtor_identifier
7702 || name
== deleting_dtor_identifier
)
7703 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
7705 /* Convert to the base class, if necessary. */
7706 if (!same_type_ignoring_top_level_qualifiers_p
7707 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
7709 if (name
!= ansi_assopname (NOP_EXPR
))
7710 /* For constructors and destructors, either the base is
7711 non-virtual, or it is virtual but we are doing the
7712 conversion from a constructor or destructor for the
7713 complete object. In either case, we can convert
7715 instance
= convert_to_base_statically (instance
, binfo
);
7717 /* However, for assignment operators, we must convert
7718 dynamically if the base is virtual. */
7719 instance
= build_base_path (PLUS_EXPR
, instance
,
7720 binfo
, /*nonnull=*/1, complain
);
7724 gcc_assert (instance
!= NULL_TREE
);
7726 fns
= lookup_fnfields (binfo
, name
, 1);
7728 /* When making a call to a constructor or destructor for a subobject
7729 that uses virtual base classes, pass down a pointer to a VTT for
7731 if ((name
== base_ctor_identifier
7732 || name
== base_dtor_identifier
)
7733 && CLASSTYPE_VBASECLASSES (class_type
))
7738 /* If the current function is a complete object constructor
7739 or destructor, then we fetch the VTT directly.
7740 Otherwise, we look it up using the VTT we were given. */
7741 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
7742 vtt
= decay_conversion (vtt
, complain
);
7743 if (vtt
== error_mark_node
)
7744 return error_mark_node
;
7745 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
7746 build2 (EQ_EXPR
, boolean_type_node
,
7747 current_in_charge_parm
, integer_zero_node
),
7750 if (BINFO_SUBVTT_INDEX (binfo
))
7751 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
7757 allocated
= make_tree_vector ();
7761 vec_safe_insert (*args
, 0, sub_vtt
);
7764 ret
= build_new_method_call (instance
, fns
, args
,
7765 TYPE_BINFO (BINFO_TYPE (binfo
)),
7769 if (allocated
!= NULL
)
7770 release_tree_vector (allocated
);
7772 if ((complain
& tf_error
)
7773 && (flags
& LOOKUP_DELEGATING_CONS
)
7774 && name
== complete_ctor_identifier
7775 && TREE_CODE (ret
) == CALL_EXPR
7776 && (DECL_ABSTRACT_ORIGIN (TREE_OPERAND (CALL_EXPR_FN (ret
), 0))
7777 == current_function_decl
))
7778 error ("constructor delegates to itself");
7783 /* Return the NAME, as a C string. The NAME indicates a function that
7784 is a member of TYPE. *FREE_P is set to true if the caller must
7785 free the memory returned.
7787 Rather than go through all of this, we should simply set the names
7788 of constructors and destructors appropriately, and dispense with
7789 ctor_identifier, dtor_identifier, etc. */
7792 name_as_c_string (tree name
, tree type
, bool *free_p
)
7796 /* Assume that we will not allocate memory. */
7798 /* Constructors and destructors are special. */
7799 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7802 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
7803 /* For a destructor, add the '~'. */
7804 if (name
== complete_dtor_identifier
7805 || name
== base_dtor_identifier
7806 || name
== deleting_dtor_identifier
)
7808 pretty_name
= concat ("~", pretty_name
, NULL
);
7809 /* Remember that we need to free the memory allocated. */
7813 else if (IDENTIFIER_TYPENAME_P (name
))
7815 pretty_name
= concat ("operator ",
7816 type_as_string_translate (TREE_TYPE (name
),
7817 TFF_PLAIN_IDENTIFIER
),
7819 /* Remember that we need to free the memory allocated. */
7823 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
7828 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
7829 be set, upon return, to the function called. ARGS may be NULL.
7830 This may change ARGS. */
7833 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
7834 tree conversion_path
, int flags
,
7835 tree
*fn_p
, tsubst_flags_t complain
)
7837 struct z_candidate
*candidates
= 0, *cand
;
7838 tree explicit_targs
= NULL_TREE
;
7839 tree basetype
= NULL_TREE
;
7840 tree access_binfo
, binfo
;
7842 tree first_mem_arg
= NULL_TREE
;
7844 bool skip_first_for_error
;
7845 vec
<tree
, va_gc
> *user_args
;
7848 int template_only
= 0;
7852 vec
<tree
, va_gc
> *orig_args
= NULL
;
7855 gcc_assert (instance
!= NULL_TREE
);
7857 /* We don't know what function we're going to call, yet. */
7861 if (error_operand_p (instance
)
7862 || !fns
|| error_operand_p (fns
))
7863 return error_mark_node
;
7865 if (!BASELINK_P (fns
))
7867 if (complain
& tf_error
)
7868 error ("call to non-function %qD", fns
);
7869 return error_mark_node
;
7872 orig_instance
= instance
;
7875 /* Dismantle the baselink to collect all the information we need. */
7876 if (!conversion_path
)
7877 conversion_path
= BASELINK_BINFO (fns
);
7878 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
7879 binfo
= BASELINK_BINFO (fns
);
7880 optype
= BASELINK_OPTYPE (fns
);
7881 fns
= BASELINK_FUNCTIONS (fns
);
7882 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
7884 explicit_targs
= TREE_OPERAND (fns
, 1);
7885 fns
= TREE_OPERAND (fns
, 0);
7888 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
7889 || TREE_CODE (fns
) == TEMPLATE_DECL
7890 || TREE_CODE (fns
) == OVERLOAD
);
7891 fn
= get_first_fn (fns
);
7892 name
= DECL_NAME (fn
);
7894 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
7895 gcc_assert (CLASS_TYPE_P (basetype
));
7897 if (processing_template_decl
)
7899 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
7900 instance
= build_non_dependent_expr (instance
);
7902 make_args_non_dependent (*args
);
7905 user_args
= args
== NULL
? NULL
: *args
;
7906 /* Under DR 147 A::A() is an invalid constructor call,
7907 not a functional cast. */
7908 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
7910 if (! (complain
& tf_error
))
7911 return error_mark_node
;
7913 if (permerror (input_location
,
7914 "cannot call constructor %<%T::%D%> directly",
7916 inform (input_location
, "for a function-style cast, remove the "
7917 "redundant %<::%D%>", name
);
7918 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
7923 /* Figure out whether to skip the first argument for the error
7924 message we will display to users if an error occurs. We don't
7925 want to display any compiler-generated arguments. The "this"
7926 pointer hasn't been added yet. However, we must remove the VTT
7927 pointer if this is a call to a base-class constructor or
7929 skip_first_for_error
= false;
7930 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7932 /* Callers should explicitly indicate whether they want to construct
7933 the complete object or just the part without virtual bases. */
7934 gcc_assert (name
!= ctor_identifier
);
7935 /* Similarly for destructors. */
7936 gcc_assert (name
!= dtor_identifier
);
7937 /* Remove the VTT pointer, if present. */
7938 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
7939 && CLASSTYPE_VBASECLASSES (basetype
))
7940 skip_first_for_error
= true;
7943 /* Process the argument list. */
7944 if (args
!= NULL
&& *args
!= NULL
)
7946 *args
= resolve_args (*args
, complain
);
7948 return error_mark_node
;
7951 /* Consider the object argument to be used even if we end up selecting a
7952 static member function. */
7953 instance
= mark_type_use (instance
);
7955 /* It's OK to call destructors and constructors on cv-qualified objects.
7956 Therefore, convert the INSTANCE to the unqualified type, if
7958 if (DECL_DESTRUCTOR_P (fn
)
7959 || DECL_CONSTRUCTOR_P (fn
))
7961 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
7963 instance
= build_this (instance
);
7964 instance
= build_nop (build_pointer_type (basetype
), instance
);
7965 instance
= build_fold_indirect_ref (instance
);
7968 if (DECL_DESTRUCTOR_P (fn
))
7969 name
= complete_dtor_identifier
;
7971 /* For the overload resolution we need to find the actual `this`
7972 that would be captured if the call turns out to be to a
7973 non-static member function. Do not actually capture it at this
7975 first_mem_arg
= maybe_resolve_dummy (instance
, false);
7977 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7978 p
= conversion_obstack_alloc (0);
7980 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
7981 initializer, not T({ }). */
7982 if (DECL_CONSTRUCTOR_P (fn
) && args
!= NULL
&& !vec_safe_is_empty (*args
)
7983 && DIRECT_LIST_INIT_P ((**args
)[0]))
7985 tree init_list
= (**args
)[0];
7986 tree init
= NULL_TREE
;
7988 gcc_assert ((*args
)->length () == 1
7989 && !(flags
& LOOKUP_ONLYCONVERTING
));
7991 /* If the initializer list has no elements and T is a class type with
7992 a default constructor, the object is value-initialized. Handle
7993 this here so we don't need to handle it wherever we use
7994 build_special_member_call. */
7995 if (CONSTRUCTOR_NELTS (init_list
) == 0
7996 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
7997 /* For a user-provided default constructor, use the normal
7998 mechanisms so that protected access works. */
7999 && type_has_non_user_provided_default_constructor (basetype
)
8000 && !processing_template_decl
)
8001 init
= build_value_init (basetype
, complain
);
8003 /* If BASETYPE is an aggregate, we need to do aggregate
8005 else if (CP_AGGREGATE_TYPE_P (basetype
))
8006 init
= digest_init (basetype
, init_list
, complain
);
8010 if (is_dummy_object (instance
))
8011 return get_target_expr_sfinae (init
, complain
);
8012 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
8013 TREE_SIDE_EFFECTS (init
) = true;
8017 /* Otherwise go ahead with overload resolution. */
8018 add_list_candidates (fns
, first_mem_arg
, init_list
,
8019 basetype
, explicit_targs
, template_only
,
8020 conversion_path
, access_binfo
, flags
,
8021 &candidates
, complain
);
8025 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
8026 explicit_targs
, template_only
, conversion_path
,
8027 access_binfo
, flags
, &candidates
, complain
);
8029 any_viable_p
= false;
8030 candidates
= splice_viable (candidates
, false, &any_viable_p
);
8034 if (complain
& tf_error
)
8036 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
8037 cxx_incomplete_type_error (instance
, basetype
);
8039 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
8040 basetype
, optype
, build_tree_list_vec (user_args
),
8041 TREE_TYPE (instance
));
8048 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8049 arglist
= build_tree_list_vec (user_args
);
8050 if (skip_first_for_error
)
8051 arglist
= TREE_CHAIN (arglist
);
8052 error ("no matching function for call to %<%T::%s(%A)%#V%>",
8053 basetype
, pretty_name
, arglist
,
8054 TREE_TYPE (instance
));
8058 print_z_candidates (location_of (name
), candidates
);
8060 call
= error_mark_node
;
8064 cand
= tourney (candidates
, complain
);
8071 if (complain
& tf_error
)
8073 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8074 arglist
= build_tree_list_vec (user_args
);
8075 if (skip_first_for_error
)
8076 arglist
= TREE_CHAIN (arglist
);
8077 if (!any_strictly_viable (candidates
))
8078 error ("no matching function for call to %<%s(%A)%>",
8079 pretty_name
, arglist
);
8081 error ("call of overloaded %<%s(%A)%> is ambiguous",
8082 pretty_name
, arglist
);
8083 print_z_candidates (location_of (name
), candidates
);
8087 call
= error_mark_node
;
8094 if (!(flags
& LOOKUP_NONVIRTUAL
)
8095 && DECL_PURE_VIRTUAL_P (fn
)
8096 && instance
== current_class_ref
8097 && (complain
& tf_warning
))
8099 /* This is not an error, it is runtime undefined
8101 if (!current_function_decl
)
8102 warning (0, "pure virtual %q#D called from "
8103 "non-static data member initializer", fn
);
8104 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
8105 || DECL_DESTRUCTOR_P (current_function_decl
))
8106 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
8107 ? "pure virtual %q#D called from constructor"
8108 : "pure virtual %q#D called from destructor"),
8112 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
8113 && !DECL_CONSTRUCTOR_P (fn
)
8114 && is_dummy_object (instance
))
8116 instance
= maybe_resolve_dummy (instance
, true);
8117 if (instance
== error_mark_node
)
8118 call
= error_mark_node
;
8119 else if (!is_dummy_object (instance
))
8121 /* We captured 'this' in the current lambda now that
8122 we know we really need it. */
8123 cand
->first_arg
= instance
;
8127 if (complain
& tf_error
)
8128 error ("cannot call member function %qD without object",
8130 call
= error_mark_node
;
8134 if (call
!= error_mark_node
)
8136 /* Optimize away vtable lookup if we know that this
8137 function can't be overridden. We need to check if
8138 the context and the type where we found fn are the same,
8139 actually FN might be defined in a different class
8140 type because of a using-declaration. In this case, we
8141 do not want to perform a non-virtual call. */
8142 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
8143 && same_type_ignoring_top_level_qualifiers_p
8144 (DECL_CONTEXT (fn
), BINFO_TYPE (binfo
))
8145 && resolves_to_fixed_type_p (instance
, 0))
8146 flags
|= LOOKUP_NONVIRTUAL
;
8148 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
8149 /* Now we know what function is being called. */
8152 /* Build the actual CALL_EXPR. */
8153 call
= build_over_call (cand
, flags
, complain
);
8154 /* In an expression of the form `a->f()' where `f' turns
8155 out to be a static member function, `a' is
8156 none-the-less evaluated. */
8157 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
8158 && !is_dummy_object (instance
)
8159 && TREE_SIDE_EFFECTS (instance
))
8160 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
8162 else if (call
!= error_mark_node
8163 && DECL_DESTRUCTOR_P (cand
->fn
)
8164 && !VOID_TYPE_P (TREE_TYPE (call
)))
8165 /* An explicit call of the form "x->~X()" has type
8166 "void". However, on platforms where destructors
8167 return "this" (i.e., those where
8168 targetm.cxx.cdtor_returns_this is true), such calls
8169 will appear to have a return value of pointer type
8170 to the low-level call machinery. We do not want to
8171 change the low-level machinery, since we want to be
8172 able to optimize "delete f()" on such platforms as
8173 "operator delete(~X(f()))" (rather than generating
8174 "t = f(), ~X(t), operator delete (t)"). */
8175 call
= build_nop (void_type_node
, call
);
8180 if (processing_template_decl
&& call
!= error_mark_node
)
8182 bool cast_to_void
= false;
8184 if (TREE_CODE (call
) == COMPOUND_EXPR
)
8185 call
= TREE_OPERAND (call
, 1);
8186 else if (TREE_CODE (call
) == NOP_EXPR
)
8188 cast_to_void
= true;
8189 call
= TREE_OPERAND (call
, 0);
8191 if (INDIRECT_REF_P (call
))
8192 call
= TREE_OPERAND (call
, 0);
8193 call
= (build_min_non_dep_call_vec
8195 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
8196 orig_instance
, orig_fns
, NULL_TREE
),
8198 SET_EXPR_LOCATION (call
, input_location
);
8199 call
= convert_from_reference (call
);
8201 call
= build_nop (void_type_node
, call
);
8204 /* Free all the conversions we allocated. */
8205 obstack_free (&conversion_obstack
, p
);
8207 if (orig_args
!= NULL
)
8208 release_tree_vector (orig_args
);
8213 /* Wrapper for above. */
8216 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8217 tree conversion_path
, int flags
,
8218 tree
*fn_p
, tsubst_flags_t complain
)
8221 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
8222 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
8224 timevar_cond_stop (TV_OVERLOAD
, subtime
);
8228 /* Returns true iff standard conversion sequence ICS1 is a proper
8229 subsequence of ICS2. */
8232 is_subseq (conversion
*ics1
, conversion
*ics2
)
8234 /* We can assume that a conversion of the same code
8235 between the same types indicates a subsequence since we only get
8236 here if the types we are converting from are the same. */
8238 while (ics1
->kind
== ck_rvalue
8239 || ics1
->kind
== ck_lvalue
)
8240 ics1
= next_conversion (ics1
);
8244 while (ics2
->kind
== ck_rvalue
8245 || ics2
->kind
== ck_lvalue
)
8246 ics2
= next_conversion (ics2
);
8248 if (ics2
->kind
== ck_user
8249 || ics2
->kind
== ck_ambig
8250 || ics2
->kind
== ck_aggr
8251 || ics2
->kind
== ck_list
8252 || ics2
->kind
== ck_identity
)
8253 /* At this point, ICS1 cannot be a proper subsequence of
8254 ICS2. We can get a USER_CONV when we are comparing the
8255 second standard conversion sequence of two user conversion
8259 ics2
= next_conversion (ics2
);
8261 if (ics2
->kind
== ics1
->kind
8262 && same_type_p (ics2
->type
, ics1
->type
)
8263 && same_type_p (next_conversion (ics2
)->type
,
8264 next_conversion (ics1
)->type
))
8269 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
8270 be any _TYPE nodes. */
8273 is_properly_derived_from (tree derived
, tree base
)
8275 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
8278 /* We only allow proper derivation here. The DERIVED_FROM_P macro
8279 considers every class derived from itself. */
8280 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
8281 && DERIVED_FROM_P (base
, derived
));
8284 /* We build the ICS for an implicit object parameter as a pointer
8285 conversion sequence. However, such a sequence should be compared
8286 as if it were a reference conversion sequence. If ICS is the
8287 implicit conversion sequence for an implicit object parameter,
8288 modify it accordingly. */
8291 maybe_handle_implicit_object (conversion
**ics
)
8295 /* [over.match.funcs]
8297 For non-static member functions, the type of the
8298 implicit object parameter is "reference to cv X"
8299 where X is the class of which the function is a
8300 member and cv is the cv-qualification on the member
8301 function declaration. */
8302 conversion
*t
= *ics
;
8303 tree reference_type
;
8305 /* The `this' parameter is a pointer to a class type. Make the
8306 implicit conversion talk about a reference to that same class
8308 reference_type
= TREE_TYPE (t
->type
);
8309 reference_type
= build_reference_type (reference_type
);
8311 if (t
->kind
== ck_qual
)
8312 t
= next_conversion (t
);
8313 if (t
->kind
== ck_ptr
)
8314 t
= next_conversion (t
);
8315 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
8316 t
= direct_reference_binding (reference_type
, t
);
8318 t
->rvaluedness_matches_p
= 0;
8323 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
8324 and return the initial reference binding conversion. Otherwise,
8325 leave *ICS unchanged and return NULL. */
8328 maybe_handle_ref_bind (conversion
**ics
)
8330 if ((*ics
)->kind
== ck_ref_bind
)
8332 conversion
*old_ics
= *ics
;
8333 *ics
= next_conversion (old_ics
);
8334 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
8341 /* Compare two implicit conversion sequences according to the rules set out in
8342 [over.ics.rank]. Return values:
8344 1: ics1 is better than ics2
8345 -1: ics2 is better than ics1
8346 0: ics1 and ics2 are indistinguishable */
8349 compare_ics (conversion
*ics1
, conversion
*ics2
)
8355 tree deref_from_type1
= NULL_TREE
;
8356 tree deref_from_type2
= NULL_TREE
;
8357 tree deref_to_type1
= NULL_TREE
;
8358 tree deref_to_type2
= NULL_TREE
;
8359 conversion_rank rank1
, rank2
;
8361 /* REF_BINDING is nonzero if the result of the conversion sequence
8362 is a reference type. In that case REF_CONV is the reference
8363 binding conversion. */
8364 conversion
*ref_conv1
;
8365 conversion
*ref_conv2
;
8367 /* Compare badness before stripping the reference conversion. */
8368 if (ics1
->bad_p
> ics2
->bad_p
)
8370 else if (ics1
->bad_p
< ics2
->bad_p
)
8373 /* Handle implicit object parameters. */
8374 maybe_handle_implicit_object (&ics1
);
8375 maybe_handle_implicit_object (&ics2
);
8377 /* Handle reference parameters. */
8378 ref_conv1
= maybe_handle_ref_bind (&ics1
);
8379 ref_conv2
= maybe_handle_ref_bind (&ics2
);
8381 /* List-initialization sequence L1 is a better conversion sequence than
8382 list-initialization sequence L2 if L1 converts to
8383 std::initializer_list<X> for some X and L2 does not. */
8384 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
8386 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
8391 When comparing the basic forms of implicit conversion sequences (as
8392 defined in _over.best.ics_)
8394 --a standard conversion sequence (_over.ics.scs_) is a better
8395 conversion sequence than a user-defined conversion sequence
8396 or an ellipsis conversion sequence, and
8398 --a user-defined conversion sequence (_over.ics.user_) is a
8399 better conversion sequence than an ellipsis conversion sequence
8400 (_over.ics.ellipsis_). */
8401 /* Use BAD_CONVERSION_RANK because we already checked for a badness
8402 mismatch. If both ICS are bad, we try to make a decision based on
8403 what would have happened if they'd been good. This is not an
8404 extension, we'll still give an error when we build up the call; this
8405 just helps us give a more helpful error message. */
8406 rank1
= BAD_CONVERSION_RANK (ics1
);
8407 rank2
= BAD_CONVERSION_RANK (ics2
);
8411 else if (rank1
< rank2
)
8414 if (ics1
->ellipsis_p
)
8415 /* Both conversions are ellipsis conversions. */
8418 /* User-defined conversion sequence U1 is a better conversion sequence
8419 than another user-defined conversion sequence U2 if they contain the
8420 same user-defined conversion operator or constructor and if the sec-
8421 ond standard conversion sequence of U1 is better than the second
8422 standard conversion sequence of U2. */
8424 /* Handle list-conversion with the same code even though it isn't always
8425 ranked as a user-defined conversion and it doesn't have a second
8426 standard conversion sequence; it will still have the desired effect.
8427 Specifically, we need to do the reference binding comparison at the
8428 end of this function. */
8430 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
8435 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
8436 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
8437 || t1
->kind
== ck_list
)
8439 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
8440 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
8441 || t2
->kind
== ck_list
)
8444 if (t1
->kind
!= t2
->kind
)
8446 else if (t1
->kind
== ck_user
)
8448 if (t1
->cand
->fn
!= t2
->cand
->fn
)
8453 /* For ambiguous or aggregate conversions, use the target type as
8454 a proxy for the conversion function. */
8455 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
8459 /* We can just fall through here, after setting up
8460 FROM_TYPE1 and FROM_TYPE2. */
8461 from_type1
= t1
->type
;
8462 from_type2
= t2
->type
;
8469 /* We're dealing with two standard conversion sequences.
8473 Standard conversion sequence S1 is a better conversion
8474 sequence than standard conversion sequence S2 if
8476 --S1 is a proper subsequence of S2 (comparing the conversion
8477 sequences in the canonical form defined by _over.ics.scs_,
8478 excluding any Lvalue Transformation; the identity
8479 conversion sequence is considered to be a subsequence of
8480 any non-identity conversion sequence */
8483 while (t1
->kind
!= ck_identity
)
8484 t1
= next_conversion (t1
);
8485 from_type1
= t1
->type
;
8488 while (t2
->kind
!= ck_identity
)
8489 t2
= next_conversion (t2
);
8490 from_type2
= t2
->type
;
8493 /* One sequence can only be a subsequence of the other if they start with
8494 the same type. They can start with different types when comparing the
8495 second standard conversion sequence in two user-defined conversion
8497 if (same_type_p (from_type1
, from_type2
))
8499 if (is_subseq (ics1
, ics2
))
8501 if (is_subseq (ics2
, ics1
))
8509 --the rank of S1 is better than the rank of S2 (by the rules
8512 Standard conversion sequences are ordered by their ranks: an Exact
8513 Match is a better conversion than a Promotion, which is a better
8514 conversion than a Conversion.
8516 Two conversion sequences with the same rank are indistinguishable
8517 unless one of the following rules applies:
8519 --A conversion that does not a convert a pointer, pointer to member,
8520 or std::nullptr_t to bool is better than one that does.
8522 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8523 so that we do not have to check it explicitly. */
8524 if (ics1
->rank
< ics2
->rank
)
8526 else if (ics2
->rank
< ics1
->rank
)
8529 to_type1
= ics1
->type
;
8530 to_type2
= ics2
->type
;
8532 /* A conversion from scalar arithmetic type to complex is worse than a
8533 conversion between scalar arithmetic types. */
8534 if (same_type_p (from_type1
, from_type2
)
8535 && ARITHMETIC_TYPE_P (from_type1
)
8536 && ARITHMETIC_TYPE_P (to_type1
)
8537 && ARITHMETIC_TYPE_P (to_type2
)
8538 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8539 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
8541 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8547 if (TYPE_PTR_P (from_type1
)
8548 && TYPE_PTR_P (from_type2
)
8549 && TYPE_PTR_P (to_type1
)
8550 && TYPE_PTR_P (to_type2
))
8552 deref_from_type1
= TREE_TYPE (from_type1
);
8553 deref_from_type2
= TREE_TYPE (from_type2
);
8554 deref_to_type1
= TREE_TYPE (to_type1
);
8555 deref_to_type2
= TREE_TYPE (to_type2
);
8557 /* The rules for pointers to members A::* are just like the rules
8558 for pointers A*, except opposite: if B is derived from A then
8559 A::* converts to B::*, not vice versa. For that reason, we
8560 switch the from_ and to_ variables here. */
8561 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
8562 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
8563 || (TYPE_PTRMEMFUNC_P (from_type1
)
8564 && TYPE_PTRMEMFUNC_P (from_type2
)
8565 && TYPE_PTRMEMFUNC_P (to_type1
)
8566 && TYPE_PTRMEMFUNC_P (to_type2
)))
8568 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
8569 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
8570 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
8571 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
8574 if (deref_from_type1
!= NULL_TREE
8575 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
8576 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
8578 /* This was one of the pointer or pointer-like conversions.
8582 --If class B is derived directly or indirectly from class A,
8583 conversion of B* to A* is better than conversion of B* to
8584 void*, and conversion of A* to void* is better than
8585 conversion of B* to void*. */
8586 if (VOID_TYPE_P (deref_to_type1
)
8587 && VOID_TYPE_P (deref_to_type2
))
8589 if (is_properly_derived_from (deref_from_type1
,
8592 else if (is_properly_derived_from (deref_from_type2
,
8596 else if (VOID_TYPE_P (deref_to_type1
)
8597 || VOID_TYPE_P (deref_to_type2
))
8599 if (same_type_p (deref_from_type1
, deref_from_type2
))
8601 if (VOID_TYPE_P (deref_to_type2
))
8603 if (is_properly_derived_from (deref_from_type1
,
8607 /* We know that DEREF_TO_TYPE1 is `void' here. */
8608 else if (is_properly_derived_from (deref_from_type1
,
8613 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
8614 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
8618 --If class B is derived directly or indirectly from class A
8619 and class C is derived directly or indirectly from B,
8621 --conversion of C* to B* is better than conversion of C* to
8624 --conversion of B* to A* is better than conversion of C* to
8626 if (same_type_p (deref_from_type1
, deref_from_type2
))
8628 if (is_properly_derived_from (deref_to_type1
,
8631 else if (is_properly_derived_from (deref_to_type2
,
8635 else if (same_type_p (deref_to_type1
, deref_to_type2
))
8637 if (is_properly_derived_from (deref_from_type2
,
8640 else if (is_properly_derived_from (deref_from_type1
,
8646 else if (CLASS_TYPE_P (non_reference (from_type1
))
8647 && same_type_p (from_type1
, from_type2
))
8649 tree from
= non_reference (from_type1
);
8653 --binding of an expression of type C to a reference of type
8654 B& is better than binding an expression of type C to a
8655 reference of type A&
8657 --conversion of C to B is better than conversion of C to A, */
8658 if (is_properly_derived_from (from
, to_type1
)
8659 && is_properly_derived_from (from
, to_type2
))
8661 if (is_properly_derived_from (to_type1
, to_type2
))
8663 else if (is_properly_derived_from (to_type2
, to_type1
))
8667 else if (CLASS_TYPE_P (non_reference (to_type1
))
8668 && same_type_p (to_type1
, to_type2
))
8670 tree to
= non_reference (to_type1
);
8674 --binding of an expression of type B to a reference of type
8675 A& is better than binding an expression of type C to a
8676 reference of type A&,
8678 --conversion of B to A is better than conversion of C to A */
8679 if (is_properly_derived_from (from_type1
, to
)
8680 && is_properly_derived_from (from_type2
, to
))
8682 if (is_properly_derived_from (from_type2
, from_type1
))
8684 else if (is_properly_derived_from (from_type1
, from_type2
))
8691 --S1 and S2 differ only in their qualification conversion and yield
8692 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8693 qualification signature of type T1 is a proper subset of the cv-
8694 qualification signature of type T2 */
8695 if (ics1
->kind
== ck_qual
8696 && ics2
->kind
== ck_qual
8697 && same_type_p (from_type1
, from_type2
))
8699 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
8706 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8707 to an implicit object parameter of a non-static member function
8708 declared without a ref-qualifier, and either S1 binds an lvalue
8709 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
8710 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
8711 draft standard, 13.3.3.2)
8713 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8714 types to which the references refer are the same type except for
8715 top-level cv-qualifiers, and the type to which the reference
8716 initialized by S2 refers is more cv-qualified than the type to
8717 which the reference initialized by S1 refers.
8719 DR 1328 [over.match.best]: the context is an initialization by
8720 conversion function for direct reference binding (13.3.1.6) of a
8721 reference to function type, the return type of F1 is the same kind of
8722 reference (i.e. lvalue or rvalue) as the reference being initialized,
8723 and the return type of F2 is not. */
8725 if (ref_conv1
&& ref_conv2
)
8727 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
8728 && (ref_conv1
->rvaluedness_matches_p
8729 != ref_conv2
->rvaluedness_matches_p
)
8730 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
8731 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
8732 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
8734 if (ref_conv1
->bad_p
8735 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
8736 TREE_TYPE (ref_conv2
->type
)))
8737 /* Don't prefer a bad conversion that drops cv-quals to a bad
8738 conversion with the wrong rvalueness. */
8740 return (ref_conv1
->rvaluedness_matches_p
8741 - ref_conv2
->rvaluedness_matches_p
);
8744 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
8746 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
8747 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
8748 if (ref_conv1
->bad_p
)
8750 /* Prefer the one that drops fewer cv-quals. */
8751 tree ftype
= next_conversion (ref_conv1
)->type
;
8752 int fquals
= cp_type_quals (ftype
);
8756 return comp_cv_qualification (q2
, q1
);
8760 /* Neither conversion sequence is better than the other. */
8764 /* The source type for this standard conversion sequence. */
8767 source_type (conversion
*t
)
8769 for (;; t
= next_conversion (t
))
8771 if (t
->kind
== ck_user
8772 || t
->kind
== ck_ambig
8773 || t
->kind
== ck_identity
)
8779 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8780 a pointer to LOSER and re-running joust to produce the warning if WINNER
8781 is actually used. */
8784 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
8786 candidate_warning
*cw
= (candidate_warning
*)
8787 conversion_obstack_alloc (sizeof (candidate_warning
));
8789 cw
->next
= winner
->warnings
;
8790 winner
->warnings
= cw
;
8793 /* Compare two candidates for overloading as described in
8794 [over.match.best]. Return values:
8796 1: cand1 is better than cand2
8797 -1: cand2 is better than cand1
8798 0: cand1 and cand2 are indistinguishable */
8801 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
8802 tsubst_flags_t complain
)
8805 int off1
= 0, off2
= 0;
8809 /* Candidates that involve bad conversions are always worse than those
8811 if (cand1
->viable
> cand2
->viable
)
8813 if (cand1
->viable
< cand2
->viable
)
8816 /* If we have two pseudo-candidates for conversions to the same type,
8817 or two candidates for the same function, arbitrarily pick one. */
8818 if (cand1
->fn
== cand2
->fn
8819 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
8822 /* Prefer a non-deleted function over an implicitly deleted move
8823 constructor or assignment operator. This differs slightly from the
8824 wording for issue 1402 (which says the move op is ignored by overload
8825 resolution), but this way produces better error messages. */
8826 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
8827 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
8828 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
8830 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
8831 && move_fn_p (cand1
->fn
))
8833 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
8834 && move_fn_p (cand2
->fn
))
8838 /* a viable function F1
8839 is defined to be a better function than another viable function F2 if
8840 for all arguments i, ICSi(F1) is not a worse conversion sequence than
8841 ICSi(F2), and then */
8843 /* for some argument j, ICSj(F1) is a better conversion sequence than
8846 /* For comparing static and non-static member functions, we ignore
8847 the implicit object parameter of the non-static function. The
8848 standard says to pretend that the static function has an object
8849 parm, but that won't work with operator overloading. */
8850 len
= cand1
->num_convs
;
8851 if (len
!= cand2
->num_convs
)
8853 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
8854 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
8856 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
8857 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
8858 /* We're comparing a near-match list constructor and a near-match
8859 non-list constructor. Just treat them as unordered. */
8862 gcc_assert (static_1
!= static_2
);
8873 for (i
= 0; i
< len
; ++i
)
8875 conversion
*t1
= cand1
->convs
[i
+ off1
];
8876 conversion
*t2
= cand2
->convs
[i
+ off2
];
8877 int comp
= compare_ics (t1
, t2
);
8881 if ((complain
& tf_warning
)
8883 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
8884 == cr_std
+ cr_promotion
)
8885 && t1
->kind
== ck_std
8886 && t2
->kind
== ck_std
8887 && TREE_CODE (t1
->type
) == INTEGER_TYPE
8888 && TREE_CODE (t2
->type
) == INTEGER_TYPE
8889 && (TYPE_PRECISION (t1
->type
)
8890 == TYPE_PRECISION (t2
->type
))
8891 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
8892 || (TREE_CODE (next_conversion (t1
)->type
)
8895 tree type
= next_conversion (t1
)->type
;
8897 struct z_candidate
*w
, *l
;
8899 type1
= t1
->type
, type2
= t2
->type
,
8900 w
= cand1
, l
= cand2
;
8902 type1
= t2
->type
, type2
= t1
->type
,
8903 w
= cand2
, l
= cand1
;
8907 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
8908 type
, type1
, type2
);
8909 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
8915 if (winner
&& comp
!= winner
)
8924 /* warn about confusing overload resolution for user-defined conversions,
8925 either between a constructor and a conversion op, or between two
8927 if ((complain
& tf_warning
)
8928 && winner
&& warn_conversion
&& cand1
->second_conv
8929 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
8930 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
8932 struct z_candidate
*w
, *l
;
8933 bool give_warning
= false;
8936 w
= cand1
, l
= cand2
;
8938 w
= cand2
, l
= cand1
;
8940 /* We don't want to complain about `X::operator T1 ()'
8941 beating `X::operator T2 () const', when T2 is a no less
8942 cv-qualified version of T1. */
8943 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
8944 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
8946 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
8947 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
8949 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
8954 if (!comp_ptr_ttypes (t
, f
))
8955 give_warning
= true;
8958 give_warning
= true;
8964 tree source
= source_type (w
->convs
[0]);
8965 if (! DECL_CONSTRUCTOR_P (w
->fn
))
8966 source
= TREE_TYPE (source
);
8967 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
8968 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
8969 source
, w
->second_conv
->type
))
8971 inform (input_location
, " because conversion sequence for the argument is better");
8981 /* DR 495 moved this tiebreaker above the template ones. */
8983 the context is an initialization by user-defined conversion (see
8984 _dcl.init_ and _over.match.user_) and the standard conversion
8985 sequence from the return type of F1 to the destination type (i.e.,
8986 the type of the entity being initialized) is a better conversion
8987 sequence than the standard conversion sequence from the return type
8988 of F2 to the destination type. */
8990 if (cand1
->second_conv
)
8992 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
8998 F1 is a non-template function and F2 is a template function
9001 if (!cand1
->template_decl
&& cand2
->template_decl
)
9003 else if (cand1
->template_decl
&& !cand2
->template_decl
)
9007 F1 and F2 are template functions and the function template for F1 is
9008 more specialized than the template for F2 according to the partial
9011 if (cand1
->template_decl
&& cand2
->template_decl
)
9013 winner
= more_specialized_fn
9014 (TI_TEMPLATE (cand1
->template_decl
),
9015 TI_TEMPLATE (cand2
->template_decl
),
9016 /* [temp.func.order]: The presence of unused ellipsis and default
9017 arguments has no effect on the partial ordering of function
9018 templates. add_function_candidate() will not have
9019 counted the "this" argument for constructors. */
9020 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
9025 /* Check whether we can discard a builtin candidate, either because we
9026 have two identical ones or matching builtin and non-builtin candidates.
9028 (Pedantically in the latter case the builtin which matched the user
9029 function should not be added to the overload set, but we spot it here.
9032 ... the builtin candidates include ...
9033 - do not have the same parameter type list as any non-template
9034 non-member candidate. */
9036 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
9038 for (i
= 0; i
< len
; ++i
)
9039 if (!same_type_p (cand1
->convs
[i
]->type
,
9040 cand2
->convs
[i
]->type
))
9042 if (i
== cand1
->num_convs
)
9044 if (cand1
->fn
== cand2
->fn
)
9045 /* Two built-in candidates; arbitrarily pick one. */
9047 else if (identifier_p (cand1
->fn
))
9048 /* cand1 is built-in; prefer cand2. */
9051 /* cand2 is built-in; prefer cand1. */
9056 /* For candidates of a multi-versioned function, make the version with
9057 the highest priority win. This version will be checked for dispatching
9058 first. If this version can be inlined into the caller, the front-end
9059 will simply make a direct call to this function. */
9061 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9062 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
9063 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9064 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
9066 tree f1
= TREE_TYPE (cand1
->fn
);
9067 tree f2
= TREE_TYPE (cand2
->fn
);
9068 tree p1
= TYPE_ARG_TYPES (f1
);
9069 tree p2
= TYPE_ARG_TYPES (f2
);
9071 /* Check if cand1->fn and cand2->fn are versions of the same function. It
9072 is possible that cand1->fn and cand2->fn are function versions but of
9073 different functions. Check types to see if they are versions of the same
9075 if (compparms (p1
, p2
)
9076 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
9078 /* Always make the version with the higher priority, more
9079 specialized, win. */
9080 gcc_assert (targetm
.compare_version_priority
);
9081 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
9088 /* If the two function declarations represent the same function (this can
9089 happen with declarations in multiple scopes and arg-dependent lookup),
9090 arbitrarily choose one. But first make sure the default args we're
9092 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
9093 && equal_functions (cand1
->fn
, cand2
->fn
))
9095 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
9096 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
9098 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
9100 for (i
= 0; i
< len
; ++i
)
9102 /* Don't crash if the fn is variadic. */
9105 parms1
= TREE_CHAIN (parms1
);
9106 parms2
= TREE_CHAIN (parms2
);
9110 parms1
= TREE_CHAIN (parms1
);
9112 parms2
= TREE_CHAIN (parms2
);
9116 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
9117 TREE_PURPOSE (parms2
)))
9121 if (complain
& tf_error
)
9123 if (permerror (input_location
,
9124 "default argument mismatch in "
9125 "overload resolution"))
9127 inform (input_location
,
9128 " candidate 1: %q+#F", cand1
->fn
);
9129 inform (input_location
,
9130 " candidate 2: %q+#F", cand2
->fn
);
9137 add_warning (cand1
, cand2
);
9140 parms1
= TREE_CHAIN (parms1
);
9141 parms2
= TREE_CHAIN (parms2
);
9149 /* Extension: If the worst conversion for one candidate is worse than the
9150 worst conversion for the other, take the first. */
9151 if (!pedantic
&& (complain
& tf_warning_or_error
))
9153 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
9154 struct z_candidate
*w
= 0, *l
= 0;
9156 for (i
= 0; i
< len
; ++i
)
9158 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
9159 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
9160 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
9161 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
9164 winner
= 1, w
= cand1
, l
= cand2
;
9166 winner
= -1, w
= cand2
, l
= cand1
;
9169 /* Don't choose a deleted function over ambiguity. */
9170 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
9174 pedwarn (input_location
, 0,
9175 "ISO C++ says that these are ambiguous, even "
9176 "though the worst conversion for the first is better than "
9177 "the worst conversion for the second:");
9178 print_z_candidate (input_location
, _("candidate 1:"), w
);
9179 print_z_candidate (input_location
, _("candidate 2:"), l
);
9187 gcc_assert (!winner
);
9191 /* Given a list of candidates for overloading, find the best one, if any.
9192 This algorithm has a worst case of O(2n) (winner is last), and a best
9193 case of O(n/2) (totally ambiguous); much better than a sorting
9196 static struct z_candidate
*
9197 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
9199 struct z_candidate
*champ
= candidates
, *challenger
;
9201 int champ_compared_to_predecessor
= 0;
9203 /* Walk through the list once, comparing each current champ to the next
9204 candidate, knocking out a candidate or two with each comparison. */
9206 for (challenger
= champ
->next
; challenger
; )
9208 fate
= joust (champ
, challenger
, 0, complain
);
9210 challenger
= challenger
->next
;
9215 champ
= challenger
->next
;
9218 champ_compared_to_predecessor
= 0;
9223 champ_compared_to_predecessor
= 1;
9226 challenger
= champ
->next
;
9230 /* Make sure the champ is better than all the candidates it hasn't yet
9231 been compared to. */
9233 for (challenger
= candidates
;
9235 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
9236 challenger
= challenger
->next
)
9238 fate
= joust (champ
, challenger
, 0, complain
);
9246 /* Returns nonzero if things of type FROM can be converted to TO. */
9249 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
9251 tree arg
= NULL_TREE
;
9252 /* implicit_conversion only considers user-defined conversions
9253 if it has an expression for the call argument list. */
9254 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
9255 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
9256 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
9259 /* Returns nonzero if things of type FROM can be converted to TO with a
9260 standard conversion. */
9263 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
9265 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
9268 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
9271 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
9272 tsubst_flags_t complain
)
9278 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9279 p
= conversion_obstack_alloc (0);
9280 /* We want to discard any access checks done for this test,
9281 as we might not be in the appropriate access context and
9282 we'll do the check again when we actually perform the
9284 push_deferring_access_checks (dk_deferred
);
9286 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9288 ok_p
= (t
&& !t
->bad_p
);
9290 /* Discard the access checks now. */
9291 pop_deferring_access_checks ();
9292 /* Free all the conversions we allocated. */
9293 obstack_free (&conversion_obstack
, p
);
9298 /* Like can_convert_arg, but allows dubious conversions as well. */
9301 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
9302 tsubst_flags_t complain
)
9307 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9308 p
= conversion_obstack_alloc (0);
9309 /* Try to perform the conversion. */
9310 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9312 /* Free all the conversions we allocated. */
9313 obstack_free (&conversion_obstack
, p
);
9318 /* Convert EXPR to TYPE. Return the converted expression.
9320 Note that we allow bad conversions here because by the time we get to
9321 this point we are committed to doing the conversion. If we end up
9322 doing a bad conversion, convert_like will complain. */
9325 perform_implicit_conversion_flags (tree type
, tree expr
,
9326 tsubst_flags_t complain
, int flags
)
9330 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9332 if (error_operand_p (expr
))
9333 return error_mark_node
;
9335 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9336 p
= conversion_obstack_alloc (0);
9338 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9344 if (complain
& tf_error
)
9346 /* If expr has unknown type, then it is an overloaded function.
9347 Call instantiate_type to get good error messages. */
9348 if (TREE_TYPE (expr
) == unknown_type_node
)
9349 instantiate_type (type
, expr
, complain
);
9350 else if (invalid_nonstatic_memfn_p (expr
, complain
))
9351 /* We gave an error. */;
9353 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
9354 TREE_TYPE (expr
), type
);
9356 expr
= error_mark_node
;
9358 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
9360 /* In a template, we are only concerned about determining the
9361 type of non-dependent expressions, so we do not have to
9362 perform the actual conversion. But for initializers, we
9363 need to be able to perform it at instantiation
9364 (or instantiate_non_dependent_expr) time. */
9365 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
9366 if (!(flags
& LOOKUP_ONLYCONVERTING
))
9367 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
9370 expr
= convert_like (conv
, expr
, complain
);
9372 /* Free all the conversions we allocated. */
9373 obstack_free (&conversion_obstack
, p
);
9379 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
9381 return perform_implicit_conversion_flags (type
, expr
, complain
,
9385 /* Convert EXPR to TYPE (as a direct-initialization) if that is
9386 permitted. If the conversion is valid, the converted expression is
9387 returned. Otherwise, NULL_TREE is returned, except in the case
9388 that TYPE is a class type; in that case, an error is issued. If
9389 C_CAST_P is true, then this direct-initialization is taking
9390 place as part of a static_cast being attempted as part of a C-style
9394 perform_direct_initialization_if_possible (tree type
,
9397 tsubst_flags_t complain
)
9402 if (type
== error_mark_node
|| error_operand_p (expr
))
9403 return error_mark_node
;
9406 If the destination type is a (possibly cv-qualified) class type:
9408 -- If the initialization is direct-initialization ...,
9409 constructors are considered. ... If no constructor applies, or
9410 the overload resolution is ambiguous, the initialization is
9412 if (CLASS_TYPE_P (type
))
9414 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
9415 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
9416 &args
, type
, LOOKUP_NORMAL
, complain
);
9417 release_tree_vector (args
);
9418 return build_cplus_new (type
, expr
, complain
);
9421 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9422 p
= conversion_obstack_alloc (0);
9424 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9426 LOOKUP_NORMAL
, complain
);
9427 if (!conv
|| conv
->bad_p
)
9430 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
9431 /*issue_conversion_warnings=*/false,
9435 /* Free all the conversions we allocated. */
9436 obstack_free (&conversion_obstack
, p
);
9441 /* When initializing a reference that lasts longer than a full-expression,
9442 this special rule applies:
9446 The temporary to which the reference is bound or the temporary
9447 that is the complete object to which the reference is bound
9448 persists for the lifetime of the reference.
9450 The temporaries created during the evaluation of the expression
9451 initializing the reference, except the temporary to which the
9452 reference is bound, are destroyed at the end of the
9453 full-expression in which they are created.
9455 In that case, we store the converted expression into a new
9456 VAR_DECL in a new scope.
9458 However, we want to be careful not to create temporaries when
9459 they are not required. For example, given:
9462 struct D : public B {};
9466 there is no need to copy the return value from "f"; we can just
9467 extend its lifetime. Similarly, given:
9470 struct T { operator S(); };
9474 we can extend the lifetime of the return value of the conversion
9477 The next several functions are involved in this lifetime extension. */
9479 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9480 reference is being bound to a temporary. Create and return a new
9481 VAR_DECL with the indicated TYPE; this variable will store the value to
9482 which the reference is bound. */
9485 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
9489 /* Create the variable. */
9490 var
= create_temporary_var (type
);
9492 /* Register the variable. */
9494 && (TREE_STATIC (decl
) || DECL_THREAD_LOCAL_P (decl
)))
9496 /* Namespace-scope or local static; give it a mangled name. */
9497 /* FIXME share comdat with decl? */
9500 TREE_STATIC (var
) = TREE_STATIC (decl
);
9501 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
9502 name
= mangle_ref_init_variable (decl
);
9503 DECL_NAME (var
) = name
;
9504 SET_DECL_ASSEMBLER_NAME (var
, name
);
9505 var
= pushdecl_top_level (var
);
9508 /* Create a new cleanup level if necessary. */
9509 maybe_push_cleanup_level (type
);
9514 /* EXPR is the initializer for a variable DECL of reference or
9515 std::initializer_list type. Create, push and return a new VAR_DECL
9516 for the initializer so that it will live as long as DECL. Any
9517 cleanup for the new variable is returned through CLEANUP, and the
9518 code to initialize the new variable is returned through INITP. */
9521 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
9528 /* Create the temporary variable. */
9529 type
= TREE_TYPE (expr
);
9530 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
9531 layout_decl (var
, 0);
9532 /* If the rvalue is the result of a function call it will be
9533 a TARGET_EXPR. If it is some other construct (such as a
9534 member access expression where the underlying object is
9535 itself the result of a function call), turn it into a
9536 TARGET_EXPR here. It is important that EXPR be a
9537 TARGET_EXPR below since otherwise the INIT_EXPR will
9538 attempt to make a bitwise copy of EXPR to initialize
9540 if (TREE_CODE (expr
) != TARGET_EXPR
)
9541 expr
= get_target_expr (expr
);
9543 if (TREE_CODE (decl
) == FIELD_DECL
9544 && extra_warnings
&& !TREE_NO_WARNING (decl
))
9546 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
9547 "until the constructor exits", decl
);
9548 TREE_NO_WARNING (decl
) = true;
9551 /* Recursively extend temps in this initializer. */
9552 TARGET_EXPR_INITIAL (expr
)
9553 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
9555 /* Any reference temp has a non-trivial initializer. */
9556 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
9558 /* If the initializer is constant, put it in DECL_INITIAL so we get
9559 static initialization and use in constant expressions. */
9560 init
= maybe_constant_init (expr
);
9561 if (TREE_CONSTANT (init
))
9563 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
9565 /* 5.19 says that a constant expression can include an
9566 lvalue-rvalue conversion applied to "a glvalue of literal type
9567 that refers to a non-volatile temporary object initialized
9568 with a constant expression". Rather than try to communicate
9569 that this VAR_DECL is a temporary, just mark it constexpr.
9571 Currently this is only useful for initializer_list temporaries,
9572 since reference vars can't appear in constant expressions. */
9573 DECL_DECLARED_CONSTEXPR_P (var
) = true;
9574 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
9575 TREE_CONSTANT (var
) = true;
9577 DECL_INITIAL (var
) = init
;
9581 /* Create the INIT_EXPR that will initialize the temporary
9583 init
= build2 (INIT_EXPR
, type
, var
, expr
);
9584 if (at_function_scope_p ())
9586 add_decl_expr (var
);
9588 if (TREE_STATIC (var
))
9589 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
9592 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9594 vec_safe_push (*cleanups
, cleanup
);
9597 /* We must be careful to destroy the temporary only
9598 after its initialization has taken place. If the
9599 initialization throws an exception, then the
9600 destructor should not be run. We cannot simply
9601 transform INIT into something like:
9603 (INIT, ({ CLEANUP_STMT; }))
9605 because emit_local_var always treats the
9606 initializer as a full-expression. Thus, the
9607 destructor would run too early; it would run at the
9608 end of initializing the reference variable, rather
9609 than at the end of the block enclosing the
9612 The solution is to pass back a cleanup expression
9613 which the caller is responsible for attaching to
9614 the statement tree. */
9618 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
9619 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9621 if (DECL_THREAD_LOCAL_P (var
))
9622 tls_aggregates
= tree_cons (NULL_TREE
, var
,
9625 static_aggregates
= tree_cons (NULL_TREE
, var
,
9629 /* Check whether the dtor is callable. */
9630 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9637 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9638 initializing a variable of that TYPE. */
9641 initialize_reference (tree type
, tree expr
,
9642 int flags
, tsubst_flags_t complain
)
9646 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9648 if (type
== error_mark_node
|| error_operand_p (expr
))
9649 return error_mark_node
;
9651 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9652 p
= conversion_obstack_alloc (0);
9654 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
9656 if (!conv
|| conv
->bad_p
)
9658 if (complain
& tf_error
)
9661 convert_like (conv
, expr
, complain
);
9662 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
9663 && !TYPE_REF_IS_RVALUE (type
)
9664 && !real_lvalue_p (expr
))
9665 error_at (loc
, "invalid initialization of non-const reference of "
9666 "type %qT from an rvalue of type %qT",
9667 type
, TREE_TYPE (expr
));
9669 error_at (loc
, "invalid initialization of reference of type "
9670 "%qT from expression of type %qT", type
,
9673 return error_mark_node
;
9676 if (conv
->kind
== ck_ref_bind
)
9677 /* Perform the conversion. */
9678 expr
= convert_like (conv
, expr
, complain
);
9679 else if (conv
->kind
== ck_ambig
)
9680 /* We gave an error in build_user_type_conversion_1. */
9681 expr
= error_mark_node
;
9685 /* Free all the conversions we allocated. */
9686 obstack_free (&conversion_obstack
, p
);
9691 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9692 which is bound either to a reference or a std::initializer_list. */
9695 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9700 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
9702 TREE_OPERAND (sub
, 1)
9703 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
9706 if (TREE_CODE (sub
) != ADDR_EXPR
)
9708 /* Deal with binding to a subobject. */
9709 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
9710 p
= &TREE_OPERAND (*p
, 0);
9711 if (TREE_CODE (*p
) == TARGET_EXPR
)
9713 tree subinit
= NULL_TREE
;
9714 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
9715 recompute_tree_invariant_for_addr_expr (sub
);
9717 init
= fold_convert (TREE_TYPE (init
), sub
);
9719 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
9724 /* INIT is part of the initializer for DECL. If there are any
9725 reference or initializer lists being initialized, extend their
9726 lifetime to match that of DECL. */
9729 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9731 tree type
= TREE_TYPE (init
);
9732 if (processing_template_decl
)
9734 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9735 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
9736 else if (is_std_init_list (type
))
9738 /* The temporary array underlying a std::initializer_list
9739 is handled like a reference temporary. */
9741 if (TREE_CODE (ctor
) == TARGET_EXPR
)
9742 ctor
= TARGET_EXPR_INITIAL (ctor
);
9743 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
9745 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
9746 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
9747 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
9750 else if (TREE_CODE (init
) == CONSTRUCTOR
)
9754 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
9755 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
9756 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
9762 /* Returns true iff an initializer for TYPE could contain temporaries that
9763 need to be extended because they are bound to references or
9764 std::initializer_list. */
9767 type_has_extended_temps (tree type
)
9769 type
= strip_array_types (type
);
9770 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9772 if (CLASS_TYPE_P (type
))
9774 if (is_std_init_list (type
))
9776 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
9777 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
9778 if (type_has_extended_temps (TREE_TYPE (f
)))
9784 /* Returns true iff TYPE is some variant of std::initializer_list. */
9787 is_std_init_list (tree type
)
9789 /* Look through typedefs. */
9792 if (cxx_dialect
== cxx98
)
9794 type
= TYPE_MAIN_VARIANT (type
);
9795 return (CLASS_TYPE_P (type
)
9796 && CP_TYPE_CONTEXT (type
) == std_node
9797 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
9800 /* Returns true iff DECL is a list constructor: i.e. a constructor which
9801 will accept an argument list of a single std::initializer_list<T>. */
9804 is_list_ctor (tree decl
)
9806 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
9809 if (!args
|| args
== void_list_node
)
9812 arg
= non_reference (TREE_VALUE (args
));
9813 if (!is_std_init_list (arg
))
9816 args
= TREE_CHAIN (args
);
9818 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9819 /* There are more non-defaulted parms. */
9825 #include "gt-cp-call.h"