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 do 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 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
);
5658 case TRUNC_DIV_EXPR
:
5663 case TRUNC_MOD_EXPR
:
5667 return cp_build_binary_op (loc
, code
, arg1
, arg2
, complain
);
5669 case UNARY_PLUS_EXPR
:
5672 case TRUTH_NOT_EXPR
:
5673 case PREINCREMENT_EXPR
:
5674 case POSTINCREMENT_EXPR
:
5675 case PREDECREMENT_EXPR
:
5676 case POSTDECREMENT_EXPR
:
5680 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5683 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5686 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
5690 /* The caller will deal with these. */
5702 /* Wrapper for above. */
5705 build_new_op (location_t loc
, enum tree_code code
, int flags
,
5706 tree arg1
, tree arg2
, tree arg3
,
5707 tree
*overload
, tsubst_flags_t complain
)
5710 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5711 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
5712 overload
, complain
);
5713 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5717 /* Returns true if FN has two parameters, of which the second has type
5721 second_parm_is_size_t (tree fn
)
5723 tree t
= FUNCTION_ARG_CHAIN (fn
);
5725 && same_type_p (TREE_VALUE (t
), size_type_node
)
5726 && TREE_CHAIN (t
) == void_list_node
);
5729 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5730 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5733 non_placement_deallocation_fn_p (tree t
)
5735 /* A template instance is never a usual deallocation function,
5736 regardless of its signature. */
5737 if (TREE_CODE (t
) == TEMPLATE_DECL
5738 || primary_template_instantiation_p (t
))
5741 /* If a class T has a member deallocation function named operator delete
5742 with exactly one parameter, then that function is a usual
5743 (non-placement) deallocation function. If class T does not declare
5744 such an operator delete but does declare a member deallocation
5745 function named operator delete with exactly two parameters, the second
5746 of which has type std::size_t (18.2), then this function is a usual
5747 deallocation function. */
5748 bool global
= DECL_NAMESPACE_SCOPE_P (t
);
5749 if (FUNCTION_ARG_CHAIN (t
) == void_list_node
5750 || ((!global
|| flag_sized_deallocation
)
5751 && second_parm_is_size_t (t
)))
5756 /* Build a call to operator delete. This has to be handled very specially,
5757 because the restrictions on what signatures match are different from all
5758 other call instances. For a normal delete, only a delete taking (void *)
5759 or (void *, size_t) is accepted. For a placement delete, only an exact
5760 match with the placement new is accepted.
5762 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5763 ADDR is the pointer to be deleted.
5764 SIZE is the size of the memory block to be deleted.
5765 GLOBAL_P is true if the delete-expression should not consider
5766 class-specific delete operators.
5767 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5769 If this call to "operator delete" is being generated as part to
5770 deallocate memory allocated via a new-expression (as per [expr.new]
5771 which requires that if the initialization throws an exception then
5772 we call a deallocation function), then ALLOC_FN is the allocation
5776 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
5777 bool global_p
, tree placement
,
5778 tree alloc_fn
, tsubst_flags_t complain
)
5780 tree fn
= NULL_TREE
;
5781 tree fns
, fnname
, type
, t
;
5783 if (addr
== error_mark_node
)
5784 return error_mark_node
;
5786 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
5788 fnname
= ansi_opname (code
);
5790 if (CLASS_TYPE_P (type
)
5791 && COMPLETE_TYPE_P (complete_type (type
))
5795 If the result of the lookup is ambiguous or inaccessible, or if
5796 the lookup selects a placement deallocation function, the
5797 program is ill-formed.
5799 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5801 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
5802 if (fns
== error_mark_node
)
5803 return error_mark_node
;
5808 if (fns
== NULL_TREE
)
5809 fns
= lookup_name_nonclass (fnname
);
5811 /* Strip const and volatile from addr. */
5812 addr
= cp_convert (ptr_type_node
, addr
, complain
);
5816 /* "A declaration of a placement deallocation function matches the
5817 declaration of a placement allocation function if it has the same
5818 number of parameters and, after parameter transformations (8.3.5),
5819 all parameter types except the first are identical."
5821 So we build up the function type we want and ask instantiate_type
5822 to get it for us. */
5823 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
5824 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
5825 t
= build_function_type (void_type_node
, t
);
5827 fn
= instantiate_type (t
, fns
, tf_none
);
5828 if (fn
== error_mark_node
)
5831 if (BASELINK_P (fn
))
5832 fn
= BASELINK_FUNCTIONS (fn
);
5834 /* "If the lookup finds the two-parameter form of a usual deallocation
5835 function (3.7.4.2) and that function, considered as a placement
5836 deallocation function, would have been selected as a match for the
5837 allocation function, the program is ill-formed." */
5838 if (second_parm_is_size_t (fn
))
5841 = G_("exception cleanup for this placement new selects "
5842 "non-placement operator delete");
5844 = G_("%q+D is a usual (non-placement) deallocation "
5845 "function in C++14 (or with -fsized-deallocation)");
5847 /* But if the class has an operator delete (void *), then that is
5848 the usual deallocation function, so we shouldn't complain
5849 about using the operator delete (void *, size_t). */
5850 if (DECL_CLASS_SCOPE_P (fn
))
5851 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5852 t
; t
= OVL_NEXT (t
))
5854 tree elt
= OVL_CURRENT (t
);
5855 if (non_placement_deallocation_fn_p (elt
)
5856 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
5859 /* Before C++14 a two-parameter global deallocation function is
5860 always a placement deallocation function, but warn if
5862 else if (!flag_sized_deallocation
)
5864 if ((complain
& tf_warning
)
5865 && warning (OPT_Wc__14_compat
, msg1
))
5866 inform (0, msg2
, fn
);
5870 if (complain
& tf_warning_or_error
)
5872 if (permerror (input_location
, msg1
))
5874 /* Only mention C++14 for namespace-scope delete. */
5875 if (DECL_NAMESPACE_SCOPE_P (fn
))
5876 inform (0, msg2
, fn
);
5878 inform (0, "%q+D is a usual (non-placement) deallocation "
5883 return error_mark_node
;
5888 /* "Any non-placement deallocation function matches a non-placement
5889 allocation function. If the lookup finds a single matching
5890 deallocation function, that function will be called; otherwise, no
5891 deallocation function will be called." */
5892 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5893 t
; t
= OVL_NEXT (t
))
5895 tree elt
= OVL_CURRENT (t
);
5896 if (non_placement_deallocation_fn_p (elt
))
5899 /* "If a class T has a member deallocation function named
5900 operator delete with exactly one parameter, then that
5901 function is a usual (non-placement) deallocation
5902 function. If class T does not declare such an operator
5903 delete but does declare a member deallocation function named
5904 operator delete with exactly two parameters, the second of
5905 which has type std::size_t (18.2), then this function is a
5906 usual deallocation function."
5908 So in a class (void*) beats (void*, size_t). */
5909 if (DECL_CLASS_SCOPE_P (fn
))
5911 if (FUNCTION_ARG_CHAIN (fn
) == void_list_node
)
5914 /* At global scope (in C++14 and above) the rules are different:
5916 If deallocation function lookup finds both a usual
5917 deallocation function with only a pointer parameter and a
5918 usual deallocation function with both a pointer parameter
5919 and a size parameter, the function to be called is selected
5922 * If the type is complete and if, for the second alternative
5923 (delete array) only, the operand is a pointer to a class
5924 type with a non-trivial destructor or a (possibly
5925 multi-dimensional) array thereof, the function with two
5926 parameters is selected.
5928 * Otherwise, it is unspecified which of the two deallocation
5929 functions is selected. */
5932 bool want_size
= COMPLETE_TYPE_P (type
);
5933 if (code
== VEC_DELETE_EXPR
5934 && !TYPE_VEC_NEW_USES_COOKIE (type
))
5935 /* We need a cookie to determine the array size. */
5937 bool have_size
= (FUNCTION_ARG_CHAIN (fn
) != void_list_node
);
5938 if (want_size
== have_size
)
5944 /* If we have a matching function, call it. */
5947 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
5949 /* If the FN is a member function, make sure that it is
5951 if (BASELINK_P (fns
))
5952 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
5955 /* Core issue 901: It's ok to new a type with deleted delete. */
5956 if (DECL_DELETED_FN (fn
) && alloc_fn
)
5961 /* The placement args might not be suitable for overload
5962 resolution at this point, so build the call directly. */
5963 int nargs
= call_expr_nargs (placement
);
5964 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
5967 for (i
= 1; i
< nargs
; i
++)
5968 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
5969 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
5970 return error_mark_node
;
5971 return build_cxx_call (fn
, nargs
, argarray
, complain
);
5976 vec
<tree
, va_gc
> *args
= make_tree_vector ();
5977 args
->quick_push (addr
);
5978 if (FUNCTION_ARG_CHAIN (fn
) != void_list_node
)
5979 args
->quick_push (size
);
5980 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
5981 release_tree_vector (args
);
5988 If no unambiguous matching deallocation function can be found,
5989 propagating the exception does not cause the object's memory to
5993 if ((complain
& tf_warning
)
5995 warning (0, "no corresponding deallocation function for %qD",
6000 if (complain
& tf_error
)
6001 error ("no suitable %<operator %s%> for %qT",
6002 operator_name_info
[(int)code
].name
, type
);
6003 return error_mark_node
;
6006 /* If the current scope isn't allowed to access DECL along
6007 BASETYPE_PATH, give an error. The most derived class in
6008 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
6009 the declaration to use in the error diagnostic. */
6012 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
6013 tsubst_flags_t complain
)
6015 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
6017 if (!accessible_p (basetype_path
, decl
, true))
6019 if (complain
& tf_error
)
6021 if (TREE_PRIVATE (decl
))
6023 error ("%q#D is private within this context", diag_decl
);
6024 inform (DECL_SOURCE_LOCATION (diag_decl
),
6025 "declared private here");
6027 else if (TREE_PROTECTED (decl
))
6029 error ("%q#D is protected within this context", diag_decl
);
6030 inform (DECL_SOURCE_LOCATION (diag_decl
),
6031 "declared protected here");
6035 error ("%q#D is inaccessible within this context", diag_decl
);
6036 inform (DECL_SOURCE_LOCATION (diag_decl
), "declared here");
6045 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
6046 bitwise or of LOOKUP_* values. If any errors are warnings are
6047 generated, set *DIAGNOSTIC_FN to "error" or "warning",
6048 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
6052 build_temp (tree expr
, tree type
, int flags
,
6053 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
6056 vec
<tree
, va_gc
> *args
;
6058 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
6059 args
= make_tree_vector_single (expr
);
6060 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6061 &args
, type
, flags
, complain
);
6062 release_tree_vector (args
);
6063 if (warningcount
+ werrorcount
> savew
)
6064 *diagnostic_kind
= DK_WARNING
;
6065 else if (errorcount
> savee
)
6066 *diagnostic_kind
= DK_ERROR
;
6068 *diagnostic_kind
= DK_UNSPECIFIED
;
6072 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
6073 EXPR is implicitly converted to type TOTYPE.
6074 FN and ARGNUM are used for diagnostics. */
6077 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
6079 /* Issue warnings about peculiar, but valid, uses of NULL. */
6080 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
6081 && ARITHMETIC_TYPE_P (totype
))
6083 source_location loc
=
6084 expansion_point_location_if_in_system_header (input_location
);
6087 warning_at (loc
, OPT_Wconversion_null
,
6088 "passing NULL to non-pointer argument %P of %qD",
6091 warning_at (loc
, OPT_Wconversion_null
,
6092 "converting to non-pointer type %qT from NULL", totype
);
6095 /* Issue warnings if "false" is converted to a NULL pointer */
6096 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
6097 && TYPE_PTR_P (totype
))
6100 warning_at (input_location
, OPT_Wconversion_null
,
6101 "converting %<false%> to pointer type for argument %P "
6102 "of %qD", argnum
, fn
);
6104 warning_at (input_location
, OPT_Wconversion_null
,
6105 "converting %<false%> to pointer type %qT", totype
);
6109 /* We gave a diagnostic during a conversion. If this was in the second
6110 standard conversion sequence of a user-defined conversion sequence, say
6111 which user-defined conversion. */
6114 maybe_print_user_conv_context (conversion
*convs
)
6116 if (convs
->user_conv_p
)
6117 for (conversion
*t
= convs
; t
; t
= next_conversion (t
))
6118 if (t
->kind
== ck_user
)
6120 print_z_candidate (0, " after user-defined conversion:",
6126 /* Perform the conversions in CONVS on the expression EXPR. FN and
6127 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
6128 indicates the `this' argument of a method. INNER is nonzero when
6129 being called to continue a conversion chain. It is negative when a
6130 reference binding will be applied, positive otherwise. If
6131 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
6132 conversions will be emitted if appropriate. If C_CAST_P is true,
6133 this conversion is coming from a C-style cast; in that case,
6134 conversions to inaccessible bases are permitted. */
6137 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
6138 int inner
, bool issue_conversion_warnings
,
6139 bool c_cast_p
, tsubst_flags_t complain
)
6141 tree totype
= convs
->type
;
6142 diagnostic_t diag_kind
;
6144 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6146 if (convs
->bad_p
&& !(complain
& tf_error
))
6147 return error_mark_node
;
6150 && convs
->kind
!= ck_user
6151 && convs
->kind
!= ck_list
6152 && convs
->kind
!= ck_ambig
6153 && (convs
->kind
!= ck_ref_bind
6154 || (convs
->user_conv_p
&& next_conversion (convs
)->bad_p
))
6155 && (convs
->kind
!= ck_rvalue
6156 || SCALAR_TYPE_P (totype
))
6157 && convs
->kind
!= ck_base
)
6159 bool complained
= false;
6160 conversion
*t
= convs
;
6162 /* Give a helpful error if this is bad because of excess braces. */
6163 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6164 && SCALAR_TYPE_P (totype
)
6165 && CONSTRUCTOR_NELTS (expr
) > 0
6166 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
6168 complained
= permerror (loc
, "too many braces around initializer "
6170 while (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6171 && CONSTRUCTOR_NELTS (expr
) == 1)
6172 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6175 /* Give a helpful error if this is bad because a conversion to bool
6176 from std::nullptr_t requires direct-initialization. */
6177 if (NULLPTR_TYPE_P (TREE_TYPE (expr
))
6178 && TREE_CODE (totype
) == BOOLEAN_TYPE
)
6179 complained
= permerror (loc
, "converting to %qT from %qT requires "
6180 "direct-initialization",
6181 totype
, TREE_TYPE (expr
));
6183 for (; t
; t
= next_conversion (t
))
6185 if (t
->kind
== ck_user
&& t
->cand
->reason
)
6187 complained
= permerror (loc
, "invalid user-defined conversion "
6188 "from %qT to %qT", TREE_TYPE (expr
),
6191 print_z_candidate (loc
, "candidate is:", t
->cand
);
6192 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6193 /*issue_conversion_warnings=*/false,
6196 if (convs
->kind
== ck_ref_bind
)
6197 expr
= convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
6198 LOOKUP_NORMAL
, NULL_TREE
,
6201 expr
= cp_convert (totype
, expr
, complain
);
6202 if (complained
&& fn
)
6203 inform (DECL_SOURCE_LOCATION (fn
),
6204 " initializing argument %P of %qD", argnum
, fn
);
6207 else if (t
->kind
== ck_user
|| !t
->bad_p
)
6209 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
6210 /*issue_conversion_warnings=*/false,
6215 else if (t
->kind
== ck_ambig
)
6216 return convert_like_real (t
, expr
, fn
, argnum
, 1,
6217 /*issue_conversion_warnings=*/false,
6220 else if (t
->kind
== ck_identity
)
6224 complained
= permerror (loc
, "invalid conversion from %qT to %qT",
6225 TREE_TYPE (expr
), totype
);
6226 if (complained
&& fn
)
6227 inform (DECL_SOURCE_LOCATION (fn
),
6228 " initializing argument %P of %qD", argnum
, fn
);
6230 return cp_convert (totype
, expr
, complain
);
6233 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6234 conversion_null_warnings (totype
, expr
, fn
, argnum
);
6236 switch (convs
->kind
)
6240 struct z_candidate
*cand
= convs
->cand
;
6241 tree convfn
= cand
->fn
;
6244 /* If we're initializing from {}, it's value-initialization. Note
6245 that under the resolution of core 1630, value-initialization can
6246 use explicit constructors. */
6247 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
6248 && CONSTRUCTOR_NELTS (expr
) == 0
6249 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
6251 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
6252 expr
= build_value_init (totype
, complain
);
6253 expr
= get_target_expr_sfinae (expr
, complain
);
6254 if (expr
!= error_mark_node
)
6256 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6257 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
6262 /* When converting from an init list we consider explicit
6263 constructors, but actually trying to call one is an error. */
6264 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
6265 /* Unless this is for direct-list-initialization. */
6266 && !DIRECT_LIST_INIT_P (expr
))
6268 if (!(complain
& tf_error
))
6269 return error_mark_node
;
6270 error ("converting to %qT from initializer list would use "
6271 "explicit constructor %qD", totype
, convfn
);
6274 expr
= mark_rvalue_use (expr
);
6276 /* Set user_conv_p on the argument conversions, so rvalue/base
6277 handling knows not to allow any more UDCs. */
6278 for (i
= 0; i
< cand
->num_convs
; ++i
)
6279 cand
->convs
[i
]->user_conv_p
= true;
6281 expr
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
6283 /* If this is a constructor or a function returning an aggr type,
6284 we need to build up a TARGET_EXPR. */
6285 if (DECL_CONSTRUCTOR_P (convfn
))
6287 expr
= build_cplus_new (totype
, expr
, complain
);
6289 /* Remember that this was list-initialization. */
6290 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
6291 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6297 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
6299 int nelts
= CONSTRUCTOR_NELTS (expr
);
6301 expr
= build_value_init (totype
, complain
);
6302 else if (nelts
== 1)
6303 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6307 expr
= mark_rvalue_use (expr
);
6309 if (type_unknown_p (expr
))
6310 expr
= instantiate_type (totype
, expr
, complain
);
6311 /* Convert a constant to its underlying value, unless we are
6312 about to bind it to a reference, in which case we need to
6313 leave it as an lvalue. */
6316 expr
= scalar_constant_value (expr
);
6317 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
6318 /* If __null has been converted to an integer type, we do not
6319 want to warn about uses of EXPR as an integer, rather than
6321 expr
= build_int_cst (totype
, 0);
6325 /* We leave bad_p off ck_ambig because overload resolution considers
6326 it valid, it just fails when we try to perform it. So we need to
6327 check complain here, too. */
6328 if (complain
& tf_error
)
6330 /* Call build_user_type_conversion again for the error. */
6331 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
6334 inform (input_location
, " initializing argument %P of %q+D",
6337 return error_mark_node
;
6341 /* Conversion to std::initializer_list<T>. */
6342 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
6343 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
6344 unsigned len
= CONSTRUCTOR_NELTS (expr
);
6345 tree array
, val
, field
;
6346 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6349 /* Convert all the elements. */
6350 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
6352 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
6353 1, false, false, complain
);
6354 if (sub
== error_mark_node
)
6356 if (!BRACE_ENCLOSED_INITIALIZER_P (val
)
6357 && !check_narrowing (TREE_TYPE (sub
), val
, complain
))
6358 return error_mark_node
;
6359 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
6360 if (!TREE_CONSTANT (sub
))
6361 TREE_CONSTANT (new_ctor
) = false;
6363 /* Build up the array. */
6364 elttype
= cp_build_qualified_type
6365 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
6366 array
= build_array_of_n_type (elttype
, len
);
6367 array
= finish_compound_literal (array
, new_ctor
, complain
);
6368 /* Take the address explicitly rather than via decay_conversion
6369 to avoid the error about taking the address of a temporary. */
6370 array
= cp_build_addr_expr (array
, complain
);
6371 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
6372 if (array
== error_mark_node
)
6373 return error_mark_node
;
6375 /* Build up the initializer_list object. */
6376 totype
= complete_type (totype
);
6377 field
= next_initializable_field (TYPE_FIELDS (totype
));
6378 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6379 field
= next_initializable_field (DECL_CHAIN (field
));
6380 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6381 new_ctor
= build_constructor (totype
, vec
);
6382 return get_target_expr_sfinae (new_ctor
, complain
);
6386 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6388 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6389 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6390 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6392 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6394 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6395 return fold_if_not_in_template (expr
);
6397 expr
= reshape_init (totype
, expr
, complain
);
6398 expr
= get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6400 if (expr
!= error_mark_node
)
6401 TARGET_EXPR_LIST_INIT_P (expr
) = true;
6408 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6409 convs
->kind
== ck_ref_bind
? -1 : 1,
6410 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6413 if (expr
== error_mark_node
)
6414 return error_mark_node
;
6416 switch (convs
->kind
)
6419 expr
= decay_conversion (expr
, complain
);
6420 if (expr
== error_mark_node
)
6421 return error_mark_node
;
6423 if (! MAYBE_CLASS_TYPE_P (totype
))
6425 /* Else fall through. */
6427 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6429 /* We are going to bind a reference directly to a base-class
6430 subobject of EXPR. */
6431 /* Build an expression for `*((base*) &expr)'. */
6432 expr
= convert_to_base (expr
, totype
,
6433 !c_cast_p
, /*nonnull=*/true, complain
);
6437 /* Copy-initialization where the cv-unqualified version of the source
6438 type is the same class as, or a derived class of, the class of the
6439 destination [is treated as direct-initialization]. [dcl.init] */
6440 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
6441 if (convs
->user_conv_p
)
6442 /* This conversion is being done in the context of a user-defined
6443 conversion (i.e. the second step of copy-initialization), so
6444 don't allow any more. */
6445 flags
|= LOOKUP_NO_CONVERSION
;
6446 if (convs
->rvaluedness_matches_p
)
6447 flags
|= LOOKUP_PREFER_RVALUE
;
6448 if (TREE_CODE (expr
) == TARGET_EXPR
6449 && TARGET_EXPR_LIST_INIT_P (expr
))
6450 /* Copy-list-initialization doesn't actually involve a copy. */
6452 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6453 if (diag_kind
&& complain
)
6455 maybe_print_user_conv_context (convs
);
6457 inform (DECL_SOURCE_LOCATION (fn
),
6458 " initializing argument %P of %qD", argnum
, fn
);
6461 return build_cplus_new (totype
, expr
, complain
);
6465 tree ref_type
= totype
;
6467 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6469 tree extype
= TREE_TYPE (expr
);
6470 if (TYPE_REF_IS_RVALUE (ref_type
)
6471 && real_lvalue_p (expr
))
6472 error_at (loc
, "cannot bind %qT lvalue to %qT",
6474 else if (!TYPE_REF_IS_RVALUE (ref_type
) && !real_lvalue_p (expr
)
6475 && !CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
)))
6476 error_at (loc
, "invalid initialization of non-const reference of "
6477 "type %qT from an rvalue of type %qT", totype
, extype
);
6478 else if (!reference_compatible_p (TREE_TYPE (totype
), extype
))
6479 error_at (loc
, "binding %qT to reference of type %qT "
6480 "discards qualifiers", extype
, totype
);
6483 maybe_print_user_conv_context (convs
);
6485 inform (input_location
,
6486 " initializing argument %P of %q+D", argnum
, fn
);
6487 return error_mark_node
;
6490 /* If necessary, create a temporary.
6492 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6493 that need temporaries, even when their types are reference
6494 compatible with the type of reference being bound, so the
6495 upcoming call to cp_build_addr_expr doesn't fail. */
6496 if (convs
->need_temporary_p
6497 || TREE_CODE (expr
) == CONSTRUCTOR
6498 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6500 /* Otherwise, a temporary of type "cv1 T1" is created and
6501 initialized from the initializer expression using the rules
6502 for a non-reference copy-initialization (8.5). */
6504 tree type
= TREE_TYPE (ref_type
);
6505 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
6507 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6508 (type
, next_conversion (convs
)->type
));
6509 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6510 && !TYPE_REF_IS_RVALUE (ref_type
))
6512 /* If the reference is volatile or non-const, we
6513 cannot create a temporary. */
6514 if (lvalue
& clk_bitfield
)
6515 error_at (loc
, "cannot bind bitfield %qE to %qT",
6517 else if (lvalue
& clk_packed
)
6518 error_at (loc
, "cannot bind packed field %qE to %qT",
6521 error_at (loc
, "cannot bind rvalue %qE to %qT",
6523 return error_mark_node
;
6525 /* If the source is a packed field, and we must use a copy
6526 constructor, then building the target expr will require
6527 binding the field to the reference parameter to the
6528 copy constructor, and we'll end up with an infinite
6529 loop. If we can use a bitwise copy, then we'll be
6531 if ((lvalue
& clk_packed
)
6532 && CLASS_TYPE_P (type
)
6533 && type_has_nontrivial_copy_init (type
))
6535 error_at (loc
, "cannot bind packed field %qE to %qT",
6537 return error_mark_node
;
6539 if (lvalue
& clk_bitfield
)
6541 expr
= convert_bitfield_to_declared_type (expr
);
6542 expr
= fold_convert (type
, expr
);
6544 expr
= build_target_expr_with_type (expr
, type
, complain
);
6547 /* Take the address of the thing to which we will bind the
6549 expr
= cp_build_addr_expr (expr
, complain
);
6550 if (expr
== error_mark_node
)
6551 return error_mark_node
;
6553 /* Convert it to a pointer to the type referred to by the
6554 reference. This will adjust the pointer if a derived to
6555 base conversion is being performed. */
6556 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
6558 /* Convert the pointer to the desired reference type. */
6559 return build_nop (ref_type
, expr
);
6563 return decay_conversion (expr
, complain
);
6566 /* Warn about deprecated conversion if appropriate. */
6567 string_conv_p (totype
, expr
, 1);
6572 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
6573 /*nonnull=*/false, complain
);
6574 return build_nop (totype
, expr
);
6577 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
6578 c_cast_p
, complain
);
6584 if (convs
->check_narrowing
6585 && !check_narrowing (totype
, expr
, complain
))
6586 return error_mark_node
;
6588 if (issue_conversion_warnings
)
6589 expr
= cp_convert_and_check (totype
, expr
, complain
);
6591 expr
= cp_convert (totype
, expr
, complain
);
6596 /* ARG is being passed to a varargs function. Perform any conversions
6597 required. Return the converted value. */
6600 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
6603 location_t loc
= EXPR_LOC_OR_LOC (arg
, input_location
);
6607 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6608 standard conversions are performed. */
6609 arg
= decay_conversion (arg
, complain
);
6610 arg_type
= TREE_TYPE (arg
);
6613 If the argument has integral or enumeration type that is subject
6614 to the integral promotions (_conv.prom_), or a floating point
6615 type that is subject to the floating point promotion
6616 (_conv.fpprom_), the value of the argument is converted to the
6617 promoted type before the call. */
6618 if (TREE_CODE (arg_type
) == REAL_TYPE
6619 && (TYPE_PRECISION (arg_type
)
6620 < TYPE_PRECISION (double_type_node
))
6621 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
6623 if ((complain
& tf_warning
)
6624 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
6625 warning_at (loc
, OPT_Wdouble_promotion
,
6626 "implicit conversion from %qT to %qT when passing "
6627 "argument to function",
6628 arg_type
, double_type_node
);
6629 arg
= convert_to_real (double_type_node
, arg
);
6631 else if (NULLPTR_TYPE_P (arg_type
))
6632 arg
= null_pointer_node
;
6633 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
6635 if (SCOPED_ENUM_P (arg_type
))
6637 tree prom
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
,
6639 prom
= cp_perform_integral_promotions (prom
, complain
);
6640 if (abi_version_crosses (6)
6641 && TYPE_MODE (TREE_TYPE (prom
)) != TYPE_MODE (arg_type
)
6642 && (complain
& tf_warning
))
6643 warning_at (loc
, OPT_Wabi
, "scoped enum %qT passed through ... as "
6644 "%qT before -fabi-version=6, %qT after", arg_type
,
6645 TREE_TYPE (prom
), ENUM_UNDERLYING_TYPE (arg_type
));
6646 if (!abi_version_at_least (6))
6650 arg
= cp_perform_integral_promotions (arg
, complain
);
6653 arg
= require_complete_type_sfinae (arg
, complain
);
6654 arg_type
= TREE_TYPE (arg
);
6656 if (arg
!= error_mark_node
6657 /* In a template (or ill-formed code), we can have an incomplete type
6658 even after require_complete_type_sfinae, in which case we don't know
6659 whether it has trivial copy or not. */
6660 && COMPLETE_TYPE_P (arg_type
))
6662 /* Build up a real lvalue-to-rvalue conversion in case the
6663 copy constructor is trivial but not callable. */
6664 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
6665 force_rvalue (arg
, complain
);
6667 /* [expr.call] 5.2.2/7:
6668 Passing a potentially-evaluated argument of class type (Clause 9)
6669 with a non-trivial copy constructor or a non-trivial destructor
6670 with no corresponding parameter is conditionally-supported, with
6671 implementation-defined semantics.
6673 We support it as pass-by-invisible-reference, just like a normal
6676 If the call appears in the context of a sizeof expression,
6677 it is not potentially-evaluated. */
6678 if (cp_unevaluated_operand
== 0
6679 && (type_has_nontrivial_copy_init (arg_type
)
6680 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
6682 if (complain
& tf_warning
)
6683 warning (OPT_Wconditionally_supported
,
6684 "passing objects of non-trivially-copyable "
6685 "type %q#T through %<...%> is conditionally supported",
6687 return cp_build_addr_expr (arg
, complain
);
6694 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6697 build_x_va_arg (source_location loc
, tree expr
, tree type
)
6699 if (processing_template_decl
)
6701 tree r
= build_min (VA_ARG_EXPR
, type
, expr
);
6702 SET_EXPR_LOCATION (r
, loc
);
6706 type
= complete_type_or_else (type
, NULL_TREE
);
6708 if (expr
== error_mark_node
|| !type
)
6709 return error_mark_node
;
6711 expr
= mark_lvalue_use (expr
);
6713 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6715 error ("cannot receive reference type %qT through %<...%>", type
);
6716 return error_mark_node
;
6719 if (type_has_nontrivial_copy_init (type
)
6720 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6722 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
6723 it as pass by invisible reference. */
6724 warning_at (loc
, OPT_Wconditionally_supported
,
6725 "receiving objects of non-trivially-copyable type %q#T "
6726 "through %<...%> is conditionally-supported", type
);
6728 tree ref
= cp_build_reference_type (type
, false);
6729 expr
= build_va_arg (loc
, expr
, ref
);
6730 return convert_from_reference (expr
);
6733 return build_va_arg (loc
, expr
, type
);
6736 /* TYPE has been given to va_arg. Apply the default conversions which
6737 would have happened when passed via ellipsis. Return the promoted
6738 type, or the passed type if there is no change. */
6741 cxx_type_promotes_to (tree type
)
6745 /* Perform the array-to-pointer and function-to-pointer
6747 type
= type_decays_to (type
);
6749 promote
= type_promotes_to (type
);
6750 if (same_type_p (type
, promote
))
6756 /* ARG is a default argument expression being passed to a parameter of
6757 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6758 zero-based argument number. Do any required conversions. Return
6759 the converted value. */
6761 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
6763 push_defarg_context (tree fn
)
6764 { vec_safe_push (default_arg_context
, fn
); }
6767 pop_defarg_context (void)
6768 { default_arg_context
->pop (); }
6771 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
6772 tsubst_flags_t complain
)
6777 /* See through clones. */
6778 fn
= DECL_ORIGIN (fn
);
6780 /* Detect recursion. */
6781 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
6784 if (complain
& tf_error
)
6785 error ("recursive evaluation of default argument for %q#D", fn
);
6786 return error_mark_node
;
6789 /* If the ARG is an unparsed default argument expression, the
6790 conversion cannot be performed. */
6791 if (TREE_CODE (arg
) == DEFAULT_ARG
)
6793 if (complain
& tf_error
)
6794 error ("call to %qD uses the default argument for parameter %P, which "
6795 "is not yet defined", fn
, parmnum
);
6796 return error_mark_node
;
6799 push_defarg_context (fn
);
6801 if (fn
&& DECL_TEMPLATE_INFO (fn
))
6802 arg
= tsubst_default_argument (fn
, type
, arg
, complain
);
6808 The names in the expression are bound, and the semantic
6809 constraints are checked, at the point where the default
6810 expressions appears.
6812 we must not perform access checks here. */
6813 push_deferring_access_checks (dk_no_check
);
6814 /* We must make a copy of ARG, in case subsequent processing
6815 alters any part of it. */
6816 arg
= break_out_target_exprs (arg
);
6817 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6818 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6820 arg
= convert_for_arg_passing (type
, arg
, complain
);
6821 pop_deferring_access_checks();
6823 pop_defarg_context ();
6828 /* Returns the type which will really be used for passing an argument of
6832 type_passed_as (tree type
)
6834 /* Pass classes with copy ctors by invisible reference. */
6835 if (TREE_ADDRESSABLE (type
))
6837 type
= build_reference_type (type
);
6838 /* There are no other pointers to this temporary. */
6839 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
6841 else if (targetm
.calls
.promote_prototypes (type
)
6842 && INTEGRAL_TYPE_P (type
)
6843 && COMPLETE_TYPE_P (type
)
6844 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6845 type
= integer_type_node
;
6850 /* Actually perform the appropriate conversion. */
6853 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
6857 /* If VAL is a bitfield, then -- since it has already been converted
6858 to TYPE -- it cannot have a precision greater than TYPE.
6860 If it has a smaller precision, we must widen it here. For
6861 example, passing "int f:3;" to a function expecting an "int" will
6862 not result in any conversion before this point.
6864 If the precision is the same we must not risk widening. For
6865 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6866 often have type "int", even though the C++ type for the field is
6867 "long long". If the value is being passed to a function
6868 expecting an "int", then no conversions will be required. But,
6869 if we call convert_bitfield_to_declared_type, the bitfield will
6870 be converted to "long long". */
6871 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
6873 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
6874 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
6876 if (val
== error_mark_node
)
6878 /* Pass classes with copy ctors by invisible reference. */
6879 else if (TREE_ADDRESSABLE (type
))
6880 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
6881 else if (targetm
.calls
.promote_prototypes (type
)
6882 && INTEGRAL_TYPE_P (type
)
6883 && COMPLETE_TYPE_P (type
)
6884 && tree_int_cst_lt (TYPE_SIZE (type
), TYPE_SIZE (integer_type_node
)))
6885 val
= cp_perform_integral_promotions (val
, complain
);
6886 if ((complain
& tf_warning
)
6887 && warn_suggest_attribute_format
)
6889 tree rhstype
= TREE_TYPE (val
);
6890 const enum tree_code coder
= TREE_CODE (rhstype
);
6891 const enum tree_code codel
= TREE_CODE (type
);
6892 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6894 && check_missing_format_attribute (type
, rhstype
))
6895 warning (OPT_Wsuggest_attribute_format
,
6896 "argument of function call might be a candidate for a format attribute");
6901 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6902 which no conversions at all should be done. This is true for some
6903 builtins which don't act like normal functions. */
6906 magic_varargs_p (tree fn
)
6908 if (flag_cilkplus
&& is_cilkplus_reduce_builtin (fn
) != BUILT_IN_NONE
)
6911 if (DECL_BUILT_IN (fn
))
6912 switch (DECL_FUNCTION_CODE (fn
))
6914 case BUILT_IN_CLASSIFY_TYPE
:
6915 case BUILT_IN_CONSTANT_P
:
6916 case BUILT_IN_NEXT_ARG
:
6917 case BUILT_IN_VA_START
:
6921 return lookup_attribute ("type generic",
6922 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
6928 /* Returns the decl of the dispatcher function if FN is a function version. */
6931 get_function_version_dispatcher (tree fn
)
6933 tree dispatcher_decl
= NULL
;
6935 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6936 && DECL_FUNCTION_VERSIONED (fn
));
6938 gcc_assert (targetm
.get_function_versions_dispatcher
);
6939 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
6941 if (dispatcher_decl
== NULL
)
6943 error_at (input_location
, "use of multiversioned function "
6944 "without a default");
6948 retrofit_lang_decl (dispatcher_decl
);
6949 gcc_assert (dispatcher_decl
!= NULL
);
6950 return dispatcher_decl
;
6953 /* fn is a function version dispatcher that is marked used. Mark all the
6954 semantically identical function versions it will dispatch as used. */
6957 mark_versions_used (tree fn
)
6959 struct cgraph_node
*node
;
6960 struct cgraph_function_version_info
*node_v
;
6961 struct cgraph_function_version_info
*it_v
;
6963 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6965 node
= cgraph_node::get (fn
);
6969 gcc_assert (node
->dispatcher_function
);
6971 node_v
= node
->function_version ();
6975 /* All semantically identical versions are chained. Traverse and mark each
6976 one of them as used. */
6977 it_v
= node_v
->next
;
6978 while (it_v
!= NULL
)
6980 mark_used (it_v
->this_node
->decl
);
6985 /* Build a call to "the copy constructor" for the type of A, even if it
6986 wouldn't be selected by normal overload resolution. Used for
6990 call_copy_ctor (tree a
, tsubst_flags_t complain
)
6992 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (a
));
6993 tree binfo
= TYPE_BINFO (ctype
);
6994 tree copy
= get_copy_ctor (ctype
, complain
);
6995 copy
= build_baselink (binfo
, binfo
, copy
, NULL_TREE
);
6996 tree ob
= build_dummy_object (ctype
);
6997 vec
<tree
, va_gc
>* args
= make_tree_vector_single (a
);
6998 tree r
= build_new_method_call (ob
, copy
, &args
, NULL_TREE
,
6999 LOOKUP_NORMAL
, NULL
, complain
);
7000 release_tree_vector (args
);
7004 /* Subroutine of the various build_*_call functions. Overload resolution
7005 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
7006 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
7007 bitmask of various LOOKUP_* flags which apply to the call itself. */
7010 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
7013 const vec
<tree
, va_gc
> *args
= cand
->args
;
7014 tree first_arg
= cand
->first_arg
;
7015 conversion
**convs
= cand
->convs
;
7017 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7022 unsigned int arg_index
= 0;
7026 bool already_used
= false;
7028 /* In a template, there is no need to perform all of the work that
7029 is normally done. We are only interested in the type of the call
7030 expression, i.e., the return type of the function. Any semantic
7031 errors will be deferred until the template is instantiated. */
7032 if (processing_template_decl
)
7036 const tree
*argarray
;
7039 return_type
= TREE_TYPE (TREE_TYPE (fn
));
7040 nargs
= vec_safe_length (args
);
7041 if (first_arg
== NULL_TREE
)
7042 argarray
= args
->address ();
7050 alcarray
= XALLOCAVEC (tree
, nargs
);
7051 alcarray
[0] = build_this (first_arg
);
7052 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
7053 alcarray
[ix
+ 1] = arg
;
7054 argarray
= alcarray
;
7057 addr
= build_addr_func (fn
, complain
);
7058 if (addr
== error_mark_node
)
7059 return error_mark_node
;
7060 expr
= build_call_array_loc (input_location
, return_type
,
7061 addr
, nargs
, argarray
);
7062 if (TREE_THIS_VOLATILE (fn
) && cfun
)
7063 current_function_returns_abnormally
= 1;
7064 return convert_from_reference (expr
);
7067 /* Give any warnings we noticed during overload resolution. */
7068 if (cand
->warnings
&& (complain
& tf_warning
))
7070 struct candidate_warning
*w
;
7071 for (w
= cand
->warnings
; w
; w
= w
->next
)
7072 joust (cand
, w
->loser
, 1, complain
);
7075 /* Make =delete work with SFINAE. */
7076 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7077 return error_mark_node
;
7079 if (DECL_FUNCTION_MEMBER_P (fn
))
7082 /* If FN is a template function, two cases must be considered.
7087 template <class T> void f();
7089 template <class T> struct B {
7093 struct C : A, B<int> {
7095 using B<int>::g; // #2
7098 In case #1 where `A::f' is a member template, DECL_ACCESS is
7099 recorded in the primary template but not in its specialization.
7100 We check access of FN using its primary template.
7102 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
7103 because it is a member of class template B, DECL_ACCESS is
7104 recorded in the specialization `B<int>::g'. We cannot use its
7105 primary template because `B<T>::g' and `B<int>::g' may have
7106 different access. */
7107 if (DECL_TEMPLATE_INFO (fn
)
7108 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
7109 access_fn
= DECL_TI_TEMPLATE (fn
);
7112 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
7114 return error_mark_node
;
7117 /* If we're checking for implicit delete, don't bother with argument
7119 if (flags
& LOOKUP_SPECULATIVE
)
7121 if (DECL_DELETED_FN (fn
))
7123 if (complain
& tf_error
)
7125 return error_mark_node
;
7127 if (cand
->viable
== 1)
7129 else if (!(complain
& tf_error
))
7130 /* Reject bad conversions now. */
7131 return error_mark_node
;
7132 /* else continue to get conversion error. */
7135 /* N3276 magic doesn't apply to nested calls. */
7136 int decltype_flag
= (complain
& tf_decltype
);
7137 complain
&= ~tf_decltype
;
7139 /* Find maximum size of vector to hold converted arguments. */
7140 parmlen
= list_length (parm
);
7141 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
7142 if (parmlen
> nargs
)
7144 argarray
= XALLOCAVEC (tree
, nargs
);
7146 /* The implicit parameters to a constructor are not considered by overload
7147 resolution, and must be of the proper type. */
7148 if (DECL_CONSTRUCTOR_P (fn
))
7151 if (first_arg
!= NULL_TREE
)
7153 object_arg
= first_arg
;
7154 first_arg
= NULL_TREE
;
7158 object_arg
= (*args
)[arg_index
];
7161 argarray
[j
++] = build_this (object_arg
);
7162 parm
= TREE_CHAIN (parm
);
7163 /* We should never try to call the abstract constructor. */
7164 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
7166 if (DECL_HAS_VTT_PARM_P (fn
))
7168 argarray
[j
++] = (*args
)[arg_index
];
7170 parm
= TREE_CHAIN (parm
);
7173 /* Bypass access control for 'this' parameter. */
7174 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7176 tree parmtype
= TREE_VALUE (parm
);
7177 tree arg
= build_this (first_arg
!= NULL_TREE
7179 : (*args
)[arg_index
]);
7180 tree argtype
= TREE_TYPE (arg
);
7184 if (convs
[i
]->bad_p
)
7186 if (complain
& tf_error
)
7188 if (permerror (input_location
, "passing %qT as %<this%> "
7189 "argument discards qualifiers",
7190 TREE_TYPE (argtype
)))
7191 inform (DECL_SOURCE_LOCATION (fn
), " in call to %qD", fn
);
7194 return error_mark_node
;
7197 /* See if the function member or the whole class type is declared
7198 final and the call can be devirtualized. */
7199 if (DECL_FINAL_P (fn
)
7200 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
7201 flags
|= LOOKUP_NONVIRTUAL
;
7203 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
7204 X is called for an object that is not of type X, or of a type
7205 derived from X, the behavior is undefined.
7207 So we can assume that anything passed as 'this' is non-null, and
7208 optimize accordingly. */
7209 gcc_assert (TYPE_PTR_P (parmtype
));
7210 /* Convert to the base in which the function was declared. */
7211 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
7212 converted_arg
= build_base_path (PLUS_EXPR
,
7214 cand
->conversion_path
,
7216 /* Check that the base class is accessible. */
7217 if (!accessible_base_p (TREE_TYPE (argtype
),
7218 BINFO_TYPE (cand
->conversion_path
), true))
7220 if (complain
& tf_error
)
7221 error ("%qT is not an accessible base of %qT",
7222 BINFO_TYPE (cand
->conversion_path
),
7223 TREE_TYPE (argtype
));
7225 return error_mark_node
;
7227 /* If fn was found by a using declaration, the conversion path
7228 will be to the derived class, not the base declaring fn. We
7229 must convert from derived to base. */
7230 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
7231 TREE_TYPE (parmtype
), ba_unique
,
7233 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
7234 base_binfo
, 1, complain
);
7236 argarray
[j
++] = converted_arg
;
7237 parm
= TREE_CHAIN (parm
);
7238 if (first_arg
!= NULL_TREE
)
7239 first_arg
= NULL_TREE
;
7246 gcc_assert (first_arg
== NULL_TREE
);
7247 for (; arg_index
< vec_safe_length (args
) && parm
;
7248 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
7250 tree type
= TREE_VALUE (parm
);
7251 tree arg
= (*args
)[arg_index
];
7252 bool conversion_warning
= true;
7256 /* If the argument is NULL and used to (implicitly) instantiate a
7257 template function (and bind one of the template arguments to
7258 the type of 'long int'), we don't want to warn about passing NULL
7259 to non-pointer argument.
7260 For example, if we have this template function:
7262 template<typename T> void func(T x) {}
7264 we want to warn (when -Wconversion is enabled) in this case:
7270 but not in this case:
7276 if (arg
== null_node
7277 && DECL_TEMPLATE_INFO (fn
)
7278 && cand
->template_decl
7279 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
7280 conversion_warning
= false;
7282 /* Warn about initializer_list deduction that isn't currently in the
7284 if (cxx_dialect
> cxx98
7285 && flag_deduce_init_list
7286 && cand
->template_decl
7287 && is_std_init_list (non_reference (type
))
7288 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
7290 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
7291 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
7292 tree patparm
= get_pattern_parm (realparm
, tmpl
);
7293 tree pattype
= TREE_TYPE (patparm
);
7294 if (PACK_EXPANSION_P (pattype
))
7295 pattype
= PACK_EXPANSION_PATTERN (pattype
);
7296 pattype
= non_reference (pattype
);
7298 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
7299 && (cand
->explicit_targs
== NULL_TREE
7300 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
7301 <= TEMPLATE_TYPE_IDX (pattype
))))
7303 pedwarn (input_location
, 0, "deducing %qT as %qT",
7304 non_reference (TREE_TYPE (patparm
)),
7305 non_reference (type
));
7306 pedwarn (input_location
, 0, " in call to %q+D", cand
->fn
);
7307 pedwarn (input_location
, 0,
7308 " (you can disable this with -fno-deduce-init-list)");
7311 val
= convert_like_with_context (conv
, arg
, fn
, i
- is_method
,
7314 : complain
& (~tf_warning
));
7316 val
= convert_for_arg_passing (type
, val
, complain
);
7318 if (val
== error_mark_node
)
7319 return error_mark_node
;
7321 argarray
[j
++] = val
;
7324 /* Default arguments */
7325 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
7327 if (TREE_VALUE (parm
) == error_mark_node
)
7328 return error_mark_node
;
7329 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
7330 TREE_PURPOSE (parm
),
7336 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
7338 tree a
= (*args
)[arg_index
];
7339 if (magic_varargs_p (fn
))
7340 /* Do no conversions for magic varargs. */
7341 a
= mark_type_use (a
);
7342 else if (DECL_CONSTRUCTOR_P (fn
)
7343 && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn
),
7346 /* Avoid infinite recursion trying to call A(...). */
7347 if (complain
& tf_error
)
7348 /* Try to call the actual copy constructor for a good error. */
7349 call_copy_ctor (a
, complain
);
7350 return error_mark_node
;
7353 a
= convert_arg_to_ellipsis (a
, complain
);
7357 gcc_assert (j
<= nargs
);
7360 check_function_arguments (TREE_TYPE (fn
), nargs
, argarray
);
7362 /* Avoid actually calling copy constructors and copy assignment operators,
7365 if (! flag_elide_constructors
)
7366 /* Do things the hard way. */;
7367 else if (cand
->num_convs
== 1
7368 && (DECL_COPY_CONSTRUCTOR_P (fn
)
7369 || DECL_MOVE_CONSTRUCTOR_P (fn
))
7370 /* It's unsafe to elide the constructor when handling
7371 a noexcept-expression, it may evaluate to the wrong
7372 value (c++/53025). */
7373 && cp_noexcept_operand
== 0)
7376 tree arg
= argarray
[num_artificial_parms_for (fn
)];
7378 bool trivial
= trivial_fn_p (fn
);
7380 /* Pull out the real argument, disregarding const-correctness. */
7382 while (CONVERT_EXPR_P (targ
)
7383 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
7384 targ
= TREE_OPERAND (targ
, 0);
7385 if (TREE_CODE (targ
) == ADDR_EXPR
)
7387 targ
= TREE_OPERAND (targ
, 0);
7388 if (!same_type_ignoring_top_level_qualifiers_p
7389 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
7398 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7400 /* [class.copy]: the copy constructor is implicitly defined even if
7401 the implementation elided its use. */
7402 if (!trivial
|| DECL_DELETED_FN (fn
))
7404 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7405 return error_mark_node
;
7406 already_used
= true;
7409 /* If we're creating a temp and we already have one, don't create a
7410 new one. If we're not creating a temp but we get one, use
7411 INIT_EXPR to collapse the temp into our target. Otherwise, if the
7412 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
7413 temp or an INIT_EXPR otherwise. */
7415 if (is_dummy_object (fa
))
7417 if (TREE_CODE (arg
) == TARGET_EXPR
)
7420 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
7422 else if (TREE_CODE (arg
) == TARGET_EXPR
|| trivial
)
7424 tree to
= stabilize_reference (cp_build_indirect_ref (fa
, RO_NULL
,
7427 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
7431 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
7432 && trivial_fn_p (fn
)
7433 && !DECL_DELETED_FN (fn
))
7435 tree to
= stabilize_reference
7436 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
7437 tree type
= TREE_TYPE (to
);
7438 tree as_base
= CLASSTYPE_AS_BASE (type
);
7439 tree arg
= argarray
[1];
7441 if (is_really_empty_class (type
))
7443 /* Avoid copying empty classes. */
7444 val
= build2 (COMPOUND_EXPR
, void_type_node
, to
, arg
);
7445 TREE_NO_WARNING (val
) = 1;
7446 val
= build2 (COMPOUND_EXPR
, type
, val
, to
);
7447 TREE_NO_WARNING (val
) = 1;
7449 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
7451 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7452 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
7456 /* We must only copy the non-tail padding parts. */
7458 tree array_type
, alias_set
;
7460 arg2
= TYPE_SIZE_UNIT (as_base
);
7461 arg0
= cp_build_addr_expr (to
, complain
);
7463 array_type
= build_array_type (char_type_node
,
7465 (size_binop (MINUS_EXPR
,
7466 arg2
, size_int (1))));
7467 alias_set
= build_int_cst (build_pointer_type (type
), 0);
7468 t
= build2 (MODIFY_EXPR
, void_type_node
,
7469 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
7470 build2 (MEM_REF
, array_type
, arg
, alias_set
));
7471 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
7472 TREE_NO_WARNING (val
) = 1;
7477 else if (DECL_DESTRUCTOR_P (fn
)
7478 && trivial_fn_p (fn
)
7479 && !DECL_DELETED_FN (fn
))
7480 return fold_convert (void_type_node
, argarray
[0]);
7481 /* FIXME handle trivial default constructor, too. */
7483 /* For calls to a multi-versioned function, overload resolution
7484 returns the function with the highest target priority, that is,
7485 the version that will checked for dispatching first. If this
7486 version is inlinable, a direct call to this version can be made
7487 otherwise the call should go through the dispatcher. */
7489 if (DECL_FUNCTION_VERSIONED (fn
)
7490 && (current_function_decl
== NULL
7491 || !targetm
.target_option
.can_inline_p (current_function_decl
, fn
)))
7493 fn
= get_function_version_dispatcher (fn
);
7497 mark_versions_used (fn
);
7501 && !mark_used (fn
, complain
))
7502 return error_mark_node
;
7504 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
7505 /* Don't mess with virtual lookup in instantiate_non_dependent_expr;
7506 virtual functions can't be constexpr. */
7507 && !in_template_function ())
7510 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
7512 ba_any
, NULL
, complain
);
7513 gcc_assert (binfo
&& binfo
!= error_mark_node
);
7515 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
7517 if (TREE_SIDE_EFFECTS (argarray
[0]))
7518 argarray
[0] = save_expr (argarray
[0]);
7519 t
= build_pointer_type (TREE_TYPE (fn
));
7520 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
7521 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
7523 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
7528 fn
= build_addr_func (fn
, complain
);
7529 if (fn
== error_mark_node
)
7530 return error_mark_node
;
7533 tree call
= build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
7534 if (TREE_CODE (call
) == CALL_EXPR
7535 && (cand
->flags
& LOOKUP_LIST_INIT_CTOR
))
7536 CALL_EXPR_LIST_INIT_P (call
) = true;
7540 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7541 This function performs no overload resolution, conversion, or other
7542 high-level operations. */
7545 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
7546 tsubst_flags_t complain
)
7551 /* Remember roughly where this call is. */
7552 location_t loc
= EXPR_LOC_OR_LOC (fn
, input_location
);
7553 fn
= build_call_a (fn
, nargs
, argarray
);
7554 SET_EXPR_LOCATION (fn
, loc
);
7556 fndecl
= get_callee_fndecl (fn
);
7558 /* Check that arguments to builtin functions match the expectations. */
7560 && DECL_BUILT_IN (fndecl
)
7561 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7562 && !check_builtin_function_arguments (fndecl
, nargs
, argarray
))
7563 return error_mark_node
;
7565 /* If it is a built-in array notation function, then the return type of
7566 the function is the element type of the array passed in as array
7567 notation (i.e. the first parameter of the function). */
7568 if (flag_cilkplus
&& TREE_CODE (fn
) == CALL_EXPR
)
7570 enum built_in_function bif
=
7571 is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn
));
7572 if (bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
7573 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
7574 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
7575 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
7576 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE
7577 || bif
== BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
7579 if (call_expr_nargs (fn
) == 0)
7581 error_at (EXPR_LOCATION (fn
), "Invalid builtin arguments");
7582 return error_mark_node
;
7584 /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or
7585 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or
7586 BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or
7587 BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or
7588 BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or
7589 BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
7590 The pre-defined return-type is the correct one. */
7591 tree array_ntn
= CALL_EXPR_ARG (fn
, 0);
7592 TREE_TYPE (fn
) = TREE_TYPE (array_ntn
);
7597 /* Some built-in function calls will be evaluated at compile-time in
7598 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7599 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7600 optimize_sav
= optimize
;
7601 if (!optimize
&& fndecl
&& DECL_IS_BUILTIN_CONSTANT_P (fndecl
)
7602 && current_function_decl
7603 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
7605 fn
= fold_if_not_in_template (fn
);
7606 optimize
= optimize_sav
;
7608 if (VOID_TYPE_P (TREE_TYPE (fn
)))
7611 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7612 function call is either the operand of a decltype-specifier or the
7613 right operand of a comma operator that is the operand of a
7614 decltype-specifier, a temporary object is not introduced for the
7615 prvalue. The type of the prvalue may be incomplete. */
7616 if (!(complain
& tf_decltype
))
7618 fn
= require_complete_type_sfinae (fn
, complain
);
7619 if (fn
== error_mark_node
)
7620 return error_mark_node
;
7622 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
7623 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
7625 return convert_from_reference (fn
);
7628 static GTY(()) tree java_iface_lookup_fn
;
7630 /* Make an expression which yields the address of the Java interface
7631 method FN. This is achieved by generating a call to libjava's
7632 _Jv_LookupInterfaceMethodIdx(). */
7635 build_java_interface_fn_ref (tree fn
, tree instance
)
7637 tree lookup_fn
, method
, idx
;
7638 tree klass_ref
, iface
, iface_ref
;
7641 if (!java_iface_lookup_fn
)
7643 tree ftype
= build_function_type_list (ptr_type_node
,
7644 ptr_type_node
, ptr_type_node
,
7645 java_int_type_node
, NULL_TREE
);
7646 java_iface_lookup_fn
7647 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype
,
7648 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
7651 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7652 This is the first entry in the vtable. */
7653 klass_ref
= build_vtbl_ref (cp_build_indirect_ref (instance
, RO_NULL
,
7654 tf_warning_or_error
),
7657 /* Get the java.lang.Class pointer for the interface being called. */
7658 iface
= DECL_CONTEXT (fn
);
7659 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
7660 if (!iface_ref
|| !VAR_P (iface_ref
)
7661 || DECL_CONTEXT (iface_ref
) != iface
)
7663 error ("could not find class$ field in java interface type %qT",
7665 return error_mark_node
;
7667 iface_ref
= build_address (iface_ref
);
7668 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
7670 /* Determine the itable index of FN. */
7672 for (method
= TYPE_METHODS (iface
); method
; method
= DECL_CHAIN (method
))
7674 if (!DECL_VIRTUAL_P (method
))
7680 idx
= build_int_cst (NULL_TREE
, i
);
7682 lookup_fn
= build1 (ADDR_EXPR
,
7683 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
7684 java_iface_lookup_fn
);
7685 return build_call_nary (ptr_type_node
, lookup_fn
,
7686 3, klass_ref
, iface_ref
, idx
);
7689 /* Returns the value to use for the in-charge parameter when making a
7690 call to a function with the indicated NAME.
7692 FIXME:Can't we find a neater way to do this mapping? */
7695 in_charge_arg_for_name (tree name
)
7697 if (name
== base_ctor_identifier
7698 || name
== base_dtor_identifier
)
7699 return integer_zero_node
;
7700 else if (name
== complete_ctor_identifier
)
7701 return integer_one_node
;
7702 else if (name
== complete_dtor_identifier
)
7703 return integer_two_node
;
7704 else if (name
== deleting_dtor_identifier
)
7705 return integer_three_node
;
7707 /* This function should only be called with one of the names listed
7713 /* Build a call to a constructor, destructor, or an assignment
7714 operator for INSTANCE, an expression with class type. NAME
7715 indicates the special member function to call; *ARGS are the
7716 arguments. ARGS may be NULL. This may change ARGS. BINFO
7717 indicates the base of INSTANCE that is to be passed as the `this'
7718 parameter to the member function called.
7720 FLAGS are the LOOKUP_* flags to use when processing the call.
7722 If NAME indicates a complete object constructor, INSTANCE may be
7723 NULL_TREE. In this case, the caller will call build_cplus_new to
7724 store the newly constructed object into a VAR_DECL. */
7727 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
7728 tree binfo
, int flags
, tsubst_flags_t complain
)
7731 /* The type of the subobject to be constructed or destroyed. */
7733 vec
<tree
, va_gc
> *allocated
= NULL
;
7736 gcc_assert (name
== complete_ctor_identifier
7737 || name
== base_ctor_identifier
7738 || name
== complete_dtor_identifier
7739 || name
== base_dtor_identifier
7740 || name
== deleting_dtor_identifier
7741 || name
== ansi_assopname (NOP_EXPR
));
7744 /* Resolve the name. */
7745 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
7746 return error_mark_node
;
7748 binfo
= TYPE_BINFO (binfo
);
7751 gcc_assert (binfo
!= NULL_TREE
);
7753 class_type
= BINFO_TYPE (binfo
);
7755 /* Handle the special case where INSTANCE is NULL_TREE. */
7756 if (name
== complete_ctor_identifier
&& !instance
)
7757 instance
= build_dummy_object (class_type
);
7760 if (name
== complete_dtor_identifier
7761 || name
== base_dtor_identifier
7762 || name
== deleting_dtor_identifier
)
7763 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
7765 /* Convert to the base class, if necessary. */
7766 if (!same_type_ignoring_top_level_qualifiers_p
7767 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
7769 if (name
!= ansi_assopname (NOP_EXPR
))
7770 /* For constructors and destructors, either the base is
7771 non-virtual, or it is virtual but we are doing the
7772 conversion from a constructor or destructor for the
7773 complete object. In either case, we can convert
7775 instance
= convert_to_base_statically (instance
, binfo
);
7777 /* However, for assignment operators, we must convert
7778 dynamically if the base is virtual. */
7779 instance
= build_base_path (PLUS_EXPR
, instance
,
7780 binfo
, /*nonnull=*/1, complain
);
7784 gcc_assert (instance
!= NULL_TREE
);
7786 fns
= lookup_fnfields (binfo
, name
, 1);
7788 /* When making a call to a constructor or destructor for a subobject
7789 that uses virtual base classes, pass down a pointer to a VTT for
7791 if ((name
== base_ctor_identifier
7792 || name
== base_dtor_identifier
)
7793 && CLASSTYPE_VBASECLASSES (class_type
))
7798 /* If the current function is a complete object constructor
7799 or destructor, then we fetch the VTT directly.
7800 Otherwise, we look it up using the VTT we were given. */
7801 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
7802 vtt
= decay_conversion (vtt
, complain
);
7803 if (vtt
== error_mark_node
)
7804 return error_mark_node
;
7805 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
7806 build2 (EQ_EXPR
, boolean_type_node
,
7807 current_in_charge_parm
, integer_zero_node
),
7810 if (BINFO_SUBVTT_INDEX (binfo
))
7811 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
7817 allocated
= make_tree_vector ();
7821 vec_safe_insert (*args
, 0, sub_vtt
);
7824 ret
= build_new_method_call (instance
, fns
, args
,
7825 TYPE_BINFO (BINFO_TYPE (binfo
)),
7829 if (allocated
!= NULL
)
7830 release_tree_vector (allocated
);
7832 if ((complain
& tf_error
)
7833 && (flags
& LOOKUP_DELEGATING_CONS
)
7834 && name
== complete_ctor_identifier
7835 && TREE_CODE (ret
) == CALL_EXPR
7836 && (DECL_ABSTRACT_ORIGIN (TREE_OPERAND (CALL_EXPR_FN (ret
), 0))
7837 == current_function_decl
))
7838 error ("constructor delegates to itself");
7843 /* Return the NAME, as a C string. The NAME indicates a function that
7844 is a member of TYPE. *FREE_P is set to true if the caller must
7845 free the memory returned.
7847 Rather than go through all of this, we should simply set the names
7848 of constructors and destructors appropriately, and dispense with
7849 ctor_identifier, dtor_identifier, etc. */
7852 name_as_c_string (tree name
, tree type
, bool *free_p
)
7856 /* Assume that we will not allocate memory. */
7858 /* Constructors and destructors are special. */
7859 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7862 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
7863 /* For a destructor, add the '~'. */
7864 if (name
== complete_dtor_identifier
7865 || name
== base_dtor_identifier
7866 || name
== deleting_dtor_identifier
)
7868 pretty_name
= concat ("~", pretty_name
, NULL
);
7869 /* Remember that we need to free the memory allocated. */
7873 else if (IDENTIFIER_TYPENAME_P (name
))
7875 pretty_name
= concat ("operator ",
7876 type_as_string_translate (TREE_TYPE (name
),
7877 TFF_PLAIN_IDENTIFIER
),
7879 /* Remember that we need to free the memory allocated. */
7883 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
7888 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
7889 be set, upon return, to the function called. ARGS may be NULL.
7890 This may change ARGS. */
7893 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
7894 tree conversion_path
, int flags
,
7895 tree
*fn_p
, tsubst_flags_t complain
)
7897 struct z_candidate
*candidates
= 0, *cand
;
7898 tree explicit_targs
= NULL_TREE
;
7899 tree basetype
= NULL_TREE
;
7900 tree access_binfo
, binfo
;
7902 tree first_mem_arg
= NULL_TREE
;
7904 bool skip_first_for_error
;
7905 vec
<tree
, va_gc
> *user_args
;
7908 int template_only
= 0;
7912 vec
<tree
, va_gc
> *orig_args
= NULL
;
7915 gcc_assert (instance
!= NULL_TREE
);
7917 /* We don't know what function we're going to call, yet. */
7921 if (error_operand_p (instance
)
7922 || !fns
|| error_operand_p (fns
))
7923 return error_mark_node
;
7925 if (!BASELINK_P (fns
))
7927 if (complain
& tf_error
)
7928 error ("call to non-function %qD", fns
);
7929 return error_mark_node
;
7932 orig_instance
= instance
;
7935 /* Dismantle the baselink to collect all the information we need. */
7936 if (!conversion_path
)
7937 conversion_path
= BASELINK_BINFO (fns
);
7938 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
7939 binfo
= BASELINK_BINFO (fns
);
7940 optype
= BASELINK_OPTYPE (fns
);
7941 fns
= BASELINK_FUNCTIONS (fns
);
7942 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
7944 explicit_targs
= TREE_OPERAND (fns
, 1);
7945 fns
= TREE_OPERAND (fns
, 0);
7948 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
7949 || TREE_CODE (fns
) == TEMPLATE_DECL
7950 || TREE_CODE (fns
) == OVERLOAD
);
7951 fn
= get_first_fn (fns
);
7952 name
= DECL_NAME (fn
);
7954 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
7955 gcc_assert (CLASS_TYPE_P (basetype
));
7957 if (processing_template_decl
)
7959 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
7960 instance
= build_non_dependent_expr (instance
);
7962 make_args_non_dependent (*args
);
7965 user_args
= args
== NULL
? NULL
: *args
;
7966 /* Under DR 147 A::A() is an invalid constructor call,
7967 not a functional cast. */
7968 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
7970 if (! (complain
& tf_error
))
7971 return error_mark_node
;
7973 if (permerror (input_location
,
7974 "cannot call constructor %<%T::%D%> directly",
7976 inform (input_location
, "for a function-style cast, remove the "
7977 "redundant %<::%D%>", name
);
7978 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
7983 /* Figure out whether to skip the first argument for the error
7984 message we will display to users if an error occurs. We don't
7985 want to display any compiler-generated arguments. The "this"
7986 pointer hasn't been added yet. However, we must remove the VTT
7987 pointer if this is a call to a base-class constructor or
7989 skip_first_for_error
= false;
7990 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7992 /* Callers should explicitly indicate whether they want to construct
7993 the complete object or just the part without virtual bases. */
7994 gcc_assert (name
!= ctor_identifier
);
7995 /* Similarly for destructors. */
7996 gcc_assert (name
!= dtor_identifier
);
7997 /* Remove the VTT pointer, if present. */
7998 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
7999 && CLASSTYPE_VBASECLASSES (basetype
))
8000 skip_first_for_error
= true;
8003 /* Process the argument list. */
8004 if (args
!= NULL
&& *args
!= NULL
)
8006 *args
= resolve_args (*args
, complain
);
8008 return error_mark_node
;
8011 /* Consider the object argument to be used even if we end up selecting a
8012 static member function. */
8013 instance
= mark_type_use (instance
);
8015 /* It's OK to call destructors and constructors on cv-qualified objects.
8016 Therefore, convert the INSTANCE to the unqualified type, if
8018 if (DECL_DESTRUCTOR_P (fn
)
8019 || DECL_CONSTRUCTOR_P (fn
))
8021 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
8023 instance
= build_this (instance
);
8024 instance
= build_nop (build_pointer_type (basetype
), instance
);
8025 instance
= build_fold_indirect_ref (instance
);
8028 if (DECL_DESTRUCTOR_P (fn
))
8029 name
= complete_dtor_identifier
;
8031 /* For the overload resolution we need to find the actual `this`
8032 that would be captured if the call turns out to be to a
8033 non-static member function. Do not actually capture it at this
8035 if (DECL_CONSTRUCTOR_P (fn
))
8036 /* Constructors don't use the enclosing 'this'. */
8037 first_mem_arg
= instance
;
8039 first_mem_arg
= maybe_resolve_dummy (instance
, false);
8041 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8042 p
= conversion_obstack_alloc (0);
8044 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
8045 initializer, not T({ }). */
8046 if (DECL_CONSTRUCTOR_P (fn
) && args
!= NULL
&& !vec_safe_is_empty (*args
)
8047 && DIRECT_LIST_INIT_P ((**args
)[0]))
8049 tree init_list
= (**args
)[0];
8050 tree init
= NULL_TREE
;
8052 gcc_assert ((*args
)->length () == 1
8053 && !(flags
& LOOKUP_ONLYCONVERTING
));
8055 /* If the initializer list has no elements and T is a class type with
8056 a default constructor, the object is value-initialized. Handle
8057 this here so we don't need to handle it wherever we use
8058 build_special_member_call. */
8059 if (CONSTRUCTOR_NELTS (init_list
) == 0
8060 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
8061 /* For a user-provided default constructor, use the normal
8062 mechanisms so that protected access works. */
8063 && type_has_non_user_provided_default_constructor (basetype
)
8064 && !processing_template_decl
)
8065 init
= build_value_init (basetype
, complain
);
8067 /* If BASETYPE is an aggregate, we need to do aggregate
8069 else if (CP_AGGREGATE_TYPE_P (basetype
))
8070 init
= digest_init (basetype
, init_list
, complain
);
8074 if (is_dummy_object (instance
))
8075 return get_target_expr_sfinae (init
, complain
);
8076 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
8077 TREE_SIDE_EFFECTS (init
) = true;
8081 /* Otherwise go ahead with overload resolution. */
8082 add_list_candidates (fns
, first_mem_arg
, init_list
,
8083 basetype
, explicit_targs
, template_only
,
8084 conversion_path
, access_binfo
, flags
,
8085 &candidates
, complain
);
8089 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
8090 explicit_targs
, template_only
, conversion_path
,
8091 access_binfo
, flags
, &candidates
, complain
);
8093 any_viable_p
= false;
8094 candidates
= splice_viable (candidates
, false, &any_viable_p
);
8098 if (complain
& tf_error
)
8100 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
8101 cxx_incomplete_type_error (instance
, basetype
);
8103 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
8104 basetype
, optype
, build_tree_list_vec (user_args
),
8105 TREE_TYPE (instance
));
8112 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8113 arglist
= build_tree_list_vec (user_args
);
8114 if (skip_first_for_error
)
8115 arglist
= TREE_CHAIN (arglist
);
8116 error ("no matching function for call to %<%T::%s(%A)%#V%>",
8117 basetype
, pretty_name
, arglist
,
8118 TREE_TYPE (instance
));
8122 print_z_candidates (location_of (name
), candidates
);
8124 call
= error_mark_node
;
8128 cand
= tourney (candidates
, complain
);
8135 if (complain
& tf_error
)
8137 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
8138 arglist
= build_tree_list_vec (user_args
);
8139 if (skip_first_for_error
)
8140 arglist
= TREE_CHAIN (arglist
);
8141 if (!any_strictly_viable (candidates
))
8142 error ("no matching function for call to %<%s(%A)%>",
8143 pretty_name
, arglist
);
8145 error ("call of overloaded %<%s(%A)%> is ambiguous",
8146 pretty_name
, arglist
);
8147 print_z_candidates (location_of (name
), candidates
);
8151 call
= error_mark_node
;
8158 if (!(flags
& LOOKUP_NONVIRTUAL
)
8159 && DECL_PURE_VIRTUAL_P (fn
)
8160 && instance
== current_class_ref
8161 && (complain
& tf_warning
))
8163 /* This is not an error, it is runtime undefined
8165 if (!current_function_decl
)
8166 warning (0, "pure virtual %q#D called from "
8167 "non-static data member initializer", fn
);
8168 else if (DECL_CONSTRUCTOR_P (current_function_decl
)
8169 || DECL_DESTRUCTOR_P (current_function_decl
))
8170 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
)
8171 ? "pure virtual %q#D called from constructor"
8172 : "pure virtual %q#D called from destructor"),
8176 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
8177 && !DECL_CONSTRUCTOR_P (fn
)
8178 && is_dummy_object (instance
))
8180 instance
= maybe_resolve_dummy (instance
, true);
8181 if (instance
== error_mark_node
)
8182 call
= error_mark_node
;
8183 else if (!is_dummy_object (instance
))
8185 /* We captured 'this' in the current lambda now that
8186 we know we really need it. */
8187 cand
->first_arg
= instance
;
8191 if (complain
& tf_error
)
8192 error ("cannot call member function %qD without object",
8194 call
= error_mark_node
;
8198 if (call
!= error_mark_node
)
8200 /* Optimize away vtable lookup if we know that this
8201 function can't be overridden. We need to check if
8202 the context and the type where we found fn are the same,
8203 actually FN might be defined in a different class
8204 type because of a using-declaration. In this case, we
8205 do not want to perform a non-virtual call. */
8206 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
8207 && same_type_ignoring_top_level_qualifiers_p
8208 (DECL_CONTEXT (fn
), BINFO_TYPE (binfo
))
8209 && resolves_to_fixed_type_p (instance
, 0))
8210 flags
|= LOOKUP_NONVIRTUAL
;
8212 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
8213 /* Now we know what function is being called. */
8216 /* Build the actual CALL_EXPR. */
8217 call
= build_over_call (cand
, flags
, complain
);
8218 /* In an expression of the form `a->f()' where `f' turns
8219 out to be a static member function, `a' is
8220 none-the-less evaluated. */
8221 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
8222 && !is_dummy_object (instance
)
8223 && TREE_SIDE_EFFECTS (instance
))
8224 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
8226 else if (call
!= error_mark_node
8227 && DECL_DESTRUCTOR_P (cand
->fn
)
8228 && !VOID_TYPE_P (TREE_TYPE (call
)))
8229 /* An explicit call of the form "x->~X()" has type
8230 "void". However, on platforms where destructors
8231 return "this" (i.e., those where
8232 targetm.cxx.cdtor_returns_this is true), such calls
8233 will appear to have a return value of pointer type
8234 to the low-level call machinery. We do not want to
8235 change the low-level machinery, since we want to be
8236 able to optimize "delete f()" on such platforms as
8237 "operator delete(~X(f()))" (rather than generating
8238 "t = f(), ~X(t), operator delete (t)"). */
8239 call
= build_nop (void_type_node
, call
);
8244 if (processing_template_decl
&& call
!= error_mark_node
)
8246 bool cast_to_void
= false;
8248 if (TREE_CODE (call
) == COMPOUND_EXPR
)
8249 call
= TREE_OPERAND (call
, 1);
8250 else if (TREE_CODE (call
) == NOP_EXPR
)
8252 cast_to_void
= true;
8253 call
= TREE_OPERAND (call
, 0);
8255 if (INDIRECT_REF_P (call
))
8256 call
= TREE_OPERAND (call
, 0);
8257 call
= (build_min_non_dep_call_vec
8259 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
8260 orig_instance
, orig_fns
, NULL_TREE
),
8262 SET_EXPR_LOCATION (call
, input_location
);
8263 call
= convert_from_reference (call
);
8265 call
= build_nop (void_type_node
, call
);
8268 /* Free all the conversions we allocated. */
8269 obstack_free (&conversion_obstack
, p
);
8271 if (orig_args
!= NULL
)
8272 release_tree_vector (orig_args
);
8277 /* Wrapper for above. */
8280 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
8281 tree conversion_path
, int flags
,
8282 tree
*fn_p
, tsubst_flags_t complain
)
8285 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
8286 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
8288 timevar_cond_stop (TV_OVERLOAD
, subtime
);
8292 /* Returns true iff standard conversion sequence ICS1 is a proper
8293 subsequence of ICS2. */
8296 is_subseq (conversion
*ics1
, conversion
*ics2
)
8298 /* We can assume that a conversion of the same code
8299 between the same types indicates a subsequence since we only get
8300 here if the types we are converting from are the same. */
8302 while (ics1
->kind
== ck_rvalue
8303 || ics1
->kind
== ck_lvalue
)
8304 ics1
= next_conversion (ics1
);
8308 while (ics2
->kind
== ck_rvalue
8309 || ics2
->kind
== ck_lvalue
)
8310 ics2
= next_conversion (ics2
);
8312 if (ics2
->kind
== ck_user
8313 || ics2
->kind
== ck_ambig
8314 || ics2
->kind
== ck_aggr
8315 || ics2
->kind
== ck_list
8316 || ics2
->kind
== ck_identity
)
8317 /* At this point, ICS1 cannot be a proper subsequence of
8318 ICS2. We can get a USER_CONV when we are comparing the
8319 second standard conversion sequence of two user conversion
8323 ics2
= next_conversion (ics2
);
8325 if (ics2
->kind
== ics1
->kind
8326 && same_type_p (ics2
->type
, ics1
->type
)
8327 && same_type_p (next_conversion (ics2
)->type
,
8328 next_conversion (ics1
)->type
))
8333 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
8334 be any _TYPE nodes. */
8337 is_properly_derived_from (tree derived
, tree base
)
8339 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
8342 /* We only allow proper derivation here. The DERIVED_FROM_P macro
8343 considers every class derived from itself. */
8344 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
8345 && DERIVED_FROM_P (base
, derived
));
8348 /* We build the ICS for an implicit object parameter as a pointer
8349 conversion sequence. However, such a sequence should be compared
8350 as if it were a reference conversion sequence. If ICS is the
8351 implicit conversion sequence for an implicit object parameter,
8352 modify it accordingly. */
8355 maybe_handle_implicit_object (conversion
**ics
)
8359 /* [over.match.funcs]
8361 For non-static member functions, the type of the
8362 implicit object parameter is "reference to cv X"
8363 where X is the class of which the function is a
8364 member and cv is the cv-qualification on the member
8365 function declaration. */
8366 conversion
*t
= *ics
;
8367 tree reference_type
;
8369 /* The `this' parameter is a pointer to a class type. Make the
8370 implicit conversion talk about a reference to that same class
8372 reference_type
= TREE_TYPE (t
->type
);
8373 reference_type
= build_reference_type (reference_type
);
8375 if (t
->kind
== ck_qual
)
8376 t
= next_conversion (t
);
8377 if (t
->kind
== ck_ptr
)
8378 t
= next_conversion (t
);
8379 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
8380 t
= direct_reference_binding (reference_type
, t
);
8382 t
->rvaluedness_matches_p
= 0;
8387 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
8388 and return the initial reference binding conversion. Otherwise,
8389 leave *ICS unchanged and return NULL. */
8392 maybe_handle_ref_bind (conversion
**ics
)
8394 if ((*ics
)->kind
== ck_ref_bind
)
8396 conversion
*old_ics
= *ics
;
8397 *ics
= next_conversion (old_ics
);
8398 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
8405 /* Compare two implicit conversion sequences according to the rules set out in
8406 [over.ics.rank]. Return values:
8408 1: ics1 is better than ics2
8409 -1: ics2 is better than ics1
8410 0: ics1 and ics2 are indistinguishable */
8413 compare_ics (conversion
*ics1
, conversion
*ics2
)
8419 tree deref_from_type1
= NULL_TREE
;
8420 tree deref_from_type2
= NULL_TREE
;
8421 tree deref_to_type1
= NULL_TREE
;
8422 tree deref_to_type2
= NULL_TREE
;
8423 conversion_rank rank1
, rank2
;
8425 /* REF_BINDING is nonzero if the result of the conversion sequence
8426 is a reference type. In that case REF_CONV is the reference
8427 binding conversion. */
8428 conversion
*ref_conv1
;
8429 conversion
*ref_conv2
;
8431 /* Compare badness before stripping the reference conversion. */
8432 if (ics1
->bad_p
> ics2
->bad_p
)
8434 else if (ics1
->bad_p
< ics2
->bad_p
)
8437 /* Handle implicit object parameters. */
8438 maybe_handle_implicit_object (&ics1
);
8439 maybe_handle_implicit_object (&ics2
);
8441 /* Handle reference parameters. */
8442 ref_conv1
= maybe_handle_ref_bind (&ics1
);
8443 ref_conv2
= maybe_handle_ref_bind (&ics2
);
8445 /* List-initialization sequence L1 is a better conversion sequence than
8446 list-initialization sequence L2 if L1 converts to
8447 std::initializer_list<X> for some X and L2 does not. */
8448 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
8450 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
8455 When comparing the basic forms of implicit conversion sequences (as
8456 defined in _over.best.ics_)
8458 --a standard conversion sequence (_over.ics.scs_) is a better
8459 conversion sequence than a user-defined conversion sequence
8460 or an ellipsis conversion sequence, and
8462 --a user-defined conversion sequence (_over.ics.user_) is a
8463 better conversion sequence than an ellipsis conversion sequence
8464 (_over.ics.ellipsis_). */
8465 /* Use BAD_CONVERSION_RANK because we already checked for a badness
8466 mismatch. If both ICS are bad, we try to make a decision based on
8467 what would have happened if they'd been good. This is not an
8468 extension, we'll still give an error when we build up the call; this
8469 just helps us give a more helpful error message. */
8470 rank1
= BAD_CONVERSION_RANK (ics1
);
8471 rank2
= BAD_CONVERSION_RANK (ics2
);
8475 else if (rank1
< rank2
)
8478 if (ics1
->ellipsis_p
)
8479 /* Both conversions are ellipsis conversions. */
8482 /* User-defined conversion sequence U1 is a better conversion sequence
8483 than another user-defined conversion sequence U2 if they contain the
8484 same user-defined conversion operator or constructor and if the sec-
8485 ond standard conversion sequence of U1 is better than the second
8486 standard conversion sequence of U2. */
8488 /* Handle list-conversion with the same code even though it isn't always
8489 ranked as a user-defined conversion and it doesn't have a second
8490 standard conversion sequence; it will still have the desired effect.
8491 Specifically, we need to do the reference binding comparison at the
8492 end of this function. */
8494 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
8499 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
8500 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
8501 || t1
->kind
== ck_list
)
8503 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
8504 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
8505 || t2
->kind
== ck_list
)
8508 if (t1
->kind
!= t2
->kind
)
8510 else if (t1
->kind
== ck_user
)
8512 if (t1
->cand
->fn
!= t2
->cand
->fn
)
8517 /* For ambiguous or aggregate conversions, use the target type as
8518 a proxy for the conversion function. */
8519 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
8523 /* We can just fall through here, after setting up
8524 FROM_TYPE1 and FROM_TYPE2. */
8525 from_type1
= t1
->type
;
8526 from_type2
= t2
->type
;
8533 /* We're dealing with two standard conversion sequences.
8537 Standard conversion sequence S1 is a better conversion
8538 sequence than standard conversion sequence S2 if
8540 --S1 is a proper subsequence of S2 (comparing the conversion
8541 sequences in the canonical form defined by _over.ics.scs_,
8542 excluding any Lvalue Transformation; the identity
8543 conversion sequence is considered to be a subsequence of
8544 any non-identity conversion sequence */
8547 while (t1
->kind
!= ck_identity
)
8548 t1
= next_conversion (t1
);
8549 from_type1
= t1
->type
;
8552 while (t2
->kind
!= ck_identity
)
8553 t2
= next_conversion (t2
);
8554 from_type2
= t2
->type
;
8557 /* One sequence can only be a subsequence of the other if they start with
8558 the same type. They can start with different types when comparing the
8559 second standard conversion sequence in two user-defined conversion
8561 if (same_type_p (from_type1
, from_type2
))
8563 if (is_subseq (ics1
, ics2
))
8565 if (is_subseq (ics2
, ics1
))
8573 --the rank of S1 is better than the rank of S2 (by the rules
8576 Standard conversion sequences are ordered by their ranks: an Exact
8577 Match is a better conversion than a Promotion, which is a better
8578 conversion than a Conversion.
8580 Two conversion sequences with the same rank are indistinguishable
8581 unless one of the following rules applies:
8583 --A conversion that does not a convert a pointer, pointer to member,
8584 or std::nullptr_t to bool is better than one that does.
8586 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8587 so that we do not have to check it explicitly. */
8588 if (ics1
->rank
< ics2
->rank
)
8590 else if (ics2
->rank
< ics1
->rank
)
8593 to_type1
= ics1
->type
;
8594 to_type2
= ics2
->type
;
8596 /* A conversion from scalar arithmetic type to complex is worse than a
8597 conversion between scalar arithmetic types. */
8598 if (same_type_p (from_type1
, from_type2
)
8599 && ARITHMETIC_TYPE_P (from_type1
)
8600 && ARITHMETIC_TYPE_P (to_type1
)
8601 && ARITHMETIC_TYPE_P (to_type2
)
8602 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8603 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
8605 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8611 if (TYPE_PTR_P (from_type1
)
8612 && TYPE_PTR_P (from_type2
)
8613 && TYPE_PTR_P (to_type1
)
8614 && TYPE_PTR_P (to_type2
))
8616 deref_from_type1
= TREE_TYPE (from_type1
);
8617 deref_from_type2
= TREE_TYPE (from_type2
);
8618 deref_to_type1
= TREE_TYPE (to_type1
);
8619 deref_to_type2
= TREE_TYPE (to_type2
);
8621 /* The rules for pointers to members A::* are just like the rules
8622 for pointers A*, except opposite: if B is derived from A then
8623 A::* converts to B::*, not vice versa. For that reason, we
8624 switch the from_ and to_ variables here. */
8625 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
8626 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
8627 || (TYPE_PTRMEMFUNC_P (from_type1
)
8628 && TYPE_PTRMEMFUNC_P (from_type2
)
8629 && TYPE_PTRMEMFUNC_P (to_type1
)
8630 && TYPE_PTRMEMFUNC_P (to_type2
)))
8632 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
8633 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
8634 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
8635 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
8638 if (deref_from_type1
!= NULL_TREE
8639 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
8640 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
8642 /* This was one of the pointer or pointer-like conversions.
8646 --If class B is derived directly or indirectly from class A,
8647 conversion of B* to A* is better than conversion of B* to
8648 void*, and conversion of A* to void* is better than
8649 conversion of B* to void*. */
8650 if (VOID_TYPE_P (deref_to_type1
)
8651 && VOID_TYPE_P (deref_to_type2
))
8653 if (is_properly_derived_from (deref_from_type1
,
8656 else if (is_properly_derived_from (deref_from_type2
,
8660 else if (VOID_TYPE_P (deref_to_type1
)
8661 || VOID_TYPE_P (deref_to_type2
))
8663 if (same_type_p (deref_from_type1
, deref_from_type2
))
8665 if (VOID_TYPE_P (deref_to_type2
))
8667 if (is_properly_derived_from (deref_from_type1
,
8671 /* We know that DEREF_TO_TYPE1 is `void' here. */
8672 else if (is_properly_derived_from (deref_from_type1
,
8677 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
8678 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
8682 --If class B is derived directly or indirectly from class A
8683 and class C is derived directly or indirectly from B,
8685 --conversion of C* to B* is better than conversion of C* to
8688 --conversion of B* to A* is better than conversion of C* to
8690 if (same_type_p (deref_from_type1
, deref_from_type2
))
8692 if (is_properly_derived_from (deref_to_type1
,
8695 else if (is_properly_derived_from (deref_to_type2
,
8699 else if (same_type_p (deref_to_type1
, deref_to_type2
))
8701 if (is_properly_derived_from (deref_from_type2
,
8704 else if (is_properly_derived_from (deref_from_type1
,
8710 else if (CLASS_TYPE_P (non_reference (from_type1
))
8711 && same_type_p (from_type1
, from_type2
))
8713 tree from
= non_reference (from_type1
);
8717 --binding of an expression of type C to a reference of type
8718 B& is better than binding an expression of type C to a
8719 reference of type A&
8721 --conversion of C to B is better than conversion of C to A, */
8722 if (is_properly_derived_from (from
, to_type1
)
8723 && is_properly_derived_from (from
, to_type2
))
8725 if (is_properly_derived_from (to_type1
, to_type2
))
8727 else if (is_properly_derived_from (to_type2
, to_type1
))
8731 else if (CLASS_TYPE_P (non_reference (to_type1
))
8732 && same_type_p (to_type1
, to_type2
))
8734 tree to
= non_reference (to_type1
);
8738 --binding of an expression of type B to a reference of type
8739 A& is better than binding an expression of type C to a
8740 reference of type A&,
8742 --conversion of B to A is better than conversion of C to A */
8743 if (is_properly_derived_from (from_type1
, to
)
8744 && is_properly_derived_from (from_type2
, to
))
8746 if (is_properly_derived_from (from_type2
, from_type1
))
8748 else if (is_properly_derived_from (from_type1
, from_type2
))
8755 --S1 and S2 differ only in their qualification conversion and yield
8756 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8757 qualification signature of type T1 is a proper subset of the cv-
8758 qualification signature of type T2 */
8759 if (ics1
->kind
== ck_qual
8760 && ics2
->kind
== ck_qual
8761 && same_type_p (from_type1
, from_type2
))
8763 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
8770 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8771 to an implicit object parameter of a non-static member function
8772 declared without a ref-qualifier, and either S1 binds an lvalue
8773 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
8774 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
8775 draft standard, 13.3.3.2)
8777 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8778 types to which the references refer are the same type except for
8779 top-level cv-qualifiers, and the type to which the reference
8780 initialized by S2 refers is more cv-qualified than the type to
8781 which the reference initialized by S1 refers.
8783 DR 1328 [over.match.best]: the context is an initialization by
8784 conversion function for direct reference binding (13.3.1.6) of a
8785 reference to function type, the return type of F1 is the same kind of
8786 reference (i.e. lvalue or rvalue) as the reference being initialized,
8787 and the return type of F2 is not. */
8789 if (ref_conv1
&& ref_conv2
)
8791 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
8792 && (ref_conv1
->rvaluedness_matches_p
8793 != ref_conv2
->rvaluedness_matches_p
)
8794 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
8795 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
8796 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
8798 if (ref_conv1
->bad_p
8799 && !same_type_p (TREE_TYPE (ref_conv1
->type
),
8800 TREE_TYPE (ref_conv2
->type
)))
8801 /* Don't prefer a bad conversion that drops cv-quals to a bad
8802 conversion with the wrong rvalueness. */
8804 return (ref_conv1
->rvaluedness_matches_p
8805 - ref_conv2
->rvaluedness_matches_p
);
8808 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
8810 int q1
= cp_type_quals (TREE_TYPE (ref_conv1
->type
));
8811 int q2
= cp_type_quals (TREE_TYPE (ref_conv2
->type
));
8812 if (ref_conv1
->bad_p
)
8814 /* Prefer the one that drops fewer cv-quals. */
8815 tree ftype
= next_conversion (ref_conv1
)->type
;
8816 int fquals
= cp_type_quals (ftype
);
8820 return comp_cv_qualification (q2
, q1
);
8824 /* Neither conversion sequence is better than the other. */
8828 /* The source type for this standard conversion sequence. */
8831 source_type (conversion
*t
)
8833 for (;; t
= next_conversion (t
))
8835 if (t
->kind
== ck_user
8836 || t
->kind
== ck_ambig
8837 || t
->kind
== ck_identity
)
8843 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8844 a pointer to LOSER and re-running joust to produce the warning if WINNER
8845 is actually used. */
8848 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
8850 candidate_warning
*cw
= (candidate_warning
*)
8851 conversion_obstack_alloc (sizeof (candidate_warning
));
8853 cw
->next
= winner
->warnings
;
8854 winner
->warnings
= cw
;
8857 /* Compare two candidates for overloading as described in
8858 [over.match.best]. Return values:
8860 1: cand1 is better than cand2
8861 -1: cand2 is better than cand1
8862 0: cand1 and cand2 are indistinguishable */
8865 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
8866 tsubst_flags_t complain
)
8869 int off1
= 0, off2
= 0;
8873 /* Candidates that involve bad conversions are always worse than those
8875 if (cand1
->viable
> cand2
->viable
)
8877 if (cand1
->viable
< cand2
->viable
)
8880 /* If we have two pseudo-candidates for conversions to the same type,
8881 or two candidates for the same function, arbitrarily pick one. */
8882 if (cand1
->fn
== cand2
->fn
8883 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
8886 /* Prefer a non-deleted function over an implicitly deleted move
8887 constructor or assignment operator. This differs slightly from the
8888 wording for issue 1402 (which says the move op is ignored by overload
8889 resolution), but this way produces better error messages. */
8890 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
8891 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
8892 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
8894 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
8895 && move_fn_p (cand1
->fn
))
8897 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
8898 && move_fn_p (cand2
->fn
))
8902 /* a viable function F1
8903 is defined to be a better function than another viable function F2 if
8904 for all arguments i, ICSi(F1) is not a worse conversion sequence than
8905 ICSi(F2), and then */
8907 /* for some argument j, ICSj(F1) is a better conversion sequence than
8910 /* For comparing static and non-static member functions, we ignore
8911 the implicit object parameter of the non-static function. The
8912 standard says to pretend that the static function has an object
8913 parm, but that won't work with operator overloading. */
8914 len
= cand1
->num_convs
;
8915 if (len
!= cand2
->num_convs
)
8917 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
8918 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
8920 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
8921 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
8922 /* We're comparing a near-match list constructor and a near-match
8923 non-list constructor. Just treat them as unordered. */
8926 gcc_assert (static_1
!= static_2
);
8937 for (i
= 0; i
< len
; ++i
)
8939 conversion
*t1
= cand1
->convs
[i
+ off1
];
8940 conversion
*t2
= cand2
->convs
[i
+ off2
];
8941 int comp
= compare_ics (t1
, t2
);
8945 if ((complain
& tf_warning
)
8947 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
8948 == cr_std
+ cr_promotion
)
8949 && t1
->kind
== ck_std
8950 && t2
->kind
== ck_std
8951 && TREE_CODE (t1
->type
) == INTEGER_TYPE
8952 && TREE_CODE (t2
->type
) == INTEGER_TYPE
8953 && (TYPE_PRECISION (t1
->type
)
8954 == TYPE_PRECISION (t2
->type
))
8955 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
8956 || (TREE_CODE (next_conversion (t1
)->type
)
8959 tree type
= next_conversion (t1
)->type
;
8961 struct z_candidate
*w
, *l
;
8963 type1
= t1
->type
, type2
= t2
->type
,
8964 w
= cand1
, l
= cand2
;
8966 type1
= t2
->type
, type2
= t1
->type
,
8967 w
= cand2
, l
= cand1
;
8971 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
8972 type
, type1
, type2
);
8973 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
8979 if (winner
&& comp
!= winner
)
8988 /* warn about confusing overload resolution for user-defined conversions,
8989 either between a constructor and a conversion op, or between two
8991 if ((complain
& tf_warning
)
8992 && winner
&& warn_conversion
&& cand1
->second_conv
8993 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
8994 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
8996 struct z_candidate
*w
, *l
;
8997 bool give_warning
= false;
9000 w
= cand1
, l
= cand2
;
9002 w
= cand2
, l
= cand1
;
9004 /* We don't want to complain about `X::operator T1 ()'
9005 beating `X::operator T2 () const', when T2 is a no less
9006 cv-qualified version of T1. */
9007 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
9008 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
9010 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
9011 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
9013 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
9018 if (!comp_ptr_ttypes (t
, f
))
9019 give_warning
= true;
9022 give_warning
= true;
9028 tree source
= source_type (w
->convs
[0]);
9029 if (! DECL_CONSTRUCTOR_P (w
->fn
))
9030 source
= TREE_TYPE (source
);
9031 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
9032 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
9033 source
, w
->second_conv
->type
))
9035 inform (input_location
, " because conversion sequence for the argument is better");
9045 /* DR 495 moved this tiebreaker above the template ones. */
9047 the context is an initialization by user-defined conversion (see
9048 _dcl.init_ and _over.match.user_) and the standard conversion
9049 sequence from the return type of F1 to the destination type (i.e.,
9050 the type of the entity being initialized) is a better conversion
9051 sequence than the standard conversion sequence from the return type
9052 of F2 to the destination type. */
9054 if (cand1
->second_conv
)
9056 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
9062 F1 is a non-template function and F2 is a template function
9065 if (!cand1
->template_decl
&& cand2
->template_decl
)
9067 else if (cand1
->template_decl
&& !cand2
->template_decl
)
9071 F1 and F2 are template functions and the function template for F1 is
9072 more specialized than the template for F2 according to the partial
9075 if (cand1
->template_decl
&& cand2
->template_decl
)
9077 winner
= more_specialized_fn
9078 (TI_TEMPLATE (cand1
->template_decl
),
9079 TI_TEMPLATE (cand2
->template_decl
),
9080 /* [temp.func.order]: The presence of unused ellipsis and default
9081 arguments has no effect on the partial ordering of function
9082 templates. add_function_candidate() will not have
9083 counted the "this" argument for constructors. */
9084 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
9089 /* Check whether we can discard a builtin candidate, either because we
9090 have two identical ones or matching builtin and non-builtin candidates.
9092 (Pedantically in the latter case the builtin which matched the user
9093 function should not be added to the overload set, but we spot it here.
9096 ... the builtin candidates include ...
9097 - do not have the same parameter type list as any non-template
9098 non-member candidate. */
9100 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
9102 for (i
= 0; i
< len
; ++i
)
9103 if (!same_type_p (cand1
->convs
[i
]->type
,
9104 cand2
->convs
[i
]->type
))
9106 if (i
== cand1
->num_convs
)
9108 if (cand1
->fn
== cand2
->fn
)
9109 /* Two built-in candidates; arbitrarily pick one. */
9111 else if (identifier_p (cand1
->fn
))
9112 /* cand1 is built-in; prefer cand2. */
9115 /* cand2 is built-in; prefer cand1. */
9120 /* For candidates of a multi-versioned function, make the version with
9121 the highest priority win. This version will be checked for dispatching
9122 first. If this version can be inlined into the caller, the front-end
9123 will simply make a direct call to this function. */
9125 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
9126 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
9127 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
9128 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
9130 tree f1
= TREE_TYPE (cand1
->fn
);
9131 tree f2
= TREE_TYPE (cand2
->fn
);
9132 tree p1
= TYPE_ARG_TYPES (f1
);
9133 tree p2
= TYPE_ARG_TYPES (f2
);
9135 /* Check if cand1->fn and cand2->fn are versions of the same function. It
9136 is possible that cand1->fn and cand2->fn are function versions but of
9137 different functions. Check types to see if they are versions of the same
9139 if (compparms (p1
, p2
)
9140 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
9142 /* Always make the version with the higher priority, more
9143 specialized, win. */
9144 gcc_assert (targetm
.compare_version_priority
);
9145 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
9152 /* If the two function declarations represent the same function (this can
9153 happen with declarations in multiple scopes and arg-dependent lookup),
9154 arbitrarily choose one. But first make sure the default args we're
9156 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
9157 && equal_functions (cand1
->fn
, cand2
->fn
))
9159 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
9160 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
9162 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
9164 for (i
= 0; i
< len
; ++i
)
9166 /* Don't crash if the fn is variadic. */
9169 parms1
= TREE_CHAIN (parms1
);
9170 parms2
= TREE_CHAIN (parms2
);
9174 parms1
= TREE_CHAIN (parms1
);
9176 parms2
= TREE_CHAIN (parms2
);
9180 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
9181 TREE_PURPOSE (parms2
)))
9185 if (complain
& tf_error
)
9187 if (permerror (input_location
,
9188 "default argument mismatch in "
9189 "overload resolution"))
9191 inform (input_location
,
9192 " candidate 1: %q+#F", cand1
->fn
);
9193 inform (input_location
,
9194 " candidate 2: %q+#F", cand2
->fn
);
9201 add_warning (cand1
, cand2
);
9204 parms1
= TREE_CHAIN (parms1
);
9205 parms2
= TREE_CHAIN (parms2
);
9213 /* Extension: If the worst conversion for one candidate is worse than the
9214 worst conversion for the other, take the first. */
9215 if (!pedantic
&& (complain
& tf_warning_or_error
))
9217 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
9218 struct z_candidate
*w
= 0, *l
= 0;
9220 for (i
= 0; i
< len
; ++i
)
9222 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
9223 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
9224 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
9225 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
9228 winner
= 1, w
= cand1
, l
= cand2
;
9230 winner
= -1, w
= cand2
, l
= cand1
;
9233 /* Don't choose a deleted function over ambiguity. */
9234 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
9238 pedwarn (input_location
, 0,
9239 "ISO C++ says that these are ambiguous, even "
9240 "though the worst conversion for the first is better than "
9241 "the worst conversion for the second:");
9242 print_z_candidate (input_location
, _("candidate 1:"), w
);
9243 print_z_candidate (input_location
, _("candidate 2:"), l
);
9251 gcc_assert (!winner
);
9255 /* Given a list of candidates for overloading, find the best one, if any.
9256 This algorithm has a worst case of O(2n) (winner is last), and a best
9257 case of O(n/2) (totally ambiguous); much better than a sorting
9260 static struct z_candidate
*
9261 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
9263 struct z_candidate
*champ
= candidates
, *challenger
;
9265 int champ_compared_to_predecessor
= 0;
9267 /* Walk through the list once, comparing each current champ to the next
9268 candidate, knocking out a candidate or two with each comparison. */
9270 for (challenger
= champ
->next
; challenger
; )
9272 fate
= joust (champ
, challenger
, 0, complain
);
9274 challenger
= challenger
->next
;
9279 champ
= challenger
->next
;
9282 champ_compared_to_predecessor
= 0;
9287 champ_compared_to_predecessor
= 1;
9290 challenger
= champ
->next
;
9294 /* Make sure the champ is better than all the candidates it hasn't yet
9295 been compared to. */
9297 for (challenger
= candidates
;
9299 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
9300 challenger
= challenger
->next
)
9302 fate
= joust (champ
, challenger
, 0, complain
);
9310 /* Returns nonzero if things of type FROM can be converted to TO. */
9313 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
9315 tree arg
= NULL_TREE
;
9316 /* implicit_conversion only considers user-defined conversions
9317 if it has an expression for the call argument list. */
9318 if (CLASS_TYPE_P (from
) || CLASS_TYPE_P (to
))
9319 arg
= build1 (CAST_EXPR
, from
, NULL_TREE
);
9320 return can_convert_arg (to
, from
, arg
, LOOKUP_IMPLICIT
, complain
);
9323 /* Returns nonzero if things of type FROM can be converted to TO with a
9324 standard conversion. */
9327 can_convert_standard (tree to
, tree from
, tsubst_flags_t complain
)
9329 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
9332 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
9335 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
9336 tsubst_flags_t complain
)
9342 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9343 p
= conversion_obstack_alloc (0);
9344 /* We want to discard any access checks done for this test,
9345 as we might not be in the appropriate access context and
9346 we'll do the check again when we actually perform the
9348 push_deferring_access_checks (dk_deferred
);
9350 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9352 ok_p
= (t
&& !t
->bad_p
);
9354 /* Discard the access checks now. */
9355 pop_deferring_access_checks ();
9356 /* Free all the conversions we allocated. */
9357 obstack_free (&conversion_obstack
, p
);
9362 /* Like can_convert_arg, but allows dubious conversions as well. */
9365 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
9366 tsubst_flags_t complain
)
9371 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9372 p
= conversion_obstack_alloc (0);
9373 /* Try to perform the conversion. */
9374 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
9376 /* Free all the conversions we allocated. */
9377 obstack_free (&conversion_obstack
, p
);
9382 /* Convert EXPR to TYPE. Return the converted expression.
9384 Note that we allow bad conversions here because by the time we get to
9385 this point we are committed to doing the conversion. If we end up
9386 doing a bad conversion, convert_like will complain. */
9389 perform_implicit_conversion_flags (tree type
, tree expr
,
9390 tsubst_flags_t complain
, int flags
)
9394 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9396 if (error_operand_p (expr
))
9397 return error_mark_node
;
9399 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9400 p
= conversion_obstack_alloc (0);
9402 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9408 if (complain
& tf_error
)
9410 /* If expr has unknown type, then it is an overloaded function.
9411 Call instantiate_type to get good error messages. */
9412 if (TREE_TYPE (expr
) == unknown_type_node
)
9413 instantiate_type (type
, expr
, complain
);
9414 else if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
9415 /* We gave an error. */;
9417 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
9418 TREE_TYPE (expr
), type
);
9420 expr
= error_mark_node
;
9422 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
9424 /* In a template, we are only concerned about determining the
9425 type of non-dependent expressions, so we do not have to
9426 perform the actual conversion. But for initializers, we
9427 need to be able to perform it at instantiation
9428 (or instantiate_non_dependent_expr) time. */
9429 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
9430 if (!(flags
& LOOKUP_ONLYCONVERTING
))
9431 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
9434 expr
= convert_like (conv
, expr
, complain
);
9436 /* Free all the conversions we allocated. */
9437 obstack_free (&conversion_obstack
, p
);
9443 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
9445 return perform_implicit_conversion_flags (type
, expr
, complain
,
9449 /* Convert EXPR to TYPE (as a direct-initialization) if that is
9450 permitted. If the conversion is valid, the converted expression is
9451 returned. Otherwise, NULL_TREE is returned, except in the case
9452 that TYPE is a class type; in that case, an error is issued. If
9453 C_CAST_P is true, then this direct-initialization is taking
9454 place as part of a static_cast being attempted as part of a C-style
9458 perform_direct_initialization_if_possible (tree type
,
9461 tsubst_flags_t complain
)
9466 if (type
== error_mark_node
|| error_operand_p (expr
))
9467 return error_mark_node
;
9470 If the destination type is a (possibly cv-qualified) class type:
9472 -- If the initialization is direct-initialization ...,
9473 constructors are considered. ... If no constructor applies, or
9474 the overload resolution is ambiguous, the initialization is
9476 if (CLASS_TYPE_P (type
))
9478 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
9479 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
9480 &args
, type
, LOOKUP_NORMAL
, complain
);
9481 release_tree_vector (args
);
9482 return build_cplus_new (type
, expr
, complain
);
9485 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9486 p
= conversion_obstack_alloc (0);
9488 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
9490 LOOKUP_NORMAL
, complain
);
9491 if (!conv
|| conv
->bad_p
)
9494 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
9495 /*issue_conversion_warnings=*/false,
9499 /* Free all the conversions we allocated. */
9500 obstack_free (&conversion_obstack
, p
);
9505 /* When initializing a reference that lasts longer than a full-expression,
9506 this special rule applies:
9510 The temporary to which the reference is bound or the temporary
9511 that is the complete object to which the reference is bound
9512 persists for the lifetime of the reference.
9514 The temporaries created during the evaluation of the expression
9515 initializing the reference, except the temporary to which the
9516 reference is bound, are destroyed at the end of the
9517 full-expression in which they are created.
9519 In that case, we store the converted expression into a new
9520 VAR_DECL in a new scope.
9522 However, we want to be careful not to create temporaries when
9523 they are not required. For example, given:
9526 struct D : public B {};
9530 there is no need to copy the return value from "f"; we can just
9531 extend its lifetime. Similarly, given:
9534 struct T { operator S(); };
9538 we can extend the lifetime of the return value of the conversion
9541 The next several functions are involved in this lifetime extension. */
9543 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9544 reference is being bound to a temporary. Create and return a new
9545 VAR_DECL with the indicated TYPE; this variable will store the value to
9546 which the reference is bound. */
9549 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
9553 /* Create the variable. */
9554 var
= create_temporary_var (type
);
9556 /* Register the variable. */
9558 && (TREE_STATIC (decl
) || CP_DECL_THREAD_LOCAL_P (decl
)))
9560 /* Namespace-scope or local static; give it a mangled name. */
9561 /* FIXME share comdat with decl? */
9564 TREE_STATIC (var
) = TREE_STATIC (decl
);
9565 CP_DECL_THREAD_LOCAL_P (var
) = CP_DECL_THREAD_LOCAL_P (decl
);
9566 set_decl_tls_model (var
, DECL_TLS_MODEL (decl
));
9567 name
= mangle_ref_init_variable (decl
);
9568 DECL_NAME (var
) = name
;
9569 SET_DECL_ASSEMBLER_NAME (var
, name
);
9570 var
= pushdecl_top_level (var
);
9573 /* Create a new cleanup level if necessary. */
9574 maybe_push_cleanup_level (type
);
9579 /* EXPR is the initializer for a variable DECL of reference or
9580 std::initializer_list type. Create, push and return a new VAR_DECL
9581 for the initializer so that it will live as long as DECL. Any
9582 cleanup for the new variable is returned through CLEANUP, and the
9583 code to initialize the new variable is returned through INITP. */
9586 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
9593 /* Create the temporary variable. */
9594 type
= TREE_TYPE (expr
);
9595 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
9596 layout_decl (var
, 0);
9597 /* If the rvalue is the result of a function call it will be
9598 a TARGET_EXPR. If it is some other construct (such as a
9599 member access expression where the underlying object is
9600 itself the result of a function call), turn it into a
9601 TARGET_EXPR here. It is important that EXPR be a
9602 TARGET_EXPR below since otherwise the INIT_EXPR will
9603 attempt to make a bitwise copy of EXPR to initialize
9605 if (TREE_CODE (expr
) != TARGET_EXPR
)
9606 expr
= get_target_expr (expr
);
9608 if (TREE_CODE (decl
) == FIELD_DECL
9609 && extra_warnings
&& !TREE_NO_WARNING (decl
))
9611 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
9612 "until the constructor exits", decl
);
9613 TREE_NO_WARNING (decl
) = true;
9616 /* Recursively extend temps in this initializer. */
9617 TARGET_EXPR_INITIAL (expr
)
9618 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
9620 /* Any reference temp has a non-trivial initializer. */
9621 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
9623 /* If the initializer is constant, put it in DECL_INITIAL so we get
9624 static initialization and use in constant expressions. */
9625 init
= maybe_constant_init (expr
);
9626 if (TREE_CONSTANT (init
))
9628 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
9630 /* 5.19 says that a constant expression can include an
9631 lvalue-rvalue conversion applied to "a glvalue of literal type
9632 that refers to a non-volatile temporary object initialized
9633 with a constant expression". Rather than try to communicate
9634 that this VAR_DECL is a temporary, just mark it constexpr.
9636 Currently this is only useful for initializer_list temporaries,
9637 since reference vars can't appear in constant expressions. */
9638 DECL_DECLARED_CONSTEXPR_P (var
) = true;
9639 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
9640 TREE_CONSTANT (var
) = true;
9642 DECL_INITIAL (var
) = init
;
9646 /* Create the INIT_EXPR that will initialize the temporary
9648 init
= split_nonconstant_init (var
, expr
);
9649 if (at_function_scope_p ())
9651 add_decl_expr (var
);
9653 if (TREE_STATIC (var
))
9654 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
9657 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9659 vec_safe_push (*cleanups
, cleanup
);
9662 /* We must be careful to destroy the temporary only
9663 after its initialization has taken place. If the
9664 initialization throws an exception, then the
9665 destructor should not be run. We cannot simply
9666 transform INIT into something like:
9668 (INIT, ({ CLEANUP_STMT; }))
9670 because emit_local_var always treats the
9671 initializer as a full-expression. Thus, the
9672 destructor would run too early; it would run at the
9673 end of initializing the reference variable, rather
9674 than at the end of the block enclosing the
9677 The solution is to pass back a cleanup expression
9678 which the caller is responsible for attaching to
9679 the statement tree. */
9683 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
9684 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9686 if (CP_DECL_THREAD_LOCAL_P (var
))
9687 tls_aggregates
= tree_cons (NULL_TREE
, var
,
9690 static_aggregates
= tree_cons (NULL_TREE
, var
,
9694 /* Check whether the dtor is callable. */
9695 cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9697 /* Avoid -Wunused-variable warning (c++/38958). */
9698 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
9700 TREE_USED (decl
) = DECL_READ_P (decl
) = true;
9706 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9707 initializing a variable of that TYPE. */
9710 initialize_reference (tree type
, tree expr
,
9711 int flags
, tsubst_flags_t complain
)
9715 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
9717 if (type
== error_mark_node
|| error_operand_p (expr
))
9718 return error_mark_node
;
9720 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9721 p
= conversion_obstack_alloc (0);
9723 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
9725 if (!conv
|| conv
->bad_p
)
9727 if (complain
& tf_error
)
9730 convert_like (conv
, expr
, complain
);
9731 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
9732 && !TYPE_REF_IS_RVALUE (type
)
9733 && !real_lvalue_p (expr
))
9734 error_at (loc
, "invalid initialization of non-const reference of "
9735 "type %qT from an rvalue of type %qT",
9736 type
, TREE_TYPE (expr
));
9738 error_at (loc
, "invalid initialization of reference of type "
9739 "%qT from expression of type %qT", type
,
9742 return error_mark_node
;
9745 if (conv
->kind
== ck_ref_bind
)
9746 /* Perform the conversion. */
9747 expr
= convert_like (conv
, expr
, complain
);
9748 else if (conv
->kind
== ck_ambig
)
9749 /* We gave an error in build_user_type_conversion_1. */
9750 expr
= error_mark_node
;
9754 /* Free all the conversions we allocated. */
9755 obstack_free (&conversion_obstack
, p
);
9760 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9761 which is bound either to a reference or a std::initializer_list. */
9764 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9769 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
9771 TREE_OPERAND (sub
, 1)
9772 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
9775 if (TREE_CODE (sub
) != ADDR_EXPR
)
9777 /* Deal with binding to a subobject. */
9778 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
9779 p
= &TREE_OPERAND (*p
, 0);
9780 if (TREE_CODE (*p
) == TARGET_EXPR
)
9782 tree subinit
= NULL_TREE
;
9783 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
9784 recompute_tree_invariant_for_addr_expr (sub
);
9786 init
= fold_convert (TREE_TYPE (init
), sub
);
9788 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
9793 /* INIT is part of the initializer for DECL. If there are any
9794 reference or initializer lists being initialized, extend their
9795 lifetime to match that of DECL. */
9798 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9800 tree type
= TREE_TYPE (init
);
9801 if (processing_template_decl
)
9803 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9804 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
9805 else if (is_std_init_list (type
))
9807 /* The temporary array underlying a std::initializer_list
9808 is handled like a reference temporary. */
9810 if (TREE_CODE (ctor
) == TARGET_EXPR
)
9811 ctor
= TARGET_EXPR_INITIAL (ctor
);
9812 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
9814 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
9815 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
9816 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
9819 else if (TREE_CODE (init
) == CONSTRUCTOR
)
9823 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
9824 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
9825 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
9831 /* Returns true iff an initializer for TYPE could contain temporaries that
9832 need to be extended because they are bound to references or
9833 std::initializer_list. */
9836 type_has_extended_temps (tree type
)
9838 type
= strip_array_types (type
);
9839 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9841 if (CLASS_TYPE_P (type
))
9843 if (is_std_init_list (type
))
9845 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
9846 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
9847 if (type_has_extended_temps (TREE_TYPE (f
)))
9853 /* Returns true iff TYPE is some variant of std::initializer_list. */
9856 is_std_init_list (tree type
)
9858 /* Look through typedefs. */
9861 if (cxx_dialect
== cxx98
)
9863 type
= TYPE_MAIN_VARIANT (type
);
9864 return (CLASS_TYPE_P (type
)
9865 && CP_TYPE_CONTEXT (type
) == std_node
9866 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
9869 /* Returns true iff DECL is a list constructor: i.e. a constructor which
9870 will accept an argument list of a single std::initializer_list<T>. */
9873 is_list_ctor (tree decl
)
9875 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
9878 if (!args
|| args
== void_list_node
)
9881 arg
= non_reference (TREE_VALUE (args
));
9882 if (!is_std_init_list (arg
))
9885 args
= TREE_CHAIN (args
);
9887 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9888 /* There are more non-defaulted parms. */
9894 #include "gt-cp-call.h"