1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 modified by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
31 #include "stor-layout.h"
32 #include "trans-mem.h"
33 #include "stringpool.h"
37 #include "diagnostic-core.h"
41 #include "langhooks.h"
42 #include "c-family/c-objc.h"
44 #include "hard-reg-set.h"
47 #include "internal-fn.h"
49 /* The various kinds of conversion. */
51 typedef enum conversion_kind
{
67 /* The rank of the conversion. Order of the enumerals matters; better
68 conversions should come earlier in the list. */
70 typedef enum conversion_rank
{
81 /* An implicit conversion sequence, in the sense of [over.best.ics].
82 The first conversion to be performed is at the end of the chain.
83 That conversion is always a cr_identity conversion. */
85 typedef struct conversion conversion
;
87 /* The kind of conversion represented by this step. */
89 /* The rank of this conversion. */
91 BOOL_BITFIELD user_conv_p
: 1;
92 BOOL_BITFIELD ellipsis_p
: 1;
93 BOOL_BITFIELD this_p
: 1;
94 /* True if this conversion would be permitted with a bending of
95 language standards, e.g. disregarding pointer qualifiers or
96 converting integers to pointers. */
97 BOOL_BITFIELD bad_p
: 1;
98 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
99 temporary should be created to hold the result of the
101 BOOL_BITFIELD need_temporary_p
: 1;
102 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
103 from a pointer-to-derived to pointer-to-base is being performed. */
104 BOOL_BITFIELD base_p
: 1;
105 /* If KIND is ck_ref_bind, true when either an lvalue reference is
106 being bound to an lvalue expression or an rvalue reference is
107 being bound to an rvalue expression. If KIND is ck_rvalue,
108 true when we should treat an lvalue as an rvalue (12.8p33). If
109 KIND is ck_base, always false. */
110 BOOL_BITFIELD rvaluedness_matches_p
: 1;
111 BOOL_BITFIELD check_narrowing
: 1;
112 /* The type of the expression resulting from the conversion. */
115 /* The next conversion in the chain. Since the conversions are
116 arranged from outermost to innermost, the NEXT conversion will
117 actually be performed before this conversion. This variant is
118 used only when KIND is neither ck_identity, ck_ambig nor
119 ck_list. Please use the next_conversion function instead
120 of using this field directly. */
122 /* The expression at the beginning of the conversion chain. This
123 variant is used only if KIND is ck_identity or ck_ambig. */
125 /* The array of conversions for an initializer_list, so this
126 variant is used only when KIN D is ck_list. */
129 /* The function candidate corresponding to this conversion
130 sequence. This field is only used if KIND is ck_user. */
131 struct z_candidate
*cand
;
134 #define CONVERSION_RANK(NODE) \
135 ((NODE)->bad_p ? cr_bad \
136 : (NODE)->ellipsis_p ? cr_ellipsis \
137 : (NODE)->user_conv_p ? cr_user \
140 #define BAD_CONVERSION_RANK(NODE) \
141 ((NODE)->ellipsis_p ? cr_ellipsis \
142 : (NODE)->user_conv_p ? cr_user \
145 static struct obstack conversion_obstack
;
146 static bool conversion_obstack_initialized
;
147 struct rejection_reason
;
149 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
150 static int equal_functions (tree
, tree
);
151 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
153 static int compare_ics (conversion
*, conversion
*);
154 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
155 static tree
build_java_interface_fn_ref (tree
, tree
);
156 #define convert_like(CONV, EXPR, COMPLAIN) \
157 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
158 /*issue_conversion_warnings=*/true, \
159 /*c_cast_p=*/false, (COMPLAIN))
160 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
161 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
162 /*issue_conversion_warnings=*/true, \
163 /*c_cast_p=*/false, (COMPLAIN))
164 static tree
convert_like_real (conversion
*, tree
, tree
, int, int, bool,
165 bool, tsubst_flags_t
);
166 static void op_error (location_t
, enum tree_code
, enum tree_code
, tree
,
168 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
170 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
171 static void print_z_candidates (location_t
, struct z_candidate
*);
172 static tree
build_this (tree
);
173 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
174 static bool any_strictly_viable (struct z_candidate
*);
175 static struct z_candidate
*add_template_candidate
176 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
177 tree
, tree
, tree
, int, unification_kind_t
, tsubst_flags_t
);
178 static struct z_candidate
*add_template_candidate_real
179 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
180 tree
, tree
, tree
, int, tree
, unification_kind_t
, tsubst_flags_t
);
181 static struct z_candidate
*add_template_conv_candidate
182 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
183 tree
, tree
, tree
, tsubst_flags_t
);
184 static void add_builtin_candidates
185 (struct z_candidate
**, enum tree_code
, enum tree_code
,
186 tree
, tree
*, int, tsubst_flags_t
);
187 static void add_builtin_candidate
188 (struct z_candidate
**, enum tree_code
, enum tree_code
,
189 tree
, tree
, tree
, tree
*, tree
*, int, tsubst_flags_t
);
190 static bool is_complete (tree
);
191 static void build_builtin_candidate
192 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
193 int, tsubst_flags_t
);
194 static struct z_candidate
*add_conv_candidate
195 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
196 tree
, tsubst_flags_t
);
197 static struct z_candidate
*add_function_candidate
198 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
199 tree
, int, tsubst_flags_t
);
200 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
202 static conversion
*standard_conversion (tree
, tree
, tree
, bool, int);
203 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
205 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
206 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
207 static conversion
*next_conversion (conversion
*);
208 static bool is_subseq (conversion
*, conversion
*);
209 static conversion
*maybe_handle_ref_bind (conversion
**);
210 static void maybe_handle_implicit_object (conversion
**);
211 static struct z_candidate
*add_candidate
212 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
213 conversion
**, tree
, tree
, int, struct rejection_reason
*, int);
214 static tree
source_type (conversion
*);
215 static void add_warning (struct z_candidate
*, struct z_candidate
*);
216 static bool reference_compatible_p (tree
, tree
);
217 static conversion
*direct_reference_binding (tree
, conversion
*);
218 static bool promoted_arithmetic_type_p (tree
);
219 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
220 static char *name_as_c_string (tree
, tree
, bool *);
221 static tree
prep_operand (tree
);
222 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
223 bool, tree
, tree
, int, struct z_candidate
**,
225 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
226 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
228 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
229 NAME can take many forms... */
232 check_dtor_name (tree basetype
, tree name
)
234 /* Just accept something we've already complained about. */
235 if (name
== error_mark_node
)
238 if (TREE_CODE (name
) == TYPE_DECL
)
239 name
= TREE_TYPE (name
);
240 else if (TYPE_P (name
))
242 else if (identifier_p (name
))
244 if ((MAYBE_CLASS_TYPE_P (basetype
)
245 && name
== constructor_name (basetype
))
246 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
247 && name
== TYPE_IDENTIFIER (basetype
)))
250 name
= get_type_value (name
);
256 template <class T> struct S { ~S(); };
260 NAME will be a class template. */
261 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
265 if (!name
|| name
== error_mark_node
)
267 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
270 /* We want the address of a function or method. We avoid creating a
271 pointer-to-member function. */
274 build_addr_func (tree function
, tsubst_flags_t complain
)
276 tree type
= TREE_TYPE (function
);
278 /* We have to do these by hand to avoid real pointer to member
280 if (TREE_CODE (type
) == METHOD_TYPE
)
282 if (TREE_CODE (function
) == OFFSET_REF
)
284 tree object
= build_address (TREE_OPERAND (function
, 0));
285 return get_member_function_from_ptrfunc (&object
,
286 TREE_OPERAND (function
, 1),
289 function
= build_address (function
);
292 function
= decay_conversion (function
, complain
);
297 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
298 POINTER_TYPE to those. Note, pointer to member function types
299 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
300 two variants. build_call_a is the primitive taking an array of
301 arguments, while build_call_n is a wrapper that handles varargs. */
304 build_call_n (tree function
, int n
, ...)
307 return build_call_a (function
, 0, NULL
);
310 tree
*argarray
= XALLOCAVEC (tree
, n
);
315 for (i
= 0; i
< n
; i
++)
316 argarray
[i
] = va_arg (ap
, tree
);
318 return build_call_a (function
, n
, argarray
);
322 /* Update various flags in cfun and the call itself based on what is being
323 called. Split out of build_call_a so that bot_manip can use it too. */
326 set_flags_from_callee (tree call
)
329 tree decl
= get_callee_fndecl (call
);
331 /* We check both the decl and the type; a function may be known not to
332 throw without being declared throw(). */
333 nothrow
= decl
&& TREE_NOTHROW (decl
);
334 if (CALL_EXPR_FN (call
))
335 nothrow
|= TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call
))));
336 else if (internal_fn_flags (CALL_EXPR_IFN (call
)) & ECF_NOTHROW
)
339 if (!nothrow
&& at_function_scope_p () && cfun
&& cp_function_chain
)
340 cp_function_chain
->can_throw
= 1;
342 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
&& cp_function_chain
)
343 current_function_returns_abnormally
= 1;
345 TREE_NOTHROW (call
) = nothrow
;
349 build_call_a (tree function
, int n
, tree
*argarray
)
356 function
= build_addr_func (function
, tf_warning_or_error
);
358 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
359 fntype
= TREE_TYPE (TREE_TYPE (function
));
360 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
361 || TREE_CODE (fntype
) == METHOD_TYPE
);
362 result_type
= TREE_TYPE (fntype
);
363 /* An rvalue has no cv-qualifiers. */
364 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
365 result_type
= cv_unqualified (result_type
);
367 function
= build_call_array_loc (input_location
,
368 result_type
, function
, n
, argarray
);
369 set_flags_from_callee (function
);
371 decl
= get_callee_fndecl (function
);
373 if (decl
&& !TREE_USED (decl
))
375 /* We invoke build_call directly for several library
376 functions. These may have been declared normally if
377 we're building libgcc, so we can't just check
379 gcc_assert (DECL_ARTIFICIAL (decl
)
380 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
385 require_complete_eh_spec_types (fntype
, decl
);
387 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
389 /* Don't pass empty class objects by value. This is useful
390 for tags in STL, which are used to control overload resolution.
391 We don't need to handle other cases of copying empty classes. */
392 if (! decl
|| ! DECL_BUILT_IN (decl
))
393 for (i
= 0; i
< n
; i
++)
395 tree arg
= CALL_EXPR_ARG (function
, i
);
396 if (is_empty_class (TREE_TYPE (arg
))
397 && ! TREE_ADDRESSABLE (TREE_TYPE (arg
)))
399 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (arg
));
400 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (t
), arg
, t
);
401 CALL_EXPR_ARG (function
, i
) = arg
;
408 /* New overloading code. */
410 typedef struct z_candidate z_candidate
;
412 typedef struct candidate_warning candidate_warning
;
413 struct candidate_warning
{
415 candidate_warning
*next
;
418 /* Information for providing diagnostics about why overloading failed. */
420 enum rejection_reason_code
{
423 rr_explicit_conversion
,
424 rr_template_conversion
,
426 rr_bad_arg_conversion
,
427 rr_template_unification
,
431 struct conversion_info
{
432 /* The index of the argument, 0-based. */
434 /* The actual argument or its type. */
436 /* The type of the parameter. */
440 struct rejection_reason
{
441 enum rejection_reason_code code
;
443 /* Information about an arity mismatch. */
445 /* The expected number of arguments. */
447 /* The actual number of arguments in the call. */
449 /* Whether the call was a varargs call. */
452 /* Information about an argument conversion mismatch. */
453 struct conversion_info conversion
;
454 /* Same, but for bad argument conversions. */
455 struct conversion_info bad_conversion
;
456 /* Information about template unification failures. These are the
457 parameters passed to fn_type_unification. */
465 unification_kind_t strict
;
467 } template_unification
;
468 /* Information about template instantiation failures. These are the
469 parameters passed to instantiate_template. */
473 } template_instantiation
;
478 /* The FUNCTION_DECL that will be called if this candidate is
479 selected by overload resolution. */
481 /* If not NULL_TREE, the first argument to use when calling this
484 /* The rest of the arguments to use when calling this function. If
485 there are no further arguments this may be NULL or it may be an
487 const vec
<tree
, va_gc
> *args
;
488 /* The implicit conversion sequences for each of the arguments to
491 /* The number of implicit conversion sequences. */
493 /* If FN is a user-defined conversion, the standard conversion
494 sequence from the type returned by FN to the desired destination
496 conversion
*second_conv
;
497 struct rejection_reason
*reason
;
498 /* If FN is a member function, the binfo indicating the path used to
499 qualify the name of FN at the call site. This path is used to
500 determine whether or not FN is accessible if it is selected by
501 overload resolution. The DECL_CONTEXT of FN will always be a
502 (possibly improper) base of this binfo. */
504 /* If FN is a non-static member function, the binfo indicating the
505 subobject to which the `this' pointer should be converted if FN
506 is selected by overload resolution. The type pointed to by
507 the `this' pointer must correspond to the most derived class
508 indicated by the CONVERSION_PATH. */
509 tree conversion_path
;
512 candidate_warning
*warnings
;
516 /* The flags active in add_candidate. */
520 /* Returns true iff T is a null pointer constant in the sense of
524 null_ptr_cst_p (tree t
)
528 A null pointer constant is an integral constant expression
529 (_expr.const_) rvalue of integer type that evaluates to zero or
530 an rvalue of type std::nullptr_t. */
531 if (NULLPTR_TYPE_P (TREE_TYPE (t
)))
533 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t
)))
535 /* Core issue 903 says only literal 0 is a null pointer constant. */
536 if (cxx_dialect
< cxx11
)
537 t
= fold_non_dependent_expr (t
);
539 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
545 /* Returns true iff T is a null member pointer value (4.11). */
548 null_member_pointer_value_p (tree t
)
550 tree type
= TREE_TYPE (t
);
553 else if (TYPE_PTRMEMFUNC_P (type
))
554 return (TREE_CODE (t
) == CONSTRUCTOR
555 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
556 else if (TYPE_PTRDATAMEM_P (type
))
557 return integer_all_onesp (t
);
562 /* Returns nonzero if PARMLIST consists of only default parms,
563 ellipsis, and/or undeduced parameter packs. */
566 sufficient_parms_p (const_tree parmlist
)
568 for (; parmlist
&& parmlist
!= void_list_node
;
569 parmlist
= TREE_CHAIN (parmlist
))
570 if (!TREE_PURPOSE (parmlist
)
571 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
576 /* Allocate N bytes of memory from the conversion obstack. The memory
577 is zeroed before being returned. */
580 conversion_obstack_alloc (size_t n
)
583 if (!conversion_obstack_initialized
)
585 gcc_obstack_init (&conversion_obstack
);
586 conversion_obstack_initialized
= true;
588 p
= obstack_alloc (&conversion_obstack
, n
);
593 /* Allocate rejection reasons. */
595 static struct rejection_reason
*
596 alloc_rejection (enum rejection_reason_code code
)
598 struct rejection_reason
*p
;
599 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
604 static struct rejection_reason
*
605 arity_rejection (tree first_arg
, int expected
, int actual
)
607 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
608 int adjust
= first_arg
!= NULL_TREE
;
609 r
->u
.arity
.expected
= expected
- adjust
;
610 r
->u
.arity
.actual
= actual
- adjust
;
614 static struct rejection_reason
*
615 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
617 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
618 int adjust
= first_arg
!= NULL_TREE
;
619 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
620 r
->u
.conversion
.from
= from
;
621 r
->u
.conversion
.to_type
= to
;
625 static struct rejection_reason
*
626 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
628 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
629 int adjust
= first_arg
!= NULL_TREE
;
630 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
631 r
->u
.bad_conversion
.from
= from
;
632 r
->u
.bad_conversion
.to_type
= to
;
636 static struct rejection_reason
*
637 explicit_conversion_rejection (tree from
, tree to
)
639 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
640 r
->u
.conversion
.n_arg
= 0;
641 r
->u
.conversion
.from
= from
;
642 r
->u
.conversion
.to_type
= to
;
646 static struct rejection_reason
*
647 template_conversion_rejection (tree from
, tree to
)
649 struct rejection_reason
*r
= alloc_rejection (rr_template_conversion
);
650 r
->u
.conversion
.n_arg
= 0;
651 r
->u
.conversion
.from
= from
;
652 r
->u
.conversion
.to_type
= to
;
656 static struct rejection_reason
*
657 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
658 const tree
*args
, unsigned int nargs
,
659 tree return_type
, unification_kind_t strict
,
662 size_t args_n_bytes
= sizeof (*args
) * nargs
;
663 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
664 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
665 r
->u
.template_unification
.tmpl
= tmpl
;
666 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
667 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
668 /* Copy args to our own storage. */
669 memcpy (args1
, args
, args_n_bytes
);
670 r
->u
.template_unification
.args
= args1
;
671 r
->u
.template_unification
.nargs
= nargs
;
672 r
->u
.template_unification
.return_type
= return_type
;
673 r
->u
.template_unification
.strict
= strict
;
674 r
->u
.template_unification
.flags
= flags
;
678 static struct rejection_reason
*
679 template_unification_error_rejection (void)
681 return alloc_rejection (rr_template_unification
);
684 static struct rejection_reason
*
685 invalid_copy_with_fn_template_rejection (void)
687 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
691 /* Dynamically allocate a conversion. */
694 alloc_conversion (conversion_kind kind
)
697 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
702 #ifdef ENABLE_CHECKING
704 /* Make sure that all memory on the conversion obstack has been
708 validate_conversion_obstack (void)
710 if (conversion_obstack_initialized
)
711 gcc_assert ((obstack_next_free (&conversion_obstack
)
712 == obstack_base (&conversion_obstack
)));
715 #endif /* ENABLE_CHECKING */
717 /* Dynamically allocate an array of N conversions. */
720 alloc_conversions (size_t n
)
722 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
726 build_conv (conversion_kind code
, tree type
, conversion
*from
)
729 conversion_rank rank
= CONVERSION_RANK (from
);
731 /* Note that the caller is responsible for filling in t->cand for
732 user-defined conversions. */
733 t
= alloc_conversion (code
);
756 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
757 t
->bad_p
= from
->bad_p
;
762 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
763 specialization of std::initializer_list<T>, if such a conversion is
767 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
769 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
770 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
771 conversion
**subconvs
= alloc_conversions (len
);
776 /* Within a list-initialization we can have more user-defined
778 flags
&= ~LOOKUP_NO_CONVERSION
;
779 /* But no narrowing conversions. */
780 flags
|= LOOKUP_NO_NARROWING
;
782 /* Can't make an array of these types. */
783 if (TREE_CODE (elttype
) == REFERENCE_TYPE
784 || TREE_CODE (elttype
) == FUNCTION_TYPE
785 || VOID_TYPE_P (elttype
))
788 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
791 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
792 false, flags
, complain
);
799 t
= alloc_conversion (ck_list
);
801 t
->u
.list
= subconvs
;
804 for (i
= 0; i
< len
; ++i
)
806 conversion
*sub
= subconvs
[i
];
807 if (sub
->rank
> t
->rank
)
809 if (sub
->user_conv_p
)
810 t
->user_conv_p
= true;
818 /* Return the next conversion of the conversion chain (if applicable),
819 or NULL otherwise. Please use this function instead of directly
820 accessing fields of struct conversion. */
823 next_conversion (conversion
*conv
)
826 || conv
->kind
== ck_identity
827 || conv
->kind
== ck_ambig
828 || conv
->kind
== ck_list
)
833 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
834 is a valid aggregate initializer for array type ATYPE. */
837 can_convert_array (tree atype
, tree ctor
, int flags
, tsubst_flags_t complain
)
840 tree elttype
= TREE_TYPE (atype
);
841 for (i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
843 tree val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
845 if (TREE_CODE (elttype
) == ARRAY_TYPE
846 && TREE_CODE (val
) == CONSTRUCTOR
)
847 ok
= can_convert_array (elttype
, val
, flags
, complain
);
849 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
857 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
858 aggregate class, if such a conversion is possible. */
861 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
863 unsigned HOST_WIDE_INT i
= 0;
865 tree field
= next_initializable_field (TYPE_FIELDS (type
));
866 tree empty_ctor
= NULL_TREE
;
868 /* We already called reshape_init in implicit_conversion. */
870 /* The conversions within the init-list aren't affected by the enclosing
871 context; they're always simple copy-initialization. */
872 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
874 for (; field
; field
= next_initializable_field (DECL_CHAIN (field
)))
876 tree ftype
= TREE_TYPE (field
);
880 if (i
< CONSTRUCTOR_NELTS (ctor
))
881 val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
882 else if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
883 /* Value-initialization of reference is ill-formed. */
887 if (empty_ctor
== NULL_TREE
)
888 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
893 if (TREE_CODE (ftype
) == ARRAY_TYPE
894 && TREE_CODE (val
) == CONSTRUCTOR
)
895 ok
= can_convert_array (ftype
, val
, flags
, complain
);
897 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
903 if (TREE_CODE (type
) == UNION_TYPE
)
907 if (i
< CONSTRUCTOR_NELTS (ctor
))
910 c
= alloc_conversion (ck_aggr
);
913 c
->user_conv_p
= true;
914 c
->check_narrowing
= true;
919 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
920 array type, if such a conversion is possible. */
923 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
926 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
927 tree elttype
= TREE_TYPE (type
);
932 enum conversion_rank rank
= cr_exact
;
934 /* We might need to propagate the size from the element to the array. */
935 complete_type (type
);
937 if (TYPE_DOMAIN (type
)
938 && !variably_modified_type_p (TYPE_DOMAIN (type
), NULL_TREE
))
940 unsigned HOST_WIDE_INT alen
= tree_to_uhwi (array_type_nelts_top (type
));
945 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
947 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
950 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
951 false, flags
, complain
);
955 if (sub
->rank
> rank
)
957 if (sub
->user_conv_p
)
963 c
= alloc_conversion (ck_aggr
);
966 c
->user_conv_p
= user
;
972 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
973 complex type, if such a conversion is possible. */
976 build_complex_conv (tree type
, tree ctor
, int flags
,
977 tsubst_flags_t complain
)
980 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
981 tree elttype
= TREE_TYPE (type
);
986 enum conversion_rank rank
= cr_exact
;
991 flags
= LOOKUP_IMPLICIT
|LOOKUP_NO_NARROWING
;
993 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
996 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
997 false, flags
, complain
);
1001 if (sub
->rank
> rank
)
1003 if (sub
->user_conv_p
)
1009 c
= alloc_conversion (ck_aggr
);
1012 c
->user_conv_p
= user
;
1018 /* Build a representation of the identity conversion from EXPR to
1019 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1022 build_identity_conv (tree type
, tree expr
)
1026 c
= alloc_conversion (ck_identity
);
1033 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1034 were multiple user-defined conversions to accomplish the job.
1035 Build a conversion that indicates that ambiguity. */
1038 build_ambiguous_conv (tree type
, tree expr
)
1042 c
= alloc_conversion (ck_ambig
);
1050 strip_top_quals (tree t
)
1052 if (TREE_CODE (t
) == ARRAY_TYPE
)
1054 return cp_build_qualified_type (t
, 0);
1057 /* Returns the standard conversion path (see [conv]) from type FROM to type
1058 TO, if any. For proper handling of null pointer constants, you must
1059 also pass the expression EXPR to convert from. If C_CAST_P is true,
1060 this conversion is coming from a C-style cast. */
1063 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1066 enum tree_code fcode
, tcode
;
1068 bool fromref
= false;
1071 to
= non_reference (to
);
1072 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1075 from
= TREE_TYPE (from
);
1078 to
= strip_top_quals (to
);
1079 from
= strip_top_quals (from
);
1081 if (expr
&& type_unknown_p (expr
))
1083 if (TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1085 tsubst_flags_t tflags
= tf_conv
;
1086 expr
= instantiate_type (to
, expr
, tflags
);
1087 if (expr
== error_mark_node
)
1089 from
= TREE_TYPE (expr
);
1091 else if (TREE_CODE (to
) == BOOLEAN_TYPE
)
1093 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1094 expr
= resolve_nondeduced_context (expr
);
1095 from
= TREE_TYPE (expr
);
1099 fcode
= TREE_CODE (from
);
1100 tcode
= TREE_CODE (to
);
1102 conv
= build_identity_conv (from
, expr
);
1103 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1105 from
= type_decays_to (from
);
1106 fcode
= TREE_CODE (from
);
1107 conv
= build_conv (ck_lvalue
, from
, conv
);
1109 else if (fromref
|| (expr
&& lvalue_p (expr
)))
1114 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1117 from
= strip_top_quals (bitfield_type
);
1118 fcode
= TREE_CODE (from
);
1121 conv
= build_conv (ck_rvalue
, from
, conv
);
1122 if (flags
& LOOKUP_PREFER_RVALUE
)
1123 conv
->rvaluedness_matches_p
= true;
1126 /* Allow conversion between `__complex__' data types. */
1127 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1129 /* The standard conversion sequence to convert FROM to TO is
1130 the standard conversion sequence to perform componentwise
1132 conversion
*part_conv
= standard_conversion
1133 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
);
1137 conv
= build_conv (part_conv
->kind
, to
, conv
);
1138 conv
->rank
= part_conv
->rank
;
1146 if (same_type_p (from
, to
))
1148 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1149 conv
->type
= qualified_to
;
1154 A null pointer constant can be converted to a pointer type; ... A
1155 null pointer constant of integral type can be converted to an
1156 rvalue of type std::nullptr_t. */
1157 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1158 || NULLPTR_TYPE_P (to
))
1159 && ((expr
&& null_ptr_cst_p (expr
))
1160 || NULLPTR_TYPE_P (from
)))
1161 conv
= build_conv (ck_std
, to
, conv
);
1162 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1163 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1165 /* For backwards brain damage compatibility, allow interconversion of
1166 pointers and integers with a pedwarn. */
1167 conv
= build_conv (ck_std
, to
, conv
);
1170 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1172 /* For backwards brain damage compatibility, allow interconversion of
1173 enums and integers with a pedwarn. */
1174 conv
= build_conv (ck_std
, to
, conv
);
1177 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1178 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1183 if (tcode
== POINTER_TYPE
1184 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from
),
1187 else if (VOID_TYPE_P (TREE_TYPE (to
))
1188 && !TYPE_PTRDATAMEM_P (from
)
1189 && TREE_CODE (TREE_TYPE (from
)) != FUNCTION_TYPE
)
1191 tree nfrom
= TREE_TYPE (from
);
1192 /* Don't try to apply restrict to void. */
1193 int quals
= cp_type_quals (nfrom
) & ~TYPE_QUAL_RESTRICT
;
1194 from
= build_pointer_type
1195 (cp_build_qualified_type (void_type_node
, quals
));
1196 conv
= build_conv (ck_ptr
, from
, conv
);
1198 else if (TYPE_PTRDATAMEM_P (from
))
1200 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1201 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1203 if (DERIVED_FROM_P (fbase
, tbase
)
1204 && (same_type_ignoring_top_level_qualifiers_p
1205 (TYPE_PTRMEM_POINTED_TO_TYPE (from
),
1206 TYPE_PTRMEM_POINTED_TO_TYPE (to
))))
1208 from
= build_ptrmem_type (tbase
,
1209 TYPE_PTRMEM_POINTED_TO_TYPE (from
));
1210 conv
= build_conv (ck_pmem
, from
, conv
);
1212 else if (!same_type_p (fbase
, tbase
))
1215 else if (CLASS_TYPE_P (TREE_TYPE (from
))
1216 && CLASS_TYPE_P (TREE_TYPE (to
))
1219 An rvalue of type "pointer to cv D," where D is a
1220 class type, can be converted to an rvalue of type
1221 "pointer to cv B," where B is a base class (clause
1222 _class.derived_) of D. If B is an inaccessible
1223 (clause _class.access_) or ambiguous
1224 (_class.member.lookup_) base class of D, a program
1225 that necessitates this conversion is ill-formed.
1226 Therefore, we use DERIVED_FROM_P, and do not check
1227 access or uniqueness. */
1228 && DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
1231 cp_build_qualified_type (TREE_TYPE (to
),
1232 cp_type_quals (TREE_TYPE (from
)));
1233 from
= build_pointer_type (from
);
1234 conv
= build_conv (ck_ptr
, from
, conv
);
1235 conv
->base_p
= true;
1238 if (tcode
== POINTER_TYPE
)
1240 to_pointee
= TREE_TYPE (to
);
1241 from_pointee
= TREE_TYPE (from
);
1245 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1246 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1249 if (same_type_p (from
, to
))
1251 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
1252 /* In a C-style cast, we ignore CV-qualification because we
1253 are allowed to perform a static_cast followed by a
1255 conv
= build_conv (ck_qual
, to
, conv
);
1256 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1257 conv
= build_conv (ck_qual
, to
, conv
);
1258 else if (expr
&& string_conv_p (to
, expr
, 0))
1259 /* converting from string constant to char *. */
1260 conv
= build_conv (ck_qual
, to
, conv
);
1261 /* Allow conversions among compatible ObjC pointer types (base
1262 conversions have been already handled above). */
1263 else if (c_dialect_objc ()
1264 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1265 conv
= build_conv (ck_ptr
, to
, conv
);
1266 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1268 conv
= build_conv (ck_ptr
, to
, conv
);
1276 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1278 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1279 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1280 tree fbase
= class_of_this_parm (fromfn
);
1281 tree tbase
= class_of_this_parm (tofn
);
1283 if (!DERIVED_FROM_P (fbase
, tbase
)
1284 || !same_type_p (static_fn_type (fromfn
),
1285 static_fn_type (tofn
)))
1288 from
= build_memfn_type (fromfn
,
1290 cp_type_quals (tbase
),
1291 type_memfn_rqual (tofn
));
1292 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1293 conv
= build_conv (ck_pmem
, from
, conv
);
1294 conv
->base_p
= true;
1296 else if (tcode
== BOOLEAN_TYPE
)
1300 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1301 to member type can be converted to a prvalue of type bool. ...
1302 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1303 std::nullptr_t can be converted to a prvalue of type bool; */
1304 if (ARITHMETIC_TYPE_P (from
)
1305 || UNSCOPED_ENUM_P (from
)
1306 || fcode
== POINTER_TYPE
1307 || TYPE_PTRMEM_P (from
)
1308 || NULLPTR_TYPE_P (from
))
1310 conv
= build_conv (ck_std
, to
, conv
);
1311 if (fcode
== POINTER_TYPE
1312 || TYPE_PTRDATAMEM_P (from
)
1313 || (TYPE_PTRMEMFUNC_P (from
)
1314 && conv
->rank
< cr_pbool
)
1315 || NULLPTR_TYPE_P (from
))
1316 conv
->rank
= cr_pbool
;
1317 if (NULLPTR_TYPE_P (from
) && (flags
& LOOKUP_ONLYCONVERTING
))
1324 /* We don't check for ENUMERAL_TYPE here because there are no standard
1325 conversions to enum type. */
1326 /* As an extension, allow conversion to complex type. */
1327 else if (ARITHMETIC_TYPE_P (to
))
1329 if (! (INTEGRAL_CODE_P (fcode
)
1330 || (fcode
== REAL_TYPE
&& !(flags
& LOOKUP_NO_NON_INTEGRAL
)))
1331 || SCOPED_ENUM_P (from
))
1333 conv
= build_conv (ck_std
, to
, conv
);
1335 /* Give this a better rank if it's a promotion. */
1336 if (same_type_p (to
, type_promotes_to (from
))
1337 && next_conversion (conv
)->rank
<= cr_promotion
)
1338 conv
->rank
= cr_promotion
;
1340 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1341 && vector_types_convertible_p (from
, to
, false))
1342 return build_conv (ck_std
, to
, conv
);
1343 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1344 && is_properly_derived_from (from
, to
))
1346 if (conv
->kind
== ck_rvalue
)
1347 conv
= next_conversion (conv
);
1348 conv
= build_conv (ck_base
, to
, conv
);
1349 /* The derived-to-base conversion indicates the initialization
1350 of a parameter with base type from an object of a derived
1351 type. A temporary object is created to hold the result of
1352 the conversion unless we're binding directly to a reference. */
1353 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1358 if (flags
& LOOKUP_NO_NARROWING
)
1359 conv
->check_narrowing
= true;
1364 /* Returns nonzero if T1 is reference-related to T2. */
1367 reference_related_p (tree t1
, tree t2
)
1369 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1372 t1
= TYPE_MAIN_VARIANT (t1
);
1373 t2
= TYPE_MAIN_VARIANT (t2
);
1377 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1378 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1380 return (same_type_p (t1
, t2
)
1381 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1382 && DERIVED_FROM_P (t1
, t2
)));
1385 /* Returns nonzero if T1 is reference-compatible with T2. */
1388 reference_compatible_p (tree t1
, tree t2
)
1392 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1393 reference-related to T2 and cv1 is the same cv-qualification as,
1394 or greater cv-qualification than, cv2. */
1395 return (reference_related_p (t1
, t2
)
1396 && at_least_as_qualified_p (t1
, t2
));
1399 /* A reference of the indicated TYPE is being bound directly to the
1400 expression represented by the implicit conversion sequence CONV.
1401 Return a conversion sequence for this binding. */
1404 direct_reference_binding (tree type
, conversion
*conv
)
1408 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1409 gcc_assert (TREE_CODE (conv
->type
) != REFERENCE_TYPE
);
1411 t
= TREE_TYPE (type
);
1415 When a parameter of reference type binds directly
1416 (_dcl.init.ref_) to an argument expression, the implicit
1417 conversion sequence is the identity conversion, unless the
1418 argument expression has a type that is a derived class of the
1419 parameter type, in which case the implicit conversion sequence is
1420 a derived-to-base Conversion.
1422 If the parameter binds directly to the result of applying a
1423 conversion function to the argument expression, the implicit
1424 conversion sequence is a user-defined conversion sequence
1425 (_over.ics.user_), with the second standard conversion sequence
1426 either an identity conversion or, if the conversion function
1427 returns an entity of a type that is a derived class of the
1428 parameter type, a derived-to-base conversion. */
1429 if (!same_type_ignoring_top_level_qualifiers_p (t
, conv
->type
))
1431 /* Represent the derived-to-base conversion. */
1432 conv
= build_conv (ck_base
, t
, conv
);
1433 /* We will actually be binding to the base-class subobject in
1434 the derived class, so we mark this conversion appropriately.
1435 That way, convert_like knows not to generate a temporary. */
1436 conv
->need_temporary_p
= false;
1438 return build_conv (ck_ref_bind
, type
, conv
);
1441 /* Returns the conversion path from type FROM to reference type TO for
1442 purposes of reference binding. For lvalue binding, either pass a
1443 reference type to FROM or an lvalue expression to EXPR. If the
1444 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1445 the conversion returned. If C_CAST_P is true, this
1446 conversion is coming from a C-style cast. */
1449 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1450 tsubst_flags_t complain
)
1452 conversion
*conv
= NULL
;
1453 tree to
= TREE_TYPE (rto
);
1458 cp_lvalue_kind gl_kind
;
1461 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1463 expr
= instantiate_type (to
, expr
, tf_none
);
1464 if (expr
== error_mark_node
)
1466 from
= TREE_TYPE (expr
);
1469 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1471 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1472 /* DR 1288: Otherwise, if the initializer list has a single element
1473 of type E and ... [T's] referenced type is reference-related to E,
1474 the object or reference is initialized from that element... */
1475 if (CONSTRUCTOR_NELTS (expr
) == 1)
1477 tree elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1478 if (error_operand_p (elt
))
1480 tree etype
= TREE_TYPE (elt
);
1481 if (reference_related_p (to
, etype
))
1488 /* Otherwise, if T is a reference type, a prvalue temporary of the
1489 type referenced by T is copy-list-initialized or
1490 direct-list-initialized, depending on the kind of initialization
1491 for the reference, and the reference is bound to that temporary. */
1492 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1493 flags
|LOOKUP_NO_TEMP_BIND
, complain
);
1497 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1499 from
= TREE_TYPE (from
);
1500 if (!TYPE_REF_IS_RVALUE (rfrom
)
1501 || TREE_CODE (from
) == FUNCTION_TYPE
)
1502 gl_kind
= clk_ordinary
;
1504 gl_kind
= clk_rvalueref
;
1508 gl_kind
= lvalue_kind (expr
);
1509 if (gl_kind
& clk_class
)
1510 /* A class prvalue is not a glvalue. */
1515 is_lvalue
= gl_kind
&& !(gl_kind
& clk_rvalueref
);
1518 if ((gl_kind
& clk_bitfield
) != 0)
1519 tfrom
= unlowered_expr_type (expr
);
1521 /* Figure out whether or not the types are reference-related and
1522 reference compatible. We have to do this after stripping
1523 references from FROM. */
1524 related_p
= reference_related_p (to
, tfrom
);
1525 /* If this is a C cast, first convert to an appropriately qualified
1526 type, so that we can later do a const_cast to the desired type. */
1527 if (related_p
&& c_cast_p
1528 && !at_least_as_qualified_p (to
, tfrom
))
1529 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1530 compatible_p
= reference_compatible_p (to
, tfrom
);
1532 /* Directly bind reference when target expression's type is compatible with
1533 the reference and expression is an lvalue. In DR391, the wording in
1534 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1535 const and rvalue references to rvalues of compatible class type.
1536 We should also do direct bindings for non-class xvalues. */
1539 || (!(flags
& LOOKUP_NO_TEMP_BIND
)
1540 && (CLASS_TYPE_P (from
)
1541 || TREE_CODE (from
) == ARRAY_TYPE
))))
1545 If the initializer expression
1547 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1548 is reference-compatible with "cv2 T2,"
1550 the reference is bound directly to the initializer expression
1554 If the initializer expression is an rvalue, with T2 a class type,
1555 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1556 is bound to the object represented by the rvalue or to a sub-object
1557 within that object. */
1559 conv
= build_identity_conv (tfrom
, expr
);
1560 conv
= direct_reference_binding (rto
, conv
);
1562 if (flags
& LOOKUP_PREFER_RVALUE
)
1563 /* The top-level caller requested that we pretend that the lvalue
1564 be treated as an rvalue. */
1565 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1566 else if (TREE_CODE (rfrom
) == REFERENCE_TYPE
)
1567 /* Handle rvalue reference to function properly. */
1568 conv
->rvaluedness_matches_p
1569 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1571 conv
->rvaluedness_matches_p
1572 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1574 if ((gl_kind
& clk_bitfield
) != 0
1575 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1576 /* For the purposes of overload resolution, we ignore the fact
1577 this expression is a bitfield or packed field. (In particular,
1578 [over.ics.ref] says specifically that a function with a
1579 non-const reference parameter is viable even if the
1580 argument is a bitfield.)
1582 However, when we actually call the function we must create
1583 a temporary to which to bind the reference. If the
1584 reference is volatile, or isn't const, then we cannot make
1585 a temporary, so we just issue an error when the conversion
1587 conv
->need_temporary_p
= true;
1589 /* Don't allow binding of lvalues (other than function lvalues) to
1590 rvalue references. */
1591 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1592 && TREE_CODE (to
) != FUNCTION_TYPE
1593 && !(flags
& LOOKUP_PREFER_RVALUE
))
1596 /* Nor the reverse. */
1597 if (!is_lvalue
&& !TYPE_REF_IS_RVALUE (rto
)
1598 && (!CP_TYPE_CONST_NON_VOLATILE_P (to
)
1599 || (flags
& LOOKUP_NO_RVAL_BIND
))
1600 && TREE_CODE (to
) != FUNCTION_TYPE
)
1608 /* [class.conv.fct] A conversion function is never used to convert a
1609 (possibly cv-qualified) object to the (possibly cv-qualified) same
1610 object type (or a reference to it), to a (possibly cv-qualified) base
1611 class of that type (or a reference to it).... */
1612 else if (CLASS_TYPE_P (from
) && !related_p
1613 && !(flags
& LOOKUP_NO_CONVERSION
))
1617 If the initializer expression
1619 -- has a class type (i.e., T2 is a class type) can be
1620 implicitly converted to an lvalue of type "cv3 T3," where
1621 "cv1 T1" is reference-compatible with "cv3 T3". (this
1622 conversion is selected by enumerating the applicable
1623 conversion functions (_over.match.ref_) and choosing the
1624 best one through overload resolution. (_over.match_).
1626 the reference is bound to the lvalue result of the conversion
1627 in the second case. */
1628 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1631 return cand
->second_conv
;
1634 /* From this point on, we conceptually need temporaries, even if we
1635 elide them. Only the cases above are "direct bindings". */
1636 if (flags
& LOOKUP_NO_TEMP_BIND
)
1641 When a parameter of reference type is not bound directly to an
1642 argument expression, the conversion sequence is the one required
1643 to convert the argument expression to the underlying type of the
1644 reference according to _over.best.ics_. Conceptually, this
1645 conversion sequence corresponds to copy-initializing a temporary
1646 of the underlying type with the argument expression. Any
1647 difference in top-level cv-qualification is subsumed by the
1648 initialization itself and does not constitute a conversion. */
1652 Otherwise, the reference shall be an lvalue reference to a
1653 non-volatile const type, or the reference shall be an rvalue
1656 We try below to treat this as a bad conversion to improve diagnostics,
1657 but if TO is an incomplete class, we need to reject this conversion
1658 now to avoid unnecessary instantiation. */
1659 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
)
1660 && !COMPLETE_TYPE_P (to
))
1663 /* We're generating a temporary now, but don't bind any more in the
1664 conversion (specifically, don't slice the temporary returned by a
1665 conversion operator). */
1666 flags
|= LOOKUP_NO_TEMP_BIND
;
1668 /* Core issue 899: When [copy-]initializing a temporary to be bound
1669 to the first parameter of a copy constructor (12.8) called with
1670 a single argument in the context of direct-initialization,
1671 explicit conversion functions are also considered.
1673 So don't set LOOKUP_ONLYCONVERTING in that case. */
1674 if (!(flags
& LOOKUP_COPY_PARM
))
1675 flags
|= LOOKUP_ONLYCONVERTING
;
1678 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1683 if (conv
->user_conv_p
)
1685 /* If initializing the temporary used a conversion function,
1686 recalculate the second conversion sequence. */
1687 for (conversion
*t
= conv
; t
; t
= next_conversion (t
))
1688 if (t
->kind
== ck_user
1689 && DECL_CONV_FN_P (t
->cand
->fn
))
1691 tree ftype
= TREE_TYPE (TREE_TYPE (t
->cand
->fn
));
1692 int sflags
= (flags
|LOOKUP_NO_CONVERSION
)&~LOOKUP_NO_TEMP_BIND
;
1693 conversion
*new_second
1694 = reference_binding (rto
, ftype
, NULL_TREE
, c_cast_p
,
1698 return merge_conversion_sequences (t
, new_second
);
1702 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1703 /* This reference binding, unlike those above, requires the
1704 creation of a temporary. */
1705 conv
->need_temporary_p
= true;
1706 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1710 Otherwise, the reference shall be an lvalue reference to a
1711 non-volatile const type, or the reference shall be an rvalue
1713 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1718 Otherwise, a temporary of type "cv1 T1" is created and
1719 initialized from the initializer expression using the rules for a
1720 non-reference copy initialization. If T1 is reference-related to
1721 T2, cv1 must be the same cv-qualification as, or greater
1722 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1723 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1729 /* Returns the implicit conversion sequence (see [over.ics]) from type
1730 FROM to type TO. The optional expression EXPR may affect the
1731 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1732 true, this conversion is coming from a C-style cast. */
1735 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1736 int flags
, tsubst_flags_t complain
)
1740 if (from
== error_mark_node
|| to
== error_mark_node
1741 || expr
== error_mark_node
)
1744 /* Other flags only apply to the primary function in overload
1745 resolution, or after we've chosen one. */
1746 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
1747 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_PREFER_RVALUE
1748 |LOOKUP_NO_NARROWING
|LOOKUP_PROTECT
|LOOKUP_NO_NON_INTEGRAL
);
1750 /* FIXME: actually we don't want warnings either, but we can't just
1751 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1752 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1753 We really ought not to issue that warning until we've committed
1754 to that conversion. */
1755 complain
&= ~tf_error
;
1757 /* Call reshape_init early to remove redundant braces. */
1758 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
)
1759 && CLASS_TYPE_P (to
)
1760 && COMPLETE_TYPE_P (complete_type (to
))
1761 && !CLASSTYPE_NON_AGGREGATE (to
))
1763 expr
= reshape_init (to
, expr
, complain
);
1764 if (expr
== error_mark_node
)
1766 from
= TREE_TYPE (expr
);
1769 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1770 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
1772 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
);
1777 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1779 if (is_std_init_list (to
))
1780 return build_list_conv (to
, expr
, flags
, complain
);
1782 /* As an extension, allow list-initialization of _Complex. */
1783 if (TREE_CODE (to
) == COMPLEX_TYPE
)
1785 conv
= build_complex_conv (to
, expr
, flags
, complain
);
1790 /* Allow conversion from an initializer-list with one element to a
1792 if (SCALAR_TYPE_P (to
))
1794 int nelts
= CONSTRUCTOR_NELTS (expr
);
1798 elt
= build_value_init (to
, tf_none
);
1799 else if (nelts
== 1)
1800 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1802 elt
= error_mark_node
;
1804 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
1805 c_cast_p
, flags
, complain
);
1808 conv
->check_narrowing
= true;
1809 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
1810 /* Too many levels of braces, i.e. '{{1}}'. */
1815 else if (TREE_CODE (to
) == ARRAY_TYPE
)
1816 return build_array_conv (to
, expr
, flags
, complain
);
1819 if (expr
!= NULL_TREE
1820 && (MAYBE_CLASS_TYPE_P (from
)
1821 || MAYBE_CLASS_TYPE_P (to
))
1822 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1824 struct z_candidate
*cand
;
1826 if (CLASS_TYPE_P (to
)
1827 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
1828 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
1829 return build_aggr_conv (to
, expr
, flags
, complain
);
1831 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
1833 conv
= cand
->second_conv
;
1835 /* We used to try to bind a reference to a temporary here, but that
1836 is now handled after the recursive call to this function at the end
1837 of reference_binding. */
1844 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1845 functions. ARGS will not be changed until a single candidate is
1848 static struct z_candidate
*
1849 add_candidate (struct z_candidate
**candidates
,
1850 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
1851 size_t num_convs
, conversion
**convs
,
1852 tree access_path
, tree conversion_path
,
1853 int viable
, struct rejection_reason
*reason
,
1856 struct z_candidate
*cand
= (struct z_candidate
*)
1857 conversion_obstack_alloc (sizeof (struct z_candidate
));
1860 cand
->first_arg
= first_arg
;
1862 cand
->convs
= convs
;
1863 cand
->num_convs
= num_convs
;
1864 cand
->access_path
= access_path
;
1865 cand
->conversion_path
= conversion_path
;
1866 cand
->viable
= viable
;
1867 cand
->reason
= reason
;
1868 cand
->next
= *candidates
;
1869 cand
->flags
= flags
;
1875 /* Return the number of remaining arguments in the parameter list
1876 beginning with ARG. */
1879 remaining_arguments (tree arg
)
1883 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
1884 arg
= TREE_CHAIN (arg
))
1890 /* Create an overload candidate for the function or method FN called
1891 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1892 FLAGS is passed on to implicit_conversion.
1894 This does not change ARGS.
1896 CTYPE, if non-NULL, is the type we want to pretend this function
1897 comes from for purposes of overload resolution. */
1899 static struct z_candidate
*
1900 add_function_candidate (struct z_candidate
**candidates
,
1901 tree fn
, tree ctype
, tree first_arg
,
1902 const vec
<tree
, va_gc
> *args
, tree access_path
,
1903 tree conversion_path
, int flags
,
1904 tsubst_flags_t complain
)
1906 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1910 tree orig_first_arg
= first_arg
;
1913 struct rejection_reason
*reason
= NULL
;
1915 /* At this point we should not see any functions which haven't been
1916 explicitly declared, except for friend functions which will have
1917 been found using argument dependent lookup. */
1918 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
1920 /* The `this', `in_chrg' and VTT arguments to constructors are not
1921 considered in overload resolution. */
1922 if (DECL_CONSTRUCTOR_P (fn
))
1924 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1925 skip
= num_artificial_parms_for (fn
);
1926 if (skip
> 0 && first_arg
!= NULL_TREE
)
1929 first_arg
= NULL_TREE
;
1935 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
1936 convs
= alloc_conversions (len
);
1938 /* 13.3.2 - Viable functions [over.match.viable]
1939 First, to be a viable function, a candidate function shall have enough
1940 parameters to agree in number with the arguments in the list.
1942 We need to check this first; otherwise, checking the ICSes might cause
1943 us to produce an ill-formed template instantiation. */
1945 parmnode
= parmlist
;
1946 for (i
= 0; i
< len
; ++i
)
1948 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1950 parmnode
= TREE_CHAIN (parmnode
);
1953 if ((i
< len
&& parmnode
)
1954 || !sufficient_parms_p (parmnode
))
1956 int remaining
= remaining_arguments (parmnode
);
1958 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
1960 /* When looking for a function from a subobject from an implicit
1961 copy/move constructor/operator=, don't consider anything that takes (a
1962 reference to) an unrelated type. See c++/44909 and core 1092. */
1963 else if (parmlist
&& (flags
& LOOKUP_DEFAULTED
))
1965 if (DECL_CONSTRUCTOR_P (fn
))
1967 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
1968 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
1974 parmnode
= chain_index (i
-1, parmlist
);
1975 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
1980 /* This only applies at the top level. */
1981 flags
&= ~LOOKUP_DEFAULTED
;
1987 /* Second, for F to be a viable function, there shall exist for each
1988 argument an implicit conversion sequence that converts that argument
1989 to the corresponding parameter of F. */
1991 parmnode
= parmlist
;
1993 for (i
= 0; i
< len
; ++i
)
1995 tree argtype
, to_type
;
2000 if (parmnode
== void_list_node
)
2003 if (i
== 0 && first_arg
!= NULL_TREE
)
2006 arg
= CONST_CAST_TREE (
2007 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
2008 argtype
= lvalue_type (arg
);
2010 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2011 && ! DECL_CONSTRUCTOR_P (fn
));
2015 tree parmtype
= TREE_VALUE (parmnode
);
2018 parmnode
= TREE_CHAIN (parmnode
);
2020 /* The type of the implicit object parameter ('this') for
2021 overload resolution is not always the same as for the
2022 function itself; conversion functions are considered to
2023 be members of the class being converted, and functions
2024 introduced by a using-declaration are considered to be
2025 members of the class that uses them.
2027 Since build_over_call ignores the ICS for the `this'
2028 parameter, we can just change the parm type. */
2029 if (ctype
&& is_this
)
2031 parmtype
= cp_build_qualified_type
2032 (ctype
, cp_type_quals (TREE_TYPE (parmtype
)));
2033 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
2035 /* If the function has a ref-qualifier, the implicit
2036 object parameter has reference type. */
2037 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
2038 parmtype
= cp_build_reference_type (parmtype
, rv
);
2039 /* The special handling of 'this' conversions in compare_ics
2040 does not apply if there is a ref-qualifier. */
2045 parmtype
= build_pointer_type (parmtype
);
2046 arg
= build_this (arg
);
2047 argtype
= lvalue_type (arg
);
2051 /* Core issue 899: When [copy-]initializing a temporary to be bound
2052 to the first parameter of a copy constructor (12.8) called with
2053 a single argument in the context of direct-initialization,
2054 explicit conversion functions are also considered.
2056 So set LOOKUP_COPY_PARM to let reference_binding know that
2057 it's being called in that context. We generalize the above
2058 to handle move constructors and template constructors as well;
2059 the standardese should soon be updated similarly. */
2060 if (ctype
&& i
== 0 && (len
-skip
== 1)
2061 && DECL_CONSTRUCTOR_P (fn
)
2062 && parmtype
!= error_mark_node
2063 && (same_type_ignoring_top_level_qualifiers_p
2064 (non_reference (parmtype
), ctype
)))
2066 if (!(flags
& LOOKUP_ONLYCONVERTING
))
2067 lflags
|= LOOKUP_COPY_PARM
;
2068 /* We allow user-defined conversions within init-lists, but
2069 don't list-initialize the copy parm, as that would mean
2070 using two levels of braces for the same type. */
2071 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
2072 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
2073 lflags
|= LOOKUP_NO_CONVERSION
;
2076 lflags
|= LOOKUP_ONLYCONVERTING
;
2078 t
= implicit_conversion (parmtype
, argtype
, arg
,
2079 /*c_cast_p=*/false, lflags
, complain
);
2084 t
= build_identity_conv (argtype
, arg
);
2085 t
->ellipsis_p
= true;
2096 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
);
2103 reason
= bad_arg_conversion_rejection (first_arg
, i
, arg
, to_type
);
2108 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2109 access_path
, conversion_path
, viable
, reason
, flags
);
2112 /* Create an overload candidate for the conversion function FN which will
2113 be invoked for expression OBJ, producing a pointer-to-function which
2114 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2115 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2116 passed on to implicit_conversion.
2118 Actually, we don't really care about FN; we care about the type it
2119 converts to. There may be multiple conversion functions that will
2120 convert to that type, and we rely on build_user_type_conversion_1 to
2121 choose the best one; so when we create our candidate, we record the type
2122 instead of the function. */
2124 static struct z_candidate
*
2125 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2126 tree first_arg
, const vec
<tree
, va_gc
> *arglist
,
2127 tree access_path
, tree conversion_path
,
2128 tsubst_flags_t complain
)
2130 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2131 int i
, len
, viable
, flags
;
2132 tree parmlist
, parmnode
;
2134 struct rejection_reason
*reason
;
2136 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2137 parmlist
= TREE_TYPE (parmlist
);
2138 parmlist
= TYPE_ARG_TYPES (parmlist
);
2140 len
= vec_safe_length (arglist
) + (first_arg
!= NULL_TREE
? 1 : 0) + 1;
2141 convs
= alloc_conversions (len
);
2142 parmnode
= parmlist
;
2144 flags
= LOOKUP_IMPLICIT
;
2147 /* Don't bother looking up the same type twice. */
2148 if (*candidates
&& (*candidates
)->fn
== totype
)
2151 for (i
= 0; i
< len
; ++i
)
2153 tree arg
, argtype
, convert_type
= NULL_TREE
;
2158 else if (i
== 1 && first_arg
!= NULL_TREE
)
2161 arg
= (*arglist
)[i
- (first_arg
!= NULL_TREE
? 1 : 0) - 1];
2162 argtype
= lvalue_type (arg
);
2166 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
2168 convert_type
= totype
;
2170 else if (parmnode
== void_list_node
)
2174 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2175 /*c_cast_p=*/false, flags
, complain
);
2176 convert_type
= TREE_VALUE (parmnode
);
2180 t
= build_identity_conv (argtype
, arg
);
2181 t
->ellipsis_p
= true;
2182 convert_type
= argtype
;
2192 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, arg
, convert_type
);
2199 parmnode
= TREE_CHAIN (parmnode
);
2203 || ! sufficient_parms_p (parmnode
))
2205 int remaining
= remaining_arguments (parmnode
);
2207 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2210 return add_candidate (candidates
, totype
, first_arg
, arglist
, len
, convs
,
2211 access_path
, conversion_path
, viable
, reason
, flags
);
2215 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2216 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
2217 int flags
, tsubst_flags_t complain
)
2224 struct rejection_reason
*reason
= NULL
;
2229 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
2230 convs
= alloc_conversions (num_convs
);
2232 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2233 conversion ops are allowed. We handle that here by just checking for
2234 boolean_type_node because other operators don't ask for it. COND_EXPR
2235 also does contextual conversion to bool for the first operand, but we
2236 handle that in build_conditional_expr, and type1 here is operand 2. */
2237 if (type1
!= boolean_type_node
)
2238 flags
|= LOOKUP_ONLYCONVERTING
;
2240 for (i
= 0; i
< 2; ++i
)
2245 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2246 /*c_cast_p=*/false, flags
, complain
);
2250 /* We need something for printing the candidate. */
2251 t
= build_identity_conv (types
[i
], NULL_TREE
);
2252 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2258 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, args
[i
],
2264 /* For COND_EXPR we rearranged the arguments; undo that now. */
2267 convs
[2] = convs
[1];
2268 convs
[1] = convs
[0];
2269 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2270 /*c_cast_p=*/false, flags
,
2277 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2282 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2284 /*access_path=*/NULL_TREE
,
2285 /*conversion_path=*/NULL_TREE
,
2286 viable
, reason
, flags
);
2290 is_complete (tree t
)
2292 return COMPLETE_TYPE_P (complete_type (t
));
2295 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2298 promoted_arithmetic_type_p (tree type
)
2302 In this section, the term promoted integral type is used to refer
2303 to those integral types which are preserved by integral promotion
2304 (including e.g. int and long but excluding e.g. char).
2305 Similarly, the term promoted arithmetic type refers to promoted
2306 integral types plus floating types. */
2307 return ((CP_INTEGRAL_TYPE_P (type
)
2308 && same_type_p (type_promotes_to (type
), type
))
2309 || TREE_CODE (type
) == REAL_TYPE
);
2312 /* Create any builtin operator overload candidates for the operator in
2313 question given the converted operand types TYPE1 and TYPE2. The other
2314 args are passed through from add_builtin_candidates to
2315 build_builtin_candidate.
2317 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2318 If CODE is requires candidates operands of the same type of the kind
2319 of which TYPE1 and TYPE2 are, we add both candidates
2320 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2323 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2324 enum tree_code code2
, tree fnname
, tree type1
,
2325 tree type2
, tree
*args
, tree
*argtypes
, int flags
,
2326 tsubst_flags_t complain
)
2330 case POSTINCREMENT_EXPR
:
2331 case POSTDECREMENT_EXPR
:
2332 args
[1] = integer_zero_node
;
2333 type2
= integer_type_node
;
2342 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2343 and VQ is either volatile or empty, there exist candidate operator
2344 functions of the form
2345 VQ T& operator++(VQ T&);
2346 T operator++(VQ T&, int);
2347 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2348 type other than bool, and VQ is either volatile or empty, there exist
2349 candidate operator functions of the form
2350 VQ T& operator--(VQ T&);
2351 T operator--(VQ T&, int);
2352 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2353 complete object type, and VQ is either volatile or empty, there exist
2354 candidate operator functions of the form
2355 T*VQ& operator++(T*VQ&);
2356 T*VQ& operator--(T*VQ&);
2357 T* operator++(T*VQ&, int);
2358 T* operator--(T*VQ&, int); */
2360 case POSTDECREMENT_EXPR
:
2361 case PREDECREMENT_EXPR
:
2362 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2364 case POSTINCREMENT_EXPR
:
2365 case PREINCREMENT_EXPR
:
2366 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2368 type1
= build_reference_type (type1
);
2373 /* 7 For every cv-qualified or cv-unqualified object type T, there
2374 exist candidate operator functions of the form
2378 8 For every function type T, there exist candidate operator functions of
2380 T& operator*(T*); */
2383 if (TYPE_PTR_P (type1
)
2384 && (TYPE_PTROB_P (type1
)
2385 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2389 /* 9 For every type T, there exist candidate operator functions of the form
2392 10For every promoted arithmetic type T, there exist candidate operator
2393 functions of the form
2397 case UNARY_PLUS_EXPR
: /* unary + */
2398 if (TYPE_PTR_P (type1
))
2401 if (ARITHMETIC_TYPE_P (type1
))
2405 /* 11For every promoted integral type T, there exist candidate operator
2406 functions of the form
2410 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2414 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2415 is the same type as C2 or is a derived class of C2, T is a complete
2416 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2417 there exist candidate operator functions of the form
2418 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2419 where CV12 is the union of CV1 and CV2. */
2422 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2424 tree c1
= TREE_TYPE (type1
);
2425 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2427 if (MAYBE_CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2428 && (TYPE_PTRMEMFUNC_P (type2
)
2429 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2434 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2435 didate operator functions of the form
2440 bool operator<(L, R);
2441 bool operator>(L, R);
2442 bool operator<=(L, R);
2443 bool operator>=(L, R);
2444 bool operator==(L, R);
2445 bool operator!=(L, R);
2446 where LR is the result of the usual arithmetic conversions between
2449 14For every pair of types T and I, where T is a cv-qualified or cv-
2450 unqualified complete object type and I is a promoted integral type,
2451 there exist candidate operator functions of the form
2452 T* operator+(T*, I);
2453 T& operator[](T*, I);
2454 T* operator-(T*, I);
2455 T* operator+(I, T*);
2456 T& operator[](I, T*);
2458 15For every T, where T is a pointer to complete object type, there exist
2459 candidate operator functions of the form112)
2460 ptrdiff_t operator-(T, T);
2462 16For every pointer or enumeration type T, there exist candidate operator
2463 functions of the form
2464 bool operator<(T, T);
2465 bool operator>(T, T);
2466 bool operator<=(T, T);
2467 bool operator>=(T, T);
2468 bool operator==(T, T);
2469 bool operator!=(T, T);
2471 17For every pointer to member type T, there exist candidate operator
2472 functions of the form
2473 bool operator==(T, T);
2474 bool operator!=(T, T); */
2477 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2479 if (TYPE_PTROB_P (type1
)
2480 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2482 type2
= ptrdiff_type_node
;
2486 case TRUNC_DIV_EXPR
:
2487 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2493 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2494 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
2496 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
2501 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
2513 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2515 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2517 if (TREE_CODE (type1
) == ENUMERAL_TYPE
2518 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
2520 if (TYPE_PTR_P (type1
)
2521 && null_ptr_cst_p (args
[1]))
2526 if (null_ptr_cst_p (args
[0])
2527 && TYPE_PTR_P (type2
))
2535 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2538 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
2540 type1
= ptrdiff_type_node
;
2543 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2545 type2
= ptrdiff_type_node
;
2550 /* 18For every pair of promoted integral types L and R, there exist candi-
2551 date operator functions of the form
2558 where LR is the result of the usual arithmetic conversions between
2561 case TRUNC_MOD_EXPR
:
2567 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2571 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2572 type, VQ is either volatile or empty, and R is a promoted arithmetic
2573 type, there exist candidate operator functions of the form
2574 VQ L& operator=(VQ L&, R);
2575 VQ L& operator*=(VQ L&, R);
2576 VQ L& operator/=(VQ L&, R);
2577 VQ L& operator+=(VQ L&, R);
2578 VQ L& operator-=(VQ L&, R);
2580 20For every pair T, VQ), where T is any type and VQ is either volatile
2581 or empty, there exist candidate operator functions of the form
2582 T*VQ& operator=(T*VQ&, T*);
2584 21For every pair T, VQ), where T is a pointer to member type and VQ is
2585 either volatile or empty, there exist candidate operator functions of
2587 VQ T& operator=(VQ T&, T);
2589 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2590 unqualified complete object type, VQ is either volatile or empty, and
2591 I is a promoted integral type, there exist candidate operator func-
2593 T*VQ& operator+=(T*VQ&, I);
2594 T*VQ& operator-=(T*VQ&, I);
2596 23For every triple L, VQ, R), where L is an integral or enumeration
2597 type, VQ is either volatile or empty, and R is a promoted integral
2598 type, there exist candidate operator functions of the form
2600 VQ L& operator%=(VQ L&, R);
2601 VQ L& operator<<=(VQ L&, R);
2602 VQ L& operator>>=(VQ L&, R);
2603 VQ L& operator&=(VQ L&, R);
2604 VQ L& operator^=(VQ L&, R);
2605 VQ L& operator|=(VQ L&, R); */
2612 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2614 type2
= ptrdiff_type_node
;
2618 case TRUNC_DIV_EXPR
:
2619 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2623 case TRUNC_MOD_EXPR
:
2629 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2634 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2636 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2637 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2638 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2639 || ((TYPE_PTRMEMFUNC_P (type1
)
2640 || TYPE_PTR_P (type1
))
2641 && null_ptr_cst_p (args
[1])))
2651 type1
= build_reference_type (type1
);
2657 For every pair of promoted arithmetic types L and R, there
2658 exist candidate operator functions of the form
2660 LR operator?(bool, L, R);
2662 where LR is the result of the usual arithmetic conversions
2663 between types L and R.
2665 For every type T, where T is a pointer or pointer-to-member
2666 type, there exist candidate operator functions of the form T
2667 operator?(bool, T, T); */
2669 if (promoted_arithmetic_type_p (type1
)
2670 && promoted_arithmetic_type_p (type2
))
2674 /* Otherwise, the types should be pointers. */
2675 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
2678 /* We don't check that the two types are the same; the logic
2679 below will actually create two candidates; one in which both
2680 parameter types are TYPE1, and one in which both parameter
2686 if (ARITHMETIC_TYPE_P (type1
))
2694 /* Make sure we don't create builtin candidates with dependent types. */
2695 bool u1
= uses_template_parms (type1
);
2696 bool u2
= type2
? uses_template_parms (type2
) : false;
2699 /* Try to recover if one of the types is non-dependent. But if
2700 there's only one type, there's nothing we can do. */
2703 /* And we lose if both are dependent. */
2706 /* Or if they have different forms. */
2707 if (TREE_CODE (type1
) != TREE_CODE (type2
))
2716 /* If we're dealing with two pointer types or two enumeral types,
2717 we need candidates for both of them. */
2718 if (type2
&& !same_type_p (type1
, type2
)
2719 && TREE_CODE (type1
) == TREE_CODE (type2
)
2720 && (TREE_CODE (type1
) == REFERENCE_TYPE
2721 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2722 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2723 || TYPE_PTRMEMFUNC_P (type1
)
2724 || MAYBE_CLASS_TYPE_P (type1
)
2725 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2727 if (TYPE_PTR_OR_PTRMEM_P (type1
))
2729 tree cptype
= composite_pointer_type (type1
, type2
,
2734 if (cptype
!= error_mark_node
)
2736 build_builtin_candidate
2737 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
2743 build_builtin_candidate
2744 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
2745 build_builtin_candidate
2746 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
2750 build_builtin_candidate
2751 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
2755 type_decays_to (tree type
)
2757 if (TREE_CODE (type
) == ARRAY_TYPE
)
2758 return build_pointer_type (TREE_TYPE (type
));
2759 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2760 return build_pointer_type (type
);
2764 /* There are three conditions of builtin candidates:
2766 1) bool-taking candidates. These are the same regardless of the input.
2767 2) pointer-pair taking candidates. These are generated for each type
2768 one of the input types converts to.
2769 3) arithmetic candidates. According to the standard, we should generate
2770 all of these, but I'm trying not to...
2772 Here we generate a superset of the possible candidates for this particular
2773 case. That is a subset of the full set the standard defines, plus some
2774 other cases which the standard disallows. add_builtin_candidate will
2775 filter out the invalid set. */
2778 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2779 enum tree_code code2
, tree fnname
, tree
*args
,
2780 int flags
, tsubst_flags_t complain
)
2784 tree type
, argtypes
[3], t
;
2785 /* TYPES[i] is the set of possible builtin-operator parameter types
2786 we will consider for the Ith argument. */
2787 vec
<tree
, va_gc
> *types
[2];
2790 for (i
= 0; i
< 3; ++i
)
2793 argtypes
[i
] = unlowered_expr_type (args
[i
]);
2795 argtypes
[i
] = NULL_TREE
;
2800 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2801 and VQ is either volatile or empty, there exist candidate operator
2802 functions of the form
2803 VQ T& operator++(VQ T&); */
2805 case POSTINCREMENT_EXPR
:
2806 case PREINCREMENT_EXPR
:
2807 case POSTDECREMENT_EXPR
:
2808 case PREDECREMENT_EXPR
:
2813 /* 24There also exist candidate operator functions of the form
2814 bool operator!(bool);
2815 bool operator&&(bool, bool);
2816 bool operator||(bool, bool); */
2818 case TRUTH_NOT_EXPR
:
2819 build_builtin_candidate
2820 (candidates
, fnname
, boolean_type_node
,
2821 NULL_TREE
, args
, argtypes
, flags
, complain
);
2824 case TRUTH_ORIF_EXPR
:
2825 case TRUTH_ANDIF_EXPR
:
2826 build_builtin_candidate
2827 (candidates
, fnname
, boolean_type_node
,
2828 boolean_type_node
, args
, argtypes
, flags
, complain
);
2850 types
[0] = make_tree_vector ();
2851 types
[1] = make_tree_vector ();
2853 for (i
= 0; i
< 2; ++i
)
2857 else if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
2861 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2864 convs
= lookup_conversions (argtypes
[i
]);
2866 if (code
== COND_EXPR
)
2868 if (real_lvalue_p (args
[i
]))
2869 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2871 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
2877 for (; convs
; convs
= TREE_CHAIN (convs
))
2879 type
= TREE_TYPE (convs
);
2882 && (TREE_CODE (type
) != REFERENCE_TYPE
2883 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2886 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2887 vec_safe_push (types
[i
], type
);
2889 type
= non_reference (type
);
2890 if (i
!= 0 || ! ref1
)
2892 type
= cv_unqualified (type_decays_to (type
));
2893 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2894 vec_safe_push (types
[i
], type
);
2895 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2896 type
= type_promotes_to (type
);
2899 if (! vec_member (type
, types
[i
]))
2900 vec_safe_push (types
[i
], type
);
2905 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2906 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2907 type
= non_reference (argtypes
[i
]);
2908 if (i
!= 0 || ! ref1
)
2910 type
= cv_unqualified (type_decays_to (type
));
2911 if (enum_p
&& UNSCOPED_ENUM_P (type
))
2912 vec_safe_push (types
[i
], type
);
2913 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2914 type
= type_promotes_to (type
);
2916 vec_safe_push (types
[i
], type
);
2920 /* Run through the possible parameter types of both arguments,
2921 creating candidates with those parameter types. */
2922 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
2927 if (!types
[1]->is_empty ())
2928 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
2929 add_builtin_candidate
2930 (candidates
, code
, code2
, fnname
, t
,
2931 u
, args
, argtypes
, flags
, complain
);
2933 add_builtin_candidate
2934 (candidates
, code
, code2
, fnname
, t
,
2935 NULL_TREE
, args
, argtypes
, flags
, complain
);
2938 release_tree_vector (types
[0]);
2939 release_tree_vector (types
[1]);
2943 /* If TMPL can be successfully instantiated as indicated by
2944 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2946 TMPL is the template. EXPLICIT_TARGS are any explicit template
2947 arguments. ARGLIST is the arguments provided at the call-site.
2948 This does not change ARGLIST. The RETURN_TYPE is the desired type
2949 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2950 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2951 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2953 static struct z_candidate
*
2954 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
2955 tree ctype
, tree explicit_targs
, tree first_arg
,
2956 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
2957 tree access_path
, tree conversion_path
,
2958 int flags
, tree obj
, unification_kind_t strict
,
2959 tsubst_flags_t complain
)
2961 int ntparms
= DECL_NTPARMS (tmpl
);
2962 tree targs
= make_tree_vec (ntparms
);
2963 unsigned int len
= vec_safe_length (arglist
);
2964 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
2965 unsigned int skip_without_in_chrg
= 0;
2966 tree first_arg_without_in_chrg
= first_arg
;
2967 tree
*args_without_in_chrg
;
2968 unsigned int nargs_without_in_chrg
;
2969 unsigned int ia
, ix
;
2971 struct z_candidate
*cand
;
2973 struct rejection_reason
*reason
= NULL
;
2976 /* We don't do deduction on the in-charge parameter, the VTT
2977 parameter or 'this'. */
2978 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
2980 if (first_arg_without_in_chrg
!= NULL_TREE
)
2981 first_arg_without_in_chrg
= NULL_TREE
;
2983 ++skip_without_in_chrg
;
2986 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
2987 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
2988 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
2990 if (first_arg_without_in_chrg
!= NULL_TREE
)
2991 first_arg_without_in_chrg
= NULL_TREE
;
2993 ++skip_without_in_chrg
;
2996 if (len
< skip_without_in_chrg
)
2999 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
3000 + (len
- skip_without_in_chrg
));
3001 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
3003 if (first_arg_without_in_chrg
!= NULL_TREE
)
3005 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
3008 for (ix
= skip_without_in_chrg
;
3009 vec_safe_iterate (arglist
, ix
, &arg
);
3012 args_without_in_chrg
[ia
] = arg
;
3015 gcc_assert (ia
== nargs_without_in_chrg
);
3017 errs
= errorcount
+sorrycount
;
3018 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
3019 args_without_in_chrg
,
3020 nargs_without_in_chrg
,
3021 return_type
, strict
, flags
, false,
3022 complain
& tf_decltype
);
3024 if (fn
== error_mark_node
)
3026 /* Don't repeat unification later if it already resulted in errors. */
3027 if (errorcount
+sorrycount
== errs
)
3028 reason
= template_unification_rejection (tmpl
, explicit_targs
,
3029 targs
, args_without_in_chrg
,
3030 nargs_without_in_chrg
,
3031 return_type
, strict
, flags
);
3033 reason
= template_unification_error_rejection ();
3039 A member function template is never instantiated to perform the
3040 copy of a class object to an object of its class type.
3042 It's a little unclear what this means; the standard explicitly
3043 does allow a template to be used to copy a class. For example,
3048 template <class T> A(const T&);
3051 void g () { A a (f ()); }
3053 the member template will be used to make the copy. The section
3054 quoted above appears in the paragraph that forbids constructors
3055 whose only parameter is (a possibly cv-qualified variant of) the
3056 class type, and a logical interpretation is that the intent was
3057 to forbid the instantiation of member templates which would then
3059 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
3061 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3062 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
3065 reason
= invalid_copy_with_fn_template_rejection ();
3070 if (obj
!= NULL_TREE
)
3071 /* Aha, this is a conversion function. */
3072 cand
= add_conv_candidate (candidates
, fn
, obj
, first_arg
, arglist
,
3073 access_path
, conversion_path
, complain
);
3075 cand
= add_function_candidate (candidates
, fn
, ctype
,
3076 first_arg
, arglist
, access_path
,
3077 conversion_path
, flags
, complain
);
3078 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
3079 /* This situation can occur if a member template of a template
3080 class is specialized. Then, instantiate_template might return
3081 an instantiation of the specialization, in which case the
3082 DECL_TI_TEMPLATE field will point at the original
3083 specialization. For example:
3085 template <class T> struct S { template <class U> void f(U);
3086 template <> void f(int) {}; };
3090 Here, TMPL will be template <class U> S<double>::f(U).
3091 And, instantiate template will give us the specialization
3092 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3093 for this will point at template <class T> template <> S<T>::f(int),
3094 so that we can find the definition. For the purposes of
3095 overload resolution, however, we want the original TMPL. */
3096 cand
->template_decl
= build_template_info (tmpl
, targs
);
3098 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3099 cand
->explicit_targs
= explicit_targs
;
3103 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, NULL
,
3104 access_path
, conversion_path
, 0, reason
, flags
);
3108 static struct z_candidate
*
3109 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3110 tree explicit_targs
, tree first_arg
,
3111 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3112 tree access_path
, tree conversion_path
, int flags
,
3113 unification_kind_t strict
, tsubst_flags_t complain
)
3116 add_template_candidate_real (candidates
, tmpl
, ctype
,
3117 explicit_targs
, first_arg
, arglist
,
3118 return_type
, access_path
, conversion_path
,
3119 flags
, NULL_TREE
, strict
, complain
);
3123 static struct z_candidate
*
3124 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3125 tree obj
, tree first_arg
,
3126 const vec
<tree
, va_gc
> *arglist
,
3127 tree return_type
, tree access_path
,
3128 tree conversion_path
, tsubst_flags_t complain
)
3131 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3132 first_arg
, arglist
, return_type
, access_path
,
3133 conversion_path
, 0, obj
, DEDUCE_CONV
,
3137 /* The CANDS are the set of candidates that were considered for
3138 overload resolution. Return the set of viable candidates, or CANDS
3139 if none are viable. If any of the candidates were viable, set
3140 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3141 considered viable only if it is strictly viable. */
3143 static struct z_candidate
*
3144 splice_viable (struct z_candidate
*cands
,
3148 struct z_candidate
*viable
;
3149 struct z_candidate
**last_viable
;
3150 struct z_candidate
**cand
;
3151 bool found_strictly_viable
= false;
3153 /* Be strict inside templates, since build_over_call won't actually
3154 do the conversions to get pedwarns. */
3155 if (processing_template_decl
)
3159 last_viable
= &viable
;
3160 *any_viable_p
= false;
3165 struct z_candidate
*c
= *cand
;
3167 && (c
->viable
== 1 || TREE_CODE (c
->fn
) == TEMPLATE_DECL
))
3169 /* Be strict in the presence of a viable candidate. Also if
3170 there are template candidates, so that we get deduction errors
3171 for them instead of silently preferring a bad conversion. */
3173 if (viable
&& !found_strictly_viable
)
3175 /* Put any spliced near matches back onto the main list so
3176 that we see them if there is no strict match. */
3177 *any_viable_p
= false;
3178 *last_viable
= cands
;
3181 last_viable
= &viable
;
3185 if (strict_p
? c
->viable
== 1 : c
->viable
)
3190 last_viable
= &c
->next
;
3191 *any_viable_p
= true;
3193 found_strictly_viable
= true;
3199 return viable
? viable
: cands
;
3203 any_strictly_viable (struct z_candidate
*cands
)
3205 for (; cands
; cands
= cands
->next
)
3206 if (cands
->viable
== 1)
3211 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3212 words, it is about to become the "this" pointer for a member
3213 function call. Take the address of the object. */
3216 build_this (tree obj
)
3218 /* In a template, we are only concerned about the type of the
3219 expression, so we can take a shortcut. */
3220 if (processing_template_decl
)
3221 return build_address (obj
);
3223 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3226 /* Returns true iff functions are equivalent. Equivalent functions are
3227 not '==' only if one is a function-local extern function or if
3228 both are extern "C". */
3231 equal_functions (tree fn1
, tree fn2
)
3233 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3235 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3237 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
3238 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3239 return decls_match (fn1
, fn2
);
3243 /* Print information about a candidate being rejected due to INFO. */
3246 print_conversion_rejection (location_t loc
, struct conversion_info
*info
)
3248 tree from
= info
->from
;
3250 from
= lvalue_type (from
);
3251 if (info
->n_arg
== -1)
3253 /* Conversion of implicit `this' argument failed. */
3254 if (!TYPE_P (info
->from
))
3255 /* A bad conversion for 'this' must be discarding cv-quals. */
3256 inform (loc
, " passing %qT as %<this%> "
3257 "argument discards qualifiers",
3260 inform (loc
, " no known conversion for implicit "
3261 "%<this%> parameter from %qT to %qT",
3262 from
, info
->to_type
);
3264 else if (!TYPE_P (info
->from
))
3266 if (info
->n_arg
>= 0)
3267 inform (loc
, " conversion of argument %d would be ill-formed:",
3269 perform_implicit_conversion (info
->to_type
, info
->from
,
3270 tf_warning_or_error
);
3272 else if (info
->n_arg
== -2)
3273 /* Conversion of conversion function return value failed. */
3274 inform (loc
, " no known conversion from %qT to %qT",
3275 from
, info
->to_type
);
3277 inform (loc
, " no known conversion for argument %d from %qT to %qT",
3278 info
->n_arg
+ 1, from
, info
->to_type
);
3281 /* Print information about a candidate with WANT parameters and we found
3285 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
)
3287 inform_n (loc
, want
,
3288 " candidate expects %d argument, %d provided",
3289 " candidate expects %d arguments, %d provided",
3293 /* Print information about one overload candidate CANDIDATE. MSGSTR
3294 is the text to print before the candidate itself.
3296 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3297 to have been run through gettext by the caller. This wart makes
3298 life simpler in print_z_candidates and for the translators. */
3301 print_z_candidate (location_t loc
, const char *msgstr
,
3302 struct z_candidate
*candidate
)
3304 const char *msg
= (msgstr
== NULL
3306 : ACONCAT ((msgstr
, " ", NULL
)));
3307 location_t cloc
= location_of (candidate
->fn
);
3309 if (identifier_p (candidate
->fn
))
3312 if (candidate
->num_convs
== 3)
3313 inform (cloc
, "%s%D(%T, %T, %T) <built-in>", msg
, candidate
->fn
,
3314 candidate
->convs
[0]->type
,
3315 candidate
->convs
[1]->type
,
3316 candidate
->convs
[2]->type
);
3317 else if (candidate
->num_convs
== 2)
3318 inform (cloc
, "%s%D(%T, %T) <built-in>", msg
, candidate
->fn
,
3319 candidate
->convs
[0]->type
,
3320 candidate
->convs
[1]->type
);
3322 inform (cloc
, "%s%D(%T) <built-in>", msg
, candidate
->fn
,
3323 candidate
->convs
[0]->type
);
3325 else if (TYPE_P (candidate
->fn
))
3326 inform (cloc
, "%s%T <conversion>", msg
, candidate
->fn
);
3327 else if (candidate
->viable
== -1)
3328 inform (cloc
, "%s%#D <near match>", msg
, candidate
->fn
);
3329 else if (DECL_DELETED_FN (candidate
->fn
))
3330 inform (cloc
, "%s%#D <deleted>", msg
, candidate
->fn
);
3332 inform (cloc
, "%s%#D", msg
, candidate
->fn
);
3333 /* Give the user some information about why this candidate failed. */
3334 if (candidate
->reason
!= NULL
)
3336 struct rejection_reason
*r
= candidate
->reason
;
3341 print_arity_information (cloc
, r
->u
.arity
.actual
,
3342 r
->u
.arity
.expected
);
3344 case rr_arg_conversion
:
3345 print_conversion_rejection (cloc
, &r
->u
.conversion
);
3347 case rr_bad_arg_conversion
:
3348 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
);
3350 case rr_explicit_conversion
:
3351 inform (cloc
, " return type %qT of explicit conversion function "
3352 "cannot be converted to %qT with a qualification "
3353 "conversion", r
->u
.conversion
.from
,
3354 r
->u
.conversion
.to_type
);
3356 case rr_template_conversion
:
3357 inform (cloc
, " conversion from return type %qT of template "
3358 "conversion function specialization to %qT is not an "
3359 "exact match", r
->u
.conversion
.from
,
3360 r
->u
.conversion
.to_type
);
3362 case rr_template_unification
:
3363 /* We use template_unification_error_rejection if unification caused
3364 actual non-SFINAE errors, in which case we don't need to repeat
3366 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
3368 inform (cloc
, " substitution of deduced template arguments "
3369 "resulted in errors seen above");
3372 /* Re-run template unification with diagnostics. */
3373 inform (cloc
, " template argument deduction/substitution failed:");
3374 fn_type_unification (r
->u
.template_unification
.tmpl
,
3375 r
->u
.template_unification
.explicit_targs
,
3377 (r
->u
.template_unification
.num_targs
)),
3378 r
->u
.template_unification
.args
,
3379 r
->u
.template_unification
.nargs
,
3380 r
->u
.template_unification
.return_type
,
3381 r
->u
.template_unification
.strict
,
3382 r
->u
.template_unification
.flags
,
3385 case rr_invalid_copy
:
3387 " a constructor taking a single argument of its own "
3388 "class type is invalid");
3392 /* This candidate didn't have any issues or we failed to
3393 handle a particular code. Either way... */
3400 print_z_candidates (location_t loc
, struct z_candidate
*candidates
)
3402 struct z_candidate
*cand1
;
3403 struct z_candidate
**cand2
;
3408 /* Remove non-viable deleted candidates. */
3410 for (cand2
= &cand1
; *cand2
; )
3412 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
3413 && !(*cand2
)->viable
3414 && DECL_DELETED_FN ((*cand2
)->fn
))
3415 *cand2
= (*cand2
)->next
;
3417 cand2
= &(*cand2
)->next
;
3419 /* ...if there are any non-deleted ones. */
3423 /* There may be duplicates in the set of candidates. We put off
3424 checking this condition as long as possible, since we have no way
3425 to eliminate duplicates from a set of functions in less than n^2
3426 time. Now we are about to emit an error message, so it is more
3427 permissible to go slowly. */
3428 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3430 tree fn
= cand1
->fn
;
3431 /* Skip builtin candidates and conversion functions. */
3434 cand2
= &cand1
->next
;
3437 if (DECL_P ((*cand2
)->fn
)
3438 && equal_functions (fn
, (*cand2
)->fn
))
3439 *cand2
= (*cand2
)->next
;
3441 cand2
= &(*cand2
)->next
;
3445 for (; candidates
; candidates
= candidates
->next
)
3446 print_z_candidate (loc
, "candidate:", candidates
);
3449 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3450 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3451 the result of the conversion function to convert it to the final
3452 desired type. Merge the two sequences into a single sequence,
3453 and return the merged sequence. */
3456 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
3459 bool bad
= user_seq
->bad_p
;
3461 gcc_assert (user_seq
->kind
== ck_user
);
3463 /* Find the end of the second conversion sequence. */
3464 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
3466 /* The entire sequence is a user-conversion sequence. */
3467 (*t
)->user_conv_p
= true;
3472 /* Replace the identity conversion with the user conversion
3479 /* Handle overload resolution for initializing an object of class type from
3480 an initializer list. First we look for a suitable constructor that
3481 takes a std::initializer_list; if we don't find one, we then look for a
3482 non-list constructor.
3484 Parameters are as for add_candidates, except that the arguments are in
3485 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3486 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3489 add_list_candidates (tree fns
, tree first_arg
,
3490 tree init_list
, tree totype
,
3491 tree explicit_targs
, bool template_only
,
3492 tree conversion_path
, tree access_path
,
3494 struct z_candidate
**candidates
,
3495 tsubst_flags_t complain
)
3497 vec
<tree
, va_gc
> *args
;
3499 gcc_assert (*candidates
== NULL
);
3501 /* We're looking for a ctor for list-initialization. */
3502 flags
|= LOOKUP_LIST_INIT_CTOR
;
3503 /* And we don't allow narrowing conversions. We also use this flag to
3504 avoid the copy constructor call for copy-list-initialization. */
3505 flags
|= LOOKUP_NO_NARROWING
;
3507 /* Always use the default constructor if the list is empty (DR 990). */
3508 if (CONSTRUCTOR_NELTS (init_list
) == 0
3509 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
3511 /* If the class has a list ctor, try passing the list as a single
3512 argument first, but only consider list ctors. */
3513 else if (TYPE_HAS_LIST_CTOR (totype
))
3515 flags
|= LOOKUP_LIST_ONLY
;
3516 args
= make_tree_vector_single (init_list
);
3517 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3518 explicit_targs
, template_only
, conversion_path
,
3519 access_path
, flags
, candidates
, complain
);
3520 if (any_strictly_viable (*candidates
))
3524 args
= ctor_to_vec (init_list
);
3526 /* We aren't looking for list-ctors anymore. */
3527 flags
&= ~LOOKUP_LIST_ONLY
;
3528 /* We allow more user-defined conversions within an init-list. */
3529 flags
&= ~LOOKUP_NO_CONVERSION
;
3531 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3532 explicit_targs
, template_only
, conversion_path
,
3533 access_path
, flags
, candidates
, complain
);
3536 /* Returns the best overload candidate to perform the requested
3537 conversion. This function is used for three the overloading situations
3538 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3539 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3540 per [dcl.init.ref], so we ignore temporary bindings. */
3542 static struct z_candidate
*
3543 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
3544 tsubst_flags_t complain
)
3546 struct z_candidate
*candidates
, *cand
;
3548 tree ctors
= NULL_TREE
;
3549 tree conv_fns
= NULL_TREE
;
3550 conversion
*conv
= NULL
;
3551 tree first_arg
= NULL_TREE
;
3552 vec
<tree
, va_gc
> *args
= NULL
;
3559 fromtype
= TREE_TYPE (expr
);
3561 /* We represent conversion within a hierarchy using RVALUE_CONV and
3562 BASE_CONV, as specified by [over.best.ics]; these become plain
3563 constructor calls, as specified in [dcl.init]. */
3564 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
3565 || !DERIVED_FROM_P (totype
, fromtype
));
3567 if (MAYBE_CLASS_TYPE_P (totype
))
3568 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3569 creating a garbage BASELINK; constructors can't be inherited. */
3570 ctors
= lookup_fnfields_slot (totype
, complete_ctor_identifier
);
3572 if (MAYBE_CLASS_TYPE_P (fromtype
))
3574 tree to_nonref
= non_reference (totype
);
3575 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
3576 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
3577 && DERIVED_FROM_P (to_nonref
, fromtype
)))
3579 /* [class.conv.fct] A conversion function is never used to
3580 convert a (possibly cv-qualified) object to the (possibly
3581 cv-qualified) same object type (or a reference to it), to a
3582 (possibly cv-qualified) base class of that type (or a
3583 reference to it)... */
3586 conv_fns
= lookup_conversions (fromtype
);
3590 flags
|= LOOKUP_NO_CONVERSION
;
3591 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3592 flags
|= LOOKUP_NO_NARROWING
;
3594 /* It's OK to bind a temporary for converting constructor arguments, but
3595 not in converting the return value of a conversion operator. */
3596 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
3597 | (flags
& LOOKUP_NO_NARROWING
));
3598 flags
&= ~LOOKUP_NO_TEMP_BIND
;
3602 int ctorflags
= flags
;
3604 first_arg
= build_dummy_object (totype
);
3606 /* We should never try to call the abstract or base constructor
3608 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
3609 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
3611 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3613 /* List-initialization. */
3614 add_list_candidates (ctors
, first_arg
, expr
, totype
, NULL_TREE
,
3615 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3616 ctorflags
, &candidates
, complain
);
3620 args
= make_tree_vector_single (expr
);
3621 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
3622 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3623 ctorflags
, &candidates
, complain
);
3626 for (cand
= candidates
; cand
; cand
= cand
->next
)
3628 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
3630 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3631 set, then this is copy-initialization. In that case, "The
3632 result of the call is then used to direct-initialize the
3633 object that is the destination of the copy-initialization."
3636 We represent this in the conversion sequence with an
3637 rvalue conversion, which means a constructor call. */
3638 if (TREE_CODE (totype
) != REFERENCE_TYPE
3639 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3641 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
3648 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
3650 tree conversion_path
= TREE_PURPOSE (conv_fns
);
3651 struct z_candidate
*old_candidates
;
3653 /* If we are called to convert to a reference type, we are trying to
3654 find a direct binding, so don't even consider temporaries. If
3655 we don't find a direct binding, the caller will try again to
3656 look for a temporary binding. */
3657 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
3658 convflags
|= LOOKUP_NO_TEMP_BIND
;
3660 old_candidates
= candidates
;
3661 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
3663 conversion_path
, TYPE_BINFO (fromtype
),
3664 flags
, &candidates
, complain
);
3666 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
3668 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
3670 = implicit_conversion (totype
,
3673 /*c_cast_p=*/false, convflags
,
3676 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3677 copy-initialization. In that case, "The result of the
3678 call is then used to direct-initialize the object that is
3679 the destination of the copy-initialization." [dcl.init]
3681 We represent this in the conversion sequence with an
3682 rvalue conversion, which means a constructor call. But
3683 don't add a second rvalue conversion if there's already
3684 one there. Which there really shouldn't be, but it's
3685 harmless since we'd add it here anyway. */
3686 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
3687 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3688 ics
= build_conv (ck_rvalue
, totype
, ics
);
3690 cand
->second_conv
= ics
;
3695 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -2,
3698 else if (DECL_NONCONVERTING_P (cand
->fn
)
3699 && ics
->rank
> cr_exact
)
3701 /* 13.3.1.5: For direct-initialization, those explicit
3702 conversion functions that are not hidden within S and
3703 yield type T or a type that can be converted to type T
3704 with a qualification conversion (4.4) are also candidate
3706 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3707 I've raised this issue with the committee. --jason 9/2011 */
3709 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
3711 else if (cand
->viable
== 1 && ics
->bad_p
)
3715 = bad_arg_conversion_rejection (NULL_TREE
, -2,
3718 else if (primary_template_instantiation_p (cand
->fn
)
3719 && ics
->rank
> cr_exact
)
3721 /* 13.3.3.1.2: If the user-defined conversion is specified by
3722 a specialization of a conversion function template, the
3723 second standard conversion sequence shall have exact match
3726 cand
->reason
= template_conversion_rejection (rettype
, totype
);
3731 candidates
= splice_viable (candidates
, false, &any_viable_p
);
3735 release_tree_vector (args
);
3739 cand
= tourney (candidates
, complain
);
3742 if (complain
& tf_error
)
3744 error ("conversion from %qT to %qT is ambiguous",
3746 print_z_candidates (location_of (expr
), candidates
);
3749 cand
= candidates
; /* any one will do */
3750 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
3751 cand
->second_conv
->user_conv_p
= true;
3752 if (!any_strictly_viable (candidates
))
3753 cand
->second_conv
->bad_p
= true;
3754 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3755 ambiguous conversion is no worse than another user-defined
3762 if (!DECL_CONSTRUCTOR_P (cand
->fn
))
3763 convtype
= non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)));
3764 else if (cand
->second_conv
->kind
== ck_rvalue
)
3765 /* DR 5: [in the first step of copy-initialization]...if the function
3766 is a constructor, the call initializes a temporary of the
3767 cv-unqualified version of the destination type. */
3768 convtype
= cv_unqualified (totype
);
3771 /* Build the user conversion sequence. */
3775 build_identity_conv (TREE_TYPE (expr
), expr
));
3777 if (cand
->viable
== -1)
3780 /* Remember that this was a list-initialization. */
3781 if (flags
& LOOKUP_NO_NARROWING
)
3782 conv
->check_narrowing
= true;
3784 /* Combine it with the second conversion sequence. */
3785 cand
->second_conv
= merge_conversion_sequences (conv
,
3791 /* Wrapper for above. */
3794 build_user_type_conversion (tree totype
, tree expr
, int flags
,
3795 tsubst_flags_t complain
)
3797 struct z_candidate
*cand
;
3800 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3801 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
3805 if (cand
->second_conv
->kind
== ck_ambig
)
3806 ret
= error_mark_node
;
3809 expr
= convert_like (cand
->second_conv
, expr
, complain
);
3810 ret
= convert_from_reference (expr
);
3816 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3820 /* Subroutine of convert_nontype_argument.
3822 EXPR is an argument for a template non-type parameter of integral or
3823 enumeration type. Do any necessary conversions (that are permitted for
3824 non-type arguments) to convert it to the parameter type.
3826 If conversion is successful, returns the converted expression;
3827 otherwise, returns error_mark_node. */
3830 build_integral_nontype_arg_conv (tree type
, tree expr
, tsubst_flags_t complain
)
3835 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
3837 if (error_operand_p (expr
))
3838 return error_mark_node
;
3840 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
3842 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3843 p
= conversion_obstack_alloc (0);
3845 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
3847 LOOKUP_IMPLICIT
, complain
);
3849 /* for a non-type template-parameter of integral or
3850 enumeration type, integral promotions (4.5) and integral
3851 conversions (4.7) are applied. */
3852 /* It should be sufficient to check the outermost conversion step, since
3853 there are no qualification conversions to integer type. */
3857 /* A conversion function is OK. If it isn't constexpr, we'll
3858 complain later that the argument isn't constant. */
3860 /* The lvalue-to-rvalue conversion is OK. */
3866 t
= next_conversion (conv
)->type
;
3867 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
3870 if (complain
& tf_error
)
3871 error_at (loc
, "conversion from %qT to %qT not considered for "
3872 "non-type template argument", t
, type
);
3873 /* and fall through. */
3881 expr
= convert_like (conv
, expr
, complain
);
3883 expr
= error_mark_node
;
3885 /* Free all the conversions we allocated. */
3886 obstack_free (&conversion_obstack
, p
);
3891 /* Do any initial processing on the arguments to a function call. */
3893 static vec
<tree
, va_gc
> *
3894 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
3899 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
3901 if (error_operand_p (arg
))
3903 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
3905 if (complain
& tf_error
)
3906 error ("invalid use of void expression");
3909 else if (invalid_nonstatic_memfn_p (input_location
, arg
, complain
))
3915 /* Perform overload resolution on FN, which is called with the ARGS.
3917 Return the candidate function selected by overload resolution, or
3918 NULL if the event that overload resolution failed. In the case
3919 that overload resolution fails, *CANDIDATES will be the set of
3920 candidates considered, and ANY_VIABLE_P will be set to true or
3921 false to indicate whether or not any of the candidates were
3924 The ARGS should already have gone through RESOLVE_ARGS before this
3925 function is called. */
3927 static struct z_candidate
*
3928 perform_overload_resolution (tree fn
,
3929 const vec
<tree
, va_gc
> *args
,
3930 struct z_candidate
**candidates
,
3931 bool *any_viable_p
, tsubst_flags_t complain
)
3933 struct z_candidate
*cand
;
3934 tree explicit_targs
;
3937 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3939 explicit_targs
= NULL_TREE
;
3943 *any_viable_p
= true;
3946 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
3947 || TREE_CODE (fn
) == TEMPLATE_DECL
3948 || TREE_CODE (fn
) == OVERLOAD
3949 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
3951 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
3953 explicit_targs
= TREE_OPERAND (fn
, 1);
3954 fn
= TREE_OPERAND (fn
, 0);
3958 /* Add the various candidate functions. */
3959 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
3960 explicit_targs
, template_only
,
3961 /*conversion_path=*/NULL_TREE
,
3962 /*access_path=*/NULL_TREE
,
3964 candidates
, complain
);
3966 *candidates
= splice_viable (*candidates
, false, any_viable_p
);
3968 cand
= tourney (*candidates
, complain
);
3972 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3976 /* Print an error message about being unable to build a call to FN with
3977 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
3978 be located; CANDIDATES is a possibly empty list of such
3982 print_error_for_call_failure (tree fn
, vec
<tree
, va_gc
> *args
,
3983 struct z_candidate
*candidates
)
3985 tree name
= DECL_NAME (OVL_CURRENT (fn
));
3986 location_t loc
= location_of (name
);
3988 if (!any_strictly_viable (candidates
))
3989 error_at (loc
, "no matching function for call to %<%D(%A)%>",
3990 name
, build_tree_list_vec (args
));
3992 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
3993 name
, build_tree_list_vec (args
));
3995 print_z_candidates (loc
, candidates
);
3998 /* Return an expression for a call to FN (a namespace-scope function,
3999 or a static member function) with the ARGS. This may change
4003 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
, bool koenig_p
,
4004 tsubst_flags_t complain
)
4006 struct z_candidate
*candidates
, *cand
;
4011 if (args
!= NULL
&& *args
!= NULL
)
4013 *args
= resolve_args (*args
, complain
);
4015 return error_mark_node
;
4019 tm_malloc_replacement (fn
);
4021 /* If this function was found without using argument dependent
4022 lookup, then we want to ignore any undeclared friend
4028 fn
= remove_hidden_names (fn
);
4031 if (complain
& tf_error
)
4032 print_error_for_call_failure (orig_fn
, *args
, NULL
);
4033 return error_mark_node
;
4037 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4038 p
= conversion_obstack_alloc (0);
4040 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
4045 if (complain
& tf_error
)
4047 if (!any_viable_p
&& candidates
&& ! candidates
->next
4048 && (TREE_CODE (candidates
->fn
) == FUNCTION_DECL
))
4049 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
4050 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4051 fn
= TREE_OPERAND (fn
, 0);
4052 print_error_for_call_failure (fn
, *args
, candidates
);
4054 result
= error_mark_node
;
4058 int flags
= LOOKUP_NORMAL
;
4059 /* If fn is template_id_expr, the call has explicit template arguments
4060 (e.g. func<int>(5)), communicate this info to build_over_call
4061 through flags so that later we can use it to decide whether to warn
4062 about peculiar null pointer conversion. */
4063 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4064 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
4065 result
= build_over_call (cand
, flags
, complain
);
4068 /* Free all the conversions we allocated. */
4069 obstack_free (&conversion_obstack
, p
);
4074 /* Build a call to a global operator new. FNNAME is the name of the
4075 operator (either "operator new" or "operator new[]") and ARGS are
4076 the arguments provided. This may change ARGS. *SIZE points to the
4077 total number of bytes required by the allocation, and is updated if
4078 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
4079 be used. If this function determines that no cookie should be
4080 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
4081 is not NULL_TREE, it is evaluated before calculating the final
4082 array size, and if it fails, the array size is replaced with
4083 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
4084 is non-NULL, it will be set, upon return, to the allocation
4088 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
4089 tree
*size
, tree
*cookie_size
, tree size_check
,
4090 tree
*fn
, tsubst_flags_t complain
)
4092 tree original_size
= *size
;
4094 struct z_candidate
*candidates
;
4095 struct z_candidate
*cand
;
4100 /* Set to (size_t)-1 if the size check fails. */
4101 if (size_check
!= NULL_TREE
)
4103 tree errval
= TYPE_MAX_VALUE (sizetype
);
4104 if (cxx_dialect
>= cxx11
&& flag_exceptions
)
4105 errval
= throw_bad_array_new_length ();
4106 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4107 original_size
, errval
);
4109 vec_safe_insert (*args
, 0, *size
);
4110 *args
= resolve_args (*args
, complain
);
4112 return error_mark_node
;
4118 If this lookup fails to find the name, or if the allocated type
4119 is not a class type, the allocation function's name is looked
4120 up in the global scope.
4122 we disregard block-scope declarations of "operator new". */
4123 fns
= lookup_function_nonclass (fnname
, *args
, /*block_p=*/false);
4125 /* Figure out what function is being called. */
4126 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
4129 /* If no suitable function could be found, issue an error message
4133 if (complain
& tf_error
)
4134 print_error_for_call_failure (fns
, *args
, candidates
);
4135 return error_mark_node
;
4138 /* If a cookie is required, add some extra space. Whether
4139 or not a cookie is required cannot be determined until
4140 after we know which function was called. */
4143 bool use_cookie
= true;
4146 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
4147 /* Skip the size_t parameter. */
4148 arg_types
= TREE_CHAIN (arg_types
);
4149 /* Check the remaining parameters (if any). */
4151 && TREE_CHAIN (arg_types
) == void_list_node
4152 && same_type_p (TREE_VALUE (arg_types
),
4155 /* If we need a cookie, adjust the number of bytes allocated. */
4158 /* Update the total size. */
4159 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
4160 /* Set to (size_t)-1 if the size check fails. */
4161 gcc_assert (size_check
!= NULL_TREE
);
4162 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4163 *size
, TYPE_MAX_VALUE (sizetype
));
4164 /* Update the argument list to reflect the adjusted size. */
4165 (**args
)[0] = *size
;
4168 *cookie_size
= NULL_TREE
;
4171 /* Tell our caller which function we decided to call. */
4175 /* Build the CALL_EXPR. */
4176 return build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4179 /* Build a new call to operator(). This may change ARGS. */
4182 build_op_call_1 (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4184 struct z_candidate
*candidates
= 0, *cand
;
4185 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
4186 tree type
= TREE_TYPE (obj
);
4188 tree result
= NULL_TREE
;
4191 if (error_operand_p (obj
))
4192 return error_mark_node
;
4194 obj
= prep_operand (obj
);
4196 if (TYPE_PTRMEMFUNC_P (type
))
4198 if (complain
& tf_error
)
4199 /* It's no good looking for an overloaded operator() on a
4200 pointer-to-member-function. */
4201 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
4202 return error_mark_node
;
4205 if (TYPE_BINFO (type
))
4207 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
4208 if (fns
== error_mark_node
)
4209 return error_mark_node
;
4214 if (args
!= NULL
&& *args
!= NULL
)
4216 *args
= resolve_args (*args
, complain
);
4218 return error_mark_node
;
4221 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4222 p
= conversion_obstack_alloc (0);
4226 first_mem_arg
= obj
;
4228 add_candidates (BASELINK_FUNCTIONS (fns
),
4229 first_mem_arg
, *args
, NULL_TREE
,
4231 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
4232 LOOKUP_NORMAL
, &candidates
, complain
);
4235 convs
= lookup_conversions (type
);
4237 for (; convs
; convs
= TREE_CHAIN (convs
))
4239 tree fns
= TREE_VALUE (convs
);
4240 tree totype
= TREE_TYPE (convs
);
4242 if (TYPE_PTRFN_P (totype
)
4243 || TYPE_REFFN_P (totype
)
4244 || (TREE_CODE (totype
) == REFERENCE_TYPE
4245 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
4246 for (; fns
; fns
= OVL_NEXT (fns
))
4248 tree fn
= OVL_CURRENT (fns
);
4250 if (DECL_NONCONVERTING_P (fn
))
4253 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4254 add_template_conv_candidate
4255 (&candidates
, fn
, obj
, NULL_TREE
, *args
, totype
,
4256 /*access_path=*/NULL_TREE
,
4257 /*conversion_path=*/NULL_TREE
, complain
);
4259 add_conv_candidate (&candidates
, fn
, obj
, NULL_TREE
,
4260 *args
, /*conversion_path=*/NULL_TREE
,
4261 /*access_path=*/NULL_TREE
, complain
);
4265 /* Be strict here because if we choose a bad conversion candidate, the
4266 errors we get won't mention the call context. */
4267 candidates
= splice_viable (candidates
, true, &any_viable_p
);
4270 if (complain
& tf_error
)
4272 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
4273 build_tree_list_vec (*args
));
4274 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4276 result
= error_mark_node
;
4280 cand
= tourney (candidates
, complain
);
4283 if (complain
& tf_error
)
4285 error ("call of %<(%T) (%A)%> is ambiguous",
4286 TREE_TYPE (obj
), build_tree_list_vec (*args
));
4287 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4289 result
= error_mark_node
;
4291 /* Since cand->fn will be a type, not a function, for a conversion
4292 function, we must be careful not to unconditionally look at
4294 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
4295 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
4296 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4299 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
, -1,
4301 obj
= convert_from_reference (obj
);
4302 result
= cp_build_function_call_vec (obj
, args
, complain
);
4306 /* Free all the conversions we allocated. */
4307 obstack_free (&conversion_obstack
, p
);
4312 /* Wrapper for above. */
4315 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4318 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4319 ret
= build_op_call_1 (obj
, args
, complain
);
4320 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4324 /* Called by op_error to prepare format strings suitable for the error
4325 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4326 and a suffix (controlled by NTYPES). */
4329 op_error_string (const char *errmsg
, int ntypes
, bool match
)
4333 const char *msgp
= concat (match
? G_("ambiguous overload for ")
4334 : G_("no match for "), errmsg
, NULL
);
4337 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
4338 else if (ntypes
== 2)
4339 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
4341 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
4347 op_error (location_t loc
, enum tree_code code
, enum tree_code code2
,
4348 tree arg1
, tree arg2
, tree arg3
, bool match
)
4352 if (code
== MODIFY_EXPR
)
4353 opname
= assignment_operator_name_info
[code2
].name
;
4355 opname
= operator_name_info
[code
].name
;
4360 if (flag_diagnostics_show_caret
)
4361 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
4363 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4365 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
4366 "in %<%E ? %E : %E%>"), 3, match
),
4368 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4371 case POSTINCREMENT_EXPR
:
4372 case POSTDECREMENT_EXPR
:
4373 if (flag_diagnostics_show_caret
)
4374 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4375 opname
, TREE_TYPE (arg1
));
4377 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4379 opname
, arg1
, opname
, TREE_TYPE (arg1
));
4383 if (flag_diagnostics_show_caret
)
4384 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
4385 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4387 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4389 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4394 if (flag_diagnostics_show_caret
)
4395 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
4396 opname
, TREE_TYPE (arg1
));
4398 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
4399 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4404 if (flag_diagnostics_show_caret
)
4405 error_at (loc
, op_error_string (G_("%<operator%s%>"), 2, match
),
4406 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4408 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4410 opname
, arg1
, opname
, arg2
,
4411 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4413 if (flag_diagnostics_show_caret
)
4414 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4415 opname
, TREE_TYPE (arg1
));
4417 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4419 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4424 /* Return the implicit conversion sequence that could be used to
4425 convert E1 to E2 in [expr.cond]. */
4428 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
4430 tree t1
= non_reference (TREE_TYPE (e1
));
4431 tree t2
= non_reference (TREE_TYPE (e2
));
4437 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4438 implicitly converted (clause _conv_) to the type "lvalue reference to
4439 T2", subject to the constraint that in the conversion the
4440 reference must bind directly (_dcl.init.ref_) to an lvalue.
4442 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
4443 implicitly converted to the type "rvalue reference to T2", subject to
4444 the constraint that the reference must bind directly. */
4445 if (lvalue_or_rvalue_with_address_p (e2
))
4447 tree rtype
= cp_build_reference_type (t2
, !real_lvalue_p (e2
));
4448 conv
= implicit_conversion (rtype
,
4452 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
4453 |LOOKUP_ONLYCONVERTING
,
4455 if (conv
&& !conv
->bad_p
)
4459 /* If E2 is a prvalue or if neither of the conversions above can be done
4460 and at least one of the operands has (possibly cv-qualified) class
4462 if (!CLASS_TYPE_P (t1
) && !CLASS_TYPE_P (t2
))
4467 If E1 and E2 have class type, and the underlying class types are
4468 the same or one is a base class of the other: E1 can be converted
4469 to match E2 if the class of T2 is the same type as, or a base
4470 class of, the class of T1, and the cv-qualification of T2 is the
4471 same cv-qualification as, or a greater cv-qualification than, the
4472 cv-qualification of T1. If the conversion is applied, E1 is
4473 changed to an rvalue of type T2 that still refers to the original
4474 source class object (or the appropriate subobject thereof). */
4475 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
4476 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
4478 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
4480 conv
= build_identity_conv (t1
, e1
);
4481 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
4482 TYPE_MAIN_VARIANT (t2
)))
4483 conv
= build_conv (ck_base
, t2
, conv
);
4485 conv
= build_conv (ck_rvalue
, t2
, conv
);
4494 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4495 converted to the type that expression E2 would have if E2 were
4496 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4497 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
4498 LOOKUP_IMPLICIT
, complain
);
4501 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4502 arguments to the conditional expression. */
4505 build_conditional_expr_1 (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
4506 tsubst_flags_t complain
)
4510 tree result
= NULL_TREE
;
4511 tree result_type
= NULL_TREE
;
4512 bool lvalue_p
= true;
4513 struct z_candidate
*candidates
= 0;
4514 struct z_candidate
*cand
;
4516 tree orig_arg2
, orig_arg3
;
4518 /* As a G++ extension, the second argument to the conditional can be
4519 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4520 c'.) If the second operand is omitted, make sure it is
4521 calculated only once. */
4524 if (complain
& tf_error
)
4525 pedwarn (loc
, OPT_Wpedantic
,
4526 "ISO C++ forbids omitting the middle term of a ?: expression");
4528 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4529 if (real_lvalue_p (arg1
))
4530 arg2
= arg1
= stabilize_reference (arg1
);
4532 arg2
= arg1
= save_expr (arg1
);
4535 /* If something has already gone wrong, just pass that fact up the
4537 if (error_operand_p (arg1
)
4538 || error_operand_p (arg2
)
4539 || error_operand_p (arg3
))
4540 return error_mark_node
;
4545 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
4547 arg1
= force_rvalue (arg1
, complain
);
4548 arg2
= force_rvalue (arg2
, complain
);
4549 arg3
= force_rvalue (arg3
, complain
);
4551 /* force_rvalue can return error_mark on valid arguments. */
4552 if (error_operand_p (arg1
)
4553 || error_operand_p (arg2
)
4554 || error_operand_p (arg3
))
4555 return error_mark_node
;
4557 tree arg1_type
= TREE_TYPE (arg1
);
4558 arg2_type
= TREE_TYPE (arg2
);
4559 arg3_type
= TREE_TYPE (arg3
);
4561 if (!VECTOR_TYPE_P (arg2_type
)
4562 && !VECTOR_TYPE_P (arg3_type
))
4564 /* Rely on the error messages of the scalar version. */
4565 tree scal
= build_conditional_expr_1 (loc
, integer_one_node
,
4566 orig_arg2
, orig_arg3
, complain
);
4567 if (scal
== error_mark_node
)
4568 return error_mark_node
;
4569 tree stype
= TREE_TYPE (scal
);
4570 tree ctype
= TREE_TYPE (arg1_type
);
4571 if (TYPE_SIZE (stype
) != TYPE_SIZE (ctype
)
4572 || (!INTEGRAL_TYPE_P (stype
) && !SCALAR_FLOAT_TYPE_P (stype
)))
4574 if (complain
& tf_error
)
4575 error_at (loc
, "inferred scalar type %qT is not an integer or "
4576 "floating point type of the same size as %qT", stype
,
4577 COMPARISON_CLASS_P (arg1
)
4578 ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
4580 return error_mark_node
;
4583 tree vtype
= build_opaque_vector_type (stype
,
4584 TYPE_VECTOR_SUBPARTS (arg1_type
));
4585 /* We could pass complain & tf_warning to unsafe_conversion_p,
4586 but the warnings (like Wsign-conversion) have already been
4587 given by the scalar build_conditional_expr_1. We still check
4588 unsafe_conversion_p to forbid truncating long long -> float. */
4589 if (unsafe_conversion_p (loc
, stype
, arg2
, false))
4591 if (complain
& tf_error
)
4592 error_at (loc
, "conversion of scalar %qT to vector %qT "
4593 "involves truncation", arg2_type
, vtype
);
4594 return error_mark_node
;
4596 if (unsafe_conversion_p (loc
, stype
, arg3
, false))
4598 if (complain
& tf_error
)
4599 error_at (loc
, "conversion of scalar %qT to vector %qT "
4600 "involves truncation", arg3_type
, vtype
);
4601 return error_mark_node
;
4604 arg2
= cp_convert (stype
, arg2
, complain
);
4605 arg2
= save_expr (arg2
);
4606 arg2
= build_vector_from_val (vtype
, arg2
);
4608 arg3
= cp_convert (stype
, arg3
, complain
);
4609 arg3
= save_expr (arg3
);
4610 arg3
= build_vector_from_val (vtype
, arg3
);
4614 if (VECTOR_TYPE_P (arg2_type
) != VECTOR_TYPE_P (arg3_type
))
4616 enum stv_conv convert_flag
=
4617 scalar_to_vector (loc
, VEC_COND_EXPR
, arg2
, arg3
,
4618 complain
& tf_error
);
4620 switch (convert_flag
)
4623 return error_mark_node
;
4626 arg2
= save_expr (arg2
);
4627 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
4628 arg2
= build_vector_from_val (arg3_type
, arg2
);
4629 arg2_type
= TREE_TYPE (arg2
);
4634 arg3
= save_expr (arg3
);
4635 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
4636 arg3
= build_vector_from_val (arg2_type
, arg3
);
4637 arg3_type
= TREE_TYPE (arg3
);
4645 if (!same_type_p (arg2_type
, arg3_type
)
4646 || TYPE_VECTOR_SUBPARTS (arg1_type
)
4647 != TYPE_VECTOR_SUBPARTS (arg2_type
)
4648 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
4650 if (complain
& tf_error
)
4652 "incompatible vector types in conditional expression: "
4653 "%qT, %qT and %qT", TREE_TYPE (arg1
),
4654 TREE_TYPE (orig_arg2
), TREE_TYPE (orig_arg3
));
4655 return error_mark_node
;
4658 if (!COMPARISON_CLASS_P (arg1
))
4659 arg1
= cp_build_binary_op (loc
, NE_EXPR
, arg1
,
4660 build_zero_cst (arg1_type
), complain
);
4661 return fold_build3 (VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
4666 The first expression is implicitly converted to bool (clause
4668 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
4670 if (error_operand_p (arg1
))
4671 return error_mark_node
;
4675 If either the second or the third operand has type (possibly
4676 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4677 array-to-pointer (_conv.array_), and function-to-pointer
4678 (_conv.func_) standard conversions are performed on the second
4679 and third operands. */
4680 arg2_type
= unlowered_expr_type (arg2
);
4681 arg3_type
= unlowered_expr_type (arg3
);
4682 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
4684 /* Do the conversions. We don't these for `void' type arguments
4685 since it can't have any effect and since decay_conversion
4686 does not handle that case gracefully. */
4687 if (!VOID_TYPE_P (arg2_type
))
4688 arg2
= decay_conversion (arg2
, complain
);
4689 if (!VOID_TYPE_P (arg3_type
))
4690 arg3
= decay_conversion (arg3
, complain
);
4691 arg2_type
= TREE_TYPE (arg2
);
4692 arg3_type
= TREE_TYPE (arg3
);
4696 One of the following shall hold:
4698 --The second or the third operand (but not both) is a
4699 throw-expression (_except.throw_); the result is of the
4700 type of the other and is an rvalue.
4702 --Both the second and the third operands have type void; the
4703 result is of type void and is an rvalue.
4705 We must avoid calling force_rvalue for expressions of type
4706 "void" because it will complain that their value is being
4708 if (TREE_CODE (arg2
) == THROW_EXPR
4709 && TREE_CODE (arg3
) != THROW_EXPR
)
4711 if (!VOID_TYPE_P (arg3_type
))
4713 arg3
= force_rvalue (arg3
, complain
);
4714 if (arg3
== error_mark_node
)
4715 return error_mark_node
;
4717 arg3_type
= TREE_TYPE (arg3
);
4718 result_type
= arg3_type
;
4720 else if (TREE_CODE (arg2
) != THROW_EXPR
4721 && TREE_CODE (arg3
) == THROW_EXPR
)
4723 if (!VOID_TYPE_P (arg2_type
))
4725 arg2
= force_rvalue (arg2
, complain
);
4726 if (arg2
== error_mark_node
)
4727 return error_mark_node
;
4729 arg2_type
= TREE_TYPE (arg2
);
4730 result_type
= arg2_type
;
4732 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
4733 result_type
= void_type_node
;
4736 if (complain
& tf_error
)
4738 if (VOID_TYPE_P (arg2_type
))
4739 error_at (EXPR_LOC_OR_LOC (arg3
, loc
),
4740 "second operand to the conditional operator "
4741 "is of type %<void%>, but the third operand is "
4742 "neither a throw-expression nor of type %<void%>");
4744 error_at (EXPR_LOC_OR_LOC (arg2
, loc
),
4745 "third operand to the conditional operator "
4746 "is of type %<void%>, but the second operand is "
4747 "neither a throw-expression nor of type %<void%>");
4749 return error_mark_node
;
4753 goto valid_operands
;
4757 Otherwise, if the second and third operand have different types,
4758 and either has (possibly cv-qualified) class type, or if both are
4759 glvalues of the same value category and the same type except for
4760 cv-qualification, an attempt is made to convert each of those operands
4761 to the type of the other. */
4762 else if (!same_type_p (arg2_type
, arg3_type
)
4763 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)
4764 || (same_type_ignoring_top_level_qualifiers_p (arg2_type
,
4766 && lvalue_or_rvalue_with_address_p (arg2
)
4767 && lvalue_or_rvalue_with_address_p (arg3
)
4768 && real_lvalue_p (arg2
) == real_lvalue_p (arg3
))))
4772 bool converted
= false;
4774 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4775 p
= conversion_obstack_alloc (0);
4777 conv2
= conditional_conversion (arg2
, arg3
, complain
);
4778 conv3
= conditional_conversion (arg3
, arg2
, complain
);
4782 If both can be converted, or one can be converted but the
4783 conversion is ambiguous, the program is ill-formed. If
4784 neither can be converted, the operands are left unchanged and
4785 further checking is performed as described below. If exactly
4786 one conversion is possible, that conversion is applied to the
4787 chosen operand and the converted operand is used in place of
4788 the original operand for the remainder of this section. */
4789 if ((conv2
&& !conv2
->bad_p
4790 && conv3
&& !conv3
->bad_p
)
4791 || (conv2
&& conv2
->kind
== ck_ambig
)
4792 || (conv3
&& conv3
->kind
== ck_ambig
))
4794 if (complain
& tf_error
)
4796 error_at (loc
, "operands to ?: have different types %qT and %qT",
4797 arg2_type
, arg3_type
);
4798 if (conv2
&& !conv2
->bad_p
&& conv3
&& !conv3
->bad_p
)
4799 inform (loc
, " and each type can be converted to the other");
4800 else if (conv2
&& conv2
->kind
== ck_ambig
)
4801 convert_like (conv2
, arg2
, complain
);
4803 convert_like (conv3
, arg3
, complain
);
4805 result
= error_mark_node
;
4807 else if (conv2
&& !conv2
->bad_p
)
4809 arg2
= convert_like (conv2
, arg2
, complain
);
4810 arg2
= convert_from_reference (arg2
);
4811 arg2_type
= TREE_TYPE (arg2
);
4812 /* Even if CONV2 is a valid conversion, the result of the
4813 conversion may be invalid. For example, if ARG3 has type
4814 "volatile X", and X does not have a copy constructor
4815 accepting a "volatile X&", then even if ARG2 can be
4816 converted to X, the conversion will fail. */
4817 if (error_operand_p (arg2
))
4818 result
= error_mark_node
;
4821 else if (conv3
&& !conv3
->bad_p
)
4823 arg3
= convert_like (conv3
, arg3
, complain
);
4824 arg3
= convert_from_reference (arg3
);
4825 arg3_type
= TREE_TYPE (arg3
);
4826 if (error_operand_p (arg3
))
4827 result
= error_mark_node
;
4831 /* Free all the conversions we allocated. */
4832 obstack_free (&conversion_obstack
, p
);
4837 /* If, after the conversion, both operands have class type,
4838 treat the cv-qualification of both operands as if it were the
4839 union of the cv-qualification of the operands.
4841 The standard is not clear about what to do in this
4842 circumstance. For example, if the first operand has type
4843 "const X" and the second operand has a user-defined
4844 conversion to "volatile X", what is the type of the second
4845 operand after this step? Making it be "const X" (matching
4846 the first operand) seems wrong, as that discards the
4847 qualification without actually performing a copy. Leaving it
4848 as "volatile X" seems wrong as that will result in the
4849 conditional expression failing altogether, even though,
4850 according to this step, the one operand could be converted to
4851 the type of the other. */
4853 && CLASS_TYPE_P (arg2_type
)
4854 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
4855 arg2_type
= arg3_type
=
4856 cp_build_qualified_type (arg2_type
,
4857 cp_type_quals (arg2_type
)
4858 | cp_type_quals (arg3_type
));
4863 If the second and third operands are glvalues of the same value
4864 category and have the same type, the result is of that type and
4866 if (((real_lvalue_p (arg2
) && real_lvalue_p (arg3
))
4867 || (xvalue_p (arg2
) && xvalue_p (arg3
)))
4868 && same_type_p (arg2_type
, arg3_type
))
4870 result_type
= arg2_type
;
4871 arg2
= mark_lvalue_use (arg2
);
4872 arg3
= mark_lvalue_use (arg3
);
4873 goto valid_operands
;
4878 Otherwise, the result is an rvalue. If the second and third
4879 operand do not have the same type, and either has (possibly
4880 cv-qualified) class type, overload resolution is used to
4881 determine the conversions (if any) to be applied to the operands
4882 (_over.match.oper_, _over.built_). */
4884 if (!same_type_p (arg2_type
, arg3_type
)
4885 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
4891 /* Rearrange the arguments so that add_builtin_candidate only has
4892 to know about two args. In build_builtin_candidate, the
4893 arguments are unscrambled. */
4897 add_builtin_candidates (&candidates
,
4900 ansi_opname (COND_EXPR
),
4902 LOOKUP_NORMAL
, complain
);
4906 If the overload resolution fails, the program is
4908 candidates
= splice_viable (candidates
, false, &any_viable_p
);
4911 if (complain
& tf_error
)
4912 error_at (loc
, "operands to ?: have different types %qT and %qT",
4913 arg2_type
, arg3_type
);
4914 return error_mark_node
;
4916 cand
= tourney (candidates
, complain
);
4919 if (complain
& tf_error
)
4921 op_error (loc
, COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, FALSE
);
4922 print_z_candidates (loc
, candidates
);
4924 return error_mark_node
;
4929 Otherwise, the conversions thus determined are applied, and
4930 the converted operands are used in place of the original
4931 operands for the remainder of this section. */
4932 conv
= cand
->convs
[0];
4933 arg1
= convert_like (conv
, arg1
, complain
);
4934 conv
= cand
->convs
[1];
4935 arg2
= convert_like (conv
, arg2
, complain
);
4936 arg2_type
= TREE_TYPE (arg2
);
4937 conv
= cand
->convs
[2];
4938 arg3
= convert_like (conv
, arg3
, complain
);
4939 arg3_type
= TREE_TYPE (arg3
);
4944 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
4945 and function-to-pointer (_conv.func_) standard conversions are
4946 performed on the second and third operands.
4948 We need to force the lvalue-to-rvalue conversion here for class types,
4949 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
4950 that isn't wrapped with a TARGET_EXPR plays havoc with exception
4953 arg2
= force_rvalue (arg2
, complain
);
4954 if (!CLASS_TYPE_P (arg2_type
))
4955 arg2_type
= TREE_TYPE (arg2
);
4957 arg3
= force_rvalue (arg3
, complain
);
4958 if (!CLASS_TYPE_P (arg3_type
))
4959 arg3_type
= TREE_TYPE (arg3
);
4961 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
4962 return error_mark_node
;
4966 After those conversions, one of the following shall hold:
4968 --The second and third operands have the same type; the result is of
4970 if (same_type_p (arg2_type
, arg3_type
))
4971 result_type
= arg2_type
;
4974 --The second and third operands have arithmetic or enumeration
4975 type; the usual arithmetic conversions are performed to bring
4976 them to a common type, and the result is of that type. */
4977 else if ((ARITHMETIC_TYPE_P (arg2_type
)
4978 || UNSCOPED_ENUM_P (arg2_type
))
4979 && (ARITHMETIC_TYPE_P (arg3_type
)
4980 || UNSCOPED_ENUM_P (arg3_type
)))
4982 /* In this case, there is always a common type. */
4983 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
4985 if (complain
& tf_warning
)
4986 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
4987 "implicit conversion from %qT to %qT to "
4988 "match other result of conditional",
4991 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
4992 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
4994 if (TREE_CODE (orig_arg2
) == CONST_DECL
4995 && TREE_CODE (orig_arg3
) == CONST_DECL
4996 && DECL_CONTEXT (orig_arg2
) == DECL_CONTEXT (orig_arg3
))
4997 /* Two enumerators from the same enumeration can have different
4998 types when the enumeration is still being defined. */;
4999 else if (complain
& tf_warning
)
5000 warning_at (loc
, OPT_Wenum_compare
, "enumeral mismatch in "
5001 "conditional expression: %qT vs %qT",
5002 arg2_type
, arg3_type
);
5004 else if (extra_warnings
5005 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
5006 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
5007 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
5008 && !same_type_p (arg2_type
,
5009 type_promotes_to (arg3_type
)))))
5011 if (complain
& tf_warning
)
5012 warning_at (loc
, OPT_Wextra
, "enumeral and non-enumeral type in "
5013 "conditional expression");
5016 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5017 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5021 --The second and third operands have pointer type, or one has
5022 pointer type and the other is a null pointer constant; pointer
5023 conversions (_conv.ptr_) and qualification conversions
5024 (_conv.qual_) are performed to bring them to their composite
5025 pointer type (_expr.rel_). The result is of the composite
5028 --The second and third operands have pointer to member type, or
5029 one has pointer to member type and the other is a null pointer
5030 constant; pointer to member conversions (_conv.mem_) and
5031 qualification conversions (_conv.qual_) are performed to bring
5032 them to a common type, whose cv-qualification shall match the
5033 cv-qualification of either the second or the third operand.
5034 The result is of the common type. */
5035 else if ((null_ptr_cst_p (arg2
)
5036 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
5037 || (null_ptr_cst_p (arg3
)
5038 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
5039 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
5040 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
5041 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
5043 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
5044 arg3
, CPO_CONDITIONAL_EXPR
,
5046 if (result_type
== error_mark_node
)
5047 return error_mark_node
;
5048 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
5049 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
5054 if (complain
& tf_error
)
5055 error_at (loc
, "operands to ?: have different types %qT and %qT",
5056 arg2_type
, arg3_type
);
5057 return error_mark_node
;
5060 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
5061 return error_mark_node
;
5064 result
= build3 (COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
5065 if (!cp_unevaluated_operand
)
5066 /* Avoid folding within decltype (c++/42013) and noexcept. */
5067 result
= fold_if_not_in_template (result
);
5069 /* We can't use result_type below, as fold might have returned a
5074 /* Expand both sides into the same slot, hopefully the target of
5075 the ?: expression. We used to check for TARGET_EXPRs here,
5076 but now we sometimes wrap them in NOP_EXPRs so the test would
5078 if (CLASS_TYPE_P (TREE_TYPE (result
)))
5079 result
= get_target_expr_sfinae (result
, complain
);
5080 /* If this expression is an rvalue, but might be mistaken for an
5081 lvalue, we must add a NON_LVALUE_EXPR. */
5082 result
= rvalue (result
);
5085 result
= force_paren_expr (result
);
5090 /* Wrapper for above. */
5093 build_conditional_expr (location_t loc
, tree arg1
, tree arg2
, tree arg3
,
5094 tsubst_flags_t complain
)
5097 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5098 ret
= build_conditional_expr_1 (loc
, arg1
, arg2
, arg3
, complain
);
5099 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5103 /* OPERAND is an operand to an expression. Perform necessary steps
5104 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
5108 prep_operand (tree operand
)
5112 if (CLASS_TYPE_P (TREE_TYPE (operand
))
5113 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
5114 /* Make sure the template type is instantiated now. */
5115 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
5121 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
5122 OVERLOAD) to the CANDIDATES, returning an updated list of
5123 CANDIDATES. The ARGS are the arguments provided to the call;
5124 if FIRST_ARG is non-null it is the implicit object argument,
5125 otherwise the first element of ARGS is used if needed. The
5126 EXPLICIT_TARGS are explicit template arguments provided.
5127 TEMPLATE_ONLY is true if only template functions should be
5128 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
5129 add_function_candidate. */
5132 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
5134 tree explicit_targs
, bool template_only
,
5135 tree conversion_path
, tree access_path
,
5137 struct z_candidate
**candidates
,
5138 tsubst_flags_t complain
)
5141 const vec
<tree
, va_gc
> *non_static_args
;
5142 bool check_list_ctor
;
5143 bool check_converting
;
5144 unification_kind_t strict
;
5150 /* Precalculate special handling of constructors and conversion ops. */
5151 fn
= OVL_CURRENT (fns
);
5152 if (DECL_CONV_FN_P (fn
))
5154 check_list_ctor
= false;
5155 check_converting
= !!(flags
& LOOKUP_ONLYCONVERTING
);
5156 if (flags
& LOOKUP_NO_CONVERSION
)
5157 /* We're doing return_type(x). */
5158 strict
= DEDUCE_CONV
;
5160 /* We're doing x.operator return_type(). */
5161 strict
= DEDUCE_EXACT
;
5162 /* [over.match.funcs] For conversion functions, the function
5163 is considered to be a member of the class of the implicit
5164 object argument for the purpose of defining the type of
5165 the implicit object parameter. */
5166 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
5170 if (DECL_CONSTRUCTOR_P (fn
))
5172 check_list_ctor
= !!(flags
& LOOKUP_LIST_ONLY
);
5173 /* For list-initialization we consider explicit constructors
5174 and complain if one is chosen. */
5176 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
5177 == LOOKUP_ONLYCONVERTING
);
5181 check_list_ctor
= false;
5182 check_converting
= false;
5184 strict
= DEDUCE_CALL
;
5185 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
5189 non_static_args
= args
;
5191 /* Delay creating the implicit this parameter until it is needed. */
5192 non_static_args
= NULL
;
5194 for (; fns
; fns
= OVL_NEXT (fns
))
5197 const vec
<tree
, va_gc
> *fn_args
;
5199 fn
= OVL_CURRENT (fns
);
5201 if (check_converting
&& DECL_NONCONVERTING_P (fn
))
5203 if (check_list_ctor
&& !is_list_ctor (fn
))
5206 /* Figure out which set of arguments to use. */
5207 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
5209 /* If this function is a non-static member and we didn't get an
5210 implicit object argument, move it out of args. */
5211 if (first_arg
== NULL_TREE
)
5215 vec
<tree
, va_gc
> *tempvec
;
5216 vec_alloc (tempvec
, args
->length () - 1);
5217 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
5218 tempvec
->quick_push (arg
);
5219 non_static_args
= tempvec
;
5220 first_arg
= (*args
)[0];
5223 fn_first_arg
= first_arg
;
5224 fn_args
= non_static_args
;
5228 /* Otherwise, just use the list of arguments provided. */
5229 fn_first_arg
= NULL_TREE
;
5233 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5234 add_template_candidate (candidates
,
5246 else if (!template_only
)
5247 add_function_candidate (candidates
,
5260 build_new_op_1 (location_t loc
, enum tree_code code
, int flags
, tree arg1
,
5261 tree arg2
, tree arg3
, tree
*overload
, tsubst_flags_t complain
)
5263 struct z_candidate
*candidates
= 0, *cand
;
5264 vec
<tree
, va_gc
> *arglist
;
5267 tree result
= NULL_TREE
;
5268 bool result_valid_p
= false;
5269 enum tree_code code2
= NOP_EXPR
;
5270 enum tree_code code_orig_arg1
= ERROR_MARK
;
5271 enum tree_code code_orig_arg2
= ERROR_MARK
;
5277 if (error_operand_p (arg1
)
5278 || error_operand_p (arg2
)
5279 || error_operand_p (arg3
))
5280 return error_mark_node
;
5282 if (code
== MODIFY_EXPR
)
5284 code2
= TREE_CODE (arg3
);
5286 fnname
= ansi_assopname (code2
);
5289 fnname
= ansi_opname (code
);
5291 arg1
= prep_operand (arg1
);
5293 bool memonly
= false;
5298 case VEC_DELETE_EXPR
:
5300 /* Use build_op_new_call and build_op_delete_call instead. */
5304 /* Use build_op_call instead. */
5307 case TRUTH_ORIF_EXPR
:
5308 case TRUTH_ANDIF_EXPR
:
5309 case TRUTH_AND_EXPR
:
5311 /* These are saved for the sake of warn_logical_operator. */
5312 code_orig_arg1
= TREE_CODE (arg1
);
5313 code_orig_arg2
= TREE_CODE (arg2
);
5321 /* These are saved for the sake of maybe_warn_bool_compare. */
5322 code_orig_arg1
= TREE_CODE (TREE_TYPE (arg1
));
5323 code_orig_arg2
= TREE_CODE (TREE_TYPE (arg2
));
5326 /* =, ->, [], () must be non-static member functions. */
5328 if (code2
!= NOP_EXPR
)
5339 arg2
= prep_operand (arg2
);
5340 arg3
= prep_operand (arg3
);
5342 if (code
== COND_EXPR
)
5343 /* Use build_conditional_expr instead. */
5345 else if (! OVERLOAD_TYPE_P (TREE_TYPE (arg1
))
5346 && (! arg2
|| ! OVERLOAD_TYPE_P (TREE_TYPE (arg2
))))
5349 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5350 arg2
= integer_zero_node
;
5352 vec_alloc (arglist
, 3);
5353 arglist
->quick_push (arg1
);
5354 if (arg2
!= NULL_TREE
)
5355 arglist
->quick_push (arg2
);
5356 if (arg3
!= NULL_TREE
)
5357 arglist
->quick_push (arg3
);
5359 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5360 p
= conversion_obstack_alloc (0);
5362 /* Add namespace-scope operators to the list of functions to
5365 add_candidates (lookup_function_nonclass (fnname
, arglist
,
5367 NULL_TREE
, arglist
, NULL_TREE
,
5368 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5369 flags
, &candidates
, complain
);
5373 args
[2] = NULL_TREE
;
5375 /* Add class-member operators to the candidate set. */
5376 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
5380 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
5381 if (fns
== error_mark_node
)
5383 result
= error_mark_node
;
5384 goto user_defined_result_ready
;
5387 add_candidates (BASELINK_FUNCTIONS (fns
),
5388 NULL_TREE
, arglist
, NULL_TREE
,
5390 BASELINK_BINFO (fns
),
5391 BASELINK_ACCESS_BINFO (fns
),
5392 flags
, &candidates
, complain
);
5394 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5395 only non-member functions that have type T1 or reference to
5396 cv-qualified-opt T1 for the first argument, if the first argument
5397 has an enumeration type, or T2 or reference to cv-qualified-opt
5398 T2 for the second argument, if the second argument has an
5399 enumeration type. Filter out those that don't match. */
5400 else if (! arg2
|| ! CLASS_TYPE_P (TREE_TYPE (arg2
)))
5402 struct z_candidate
**candp
, **next
;
5404 for (candp
= &candidates
; *candp
; candp
= next
)
5406 tree parmlist
, parmtype
;
5407 int i
, nargs
= (arg2
? 2 : 1);
5412 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5414 for (i
= 0; i
< nargs
; ++i
)
5416 parmtype
= TREE_VALUE (parmlist
);
5418 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
5419 parmtype
= TREE_TYPE (parmtype
);
5420 if (TREE_CODE (TREE_TYPE (args
[i
])) == ENUMERAL_TYPE
5421 && (same_type_ignoring_top_level_qualifiers_p
5422 (TREE_TYPE (args
[i
]), parmtype
)))
5425 parmlist
= TREE_CHAIN (parmlist
);
5428 /* No argument has an appropriate type, so remove this
5429 candidate function from the list. */
5432 *candp
= cand
->next
;
5438 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
5445 /* For these, the built-in candidates set is empty
5446 [over.match.oper]/3. We don't want non-strict matches
5447 because exact matches are always possible with built-in
5448 operators. The built-in candidate set for COMPONENT_REF
5449 would be empty too, but since there are no such built-in
5450 operators, we accept non-strict matches for them. */
5459 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
5464 case POSTINCREMENT_EXPR
:
5465 case POSTDECREMENT_EXPR
:
5466 /* Don't try anything fancy if we're not allowed to produce
5468 if (!(complain
& tf_error
))
5469 return error_mark_node
;
5471 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5472 distinguish between prefix and postfix ++ and
5473 operator++() was used for both, so we allow this with
5477 const char *msg
= (flag_permissive
)
5478 ? G_("no %<%D(int)%> declared for postfix %qs,"
5479 " trying prefix operator instead")
5480 : G_("no %<%D(int)%> declared for postfix %qs");
5481 permerror (loc
, msg
, fnname
, operator_name_info
[code
].name
);
5484 if (!flag_permissive
)
5485 return error_mark_node
;
5487 if (code
== POSTINCREMENT_EXPR
)
5488 code
= PREINCREMENT_EXPR
;
5490 code
= PREDECREMENT_EXPR
;
5491 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
5492 NULL_TREE
, overload
, complain
);
5495 /* The caller will deal with these. */
5500 result_valid_p
= true;
5504 if (complain
& tf_error
)
5506 /* If one of the arguments of the operator represents
5507 an invalid use of member function pointer, try to report
5508 a meaningful error ... */
5509 if (invalid_nonstatic_memfn_p (loc
, arg1
, tf_error
)
5510 || invalid_nonstatic_memfn_p (loc
, arg2
, tf_error
)
5511 || invalid_nonstatic_memfn_p (loc
, arg3
, tf_error
))
5512 /* We displayed the error message. */;
5515 /* ... Otherwise, report the more generic
5516 "no matching operator found" error */
5517 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
5518 print_z_candidates (loc
, candidates
);
5521 result
= error_mark_node
;
5527 cand
= tourney (candidates
, complain
);
5530 if (complain
& tf_error
)
5532 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
5533 print_z_candidates (loc
, candidates
);
5535 result
= error_mark_node
;
5537 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5540 *overload
= cand
->fn
;
5542 if (resolve_args (arglist
, complain
) == NULL
)
5543 result
= error_mark_node
;
5545 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5549 /* Give any warnings we noticed during overload resolution. */
5550 if (cand
->warnings
&& (complain
& tf_warning
))
5552 struct candidate_warning
*w
;
5553 for (w
= cand
->warnings
; w
; w
= w
->next
)
5554 joust (cand
, w
->loser
, 1, complain
);
5557 /* Check for comparison of different enum types. */
5566 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
5567 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
5568 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
5569 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
)))
5570 && (complain
& tf_warning
))
5572 warning (OPT_Wenum_compare
,
5573 "comparison between %q#T and %q#T",
5574 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5581 /* We need to strip any leading REF_BIND so that bitfields
5582 don't cause errors. This should not remove any important
5583 conversions, because builtins don't apply to class
5584 objects directly. */
5585 conv
= cand
->convs
[0];
5586 if (conv
->kind
== ck_ref_bind
)
5587 conv
= next_conversion (conv
);
5588 arg1
= convert_like (conv
, arg1
, complain
);
5592 conv
= cand
->convs
[1];
5593 if (conv
->kind
== ck_ref_bind
)
5594 conv
= next_conversion (conv
);
5596 arg2
= decay_conversion (arg2
, complain
);
5598 /* We need to call warn_logical_operator before
5599 converting arg2 to a boolean_type, but after
5600 decaying an enumerator to its value. */
5601 if (complain
& tf_warning
)
5602 warn_logical_operator (loc
, code
, boolean_type_node
,
5603 code_orig_arg1
, arg1
,
5604 code_orig_arg2
, arg2
);
5606 arg2
= convert_like (conv
, arg2
, complain
);
5610 conv
= cand
->convs
[2];
5611 if (conv
->kind
== ck_ref_bind
)
5612 conv
= next_conversion (conv
);
5613 arg3
= convert_like (conv
, arg3
, complain
);
5619 user_defined_result_ready
:
5621 /* Free all the conversions we allocated. */
5622 obstack_free (&conversion_obstack
, p
);
5624 if (result
|| result_valid_p
)
5631 return cp_build_modify_expr (arg1
, code2
, arg2
, complain
);
5634 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
5636 case TRUTH_ANDIF_EXPR
:
5637 case TRUTH_ORIF_EXPR
:
5638 case TRUTH_AND_EXPR
:
5640 if (complain
& tf_warning
)
5641 warn_logical_operator (loc
, code
, boolean_type_node
,
5642 code_orig_arg1
, arg1
, code_orig_arg2
, arg2
);
5650 if ((complain
& tf_warning
)
5651 && ((code_orig_arg1
== BOOLEAN_TYPE
)
5652 ^ (code_orig_arg2
== BOOLEAN_TYPE
)))
5653 maybe_warn_bool_compare (loc
, code
, arg1
, arg2
);
5654 if (complain
& tf_warning
&& warn_tautological_compare
)
5655 warn_tautological_cmp (loc
, code
, arg1
, arg2
);
5660 case TRUNC_DIV_EXPR
:
5665 case TRUNC_MOD_EXPR
:
5669 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
5671 case UNARY_PLUS_EXPR
:
5674 case TRUTH_NOT_EXPR
:
5675 case PREINCREMENT_EXPR
:
5676 case POSTINCREMENT_EXPR
:
5677 case PREDECREMENT_EXPR
:
5678 case POSTDECREMENT_EXPR
:
5682 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5685 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5688 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
5692 /* The caller will deal with these. */
5704 /* Wrapper for above. */
5707 build_new_op (location_t loc
, enum tree_code code
, int flags
,
5708 tree arg1
, tree arg2
, tree arg3
,
5709 tree
*overload
, tsubst_flags_t complain
)
5712 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5713 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
5714 overload
, complain
);
5715 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5719 /* Returns true if FN has two parameters, of which the second has type
5723 second_parm_is_size_t (tree fn
)
5725 tree t
= FUNCTION_ARG_CHAIN (fn
);
5727 && same_type_p (TREE_VALUE (t
), size_type_node
)
5728 && TREE_CHAIN (t
) == void_list_node
);
5731 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5732 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5735 non_placement_deallocation_fn_p (tree t
)
5737 /* A template instance is never a usual deallocation function,
5738 regardless of its signature. */
5739 if (TREE_CODE (t
) == TEMPLATE_DECL
5740 || primary_template_instantiation_p (t
))
5743 /* If a class T has a member deallocation function named operator delete
5744 with exactly one parameter, then that function is a usual
5745 (non-placement) deallocation function. If class T does not declare
5746 such an operator delete but does declare a member deallocation
5747 function named operator delete with exactly two parameters, the second
5748 of which has type std::size_t (18.2), then this function is a usual
5749 deallocation function. */
5750 bool global
= DECL_NAMESPACE_SCOPE_P (t
);
5751 if (FUNCTION_ARG_CHAIN (t
) == void_list_node
5752 || ((!global
|| flag_sized_deallocation
)
5753 && second_parm_is_size_t (t
)))
5758 /* Build a call to operator delete. This has to be handled very specially,
5759 because the restrictions on what signatures match are different from all
5760 other call instances. For a normal delete, only a delete taking (void *)
5761 or (void *, size_t) is accepted. For a placement delete, only an exact
5762 match with the placement new is accepted.
5764 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5765 ADDR is the pointer to be deleted.
5766 SIZE is the size of the memory block to be deleted.
5767 GLOBAL_P is true if the delete-expression should not consider
5768 class-specific delete operators.
5769 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5771 If this call to "operator delete" is being generated as part to
5772 deallocate memory allocated via a new-expression (as per [expr.new]
5773 which requires that if the initialization throws an exception then
5774 we call a deallocation function), then ALLOC_FN is the allocation
5778 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
5779 bool global_p
, tree placement
,
5780 tree alloc_fn
, tsubst_flags_t complain
)
5782 tree fn
= NULL_TREE
;
5783 tree fns
, fnname
, type
, t
;
5785 if (addr
== error_mark_node
)
5786 return error_mark_node
;
5788 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
5790 fnname
= ansi_opname (code
);
5792 if (CLASS_TYPE_P (type
)
5793 && COMPLETE_TYPE_P (complete_type (type
))
5797 If the result of the lookup is ambiguous or inaccessible, or if
5798 the lookup selects a placement deallocation function, the
5799 program is ill-formed.
5801 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5803 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
5804 if (fns
== error_mark_node
)
5805 return error_mark_node
;
5810 if (fns
== NULL_TREE
)
5811 fns
= lookup_name_nonclass (fnname
);
5813 /* Strip const and volatile from addr. */
5814 addr
= cp_convert (ptr_type_node
, addr
, complain
);
5818 /* "A declaration of a placement deallocation function matches the
5819 declaration of a placement allocation function if it has the same
5820 number of parameters and, after parameter transformations (8.3.5),
5821 all parameter types except the first are identical."
5823 So we build up the function type we want and ask instantiate_type
5824 to get it for us. */
5825 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
5826 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
5827 t
= build_function_type (void_type_node
, t
);
5829 fn
= instantiate_type (t
, fns
, tf_none
);
5830 if (fn
== error_mark_node
)
5833 if (BASELINK_P (fn
))
5834 fn
= BASELINK_FUNCTIONS (fn
);
5836 /* "If the lookup finds the two-parameter form of a usual deallocation
5837 function (3.7.4.2) and that function, considered as a placement
5838 deallocation function, would have been selected as a match for the
5839 allocation function, the program is ill-formed." */
5840 if (second_parm_is_size_t (fn
))
5843 = G_("exception cleanup for this placement new selects "
5844 "non-placement operator delete");
5846 = G_("%q+D is a usual (non-placement) deallocation "
5847 "function in C++14 (or with -fsized-deallocation)");
5849 /* But if the class has an operator delete (void *), then that is
5850 the usual deallocation function, so we shouldn't complain
5851 about using the operator delete (void *, size_t). */
5852 if (DECL_CLASS_SCOPE_P (fn
))
5853 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5854 t
; t
= OVL_NEXT (t
))
5856 tree elt
= OVL_CURRENT (t
);
5857 if (non_placement_deallocation_fn_p (elt
)
5858 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
5861 /* Before C++14 a two-parameter global deallocation function is
5862 always a placement deallocation function, but warn if
5864 else if (!flag_sized_deallocation
)
5866 if ((complain
& tf_warning
)
5867 && warning (OPT_Wc__14_compat
, msg1
))
5868 inform (0, msg2
, fn
);
5872 if (complain
& tf_warning_or_error
)
5874 if (permerror (input_location
, msg1
))
5876 /* Only mention C++14 for namespace-scope delete. */
5877 if (DECL_NAMESPACE_SCOPE_P (fn
))
5878 inform (0, msg2
, fn
);
5880 inform (0, "%q+D is a usual (non-placement) deallocation "
5885 return error_mark_node
;
5890 /* "Any non-placement deallocation function matches a non-placement
5891 allocation function. If the lookup finds a single matching
5892 deallocation function, that function will be called; otherwise, no
5893 deallocation function will be called." */
5894 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5895 t
; t
= OVL_NEXT (t
))
5897 tree elt
= OVL_CURRENT (t
);
5898 if (non_placement_deallocation_fn_p (elt
))
5901 /* "If a class T has a member deallocation function named
5902 operator delete with exactly one parameter, then that
5903 function is a usual (non-placement) deallocation
5904 function. If class T does not declare such an operator
5905 delete but does declare a member deallocation function named
5906 operator delete with exactly two parameters, the second of
5907 which has type std::size_t (18.2), then this function is a
5908 usual deallocation function."
5910 So in a class (void*) beats (void*, size_t). */
5911 if (DECL_CLASS_SCOPE_P (fn
))
5913 if (FUNCTION_ARG_CHAIN (fn
) == void_list_node
)
5916 /* At global scope (in C++14 and above) the rules are different:
5918 If deallocation function lookup finds both a usual
5919 deallocation function with only a pointer parameter and a
5920 usual deallocation function with both a pointer parameter
5921 and a size parameter, the function to be called is selected
5924 * If the type is complete and if, for the second alternative
5925 (delete array) only, the operand is a pointer to a class
5926 type with a non-trivial destructor or a (possibly
5927 multi-dimensional) array thereof, the function with two
5928 parameters is selected.
5930 * Otherwise, it is unspecified which of the two deallocation
5931 functions is selected. */
5934 bool want_size
= COMPLETE_TYPE_P (type
);
5935 if (code
== VEC_DELETE_EXPR
5936 && !TYPE_VEC_NEW_USES_COOKIE (type
))
5937 /* We need a cookie to determine the array size. */
5939 bool have_size
= (FUNCTION_ARG_CHAIN (fn
) != void_list_node
);
5940 if (want_size
== have_size
)
5946 /* If we have a matching function, call it. */
5949 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
5951 /* If the FN is a member function, make sure that it is
5953 if (BASELINK_P (fns
))
5954 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
5957 /* Core issue 901: It's ok to new a type with deleted delete. */
5958 if (DECL_DELETED_FN (fn
) && alloc_fn
)
5963 /* The placement args might not be suitable for overload
5964 resolution at this point, so build the call directly. */
5965 int nargs
= call_expr_nargs (placement
);
5966 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
5969 for (i
= 1; i
< nargs
; i
++)
5970 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
5971 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
5972 return error_mark_node
;
5973 return build_cxx_call (fn
, nargs
, argarray
, complain
);
5978 vec
<tree
, va_gc
> *args
= make_tree_vector ();
5979 args
->quick_push (addr
);
5980 if (FUNCTION_ARG_CHAIN (fn
) != void_list_node
)
5981 args
->quick_push (size
);
5982 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
5983 release_tree_vector (args
);
5990 If no unambiguous matching deallocation function can be found,
5991 propagating the exception does not cause the object's memory to
5995 if ((complain
& tf_warning
)
5997 warning (0, "no corresponding deallocation function for %qD",
6002 if (complain
& tf_error
)
6003 error ("no suitable %<operator %s%> for %qT",
6004 operator_name_info
[(int)code
].name
, type
);
6005 return error_mark_node
;
6008 /* If the current scope isn't allowed to access DECL along
6009 BASETYPE_PATH, give an error. The most derived class in
6010 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
6011 the declaration to use in the error diagnostic. */
6014 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
6015 tsubst_flags_t complain
)
6017 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
6019 if (!accessible_p (basetype_path
, decl
, true))
6021 if (complain
& tf_error
)
6023 if (TREE_PRIVATE (decl
))
6025 error ("%q#D is private within this context", diag_decl
);
6026 inform (DECL_SOURCE_LOCATION (diag_decl
),
6027 "declared private here");
6029 else if (TREE_PROTECTED (decl
))
6031 error ("%q#D is protected within this context", diag_decl
);
6032 inform (DECL_SOURCE_LOCATION (diag_decl
),
6033 "declared protected here");
6037 error ("%q#D is inaccessible within this context", diag_decl
);
6038 inform (DECL_SOURCE_LOCATION (diag_decl
), "declared here");
6047 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
6048 bitwise or of LOOKUP_* values. If any errors are warnings are
6049 generated, set *DIAGNOSTIC_FN to "error" or "warning",
6050 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
6054 build_temp (tree expr
, tree type
, int flags
,
6055 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
6058 vec
<tree
, va_gc
> *args
;
6060 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
6061 args
= make_tree_vector_single (expr
);
6062 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6063 &args
, type
, flags
, complain
);
6064 release_tree_vector (args
);
6065 if (warningcount
+ werrorcount
> savew
)
6066 *diagnostic_kind
= DK_WARNING
;
6067 else if (errorcount
> savee
)
6068 *diagnostic_kind
= DK_ERROR
;
6070 *diagnostic_kind
= DK_UNSPECIFIED
;
6074 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
6075 EXPR is implicitly converted to type TOTYPE.
6076 FN and ARGNUM are used for diagnostics. */
6079 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6081 /* Issue warnings about peculiar, but valid, uses of NULL. */
6082 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
6083 && ARITHMETIC_TYPE_P (totype
))
6085 source_location loc
=
6086 expansion_point_location_if_in_system_header (input_location
);
6089 warning_at (loc
, OPT_Wconversion_null
,
6090 "passing NULL to non-pointer argument %P of %qD",
6093 warning_at (loc
, OPT_Wconversion_null
,
6094 "converting to non-pointer type %qT from NULL", totype
);
6097 /* Issue warnings if "false" is converted to a NULL pointer */
6098 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6099 && TYPE_PTR_P (totype
))
6102 warning_at (input_location
, OPT_Wconversion_null
,
6103 "converting %<false%> to pointer type for argument %P "
6104 "of %qD", argnum
, fn
);
6106 warning_at (input_location
, OPT_Wconversion_null
,
6107 "converting %<false%> to pointer type %qT", totype
);
6111 /* We gave a diagnostic during a conversion. If this was in the second
6112 standard conversion sequence of a user-defined conversion sequence, say
6113 which user-defined conversion. */
6116 maybe_print_user_conv_context (conversion
*convs
)
6118 if (convs
->user_conv_p
)
6119 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6120 if (t
->kind
== ck_user
)
6122 print_z_candidate (0, " after user-defined conversion:",
6128 /* Perform the conversions in CONVS on the expression EXPR. FN and
6129 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6130 indicates the `this' argument of a method. INNER is nonzero when
6131 being called to continue a conversion chain. It is negative when a
6132 reference binding will be applied, positive otherwise. If
6133 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6134 conversions will be emitted if appropriate. If C_CAST_P is true,
6135 this conversion is coming from a C-style cast; in that case,
6136 conversions to inaccessible bases are permitted. */
6139 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6140 int inner
, bool issue_conversion_warnings
,
6141 bool c_cast_p
, tsubst_flags_t complain
)
6143 tree totype
= convs
->type
;
6144 diagnostic_t diag_kind
;
6146 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6148 if (convs
->bad_p
&& !(complain
& tf_error
))
6149 return error_mark_node
;
6152 && convs
->kind
!= ck_user
6153 && convs
->kind
!= ck_list
6154 && convs
->kind
!= ck_ambig
6155 && (convs
->kind
!= ck_ref_bind
6156 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
6157 && (convs
->kind
!= ck_rvalue
6158 || SCALAR_TYPE_P (totype
))
6159 && convs
->kind
!= ck_base
)
6161 bool complained
= false;
6162 conversion
*t
= convs
;
6164 /* Give a helpful error if this is bad because of excess braces. */
6165 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6166 && SCALAR_TYPE_P (totype
)
6167 && CONSTRUCTOR_NELTS (expr
) > 0
6168 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
6170 complained
= permerror (loc
, "too many braces around initializer "
6172 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6173 && CONSTRUCTOR_NELTS (expr
) == 1)
6174 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6177 /* Give a helpful error if this is bad because a conversion to bool
6178 from std::nullptr_t requires direct-initialization. */
6179 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
6180 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
6181 complained
= permerror (loc
, "converting to %qT from %qT requires "
6182 "direct-initialization",
6183 totype
, TREE_TYPE (expr
));
6185 for (; t
; t
= next_conversion (t
))
6187 if (t
->kind
== ck_user
&& t
->cand
->reason
)
6189 complained
= permerror (loc
, "invalid user-defined conversion "
6190 "from %qT to %qT", TREE_TYPE (expr
),
6193 print_z_candidate (loc
, "candidate is:", t
->cand
);
6194 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6195 /*issue_conversion_warnings=*/false,
6198 if (convs
->kind
== ck_ref_bind
)
6199 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
6200 LOOKUP_NORMAL
, NULL_TREE
,
6203 expr
= cp_convert (totype
, expr
, complain
);
6204 if (complained
&& fn
)
6205 inform (DECL_SOURCE_LOCATION (fn
),
6206 " initializing argument %P of %qD", argnum
, fn
);
6209 else if (t
->kind
== ck_user
|| !t
->bad_p
)
6211 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6212 /*issue_conversion_warnings=*/false,
6217 else if (t
->kind
== ck_ambig
)
6218 return convert_like_real (t
, expr
, fn
, argnum
, 1,
6219 /*issue_conversion_warnings=*/false,
6222 else if (t
->kind
== ck_identity
)
6226 complained
= permerror (loc
, "invalid conversion from %qT to %qT",
6227 TREE_TYPE (expr
), totype
);
6228 if (complained
&& fn
)
6229 inform (DECL_SOURCE_LOCATION (fn
),
6230 " initializing argument %P of %qD", argnum
, fn
);
6232 return cp_convert (totype
, expr
, complain
);
6235 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6236 conversion_null_warnings (totype
, expr
, fn
, argnum
);
6238 switch (convs
->kind
)
6242 struct z_candidate
*cand
= convs
->cand
;
6243 tree convfn
= cand
->fn
;
6246 /* If we're initializing from {}, it's value-initialization. Note
6247 that under the resolution of core 1630, value-initialization can
6248 use explicit constructors. */
6249 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6250 && CONSTRUCTOR_NELTS (expr
) == 0
6251 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
6253 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
6254 expr
= build_value_init (totype
, complain
);
6255 expr
= get_target_expr_sfinae (expr
, complain
);
6256 if (expr
!= error_mark_node
)
6258 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6259 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
6264 /* When converting from an init list we consider explicit
6265 constructors, but actually trying to call one is an error. */
6266 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
6267 /* Unless this is for direct-list-initialization. */
6268 && !DIRECT_LIST_INIT_P (expr
))
6270 if (!(complain
& tf_error
))
6271 return error_mark_node
;
6272 error ("converting to %qT from initializer list would use "
6273 "explicit constructor %qD", totype
, convfn
);
6276 expr
= mark_rvalue_use (expr
);
6278 /* Set user_conv_p on the argument conversions, so rvalue/base
6279 handling knows not to allow any more UDCs. */
6280 for (i
= 0; i
< cand
->num_convs
; ++i
)
6281 cand
->convs
[i
]->user_conv_p
= true;
6283 expr
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
6285 /* If this is a constructor or a function returning an aggr type,
6286 we need to build up a TARGET_EXPR. */
6287 if (DECL_CONSTRUCTOR_P (convfn
))
6289 expr
= build_cplus_new (totype
, expr
, complain
);
6291 /* Remember that this was list-initialization. */
6292 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
6293 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6299 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
6301 int nelts
= CONSTRUCTOR_NELTS (expr
);
6303 expr
= build_value_init (totype
, complain
);
6304 else if (nelts
== 1)
6305 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6309 expr
= mark_rvalue_use (expr
);
6311 if (type_unknown_p (expr
))
6312 expr
= instantiate_type (totype
, expr
, complain
);
6313 /* Convert a constant to its underlying value, unless we are
6314 about to bind it to a reference, in which case we need to
6315 leave it as an lvalue. */
6318 expr
= scalar_constant_value (expr
);
6319 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
6320 /* If __null has been converted to an integer type, we do not
6321 want to warn about uses of EXPR as an integer, rather than
6323 expr
= build_int_cst (totype
, 0);
6327 /* We leave bad_p off ck_ambig because overload resolution considers
6328 it valid, it just fails when we try to perform it. So we need to
6329 check complain here, too. */
6330 if (complain
& tf_error
)
6332 /* Call build_user_type_conversion again for the error. */
6333 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
6336 inform (input_location
, " initializing argument %P of %q+D",
6339 return error_mark_node
;
6343 /* Conversion to std::initializer_list<T>. */
6344 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
6345 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
6346 unsigned len
= CONSTRUCTOR_NELTS (expr
);
6347 tree array
, val
, field
;
6348 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6351 /* Convert all the elements. */
6352 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
6354 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
6355 1, false, false, complain
);
6356 if (sub
== error_mark_node
)
6358 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
6359 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
6360 return error_mark_node
;
6361 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
6362 if (!TREE_CONSTANT (sub
))
6363 TREE_CONSTANT (new_ctor
) = false;
6365 /* Build up the array. */
6366 elttype
= cp_build_qualified_type
6367 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
6368 array
= build_array_of_n_type (elttype
, len
);
6369 array
= finish_compound_literal (array
, new_ctor
, complain
);
6370 /* Take the address explicitly rather than via decay_conversion
6371 to avoid the error about taking the address of a temporary. */
6372 array
= cp_build_addr_expr (array
, complain
);
6373 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
6374 if (array
== error_mark_node
)
6375 return error_mark_node
;
6377 /* Build up the initializer_list object. */
6378 totype
= complete_type (totype
);
6379 field
= next_initializable_field (TYPE_FIELDS (totype
));
6380 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6381 field
= next_initializable_field (DECL_CHAIN (field
));
6382 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6383 new_ctor
= build_constructor (totype
, vec
);
6384 return get_target_expr_sfinae (new_ctor
, complain
);
6388 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6390 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6391 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6392 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6394 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6396 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6397 return fold_if_not_in_template (expr
);
6399 expr
= reshape_init (totype
, expr
, complain
);
6400 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6402 if (expr
!= error_mark_node
)
6403 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6410 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6411 convs
->kind
== ck_ref_bind
? -1 : 1,
6412 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6415 if (expr
== error_mark_node
)
6416 return error_mark_node
;
6418 switch (convs
->kind
)
6421 expr
= decay_conversion (expr
, complain
);
6422 if (expr
== error_mark_node
)
6423 return error_mark_node
;
6425 if (! MAYBE_CLASS_TYPE_P (totype
))
6427 /* Else fall through. */
6429 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6431 /* We are going to bind a reference directly to a base-class
6432 subobject of EXPR. */
6433 /* Build an expression for `*((base*) &expr)'. */
6434 expr
= convert_to_base (expr
, totype
,
6435 !c_cast_p
, /*nonnull=*/true, complain
);
6439 /* Copy-initialization where the cv-unqualified version of the source
6440 type is the same class as, or a derived class of, the class of the
6441 destination [is treated as direct-initialization]. [dcl.init] */
6442 flags
= LOOKUP_NORMAL
;
6443 if (convs
->user_conv_p
)
6444 /* This conversion is being done in the context of a user-defined
6445 conversion (i.e. the second step of copy-initialization), so
6446 don't allow any more. */
6447 flags
|= LOOKUP_NO_CONVERSION
;
6449 flags
|= LOOKUP_ONLYCONVERTING
;
6450 if (convs
->rvaluedness_matches_p
)
6451 flags
|= LOOKUP_PREFER_RVALUE
;
6452 if (TREE_CODE (expr
) == TARGET_EXPR
6453 && TARGET_EXPR_LIST_INIT_P (expr
))
6454 /* Copy-list-initialization doesn't actually involve a copy. */
6456 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6457 if (diag_kind
&& complain
)
6459 maybe_print_user_conv_context (convs
);
6461 inform (DECL_SOURCE_LOCATION (fn
),
6462 " initializing argument %P of %qD", argnum
, fn
);
6465 return build_cplus_new (totype
, expr
, complain
);
6469 tree ref_type
= totype
;
6471 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6473 tree extype
= TREE_TYPE (expr
);
6474 if (TYPE_REF_IS_RVALUE (ref_type
)
6475 && real_lvalue_p (expr
))
6476 error_at (loc
, "cannot bind %qT lvalue to %qT",
6478 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !real_lvalue_p (expr
)
6479 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
6480 error_at (loc
, "invalid initialization of non-const reference of "
6481 "type %qT from an rvalue of type %qT", totype
, extype
);
6482 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
6483 error_at (loc
, "binding %qT to reference of type %qT "
6484 "discards qualifiers", extype
, totype
);
6487 maybe_print_user_conv_context (convs
);
6489 inform (input_location
,
6490 " initializing argument %P of %q+D", argnum
, fn
);
6491 return error_mark_node
;
6494 /* If necessary, create a temporary.
6496 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6497 that need temporaries, even when their types are reference
6498 compatible with the type of reference being bound, so the
6499 upcoming call to cp_build_addr_expr doesn't fail. */
6500 if (convs
->need_temporary_p
6501 || TREE_CODE (expr
) == CONSTRUCTOR
6502 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6504 /* Otherwise, a temporary of type "cv1 T1" is created and
6505 initialized from the initializer expression using the rules
6506 for a non-reference copy-initialization (8.5). */
6508 tree type
= TREE_TYPE (ref_type
);
6509 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
6511 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6512 (type
, next_conversion (convs
)->type
));
6513 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6514 && !TYPE_REF_IS_RVALUE (ref_type
))
6516 /* If the reference is volatile or non-const, we
6517 cannot create a temporary. */
6518 if (lvalue
& clk_bitfield
)
6519 error_at (loc
, "cannot bind bitfield %qE to %qT",
6521 else if (lvalue
& clk_packed
)
6522 error_at (loc
, "cannot bind packed field %qE to %qT",
6525 error_at (loc
, "cannot bind rvalue %qE to %qT",
6527 return error_mark_node
;
6529 /* If the source is a packed field, and we must use a copy
6530 constructor, then building the target expr will require
6531 binding the field to the reference parameter to the
6532 copy constructor, and we'll end up with an infinite
6533 loop. If we can use a bitwise copy, then we'll be
6535 if ((lvalue
& clk_packed
)
6536 && CLASS_TYPE_P (type
)
6537 && type_has_nontrivial_copy_init (type
))
6539 error_at (loc
, "cannot bind packed field %qE to %qT",
6541 return error_mark_node
;
6543 if (lvalue
& clk_bitfield
)
6545 expr
= convert_bitfield_to_declared_type (expr
);
6546 expr
= fold_convert (type
, expr
);
6548 expr
= build_target_expr_with_type (expr
, type
, complain
);
6551 /* Take the address of the thing to which we will bind the
6553 expr
= cp_build_addr_expr (expr
, complain
);
6554 if (expr
== error_mark_node
)
6555 return error_mark_node
;
6557 /* Convert it to a pointer to the type referred to by the
6558 reference. This will adjust the pointer if a derived to
6559 base conversion is being performed. */
6560 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
6562 /* Convert the pointer to the desired reference type. */
6563 return build_nop (ref_type
, expr
);
6567 return decay_conversion (expr
, complain
);
6570 /* Warn about deprecated conversion if appropriate. */
6571 string_conv_p (totype
, expr
, 1);
6576 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
6577 /*nonnull=*/false, complain
);
6578 return build_nop (totype
, expr
);
6581 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
6582 c_cast_p
, complain
);
6588 if (convs
->check_narrowing
6589 && !check_narrowing (totype
, expr
, complain
))
6590 return error_mark_node
;
6592 if (issue_conversion_warnings
)
6593 expr
= cp_convert_and_check (totype
, expr
, complain
);
6595 expr
= cp_convert (totype
, expr
, complain
);
6600 /* ARG is being passed to a varargs function. Perform any conversions
6601 required. Return the converted value. */
6604 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
6607 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
6611 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6612 standard conversions are performed. */
6613 arg
= decay_conversion (arg
, complain
);
6614 arg_type
= TREE_TYPE (arg
);
6617 If the argument has integral or enumeration type that is subject
6618 to the integral promotions (_conv.prom_), or a floating point
6619 type that is subject to the floating point promotion
6620 (_conv.fpprom_), the value of the argument is converted to the
6621 promoted type before the call. */
6622 if (TREE_CODE (arg_type
) == REAL_TYPE
6623 && (TYPE_PRECISION (arg_type
)
6624 < TYPE_PRECISION (double_type_node
))
6625 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
6627 if ((complain
& tf_warning
)
6628 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
6629 warning_at (loc
, OPT_Wdouble_promotion
,
6630 "implicit conversion from %qT to %qT when passing "
6631 "argument to function",
6632 arg_type
, double_type_node
);
6633 arg
= convert_to_real (double_type_node
, arg
);
6635 else if (NULLPTR_TYPE_P (arg_type
))
6636 arg
= null_pointer_node
;
6637 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
6639 if (SCOPED_ENUM_P (arg_type
))
6641 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
6643 prom
= cp_perform_integral_promotions (prom
, complain
);
6644 if (abi_version_crosses (6)
6645 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
6646 && (complain
& tf_warning
))
6647 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through ... as "
6648 "%qT before -fabi-version=6, %qT after", arg_type
,
6649 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
6650 if (!abi_version_at_least (6))
6654 arg
= cp_perform_integral_promotions (arg
, complain
);
6657 arg
= require_complete_type_sfinae (arg
, complain
);
6658 arg_type
= TREE_TYPE (arg
);
6660 if (arg
!= error_mark_node
6661 /* In a template (or ill-formed code), we can have an incomplete type
6662 even after require_complete_type_sfinae, in which case we don't know
6663 whether it has trivial copy or not. */
6664 && COMPLETE_TYPE_P (arg_type
))
6666 /* Build up a real lvalue-to-rvalue conversion in case the
6667 copy constructor is trivial but not callable. */
6668 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
6669 force_rvalue (arg
, complain
);
6671 /* [expr.call] 5.2.2/7:
6672 Passing a potentially-evaluated argument of class type (Clause 9)
6673 with a non-trivial copy constructor or a non-trivial destructor
6674 with no corresponding parameter is conditionally-supported, with
6675 implementation-defined semantics.
6677 We support it as pass-by-invisible-reference, just like a normal
6680 If the call appears in the context of a sizeof expression,
6681 it is not potentially-evaluated. */
6682 if (cp_unevaluated_operand
== 0
6683 && (type_has_nontrivial_copy_init (arg_type
)
6684 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
6686 if (complain
& tf_warning
)
6687 warning (OPT_Wconditionally_supported
,
6688 "passing objects of non-trivially-copyable "
6689 "type %q#T through %<...%> is conditionally supported",
6691 return cp_build_addr_expr (arg
, complain
);
6698 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6701 build_x_va_arg (source_location loc
, tree expr
, tree type
)
6703 if (processing_template_decl
)
6705 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
6706 SET_EXPR_LOCATION (r
, loc
);
6710 type
= complete_type_or_else (type
, NULL_TREE
);
6712 if (expr
== error_mark_node
|| !type
)
6713 return error_mark_node
;
6715 expr
= mark_lvalue_use (expr
);
6717 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6719 error ("cannot receive reference type %qT through %<...%>", type
);
6720 return error_mark_node
;
6723 if (type_has_nontrivial_copy_init (type
)
6724 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6726 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
6727 it as pass by invisible reference. */
6728 warning_at (loc
, OPT_Wconditionally_supported
,
6729 "receiving objects of non-trivially-copyable type %q#T "
6730 "through %<...%> is conditionally-supported", type
);
6732 tree ref
= cp_build_reference_type (type
, false);
6733 expr
= build_va_arg (loc
, expr
, ref
);
6734 return convert_from_reference (expr
);
6737 return build_va_arg (loc
, expr
, type
);
6740 /* TYPE has been given to va_arg. Apply the default conversions which
6741 would have happened when passed via ellipsis. Return the promoted
6742 type, or the passed type if there is no change. */
6745 cxx_type_promotes_to (tree type
)
6749 /* Perform the array-to-pointer and function-to-pointer
6751 type
= type_decays_to (type
);
6753 promote
= type_promotes_to (type
);
6754 if (same_type_p (type
, promote
))
6760 /* ARG is a default argument expression being passed to a parameter of
6761 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6762 zero-based argument number. Do any required conversions. Return
6763 the converted value. */
6765 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
6767 push_defarg_context (tree fn
)
6768 { vec_safe_push (default_arg_context
, fn
); }
6771 pop_defarg_context (void)
6772 { default_arg_context
->pop (); }
6775 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
6776 tsubst_flags_t complain
)
6781 /* See through clones. */
6782 fn
= DECL_ORIGIN (fn
);
6784 /* Detect recursion. */
6785 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
6788 if (complain
& tf_error
)
6789 error ("recursive evaluation of default argument for %q#D", fn
);
6790 return error_mark_node
;
6793 /* If the ARG is an unparsed default argument expression, the
6794 conversion cannot be performed. */
6795 if (TREE_CODE (arg
) == DEFAULT_ARG
)
6797 if (complain
& tf_error
)
6798 error ("call to %qD uses the default argument for parameter %P, which "
6799 "is not yet defined", fn
, parmnum
);
6800 return error_mark_node
;
6803 push_defarg_context (fn
);
6805 if (fn
&& DECL_TEMPLATE_INFO (fn
))
6806 arg
= tsubst_default_argument (fn
, type
, arg
, complain
);
6812 The names in the expression are bound, and the semantic
6813 constraints are checked, at the point where the default
6814 expressions appears.
6816 we must not perform access checks here. */
6817 push_deferring_access_checks (dk_no_check
);
6818 /* We must make a copy of ARG, in case subsequent processing
6819 alters any part of it. */
6820 arg
= break_out_target_exprs (arg
);
6821 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6822 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6824 arg
= convert_for_arg_passing (type
, arg
, complain
);
6825 pop_deferring_access_checks();
6827 pop_defarg_context ();
6832 /* Returns the type which will really be used for passing an argument of
6836 type_passed_as (tree type
)
6838 /* Pass classes with copy ctors by invisible reference. */
6839 if (TREE_ADDRESSABLE (type
))
6841 type
= build_reference_type (type
);
6842 /* There are no other pointers to this temporary. */
6843 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
6845 else if (targetm
.calls
.promote_prototypes (type
)
6846 && INTEGRAL_TYPE_P (type
)
6847 && COMPLETE_TYPE_P (type
)
6848 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6849 type
= integer_type_node
;
6854 /* Actually perform the appropriate conversion. */
6857 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
6861 /* If VAL is a bitfield, then -- since it has already been converted
6862 to TYPE -- it cannot have a precision greater than TYPE.
6864 If it has a smaller precision, we must widen it here. For
6865 example, passing "int f:3;" to a function expecting an "int" will
6866 not result in any conversion before this point.
6868 If the precision is the same we must not risk widening. For
6869 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6870 often have type "int", even though the C++ type for the field is
6871 "long long". If the value is being passed to a function
6872 expecting an "int", then no conversions will be required. But,
6873 if we call convert_bitfield_to_declared_type, the bitfield will
6874 be converted to "long long". */
6875 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
6877 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
6878 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
6880 if (val
== error_mark_node
)
6882 /* Pass classes with copy ctors by invisible reference. */
6883 else if (TREE_ADDRESSABLE (type
))
6884 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
6885 else if (targetm
.calls
.promote_prototypes (type
)
6886 && INTEGRAL_TYPE_P (type
)
6887 && COMPLETE_TYPE_P (type
)
6888 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6889 val
= cp_perform_integral_promotions (val
, complain
);
6890 if ((complain
& tf_warning
)
6891 && warn_suggest_attribute_format
)
6893 tree rhstype
= TREE_TYPE (val
);
6894 const enum tree_code coder
= TREE_CODE (rhstype
);
6895 const enum tree_code codel
= TREE_CODE (type
);
6896 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6898 && check_missing_format_attribute (type
, rhstype
))
6899 warning (OPT_Wsuggest_attribute_format
,
6900 "argument of function call might be a candidate for a format attribute");
6905 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6906 which no conversions at all should be done. This is true for some
6907 builtins which don't act like normal functions. */
6910 magic_varargs_p (tree fn
)
6912 if (flag_cilkplus
&& is_cilkplus_reduce_builtin (fn
) != BUILT_IN_NONE
)
6915 if (DECL_BUILT_IN (fn
))
6916 switch (DECL_FUNCTION_CODE (fn
))
6918 case BUILT_IN_CLASSIFY_TYPE
:
6919 case BUILT_IN_CONSTANT_P
:
6920 case BUILT_IN_NEXT_ARG
:
6921 case BUILT_IN_VA_START
:
6925 return lookup_attribute ("type generic",
6926 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
6932 /* Returns the decl of the dispatcher function if FN is a function version. */
6935 get_function_version_dispatcher (tree fn
)
6937 tree dispatcher_decl
= NULL
;
6939 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6940 && DECL_FUNCTION_VERSIONED (fn
));
6942 gcc_assert (targetm
.get_function_versions_dispatcher
);
6943 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
6945 if (dispatcher_decl
== NULL
)
6947 error_at (input_location
, "use of multiversioned function "
6948 "without a default");
6952 retrofit_lang_decl (dispatcher_decl
);
6953 gcc_assert (dispatcher_decl
!= NULL
);
6954 return dispatcher_decl
;
6957 /* fn is a function version dispatcher that is marked used. Mark all the
6958 semantically identical function versions it will dispatch as used. */
6961 mark_versions_used (tree fn
)
6963 struct cgraph_node
*node
;
6964 struct cgraph_function_version_info
*node_v
;
6965 struct cgraph_function_version_info
*it_v
;
6967 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6969 node
= cgraph_node::get (fn
);
6973 gcc_assert (node
->dispatcher_function
);
6975 node_v
= node
->function_version ();
6979 /* All semantically identical versions are chained. Traverse and mark each
6980 one of them as used. */
6981 it_v
= node_v
->next
;
6982 while (it_v
!= NULL
)
6984 mark_used (it_v
->this_node
->decl
);
6989 /* Build a call to "the copy constructor" for the type of A, even if it
6990 wouldn't be selected by normal overload resolution. Used for
6994 call_copy_ctor (tree a
, tsubst_flags_t complain
)
6996 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
6997 tree binfo
= TYPE_BINFO (ctype
);
6998 tree copy
= get_copy_ctor (ctype
, complain
);
6999 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
7000 tree ob
= build_dummy_object (ctype
);
7001 vec
<tree
, va_gc
>* args
= make_tree_vector_single (a
);
7002 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
7003 LOOKUP_NORMAL
, NULL
, complain
);
7004 release_tree_vector (args
);
7008 /* Subroutine of the various build_*_call functions. Overload resolution
7009 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
7010 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
7011 bitmask of various LOOKUP_* flags which apply to the call itself. */
7014 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
7017 const vec
<tree
, va_gc
> *args
= cand
->args
;
7018 tree first_arg
= cand
->first_arg
;
7019 conversion
**convs
= cand
->convs
;
7021 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7026 unsigned int arg_index
= 0;
7030 bool already_used
= false;
7032 /* In a template, there is no need to perform all of the work that
7033 is normally done. We are only interested in the type of the call
7034 expression, i.e., the return type of the function. Any semantic
7035 errors will be deferred until the template is instantiated. */
7036 if (processing_template_decl
)
7040 const tree
*argarray
;
7043 return_type
= TREE_TYPE (TREE_TYPE (fn
));
7044 nargs
= vec_safe_length (args
);
7045 if (first_arg
== NULL_TREE
)
7046 argarray
= args
->address ();
7054 alcarray
= XALLOCAVEC (tree
, nargs
);
7055 alcarray
[0] = build_this (first_arg
);
7056 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
7057 alcarray
[ix
+ 1] = arg
;
7058 argarray
= alcarray
;
7061 addr
= build_addr_func (fn
, complain
);
7062 if (addr
== error_mark_node
)
7063 return error_mark_node
;
7064 expr
= build_call_array_loc (input_location
, return_type
,
7065 addr
, nargs
, argarray
);
7066 if (TREE_THIS_VOLATILE (fn
) && cfun
)
7067 current_function_returns_abnormally
= 1;
7068 return convert_from_reference (expr
);
7071 /* Give any warnings we noticed during overload resolution. */
7072 if (cand
->warnings
&& (complain
& tf_warning
))
7074 struct candidate_warning
*w
;
7075 for (w
= cand
->warnings
; w
; w
= w
->next
)
7076 joust (cand
, w
->loser
, 1, complain
);
7079 /* Make =delete work with SFINAE. */
7080 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7081 return error_mark_node
;
7083 if (DECL_FUNCTION_MEMBER_P (fn
))
7086 /* If FN is a template function, two cases must be considered.
7091 template <class T> void f();
7093 template <class T> struct B {
7097 struct C : A, B<int> {
7099 using B<int>::g; // #2
7102 In case #1 where `A::f' is a member template, DECL_ACCESS is
7103 recorded in the primary template but not in its specialization.
7104 We check access of FN using its primary template.
7106 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
7107 because it is a member of class template B, DECL_ACCESS is
7108 recorded in the specialization `B<int>::g'. We cannot use its
7109 primary template because `B<T>::g' and `B<int>::g' may have
7110 different access. */
7111 if (DECL_TEMPLATE_INFO (fn
)
7112 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
7113 access_fn
= DECL_TI_TEMPLATE (fn
);
7116 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
7118 return error_mark_node
;
7121 /* If we're checking for implicit delete, don't bother with argument
7123 if (flags
& LOOKUP_SPECULATIVE
)
7125 if (DECL_DELETED_FN (fn
))
7127 if (complain
& tf_error
)
7129 return error_mark_node
;
7131 if (cand
->viable
== 1)
7133 else if (!(complain
& tf_error
))
7134 /* Reject bad conversions now. */
7135 return error_mark_node
;
7136 /* else continue to get conversion error. */
7139 /* N3276 magic doesn't apply to nested calls. */
7140 int decltype_flag
= (complain
& tf_decltype
);
7141 complain
&= ~tf_decltype
;
7143 /* Find maximum size of vector to hold converted arguments. */
7144 parmlen
= list_length (parm
);
7145 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
7146 if (parmlen
> nargs
)
7148 argarray
= XALLOCAVEC (tree
, nargs
);
7150 /* The implicit parameters to a constructor are not considered by overload
7151 resolution, and must be of the proper type. */
7152 if (DECL_CONSTRUCTOR_P (fn
))
7155 if (first_arg
!= NULL_TREE
)
7157 object_arg
= first_arg
;
7158 first_arg
= NULL_TREE
;
7162 object_arg
= (*args
)[arg_index
];
7165 argarray
[j
++] = build_this (object_arg
);
7166 parm
= TREE_CHAIN (parm
);
7167 /* We should never try to call the abstract constructor. */
7168 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
7170 if (DECL_HAS_VTT_PARM_P (fn
))
7172 argarray
[j
++] = (*args
)[arg_index
];
7174 parm
= TREE_CHAIN (parm
);
7177 /* Bypass access control for 'this' parameter. */
7178 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7180 tree parmtype
= TREE_VALUE (parm
);
7181 tree arg
= build_this (first_arg
!= NULL_TREE
7183 : (*args
)[arg_index
]);
7184 tree argtype
= TREE_TYPE (arg
);
7188 if (convs
[i
]->bad_p
)
7190 if (complain
& tf_error
)
7192 if (permerror (input_location
, "passing %qT as %<this%> "
7193 "argument discards qualifiers",
7194 TREE_TYPE (argtype
)))
7195 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
7198 return error_mark_node
;
7201 /* See if the function member or the whole class type is declared
7202 final and the call can be devirtualized. */
7203 if (DECL_FINAL_P (fn
)
7204 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
7205 flags
|= LOOKUP_NONVIRTUAL
;
7207 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
7208 X is called for an object that is not of type X, or of a type
7209 derived from X, the behavior is undefined.
7211 So we can assume that anything passed as 'this' is non-null, and
7212 optimize accordingly. */
7213 gcc_assert (TYPE_PTR_P (parmtype
));
7214 /* Convert to the base in which the function was declared. */
7215 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
7216 converted_arg
= build_base_path (PLUS_EXPR
,
7218 cand
->conversion_path
,
7220 /* Check that the base class is accessible. */
7221 if (!accessible_base_p (TREE_TYPE (argtype
),
7222 BINFO_TYPE (cand
->conversion_path
), true))
7224 if (complain
& tf_error
)
7225 error ("%qT is not an accessible base of %qT",
7226 BINFO_TYPE (cand
->conversion_path
),
7227 TREE_TYPE (argtype
));
7229 return error_mark_node
;
7231 /* If fn was found by a using declaration, the conversion path
7232 will be to the derived class, not the base declaring fn. We
7233 must convert from derived to base. */
7234 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
7235 TREE_TYPE (parmtype
), ba_unique
,
7237 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
7238 base_binfo
, 1, complain
);
7240 argarray
[j
++] = converted_arg
;
7241 parm
= TREE_CHAIN (parm
);
7242 if (first_arg
!= NULL_TREE
)
7243 first_arg
= NULL_TREE
;
7250 gcc_assert (first_arg
== NULL_TREE
);
7251 for (; arg_index
< vec_safe_length (args
) && parm
;
7252 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
7254 tree type
= TREE_VALUE (parm
);
7255 tree arg
= (*args
)[arg_index
];
7256 bool conversion_warning
= true;
7260 /* If the argument is NULL and used to (implicitly) instantiate a
7261 template function (and bind one of the template arguments to
7262 the type of 'long int'), we don't want to warn about passing NULL
7263 to non-pointer argument.
7264 For example, if we have this template function:
7266 template<typename T> void func(T x) {}
7268 we want to warn (when -Wconversion is enabled) in this case:
7274 but not in this case:
7280 if (arg
== null_node
7281 && DECL_TEMPLATE_INFO (fn
)
7282 && cand
->template_decl
7283 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
7284 conversion_warning
= false;
7286 /* Warn about initializer_list deduction that isn't currently in the
7288 if (cxx_dialect
> cxx98
7289 && flag_deduce_init_list
7290 && cand
->template_decl
7291 && is_std_init_list (non_reference (type
))
7292 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
7294 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
7295 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
7296 tree patparm
= get_pattern_parm (realparm
, tmpl
);
7297 tree pattype
= TREE_TYPE (patparm
);
7298 if (PACK_EXPANSION_P (pattype
))
7299 pattype
= PACK_EXPANSION_PATTERN (pattype
);
7300 pattype
= non_reference (pattype
);
7302 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
7303 && (cand
->explicit_targs
== NULL_TREE
7304 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
7305 <= TEMPLATE_TYPE_IDX (pattype
))))
7307 pedwarn (input_location
, 0, "deducing %qT as %qT",
7308 non_reference (TREE_TYPE (patparm
)),
7309 non_reference (type
));
7310 pedwarn (input_location
, 0, " in call to %q+D", cand
->fn
);
7311 pedwarn (input_location
, 0,
7312 " (you can disable this with -fno-deduce-init-list)");
7315 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
7318 : complain
& (~tf_warning
));
7320 val
= convert_for_arg_passing (type
, val
, complain
);
7322 if (val
== error_mark_node
)
7323 return error_mark_node
;
7325 argarray
[j
++] = val
;
7328 /* Default arguments */
7329 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
7331 if (TREE_VALUE (parm
) == error_mark_node
)
7332 return error_mark_node
;
7333 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
7334 TREE_PURPOSE (parm
),
7340 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
7342 tree a
= (*args
)[arg_index
];
7343 if (magic_varargs_p (fn
))
7344 /* Do no conversions for magic varargs. */
7345 a
= mark_type_use (a
);
7346 else if (DECL_CONSTRUCTOR_P (fn
)
7347 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
7350 /* Avoid infinite recursion trying to call A(...). */
7351 if (complain
& tf_error
)
7352 /* Try to call the actual copy constructor for a good error. */
7353 call_copy_ctor (a
, complain
);
7354 return error_mark_node
;
7357 a
= convert_arg_to_ellipsis (a
, complain
);
7361 gcc_assert (j
<= nargs
);
7364 check_function_arguments (TREE_TYPE (fn
), nargs
, argarray
);
7366 /* Avoid actually calling copy constructors and copy assignment operators,
7369 if (! flag_elide_constructors
)
7370 /* Do things the hard way. */;
7371 else if (cand
->num_convs
== 1
7372 && (DECL_COPY_CONSTRUCTOR_P (fn
)
7373 || DECL_MOVE_CONSTRUCTOR_P (fn
))
7374 /* It's unsafe to elide the constructor when handling
7375 a noexcept-expression, it may evaluate to the wrong
7376 value (c++/53025). */
7377 && cp_noexcept_operand
== 0)
7380 tree arg
= argarray
[num_artificial_parms_for (fn
)];
7382 bool trivial
= trivial_fn_p (fn
);
7384 /* Pull out the real argument, disregarding const-correctness. */
7386 while (CONVERT_EXPR_P (targ
)
7387 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
7388 targ
= TREE_OPERAND (targ
, 0);
7389 if (TREE_CODE (targ
) == ADDR_EXPR
)
7391 targ
= TREE_OPERAND (targ
, 0);
7392 if (!same_type_ignoring_top_level_qualifiers_p
7393 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
7402 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7404 /* [class.copy]: the copy constructor is implicitly defined even if
7405 the implementation elided its use. */
7406 if (!trivial
|| DECL_DELETED_FN (fn
))
7408 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7409 return error_mark_node
;
7410 already_used
= true;
7413 /* If we're creating a temp and we already have one, don't create a
7414 new one. If we're not creating a temp but we get one, use
7415 INIT_EXPR to collapse the temp into our target. Otherwise, if the
7416 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
7417 temp or an INIT_EXPR otherwise. */
7419 if (is_dummy_object (fa
))
7421 if (TREE_CODE (arg
) == TARGET_EXPR
)
7424 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
7426 else if (TREE_CODE (arg
) == TARGET_EXPR
|| trivial
)
7428 tree to
= stabilize_reference (cp_build_indirect_ref (fa
, RO_NULL
,
7431 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
7435 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
7436 && trivial_fn_p (fn
)
7437 && !DECL_DELETED_FN (fn
))
7439 tree to
= stabilize_reference
7440 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
7441 tree type
= TREE_TYPE (to
);
7442 tree as_base
= CLASSTYPE_AS_BASE (type
);
7443 tree arg
= argarray
[1];
7445 if (is_really_empty_class (type
))
7447 /* Avoid copying empty classes. */
7448 val
= build2 (COMPOUND_EXPR
, void_type_node
, to
, arg
);
7449 TREE_NO_WARNING (val
) = 1;
7450 val
= build2 (COMPOUND_EXPR
, type
, val
, to
);
7451 TREE_NO_WARNING (val
) = 1;
7453 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
7455 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7456 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
7460 /* We must only copy the non-tail padding parts. */
7462 tree array_type
, alias_set
;
7464 arg2
= TYPE_SIZE_UNIT (as_base
);
7465 arg0
= cp_build_addr_expr (to
, complain
);
7467 array_type
= build_array_type (char_type_node
,
7469 (size_binop (MINUS_EXPR
,
7470 arg2
, size_int (1))));
7471 alias_set
= build_int_cst (build_pointer_type (type
), 0);
7472 t
= build2 (MODIFY_EXPR
, void_type_node
,
7473 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
7474 build2 (MEM_REF
, array_type
, arg
, alias_set
));
7475 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
7476 TREE_NO_WARNING (val
) = 1;
7481 else if (DECL_DESTRUCTOR_P (fn
)
7482 && trivial_fn_p (fn
)
7483 && !DECL_DELETED_FN (fn
))
7484 return fold_convert (void_type_node
, argarray
[0]);
7485 /* FIXME handle trivial default constructor, too. */
7487 /* For calls to a multi-versioned function, overload resolution
7488 returns the function with the highest target priority, that is,
7489 the version that will checked for dispatching first. If this
7490 version is inlinable, a direct call to this version can be made
7491 otherwise the call should go through the dispatcher. */
7493 if (DECL_FUNCTION_VERSIONED (fn
)
7494 && (current_function_decl
== NULL
7495 || !targetm
.target_option
.can_inline_p (current_function_decl
, fn
)))
7497 fn
= get_function_version_dispatcher (fn
);
7501 mark_versions_used (fn
);
7505 && !mark_used (fn
, complain
))
7506 return error_mark_node
;
7508 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
7509 /* Don't mess with virtual lookup in instantiate_non_dependent_expr;
7510 virtual functions can't be constexpr. */
7511 && !in_template_function ())
7514 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
7516 ba_any
, NULL
, complain
);
7517 gcc_assert (binfo
&& binfo
!= error_mark_node
);
7519 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
7521 if (TREE_SIDE_EFFECTS (argarray
[0]))
7522 argarray
[0] = save_expr (argarray
[0]);
7523 t
= build_pointer_type (TREE_TYPE (fn
));
7524 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
7525 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
7527 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
7532 fn
= build_addr_func (fn
, complain
);
7533 if (fn
== error_mark_node
)
7534 return error_mark_node
;
7537 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
7538 if (TREE_CODE (call
) == CALL_EXPR
7539 && (cand
->flags
& LOOKUP_LIST_INIT_CTOR
))
7540 CALL_EXPR_LIST_INIT_P (call
) = true;
7544 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7545 This function performs no overload resolution, conversion, or other
7546 high-level operations. */
7549 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
7550 tsubst_flags_t complain
)
7555 /* Remember roughly where this call is. */
7556 location_t loc
= EXPR_LOC_OR_LOC (fn
, input_location
);
7557 fn
= build_call_a (fn
, nargs
, argarray
);
7558 SET_EXPR_LOCATION (fn
, loc
);
7560 fndecl
= get_callee_fndecl (fn
);
7562 /* Check that arguments to builtin functions match the expectations. */
7564 && DECL_BUILT_IN (fndecl
)
7565 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7566 && !check_builtin_function_arguments (fndecl
, nargs
, argarray
))
7567 return error_mark_node
;
7569 /* If it is a built-in array notation function, then the return type of
7570 the function is the element type of the array passed in as array
7571 notation (i.e. the first parameter of the function). */
7572 if (flag_cilkplus
&& TREE_CODE (fn
) == CALL_EXPR
)
7574 enum built_in_function bif
=
7575 is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn
));
7576 if (bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
7577 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
7578 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
7579 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
7580 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE
7581 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
7583 if (call_expr_nargs (fn
) == 0)
7585 error_at (EXPR_LOCATION (fn
), "Invalid builtin arguments");
7586 return error_mark_node
;
7588 /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or
7589 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or
7590 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or
7591 BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or
7592 BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or
7593 BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
7594 The pre-defined return-type is the correct one. */
7595 tree array_ntn
= CALL_EXPR_ARG (fn
, 0);
7596 TREE_TYPE (fn
) = TREE_TYPE (array_ntn
);
7601 /* Some built-in function calls will be evaluated at compile-time in
7602 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7603 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7604 optimize_sav
= optimize
;
7605 if (!optimize
&& fndecl
&& DECL_IS_BUILTIN_CONSTANT_P (fndecl
)
7606 && current_function_decl
7607 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
7609 fn
= fold_if_not_in_template (fn
);
7610 optimize
= optimize_sav
;
7612 if (VOID_TYPE_P (TREE_TYPE (fn
)))
7615 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7616 function call is either the operand of a decltype-specifier or the
7617 right operand of a comma operator that is the operand of a
7618 decltype-specifier, a temporary object is not introduced for the
7619 prvalue. The type of the prvalue may be incomplete. */
7620 if (!(complain
& tf_decltype
))
7622 fn
= require_complete_type_sfinae (fn
, complain
);
7623 if (fn
== error_mark_node
)
7624 return error_mark_node
;
7626 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
7627 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
7629 return convert_from_reference (fn
);
7632 static GTY(()) tree java_iface_lookup_fn
;
7634 /* Make an expression which yields the address of the Java interface
7635 method FN. This is achieved by generating a call to libjava's
7636 _Jv_LookupInterfaceMethodIdx(). */
7639 build_java_interface_fn_ref (tree fn
, tree instance
)
7641 tree lookup_fn
, method
, idx
;
7642 tree klass_ref
, iface
, iface_ref
;
7645 if (!java_iface_lookup_fn
)
7647 tree ftype
= build_function_type_list (ptr_type_node
,
7648 ptr_type_node
, ptr_type_node
,
7649 java_int_type_node
, NULL_TREE
);
7650 java_iface_lookup_fn
7651 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype
,
7652 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
7655 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7656 This is the first entry in the vtable. */
7657 klass_ref
= build_vtbl_ref (cp_build_indirect_ref (instance
, RO_NULL
,
7658 tf_warning_or_error
),
7661 /* Get the java.lang.Class pointer for the interface being called. */
7662 iface
= DECL_CONTEXT (fn
);
7663 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
7664 if (!iface_ref
|| !VAR_P (iface_ref
)
7665 || DECL_CONTEXT (iface_ref
) != iface
)
7667 error ("could not find class$ field in java interface type %qT",
7669 return error_mark_node
;
7671 iface_ref
= build_address (iface_ref
);
7672 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
7674 /* Determine the itable index of FN. */
7676 for (method
= TYPE_METHODS (iface
); method
; method
= DECL_CHAIN (method
))
7678 if (!DECL_VIRTUAL_P (method
))
7684 idx
= build_int_cst (NULL_TREE
, i
);
7686 lookup_fn
= build1 (ADDR_EXPR
,
7687 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
7688 java_iface_lookup_fn
);
7689 return build_call_nary (ptr_type_node
, lookup_fn
,
7690 3, klass_ref
, iface_ref
, idx
);
7693 /* Returns the value to use for the in-charge parameter when making a
7694 call to a function with the indicated NAME.
7696 FIXME:Can't we find a neater way to do this mapping? */
7699 in_charge_arg_for_name (tree name
)
7701 if (name
== base_ctor_identifier
7702 || name
== base_dtor_identifier
)
7703 return integer_zero_node
;
7704 else if (name
== complete_ctor_identifier
)
7705 return integer_one_node
;
7706 else if (name
== complete_dtor_identifier
)
7707 return integer_two_node
;
7708 else if (name
== deleting_dtor_identifier
)
7709 return integer_three_node
;
7711 /* This function should only be called with one of the names listed
7717 /* Build a call to a constructor, destructor, or an assignment
7718 operator for INSTANCE, an expression with class type. NAME
7719 indicates the special member function to call; *ARGS are the
7720 arguments. ARGS may be NULL. This may change ARGS. BINFO
7721 indicates the base of INSTANCE that is to be passed as the `this'
7722 parameter to the member function called.
7724 FLAGS are the LOOKUP_* flags to use when processing the call.
7726 If NAME indicates a complete object constructor, INSTANCE may be
7727 NULL_TREE. In this case, the caller will call build_cplus_new to
7728 store the newly constructed object into a VAR_DECL. */
7731 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
7732 tree binfo
, int flags
, tsubst_flags_t complain
)
7735 /* The type of the subobject to be constructed or destroyed. */
7737 vec
<tree
, va_gc
> *allocated
= NULL
;
7740 gcc_assert (name
== complete_ctor_identifier
7741 || name
== base_ctor_identifier
7742 || name
== complete_dtor_identifier
7743 || name
== base_dtor_identifier
7744 || name
== deleting_dtor_identifier
7745 || name
== ansi_assopname (NOP_EXPR
));
7748 /* Resolve the name. */
7749 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
7750 return error_mark_node
;
7752 binfo
= TYPE_BINFO (binfo
);
7755 gcc_assert (binfo
!= NULL_TREE
);
7757 class_type
= BINFO_TYPE (binfo
);
7759 /* Handle the special case where INSTANCE is NULL_TREE. */
7760 if (name
== complete_ctor_identifier
&& !instance
)
7761 instance
= build_dummy_object (class_type
);
7764 if (name
== complete_dtor_identifier
7765 || name
== base_dtor_identifier
7766 || name
== deleting_dtor_identifier
)
7767 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
7769 /* Convert to the base class, if necessary. */
7770 if (!same_type_ignoring_top_level_qualifiers_p
7771 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
7773 if (name
!= ansi_assopname (NOP_EXPR
))
7774 /* For constructors and destructors, either the base is
7775 non-virtual, or it is virtual but we are doing the
7776 conversion from a constructor or destructor for the
7777 complete object. In either case, we can convert
7779 instance
= convert_to_base_statically (instance
, binfo
);
7781 /* However, for assignment operators, we must convert
7782 dynamically if the base is virtual. */
7783 instance
= build_base_path (PLUS_EXPR
, instance
,
7784 binfo
, /*nonnull=*/1, complain
);
7788 gcc_assert (instance
!= NULL_TREE
);
7790 fns
= lookup_fnfields (binfo
, name
, 1);
7792 /* When making a call to a constructor or destructor for a subobject
7793 that uses virtual base classes, pass down a pointer to a VTT for
7795 if ((name
== base_ctor_identifier
7796 || name
== base_dtor_identifier
)
7797 && CLASSTYPE_VBASECLASSES (class_type
))
7802 /* If the current function is a complete object constructor
7803 or destructor, then we fetch the VTT directly.
7804 Otherwise, we look it up using the VTT we were given. */
7805 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
7806 vtt
= decay_conversion (vtt
, complain
);
7807 if (vtt
== error_mark_node
)
7808 return error_mark_node
;
7809 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
7810 build2 (EQ_EXPR
, boolean_type_node
,
7811 current_in_charge_parm
, integer_zero_node
),
7814 if (BINFO_SUBVTT_INDEX (binfo
))
7815 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
7821 allocated
= make_tree_vector ();
7825 vec_safe_insert (*args
, 0, sub_vtt
);
7828 ret
= build_new_method_call (instance
, fns
, args
,
7829 TYPE_BINFO (BINFO_TYPE (binfo
)),
7833 if (allocated
!= NULL
)
7834 release_tree_vector (allocated
);
7836 if ((complain
& tf_error
)
7837 && (flags
& LOOKUP_DELEGATING_CONS
)
7838 && name
== complete_ctor_identifier
7839 && TREE_CODE (ret
) == CALL_EXPR
7840 && (DECL_ABSTRACT_ORIGIN (TREE_OPERAND (CALL_EXPR_FN (ret
), 0))
7841 == current_function_decl
))
7842 error ("constructor delegates to itself");
7847 /* Return the NAME, as a C string. The NAME indicates a function that
7848 is a member of TYPE. *FREE_P is set to true if the caller must
7849 free the memory returned.
7851 Rather than go through all of this, we should simply set the names
7852 of constructors and destructors appropriately, and dispense with
7853 ctor_identifier, dtor_identifier, etc. */
7856 name_as_c_string (tree name
, tree type
, bool *free_p
)
7860 /* Assume that we will not allocate memory. */
7862 /* Constructors and destructors are special. */
7863 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7866 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
7867 /* For a destructor, add the '~'. */
7868 if (name
== complete_dtor_identifier
7869 || name
== base_dtor_identifier
7870 || name
== deleting_dtor_identifier
)
7872 pretty_name
= concat ("~", pretty_name
, NULL
);
7873 /* Remember that we need to free the memory allocated. */
7877 else if (IDENTIFIER_TYPENAME_P (name
))
7879 pretty_name
= concat ("operator ",
7880 type_as_string_translate (TREE_TYPE (name
),
7881 TFF_PLAIN_IDENTIFIER
),
7883 /* Remember that we need to free the memory allocated. */
7887 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
7892 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
7893 be set, upon return, to the function called. ARGS may be NULL.
7894 This may change ARGS. */
7897 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
7898 tree conversion_path
, int flags
,
7899 tree
*fn_p
, tsubst_flags_t complain
)
7901 struct z_candidate
*candidates
= 0, *cand
;
7902 tree explicit_targs
= NULL_TREE
;
7903 tree basetype
= NULL_TREE
;
7904 tree access_binfo
, binfo
;
7906 tree first_mem_arg
= NULL_TREE
;
7908 bool skip_first_for_error
;
7909 vec
<tree
, va_gc
> *user_args
;
7912 int template_only
= 0;
7916 vec
<tree
, va_gc
> *orig_args
= NULL
;
7919 gcc_assert (instance
!= NULL_TREE
);
7921 /* We don't know what function we're going to call, yet. */
7925 if (error_operand_p (instance
)
7926 || !fns
|| error_operand_p (fns
))
7927 return error_mark_node
;
7929 if (!BASELINK_P (fns
))
7931 if (complain
& tf_error
)
7932 error ("call to non-function %qD", fns
);
7933 return error_mark_node
;
7936 orig_instance
= instance
;
7939 /* Dismantle the baselink to collect all the information we need. */
7940 if (!conversion_path
)
7941 conversion_path
= BASELINK_BINFO (fns
);
7942 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
7943 binfo
= BASELINK_BINFO (fns
);
7944 optype
= BASELINK_OPTYPE (fns
);
7945 fns
= BASELINK_FUNCTIONS (fns
);
7946 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
7948 explicit_targs
= TREE_OPERAND (fns
, 1);
7949 fns
= TREE_OPERAND (fns
, 0);
7952 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
7953 || TREE_CODE (fns
) == TEMPLATE_DECL
7954 || TREE_CODE (fns
) == OVERLOAD
);
7955 fn
= get_first_fn (fns
);
7956 name
= DECL_NAME (fn
);
7958 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
7959 gcc_assert (CLASS_TYPE_P (basetype
));
7961 if (processing_template_decl
)
7963 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
7964 instance
= build_non_dependent_expr (instance
);
7966 make_args_non_dependent (*args
);
7969 user_args
= args
== NULL
? NULL
: *args
;
7970 /* Under DR 147 A::A() is an invalid constructor call,
7971 not a functional cast. */
7972 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
7974 if (! (complain
& tf_error
))
7975 return error_mark_node
;
7977 if (permerror (input_location
,
7978 "cannot call constructor %<%T::%D%> directly",
7980 inform (input_location
, "for a function-style cast, remove the "
7981 "redundant %<::%D%>", name
);
7982 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
7987 /* Figure out whether to skip the first argument for the error
7988 message we will display to users if an error occurs. We don't
7989 want to display any compiler-generated arguments. The "this"
7990 pointer hasn't been added yet. However, we must remove the VTT
7991 pointer if this is a call to a base-class constructor or
7993 skip_first_for_error
= false;
7994 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7996 /* Callers should explicitly indicate whether they want to construct
7997 the complete object or just the part without virtual bases. */
7998 gcc_assert (name
!= ctor_identifier
);
7999 /* Similarly for destructors. */
8000 gcc_assert (name
!= dtor_identifier
);
8001 /* Remove the VTT pointer, if present. */
8002 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
8003 && CLASSTYPE_VBASECLASSES (basetype
))
8004 skip_first_for_error
= true;
8007 /* Process the argument list. */
8008 if (args
!= NULL
&& *args
!= NULL
)
8010 *args
= resolve_args (*args
, complain
);
8012 return error_mark_node
;
8015 /* Consider the object argument to be used even if we end up selecting a
8016 static member function. */
8017 instance
= mark_type_use (instance
);
8019 /* It's OK to call destructors and constructors on cv-qualified objects.
8020 Therefore, convert the INSTANCE to the unqualified type, if
8022 if (DECL_DESTRUCTOR_P (fn
)
8023 || DECL_CONSTRUCTOR_P (fn
))
8025 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
8027 instance
= build_this (instance
);
8028 instance
= build_nop (build_pointer_type (basetype
), instance
);
8029 instance
= build_fold_indirect_ref (instance
);
8032 if (DECL_DESTRUCTOR_P (fn
))
8033 name
= complete_dtor_identifier
;
8035 /* For the overload resolution we need to find the actual `this`
8036 that would be captured if the call turns out to be to a
8037 non-static member function. Do not actually capture it at this
8039 if (DECL_CONSTRUCTOR_P (fn
))
8040 /* Constructors don't use the enclosing 'this'. */
8041 first_mem_arg
= instance
;
8043 first_mem_arg
= maybe_resolve_dummy (instance
, false);
8045 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8046 p
= conversion_obstack_alloc (0);
8048 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
8049 initializer, not T({ }). */
8050 if (DECL_CONSTRUCTOR_P (fn
) && args
!= NULL
&& !vec_safe_is_empty (*args
)
8051 && DIRECT_LIST_INIT_P ((**args
)[0]))
8053 tree init_list
= (**args
)[0];
8054 tree init
= NULL_TREE
;
8056 gcc_assert ((*args
)->length () == 1
8057 && !(flags
& LOOKUP_ONLYCONVERTING
));
8059 /* If the initializer list has no elements and T is a class type with
8060 a default constructor, the object is value-initialized. Handle
8061 this here so we don't need to handle it wherever we use
8062 build_special_member_call. */
8063 if (CONSTRUCTOR_NELTS (init_list
) == 0
8064 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
8065 /* For a user-provided default constructor, use the normal
8066 mechanisms so that protected access works. */
8067 && type_has_non_user_provided_default_constructor (basetype
)
8068 && !processing_template_decl
)
8069 init
= build_value_init (basetype
, complain
);
8071 /* If BASETYPE is an aggregate, we need to do aggregate
8073 else if (CP_AGGREGATE_TYPE_P (basetype
))
8075 init
= reshape_init (basetype
, init_list
, complain
);
8076 init
= digest_init (basetype
, init
, complain
);
8081 if (is_dummy_object (instance
))
8082 return get_target_expr_sfinae (init
, complain
);
8083 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
8084 TREE_SIDE_EFFECTS (init
) = true;
8088 /* Otherwise go ahead with overload resolution. */
8089 add_list_candidates (fns
, first_mem_arg
, init_list
,
8090 basetype
, explicit_targs
, template_only
,
8091 conversion_path
, access_binfo
, flags
,
8092 &candidates
, complain
);
8096 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
8097 explicit_targs
, template_only
, conversion_path
,
8098 access_binfo
, flags
, &candidates
, complain
);
8100 any_viable_p
= false;
8101 candidates
= splice_viable (candidates
, false, &any_viable_p
);
8105 if (complain
& tf_error
)
8107 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
8108 cxx_incomplete_type_error (instance
, basetype
);
8110 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
8111 basetype
, optype
, build_tree_list_vec (user_args
),
8112 TREE_TYPE (instance
));
8119 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8120 arglist
= build_tree_list_vec (user_args
);
8121 if (skip_first_for_error
)
8122 arglist
= TREE_CHAIN (arglist
);
8123 error ("no matching function for call to %<%T::%s(%A)%#V%>",
8124 basetype
, pretty_name
, arglist
,
8125 TREE_TYPE (instance
));
8129 print_z_candidates (location_of (name
), candidates
);
8131 call
= error_mark_node
;
8135 cand
= tourney (candidates
, complain
);
8142 if (complain
& tf_error
)
8144 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8145 arglist
= build_tree_list_vec (user_args
);
8146 if (skip_first_for_error
)
8147 arglist
= TREE_CHAIN (arglist
);
8148 if (!any_strictly_viable (candidates
))
8149 error ("no matching function for call to %<%s(%A)%>",
8150 pretty_name
, arglist
);
8152 error ("call of overloaded %<%s(%A)%> is ambiguous",
8153 pretty_name
, arglist
);
8154 print_z_candidates (location_of (name
), candidates
);
8158 call
= error_mark_node
;
8165 if (!(flags
& LOOKUP_NONVIRTUAL
)
8166 && DECL_PURE_VIRTUAL_P (fn
)
8167 && instance
== current_class_ref
8168 && (complain
& tf_warning
))
8170 /* This is not an error, it is runtime undefined
8172 if (!current_function_decl
)
8173 warning (0, "pure virtual %q#D called from "
8174 "non-static data member initializer", fn
);
8175 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
8176 || DECL_DESTRUCTOR_P (current_function_decl
))
8177 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
8178 ? "pure virtual %q#D called from constructor"
8179 : "pure virtual %q#D called from destructor"),
8183 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
8184 && !DECL_CONSTRUCTOR_P (fn
)
8185 && is_dummy_object (instance
))
8187 instance
= maybe_resolve_dummy (instance
, true);
8188 if (instance
== error_mark_node
)
8189 call
= error_mark_node
;
8190 else if (!is_dummy_object (instance
))
8192 /* We captured 'this' in the current lambda now that
8193 we know we really need it. */
8194 cand
->first_arg
= instance
;
8198 if (complain
& tf_error
)
8199 error ("cannot call member function %qD without object",
8201 call
= error_mark_node
;
8205 if (call
!= error_mark_node
)
8207 /* Optimize away vtable lookup if we know that this
8208 function can't be overridden. We need to check if
8209 the context and the type where we found fn are the same,
8210 actually FN might be defined in a different class
8211 type because of a using-declaration. In this case, we
8212 do not want to perform a non-virtual call. */
8213 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
8214 && same_type_ignoring_top_level_qualifiers_p
8215 (DECL_CONTEXT (fn
), BINFO_TYPE (binfo
))
8216 && resolves_to_fixed_type_p (instance
, 0))
8217 flags
|= LOOKUP_NONVIRTUAL
;
8219 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
8220 /* Now we know what function is being called. */
8223 /* Build the actual CALL_EXPR. */
8224 call
= build_over_call (cand
, flags
, complain
);
8225 /* In an expression of the form `a->f()' where `f' turns
8226 out to be a static member function, `a' is
8227 none-the-less evaluated. */
8228 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
8229 && !is_dummy_object (instance
)
8230 && TREE_SIDE_EFFECTS (instance
))
8231 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
8233 else if (call
!= error_mark_node
8234 && DECL_DESTRUCTOR_P (cand
->fn
)
8235 && !VOID_TYPE_P (TREE_TYPE (call
)))
8236 /* An explicit call of the form "x->~X()" has type
8237 "void". However, on platforms where destructors
8238 return "this" (i.e., those where
8239 targetm.cxx.cdtor_returns_this is true), such calls
8240 will appear to have a return value of pointer type
8241 to the low-level call machinery. We do not want to
8242 change the low-level machinery, since we want to be
8243 able to optimize "delete f()" on such platforms as
8244 "operator delete(~X(f()))" (rather than generating
8245 "t = f(), ~X(t), operator delete (t)"). */
8246 call
= build_nop (void_type_node
, call
);
8251 if (processing_template_decl
&& call
!= error_mark_node
)
8253 bool cast_to_void
= false;
8255 if (TREE_CODE (call
) == COMPOUND_EXPR
)
8256 call
= TREE_OPERAND (call
, 1);
8257 else if (TREE_CODE (call
) == NOP_EXPR
)
8259 cast_to_void
= true;
8260 call
= TREE_OPERAND (call
, 0);
8262 if (INDIRECT_REF_P (call
))
8263 call
= TREE_OPERAND (call
, 0);
8264 call
= (build_min_non_dep_call_vec
8266 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
8267 orig_instance
, orig_fns
, NULL_TREE
),
8269 SET_EXPR_LOCATION (call
, input_location
);
8270 call
= convert_from_reference (call
);
8272 call
= build_nop (void_type_node
, call
);
8275 /* Free all the conversions we allocated. */
8276 obstack_free (&conversion_obstack
, p
);
8278 if (orig_args
!= NULL
)
8279 release_tree_vector (orig_args
);
8284 /* Wrapper for above. */
8287 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8288 tree conversion_path
, int flags
,
8289 tree
*fn_p
, tsubst_flags_t complain
)
8292 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
8293 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
8295 timevar_cond_stop (TV_OVERLOAD
, subtime
);
8299 /* Returns true iff standard conversion sequence ICS1 is a proper
8300 subsequence of ICS2. */
8303 is_subseq (conversion
*ics1
, conversion
*ics2
)
8305 /* We can assume that a conversion of the same code
8306 between the same types indicates a subsequence since we only get
8307 here if the types we are converting from are the same. */
8309 while (ics1
->kind
== ck_rvalue
8310 || ics1
->kind
== ck_lvalue
)
8311 ics1
= next_conversion (ics1
);
8315 while (ics2
->kind
== ck_rvalue
8316 || ics2
->kind
== ck_lvalue
)
8317 ics2
= next_conversion (ics2
);
8319 if (ics2
->kind
== ck_user
8320 || ics2
->kind
== ck_ambig
8321 || ics2
->kind
== ck_aggr
8322 || ics2
->kind
== ck_list
8323 || ics2
->kind
== ck_identity
)
8324 /* At this point, ICS1 cannot be a proper subsequence of
8325 ICS2. We can get a USER_CONV when we are comparing the
8326 second standard conversion sequence of two user conversion
8330 ics2
= next_conversion (ics2
);
8332 if (ics2
->kind
== ics1
->kind
8333 && same_type_p (ics2
->type
, ics1
->type
)
8334 && same_type_p (next_conversion (ics2
)->type
,
8335 next_conversion (ics1
)->type
))
8340 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
8341 be any _TYPE nodes. */
8344 is_properly_derived_from (tree derived
, tree base
)
8346 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
8349 /* We only allow proper derivation here. The DERIVED_FROM_P macro
8350 considers every class derived from itself. */
8351 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
8352 && DERIVED_FROM_P (base
, derived
));
8355 /* We build the ICS for an implicit object parameter as a pointer
8356 conversion sequence. However, such a sequence should be compared
8357 as if it were a reference conversion sequence. If ICS is the
8358 implicit conversion sequence for an implicit object parameter,
8359 modify it accordingly. */
8362 maybe_handle_implicit_object (conversion
**ics
)
8366 /* [over.match.funcs]
8368 For non-static member functions, the type of the
8369 implicit object parameter is "reference to cv X"
8370 where X is the class of which the function is a
8371 member and cv is the cv-qualification on the member
8372 function declaration. */
8373 conversion
*t
= *ics
;
8374 tree reference_type
;
8376 /* The `this' parameter is a pointer to a class type. Make the
8377 implicit conversion talk about a reference to that same class
8379 reference_type
= TREE_TYPE (t
->type
);
8380 reference_type
= build_reference_type (reference_type
);
8382 if (t
->kind
== ck_qual
)
8383 t
= next_conversion (t
);
8384 if (t
->kind
== ck_ptr
)
8385 t
= next_conversion (t
);
8386 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
8387 t
= direct_reference_binding (reference_type
, t
);
8389 t
->rvaluedness_matches_p
= 0;
8394 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
8395 and return the initial reference binding conversion. Otherwise,
8396 leave *ICS unchanged and return NULL. */
8399 maybe_handle_ref_bind (conversion
**ics
)
8401 if ((*ics
)->kind
== ck_ref_bind
)
8403 conversion
*old_ics
= *ics
;
8404 *ics
= next_conversion (old_ics
);
8405 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
8412 /* Compare two implicit conversion sequences according to the rules set out in
8413 [over.ics.rank]. Return values:
8415 1: ics1 is better than ics2
8416 -1: ics2 is better than ics1
8417 0: ics1 and ics2 are indistinguishable */
8420 compare_ics (conversion
*ics1
, conversion
*ics2
)
8426 tree deref_from_type1
= NULL_TREE
;
8427 tree deref_from_type2
= NULL_TREE
;
8428 tree deref_to_type1
= NULL_TREE
;
8429 tree deref_to_type2
= NULL_TREE
;
8430 conversion_rank rank1
, rank2
;
8432 /* REF_BINDING is nonzero if the result of the conversion sequence
8433 is a reference type. In that case REF_CONV is the reference
8434 binding conversion. */
8435 conversion
*ref_conv1
;
8436 conversion
*ref_conv2
;
8438 /* Compare badness before stripping the reference conversion. */
8439 if (ics1
->bad_p
> ics2
->bad_p
)
8441 else if (ics1
->bad_p
< ics2
->bad_p
)
8444 /* Handle implicit object parameters. */
8445 maybe_handle_implicit_object (&ics1
);
8446 maybe_handle_implicit_object (&ics2
);
8448 /* Handle reference parameters. */
8449 ref_conv1
= maybe_handle_ref_bind (&ics1
);
8450 ref_conv2
= maybe_handle_ref_bind (&ics2
);
8452 /* List-initialization sequence L1 is a better conversion sequence than
8453 list-initialization sequence L2 if L1 converts to
8454 std::initializer_list<X> for some X and L2 does not. */
8455 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
8457 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
8462 When comparing the basic forms of implicit conversion sequences (as
8463 defined in _over.best.ics_)
8465 --a standard conversion sequence (_over.ics.scs_) is a better
8466 conversion sequence than a user-defined conversion sequence
8467 or an ellipsis conversion sequence, and
8469 --a user-defined conversion sequence (_over.ics.user_) is a
8470 better conversion sequence than an ellipsis conversion sequence
8471 (_over.ics.ellipsis_). */
8472 /* Use BAD_CONVERSION_RANK because we already checked for a badness
8473 mismatch. If both ICS are bad, we try to make a decision based on
8474 what would have happened if they'd been good. This is not an
8475 extension, we'll still give an error when we build up the call; this
8476 just helps us give a more helpful error message. */
8477 rank1
= BAD_CONVERSION_RANK (ics1
);
8478 rank2
= BAD_CONVERSION_RANK (ics2
);
8482 else if (rank1
< rank2
)
8485 if (ics1
->ellipsis_p
)
8486 /* Both conversions are ellipsis conversions. */
8489 /* User-defined conversion sequence U1 is a better conversion sequence
8490 than another user-defined conversion sequence U2 if they contain the
8491 same user-defined conversion operator or constructor and if the sec-
8492 ond standard conversion sequence of U1 is better than the second
8493 standard conversion sequence of U2. */
8495 /* Handle list-conversion with the same code even though it isn't always
8496 ranked as a user-defined conversion and it doesn't have a second
8497 standard conversion sequence; it will still have the desired effect.
8498 Specifically, we need to do the reference binding comparison at the
8499 end of this function. */
8501 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
8506 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
8507 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
8508 || t1
->kind
== ck_list
)
8510 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
8511 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
8512 || t2
->kind
== ck_list
)
8515 if (t1
->kind
!= t2
->kind
)
8517 else if (t1
->kind
== ck_user
)
8519 if (t1
->cand
->fn
!= t2
->cand
->fn
)
8524 /* For ambiguous or aggregate conversions, use the target type as
8525 a proxy for the conversion function. */
8526 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
8530 /* We can just fall through here, after setting up
8531 FROM_TYPE1 and FROM_TYPE2. */
8532 from_type1
= t1
->type
;
8533 from_type2
= t2
->type
;
8540 /* We're dealing with two standard conversion sequences.
8544 Standard conversion sequence S1 is a better conversion
8545 sequence than standard conversion sequence S2 if
8547 --S1 is a proper subsequence of S2 (comparing the conversion
8548 sequences in the canonical form defined by _over.ics.scs_,
8549 excluding any Lvalue Transformation; the identity
8550 conversion sequence is considered to be a subsequence of
8551 any non-identity conversion sequence */
8554 while (t1
->kind
!= ck_identity
)
8555 t1
= next_conversion (t1
);
8556 from_type1
= t1
->type
;
8559 while (t2
->kind
!= ck_identity
)
8560 t2
= next_conversion (t2
);
8561 from_type2
= t2
->type
;
8564 /* One sequence can only be a subsequence of the other if they start with
8565 the same type. They can start with different types when comparing the
8566 second standard conversion sequence in two user-defined conversion
8568 if (same_type_p (from_type1
, from_type2
))
8570 if (is_subseq (ics1
, ics2
))
8572 if (is_subseq (ics2
, ics1
))
8580 --the rank of S1 is better than the rank of S2 (by the rules
8583 Standard conversion sequences are ordered by their ranks: an Exact
8584 Match is a better conversion than a Promotion, which is a better
8585 conversion than a Conversion.
8587 Two conversion sequences with the same rank are indistinguishable
8588 unless one of the following rules applies:
8590 --A conversion that does not a convert a pointer, pointer to member,
8591 or std::nullptr_t to bool is better than one that does.
8593 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8594 so that we do not have to check it explicitly. */
8595 if (ics1
->rank
< ics2
->rank
)
8597 else if (ics2
->rank
< ics1
->rank
)
8600 to_type1
= ics1
->type
;
8601 to_type2
= ics2
->type
;
8603 /* A conversion from scalar arithmetic type to complex is worse than a
8604 conversion between scalar arithmetic types. */
8605 if (same_type_p (from_type1
, from_type2
)
8606 && ARITHMETIC_TYPE_P (from_type1
)
8607 && ARITHMETIC_TYPE_P (to_type1
)
8608 && ARITHMETIC_TYPE_P (to_type2
)
8609 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8610 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
8612 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8618 if (TYPE_PTR_P (from_type1
)
8619 && TYPE_PTR_P (from_type2
)
8620 && TYPE_PTR_P (to_type1
)
8621 && TYPE_PTR_P (to_type2
))
8623 deref_from_type1
= TREE_TYPE (from_type1
);
8624 deref_from_type2
= TREE_TYPE (from_type2
);
8625 deref_to_type1
= TREE_TYPE (to_type1
);
8626 deref_to_type2
= TREE_TYPE (to_type2
);
8628 /* The rules for pointers to members A::* are just like the rules
8629 for pointers A*, except opposite: if B is derived from A then
8630 A::* converts to B::*, not vice versa. For that reason, we
8631 switch the from_ and to_ variables here. */
8632 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
8633 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
8634 || (TYPE_PTRMEMFUNC_P (from_type1
)
8635 && TYPE_PTRMEMFUNC_P (from_type2
)
8636 && TYPE_PTRMEMFUNC_P (to_type1
)
8637 && TYPE_PTRMEMFUNC_P (to_type2
)))
8639 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
8640 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
8641 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
8642 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
8645 if (deref_from_type1
!= NULL_TREE
8646 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
8647 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
8649 /* This was one of the pointer or pointer-like conversions.
8653 --If class B is derived directly or indirectly from class A,
8654 conversion of B* to A* is better than conversion of B* to
8655 void*, and conversion of A* to void* is better than
8656 conversion of B* to void*. */
8657 if (VOID_TYPE_P (deref_to_type1
)
8658 && VOID_TYPE_P (deref_to_type2
))
8660 if (is_properly_derived_from (deref_from_type1
,
8663 else if (is_properly_derived_from (deref_from_type2
,
8667 else if (VOID_TYPE_P (deref_to_type1
)
8668 || VOID_TYPE_P (deref_to_type2
))
8670 if (same_type_p (deref_from_type1
, deref_from_type2
))
8672 if (VOID_TYPE_P (deref_to_type2
))
8674 if (is_properly_derived_from (deref_from_type1
,
8678 /* We know that DEREF_TO_TYPE1 is `void' here. */
8679 else if (is_properly_derived_from (deref_from_type1
,
8684 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
8685 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
8689 --If class B is derived directly or indirectly from class A
8690 and class C is derived directly or indirectly from B,
8692 --conversion of C* to B* is better than conversion of C* to
8695 --conversion of B* to A* is better than conversion of C* to
8697 if (same_type_p (deref_from_type1
, deref_from_type2
))
8699 if (is_properly_derived_from (deref_to_type1
,
8702 else if (is_properly_derived_from (deref_to_type2
,
8706 else if (same_type_p (deref_to_type1
, deref_to_type2
))
8708 if (is_properly_derived_from (deref_from_type2
,
8711 else if (is_properly_derived_from (deref_from_type1
,
8717 else if (CLASS_TYPE_P (non_reference (from_type1
))
8718 && same_type_p (from_type1
, from_type2
))
8720 tree from
= non_reference (from_type1
);
8724 --binding of an expression of type C to a reference of type
8725 B& is better than binding an expression of type C to a
8726 reference of type A&
8728 --conversion of C to B is better than conversion of C to A, */
8729 if (is_properly_derived_from (from
, to_type1
)
8730 && is_properly_derived_from (from
, to_type2
))
8732 if (is_properly_derived_from (to_type1
, to_type2
))
8734 else if (is_properly_derived_from (to_type2
, to_type1
))
8738 else if (CLASS_TYPE_P (non_reference (to_type1
))
8739 && same_type_p (to_type1
, to_type2
))
8741 tree to
= non_reference (to_type1
);
8745 --binding of an expression of type B to a reference of type
8746 A& is better than binding an expression of type C to a
8747 reference of type A&,
8749 --conversion of B to A is better than conversion of C to A */
8750 if (is_properly_derived_from (from_type1
, to
)
8751 && is_properly_derived_from (from_type2
, to
))
8753 if (is_properly_derived_from (from_type2
, from_type1
))
8755 else if (is_properly_derived_from (from_type1
, from_type2
))
8762 --S1 and S2 differ only in their qualification conversion and yield
8763 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8764 qualification signature of type T1 is a proper subset of the cv-
8765 qualification signature of type T2 */
8766 if (ics1
->kind
== ck_qual
8767 && ics2
->kind
== ck_qual
8768 && same_type_p (from_type1
, from_type2
))
8770 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
8777 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8778 to an implicit object parameter of a non-static member function
8779 declared without a ref-qualifier, and either S1 binds an lvalue
8780 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
8781 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
8782 draft standard, 13.3.3.2)
8784 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8785 types to which the references refer are the same type except for
8786 top-level cv-qualifiers, and the type to which the reference
8787 initialized by S2 refers is more cv-qualified than the type to
8788 which the reference initialized by S1 refers.
8790 DR 1328 [over.match.best]: the context is an initialization by
8791 conversion function for direct reference binding (13.3.1.6) of a
8792 reference to function type, the return type of F1 is the same kind of
8793 reference (i.e. lvalue or rvalue) as the reference being initialized,
8794 and the return type of F2 is not. */
8796 if (ref_conv1
&& ref_conv2
)
8798 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
8799 && (ref_conv1
->rvaluedness_matches_p
8800 != ref_conv2
->rvaluedness_matches_p
)
8801 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
8802 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
8803 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
8805 if (ref_conv1
->bad_p
8806 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
8807 TREE_TYPE (ref_conv2
->type
)))
8808 /* Don't prefer a bad conversion that drops cv-quals to a bad
8809 conversion with the wrong rvalueness. */
8811 return (ref_conv1
->rvaluedness_matches_p
8812 - ref_conv2
->rvaluedness_matches_p
);
8815 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
8817 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
8818 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
8819 if (ref_conv1
->bad_p
)
8821 /* Prefer the one that drops fewer cv-quals. */
8822 tree ftype
= next_conversion (ref_conv1
)->type
;
8823 int fquals
= cp_type_quals (ftype
);
8827 return comp_cv_qualification (q2
, q1
);
8831 /* Neither conversion sequence is better than the other. */
8835 /* The source type for this standard conversion sequence. */
8838 source_type (conversion
*t
)
8840 for (;; t
= next_conversion (t
))
8842 if (t
->kind
== ck_user
8843 || t
->kind
== ck_ambig
8844 || t
->kind
== ck_identity
)
8850 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8851 a pointer to LOSER and re-running joust to produce the warning if WINNER
8852 is actually used. */
8855 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
8857 candidate_warning
*cw
= (candidate_warning
*)
8858 conversion_obstack_alloc (sizeof (candidate_warning
));
8860 cw
->next
= winner
->warnings
;
8861 winner
->warnings
= cw
;
8864 /* Compare two candidates for overloading as described in
8865 [over.match.best]. Return values:
8867 1: cand1 is better than cand2
8868 -1: cand2 is better than cand1
8869 0: cand1 and cand2 are indistinguishable */
8872 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
8873 tsubst_flags_t complain
)
8876 int off1
= 0, off2
= 0;
8880 /* Candidates that involve bad conversions are always worse than those
8882 if (cand1
->viable
> cand2
->viable
)
8884 if (cand1
->viable
< cand2
->viable
)
8887 /* If we have two pseudo-candidates for conversions to the same type,
8888 or two candidates for the same function, arbitrarily pick one. */
8889 if (cand1
->fn
== cand2
->fn
8890 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
8893 /* Prefer a non-deleted function over an implicitly deleted move
8894 constructor or assignment operator. This differs slightly from the
8895 wording for issue 1402 (which says the move op is ignored by overload
8896 resolution), but this way produces better error messages. */
8897 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
8898 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
8899 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
8901 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
8902 && move_fn_p (cand1
->fn
))
8904 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
8905 && move_fn_p (cand2
->fn
))
8909 /* a viable function F1
8910 is defined to be a better function than another viable function F2 if
8911 for all arguments i, ICSi(F1) is not a worse conversion sequence than
8912 ICSi(F2), and then */
8914 /* for some argument j, ICSj(F1) is a better conversion sequence than
8917 /* For comparing static and non-static member functions, we ignore
8918 the implicit object parameter of the non-static function. The
8919 standard says to pretend that the static function has an object
8920 parm, but that won't work with operator overloading. */
8921 len
= cand1
->num_convs
;
8922 if (len
!= cand2
->num_convs
)
8924 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
8925 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
8927 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
8928 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
8929 /* We're comparing a near-match list constructor and a near-match
8930 non-list constructor. Just treat them as unordered. */
8933 gcc_assert (static_1
!= static_2
);
8944 for (i
= 0; i
< len
; ++i
)
8946 conversion
*t1
= cand1
->convs
[i
+ off1
];
8947 conversion
*t2
= cand2
->convs
[i
+ off2
];
8948 int comp
= compare_ics (t1
, t2
);
8952 if ((complain
& tf_warning
)
8954 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
8955 == cr_std
+ cr_promotion
)
8956 && t1
->kind
== ck_std
8957 && t2
->kind
== ck_std
8958 && TREE_CODE (t1
->type
) == INTEGER_TYPE
8959 && TREE_CODE (t2
->type
) == INTEGER_TYPE
8960 && (TYPE_PRECISION (t1
->type
)
8961 == TYPE_PRECISION (t2
->type
))
8962 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
8963 || (TREE_CODE (next_conversion (t1
)->type
)
8966 tree type
= next_conversion (t1
)->type
;
8968 struct z_candidate
*w
, *l
;
8970 type1
= t1
->type
, type2
= t2
->type
,
8971 w
= cand1
, l
= cand2
;
8973 type1
= t2
->type
, type2
= t1
->type
,
8974 w
= cand2
, l
= cand1
;
8978 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
8979 type
, type1
, type2
);
8980 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
8986 if (winner
&& comp
!= winner
)
8995 /* warn about confusing overload resolution for user-defined conversions,
8996 either between a constructor and a conversion op, or between two
8998 if ((complain
& tf_warning
)
8999 && winner
&& warn_conversion
&& cand1
->second_conv
9000 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
9001 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
9003 struct z_candidate
*w
, *l
;
9004 bool give_warning
= false;
9007 w
= cand1
, l
= cand2
;
9009 w
= cand2
, l
= cand1
;
9011 /* We don't want to complain about `X::operator T1 ()'
9012 beating `X::operator T2 () const', when T2 is a no less
9013 cv-qualified version of T1. */
9014 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
9015 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
9017 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
9018 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
9020 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
9025 if (!comp_ptr_ttypes (t
, f
))
9026 give_warning
= true;
9029 give_warning
= true;
9035 tree source
= source_type (w
->convs
[0]);
9036 if (! DECL_CONSTRUCTOR_P (w
->fn
))
9037 source
= TREE_TYPE (source
);
9038 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
9039 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
9040 source
, w
->second_conv
->type
))
9042 inform (input_location
, " because conversion sequence for the argument is better");
9052 /* DR 495 moved this tiebreaker above the template ones. */
9054 the context is an initialization by user-defined conversion (see
9055 _dcl.init_ and _over.match.user_) and the standard conversion
9056 sequence from the return type of F1 to the destination type (i.e.,
9057 the type of the entity being initialized) is a better conversion
9058 sequence than the standard conversion sequence from the return type
9059 of F2 to the destination type. */
9061 if (cand1
->second_conv
)
9063 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
9069 F1 is a non-template function and F2 is a template function
9072 if (!cand1
->template_decl
&& cand2
->template_decl
)
9074 else if (cand1
->template_decl
&& !cand2
->template_decl
)
9078 F1 and F2 are template functions and the function template for F1 is
9079 more specialized than the template for F2 according to the partial
9082 if (cand1
->template_decl
&& cand2
->template_decl
)
9084 winner
= more_specialized_fn
9085 (TI_TEMPLATE (cand1
->template_decl
),
9086 TI_TEMPLATE (cand2
->template_decl
),
9087 /* [temp.func.order]: The presence of unused ellipsis and default
9088 arguments has no effect on the partial ordering of function
9089 templates. add_function_candidate() will not have
9090 counted the "this" argument for constructors. */
9091 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
9096 /* Check whether we can discard a builtin candidate, either because we
9097 have two identical ones or matching builtin and non-builtin candidates.
9099 (Pedantically in the latter case the builtin which matched the user
9100 function should not be added to the overload set, but we spot it here.
9103 ... the builtin candidates include ...
9104 - do not have the same parameter type list as any non-template
9105 non-member candidate. */
9107 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
9109 for (i
= 0; i
< len
; ++i
)
9110 if (!same_type_p (cand1
->convs
[i
]->type
,
9111 cand2
->convs
[i
]->type
))
9113 if (i
== cand1
->num_convs
)
9115 if (cand1
->fn
== cand2
->fn
)
9116 /* Two built-in candidates; arbitrarily pick one. */
9118 else if (identifier_p (cand1
->fn
))
9119 /* cand1 is built-in; prefer cand2. */
9122 /* cand2 is built-in; prefer cand1. */
9127 /* For candidates of a multi-versioned function, make the version with
9128 the highest priority win. This version will be checked for dispatching
9129 first. If this version can be inlined into the caller, the front-end
9130 will simply make a direct call to this function. */
9132 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9133 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
9134 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9135 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
9137 tree f1
= TREE_TYPE (cand1
->fn
);
9138 tree f2
= TREE_TYPE (cand2
->fn
);
9139 tree p1
= TYPE_ARG_TYPES (f1
);
9140 tree p2
= TYPE_ARG_TYPES (f2
);
9142 /* Check if cand1->fn and cand2->fn are versions of the same function. It
9143 is possible that cand1->fn and cand2->fn are function versions but of
9144 different functions. Check types to see if they are versions of the same
9146 if (compparms (p1
, p2
)
9147 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
9149 /* Always make the version with the higher priority, more
9150 specialized, win. */
9151 gcc_assert (targetm
.compare_version_priority
);
9152 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
9159 /* If the two function declarations represent the same function (this can
9160 happen with declarations in multiple scopes and arg-dependent lookup),
9161 arbitrarily choose one. But first make sure the default args we're
9163 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
9164 && equal_functions (cand1
->fn
, cand2
->fn
))
9166 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
9167 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
9169 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
9171 for (i
= 0; i
< len
; ++i
)
9173 /* Don't crash if the fn is variadic. */
9176 parms1
= TREE_CHAIN (parms1
);
9177 parms2
= TREE_CHAIN (parms2
);
9181 parms1
= TREE_CHAIN (parms1
);
9183 parms2
= TREE_CHAIN (parms2
);
9187 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
9188 TREE_PURPOSE (parms2
)))
9192 if (complain
& tf_error
)
9194 if (permerror (input_location
,
9195 "default argument mismatch in "
9196 "overload resolution"))
9198 inform (input_location
,
9199 " candidate 1: %q+#F", cand1
->fn
);
9200 inform (input_location
,
9201 " candidate 2: %q+#F", cand2
->fn
);
9208 add_warning (cand1
, cand2
);
9211 parms1
= TREE_CHAIN (parms1
);
9212 parms2
= TREE_CHAIN (parms2
);
9220 /* Extension: If the worst conversion for one candidate is worse than the
9221 worst conversion for the other, take the first. */
9222 if (!pedantic
&& (complain
& tf_warning_or_error
))
9224 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
9225 struct z_candidate
*w
= 0, *l
= 0;
9227 for (i
= 0; i
< len
; ++i
)
9229 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
9230 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
9231 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
9232 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
9235 winner
= 1, w
= cand1
, l
= cand2
;
9237 winner
= -1, w
= cand2
, l
= cand1
;
9240 /* Don't choose a deleted function over ambiguity. */
9241 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
9245 pedwarn (input_location
, 0,
9246 "ISO C++ says that these are ambiguous, even "
9247 "though the worst conversion for the first is better than "
9248 "the worst conversion for the second:");
9249 print_z_candidate (input_location
, _("candidate 1:"), w
);
9250 print_z_candidate (input_location
, _("candidate 2:"), l
);
9258 gcc_assert (!winner
);
9262 /* Given a list of candidates for overloading, find the best one, if any.
9263 This algorithm has a worst case of O(2n) (winner is last), and a best
9264 case of O(n/2) (totally ambiguous); much better than a sorting
9267 static struct z_candidate
*
9268 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
9270 struct z_candidate
*champ
= candidates
, *challenger
;
9272 int champ_compared_to_predecessor
= 0;
9274 /* Walk through the list once, comparing each current champ to the next
9275 candidate, knocking out a candidate or two with each comparison. */
9277 for (challenger
= champ
->next
; challenger
; )
9279 fate
= joust (champ
, challenger
, 0, complain
);
9281 challenger
= challenger
->next
;
9286 champ
= challenger
->next
;
9289 champ_compared_to_predecessor
= 0;
9294 champ_compared_to_predecessor
= 1;
9297 challenger
= champ
->next
;
9301 /* Make sure the champ is better than all the candidates it hasn't yet
9302 been compared to. */
9304 for (challenger
= candidates
;
9306 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
9307 challenger
= challenger
->next
)
9309 fate
= joust (champ
, challenger
, 0, complain
);
9317 /* Returns nonzero if things of type FROM can be converted to TO. */
9320 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
9322 tree arg
= NULL_TREE
;
9323 /* implicit_conversion only considers user-defined conversions
9324 if it has an expression for the call argument list. */
9325 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
9326 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
9327 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
9330 /* Returns nonzero if things of type FROM can be converted to TO with a
9331 standard conversion. */
9334 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
9336 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
9339 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
9342 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
9343 tsubst_flags_t complain
)
9349 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9350 p
= conversion_obstack_alloc (0);
9351 /* We want to discard any access checks done for this test,
9352 as we might not be in the appropriate access context and
9353 we'll do the check again when we actually perform the
9355 push_deferring_access_checks (dk_deferred
);
9357 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9359 ok_p
= (t
&& !t
->bad_p
);
9361 /* Discard the access checks now. */
9362 pop_deferring_access_checks ();
9363 /* Free all the conversions we allocated. */
9364 obstack_free (&conversion_obstack
, p
);
9369 /* Like can_convert_arg, but allows dubious conversions as well. */
9372 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
9373 tsubst_flags_t complain
)
9378 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9379 p
= conversion_obstack_alloc (0);
9380 /* Try to perform the conversion. */
9381 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9383 /* Free all the conversions we allocated. */
9384 obstack_free (&conversion_obstack
, p
);
9389 /* Convert EXPR to TYPE. Return the converted expression.
9391 Note that we allow bad conversions here because by the time we get to
9392 this point we are committed to doing the conversion. If we end up
9393 doing a bad conversion, convert_like will complain. */
9396 perform_implicit_conversion_flags (tree type
, tree expr
,
9397 tsubst_flags_t complain
, int flags
)
9401 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9403 if (error_operand_p (expr
))
9404 return error_mark_node
;
9406 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9407 p
= conversion_obstack_alloc (0);
9409 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9415 if (complain
& tf_error
)
9417 /* If expr has unknown type, then it is an overloaded function.
9418 Call instantiate_type to get good error messages. */
9419 if (TREE_TYPE (expr
) == unknown_type_node
)
9420 instantiate_type (type
, expr
, complain
);
9421 else if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
9422 /* We gave an error. */;
9424 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
9425 TREE_TYPE (expr
), type
);
9427 expr
= error_mark_node
;
9429 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
9431 /* In a template, we are only concerned about determining the
9432 type of non-dependent expressions, so we do not have to
9433 perform the actual conversion. But for initializers, we
9434 need to be able to perform it at instantiation
9435 (or instantiate_non_dependent_expr) time. */
9436 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
9437 if (!(flags
& LOOKUP_ONLYCONVERTING
))
9438 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
9441 expr
= convert_like (conv
, expr
, complain
);
9443 /* Free all the conversions we allocated. */
9444 obstack_free (&conversion_obstack
, p
);
9450 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
9452 return perform_implicit_conversion_flags (type
, expr
, complain
,
9456 /* Convert EXPR to TYPE (as a direct-initialization) if that is
9457 permitted. If the conversion is valid, the converted expression is
9458 returned. Otherwise, NULL_TREE is returned, except in the case
9459 that TYPE is a class type; in that case, an error is issued. If
9460 C_CAST_P is true, then this direct-initialization is taking
9461 place as part of a static_cast being attempted as part of a C-style
9465 perform_direct_initialization_if_possible (tree type
,
9468 tsubst_flags_t complain
)
9473 if (type
== error_mark_node
|| error_operand_p (expr
))
9474 return error_mark_node
;
9477 If the destination type is a (possibly cv-qualified) class type:
9479 -- If the initialization is direct-initialization ...,
9480 constructors are considered. ... If no constructor applies, or
9481 the overload resolution is ambiguous, the initialization is
9483 if (CLASS_TYPE_P (type
))
9485 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
9486 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
9487 &args
, type
, LOOKUP_NORMAL
, complain
);
9488 release_tree_vector (args
);
9489 return build_cplus_new (type
, expr
, complain
);
9492 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9493 p
= conversion_obstack_alloc (0);
9495 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9497 LOOKUP_NORMAL
, complain
);
9498 if (!conv
|| conv
->bad_p
)
9501 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
9502 /*issue_conversion_warnings=*/false,
9506 /* Free all the conversions we allocated. */
9507 obstack_free (&conversion_obstack
, p
);
9512 /* When initializing a reference that lasts longer than a full-expression,
9513 this special rule applies:
9517 The temporary to which the reference is bound or the temporary
9518 that is the complete object to which the reference is bound
9519 persists for the lifetime of the reference.
9521 The temporaries created during the evaluation of the expression
9522 initializing the reference, except the temporary to which the
9523 reference is bound, are destroyed at the end of the
9524 full-expression in which they are created.
9526 In that case, we store the converted expression into a new
9527 VAR_DECL in a new scope.
9529 However, we want to be careful not to create temporaries when
9530 they are not required. For example, given:
9533 struct D : public B {};
9537 there is no need to copy the return value from "f"; we can just
9538 extend its lifetime. Similarly, given:
9541 struct T { operator S(); };
9545 we can extend the lifetime of the return value of the conversion
9548 The next several functions are involved in this lifetime extension. */
9550 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9551 reference is being bound to a temporary. Create and return a new
9552 VAR_DECL with the indicated TYPE; this variable will store the value to
9553 which the reference is bound. */
9556 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
9560 /* Create the variable. */
9561 var
= create_temporary_var (type
);
9563 /* Register the variable. */
9565 && (TREE_STATIC (decl
) || CP_DECL_THREAD_LOCAL_P (decl
)))
9567 /* Namespace-scope or local static; give it a mangled name. */
9568 /* FIXME share comdat with decl? */
9571 TREE_STATIC (var
) = TREE_STATIC (decl
);
9572 CP_DECL_THREAD_LOCAL_P (var
) = CP_DECL_THREAD_LOCAL_P (decl
);
9573 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
9574 name
= mangle_ref_init_variable (decl
);
9575 DECL_NAME (var
) = name
;
9576 SET_DECL_ASSEMBLER_NAME (var
, name
);
9577 var
= pushdecl_top_level (var
);
9580 /* Create a new cleanup level if necessary. */
9581 maybe_push_cleanup_level (type
);
9586 /* EXPR is the initializer for a variable DECL of reference or
9587 std::initializer_list type. Create, push and return a new VAR_DECL
9588 for the initializer so that it will live as long as DECL. Any
9589 cleanup for the new variable is returned through CLEANUP, and the
9590 code to initialize the new variable is returned through INITP. */
9593 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
9600 /* Create the temporary variable. */
9601 type
= TREE_TYPE (expr
);
9602 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
9603 layout_decl (var
, 0);
9604 /* If the rvalue is the result of a function call it will be
9605 a TARGET_EXPR. If it is some other construct (such as a
9606 member access expression where the underlying object is
9607 itself the result of a function call), turn it into a
9608 TARGET_EXPR here. It is important that EXPR be a
9609 TARGET_EXPR below since otherwise the INIT_EXPR will
9610 attempt to make a bitwise copy of EXPR to initialize
9612 if (TREE_CODE (expr
) != TARGET_EXPR
)
9613 expr
= get_target_expr (expr
);
9615 if (TREE_CODE (decl
) == FIELD_DECL
9616 && extra_warnings
&& !TREE_NO_WARNING (decl
))
9618 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
9619 "until the constructor exits", decl
);
9620 TREE_NO_WARNING (decl
) = true;
9623 /* Recursively extend temps in this initializer. */
9624 TARGET_EXPR_INITIAL (expr
)
9625 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
9627 /* Any reference temp has a non-trivial initializer. */
9628 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
9630 /* If the initializer is constant, put it in DECL_INITIAL so we get
9631 static initialization and use in constant expressions. */
9632 init
= maybe_constant_init (expr
);
9633 if (TREE_CONSTANT (init
))
9635 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
9637 /* 5.19 says that a constant expression can include an
9638 lvalue-rvalue conversion applied to "a glvalue of literal type
9639 that refers to a non-volatile temporary object initialized
9640 with a constant expression". Rather than try to communicate
9641 that this VAR_DECL is a temporary, just mark it constexpr.
9643 Currently this is only useful for initializer_list temporaries,
9644 since reference vars can't appear in constant expressions. */
9645 DECL_DECLARED_CONSTEXPR_P (var
) = true;
9646 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
9647 TREE_CONSTANT (var
) = true;
9649 DECL_INITIAL (var
) = init
;
9653 /* Create the INIT_EXPR that will initialize the temporary
9655 init
= split_nonconstant_init (var
, expr
);
9656 if (at_function_scope_p ())
9658 add_decl_expr (var
);
9660 if (TREE_STATIC (var
))
9661 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
9664 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9666 vec_safe_push (*cleanups
, cleanup
);
9669 /* We must be careful to destroy the temporary only
9670 after its initialization has taken place. If the
9671 initialization throws an exception, then the
9672 destructor should not be run. We cannot simply
9673 transform INIT into something like:
9675 (INIT, ({ CLEANUP_STMT; }))
9677 because emit_local_var always treats the
9678 initializer as a full-expression. Thus, the
9679 destructor would run too early; it would run at the
9680 end of initializing the reference variable, rather
9681 than at the end of the block enclosing the
9684 The solution is to pass back a cleanup expression
9685 which the caller is responsible for attaching to
9686 the statement tree. */
9690 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
9691 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9693 if (CP_DECL_THREAD_LOCAL_P (var
))
9694 tls_aggregates
= tree_cons (NULL_TREE
, var
,
9697 static_aggregates
= tree_cons (NULL_TREE
, var
,
9701 /* Check whether the dtor is callable. */
9702 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9704 /* Avoid -Wunused-variable warning (c++/38958). */
9705 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
9707 TREE_USED (decl
) = DECL_READ_P (decl
) = true;
9713 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9714 initializing a variable of that TYPE. */
9717 initialize_reference (tree type
, tree expr
,
9718 int flags
, tsubst_flags_t complain
)
9722 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9724 if (type
== error_mark_node
|| error_operand_p (expr
))
9725 return error_mark_node
;
9727 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9728 p
= conversion_obstack_alloc (0);
9730 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
9732 if (!conv
|| conv
->bad_p
)
9734 if (complain
& tf_error
)
9737 convert_like (conv
, expr
, complain
);
9738 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
9739 && !TYPE_REF_IS_RVALUE (type
)
9740 && !real_lvalue_p (expr
))
9741 error_at (loc
, "invalid initialization of non-const reference of "
9742 "type %qT from an rvalue of type %qT",
9743 type
, TREE_TYPE (expr
));
9745 error_at (loc
, "invalid initialization of reference of type "
9746 "%qT from expression of type %qT", type
,
9749 return error_mark_node
;
9752 if (conv
->kind
== ck_ref_bind
)
9753 /* Perform the conversion. */
9754 expr
= convert_like (conv
, expr
, complain
);
9755 else if (conv
->kind
== ck_ambig
)
9756 /* We gave an error in build_user_type_conversion_1. */
9757 expr
= error_mark_node
;
9761 /* Free all the conversions we allocated. */
9762 obstack_free (&conversion_obstack
, p
);
9767 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9768 which is bound either to a reference or a std::initializer_list. */
9771 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9776 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
9778 TREE_OPERAND (sub
, 1)
9779 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
9782 if (TREE_CODE (sub
) != ADDR_EXPR
)
9784 /* Deal with binding to a subobject. */
9785 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
9786 p
= &TREE_OPERAND (*p
, 0);
9787 if (TREE_CODE (*p
) == TARGET_EXPR
)
9789 tree subinit
= NULL_TREE
;
9790 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
9791 recompute_tree_invariant_for_addr_expr (sub
);
9793 init
= fold_convert (TREE_TYPE (init
), sub
);
9795 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
9800 /* INIT is part of the initializer for DECL. If there are any
9801 reference or initializer lists being initialized, extend their
9802 lifetime to match that of DECL. */
9805 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9807 tree type
= TREE_TYPE (init
);
9808 if (processing_template_decl
)
9810 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9811 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
9812 else if (is_std_init_list (type
))
9814 /* The temporary array underlying a std::initializer_list
9815 is handled like a reference temporary. */
9817 if (TREE_CODE (ctor
) == TARGET_EXPR
)
9818 ctor
= TARGET_EXPR_INITIAL (ctor
);
9819 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
9821 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
9822 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
9823 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
9826 else if (TREE_CODE (init
) == CONSTRUCTOR
)
9830 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
9831 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
9832 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
9838 /* Returns true iff an initializer for TYPE could contain temporaries that
9839 need to be extended because they are bound to references or
9840 std::initializer_list. */
9843 type_has_extended_temps (tree type
)
9845 type
= strip_array_types (type
);
9846 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9848 if (CLASS_TYPE_P (type
))
9850 if (is_std_init_list (type
))
9852 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
9853 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
9854 if (type_has_extended_temps (TREE_TYPE (f
)))
9860 /* Returns true iff TYPE is some variant of std::initializer_list. */
9863 is_std_init_list (tree type
)
9865 /* Look through typedefs. */
9868 if (cxx_dialect
== cxx98
)
9870 type
= TYPE_MAIN_VARIANT (type
);
9871 return (CLASS_TYPE_P (type
)
9872 && CP_TYPE_CONTEXT (type
) == std_node
9873 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
9876 /* Returns true iff DECL is a list constructor: i.e. a constructor which
9877 will accept an argument list of a single std::initializer_list<T>. */
9880 is_list_ctor (tree decl
)
9882 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
9885 if (!args
|| args
== void_list_node
)
9888 arg
= non_reference (TREE_VALUE (args
));
9889 if (!is_std_init_list (arg
))
9892 args
= TREE_CHAIN (args
);
9894 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9895 /* There are more non-defaulted parms. */
9901 #include "gt-cp-call.h"