1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987-2013 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"
33 #include "diagnostic-core.h"
37 #include "langhooks.h"
38 #include "c-family/c-objc.h"
42 /* The various kinds of conversion. */
44 typedef enum conversion_kind
{
60 /* The rank of the conversion. Order of the enumerals matters; better
61 conversions should come earlier in the list. */
63 typedef enum conversion_rank
{
74 /* An implicit conversion sequence, in the sense of [over.best.ics].
75 The first conversion to be performed is at the end of the chain.
76 That conversion is always a cr_identity conversion. */
78 typedef struct conversion conversion
;
80 /* The kind of conversion represented by this step. */
82 /* The rank of this conversion. */
84 BOOL_BITFIELD user_conv_p
: 1;
85 BOOL_BITFIELD ellipsis_p
: 1;
86 BOOL_BITFIELD this_p
: 1;
87 /* True if this conversion would be permitted with a bending of
88 language standards, e.g. disregarding pointer qualifiers or
89 converting integers to pointers. */
90 BOOL_BITFIELD bad_p
: 1;
91 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
92 temporary should be created to hold the result of the
94 BOOL_BITFIELD need_temporary_p
: 1;
95 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
96 from a pointer-to-derived to pointer-to-base is being performed. */
97 BOOL_BITFIELD base_p
: 1;
98 /* If KIND is ck_ref_bind, true when either an lvalue reference is
99 being bound to an lvalue expression or an rvalue reference is
100 being bound to an rvalue expression. If KIND is ck_rvalue,
101 true when we should treat an lvalue as an rvalue (12.8p33). If
102 KIND is ck_base, always false. */
103 BOOL_BITFIELD rvaluedness_matches_p
: 1;
104 BOOL_BITFIELD check_narrowing
: 1;
105 /* The type of the expression resulting from the conversion. */
108 /* The next conversion in the chain. Since the conversions are
109 arranged from outermost to innermost, the NEXT conversion will
110 actually be performed before this conversion. This variant is
111 used only when KIND is neither ck_identity, ck_ambig nor
112 ck_list. Please use the next_conversion function instead
113 of using this field directly. */
115 /* The expression at the beginning of the conversion chain. This
116 variant is used only if KIND is ck_identity or ck_ambig. */
118 /* The array of conversions for an initializer_list, so this
119 variant is used only when KIN D is ck_list. */
122 /* The function candidate corresponding to this conversion
123 sequence. This field is only used if KIND is ck_user. */
124 struct z_candidate
*cand
;
127 #define CONVERSION_RANK(NODE) \
128 ((NODE)->bad_p ? cr_bad \
129 : (NODE)->ellipsis_p ? cr_ellipsis \
130 : (NODE)->user_conv_p ? cr_user \
133 #define BAD_CONVERSION_RANK(NODE) \
134 ((NODE)->ellipsis_p ? cr_ellipsis \
135 : (NODE)->user_conv_p ? cr_user \
138 static struct obstack conversion_obstack
;
139 static bool conversion_obstack_initialized
;
140 struct rejection_reason
;
142 static struct z_candidate
* tourney (struct z_candidate
*, tsubst_flags_t
);
143 static int equal_functions (tree
, tree
);
144 static int joust (struct z_candidate
*, struct z_candidate
*, bool,
146 static int compare_ics (conversion
*, conversion
*);
147 static tree
build_over_call (struct z_candidate
*, int, tsubst_flags_t
);
148 static tree
build_java_interface_fn_ref (tree
, tree
);
149 #define convert_like(CONV, EXPR, COMPLAIN) \
150 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
151 /*issue_conversion_warnings=*/true, \
152 /*c_cast_p=*/false, (COMPLAIN))
153 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
154 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
155 /*issue_conversion_warnings=*/true, \
156 /*c_cast_p=*/false, (COMPLAIN))
157 static tree
convert_like_real (conversion
*, tree
, tree
, int, int, bool,
158 bool, tsubst_flags_t
);
159 static void op_error (location_t
, enum tree_code
, enum tree_code
, tree
,
161 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int,
163 static void print_z_candidate (location_t
, const char *, struct z_candidate
*);
164 static void print_z_candidates (location_t
, struct z_candidate
*);
165 static tree
build_this (tree
);
166 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
167 static bool any_strictly_viable (struct z_candidate
*);
168 static struct z_candidate
*add_template_candidate
169 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
170 tree
, tree
, tree
, int, unification_kind_t
, tsubst_flags_t
);
171 static struct z_candidate
*add_template_candidate_real
172 (struct z_candidate
**, tree
, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
173 tree
, tree
, tree
, int, tree
, unification_kind_t
, tsubst_flags_t
);
174 static struct z_candidate
*add_template_conv_candidate
175 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *,
176 tree
, tree
, tree
, tsubst_flags_t
);
177 static void add_builtin_candidates
178 (struct z_candidate
**, enum tree_code
, enum tree_code
,
179 tree
, tree
*, int, tsubst_flags_t
);
180 static void add_builtin_candidate
181 (struct z_candidate
**, enum tree_code
, enum tree_code
,
182 tree
, tree
, tree
, tree
*, tree
*, int, tsubst_flags_t
);
183 static bool is_complete (tree
);
184 static void build_builtin_candidate
185 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
186 int, tsubst_flags_t
);
187 static struct z_candidate
*add_conv_candidate
188 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
189 tree
, tsubst_flags_t
);
190 static struct z_candidate
*add_function_candidate
191 (struct z_candidate
**, tree
, tree
, tree
, const vec
<tree
, va_gc
> *, tree
,
192 tree
, int, tsubst_flags_t
);
193 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int,
195 static conversion
*standard_conversion (tree
, tree
, tree
, bool, int);
196 static conversion
*reference_binding (tree
, tree
, tree
, bool, int,
198 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
199 static conversion
*build_list_conv (tree
, tree
, int, tsubst_flags_t
);
200 static conversion
*next_conversion (conversion
*);
201 static bool is_subseq (conversion
*, conversion
*);
202 static conversion
*maybe_handle_ref_bind (conversion
**);
203 static void maybe_handle_implicit_object (conversion
**);
204 static struct z_candidate
*add_candidate
205 (struct z_candidate
**, tree
, tree
, const vec
<tree
, va_gc
> *, size_t,
206 conversion
**, tree
, tree
, int, struct rejection_reason
*);
207 static tree
source_type (conversion
*);
208 static void add_warning (struct z_candidate
*, struct z_candidate
*);
209 static bool reference_compatible_p (tree
, tree
);
210 static conversion
*direct_reference_binding (tree
, conversion
*);
211 static bool promoted_arithmetic_type_p (tree
);
212 static conversion
*conditional_conversion (tree
, tree
, tsubst_flags_t
);
213 static char *name_as_c_string (tree
, tree
, bool *);
214 static tree
prep_operand (tree
);
215 static void add_candidates (tree
, tree
, const vec
<tree
, va_gc
> *, tree
, tree
,
216 bool, tree
, tree
, int, struct z_candidate
**,
218 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
219 static bool magic_varargs_p (tree
);
220 static tree
build_temp (tree
, tree
, int, diagnostic_t
*, tsubst_flags_t
);
222 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
223 NAME can take many forms... */
226 check_dtor_name (tree basetype
, tree name
)
228 /* Just accept something we've already complained about. */
229 if (name
== error_mark_node
)
232 if (TREE_CODE (name
) == TYPE_DECL
)
233 name
= TREE_TYPE (name
);
234 else if (TYPE_P (name
))
236 else if (identifier_p (name
))
238 if ((MAYBE_CLASS_TYPE_P (basetype
)
239 && name
== constructor_name (basetype
))
240 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
241 && name
== TYPE_IDENTIFIER (basetype
)))
244 name
= get_type_value (name
);
250 template <class T> struct S { ~S(); };
254 NAME will be a class template. */
255 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
259 if (!name
|| name
== error_mark_node
)
261 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
264 /* We want the address of a function or method. We avoid creating a
265 pointer-to-member function. */
268 build_addr_func (tree function
, tsubst_flags_t complain
)
270 tree type
= TREE_TYPE (function
);
272 /* We have to do these by hand to avoid real pointer to member
274 if (TREE_CODE (type
) == METHOD_TYPE
)
276 if (TREE_CODE (function
) == OFFSET_REF
)
278 tree object
= build_address (TREE_OPERAND (function
, 0));
279 return get_member_function_from_ptrfunc (&object
,
280 TREE_OPERAND (function
, 1),
283 function
= build_address (function
);
286 function
= decay_conversion (function
, complain
);
291 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
292 POINTER_TYPE to those. Note, pointer to member function types
293 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
294 two variants. build_call_a is the primitive taking an array of
295 arguments, while build_call_n is a wrapper that handles varargs. */
298 build_call_n (tree function
, int n
, ...)
301 return build_call_a (function
, 0, NULL
);
304 tree
*argarray
= XALLOCAVEC (tree
, n
);
309 for (i
= 0; i
< n
; i
++)
310 argarray
[i
] = va_arg (ap
, tree
);
312 return build_call_a (function
, n
, argarray
);
316 /* Update various flags in cfun and the call itself based on what is being
317 called. Split out of build_call_a so that bot_manip can use it too. */
320 set_flags_from_callee (tree call
)
323 tree decl
= get_callee_fndecl (call
);
325 /* We check both the decl and the type; a function may be known not to
326 throw without being declared throw(). */
327 nothrow
= ((decl
&& TREE_NOTHROW (decl
))
328 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call
)))));
330 if (!nothrow
&& at_function_scope_p () && cfun
&& cp_function_chain
)
331 cp_function_chain
->can_throw
= 1;
333 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
&& cp_function_chain
)
334 current_function_returns_abnormally
= 1;
336 TREE_NOTHROW (call
) = nothrow
;
340 build_call_a (tree function
, int n
, tree
*argarray
)
347 function
= build_addr_func (function
, tf_warning_or_error
);
349 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
350 fntype
= TREE_TYPE (TREE_TYPE (function
));
351 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
352 || TREE_CODE (fntype
) == METHOD_TYPE
);
353 result_type
= TREE_TYPE (fntype
);
354 /* An rvalue has no cv-qualifiers. */
355 if (SCALAR_TYPE_P (result_type
) || VOID_TYPE_P (result_type
))
356 result_type
= cv_unqualified (result_type
);
358 function
= build_call_array_loc (input_location
,
359 result_type
, function
, n
, argarray
);
360 set_flags_from_callee (function
);
362 decl
= get_callee_fndecl (function
);
364 if (decl
&& !TREE_USED (decl
))
366 /* We invoke build_call directly for several library
367 functions. These may have been declared normally if
368 we're building libgcc, so we can't just check
370 gcc_assert (DECL_ARTIFICIAL (decl
)
371 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
376 if (decl
&& TREE_DEPRECATED (decl
))
377 warn_deprecated_use (decl
, NULL_TREE
);
378 require_complete_eh_spec_types (fntype
, decl
);
380 TREE_HAS_CONSTRUCTOR (function
) = (decl
&& DECL_CONSTRUCTOR_P (decl
));
382 /* Don't pass empty class objects by value. This is useful
383 for tags in STL, which are used to control overload resolution.
384 We don't need to handle other cases of copying empty classes. */
385 if (! decl
|| ! DECL_BUILT_IN (decl
))
386 for (i
= 0; i
< n
; i
++)
388 tree arg
= CALL_EXPR_ARG (function
, i
);
389 if (is_empty_class (TREE_TYPE (arg
))
390 && ! TREE_ADDRESSABLE (TREE_TYPE (arg
)))
392 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (arg
));
393 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (t
), arg
, t
);
394 CALL_EXPR_ARG (function
, i
) = arg
;
401 /* Build something of the form ptr->method (args)
402 or object.method (args). This can also build
403 calls to constructors, and find friends.
405 Member functions always take their class variable
408 INSTANCE is a class instance.
410 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
412 PARMS help to figure out what that NAME really refers to.
414 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
415 down to the real instance type to use for access checking. We need this
416 information to get protected accesses correct.
418 FLAGS is the logical disjunction of zero or more LOOKUP_
419 flags. See cp-tree.h for more info.
421 If this is all OK, calls build_function_call with the resolved
424 This function must also handle being called to perform
425 initialization, promotion/coercion of arguments, and
426 instantiation of default parameters.
428 Note that NAME may refer to an instance variable name. If
429 `operator()()' is defined for the type of that field, then we return
432 /* New overloading code. */
434 typedef struct z_candidate z_candidate
;
436 typedef struct candidate_warning candidate_warning
;
437 struct candidate_warning
{
439 candidate_warning
*next
;
442 /* Information for providing diagnostics about why overloading failed. */
444 enum rejection_reason_code
{
447 rr_explicit_conversion
,
448 rr_template_conversion
,
450 rr_bad_arg_conversion
,
451 rr_template_unification
,
455 struct conversion_info
{
456 /* The index of the argument, 0-based. */
458 /* The type of the actual argument. */
460 /* The type of the formal argument. */
464 struct rejection_reason
{
465 enum rejection_reason_code code
;
467 /* Information about an arity mismatch. */
469 /* The expected number of arguments. */
471 /* The actual number of arguments in the call. */
473 /* Whether the call was a varargs call. */
476 /* Information about an argument conversion mismatch. */
477 struct conversion_info conversion
;
478 /* Same, but for bad argument conversions. */
479 struct conversion_info bad_conversion
;
480 /* Information about template unification failures. These are the
481 parameters passed to fn_type_unification. */
489 unification_kind_t strict
;
491 } template_unification
;
492 /* Information about template instantiation failures. These are the
493 parameters passed to instantiate_template. */
497 } template_instantiation
;
502 /* The FUNCTION_DECL that will be called if this candidate is
503 selected by overload resolution. */
505 /* If not NULL_TREE, the first argument to use when calling this
508 /* The rest of the arguments to use when calling this function. If
509 there are no further arguments this may be NULL or it may be an
511 const vec
<tree
, va_gc
> *args
;
512 /* The implicit conversion sequences for each of the arguments to
515 /* The number of implicit conversion sequences. */
517 /* If FN is a user-defined conversion, the standard conversion
518 sequence from the type returned by FN to the desired destination
520 conversion
*second_conv
;
522 struct rejection_reason
*reason
;
523 /* If FN is a member function, the binfo indicating the path used to
524 qualify the name of FN at the call site. This path is used to
525 determine whether or not FN is accessible if it is selected by
526 overload resolution. The DECL_CONTEXT of FN will always be a
527 (possibly improper) base of this binfo. */
529 /* If FN is a non-static member function, the binfo indicating the
530 subobject to which the `this' pointer should be converted if FN
531 is selected by overload resolution. The type pointed to by
532 the `this' pointer must correspond to the most derived class
533 indicated by the CONVERSION_PATH. */
534 tree conversion_path
;
537 candidate_warning
*warnings
;
541 /* Returns true iff T is a null pointer constant in the sense of
545 null_ptr_cst_p (tree t
)
549 A null pointer constant is an integral constant expression
550 (_expr.const_) rvalue of integer type that evaluates to zero or
551 an rvalue of type std::nullptr_t. */
552 if (NULLPTR_TYPE_P (TREE_TYPE (t
)))
554 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t
)))
556 /* Core issue 903 says only literal 0 is a null pointer constant. */
557 if (cxx_dialect
< cxx0x
)
558 t
= maybe_constant_value (t
);
560 if (integer_zerop (t
) && !TREE_OVERFLOW (t
))
566 /* Returns true iff T is a null member pointer value (4.11). */
569 null_member_pointer_value_p (tree t
)
571 tree type
= TREE_TYPE (t
);
574 else if (TYPE_PTRMEMFUNC_P (type
))
575 return (TREE_CODE (t
) == CONSTRUCTOR
576 && integer_zerop (CONSTRUCTOR_ELT (t
, 0)->value
));
577 else if (TYPE_PTRDATAMEM_P (type
))
578 return integer_all_onesp (t
);
583 /* Returns nonzero if PARMLIST consists of only default parms,
584 ellipsis, and/or undeduced parameter packs. */
587 sufficient_parms_p (const_tree parmlist
)
589 for (; parmlist
&& parmlist
!= void_list_node
;
590 parmlist
= TREE_CHAIN (parmlist
))
591 if (!TREE_PURPOSE (parmlist
)
592 && !PACK_EXPANSION_P (TREE_VALUE (parmlist
)))
597 /* Allocate N bytes of memory from the conversion obstack. The memory
598 is zeroed before being returned. */
601 conversion_obstack_alloc (size_t n
)
604 if (!conversion_obstack_initialized
)
606 gcc_obstack_init (&conversion_obstack
);
607 conversion_obstack_initialized
= true;
609 p
= obstack_alloc (&conversion_obstack
, n
);
614 /* Allocate rejection reasons. */
616 static struct rejection_reason
*
617 alloc_rejection (enum rejection_reason_code code
)
619 struct rejection_reason
*p
;
620 p
= (struct rejection_reason
*) conversion_obstack_alloc (sizeof *p
);
625 static struct rejection_reason
*
626 arity_rejection (tree first_arg
, int expected
, int actual
)
628 struct rejection_reason
*r
= alloc_rejection (rr_arity
);
629 int adjust
= first_arg
!= NULL_TREE
;
630 r
->u
.arity
.expected
= expected
- adjust
;
631 r
->u
.arity
.actual
= actual
- adjust
;
635 static struct rejection_reason
*
636 arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
638 struct rejection_reason
*r
= alloc_rejection (rr_arg_conversion
);
639 int adjust
= first_arg
!= NULL_TREE
;
640 r
->u
.conversion
.n_arg
= n_arg
- adjust
;
641 r
->u
.conversion
.from_type
= from
;
642 r
->u
.conversion
.to_type
= to
;
646 static struct rejection_reason
*
647 bad_arg_conversion_rejection (tree first_arg
, int n_arg
, tree from
, tree to
)
649 struct rejection_reason
*r
= alloc_rejection (rr_bad_arg_conversion
);
650 int adjust
= first_arg
!= NULL_TREE
;
651 r
->u
.bad_conversion
.n_arg
= n_arg
- adjust
;
652 r
->u
.bad_conversion
.from_type
= from
;
653 r
->u
.bad_conversion
.to_type
= to
;
657 static struct rejection_reason
*
658 explicit_conversion_rejection (tree from
, tree to
)
660 struct rejection_reason
*r
= alloc_rejection (rr_explicit_conversion
);
661 r
->u
.conversion
.n_arg
= 0;
662 r
->u
.conversion
.from_type
= from
;
663 r
->u
.conversion
.to_type
= to
;
667 static struct rejection_reason
*
668 template_conversion_rejection (tree from
, tree to
)
670 struct rejection_reason
*r
= alloc_rejection (rr_template_conversion
);
671 r
->u
.conversion
.n_arg
= 0;
672 r
->u
.conversion
.from_type
= from
;
673 r
->u
.conversion
.to_type
= to
;
677 static struct rejection_reason
*
678 template_unification_rejection (tree tmpl
, tree explicit_targs
, tree targs
,
679 const tree
*args
, unsigned int nargs
,
680 tree return_type
, unification_kind_t strict
,
683 size_t args_n_bytes
= sizeof (*args
) * nargs
;
684 tree
*args1
= (tree
*) conversion_obstack_alloc (args_n_bytes
);
685 struct rejection_reason
*r
= alloc_rejection (rr_template_unification
);
686 r
->u
.template_unification
.tmpl
= tmpl
;
687 r
->u
.template_unification
.explicit_targs
= explicit_targs
;
688 r
->u
.template_unification
.num_targs
= TREE_VEC_LENGTH (targs
);
689 /* Copy args to our own storage. */
690 memcpy (args1
, args
, args_n_bytes
);
691 r
->u
.template_unification
.args
= args1
;
692 r
->u
.template_unification
.nargs
= nargs
;
693 r
->u
.template_unification
.return_type
= return_type
;
694 r
->u
.template_unification
.strict
= strict
;
695 r
->u
.template_unification
.flags
= flags
;
699 static struct rejection_reason
*
700 template_unification_error_rejection (void)
702 return alloc_rejection (rr_template_unification
);
705 static struct rejection_reason
*
706 invalid_copy_with_fn_template_rejection (void)
708 struct rejection_reason
*r
= alloc_rejection (rr_invalid_copy
);
712 /* Dynamically allocate a conversion. */
715 alloc_conversion (conversion_kind kind
)
718 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
723 #ifdef ENABLE_CHECKING
725 /* Make sure that all memory on the conversion obstack has been
729 validate_conversion_obstack (void)
731 if (conversion_obstack_initialized
)
732 gcc_assert ((obstack_next_free (&conversion_obstack
)
733 == obstack_base (&conversion_obstack
)));
736 #endif /* ENABLE_CHECKING */
738 /* Dynamically allocate an array of N conversions. */
741 alloc_conversions (size_t n
)
743 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
747 build_conv (conversion_kind code
, tree type
, conversion
*from
)
750 conversion_rank rank
= CONVERSION_RANK (from
);
752 /* Note that the caller is responsible for filling in t->cand for
753 user-defined conversions. */
754 t
= alloc_conversion (code
);
777 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
778 t
->bad_p
= from
->bad_p
;
783 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
784 specialization of std::initializer_list<T>, if such a conversion is
788 build_list_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
790 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type
), 0);
791 unsigned len
= CONSTRUCTOR_NELTS (ctor
);
792 conversion
**subconvs
= alloc_conversions (len
);
797 /* Within a list-initialization we can have more user-defined
799 flags
&= ~LOOKUP_NO_CONVERSION
;
800 /* But no narrowing conversions. */
801 flags
|= LOOKUP_NO_NARROWING
;
803 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
806 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
807 false, flags
, complain
);
814 t
= alloc_conversion (ck_list
);
816 t
->u
.list
= subconvs
;
819 for (i
= 0; i
< len
; ++i
)
821 conversion
*sub
= subconvs
[i
];
822 if (sub
->rank
> t
->rank
)
824 if (sub
->user_conv_p
)
825 t
->user_conv_p
= true;
833 /* Return the next conversion of the conversion chain (if applicable),
834 or NULL otherwise. Please use this function instead of directly
835 accessing fields of struct conversion. */
838 next_conversion (conversion
*conv
)
841 || conv
->kind
== ck_identity
842 || conv
->kind
== ck_ambig
843 || conv
->kind
== ck_list
)
848 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
849 is a valid aggregate initializer for array type ATYPE. */
852 can_convert_array (tree atype
, tree ctor
, int flags
, tsubst_flags_t complain
)
855 tree elttype
= TREE_TYPE (atype
);
856 for (i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
858 tree val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
860 if (TREE_CODE (elttype
) == ARRAY_TYPE
861 && TREE_CODE (val
) == CONSTRUCTOR
)
862 ok
= can_convert_array (elttype
, val
, flags
, complain
);
864 ok
= can_convert_arg (elttype
, TREE_TYPE (val
), val
, flags
,
872 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
873 aggregate class, if such a conversion is possible. */
876 build_aggr_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
878 unsigned HOST_WIDE_INT i
= 0;
880 tree field
= next_initializable_field (TYPE_FIELDS (type
));
881 tree empty_ctor
= NULL_TREE
;
883 ctor
= reshape_init (type
, ctor
, tf_none
);
884 if (ctor
== error_mark_node
)
887 for (; field
; field
= next_initializable_field (DECL_CHAIN (field
)))
889 tree ftype
= TREE_TYPE (field
);
893 if (i
< CONSTRUCTOR_NELTS (ctor
))
894 val
= CONSTRUCTOR_ELT (ctor
, i
)->value
;
897 if (empty_ctor
== NULL_TREE
)
898 empty_ctor
= build_constructor (init_list_type_node
, NULL
);
903 if (TREE_CODE (ftype
) == ARRAY_TYPE
904 && TREE_CODE (val
) == CONSTRUCTOR
)
905 ok
= can_convert_array (ftype
, val
, flags
, complain
);
907 ok
= can_convert_arg (ftype
, TREE_TYPE (val
), val
, flags
,
913 if (TREE_CODE (type
) == UNION_TYPE
)
917 if (i
< CONSTRUCTOR_NELTS (ctor
))
920 c
= alloc_conversion (ck_aggr
);
923 c
->user_conv_p
= true;
928 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
929 array type, if such a conversion is possible. */
932 build_array_conv (tree type
, tree ctor
, int flags
, tsubst_flags_t complain
)
935 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
936 tree elttype
= TREE_TYPE (type
);
941 enum conversion_rank rank
= cr_exact
;
943 if (TYPE_DOMAIN (type
))
945 unsigned HOST_WIDE_INT alen
= tree_low_cst (array_type_nelts_top (type
), 1);
950 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
953 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
954 false, flags
, complain
);
958 if (sub
->rank
> rank
)
960 if (sub
->user_conv_p
)
966 c
= alloc_conversion (ck_aggr
);
969 c
->user_conv_p
= user
;
975 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
976 complex type, if such a conversion is possible. */
979 build_complex_conv (tree type
, tree ctor
, int flags
,
980 tsubst_flags_t complain
)
983 unsigned HOST_WIDE_INT len
= CONSTRUCTOR_NELTS (ctor
);
984 tree elttype
= TREE_TYPE (type
);
989 enum conversion_rank rank
= cr_exact
;
994 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), i
, val
)
997 = implicit_conversion (elttype
, TREE_TYPE (val
), val
,
998 false, flags
, complain
);
1002 if (sub
->rank
> rank
)
1004 if (sub
->user_conv_p
)
1010 c
= alloc_conversion (ck_aggr
);
1013 c
->user_conv_p
= user
;
1019 /* Build a representation of the identity conversion from EXPR to
1020 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1023 build_identity_conv (tree type
, tree expr
)
1027 c
= alloc_conversion (ck_identity
);
1034 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1035 were multiple user-defined conversions to accomplish the job.
1036 Build a conversion that indicates that ambiguity. */
1039 build_ambiguous_conv (tree type
, tree expr
)
1043 c
= alloc_conversion (ck_ambig
);
1051 strip_top_quals (tree t
)
1053 if (TREE_CODE (t
) == ARRAY_TYPE
)
1055 return cp_build_qualified_type (t
, 0);
1058 /* Returns the standard conversion path (see [conv]) from type FROM to type
1059 TO, if any. For proper handling of null pointer constants, you must
1060 also pass the expression EXPR to convert from. If C_CAST_P is true,
1061 this conversion is coming from a C-style cast. */
1064 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1067 enum tree_code fcode
, tcode
;
1069 bool fromref
= false;
1072 to
= non_reference (to
);
1073 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1076 from
= TREE_TYPE (from
);
1079 to
= strip_top_quals (to
);
1080 from
= strip_top_quals (from
);
1082 if ((TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
1083 && expr
&& type_unknown_p (expr
))
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
);
1092 fcode
= TREE_CODE (from
);
1093 tcode
= TREE_CODE (to
);
1095 conv
= build_identity_conv (from
, expr
);
1096 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
1098 from
= type_decays_to (from
);
1099 fcode
= TREE_CODE (from
);
1100 conv
= build_conv (ck_lvalue
, from
, conv
);
1102 else if (fromref
|| (expr
&& lvalue_p (expr
)))
1107 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
1110 from
= strip_top_quals (bitfield_type
);
1111 fcode
= TREE_CODE (from
);
1114 conv
= build_conv (ck_rvalue
, from
, conv
);
1115 if (flags
& LOOKUP_PREFER_RVALUE
)
1116 conv
->rvaluedness_matches_p
= true;
1119 /* Allow conversion between `__complex__' data types. */
1120 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
1122 /* The standard conversion sequence to convert FROM to TO is
1123 the standard conversion sequence to perform componentwise
1125 conversion
*part_conv
= standard_conversion
1126 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
);
1130 conv
= build_conv (part_conv
->kind
, to
, conv
);
1131 conv
->rank
= part_conv
->rank
;
1139 if (same_type_p (from
, to
))
1141 if (CLASS_TYPE_P (to
) && conv
->kind
== ck_rvalue
)
1142 conv
->type
= qualified_to
;
1147 A null pointer constant can be converted to a pointer type; ... A
1148 null pointer constant of integral type can be converted to an
1149 rvalue of type std::nullptr_t. */
1150 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEM_P (to
)
1151 || NULLPTR_TYPE_P (to
))
1152 && expr
&& null_ptr_cst_p (expr
))
1153 conv
= build_conv (ck_std
, to
, conv
);
1154 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
1155 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
1157 /* For backwards brain damage compatibility, allow interconversion of
1158 pointers and integers with a pedwarn. */
1159 conv
= build_conv (ck_std
, to
, conv
);
1162 else if (UNSCOPED_ENUM_P (to
) && fcode
== INTEGER_TYPE
)
1164 /* For backwards brain damage compatibility, allow interconversion of
1165 enums and integers with a pedwarn. */
1166 conv
= build_conv (ck_std
, to
, conv
);
1169 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
1170 || (TYPE_PTRDATAMEM_P (to
) && TYPE_PTRDATAMEM_P (from
)))
1175 if (tcode
== POINTER_TYPE
1176 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from
),
1179 else if (VOID_TYPE_P (TREE_TYPE (to
))
1180 && !TYPE_PTRDATAMEM_P (from
)
1181 && TREE_CODE (TREE_TYPE (from
)) != FUNCTION_TYPE
)
1183 tree nfrom
= TREE_TYPE (from
);
1184 from
= build_pointer_type
1185 (cp_build_qualified_type (void_type_node
,
1186 cp_type_quals (nfrom
)));
1187 conv
= build_conv (ck_ptr
, from
, conv
);
1189 else if (TYPE_PTRDATAMEM_P (from
))
1191 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
1192 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
1194 if (DERIVED_FROM_P (fbase
, tbase
)
1195 && (same_type_ignoring_top_level_qualifiers_p
1196 (TYPE_PTRMEM_POINTED_TO_TYPE (from
),
1197 TYPE_PTRMEM_POINTED_TO_TYPE (to
))))
1199 from
= build_ptrmem_type (tbase
,
1200 TYPE_PTRMEM_POINTED_TO_TYPE (from
));
1201 conv
= build_conv (ck_pmem
, from
, conv
);
1203 else if (!same_type_p (fbase
, tbase
))
1206 else if (CLASS_TYPE_P (TREE_TYPE (from
))
1207 && CLASS_TYPE_P (TREE_TYPE (to
))
1210 An rvalue of type "pointer to cv D," where D is a
1211 class type, can be converted to an rvalue of type
1212 "pointer to cv B," where B is a base class (clause
1213 _class.derived_) of D. If B is an inaccessible
1214 (clause _class.access_) or ambiguous
1215 (_class.member.lookup_) base class of D, a program
1216 that necessitates this conversion is ill-formed.
1217 Therefore, we use DERIVED_FROM_P, and do not check
1218 access or uniqueness. */
1219 && DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
1222 cp_build_qualified_type (TREE_TYPE (to
),
1223 cp_type_quals (TREE_TYPE (from
)));
1224 from
= build_pointer_type (from
);
1225 conv
= build_conv (ck_ptr
, from
, conv
);
1226 conv
->base_p
= true;
1229 if (tcode
== POINTER_TYPE
)
1231 to_pointee
= TREE_TYPE (to
);
1232 from_pointee
= TREE_TYPE (from
);
1236 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
1237 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
1240 if (same_type_p (from
, to
))
1242 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
1243 /* In a C-style cast, we ignore CV-qualification because we
1244 are allowed to perform a static_cast followed by a
1246 conv
= build_conv (ck_qual
, to
, conv
);
1247 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
1248 conv
= build_conv (ck_qual
, to
, conv
);
1249 else if (expr
&& string_conv_p (to
, expr
, 0))
1250 /* converting from string constant to char *. */
1251 conv
= build_conv (ck_qual
, to
, conv
);
1252 /* Allow conversions among compatible ObjC pointer types (base
1253 conversions have been already handled above). */
1254 else if (c_dialect_objc ()
1255 && objc_compare_types (to
, from
, -4, NULL_TREE
))
1256 conv
= build_conv (ck_ptr
, to
, conv
);
1257 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
1259 conv
= build_conv (ck_ptr
, to
, conv
);
1267 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
1269 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
1270 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
1271 tree fbase
= class_of_this_parm (fromfn
);
1272 tree tbase
= class_of_this_parm (tofn
);
1274 if (!DERIVED_FROM_P (fbase
, tbase
)
1275 || !same_type_p (static_fn_type (fromfn
),
1276 static_fn_type (tofn
)))
1279 from
= build_memfn_type (fromfn
,
1281 cp_type_quals (tbase
),
1282 type_memfn_rqual (tofn
));
1283 from
= build_ptrmemfunc_type (build_pointer_type (from
));
1284 conv
= build_conv (ck_pmem
, from
, conv
);
1285 conv
->base_p
= true;
1287 else if (tcode
== BOOLEAN_TYPE
)
1291 An rvalue of arithmetic, unscoped enumeration, pointer, or
1292 pointer to member type can be converted to an rvalue of type
1293 bool. ... An rvalue of type std::nullptr_t can be converted
1294 to an rvalue of type bool; */
1295 if (ARITHMETIC_TYPE_P (from
)
1296 || UNSCOPED_ENUM_P (from
)
1297 || fcode
== POINTER_TYPE
1298 || TYPE_PTRMEM_P (from
)
1299 || NULLPTR_TYPE_P (from
))
1301 conv
= build_conv (ck_std
, to
, conv
);
1302 if (fcode
== POINTER_TYPE
1303 || TYPE_PTRDATAMEM_P (from
)
1304 || (TYPE_PTRMEMFUNC_P (from
)
1305 && conv
->rank
< cr_pbool
)
1306 || NULLPTR_TYPE_P (from
))
1307 conv
->rank
= cr_pbool
;
1313 /* We don't check for ENUMERAL_TYPE here because there are no standard
1314 conversions to enum type. */
1315 /* As an extension, allow conversion to complex type. */
1316 else if (ARITHMETIC_TYPE_P (to
))
1318 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
)
1319 || SCOPED_ENUM_P (from
))
1321 conv
= build_conv (ck_std
, to
, conv
);
1323 /* Give this a better rank if it's a promotion. */
1324 if (same_type_p (to
, type_promotes_to (from
))
1325 && next_conversion (conv
)->rank
<= cr_promotion
)
1326 conv
->rank
= cr_promotion
;
1328 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
1329 && vector_types_convertible_p (from
, to
, false))
1330 return build_conv (ck_std
, to
, conv
);
1331 else if (MAYBE_CLASS_TYPE_P (to
) && MAYBE_CLASS_TYPE_P (from
)
1332 && is_properly_derived_from (from
, to
))
1334 if (conv
->kind
== ck_rvalue
)
1335 conv
= next_conversion (conv
);
1336 conv
= build_conv (ck_base
, to
, conv
);
1337 /* The derived-to-base conversion indicates the initialization
1338 of a parameter with base type from an object of a derived
1339 type. A temporary object is created to hold the result of
1340 the conversion unless we're binding directly to a reference. */
1341 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
1346 if (flags
& LOOKUP_NO_NARROWING
)
1347 conv
->check_narrowing
= true;
1352 /* Returns nonzero if T1 is reference-related to T2. */
1355 reference_related_p (tree t1
, tree t2
)
1357 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1360 t1
= TYPE_MAIN_VARIANT (t1
);
1361 t2
= TYPE_MAIN_VARIANT (t2
);
1365 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1366 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1368 return (same_type_p (t1
, t2
)
1369 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
1370 && DERIVED_FROM_P (t1
, t2
)));
1373 /* Returns nonzero if T1 is reference-compatible with T2. */
1376 reference_compatible_p (tree t1
, tree t2
)
1380 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1381 reference-related to T2 and cv1 is the same cv-qualification as,
1382 or greater cv-qualification than, cv2. */
1383 return (reference_related_p (t1
, t2
)
1384 && at_least_as_qualified_p (t1
, t2
));
1387 /* A reference of the indicated TYPE is being bound directly to the
1388 expression represented by the implicit conversion sequence CONV.
1389 Return a conversion sequence for this binding. */
1392 direct_reference_binding (tree type
, conversion
*conv
)
1396 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1397 gcc_assert (TREE_CODE (conv
->type
) != REFERENCE_TYPE
);
1399 t
= TREE_TYPE (type
);
1403 When a parameter of reference type binds directly
1404 (_dcl.init.ref_) to an argument expression, the implicit
1405 conversion sequence is the identity conversion, unless the
1406 argument expression has a type that is a derived class of the
1407 parameter type, in which case the implicit conversion sequence is
1408 a derived-to-base Conversion.
1410 If the parameter binds directly to the result of applying a
1411 conversion function to the argument expression, the implicit
1412 conversion sequence is a user-defined conversion sequence
1413 (_over.ics.user_), with the second standard conversion sequence
1414 either an identity conversion or, if the conversion function
1415 returns an entity of a type that is a derived class of the
1416 parameter type, a derived-to-base conversion. */
1417 if (!same_type_ignoring_top_level_qualifiers_p (t
, conv
->type
))
1419 /* Represent the derived-to-base conversion. */
1420 conv
= build_conv (ck_base
, t
, conv
);
1421 /* We will actually be binding to the base-class subobject in
1422 the derived class, so we mark this conversion appropriately.
1423 That way, convert_like knows not to generate a temporary. */
1424 conv
->need_temporary_p
= false;
1426 return build_conv (ck_ref_bind
, type
, conv
);
1429 /* Returns the conversion path from type FROM to reference type TO for
1430 purposes of reference binding. For lvalue binding, either pass a
1431 reference type to FROM or an lvalue expression to EXPR. If the
1432 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1433 the conversion returned. If C_CAST_P is true, this
1434 conversion is coming from a C-style cast. */
1437 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
,
1438 tsubst_flags_t complain
)
1440 conversion
*conv
= NULL
;
1441 tree to
= TREE_TYPE (rto
);
1446 cp_lvalue_kind gl_kind
;
1449 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1451 expr
= instantiate_type (to
, expr
, tf_none
);
1452 if (expr
== error_mark_node
)
1454 from
= TREE_TYPE (expr
);
1457 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1459 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
1460 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1462 if (!CLASS_TYPE_P (to
)
1463 && CONSTRUCTOR_NELTS (expr
) == 1)
1465 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1466 if (error_operand_p (expr
))
1468 from
= TREE_TYPE (expr
);
1472 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1474 from
= TREE_TYPE (from
);
1475 if (!TYPE_REF_IS_RVALUE (rfrom
)
1476 || TREE_CODE (from
) == FUNCTION_TYPE
)
1477 gl_kind
= clk_ordinary
;
1479 gl_kind
= clk_rvalueref
;
1483 gl_kind
= lvalue_kind (expr
);
1484 if (gl_kind
& clk_class
)
1485 /* A class prvalue is not a glvalue. */
1490 is_lvalue
= gl_kind
&& !(gl_kind
& clk_rvalueref
);
1493 if ((gl_kind
& clk_bitfield
) != 0)
1494 tfrom
= unlowered_expr_type (expr
);
1496 /* Figure out whether or not the types are reference-related and
1497 reference compatible. We have do do this after stripping
1498 references from FROM. */
1499 related_p
= reference_related_p (to
, tfrom
);
1500 /* If this is a C cast, first convert to an appropriately qualified
1501 type, so that we can later do a const_cast to the desired type. */
1502 if (related_p
&& c_cast_p
1503 && !at_least_as_qualified_p (to
, tfrom
))
1504 to
= cp_build_qualified_type (to
, cp_type_quals (tfrom
));
1505 compatible_p
= reference_compatible_p (to
, tfrom
);
1507 /* Directly bind reference when target expression's type is compatible with
1508 the reference and expression is an lvalue. In DR391, the wording in
1509 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1510 const and rvalue references to rvalues of compatible class type.
1511 We should also do direct bindings for non-class xvalues. */
1514 || (((CP_TYPE_CONST_NON_VOLATILE_P (to
)
1515 && !(flags
& LOOKUP_NO_RVAL_BIND
))
1516 || TYPE_REF_IS_RVALUE (rto
))
1518 || (!(flags
& LOOKUP_NO_TEMP_BIND
)
1519 && (CLASS_TYPE_P (from
)
1520 || TREE_CODE (from
) == ARRAY_TYPE
))))))
1524 If the initializer expression
1526 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1527 is reference-compatible with "cv2 T2,"
1529 the reference is bound directly to the initializer expression
1533 If the initializer expression is an rvalue, with T2 a class type,
1534 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1535 is bound to the object represented by the rvalue or to a sub-object
1536 within that object. */
1538 conv
= build_identity_conv (tfrom
, expr
);
1539 conv
= direct_reference_binding (rto
, conv
);
1541 if (flags
& LOOKUP_PREFER_RVALUE
)
1542 /* The top-level caller requested that we pretend that the lvalue
1543 be treated as an rvalue. */
1544 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1545 else if (TREE_CODE (rfrom
) == REFERENCE_TYPE
)
1546 /* Handle rvalue reference to function properly. */
1547 conv
->rvaluedness_matches_p
1548 = (TYPE_REF_IS_RVALUE (rto
) == TYPE_REF_IS_RVALUE (rfrom
));
1550 conv
->rvaluedness_matches_p
1551 = (TYPE_REF_IS_RVALUE (rto
) == !is_lvalue
);
1553 if ((gl_kind
& clk_bitfield
) != 0
1554 || ((gl_kind
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1555 /* For the purposes of overload resolution, we ignore the fact
1556 this expression is a bitfield or packed field. (In particular,
1557 [over.ics.ref] says specifically that a function with a
1558 non-const reference parameter is viable even if the
1559 argument is a bitfield.)
1561 However, when we actually call the function we must create
1562 a temporary to which to bind the reference. If the
1563 reference is volatile, or isn't const, then we cannot make
1564 a temporary, so we just issue an error when the conversion
1566 conv
->need_temporary_p
= true;
1568 /* Don't allow binding of lvalues (other than function lvalues) to
1569 rvalue references. */
1570 if (is_lvalue
&& TYPE_REF_IS_RVALUE (rto
)
1571 && TREE_CODE (to
) != FUNCTION_TYPE
1572 && !(flags
& LOOKUP_PREFER_RVALUE
))
1577 /* [class.conv.fct] A conversion function is never used to convert a
1578 (possibly cv-qualified) object to the (possibly cv-qualified) same
1579 object type (or a reference to it), to a (possibly cv-qualified) base
1580 class of that type (or a reference to it).... */
1581 else if (CLASS_TYPE_P (from
) && !related_p
1582 && !(flags
& LOOKUP_NO_CONVERSION
))
1586 If the initializer expression
1588 -- has a class type (i.e., T2 is a class type) can be
1589 implicitly converted to an lvalue of type "cv3 T3," where
1590 "cv1 T1" is reference-compatible with "cv3 T3". (this
1591 conversion is selected by enumerating the applicable
1592 conversion functions (_over.match.ref_) and choosing the
1593 best one through overload resolution. (_over.match_).
1595 the reference is bound to the lvalue result of the conversion
1596 in the second case. */
1597 z_candidate
*cand
= build_user_type_conversion_1 (rto
, expr
, flags
,
1600 return cand
->second_conv
;
1603 /* From this point on, we conceptually need temporaries, even if we
1604 elide them. Only the cases above are "direct bindings". */
1605 if (flags
& LOOKUP_NO_TEMP_BIND
)
1610 When a parameter of reference type is not bound directly to an
1611 argument expression, the conversion sequence is the one required
1612 to convert the argument expression to the underlying type of the
1613 reference according to _over.best.ics_. Conceptually, this
1614 conversion sequence corresponds to copy-initializing a temporary
1615 of the underlying type with the argument expression. Any
1616 difference in top-level cv-qualification is subsumed by the
1617 initialization itself and does not constitute a conversion. */
1621 Otherwise, the reference shall be to a non-volatile const type.
1623 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1624 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1629 Otherwise, a temporary of type "cv1 T1" is created and
1630 initialized from the initializer expression using the rules for a
1631 non-reference copy initialization. If T1 is reference-related to
1632 T2, cv1 must be the same cv-qualification as, or greater
1633 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1634 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1637 /* We're generating a temporary now, but don't bind any more in the
1638 conversion (specifically, don't slice the temporary returned by a
1639 conversion operator). */
1640 flags
|= LOOKUP_NO_TEMP_BIND
;
1642 /* Core issue 899: When [copy-]initializing a temporary to be bound
1643 to the first parameter of a copy constructor (12.8) called with
1644 a single argument in the context of direct-initialization,
1645 explicit conversion functions are also considered.
1647 So don't set LOOKUP_ONLYCONVERTING in that case. */
1648 if (!(flags
& LOOKUP_COPY_PARM
))
1649 flags
|= LOOKUP_ONLYCONVERTING
;
1652 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1657 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1658 /* This reference binding, unlike those above, requires the
1659 creation of a temporary. */
1660 conv
->need_temporary_p
= true;
1661 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1666 /* Returns the implicit conversion sequence (see [over.ics]) from type
1667 FROM to type TO. The optional expression EXPR may affect the
1668 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1669 true, this conversion is coming from a C-style cast. */
1672 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1673 int flags
, tsubst_flags_t complain
)
1677 if (from
== error_mark_node
|| to
== error_mark_node
1678 || expr
== error_mark_node
)
1681 /* Other flags only apply to the primary function in overload
1682 resolution, or after we've chosen one. */
1683 flags
&= (LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
|LOOKUP_COPY_PARM
1684 |LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
|LOOKUP_PREFER_RVALUE
1685 |LOOKUP_NO_NARROWING
|LOOKUP_PROTECT
);
1687 /* FIXME: actually we don't want warnings either, but we can't just
1688 have 'complain &= ~(tf_warning|tf_error)' because it would cause
1689 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
1690 We really ought not to issue that warning until we've committed
1691 to that conversion. */
1692 complain
&= ~tf_error
;
1694 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1695 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
, complain
);
1697 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
);
1702 if (expr
&& BRACE_ENCLOSED_INITIALIZER_P (expr
))
1704 if (is_std_init_list (to
))
1705 return build_list_conv (to
, expr
, flags
, complain
);
1707 /* As an extension, allow list-initialization of _Complex. */
1708 if (TREE_CODE (to
) == COMPLEX_TYPE
)
1710 conv
= build_complex_conv (to
, expr
, flags
, complain
);
1715 /* Allow conversion from an initializer-list with one element to a
1717 if (SCALAR_TYPE_P (to
))
1719 int nelts
= CONSTRUCTOR_NELTS (expr
);
1723 elt
= build_value_init (to
, tf_none
);
1724 else if (nelts
== 1)
1725 elt
= CONSTRUCTOR_ELT (expr
, 0)->value
;
1727 elt
= error_mark_node
;
1729 conv
= implicit_conversion (to
, TREE_TYPE (elt
), elt
,
1730 c_cast_p
, flags
, complain
);
1733 conv
->check_narrowing
= true;
1734 if (BRACE_ENCLOSED_INITIALIZER_P (elt
))
1735 /* Too many levels of braces, i.e. '{{1}}'. */
1740 else if (TREE_CODE (to
) == ARRAY_TYPE
)
1741 return build_array_conv (to
, expr
, flags
, complain
);
1744 if (expr
!= NULL_TREE
1745 && (MAYBE_CLASS_TYPE_P (from
)
1746 || MAYBE_CLASS_TYPE_P (to
))
1747 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1749 struct z_candidate
*cand
;
1751 if (CLASS_TYPE_P (to
)
1752 && BRACE_ENCLOSED_INITIALIZER_P (expr
)
1753 && !CLASSTYPE_NON_AGGREGATE (complete_type (to
)))
1754 return build_aggr_conv (to
, expr
, flags
, complain
);
1756 cand
= build_user_type_conversion_1 (to
, expr
, flags
, complain
);
1758 conv
= cand
->second_conv
;
1760 /* We used to try to bind a reference to a temporary here, but that
1761 is now handled after the recursive call to this function at the end
1762 of reference_binding. */
1769 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1770 functions. ARGS will not be changed until a single candidate is
1773 static struct z_candidate
*
1774 add_candidate (struct z_candidate
**candidates
,
1775 tree fn
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
1776 size_t num_convs
, conversion
**convs
,
1777 tree access_path
, tree conversion_path
,
1778 int viable
, struct rejection_reason
*reason
)
1780 struct z_candidate
*cand
= (struct z_candidate
*)
1781 conversion_obstack_alloc (sizeof (struct z_candidate
));
1784 cand
->first_arg
= first_arg
;
1786 cand
->convs
= convs
;
1787 cand
->num_convs
= num_convs
;
1788 cand
->access_path
= access_path
;
1789 cand
->conversion_path
= conversion_path
;
1790 cand
->viable
= viable
;
1791 cand
->reason
= reason
;
1792 cand
->next
= *candidates
;
1798 /* Return the number of remaining arguments in the parameter list
1799 beginning with ARG. */
1802 remaining_arguments (tree arg
)
1806 for (n
= 0; arg
!= NULL_TREE
&& arg
!= void_list_node
;
1807 arg
= TREE_CHAIN (arg
))
1813 /* Create an overload candidate for the function or method FN called
1814 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1815 FLAGS is passed on to implicit_conversion.
1817 This does not change ARGS.
1819 CTYPE, if non-NULL, is the type we want to pretend this function
1820 comes from for purposes of overload resolution. */
1822 static struct z_candidate
*
1823 add_function_candidate (struct z_candidate
**candidates
,
1824 tree fn
, tree ctype
, tree first_arg
,
1825 const vec
<tree
, va_gc
> *args
, tree access_path
,
1826 tree conversion_path
, int flags
,
1827 tsubst_flags_t complain
)
1829 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1833 tree orig_first_arg
= first_arg
;
1836 struct rejection_reason
*reason
= NULL
;
1838 /* At this point we should not see any functions which haven't been
1839 explicitly declared, except for friend functions which will have
1840 been found using argument dependent lookup. */
1841 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
1843 /* The `this', `in_chrg' and VTT arguments to constructors are not
1844 considered in overload resolution. */
1845 if (DECL_CONSTRUCTOR_P (fn
))
1847 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1848 skip
= num_artificial_parms_for (fn
);
1849 if (skip
> 0 && first_arg
!= NULL_TREE
)
1852 first_arg
= NULL_TREE
;
1858 len
= vec_safe_length (args
) - skip
+ (first_arg
!= NULL_TREE
? 1 : 0);
1859 convs
= alloc_conversions (len
);
1861 /* 13.3.2 - Viable functions [over.match.viable]
1862 First, to be a viable function, a candidate function shall have enough
1863 parameters to agree in number with the arguments in the list.
1865 We need to check this first; otherwise, checking the ICSes might cause
1866 us to produce an ill-formed template instantiation. */
1868 parmnode
= parmlist
;
1869 for (i
= 0; i
< len
; ++i
)
1871 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1873 parmnode
= TREE_CHAIN (parmnode
);
1876 if ((i
< len
&& parmnode
)
1877 || !sufficient_parms_p (parmnode
))
1879 int remaining
= remaining_arguments (parmnode
);
1881 reason
= arity_rejection (first_arg
, i
+ remaining
, len
);
1883 /* When looking for a function from a subobject from an implicit
1884 copy/move constructor/operator=, don't consider anything that takes (a
1885 reference to) an unrelated type. See c++/44909 and core 1092. */
1886 else if (parmlist
&& (flags
& LOOKUP_DEFAULTED
))
1888 if (DECL_CONSTRUCTOR_P (fn
))
1890 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
1891 && DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
)
1897 parmnode
= chain_index (i
-1, parmlist
);
1898 if (!reference_related_p (non_reference (TREE_VALUE (parmnode
)),
1903 /* This only applies at the top level. */
1904 flags
&= ~LOOKUP_DEFAULTED
;
1910 /* Second, for F to be a viable function, there shall exist for each
1911 argument an implicit conversion sequence that converts that argument
1912 to the corresponding parameter of F. */
1914 parmnode
= parmlist
;
1916 for (i
= 0; i
< len
; ++i
)
1918 tree argtype
, to_type
;
1923 if (parmnode
== void_list_node
)
1926 if (i
== 0 && first_arg
!= NULL_TREE
)
1929 arg
= CONST_CAST_TREE (
1930 (*args
)[i
+ skip
- (first_arg
!= NULL_TREE
? 1 : 0)]);
1931 argtype
= lvalue_type (arg
);
1933 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1934 && ! DECL_CONSTRUCTOR_P (fn
));
1938 tree parmtype
= TREE_VALUE (parmnode
);
1941 parmnode
= TREE_CHAIN (parmnode
);
1943 /* The type of the implicit object parameter ('this') for
1944 overload resolution is not always the same as for the
1945 function itself; conversion functions are considered to
1946 be members of the class being converted, and functions
1947 introduced by a using-declaration are considered to be
1948 members of the class that uses them.
1950 Since build_over_call ignores the ICS for the `this'
1951 parameter, we can just change the parm type. */
1952 if (ctype
&& is_this
)
1954 parmtype
= cp_build_qualified_type
1955 (ctype
, cp_type_quals (TREE_TYPE (parmtype
)));
1956 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn
)))
1958 /* If the function has a ref-qualifier, the implicit
1959 object parameter has reference type. */
1960 bool rv
= FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn
));
1961 parmtype
= cp_build_reference_type (parmtype
, rv
);
1965 parmtype
= build_pointer_type (parmtype
);
1966 arg
= build_this (arg
);
1967 argtype
= lvalue_type (arg
);
1971 /* Core issue 899: When [copy-]initializing a temporary to be bound
1972 to the first parameter of a copy constructor (12.8) called with
1973 a single argument in the context of direct-initialization,
1974 explicit conversion functions are also considered.
1976 So set LOOKUP_COPY_PARM to let reference_binding know that
1977 it's being called in that context. We generalize the above
1978 to handle move constructors and template constructors as well;
1979 the standardese should soon be updated similarly. */
1980 if (ctype
&& i
== 0 && (len
-skip
== 1)
1981 && DECL_CONSTRUCTOR_P (fn
)
1982 && parmtype
!= error_mark_node
1983 && (same_type_ignoring_top_level_qualifiers_p
1984 (non_reference (parmtype
), ctype
)))
1986 if (!(flags
& LOOKUP_ONLYCONVERTING
))
1987 lflags
|= LOOKUP_COPY_PARM
;
1988 /* We allow user-defined conversions within init-lists, but
1989 don't list-initialize the copy parm, as that would mean
1990 using two levels of braces for the same type. */
1991 if ((flags
& LOOKUP_LIST_INIT_CTOR
)
1992 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
1993 lflags
|= LOOKUP_NO_CONVERSION
;
1996 lflags
|= LOOKUP_ONLYCONVERTING
;
1998 t
= implicit_conversion (parmtype
, argtype
, arg
,
1999 /*c_cast_p=*/false, lflags
, complain
);
2004 t
= build_identity_conv (argtype
, arg
);
2005 t
->ellipsis_p
= true;
2016 reason
= arg_conversion_rejection (first_arg
, i
, argtype
, to_type
);
2023 reason
= bad_arg_conversion_rejection (first_arg
, i
, argtype
, to_type
);
2028 return add_candidate (candidates
, fn
, orig_first_arg
, args
, len
, convs
,
2029 access_path
, conversion_path
, viable
, reason
);
2032 /* Create an overload candidate for the conversion function FN which will
2033 be invoked for expression OBJ, producing a pointer-to-function which
2034 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2035 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2036 passed on to implicit_conversion.
2038 Actually, we don't really care about FN; we care about the type it
2039 converts to. There may be multiple conversion functions that will
2040 convert to that type, and we rely on build_user_type_conversion_1 to
2041 choose the best one; so when we create our candidate, we record the type
2042 instead of the function. */
2044 static struct z_candidate
*
2045 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
2046 tree first_arg
, const vec
<tree
, va_gc
> *arglist
,
2047 tree access_path
, tree conversion_path
,
2048 tsubst_flags_t complain
)
2050 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
2051 int i
, len
, viable
, flags
;
2052 tree parmlist
, parmnode
;
2054 struct rejection_reason
*reason
;
2056 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
2057 parmlist
= TREE_TYPE (parmlist
);
2058 parmlist
= TYPE_ARG_TYPES (parmlist
);
2060 len
= vec_safe_length (arglist
) + (first_arg
!= NULL_TREE
? 1 : 0) + 1;
2061 convs
= alloc_conversions (len
);
2062 parmnode
= parmlist
;
2064 flags
= LOOKUP_IMPLICIT
;
2067 /* Don't bother looking up the same type twice. */
2068 if (*candidates
&& (*candidates
)->fn
== totype
)
2071 for (i
= 0; i
< len
; ++i
)
2073 tree arg
, argtype
, convert_type
= NULL_TREE
;
2078 else if (i
== 1 && first_arg
!= NULL_TREE
)
2081 arg
= (*arglist
)[i
- (first_arg
!= NULL_TREE
? 1 : 0) - 1];
2082 argtype
= lvalue_type (arg
);
2086 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
2088 convert_type
= totype
;
2090 else if (parmnode
== void_list_node
)
2094 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
2095 /*c_cast_p=*/false, flags
, complain
);
2096 convert_type
= TREE_VALUE (parmnode
);
2100 t
= build_identity_conv (argtype
, arg
);
2101 t
->ellipsis_p
= true;
2102 convert_type
= argtype
;
2112 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, argtype
, convert_type
);
2119 parmnode
= TREE_CHAIN (parmnode
);
2123 || ! sufficient_parms_p (parmnode
))
2125 int remaining
= remaining_arguments (parmnode
);
2127 reason
= arity_rejection (NULL_TREE
, i
+ remaining
, len
);
2130 return add_candidate (candidates
, totype
, first_arg
, arglist
, len
, convs
,
2131 access_path
, conversion_path
, viable
, reason
);
2135 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
2136 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
2137 int flags
, tsubst_flags_t complain
)
2144 struct rejection_reason
*reason
= NULL
;
2149 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
2150 convs
= alloc_conversions (num_convs
);
2152 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2153 conversion ops are allowed. We handle that here by just checking for
2154 boolean_type_node because other operators don't ask for it. COND_EXPR
2155 also does contextual conversion to bool for the first operand, but we
2156 handle that in build_conditional_expr, and type1 here is operand 2. */
2157 if (type1
!= boolean_type_node
)
2158 flags
|= LOOKUP_ONLYCONVERTING
;
2160 for (i
= 0; i
< 2; ++i
)
2165 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
2166 /*c_cast_p=*/false, flags
, complain
);
2170 /* We need something for printing the candidate. */
2171 t
= build_identity_conv (types
[i
], NULL_TREE
);
2172 reason
= arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2178 reason
= bad_arg_conversion_rejection (NULL_TREE
, i
, argtypes
[i
],
2184 /* For COND_EXPR we rearranged the arguments; undo that now. */
2187 convs
[2] = convs
[1];
2188 convs
[1] = convs
[0];
2189 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
2190 /*c_cast_p=*/false, flags
,
2197 reason
= arg_conversion_rejection (NULL_TREE
, 0, argtypes
[2],
2202 add_candidate (candidates
, fnname
, /*first_arg=*/NULL_TREE
, /*args=*/NULL
,
2204 /*access_path=*/NULL_TREE
,
2205 /*conversion_path=*/NULL_TREE
,
2210 is_complete (tree t
)
2212 return COMPLETE_TYPE_P (complete_type (t
));
2215 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2218 promoted_arithmetic_type_p (tree type
)
2222 In this section, the term promoted integral type is used to refer
2223 to those integral types which are preserved by integral promotion
2224 (including e.g. int and long but excluding e.g. char).
2225 Similarly, the term promoted arithmetic type refers to promoted
2226 integral types plus floating types. */
2227 return ((CP_INTEGRAL_TYPE_P (type
)
2228 && same_type_p (type_promotes_to (type
), type
))
2229 || TREE_CODE (type
) == REAL_TYPE
);
2232 /* Create any builtin operator overload candidates for the operator in
2233 question given the converted operand types TYPE1 and TYPE2. The other
2234 args are passed through from add_builtin_candidates to
2235 build_builtin_candidate.
2237 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2238 If CODE is requires candidates operands of the same type of the kind
2239 of which TYPE1 and TYPE2 are, we add both candidates
2240 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2243 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
2244 enum tree_code code2
, tree fnname
, tree type1
,
2245 tree type2
, tree
*args
, tree
*argtypes
, int flags
,
2246 tsubst_flags_t complain
)
2250 case POSTINCREMENT_EXPR
:
2251 case POSTDECREMENT_EXPR
:
2252 args
[1] = integer_zero_node
;
2253 type2
= integer_type_node
;
2262 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2263 and VQ is either volatile or empty, there exist candidate operator
2264 functions of the form
2265 VQ T& operator++(VQ T&);
2266 T operator++(VQ T&, int);
2267 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2268 type other than bool, and VQ is either volatile or empty, there exist
2269 candidate operator functions of the form
2270 VQ T& operator--(VQ T&);
2271 T operator--(VQ T&, int);
2272 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
2273 complete object type, and VQ is either volatile or empty, there exist
2274 candidate operator functions of the form
2275 T*VQ& operator++(T*VQ&);
2276 T*VQ& operator--(T*VQ&);
2277 T* operator++(T*VQ&, int);
2278 T* operator--(T*VQ&, int); */
2280 case POSTDECREMENT_EXPR
:
2281 case PREDECREMENT_EXPR
:
2282 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
2284 case POSTINCREMENT_EXPR
:
2285 case PREINCREMENT_EXPR
:
2286 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
2288 type1
= build_reference_type (type1
);
2293 /* 7 For every cv-qualified or cv-unqualified object type T, there
2294 exist candidate operator functions of the form
2298 8 For every function type T, there exist candidate operator functions of
2300 T& operator*(T*); */
2303 if (TYPE_PTR_P (type1
)
2304 && !uses_template_parms (TREE_TYPE (type1
))
2305 && (TYPE_PTROB_P (type1
)
2306 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
2310 /* 9 For every type T, there exist candidate operator functions of the form
2313 10For every promoted arithmetic type T, there exist candidate operator
2314 functions of the form
2318 case UNARY_PLUS_EXPR
: /* unary + */
2319 if (TYPE_PTR_P (type1
))
2322 if (ARITHMETIC_TYPE_P (type1
))
2326 /* 11For every promoted integral type T, there exist candidate operator
2327 functions of the form
2331 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
))
2335 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2336 is the same type as C2 or is a derived class of C2, T is a complete
2337 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2338 there exist candidate operator functions of the form
2339 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2340 where CV12 is the union of CV1 and CV2. */
2343 if (TYPE_PTR_P (type1
) && TYPE_PTRMEM_P (type2
))
2345 tree c1
= TREE_TYPE (type1
);
2346 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
2348 if (MAYBE_CLASS_TYPE_P (c1
) && DERIVED_FROM_P (c2
, c1
)
2349 && (TYPE_PTRMEMFUNC_P (type2
)
2350 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
2355 /* 13For every pair of promoted arithmetic types L and R, there exist can-
2356 didate operator functions of the form
2361 bool operator<(L, R);
2362 bool operator>(L, R);
2363 bool operator<=(L, R);
2364 bool operator>=(L, R);
2365 bool operator==(L, R);
2366 bool operator!=(L, R);
2367 where LR is the result of the usual arithmetic conversions between
2370 14For every pair of types T and I, where T is a cv-qualified or cv-
2371 unqualified complete object type and I is a promoted integral type,
2372 there exist candidate operator functions of the form
2373 T* operator+(T*, I);
2374 T& operator[](T*, I);
2375 T* operator-(T*, I);
2376 T* operator+(I, T*);
2377 T& operator[](I, T*);
2379 15For every T, where T is a pointer to complete object type, there exist
2380 candidate operator functions of the form112)
2381 ptrdiff_t operator-(T, T);
2383 16For every pointer or enumeration type T, there exist candidate operator
2384 functions of the form
2385 bool operator<(T, T);
2386 bool operator>(T, T);
2387 bool operator<=(T, T);
2388 bool operator>=(T, T);
2389 bool operator==(T, T);
2390 bool operator!=(T, T);
2392 17For every pointer to member type T, there exist candidate operator
2393 functions of the form
2394 bool operator==(T, T);
2395 bool operator!=(T, T); */
2398 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
2400 if (TYPE_PTROB_P (type1
)
2401 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2403 type2
= ptrdiff_type_node
;
2407 case TRUNC_DIV_EXPR
:
2408 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2414 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2415 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
)))
2417 if (TYPE_PTRMEM_P (type1
) && null_ptr_cst_p (args
[1]))
2422 if (TYPE_PTRMEM_P (type2
) && null_ptr_cst_p (args
[0]))
2434 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2436 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2438 if (TREE_CODE (type1
) == ENUMERAL_TYPE
2439 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
2441 if (TYPE_PTR_P (type1
)
2442 && null_ptr_cst_p (args
[1])
2443 && !uses_template_parms (type1
))
2448 if (null_ptr_cst_p (args
[0])
2449 && TYPE_PTR_P (type2
)
2450 && !uses_template_parms (type2
))
2458 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2461 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
2463 type1
= ptrdiff_type_node
;
2466 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2468 type2
= ptrdiff_type_node
;
2473 /* 18For every pair of promoted integral types L and R, there exist candi-
2474 date operator functions of the form
2481 where LR is the result of the usual arithmetic conversions between
2484 case TRUNC_MOD_EXPR
:
2490 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2494 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2495 type, VQ is either volatile or empty, and R is a promoted arithmetic
2496 type, there exist candidate operator functions of the form
2497 VQ L& operator=(VQ L&, R);
2498 VQ L& operator*=(VQ L&, R);
2499 VQ L& operator/=(VQ L&, R);
2500 VQ L& operator+=(VQ L&, R);
2501 VQ L& operator-=(VQ L&, R);
2503 20For every pair T, VQ), where T is any type and VQ is either volatile
2504 or empty, there exist candidate operator functions of the form
2505 T*VQ& operator=(T*VQ&, T*);
2507 21For every pair T, VQ), where T is a pointer to member type and VQ is
2508 either volatile or empty, there exist candidate operator functions of
2510 VQ T& operator=(VQ T&, T);
2512 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2513 unqualified complete object type, VQ is either volatile or empty, and
2514 I is a promoted integral type, there exist candidate operator func-
2516 T*VQ& operator+=(T*VQ&, I);
2517 T*VQ& operator-=(T*VQ&, I);
2519 23For every triple L, VQ, R), where L is an integral or enumeration
2520 type, VQ is either volatile or empty, and R is a promoted integral
2521 type, there exist candidate operator functions of the form
2523 VQ L& operator%=(VQ L&, R);
2524 VQ L& operator<<=(VQ L&, R);
2525 VQ L& operator>>=(VQ L&, R);
2526 VQ L& operator&=(VQ L&, R);
2527 VQ L& operator^=(VQ L&, R);
2528 VQ L& operator|=(VQ L&, R); */
2535 if (TYPE_PTROB_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2537 type2
= ptrdiff_type_node
;
2541 case TRUNC_DIV_EXPR
:
2542 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2546 case TRUNC_MOD_EXPR
:
2552 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1
) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2
))
2557 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
2559 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
2560 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2561 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2562 || ((TYPE_PTRMEMFUNC_P (type1
)
2563 || TYPE_PTR_P (type1
))
2564 && null_ptr_cst_p (args
[1])))
2574 type1
= build_reference_type (type1
);
2580 For every pair of promoted arithmetic types L and R, there
2581 exist candidate operator functions of the form
2583 LR operator?(bool, L, R);
2585 where LR is the result of the usual arithmetic conversions
2586 between types L and R.
2588 For every type T, where T is a pointer or pointer-to-member
2589 type, there exist candidate operator functions of the form T
2590 operator?(bool, T, T); */
2592 if (promoted_arithmetic_type_p (type1
)
2593 && promoted_arithmetic_type_p (type2
))
2597 /* Otherwise, the types should be pointers. */
2598 if (!TYPE_PTR_OR_PTRMEM_P (type1
) || !TYPE_PTR_OR_PTRMEM_P (type2
))
2601 /* We don't check that the two types are the same; the logic
2602 below will actually create two candidates; one in which both
2603 parameter types are TYPE1, and one in which both parameter
2609 if (ARITHMETIC_TYPE_P (type1
))
2617 /* If we're dealing with two pointer types or two enumeral types,
2618 we need candidates for both of them. */
2619 if (type2
&& !same_type_p (type1
, type2
)
2620 && TREE_CODE (type1
) == TREE_CODE (type2
)
2621 && (TREE_CODE (type1
) == REFERENCE_TYPE
2622 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2623 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
2624 || TYPE_PTRMEMFUNC_P (type1
)
2625 || MAYBE_CLASS_TYPE_P (type1
)
2626 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2628 if (TYPE_PTR_OR_PTRMEM_P (type1
))
2630 tree cptype
= composite_pointer_type (type1
, type2
,
2635 if (cptype
!= error_mark_node
)
2637 build_builtin_candidate
2638 (candidates
, fnname
, cptype
, cptype
, args
, argtypes
,
2644 build_builtin_candidate
2645 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
, complain
);
2646 build_builtin_candidate
2647 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
, complain
);
2651 build_builtin_candidate
2652 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
, complain
);
2656 type_decays_to (tree type
)
2658 if (TREE_CODE (type
) == ARRAY_TYPE
)
2659 return build_pointer_type (TREE_TYPE (type
));
2660 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2661 return build_pointer_type (type
);
2665 /* There are three conditions of builtin candidates:
2667 1) bool-taking candidates. These are the same regardless of the input.
2668 2) pointer-pair taking candidates. These are generated for each type
2669 one of the input types converts to.
2670 3) arithmetic candidates. According to the standard, we should generate
2671 all of these, but I'm trying not to...
2673 Here we generate a superset of the possible candidates for this particular
2674 case. That is a subset of the full set the standard defines, plus some
2675 other cases which the standard disallows. add_builtin_candidate will
2676 filter out the invalid set. */
2679 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2680 enum tree_code code2
, tree fnname
, tree
*args
,
2681 int flags
, tsubst_flags_t complain
)
2685 tree type
, argtypes
[3], t
;
2686 /* TYPES[i] is the set of possible builtin-operator parameter types
2687 we will consider for the Ith argument. */
2688 vec
<tree
, va_gc
> *types
[2];
2691 for (i
= 0; i
< 3; ++i
)
2694 argtypes
[i
] = unlowered_expr_type (args
[i
]);
2696 argtypes
[i
] = NULL_TREE
;
2701 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2702 and VQ is either volatile or empty, there exist candidate operator
2703 functions of the form
2704 VQ T& operator++(VQ T&); */
2706 case POSTINCREMENT_EXPR
:
2707 case PREINCREMENT_EXPR
:
2708 case POSTDECREMENT_EXPR
:
2709 case PREDECREMENT_EXPR
:
2714 /* 24There also exist candidate operator functions of the form
2715 bool operator!(bool);
2716 bool operator&&(bool, bool);
2717 bool operator||(bool, bool); */
2719 case TRUTH_NOT_EXPR
:
2720 build_builtin_candidate
2721 (candidates
, fnname
, boolean_type_node
,
2722 NULL_TREE
, args
, argtypes
, flags
, complain
);
2725 case TRUTH_ORIF_EXPR
:
2726 case TRUTH_ANDIF_EXPR
:
2727 build_builtin_candidate
2728 (candidates
, fnname
, boolean_type_node
,
2729 boolean_type_node
, args
, argtypes
, flags
, complain
);
2751 types
[0] = make_tree_vector ();
2752 types
[1] = make_tree_vector ();
2754 for (i
= 0; i
< 2; ++i
)
2758 else if (MAYBE_CLASS_TYPE_P (argtypes
[i
]))
2762 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2765 convs
= lookup_conversions (argtypes
[i
]);
2767 if (code
== COND_EXPR
)
2769 if (real_lvalue_p (args
[i
]))
2770 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2772 vec_safe_push (types
[i
], TYPE_MAIN_VARIANT (argtypes
[i
]));
2778 for (; convs
; convs
= TREE_CHAIN (convs
))
2780 type
= TREE_TYPE (convs
);
2783 && (TREE_CODE (type
) != REFERENCE_TYPE
2784 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2787 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2788 vec_safe_push (types
[i
], type
);
2790 type
= non_reference (type
);
2791 if (i
!= 0 || ! ref1
)
2793 type
= cv_unqualified (type_decays_to (type
));
2794 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2795 vec_safe_push (types
[i
], type
);
2796 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2797 type
= type_promotes_to (type
);
2800 if (! vec_member (type
, types
[i
]))
2801 vec_safe_push (types
[i
], type
);
2806 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2807 vec_safe_push (types
[i
], build_reference_type (argtypes
[i
]));
2808 type
= non_reference (argtypes
[i
]);
2809 if (i
!= 0 || ! ref1
)
2811 type
= cv_unqualified (type_decays_to (type
));
2812 if (enum_p
&& UNSCOPED_ENUM_P (type
))
2813 vec_safe_push (types
[i
], type
);
2814 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
2815 type
= type_promotes_to (type
);
2817 vec_safe_push (types
[i
], type
);
2821 /* Run through the possible parameter types of both arguments,
2822 creating candidates with those parameter types. */
2823 FOR_EACH_VEC_ELT_REVERSE (*(types
[0]), ix
, t
)
2828 if (!types
[1]->is_empty ())
2829 FOR_EACH_VEC_ELT_REVERSE (*(types
[1]), jx
, u
)
2830 add_builtin_candidate
2831 (candidates
, code
, code2
, fnname
, t
,
2832 u
, args
, argtypes
, flags
, complain
);
2834 add_builtin_candidate
2835 (candidates
, code
, code2
, fnname
, t
,
2836 NULL_TREE
, args
, argtypes
, flags
, complain
);
2839 release_tree_vector (types
[0]);
2840 release_tree_vector (types
[1]);
2844 /* If TMPL can be successfully instantiated as indicated by
2845 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2847 TMPL is the template. EXPLICIT_TARGS are any explicit template
2848 arguments. ARGLIST is the arguments provided at the call-site.
2849 This does not change ARGLIST. The RETURN_TYPE is the desired type
2850 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2851 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2852 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2854 static struct z_candidate
*
2855 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
2856 tree ctype
, tree explicit_targs
, tree first_arg
,
2857 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
2858 tree access_path
, tree conversion_path
,
2859 int flags
, tree obj
, unification_kind_t strict
,
2860 tsubst_flags_t complain
)
2862 int ntparms
= DECL_NTPARMS (tmpl
);
2863 tree targs
= make_tree_vec (ntparms
);
2864 unsigned int len
= vec_safe_length (arglist
);
2865 unsigned int nargs
= (first_arg
== NULL_TREE
? 0 : 1) + len
;
2866 unsigned int skip_without_in_chrg
= 0;
2867 tree first_arg_without_in_chrg
= first_arg
;
2868 tree
*args_without_in_chrg
;
2869 unsigned int nargs_without_in_chrg
;
2870 unsigned int ia
, ix
;
2872 struct z_candidate
*cand
;
2874 struct rejection_reason
*reason
= NULL
;
2877 /* We don't do deduction on the in-charge parameter, the VTT
2878 parameter or 'this'. */
2879 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
2881 if (first_arg_without_in_chrg
!= NULL_TREE
)
2882 first_arg_without_in_chrg
= NULL_TREE
;
2884 ++skip_without_in_chrg
;
2887 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
2888 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
2889 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
2891 if (first_arg_without_in_chrg
!= NULL_TREE
)
2892 first_arg_without_in_chrg
= NULL_TREE
;
2894 ++skip_without_in_chrg
;
2897 if (len
< skip_without_in_chrg
)
2900 nargs_without_in_chrg
= ((first_arg_without_in_chrg
!= NULL_TREE
? 1 : 0)
2901 + (len
- skip_without_in_chrg
));
2902 args_without_in_chrg
= XALLOCAVEC (tree
, nargs_without_in_chrg
);
2904 if (first_arg_without_in_chrg
!= NULL_TREE
)
2906 args_without_in_chrg
[ia
] = first_arg_without_in_chrg
;
2909 for (ix
= skip_without_in_chrg
;
2910 vec_safe_iterate (arglist
, ix
, &arg
);
2913 args_without_in_chrg
[ia
] = arg
;
2916 gcc_assert (ia
== nargs_without_in_chrg
);
2918 errs
= errorcount
+sorrycount
;
2919 fn
= fn_type_unification (tmpl
, explicit_targs
, targs
,
2920 args_without_in_chrg
,
2921 nargs_without_in_chrg
,
2922 return_type
, strict
, flags
, false,
2923 complain
& tf_decltype
);
2925 if (fn
== error_mark_node
)
2927 /* Don't repeat unification later if it already resulted in errors. */
2928 if (errorcount
+sorrycount
== errs
)
2929 reason
= template_unification_rejection (tmpl
, explicit_targs
,
2930 targs
, args_without_in_chrg
,
2931 nargs_without_in_chrg
,
2932 return_type
, strict
, flags
);
2934 reason
= template_unification_error_rejection ();
2940 A member function template is never instantiated to perform the
2941 copy of a class object to an object of its class type.
2943 It's a little unclear what this means; the standard explicitly
2944 does allow a template to be used to copy a class. For example,
2949 template <class T> A(const T&);
2952 void g () { A a (f ()); }
2954 the member template will be used to make the copy. The section
2955 quoted above appears in the paragraph that forbids constructors
2956 whose only parameter is (a possibly cv-qualified variant of) the
2957 class type, and a logical interpretation is that the intent was
2958 to forbid the instantiation of member templates which would then
2960 if (DECL_CONSTRUCTOR_P (fn
) && nargs
== 2)
2962 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
2963 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
2966 reason
= invalid_copy_with_fn_template_rejection ();
2971 if (obj
!= NULL_TREE
)
2972 /* Aha, this is a conversion function. */
2973 cand
= add_conv_candidate (candidates
, fn
, obj
, first_arg
, arglist
,
2974 access_path
, conversion_path
, complain
);
2976 cand
= add_function_candidate (candidates
, fn
, ctype
,
2977 first_arg
, arglist
, access_path
,
2978 conversion_path
, flags
, complain
);
2979 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
2980 /* This situation can occur if a member template of a template
2981 class is specialized. Then, instantiate_template might return
2982 an instantiation of the specialization, in which case the
2983 DECL_TI_TEMPLATE field will point at the original
2984 specialization. For example:
2986 template <class T> struct S { template <class U> void f(U);
2987 template <> void f(int) {}; };
2991 Here, TMPL will be template <class U> S<double>::f(U).
2992 And, instantiate template will give us the specialization
2993 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2994 for this will point at template <class T> template <> S<T>::f(int),
2995 so that we can find the definition. For the purposes of
2996 overload resolution, however, we want the original TMPL. */
2997 cand
->template_decl
= build_template_info (tmpl
, targs
);
2999 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
3000 cand
->explicit_targs
= explicit_targs
;
3004 return add_candidate (candidates
, tmpl
, first_arg
, arglist
, nargs
, NULL
,
3005 access_path
, conversion_path
, 0, reason
);
3009 static struct z_candidate
*
3010 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
3011 tree explicit_targs
, tree first_arg
,
3012 const vec
<tree
, va_gc
> *arglist
, tree return_type
,
3013 tree access_path
, tree conversion_path
, int flags
,
3014 unification_kind_t strict
, tsubst_flags_t complain
)
3017 add_template_candidate_real (candidates
, tmpl
, ctype
,
3018 explicit_targs
, first_arg
, arglist
,
3019 return_type
, access_path
, conversion_path
,
3020 flags
, NULL_TREE
, strict
, complain
);
3024 static struct z_candidate
*
3025 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
3026 tree obj
, tree first_arg
,
3027 const vec
<tree
, va_gc
> *arglist
,
3028 tree return_type
, tree access_path
,
3029 tree conversion_path
, tsubst_flags_t complain
)
3032 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
3033 first_arg
, arglist
, return_type
, access_path
,
3034 conversion_path
, 0, obj
, DEDUCE_CONV
,
3038 /* The CANDS are the set of candidates that were considered for
3039 overload resolution. Return the set of viable candidates, or CANDS
3040 if none are viable. If any of the candidates were viable, set
3041 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3042 considered viable only if it is strictly viable. */
3044 static struct z_candidate
*
3045 splice_viable (struct z_candidate
*cands
,
3049 struct z_candidate
*viable
;
3050 struct z_candidate
**last_viable
;
3051 struct z_candidate
**cand
;
3053 /* Be strict inside templates, since build_over_call won't actually
3054 do the conversions to get pedwarns. */
3055 if (processing_template_decl
)
3059 last_viable
= &viable
;
3060 *any_viable_p
= false;
3065 struct z_candidate
*c
= *cand
;
3066 if (strict_p
? c
->viable
== 1 : c
->viable
)
3071 last_viable
= &c
->next
;
3072 *any_viable_p
= true;
3078 return viable
? viable
: cands
;
3082 any_strictly_viable (struct z_candidate
*cands
)
3084 for (; cands
; cands
= cands
->next
)
3085 if (cands
->viable
== 1)
3090 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3091 words, it is about to become the "this" pointer for a member
3092 function call. Take the address of the object. */
3095 build_this (tree obj
)
3097 /* In a template, we are only concerned about the type of the
3098 expression, so we can take a shortcut. */
3099 if (processing_template_decl
)
3100 return build_address (obj
);
3102 return cp_build_addr_expr (obj
, tf_warning_or_error
);
3105 /* Returns true iff functions are equivalent. Equivalent functions are
3106 not '==' only if one is a function-local extern function or if
3107 both are extern "C". */
3110 equal_functions (tree fn1
, tree fn2
)
3112 if (TREE_CODE (fn1
) != TREE_CODE (fn2
))
3114 if (TREE_CODE (fn1
) == TEMPLATE_DECL
)
3116 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
3117 || DECL_EXTERN_C_FUNCTION_P (fn1
))
3118 return decls_match (fn1
, fn2
);
3122 /* Print information about a candidate being rejected due to INFO. */
3125 print_conversion_rejection (location_t loc
, struct conversion_info
*info
)
3127 if (info
->n_arg
== -1)
3128 /* Conversion of implicit `this' argument failed. */
3129 inform (loc
, " no known conversion for implicit "
3130 "%<this%> parameter from %qT to %qT",
3131 info
->from_type
, info
->to_type
);
3133 inform (loc
, " no known conversion for argument %d from %qT to %qT",
3134 info
->n_arg
+1, info
->from_type
, info
->to_type
);
3137 /* Print information about a candidate with WANT parameters and we found
3141 print_arity_information (location_t loc
, unsigned int have
, unsigned int want
)
3143 inform_n (loc
, want
,
3144 " candidate expects %d argument, %d provided",
3145 " candidate expects %d arguments, %d provided",
3149 /* Print information about one overload candidate CANDIDATE. MSGSTR
3150 is the text to print before the candidate itself.
3152 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3153 to have been run through gettext by the caller. This wart makes
3154 life simpler in print_z_candidates and for the translators. */
3157 print_z_candidate (location_t loc
, const char *msgstr
,
3158 struct z_candidate
*candidate
)
3160 const char *msg
= (msgstr
== NULL
3162 : ACONCAT ((msgstr
, " ", NULL
)));
3163 location_t cloc
= location_of (candidate
->fn
);
3165 if (identifier_p (candidate
->fn
))
3168 if (candidate
->num_convs
== 3)
3169 inform (cloc
, "%s%D(%T, %T, %T) <built-in>", msg
, candidate
->fn
,
3170 candidate
->convs
[0]->type
,
3171 candidate
->convs
[1]->type
,
3172 candidate
->convs
[2]->type
);
3173 else if (candidate
->num_convs
== 2)
3174 inform (cloc
, "%s%D(%T, %T) <built-in>", msg
, candidate
->fn
,
3175 candidate
->convs
[0]->type
,
3176 candidate
->convs
[1]->type
);
3178 inform (cloc
, "%s%D(%T) <built-in>", msg
, candidate
->fn
,
3179 candidate
->convs
[0]->type
);
3181 else if (TYPE_P (candidate
->fn
))
3182 inform (cloc
, "%s%T <conversion>", msg
, candidate
->fn
);
3183 else if (candidate
->viable
== -1)
3184 inform (cloc
, "%s%#D <near match>", msg
, candidate
->fn
);
3185 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate
->fn
)))
3186 inform (cloc
, "%s%#D <deleted>", msg
, candidate
->fn
);
3188 inform (cloc
, "%s%#D", msg
, candidate
->fn
);
3189 /* Give the user some information about why this candidate failed. */
3190 if (candidate
->reason
!= NULL
)
3192 struct rejection_reason
*r
= candidate
->reason
;
3197 print_arity_information (cloc
, r
->u
.arity
.actual
,
3198 r
->u
.arity
.expected
);
3200 case rr_arg_conversion
:
3201 print_conversion_rejection (cloc
, &r
->u
.conversion
);
3203 case rr_bad_arg_conversion
:
3204 print_conversion_rejection (cloc
, &r
->u
.bad_conversion
);
3206 case rr_explicit_conversion
:
3207 inform (cloc
, " return type %qT of explicit conversion function "
3208 "cannot be converted to %qT with a qualification "
3209 "conversion", r
->u
.conversion
.from_type
,
3210 r
->u
.conversion
.to_type
);
3212 case rr_template_conversion
:
3213 inform (cloc
, " conversion from return type %qT of template "
3214 "conversion function specialization to %qT is not an "
3215 "exact match", r
->u
.conversion
.from_type
,
3216 r
->u
.conversion
.to_type
);
3218 case rr_template_unification
:
3219 /* We use template_unification_error_rejection if unification caused
3220 actual non-SFINAE errors, in which case we don't need to repeat
3222 if (r
->u
.template_unification
.tmpl
== NULL_TREE
)
3224 inform (cloc
, " substitution of deduced template arguments "
3225 "resulted in errors seen above");
3228 /* Re-run template unification with diagnostics. */
3229 inform (cloc
, " template argument deduction/substitution failed:");
3230 fn_type_unification (r
->u
.template_unification
.tmpl
,
3231 r
->u
.template_unification
.explicit_targs
,
3233 (r
->u
.template_unification
.num_targs
)),
3234 r
->u
.template_unification
.args
,
3235 r
->u
.template_unification
.nargs
,
3236 r
->u
.template_unification
.return_type
,
3237 r
->u
.template_unification
.strict
,
3238 r
->u
.template_unification
.flags
,
3241 case rr_invalid_copy
:
3243 " a constructor taking a single argument of its own "
3244 "class type is invalid");
3248 /* This candidate didn't have any issues or we failed to
3249 handle a particular code. Either way... */
3256 print_z_candidates (location_t loc
, struct z_candidate
*candidates
)
3258 struct z_candidate
*cand1
;
3259 struct z_candidate
**cand2
;
3265 /* Remove non-viable deleted candidates. */
3267 for (cand2
= &cand1
; *cand2
; )
3269 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
3270 && !(*cand2
)->viable
3271 && DECL_DELETED_FN ((*cand2
)->fn
))
3272 *cand2
= (*cand2
)->next
;
3274 cand2
= &(*cand2
)->next
;
3276 /* ...if there are any non-deleted ones. */
3280 /* There may be duplicates in the set of candidates. We put off
3281 checking this condition as long as possible, since we have no way
3282 to eliminate duplicates from a set of functions in less than n^2
3283 time. Now we are about to emit an error message, so it is more
3284 permissible to go slowly. */
3285 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3287 tree fn
= cand1
->fn
;
3288 /* Skip builtin candidates and conversion functions. */
3291 cand2
= &cand1
->next
;
3294 if (DECL_P ((*cand2
)->fn
)
3295 && equal_functions (fn
, (*cand2
)->fn
))
3296 *cand2
= (*cand2
)->next
;
3298 cand2
= &(*cand2
)->next
;
3302 for (n_candidates
= 0, cand1
= candidates
; cand1
; cand1
= cand1
->next
)
3305 inform_n (loc
, n_candidates
, "candidate is:", "candidates are:");
3306 for (; candidates
; candidates
= candidates
->next
)
3307 print_z_candidate (loc
, NULL
, candidates
);
3310 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3311 USER_CONV. STD_SEQ is the standard conversion sequence applied to
3312 the result of the conversion function to convert it to the final
3313 desired type. Merge the two sequences into a single sequence,
3314 and return the merged sequence. */
3317 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
3320 bool bad
= user_seq
->bad_p
;
3322 gcc_assert (user_seq
->kind
== ck_user
);
3324 /* Find the end of the second conversion sequence. */
3325 for (t
= &std_seq
; (*t
)->kind
!= ck_identity
; t
= &((*t
)->u
.next
))
3327 /* The entire sequence is a user-conversion sequence. */
3328 (*t
)->user_conv_p
= true;
3333 /* Replace the identity conversion with the user conversion
3340 /* Handle overload resolution for initializing an object of class type from
3341 an initializer list. First we look for a suitable constructor that
3342 takes a std::initializer_list; if we don't find one, we then look for a
3343 non-list constructor.
3345 Parameters are as for add_candidates, except that the arguments are in
3346 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
3347 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
3350 add_list_candidates (tree fns
, tree first_arg
,
3351 tree init_list
, tree totype
,
3352 tree explicit_targs
, bool template_only
,
3353 tree conversion_path
, tree access_path
,
3355 struct z_candidate
**candidates
,
3356 tsubst_flags_t complain
)
3358 vec
<tree
, va_gc
> *args
;
3360 gcc_assert (*candidates
== NULL
);
3362 /* We're looking for a ctor for list-initialization. */
3363 flags
|= LOOKUP_LIST_INIT_CTOR
;
3364 /* And we don't allow narrowing conversions. We also use this flag to
3365 avoid the copy constructor call for copy-list-initialization. */
3366 flags
|= LOOKUP_NO_NARROWING
;
3368 /* Always use the default constructor if the list is empty (DR 990). */
3369 if (CONSTRUCTOR_NELTS (init_list
) == 0
3370 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
3372 /* If the class has a list ctor, try passing the list as a single
3373 argument first, but only consider list ctors. */
3374 else if (TYPE_HAS_LIST_CTOR (totype
))
3376 flags
|= LOOKUP_LIST_ONLY
;
3377 args
= make_tree_vector_single (init_list
);
3378 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3379 explicit_targs
, template_only
, conversion_path
,
3380 access_path
, flags
, candidates
, complain
);
3381 if (any_strictly_viable (*candidates
))
3385 args
= ctor_to_vec (init_list
);
3387 /* We aren't looking for list-ctors anymore. */
3388 flags
&= ~LOOKUP_LIST_ONLY
;
3389 /* We allow more user-defined conversions within an init-list. */
3390 flags
&= ~LOOKUP_NO_CONVERSION
;
3392 add_candidates (fns
, first_arg
, args
, NULL_TREE
,
3393 explicit_targs
, template_only
, conversion_path
,
3394 access_path
, flags
, candidates
, complain
);
3397 /* Returns the best overload candidate to perform the requested
3398 conversion. This function is used for three the overloading situations
3399 described in [over.match.copy], [over.match.conv], and [over.match.ref].
3400 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3401 per [dcl.init.ref], so we ignore temporary bindings. */
3403 static struct z_candidate
*
3404 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
,
3405 tsubst_flags_t complain
)
3407 struct z_candidate
*candidates
, *cand
;
3409 tree ctors
= NULL_TREE
;
3410 tree conv_fns
= NULL_TREE
;
3411 conversion
*conv
= NULL
;
3412 tree first_arg
= NULL_TREE
;
3413 vec
<tree
, va_gc
> *args
= NULL
;
3420 fromtype
= TREE_TYPE (expr
);
3422 /* We represent conversion within a hierarchy using RVALUE_CONV and
3423 BASE_CONV, as specified by [over.best.ics]; these become plain
3424 constructor calls, as specified in [dcl.init]. */
3425 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype
) || !MAYBE_CLASS_TYPE_P (totype
)
3426 || !DERIVED_FROM_P (totype
, fromtype
));
3428 if (MAYBE_CLASS_TYPE_P (totype
))
3429 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3430 creating a garbage BASELINK; constructors can't be inherited. */
3431 ctors
= lookup_fnfields_slot (totype
, complete_ctor_identifier
);
3433 if (MAYBE_CLASS_TYPE_P (fromtype
))
3435 tree to_nonref
= non_reference (totype
);
3436 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
3437 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
3438 && DERIVED_FROM_P (to_nonref
, fromtype
)))
3440 /* [class.conv.fct] A conversion function is never used to
3441 convert a (possibly cv-qualified) object to the (possibly
3442 cv-qualified) same object type (or a reference to it), to a
3443 (possibly cv-qualified) base class of that type (or a
3444 reference to it)... */
3447 conv_fns
= lookup_conversions (fromtype
);
3451 flags
|= LOOKUP_NO_CONVERSION
;
3452 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3453 flags
|= LOOKUP_NO_NARROWING
;
3455 /* It's OK to bind a temporary for converting constructor arguments, but
3456 not in converting the return value of a conversion operator. */
3457 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
);
3458 flags
&= ~LOOKUP_NO_TEMP_BIND
;
3462 int ctorflags
= flags
;
3464 first_arg
= build_int_cst (build_pointer_type (totype
), 0);
3465 first_arg
= build_fold_indirect_ref (first_arg
);
3467 /* We should never try to call the abstract or base constructor
3469 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
3470 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
3472 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
3474 /* List-initialization. */
3475 add_list_candidates (ctors
, first_arg
, expr
, totype
, NULL_TREE
,
3476 false, TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3477 ctorflags
, &candidates
, complain
);
3481 args
= make_tree_vector_single (expr
);
3482 add_candidates (ctors
, first_arg
, args
, NULL_TREE
, NULL_TREE
, false,
3483 TYPE_BINFO (totype
), TYPE_BINFO (totype
),
3484 ctorflags
, &candidates
, complain
);
3487 for (cand
= candidates
; cand
; cand
= cand
->next
)
3489 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
3491 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3492 set, then this is copy-initialization. In that case, "The
3493 result of the call is then used to direct-initialize the
3494 object that is the destination of the copy-initialization."
3497 We represent this in the conversion sequence with an
3498 rvalue conversion, which means a constructor call. */
3499 if (TREE_CODE (totype
) != REFERENCE_TYPE
3500 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3502 = build_conv (ck_rvalue
, totype
, cand
->second_conv
);
3509 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
3511 tree conversion_path
= TREE_PURPOSE (conv_fns
);
3512 struct z_candidate
*old_candidates
;
3514 /* If we are called to convert to a reference type, we are trying to
3515 find a direct binding, so don't even consider temporaries. If
3516 we don't find a direct binding, the caller will try again to
3517 look for a temporary binding. */
3518 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
3519 convflags
|= LOOKUP_NO_TEMP_BIND
;
3521 old_candidates
= candidates
;
3522 add_candidates (TREE_VALUE (conv_fns
), first_arg
, NULL
, totype
,
3524 conversion_path
, TYPE_BINFO (fromtype
),
3525 flags
, &candidates
, complain
);
3527 for (cand
= candidates
; cand
!= old_candidates
; cand
= cand
->next
)
3529 tree rettype
= TREE_TYPE (TREE_TYPE (cand
->fn
));
3531 = implicit_conversion (totype
,
3534 /*c_cast_p=*/false, convflags
,
3537 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3538 copy-initialization. In that case, "The result of the
3539 call is then used to direct-initialize the object that is
3540 the destination of the copy-initialization." [dcl.init]
3542 We represent this in the conversion sequence with an
3543 rvalue conversion, which means a constructor call. But
3544 don't add a second rvalue conversion if there's already
3545 one there. Which there really shouldn't be, but it's
3546 harmless since we'd add it here anyway. */
3547 if (ics
&& MAYBE_CLASS_TYPE_P (totype
) && ics
->kind
!= ck_rvalue
3548 && !(convflags
& LOOKUP_NO_TEMP_BIND
))
3549 ics
= build_conv (ck_rvalue
, totype
, ics
);
3551 cand
->second_conv
= ics
;
3556 cand
->reason
= arg_conversion_rejection (NULL_TREE
, -1,
3559 else if (DECL_NONCONVERTING_P (cand
->fn
)
3560 && ics
->rank
> cr_exact
)
3562 /* 13.3.1.5: For direct-initialization, those explicit
3563 conversion functions that are not hidden within S and
3564 yield type T or a type that can be converted to type T
3565 with a qualification conversion (4.4) are also candidate
3567 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3568 I've raised this issue with the committee. --jason 9/2011 */
3570 cand
->reason
= explicit_conversion_rejection (rettype
, totype
);
3572 else if (cand
->viable
== 1 && ics
->bad_p
)
3576 = bad_arg_conversion_rejection (NULL_TREE
, -1,
3579 else if (primary_template_instantiation_p (cand
->fn
)
3580 && ics
->rank
> cr_exact
)
3582 /* 13.3.3.1.2: If the user-defined conversion is specified by
3583 a specialization of a conversion function template, the
3584 second standard conversion sequence shall have exact match
3587 cand
->reason
= template_conversion_rejection (rettype
, totype
);
3592 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
3596 release_tree_vector (args
);
3600 cand
= tourney (candidates
, complain
);
3603 if (complain
& tf_error
)
3605 error ("conversion from %qT to %qT is ambiguous",
3607 print_z_candidates (location_of (expr
), candidates
);
3610 cand
= candidates
; /* any one will do */
3611 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
3612 cand
->second_conv
->user_conv_p
= true;
3613 if (!any_strictly_viable (candidates
))
3614 cand
->second_conv
->bad_p
= true;
3615 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3616 ambiguous conversion is no worse than another user-defined
3622 /* Build the user conversion sequence. */
3625 (DECL_CONSTRUCTOR_P (cand
->fn
)
3626 ? totype
: non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)))),
3627 build_identity_conv (TREE_TYPE (expr
), expr
));
3629 if (cand
->viable
== -1)
3632 /* Remember that this was a list-initialization. */
3633 if (flags
& LOOKUP_NO_NARROWING
)
3634 conv
->check_narrowing
= true;
3636 /* Combine it with the second conversion sequence. */
3637 cand
->second_conv
= merge_conversion_sequences (conv
,
3643 /* Wrapper for above. */
3646 build_user_type_conversion (tree totype
, tree expr
, int flags
,
3647 tsubst_flags_t complain
)
3649 struct z_candidate
*cand
;
3652 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3653 cand
= build_user_type_conversion_1 (totype
, expr
, flags
, complain
);
3657 if (cand
->second_conv
->kind
== ck_ambig
)
3658 ret
= error_mark_node
;
3661 expr
= convert_like (cand
->second_conv
, expr
, complain
);
3662 ret
= convert_from_reference (expr
);
3668 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3672 /* Subroutine of convert_nontype_argument.
3674 EXPR is an argument for a template non-type parameter of integral or
3675 enumeration type. Do any necessary conversions (that are permitted for
3676 non-type arguments) to convert it to the parameter type.
3678 If conversion is successful, returns the converted expression;
3679 otherwise, returns error_mark_node. */
3682 build_integral_nontype_arg_conv (tree type
, tree expr
, tsubst_flags_t complain
)
3687 location_t loc
= EXPR_LOC_OR_HERE (expr
);
3689 if (error_operand_p (expr
))
3690 return error_mark_node
;
3692 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
3694 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3695 p
= conversion_obstack_alloc (0);
3697 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
3699 LOOKUP_IMPLICIT
, complain
);
3701 /* for a non-type template-parameter of integral or
3702 enumeration type, integral promotions (4.5) and integral
3703 conversions (4.7) are applied. */
3704 /* It should be sufficient to check the outermost conversion step, since
3705 there are no qualification conversions to integer type. */
3709 /* A conversion function is OK. If it isn't constexpr, we'll
3710 complain later that the argument isn't constant. */
3712 /* The lvalue-to-rvalue conversion is OK. */
3718 t
= next_conversion (conv
)->type
;
3719 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t
))
3722 if (complain
& tf_error
)
3723 error_at (loc
, "conversion from %qT to %qT not considered for "
3724 "non-type template argument", t
, type
);
3725 /* and fall through. */
3733 expr
= convert_like (conv
, expr
, complain
);
3735 expr
= error_mark_node
;
3737 /* Free all the conversions we allocated. */
3738 obstack_free (&conversion_obstack
, p
);
3743 /* Do any initial processing on the arguments to a function call. */
3745 static vec
<tree
, va_gc
> *
3746 resolve_args (vec
<tree
, va_gc
> *args
, tsubst_flags_t complain
)
3751 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
3753 if (error_operand_p (arg
))
3755 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
3757 if (complain
& tf_error
)
3758 error ("invalid use of void expression");
3761 else if (invalid_nonstatic_memfn_p (arg
, complain
))
3767 /* Perform overload resolution on FN, which is called with the ARGS.
3769 Return the candidate function selected by overload resolution, or
3770 NULL if the event that overload resolution failed. In the case
3771 that overload resolution fails, *CANDIDATES will be the set of
3772 candidates considered, and ANY_VIABLE_P will be set to true or
3773 false to indicate whether or not any of the candidates were
3776 The ARGS should already have gone through RESOLVE_ARGS before this
3777 function is called. */
3779 static struct z_candidate
*
3780 perform_overload_resolution (tree fn
,
3781 const vec
<tree
, va_gc
> *args
,
3782 struct z_candidate
**candidates
,
3783 bool *any_viable_p
, tsubst_flags_t complain
)
3785 struct z_candidate
*cand
;
3786 tree explicit_targs
;
3789 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
3791 explicit_targs
= NULL_TREE
;
3795 *any_viable_p
= true;
3798 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
3799 || TREE_CODE (fn
) == TEMPLATE_DECL
3800 || TREE_CODE (fn
) == OVERLOAD
3801 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
3803 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
3805 explicit_targs
= TREE_OPERAND (fn
, 1);
3806 fn
= TREE_OPERAND (fn
, 0);
3810 /* Add the various candidate functions. */
3811 add_candidates (fn
, NULL_TREE
, args
, NULL_TREE
,
3812 explicit_targs
, template_only
,
3813 /*conversion_path=*/NULL_TREE
,
3814 /*access_path=*/NULL_TREE
,
3816 candidates
, complain
);
3818 *candidates
= splice_viable (*candidates
, pedantic
, any_viable_p
);
3820 cand
= tourney (*candidates
, complain
);
3824 timevar_cond_stop (TV_OVERLOAD
, subtime
);
3828 /* Print an error message about being unable to build a call to FN with
3829 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
3830 be located; CANDIDATES is a possibly empty list of such
3834 print_error_for_call_failure (tree fn
, vec
<tree
, va_gc
> *args
, bool any_viable_p
,
3835 struct z_candidate
*candidates
)
3837 tree name
= DECL_NAME (OVL_CURRENT (fn
));
3838 location_t loc
= location_of (name
);
3841 error_at (loc
, "no matching function for call to %<%D(%A)%>",
3842 name
, build_tree_list_vec (args
));
3844 error_at (loc
, "call of overloaded %<%D(%A)%> is ambiguous",
3845 name
, build_tree_list_vec (args
));
3847 print_z_candidates (loc
, candidates
);
3850 /* Return an expression for a call to FN (a namespace-scope function,
3851 or a static member function) with the ARGS. This may change
3855 build_new_function_call (tree fn
, vec
<tree
, va_gc
> **args
, bool koenig_p
,
3856 tsubst_flags_t complain
)
3858 struct z_candidate
*candidates
, *cand
;
3863 if (args
!= NULL
&& *args
!= NULL
)
3865 *args
= resolve_args (*args
, complain
);
3867 return error_mark_node
;
3871 tm_malloc_replacement (fn
);
3873 /* If this function was found without using argument dependent
3874 lookup, then we want to ignore any undeclared friend
3880 fn
= remove_hidden_names (fn
);
3883 if (complain
& tf_error
)
3884 print_error_for_call_failure (orig_fn
, *args
, false, NULL
);
3885 return error_mark_node
;
3889 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3890 p
= conversion_obstack_alloc (0);
3892 cand
= perform_overload_resolution (fn
, *args
, &candidates
, &any_viable_p
,
3897 if (complain
& tf_error
)
3899 if (!any_viable_p
&& candidates
&& ! candidates
->next
3900 && (TREE_CODE (candidates
->fn
) == FUNCTION_DECL
))
3901 return cp_build_function_call_vec (candidates
->fn
, args
, complain
);
3902 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
3903 fn
= TREE_OPERAND (fn
, 0);
3904 print_error_for_call_failure (fn
, *args
, any_viable_p
, candidates
);
3906 result
= error_mark_node
;
3910 int flags
= LOOKUP_NORMAL
;
3911 /* If fn is template_id_expr, the call has explicit template arguments
3912 (e.g. func<int>(5)), communicate this info to build_over_call
3913 through flags so that later we can use it to decide whether to warn
3914 about peculiar null pointer conversion. */
3915 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
3916 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
3917 result
= build_over_call (cand
, flags
, complain
);
3920 /* Free all the conversions we allocated. */
3921 obstack_free (&conversion_obstack
, p
);
3926 /* Build a call to a global operator new. FNNAME is the name of the
3927 operator (either "operator new" or "operator new[]") and ARGS are
3928 the arguments provided. This may change ARGS. *SIZE points to the
3929 total number of bytes required by the allocation, and is updated if
3930 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3931 be used. If this function determines that no cookie should be
3932 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
3933 is not NULL_TREE, it is evaluated before calculating the final
3934 array size, and if it fails, the array size is replaced with
3935 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
3936 is non-NULL, it will be set, upon return, to the allocation
3940 build_operator_new_call (tree fnname
, vec
<tree
, va_gc
> **args
,
3941 tree
*size
, tree
*cookie_size
, tree size_check
,
3942 tree
*fn
, tsubst_flags_t complain
)
3944 tree original_size
= *size
;
3946 struct z_candidate
*candidates
;
3947 struct z_candidate
*cand
;
3952 /* Set to (size_t)-1 if the size check fails. */
3953 if (size_check
!= NULL_TREE
)
3954 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
3955 original_size
, TYPE_MAX_VALUE (sizetype
));
3956 vec_safe_insert (*args
, 0, *size
);
3957 *args
= resolve_args (*args
, complain
);
3959 return error_mark_node
;
3965 If this lookup fails to find the name, or if the allocated type
3966 is not a class type, the allocation function's name is looked
3967 up in the global scope.
3969 we disregard block-scope declarations of "operator new". */
3970 fns
= lookup_function_nonclass (fnname
, *args
, /*block_p=*/false);
3972 /* Figure out what function is being called. */
3973 cand
= perform_overload_resolution (fns
, *args
, &candidates
, &any_viable_p
,
3976 /* If no suitable function could be found, issue an error message
3980 if (complain
& tf_error
)
3981 print_error_for_call_failure (fns
, *args
, any_viable_p
, candidates
);
3982 return error_mark_node
;
3985 /* If a cookie is required, add some extra space. Whether
3986 or not a cookie is required cannot be determined until
3987 after we know which function was called. */
3990 bool use_cookie
= true;
3991 if (!abi_version_at_least (2))
3993 /* In G++ 3.2, the check was implemented incorrectly; it
3994 looked at the placement expression, rather than the
3995 type of the function. */
3996 if ((*args
)->length () == 2
3997 && same_type_p (TREE_TYPE ((**args
)[1]), ptr_type_node
))
4004 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
4005 /* Skip the size_t parameter. */
4006 arg_types
= TREE_CHAIN (arg_types
);
4007 /* Check the remaining parameters (if any). */
4009 && TREE_CHAIN (arg_types
) == void_list_node
4010 && same_type_p (TREE_VALUE (arg_types
),
4014 /* If we need a cookie, adjust the number of bytes allocated. */
4017 /* Update the total size. */
4018 *size
= size_binop (PLUS_EXPR
, original_size
, *cookie_size
);
4019 /* Set to (size_t)-1 if the size check fails. */
4020 gcc_assert (size_check
!= NULL_TREE
);
4021 *size
= fold_build3 (COND_EXPR
, sizetype
, size_check
,
4022 *size
, TYPE_MAX_VALUE (sizetype
));
4023 /* Update the argument list to reflect the adjusted size. */
4024 (**args
)[0] = *size
;
4027 *cookie_size
= NULL_TREE
;
4030 /* Tell our caller which function we decided to call. */
4034 /* Build the CALL_EXPR. */
4035 return build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4038 /* Build a new call to operator(). This may change ARGS. */
4041 build_op_call_1 (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4043 struct z_candidate
*candidates
= 0, *cand
;
4044 tree fns
, convs
, first_mem_arg
= NULL_TREE
;
4045 tree type
= TREE_TYPE (obj
);
4047 tree result
= NULL_TREE
;
4050 if (error_operand_p (obj
))
4051 return error_mark_node
;
4053 obj
= prep_operand (obj
);
4055 if (TYPE_PTRMEMFUNC_P (type
))
4057 if (complain
& tf_error
)
4058 /* It's no good looking for an overloaded operator() on a
4059 pointer-to-member-function. */
4060 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
4061 return error_mark_node
;
4064 if (TYPE_BINFO (type
))
4066 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
4067 if (fns
== error_mark_node
)
4068 return error_mark_node
;
4073 if (args
!= NULL
&& *args
!= NULL
)
4075 *args
= resolve_args (*args
, complain
);
4077 return error_mark_node
;
4080 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4081 p
= conversion_obstack_alloc (0);
4085 first_mem_arg
= obj
;
4087 add_candidates (BASELINK_FUNCTIONS (fns
),
4088 first_mem_arg
, *args
, NULL_TREE
,
4090 BASELINK_BINFO (fns
), BASELINK_ACCESS_BINFO (fns
),
4091 LOOKUP_NORMAL
, &candidates
, complain
);
4094 convs
= lookup_conversions (type
);
4096 for (; convs
; convs
= TREE_CHAIN (convs
))
4098 tree fns
= TREE_VALUE (convs
);
4099 tree totype
= TREE_TYPE (convs
);
4101 if (TYPE_PTRFN_P (totype
)
4102 || TYPE_REFFN_P (totype
)
4103 || (TREE_CODE (totype
) == REFERENCE_TYPE
4104 && TYPE_PTRFN_P (TREE_TYPE (totype
))))
4105 for (; fns
; fns
= OVL_NEXT (fns
))
4107 tree fn
= OVL_CURRENT (fns
);
4109 if (DECL_NONCONVERTING_P (fn
))
4112 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4113 add_template_conv_candidate
4114 (&candidates
, fn
, obj
, NULL_TREE
, *args
, totype
,
4115 /*access_path=*/NULL_TREE
,
4116 /*conversion_path=*/NULL_TREE
, complain
);
4118 add_conv_candidate (&candidates
, fn
, obj
, NULL_TREE
,
4119 *args
, /*conversion_path=*/NULL_TREE
,
4120 /*access_path=*/NULL_TREE
, complain
);
4124 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
4127 if (complain
& tf_error
)
4129 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
),
4130 build_tree_list_vec (*args
));
4131 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4133 result
= error_mark_node
;
4137 cand
= tourney (candidates
, complain
);
4140 if (complain
& tf_error
)
4142 error ("call of %<(%T) (%A)%> is ambiguous",
4143 TREE_TYPE (obj
), build_tree_list_vec (*args
));
4144 print_z_candidates (location_of (TREE_TYPE (obj
)), candidates
);
4146 result
= error_mark_node
;
4148 /* Since cand->fn will be a type, not a function, for a conversion
4149 function, we must be careful not to unconditionally look at
4151 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
4152 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
4153 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
4156 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
, -1,
4158 obj
= convert_from_reference (obj
);
4159 result
= cp_build_function_call_vec (obj
, args
, complain
);
4163 /* Free all the conversions we allocated. */
4164 obstack_free (&conversion_obstack
, p
);
4169 /* Wrapper for above. */
4172 build_op_call (tree obj
, vec
<tree
, va_gc
> **args
, tsubst_flags_t complain
)
4175 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4176 ret
= build_op_call_1 (obj
, args
, complain
);
4177 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4181 /* Called by op_error to prepare format strings suitable for the error
4182 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
4183 and a suffix (controlled by NTYPES). */
4186 op_error_string (const char *errmsg
, int ntypes
, bool match
)
4190 const char *msgp
= concat (match
? G_("ambiguous overload for ")
4191 : G_("no match for "), errmsg
, NULL
);
4194 msg
= concat (msgp
, G_(" (operand types are %qT, %qT, and %qT)"), NULL
);
4195 else if (ntypes
== 2)
4196 msg
= concat (msgp
, G_(" (operand types are %qT and %qT)"), NULL
);
4198 msg
= concat (msgp
, G_(" (operand type is %qT)"), NULL
);
4204 op_error (location_t loc
, enum tree_code code
, enum tree_code code2
,
4205 tree arg1
, tree arg2
, tree arg3
, bool match
)
4209 if (code
== MODIFY_EXPR
)
4210 opname
= assignment_operator_name_info
[code2
].name
;
4212 opname
= operator_name_info
[code
].name
;
4217 if (flag_diagnostics_show_caret
)
4218 error_at (loc
, op_error_string (G_("ternary %<operator?:%>"),
4220 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4222 error_at (loc
, op_error_string (G_("ternary %<operator?:%> "
4223 "in %<%E ? %E : %E%>"), 3, match
),
4225 TREE_TYPE (arg1
), TREE_TYPE (arg2
), TREE_TYPE (arg3
));
4228 case POSTINCREMENT_EXPR
:
4229 case POSTDECREMENT_EXPR
:
4230 if (flag_diagnostics_show_caret
)
4231 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4232 opname
, TREE_TYPE (arg1
));
4234 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E%s%>"),
4236 opname
, arg1
, opname
, TREE_TYPE (arg1
));
4240 if (flag_diagnostics_show_caret
)
4241 error_at (loc
, op_error_string (G_("%<operator[]%>"), 2, match
),
4242 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4244 error_at (loc
, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"),
4246 arg1
, arg2
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4251 if (flag_diagnostics_show_caret
)
4252 error_at (loc
, op_error_string (G_("%qs"), 1, match
),
4253 opname
, TREE_TYPE (arg1
));
4255 error_at (loc
, op_error_string (G_("%qs in %<%s %E%>"), 1, match
),
4256 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4261 if (flag_diagnostics_show_caret
)
4262 error_at (loc
, op_error_string (G_("%<operator%s%>"), 2, match
),
4263 opname
, TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4265 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"),
4267 opname
, arg1
, opname
, arg2
,
4268 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4270 if (flag_diagnostics_show_caret
)
4271 error_at (loc
, op_error_string (G_("%<operator%s%>"), 1, match
),
4272 opname
, TREE_TYPE (arg1
));
4274 error_at (loc
, op_error_string (G_("%<operator%s%> in %<%s%E%>"),
4276 opname
, opname
, arg1
, TREE_TYPE (arg1
));
4281 /* Return the implicit conversion sequence that could be used to
4282 convert E1 to E2 in [expr.cond]. */
4285 conditional_conversion (tree e1
, tree e2
, tsubst_flags_t complain
)
4287 tree t1
= non_reference (TREE_TYPE (e1
));
4288 tree t2
= non_reference (TREE_TYPE (e2
));
4294 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
4295 implicitly converted (clause _conv_) to the type "lvalue reference to
4296 T2", subject to the constraint that in the conversion the
4297 reference must bind directly (_dcl.init.ref_) to an lvalue. */
4298 if (real_lvalue_p (e2
))
4300 conv
= implicit_conversion (build_reference_type (t2
),
4304 LOOKUP_NO_TEMP_BIND
|LOOKUP_NO_RVAL_BIND
4305 |LOOKUP_ONLYCONVERTING
,
4313 If E1 and E2 have class type, and the underlying class types are
4314 the same or one is a base class of the other: E1 can be converted
4315 to match E2 if the class of T2 is the same type as, or a base
4316 class of, the class of T1, and the cv-qualification of T2 is the
4317 same cv-qualification as, or a greater cv-qualification than, the
4318 cv-qualification of T1. If the conversion is applied, E1 is
4319 changed to an rvalue of type T2 that still refers to the original
4320 source class object (or the appropriate subobject thereof). */
4321 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
4322 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
4324 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
4326 conv
= build_identity_conv (t1
, e1
);
4327 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
4328 TYPE_MAIN_VARIANT (t2
)))
4329 conv
= build_conv (ck_base
, t2
, conv
);
4331 conv
= build_conv (ck_rvalue
, t2
, conv
);
4340 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
4341 converted to the type that expression E2 would have if E2 were
4342 converted to an rvalue (or the type it has, if E2 is an rvalue). */
4343 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
4344 LOOKUP_IMPLICIT
, complain
);
4347 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
4348 arguments to the conditional expression. */
4351 build_conditional_expr_1 (tree arg1
, tree arg2
, tree arg3
,
4352 tsubst_flags_t complain
)
4356 tree result
= NULL_TREE
;
4357 tree result_type
= NULL_TREE
;
4358 bool lvalue_p
= true;
4359 struct z_candidate
*candidates
= 0;
4360 struct z_candidate
*cand
;
4362 tree orig_arg2
, orig_arg3
;
4364 /* As a G++ extension, the second argument to the conditional can be
4365 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
4366 c'.) If the second operand is omitted, make sure it is
4367 calculated only once. */
4370 if (complain
& tf_error
)
4371 pedwarn (input_location
, OPT_Wpedantic
,
4372 "ISO C++ forbids omitting the middle term of a ?: expression");
4374 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
4375 if (real_lvalue_p (arg1
))
4376 arg2
= arg1
= stabilize_reference (arg1
);
4378 arg2
= arg1
= save_expr (arg1
);
4381 /* If something has already gone wrong, just pass that fact up the
4383 if (error_operand_p (arg1
)
4384 || error_operand_p (arg2
)
4385 || error_operand_p (arg3
))
4386 return error_mark_node
;
4391 if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1
)))
4393 arg1
= force_rvalue (arg1
, complain
);
4394 arg2
= force_rvalue (arg2
, complain
);
4395 arg3
= force_rvalue (arg3
, complain
);
4397 tree arg1_type
= TREE_TYPE (arg1
);
4398 arg2_type
= TREE_TYPE (arg2
);
4399 arg3_type
= TREE_TYPE (arg3
);
4401 if (TREE_CODE (arg2_type
) != VECTOR_TYPE
4402 && TREE_CODE (arg3_type
) != VECTOR_TYPE
)
4404 if (complain
& tf_error
)
4405 error ("at least one operand of a vector conditional operator "
4406 "must be a vector");
4407 return error_mark_node
;
4410 if ((TREE_CODE (arg2_type
) == VECTOR_TYPE
)
4411 != (TREE_CODE (arg3_type
) == VECTOR_TYPE
))
4413 enum stv_conv convert_flag
=
4414 scalar_to_vector (input_location
, VEC_COND_EXPR
, arg2
, arg3
,
4415 complain
& tf_error
);
4417 switch (convert_flag
)
4420 return error_mark_node
;
4423 arg2
= convert (TREE_TYPE (arg3_type
), arg2
);
4424 arg2
= build_vector_from_val (arg3_type
, arg2
);
4425 arg2_type
= TREE_TYPE (arg2
);
4430 arg3
= convert (TREE_TYPE (arg2_type
), arg3
);
4431 arg3
= build_vector_from_val (arg2_type
, arg3
);
4432 arg3_type
= TREE_TYPE (arg3
);
4440 if (!same_type_p (arg2_type
, arg3_type
)
4441 || TYPE_VECTOR_SUBPARTS (arg1_type
)
4442 != TYPE_VECTOR_SUBPARTS (arg2_type
)
4443 || TYPE_SIZE (arg1_type
) != TYPE_SIZE (arg2_type
))
4445 if (complain
& tf_error
)
4446 error ("incompatible vector types in conditional expression: "
4447 "%qT, %qT and %qT", TREE_TYPE (arg1
), TREE_TYPE (orig_arg2
),
4448 TREE_TYPE (orig_arg3
));
4449 return error_mark_node
;
4452 if (!COMPARISON_CLASS_P (arg1
))
4453 arg1
= fold_build2 (NE_EXPR
, signed_type_for (arg1_type
), arg1
,
4454 build_zero_cst (arg1_type
));
4455 return fold_build3 (VEC_COND_EXPR
, arg2_type
, arg1
, arg2
, arg3
);
4460 The first expression is implicitly converted to bool (clause
4462 arg1
= perform_implicit_conversion_flags (boolean_type_node
, arg1
, complain
,
4464 if (error_operand_p (arg1
))
4465 return error_mark_node
;
4469 If either the second or the third operand has type (possibly
4470 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
4471 array-to-pointer (_conv.array_), and function-to-pointer
4472 (_conv.func_) standard conversions are performed on the second
4473 and third operands. */
4474 arg2_type
= unlowered_expr_type (arg2
);
4475 arg3_type
= unlowered_expr_type (arg3
);
4476 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
4478 /* Do the conversions. We don't these for `void' type arguments
4479 since it can't have any effect and since decay_conversion
4480 does not handle that case gracefully. */
4481 if (!VOID_TYPE_P (arg2_type
))
4482 arg2
= decay_conversion (arg2
, complain
);
4483 if (!VOID_TYPE_P (arg3_type
))
4484 arg3
= decay_conversion (arg3
, complain
);
4485 arg2_type
= TREE_TYPE (arg2
);
4486 arg3_type
= TREE_TYPE (arg3
);
4490 One of the following shall hold:
4492 --The second or the third operand (but not both) is a
4493 throw-expression (_except.throw_); the result is of the
4494 type of the other and is an rvalue.
4496 --Both the second and the third operands have type void; the
4497 result is of type void and is an rvalue.
4499 We must avoid calling force_rvalue for expressions of type
4500 "void" because it will complain that their value is being
4502 if (TREE_CODE (arg2
) == THROW_EXPR
4503 && TREE_CODE (arg3
) != THROW_EXPR
)
4505 if (!VOID_TYPE_P (arg3_type
))
4507 arg3
= force_rvalue (arg3
, complain
);
4508 if (arg3
== error_mark_node
)
4509 return error_mark_node
;
4511 arg3_type
= TREE_TYPE (arg3
);
4512 result_type
= arg3_type
;
4514 else if (TREE_CODE (arg2
) != THROW_EXPR
4515 && TREE_CODE (arg3
) == THROW_EXPR
)
4517 if (!VOID_TYPE_P (arg2_type
))
4519 arg2
= force_rvalue (arg2
, complain
);
4520 if (arg2
== error_mark_node
)
4521 return error_mark_node
;
4523 arg2_type
= TREE_TYPE (arg2
);
4524 result_type
= arg2_type
;
4526 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
4527 result_type
= void_type_node
;
4530 if (complain
& tf_error
)
4532 if (VOID_TYPE_P (arg2_type
))
4533 error ("second operand to the conditional operator "
4534 "is of type %<void%>, "
4535 "but the third operand is neither a throw-expression "
4536 "nor of type %<void%>");
4538 error ("third operand to the conditional operator "
4539 "is of type %<void%>, "
4540 "but the second operand is neither a throw-expression "
4541 "nor of type %<void%>");
4543 return error_mark_node
;
4547 goto valid_operands
;
4551 Otherwise, if the second and third operand have different types,
4552 and either has (possibly cv-qualified) class type, an attempt is
4553 made to convert each of those operands to the type of the other. */
4554 else if (!same_type_p (arg2_type
, arg3_type
)
4555 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
4560 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4561 p
= conversion_obstack_alloc (0);
4563 conv2
= conditional_conversion (arg2
, arg3
, complain
);
4564 conv3
= conditional_conversion (arg3
, arg2
, complain
);
4568 If both can be converted, or one can be converted but the
4569 conversion is ambiguous, the program is ill-formed. If
4570 neither can be converted, the operands are left unchanged and
4571 further checking is performed as described below. If exactly
4572 one conversion is possible, that conversion is applied to the
4573 chosen operand and the converted operand is used in place of
4574 the original operand for the remainder of this section. */
4575 if ((conv2
&& !conv2
->bad_p
4576 && conv3
&& !conv3
->bad_p
)
4577 || (conv2
&& conv2
->kind
== ck_ambig
)
4578 || (conv3
&& conv3
->kind
== ck_ambig
))
4580 error ("operands to ?: have different types %qT and %qT",
4581 arg2_type
, arg3_type
);
4582 result
= error_mark_node
;
4584 else if (conv2
&& (!conv2
->bad_p
|| !conv3
))
4586 arg2
= convert_like (conv2
, arg2
, complain
);
4587 arg2
= convert_from_reference (arg2
);
4588 arg2_type
= TREE_TYPE (arg2
);
4589 /* Even if CONV2 is a valid conversion, the result of the
4590 conversion may be invalid. For example, if ARG3 has type
4591 "volatile X", and X does not have a copy constructor
4592 accepting a "volatile X&", then even if ARG2 can be
4593 converted to X, the conversion will fail. */
4594 if (error_operand_p (arg2
))
4595 result
= error_mark_node
;
4597 else if (conv3
&& (!conv3
->bad_p
|| !conv2
))
4599 arg3
= convert_like (conv3
, arg3
, complain
);
4600 arg3
= convert_from_reference (arg3
);
4601 arg3_type
= TREE_TYPE (arg3
);
4602 if (error_operand_p (arg3
))
4603 result
= error_mark_node
;
4606 /* Free all the conversions we allocated. */
4607 obstack_free (&conversion_obstack
, p
);
4612 /* If, after the conversion, both operands have class type,
4613 treat the cv-qualification of both operands as if it were the
4614 union of the cv-qualification of the operands.
4616 The standard is not clear about what to do in this
4617 circumstance. For example, if the first operand has type
4618 "const X" and the second operand has a user-defined
4619 conversion to "volatile X", what is the type of the second
4620 operand after this step? Making it be "const X" (matching
4621 the first operand) seems wrong, as that discards the
4622 qualification without actually performing a copy. Leaving it
4623 as "volatile X" seems wrong as that will result in the
4624 conditional expression failing altogether, even though,
4625 according to this step, the one operand could be converted to
4626 the type of the other. */
4627 if ((conv2
|| conv3
)
4628 && CLASS_TYPE_P (arg2_type
)
4629 && cp_type_quals (arg2_type
) != cp_type_quals (arg3_type
))
4630 arg2_type
= arg3_type
=
4631 cp_build_qualified_type (arg2_type
,
4632 cp_type_quals (arg2_type
)
4633 | cp_type_quals (arg3_type
));
4638 If the second and third operands are lvalues and have the same
4639 type, the result is of that type and is an lvalue. */
4640 if (real_lvalue_p (arg2
)
4641 && real_lvalue_p (arg3
)
4642 && same_type_p (arg2_type
, arg3_type
))
4644 result_type
= arg2_type
;
4645 arg2
= mark_lvalue_use (arg2
);
4646 arg3
= mark_lvalue_use (arg3
);
4647 goto valid_operands
;
4652 Otherwise, the result is an rvalue. If the second and third
4653 operand do not have the same type, and either has (possibly
4654 cv-qualified) class type, overload resolution is used to
4655 determine the conversions (if any) to be applied to the operands
4656 (_over.match.oper_, _over.built_). */
4658 if (!same_type_p (arg2_type
, arg3_type
)
4659 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
4665 /* Rearrange the arguments so that add_builtin_candidate only has
4666 to know about two args. In build_builtin_candidate, the
4667 arguments are unscrambled. */
4671 add_builtin_candidates (&candidates
,
4674 ansi_opname (COND_EXPR
),
4676 LOOKUP_NORMAL
, complain
);
4680 If the overload resolution fails, the program is
4682 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
4685 if (complain
& tf_error
)
4687 op_error (input_location
, COND_EXPR
, NOP_EXPR
,
4688 arg1
, arg2
, arg3
, FALSE
);
4689 print_z_candidates (location_of (arg1
), candidates
);
4691 return error_mark_node
;
4693 cand
= tourney (candidates
, complain
);
4696 if (complain
& tf_error
)
4698 op_error (input_location
, COND_EXPR
, NOP_EXPR
,
4699 arg1
, arg2
, arg3
, FALSE
);
4700 print_z_candidates (location_of (arg1
), candidates
);
4702 return error_mark_node
;
4707 Otherwise, the conversions thus determined are applied, and
4708 the converted operands are used in place of the original
4709 operands for the remainder of this section. */
4710 conv
= cand
->convs
[0];
4711 arg1
= convert_like (conv
, arg1
, complain
);
4712 conv
= cand
->convs
[1];
4713 arg2
= convert_like (conv
, arg2
, complain
);
4714 arg2_type
= TREE_TYPE (arg2
);
4715 conv
= cand
->convs
[2];
4716 arg3
= convert_like (conv
, arg3
, complain
);
4717 arg3_type
= TREE_TYPE (arg3
);
4722 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
4723 and function-to-pointer (_conv.func_) standard conversions are
4724 performed on the second and third operands.
4726 We need to force the lvalue-to-rvalue conversion here for class types,
4727 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
4728 that isn't wrapped with a TARGET_EXPR plays havoc with exception
4731 arg2
= force_rvalue (arg2
, complain
);
4732 if (!CLASS_TYPE_P (arg2_type
))
4733 arg2_type
= TREE_TYPE (arg2
);
4735 arg3
= force_rvalue (arg3
, complain
);
4736 if (!CLASS_TYPE_P (arg3_type
))
4737 arg3_type
= TREE_TYPE (arg3
);
4739 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
4740 return error_mark_node
;
4744 After those conversions, one of the following shall hold:
4746 --The second and third operands have the same type; the result is of
4748 if (same_type_p (arg2_type
, arg3_type
))
4749 result_type
= arg2_type
;
4752 --The second and third operands have arithmetic or enumeration
4753 type; the usual arithmetic conversions are performed to bring
4754 them to a common type, and the result is of that type. */
4755 else if ((ARITHMETIC_TYPE_P (arg2_type
)
4756 || UNSCOPED_ENUM_P (arg2_type
))
4757 && (ARITHMETIC_TYPE_P (arg3_type
)
4758 || UNSCOPED_ENUM_P (arg3_type
)))
4760 /* In this case, there is always a common type. */
4761 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
4763 do_warn_double_promotion (result_type
, arg2_type
, arg3_type
,
4764 "implicit conversion from %qT to %qT to "
4765 "match other result of conditional",
4768 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
4769 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
4771 if (TREE_CODE (orig_arg2
) == CONST_DECL
4772 && TREE_CODE (orig_arg3
) == CONST_DECL
4773 && DECL_CONTEXT (orig_arg2
) == DECL_CONTEXT (orig_arg3
))
4774 /* Two enumerators from the same enumeration can have different
4775 types when the enumeration is still being defined. */;
4776 else if (complain
& tf_warning
)
4777 warning (OPT_Wenum_compare
,
4778 "enumeral mismatch in conditional expression: %qT vs %qT",
4779 arg2_type
, arg3_type
);
4781 else if (extra_warnings
4782 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
4783 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
4784 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
4785 && !same_type_p (arg2_type
, type_promotes_to (arg3_type
)))))
4787 if (complain
& tf_warning
)
4789 "enumeral and non-enumeral type in conditional expression");
4792 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
4793 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
4797 --The second and third operands have pointer type, or one has
4798 pointer type and the other is a null pointer constant; pointer
4799 conversions (_conv.ptr_) and qualification conversions
4800 (_conv.qual_) are performed to bring them to their composite
4801 pointer type (_expr.rel_). The result is of the composite
4804 --The second and third operands have pointer to member type, or
4805 one has pointer to member type and the other is a null pointer
4806 constant; pointer to member conversions (_conv.mem_) and
4807 qualification conversions (_conv.qual_) are performed to bring
4808 them to a common type, whose cv-qualification shall match the
4809 cv-qualification of either the second or the third operand.
4810 The result is of the common type. */
4811 else if ((null_ptr_cst_p (arg2
)
4812 && TYPE_PTR_OR_PTRMEM_P (arg3_type
))
4813 || (null_ptr_cst_p (arg3
)
4814 && TYPE_PTR_OR_PTRMEM_P (arg2_type
))
4815 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
4816 || (TYPE_PTRDATAMEM_P (arg2_type
) && TYPE_PTRDATAMEM_P (arg3_type
))
4817 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
4819 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
4820 arg3
, CPO_CONDITIONAL_EXPR
,
4822 if (result_type
== error_mark_node
)
4823 return error_mark_node
;
4824 arg2
= perform_implicit_conversion (result_type
, arg2
, complain
);
4825 arg3
= perform_implicit_conversion (result_type
, arg3
, complain
);
4830 if (complain
& tf_error
)
4831 error ("operands to ?: have different types %qT and %qT",
4832 arg2_type
, arg3_type
);
4833 return error_mark_node
;
4836 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
4837 return error_mark_node
;
4840 result
= build3 (COND_EXPR
, result_type
, arg1
, arg2
, arg3
);
4841 if (!cp_unevaluated_operand
)
4842 /* Avoid folding within decltype (c++/42013) and noexcept. */
4843 result
= fold_if_not_in_template (result
);
4845 /* We can't use result_type below, as fold might have returned a
4850 /* Expand both sides into the same slot, hopefully the target of
4851 the ?: expression. We used to check for TARGET_EXPRs here,
4852 but now we sometimes wrap them in NOP_EXPRs so the test would
4854 if (CLASS_TYPE_P (TREE_TYPE (result
)))
4855 result
= get_target_expr_sfinae (result
, complain
);
4856 /* If this expression is an rvalue, but might be mistaken for an
4857 lvalue, we must add a NON_LVALUE_EXPR. */
4858 result
= rvalue (result
);
4861 result
= force_paren_expr (result
);
4866 /* Wrapper for above. */
4869 build_conditional_expr (tree arg1
, tree arg2
, tree arg3
,
4870 tsubst_flags_t complain
)
4873 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
4874 ret
= build_conditional_expr_1 (arg1
, arg2
, arg3
, complain
);
4875 timevar_cond_stop (TV_OVERLOAD
, subtime
);
4879 /* OPERAND is an operand to an expression. Perform necessary steps
4880 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4884 prep_operand (tree operand
)
4888 if (CLASS_TYPE_P (TREE_TYPE (operand
))
4889 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
4890 /* Make sure the template type is instantiated now. */
4891 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
4897 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4898 OVERLOAD) to the CANDIDATES, returning an updated list of
4899 CANDIDATES. The ARGS are the arguments provided to the call;
4900 if FIRST_ARG is non-null it is the implicit object argument,
4901 otherwise the first element of ARGS is used if needed. The
4902 EXPLICIT_TARGS are explicit template arguments provided.
4903 TEMPLATE_ONLY is true if only template functions should be
4904 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4905 add_function_candidate. */
4908 add_candidates (tree fns
, tree first_arg
, const vec
<tree
, va_gc
> *args
,
4910 tree explicit_targs
, bool template_only
,
4911 tree conversion_path
, tree access_path
,
4913 struct z_candidate
**candidates
,
4914 tsubst_flags_t complain
)
4917 const vec
<tree
, va_gc
> *non_static_args
;
4918 bool check_list_ctor
;
4919 bool check_converting
;
4920 unification_kind_t strict
;
4926 /* Precalculate special handling of constructors and conversion ops. */
4927 fn
= OVL_CURRENT (fns
);
4928 if (DECL_CONV_FN_P (fn
))
4930 check_list_ctor
= false;
4931 check_converting
= !!(flags
& LOOKUP_ONLYCONVERTING
);
4932 if (flags
& LOOKUP_NO_CONVERSION
)
4933 /* We're doing return_type(x). */
4934 strict
= DEDUCE_CONV
;
4936 /* We're doing x.operator return_type(). */
4937 strict
= DEDUCE_EXACT
;
4938 /* [over.match.funcs] For conversion functions, the function
4939 is considered to be a member of the class of the implicit
4940 object argument for the purpose of defining the type of
4941 the implicit object parameter. */
4942 ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (first_arg
));
4946 if (DECL_CONSTRUCTOR_P (fn
))
4948 check_list_ctor
= !!(flags
& LOOKUP_LIST_ONLY
);
4949 /* For list-initialization we consider explicit constructors
4950 and complain if one is chosen. */
4952 = ((flags
& (LOOKUP_ONLYCONVERTING
|LOOKUP_LIST_INIT_CTOR
))
4953 == LOOKUP_ONLYCONVERTING
);
4957 check_list_ctor
= false;
4958 check_converting
= false;
4960 strict
= DEDUCE_CALL
;
4961 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
4965 non_static_args
= args
;
4967 /* Delay creating the implicit this parameter until it is needed. */
4968 non_static_args
= NULL
;
4970 for (; fns
; fns
= OVL_NEXT (fns
))
4973 const vec
<tree
, va_gc
> *fn_args
;
4975 fn
= OVL_CURRENT (fns
);
4977 if (check_converting
&& DECL_NONCONVERTING_P (fn
))
4979 if (check_list_ctor
&& !is_list_ctor (fn
))
4982 /* Figure out which set of arguments to use. */
4983 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
4985 /* If this function is a non-static member and we didn't get an
4986 implicit object argument, move it out of args. */
4987 if (first_arg
== NULL_TREE
)
4991 vec
<tree
, va_gc
> *tempvec
;
4992 vec_alloc (tempvec
, args
->length () - 1);
4993 for (ix
= 1; args
->iterate (ix
, &arg
); ++ix
)
4994 tempvec
->quick_push (arg
);
4995 non_static_args
= tempvec
;
4996 first_arg
= (*args
)[0];
4999 fn_first_arg
= first_arg
;
5000 fn_args
= non_static_args
;
5004 /* Otherwise, just use the list of arguments provided. */
5005 fn_first_arg
= NULL_TREE
;
5009 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5010 add_template_candidate (candidates
,
5022 else if (!template_only
)
5023 add_function_candidate (candidates
,
5036 build_new_op_1 (location_t loc
, enum tree_code code
, int flags
, tree arg1
,
5037 tree arg2
, tree arg3
, tree
*overload
, tsubst_flags_t complain
)
5039 struct z_candidate
*candidates
= 0, *cand
;
5040 vec
<tree
, va_gc
> *arglist
;
5043 tree result
= NULL_TREE
;
5044 bool result_valid_p
= false;
5045 enum tree_code code2
= NOP_EXPR
;
5046 enum tree_code code_orig_arg1
= ERROR_MARK
;
5047 enum tree_code code_orig_arg2
= ERROR_MARK
;
5053 if (error_operand_p (arg1
)
5054 || error_operand_p (arg2
)
5055 || error_operand_p (arg3
))
5056 return error_mark_node
;
5058 if (code
== MODIFY_EXPR
)
5060 code2
= TREE_CODE (arg3
);
5062 fnname
= ansi_assopname (code2
);
5065 fnname
= ansi_opname (code
);
5067 arg1
= prep_operand (arg1
);
5073 case VEC_DELETE_EXPR
:
5075 /* Use build_op_new_call and build_op_delete_call instead. */
5079 /* Use build_op_call instead. */
5082 case TRUTH_ORIF_EXPR
:
5083 case TRUTH_ANDIF_EXPR
:
5084 case TRUTH_AND_EXPR
:
5086 /* These are saved for the sake of warn_logical_operator. */
5087 code_orig_arg1
= TREE_CODE (arg1
);
5088 code_orig_arg2
= TREE_CODE (arg2
);
5094 arg2
= prep_operand (arg2
);
5095 arg3
= prep_operand (arg3
);
5097 if (code
== COND_EXPR
)
5098 /* Use build_conditional_expr instead. */
5100 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1
))
5101 && (! arg2
|| ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))))
5104 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
5105 arg2
= integer_zero_node
;
5107 vec_alloc (arglist
, 3);
5108 arglist
->quick_push (arg1
);
5109 if (arg2
!= NULL_TREE
)
5110 arglist
->quick_push (arg2
);
5111 if (arg3
!= NULL_TREE
)
5112 arglist
->quick_push (arg3
);
5114 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5115 p
= conversion_obstack_alloc (0);
5117 /* Add namespace-scope operators to the list of functions to
5119 add_candidates (lookup_function_nonclass (fnname
, arglist
, /*block_p=*/true),
5120 NULL_TREE
, arglist
, NULL_TREE
,
5121 NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
5122 flags
, &candidates
, complain
);
5126 args
[2] = NULL_TREE
;
5128 /* Add class-member operators to the candidate set. */
5129 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
5133 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
5134 if (fns
== error_mark_node
)
5136 result
= error_mark_node
;
5137 goto user_defined_result_ready
;
5140 add_candidates (BASELINK_FUNCTIONS (fns
),
5141 NULL_TREE
, arglist
, NULL_TREE
,
5143 BASELINK_BINFO (fns
),
5144 BASELINK_ACCESS_BINFO (fns
),
5145 flags
, &candidates
, complain
);
5147 /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then
5148 only non-member functions that have type T1 or reference to
5149 cv-qualified-opt T1 for the first argument, if the first argument
5150 has an enumeration type, or T2 or reference to cv-qualified-opt
5151 T2 for the second argument, if the the second argument has an
5152 enumeration type. Filter out those that don't match. */
5153 else if (! arg2
|| ! CLASS_TYPE_P (TREE_TYPE (arg2
)))
5155 struct z_candidate
**candp
, **next
;
5157 for (candp
= &candidates
; *candp
; candp
= next
)
5159 tree parmlist
, parmtype
;
5160 int i
, nargs
= (arg2
? 2 : 1);
5165 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
5167 for (i
= 0; i
< nargs
; ++i
)
5169 parmtype
= TREE_VALUE (parmlist
);
5171 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
5172 parmtype
= TREE_TYPE (parmtype
);
5173 if (TREE_CODE (TREE_TYPE (args
[i
])) == ENUMERAL_TYPE
5174 && (same_type_ignoring_top_level_qualifiers_p
5175 (TREE_TYPE (args
[i
]), parmtype
)))
5178 parmlist
= TREE_CHAIN (parmlist
);
5181 /* No argument has an appropriate type, so remove this
5182 candidate function from the list. */
5185 *candp
= cand
->next
;
5191 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
,
5198 /* For these, the built-in candidates set is empty
5199 [over.match.oper]/3. We don't want non-strict matches
5200 because exact matches are always possible with built-in
5201 operators. The built-in candidate set for COMPONENT_REF
5202 would be empty too, but since there are no such built-in
5203 operators, we accept non-strict matches for them. */
5208 strict_p
= pedantic
;
5212 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
5217 case POSTINCREMENT_EXPR
:
5218 case POSTDECREMENT_EXPR
:
5219 /* Don't try anything fancy if we're not allowed to produce
5221 if (!(complain
& tf_error
))
5222 return error_mark_node
;
5224 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
5225 distinguish between prefix and postfix ++ and
5226 operator++() was used for both, so we allow this with
5230 const char *msg
= (flag_permissive
)
5231 ? G_("no %<%D(int)%> declared for postfix %qs,"
5232 " trying prefix operator instead")
5233 : G_("no %<%D(int)%> declared for postfix %qs");
5234 permerror (loc
, msg
, fnname
, operator_name_info
[code
].name
);
5237 if (!flag_permissive
)
5238 return error_mark_node
;
5240 if (code
== POSTINCREMENT_EXPR
)
5241 code
= PREINCREMENT_EXPR
;
5243 code
= PREDECREMENT_EXPR
;
5244 result
= build_new_op_1 (loc
, code
, flags
, arg1
, NULL_TREE
,
5245 NULL_TREE
, overload
, complain
);
5248 /* The caller will deal with these. */
5253 result_valid_p
= true;
5257 if (complain
& tf_error
)
5259 /* If one of the arguments of the operator represents
5260 an invalid use of member function pointer, try to report
5261 a meaningful error ... */
5262 if (invalid_nonstatic_memfn_p (arg1
, tf_error
)
5263 || invalid_nonstatic_memfn_p (arg2
, tf_error
)
5264 || invalid_nonstatic_memfn_p (arg3
, tf_error
))
5265 /* We displayed the error message. */;
5268 /* ... Otherwise, report the more generic
5269 "no matching operator found" error */
5270 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, FALSE
);
5271 print_z_candidates (loc
, candidates
);
5274 result
= error_mark_node
;
5280 cand
= tourney (candidates
, complain
);
5283 if (complain
& tf_error
)
5285 op_error (loc
, code
, code2
, arg1
, arg2
, arg3
, TRUE
);
5286 print_z_candidates (loc
, candidates
);
5288 result
= error_mark_node
;
5290 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
5293 *overload
= cand
->fn
;
5295 if (resolve_args (arglist
, complain
) == NULL
)
5296 result
= error_mark_node
;
5298 result
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5302 /* Give any warnings we noticed during overload resolution. */
5303 if (cand
->warnings
&& (complain
& tf_warning
))
5305 struct candidate_warning
*w
;
5306 for (w
= cand
->warnings
; w
; w
= w
->next
)
5307 joust (cand
, w
->loser
, 1, complain
);
5310 /* Check for comparison of different enum types. */
5319 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
5320 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
5321 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
5322 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
)))
5323 && (complain
& tf_warning
))
5325 warning (OPT_Wenum_compare
,
5326 "comparison between %q#T and %q#T",
5327 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
5334 /* We need to strip any leading REF_BIND so that bitfields
5335 don't cause errors. This should not remove any important
5336 conversions, because builtins don't apply to class
5337 objects directly. */
5338 conv
= cand
->convs
[0];
5339 if (conv
->kind
== ck_ref_bind
)
5340 conv
= next_conversion (conv
);
5341 arg1
= convert_like (conv
, arg1
, complain
);
5345 conv
= cand
->convs
[1];
5346 if (conv
->kind
== ck_ref_bind
)
5347 conv
= next_conversion (conv
);
5349 arg2
= decay_conversion (arg2
, complain
);
5351 /* We need to call warn_logical_operator before
5352 converting arg2 to a boolean_type, but after
5353 decaying an enumerator to its value. */
5354 if (complain
& tf_warning
)
5355 warn_logical_operator (loc
, code
, boolean_type_node
,
5356 code_orig_arg1
, arg1
,
5357 code_orig_arg2
, arg2
);
5359 arg2
= convert_like (conv
, arg2
, complain
);
5363 conv
= cand
->convs
[2];
5364 if (conv
->kind
== ck_ref_bind
)
5365 conv
= next_conversion (conv
);
5366 arg3
= convert_like (conv
, arg3
, complain
);
5372 user_defined_result_ready
:
5374 /* Free all the conversions we allocated. */
5375 obstack_free (&conversion_obstack
, p
);
5377 if (result
|| result_valid_p
)
5384 return cp_build_modify_expr (arg1
, code2
, arg2
, complain
);
5387 return cp_build_indirect_ref (arg1
, RO_UNARY_STAR
, complain
);
5389 case TRUTH_ANDIF_EXPR
:
5390 case TRUTH_ORIF_EXPR
:
5391 case TRUTH_AND_EXPR
:
5393 warn_logical_operator (loc
, code
, boolean_type_node
,
5394 code_orig_arg1
, arg1
, code_orig_arg2
, arg2
);
5399 case TRUNC_DIV_EXPR
:
5410 case TRUNC_MOD_EXPR
:
5414 return cp_build_binary_op (input_location
, code
, arg1
, arg2
, complain
);
5416 case UNARY_PLUS_EXPR
:
5419 case TRUTH_NOT_EXPR
:
5420 case PREINCREMENT_EXPR
:
5421 case POSTINCREMENT_EXPR
:
5422 case PREDECREMENT_EXPR
:
5423 case POSTDECREMENT_EXPR
:
5427 return cp_build_unary_op (code
, arg1
, candidates
!= 0, complain
);
5430 return cp_build_array_ref (input_location
, arg1
, arg2
, complain
);
5433 return build_m_component_ref (cp_build_indirect_ref (arg1
, RO_ARROW_STAR
,
5437 /* The caller will deal with these. */
5449 /* Wrapper for above. */
5452 build_new_op (location_t loc
, enum tree_code code
, int flags
,
5453 tree arg1
, tree arg2
, tree arg3
,
5454 tree
*overload
, tsubst_flags_t complain
)
5457 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
5458 ret
= build_new_op_1 (loc
, code
, flags
, arg1
, arg2
, arg3
,
5459 overload
, complain
);
5460 timevar_cond_stop (TV_OVERLOAD
, subtime
);
5464 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
5465 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
5468 non_placement_deallocation_fn_p (tree t
)
5470 /* A template instance is never a usual deallocation function,
5471 regardless of its signature. */
5472 if (TREE_CODE (t
) == TEMPLATE_DECL
5473 || primary_template_instantiation_p (t
))
5476 /* If a class T has a member deallocation function named operator delete
5477 with exactly one parameter, then that function is a usual
5478 (non-placement) deallocation function. If class T does not declare
5479 such an operator delete but does declare a member deallocation
5480 function named operator delete with exactly two parameters, the second
5481 of which has type std::size_t (18.2), then this function is a usual
5482 deallocation function. */
5483 t
= FUNCTION_ARG_CHAIN (t
);
5484 if (t
== void_list_node
5485 || (t
&& same_type_p (TREE_VALUE (t
), size_type_node
)
5486 && TREE_CHAIN (t
) == void_list_node
))
5491 /* Build a call to operator delete. This has to be handled very specially,
5492 because the restrictions on what signatures match are different from all
5493 other call instances. For a normal delete, only a delete taking (void *)
5494 or (void *, size_t) is accepted. For a placement delete, only an exact
5495 match with the placement new is accepted.
5497 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
5498 ADDR is the pointer to be deleted.
5499 SIZE is the size of the memory block to be deleted.
5500 GLOBAL_P is true if the delete-expression should not consider
5501 class-specific delete operators.
5502 PLACEMENT is the corresponding placement new call, or NULL_TREE.
5504 If this call to "operator delete" is being generated as part to
5505 deallocate memory allocated via a new-expression (as per [expr.new]
5506 which requires that if the initialization throws an exception then
5507 we call a deallocation function), then ALLOC_FN is the allocation
5511 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
5512 bool global_p
, tree placement
,
5513 tree alloc_fn
, tsubst_flags_t complain
)
5515 tree fn
= NULL_TREE
;
5516 tree fns
, fnname
, type
, t
;
5518 if (addr
== error_mark_node
)
5519 return error_mark_node
;
5521 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
5523 fnname
= ansi_opname (code
);
5525 if (CLASS_TYPE_P (type
)
5526 && COMPLETE_TYPE_P (complete_type (type
))
5530 If the result of the lookup is ambiguous or inaccessible, or if
5531 the lookup selects a placement deallocation function, the
5532 program is ill-formed.
5534 Therefore, we ask lookup_fnfields to complain about ambiguity. */
5536 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
5537 if (fns
== error_mark_node
)
5538 return error_mark_node
;
5543 if (fns
== NULL_TREE
)
5544 fns
= lookup_name_nonclass (fnname
);
5546 /* Strip const and volatile from addr. */
5547 addr
= cp_convert (ptr_type_node
, addr
, complain
);
5551 /* "A declaration of a placement deallocation function matches the
5552 declaration of a placement allocation function if it has the same
5553 number of parameters and, after parameter transformations (8.3.5),
5554 all parameter types except the first are identical."
5556 So we build up the function type we want and ask instantiate_type
5557 to get it for us. */
5558 t
= FUNCTION_ARG_CHAIN (alloc_fn
);
5559 t
= tree_cons (NULL_TREE
, ptr_type_node
, t
);
5560 t
= build_function_type (void_type_node
, t
);
5562 fn
= instantiate_type (t
, fns
, tf_none
);
5563 if (fn
== error_mark_node
)
5566 if (BASELINK_P (fn
))
5567 fn
= BASELINK_FUNCTIONS (fn
);
5569 /* "If the lookup finds the two-parameter form of a usual deallocation
5570 function (3.7.4.2) and that function, considered as a placement
5571 deallocation function, would have been selected as a match for the
5572 allocation function, the program is ill-formed." */
5573 if (non_placement_deallocation_fn_p (fn
))
5575 /* But if the class has an operator delete (void *), then that is
5576 the usual deallocation function, so we shouldn't complain
5577 about using the operator delete (void *, size_t). */
5578 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5579 t
; t
= OVL_NEXT (t
))
5581 tree elt
= OVL_CURRENT (t
);
5582 if (non_placement_deallocation_fn_p (elt
)
5583 && FUNCTION_ARG_CHAIN (elt
) == void_list_node
)
5586 if (complain
& tf_error
)
5588 permerror (0, "non-placement deallocation function %q+D", fn
);
5589 permerror (input_location
, "selected for placement delete");
5592 return error_mark_node
;
5597 /* "Any non-placement deallocation function matches a non-placement
5598 allocation function. If the lookup finds a single matching
5599 deallocation function, that function will be called; otherwise, no
5600 deallocation function will be called." */
5601 for (t
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
5602 t
; t
= OVL_NEXT (t
))
5604 tree elt
= OVL_CURRENT (t
);
5605 if (non_placement_deallocation_fn_p (elt
))
5608 /* "If a class T has a member deallocation function named
5609 operator delete with exactly one parameter, then that
5610 function is a usual (non-placement) deallocation
5611 function. If class T does not declare such an operator
5612 delete but does declare a member deallocation function named
5613 operator delete with exactly two parameters, the second of
5614 which has type std::size_t (18.2), then this function is a
5615 usual deallocation function."
5617 So (void*) beats (void*, size_t). */
5618 if (FUNCTION_ARG_CHAIN (fn
) == void_list_node
)
5623 /* If we have a matching function, call it. */
5626 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
5628 /* If the FN is a member function, make sure that it is
5630 if (BASELINK_P (fns
))
5631 perform_or_defer_access_check (BASELINK_BINFO (fns
), fn
, fn
,
5634 /* Core issue 901: It's ok to new a type with deleted delete. */
5635 if (DECL_DELETED_FN (fn
) && alloc_fn
)
5640 /* The placement args might not be suitable for overload
5641 resolution at this point, so build the call directly. */
5642 int nargs
= call_expr_nargs (placement
);
5643 tree
*argarray
= XALLOCAVEC (tree
, nargs
);
5646 for (i
= 1; i
< nargs
; i
++)
5647 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
5649 return build_cxx_call (fn
, nargs
, argarray
, complain
);
5654 vec
<tree
, va_gc
> *args
;
5655 vec_alloc (args
, 2);
5656 args
->quick_push (addr
);
5657 if (FUNCTION_ARG_CHAIN (fn
) != void_list_node
)
5658 args
->quick_push (size
);
5659 ret
= cp_build_function_call_vec (fn
, &args
, complain
);
5667 If no unambiguous matching deallocation function can be found,
5668 propagating the exception does not cause the object's memory to
5672 if ((complain
& tf_warning
)
5674 warning (0, "no corresponding deallocation function for %qD",
5679 if (complain
& tf_error
)
5680 error ("no suitable %<operator %s%> for %qT",
5681 operator_name_info
[(int)code
].name
, type
);
5682 return error_mark_node
;
5685 /* If the current scope isn't allowed to access DECL along
5686 BASETYPE_PATH, give an error. The most derived class in
5687 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
5688 the declaration to use in the error diagnostic. */
5691 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
,
5692 tsubst_flags_t complain
)
5694 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
5696 if (!accessible_p (basetype_path
, decl
, true))
5698 if (complain
& tf_error
)
5700 if (TREE_PRIVATE (decl
))
5701 error ("%q+#D is private", diag_decl
);
5702 else if (TREE_PROTECTED (decl
))
5703 error ("%q+#D is protected", diag_decl
);
5705 error ("%q+#D is inaccessible", diag_decl
);
5706 error ("within this context");
5714 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
5715 bitwise or of LOOKUP_* values. If any errors are warnings are
5716 generated, set *DIAGNOSTIC_FN to "error" or "warning",
5717 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
5721 build_temp (tree expr
, tree type
, int flags
,
5722 diagnostic_t
*diagnostic_kind
, tsubst_flags_t complain
)
5725 vec
<tree
, va_gc
> *args
;
5727 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
5728 args
= make_tree_vector_single (expr
);
5729 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
5730 &args
, type
, flags
, complain
);
5731 release_tree_vector (args
);
5732 if (warningcount
+ werrorcount
> savew
)
5733 *diagnostic_kind
= DK_WARNING
;
5734 else if (errorcount
> savee
)
5735 *diagnostic_kind
= DK_ERROR
;
5737 *diagnostic_kind
= DK_UNSPECIFIED
;
5741 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
5742 EXPR is implicitly converted to type TOTYPE.
5743 FN and ARGNUM are used for diagnostics. */
5746 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
5748 /* Issue warnings about peculiar, but valid, uses of NULL. */
5749 if (expr
== null_node
&& TREE_CODE (totype
) != BOOLEAN_TYPE
5750 && ARITHMETIC_TYPE_P (totype
))
5752 source_location loc
=
5753 expansion_point_location_if_in_system_header (input_location
);
5756 warning_at (loc
, OPT_Wconversion_null
,
5757 "passing NULL to non-pointer argument %P of %qD",
5760 warning_at (loc
, OPT_Wconversion_null
,
5761 "converting to non-pointer type %qT from NULL", totype
);
5764 /* Issue warnings if "false" is converted to a NULL pointer */
5765 else if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
5766 && TYPE_PTR_P (totype
))
5769 warning_at (input_location
, OPT_Wconversion_null
,
5770 "converting %<false%> to pointer type for argument %P "
5771 "of %qD", argnum
, fn
);
5773 warning_at (input_location
, OPT_Wconversion_null
,
5774 "converting %<false%> to pointer type %qT", totype
);
5778 /* Perform the conversions in CONVS on the expression EXPR. FN and
5779 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
5780 indicates the `this' argument of a method. INNER is nonzero when
5781 being called to continue a conversion chain. It is negative when a
5782 reference binding will be applied, positive otherwise. If
5783 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
5784 conversions will be emitted if appropriate. If C_CAST_P is true,
5785 this conversion is coming from a C-style cast; in that case,
5786 conversions to inaccessible bases are permitted. */
5789 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
5790 int inner
, bool issue_conversion_warnings
,
5791 bool c_cast_p
, tsubst_flags_t complain
)
5793 tree totype
= convs
->type
;
5794 diagnostic_t diag_kind
;
5796 location_t loc
= EXPR_LOC_OR_HERE (expr
);
5798 if (convs
->bad_p
&& !(complain
& tf_error
))
5799 return error_mark_node
;
5802 && convs
->kind
!= ck_user
5803 && convs
->kind
!= ck_list
5804 && convs
->kind
!= ck_ambig
5805 && (convs
->kind
!= ck_ref_bind
5806 || convs
->user_conv_p
)
5807 && convs
->kind
!= ck_rvalue
5808 && convs
->kind
!= ck_base
)
5810 conversion
*t
= convs
;
5812 /* Give a helpful error if this is bad because of excess braces. */
5813 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
5814 && SCALAR_TYPE_P (totype
)
5815 && CONSTRUCTOR_NELTS (expr
) > 0
5816 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr
, 0)->value
))
5817 permerror (loc
, "too many braces around initializer for %qT", totype
);
5819 for (; t
; t
= next_conversion (t
))
5821 if (t
->kind
== ck_user
&& t
->cand
->reason
)
5823 permerror (loc
, "invalid user-defined conversion "
5824 "from %qT to %qT", TREE_TYPE (expr
), totype
);
5825 print_z_candidate (loc
, "candidate is:", t
->cand
);
5826 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
5827 /*issue_conversion_warnings=*/false,
5830 if (convs
->kind
== ck_ref_bind
)
5831 return convert_to_reference (totype
, expr
, CONV_IMPLICIT
,
5832 LOOKUP_NORMAL
, NULL_TREE
,
5835 return cp_convert (totype
, expr
, complain
);
5837 else if (t
->kind
== ck_user
|| !t
->bad_p
)
5839 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
5840 /*issue_conversion_warnings=*/false,
5845 else if (t
->kind
== ck_ambig
)
5846 return convert_like_real (t
, expr
, fn
, argnum
, 1,
5847 /*issue_conversion_warnings=*/false,
5850 else if (t
->kind
== ck_identity
)
5854 if (permerror (loc
, "invalid conversion from %qT to %qT",
5855 TREE_TYPE (expr
), totype
)
5857 inform (DECL_SOURCE_LOCATION (fn
),
5858 "initializing argument %P of %qD", argnum
, fn
);
5860 return cp_convert (totype
, expr
, complain
);
5863 if (issue_conversion_warnings
&& (complain
& tf_warning
))
5864 conversion_null_warnings (totype
, expr
, fn
, argnum
);
5866 switch (convs
->kind
)
5870 struct z_candidate
*cand
= convs
->cand
;
5871 tree convfn
= cand
->fn
;
5874 /* When converting from an init list we consider explicit
5875 constructors, but actually trying to call one is an error. */
5876 if (DECL_NONCONVERTING_P (convfn
) && DECL_CONSTRUCTOR_P (convfn
)
5877 /* Unless this is for direct-list-initialization. */
5878 && !(BRACE_ENCLOSED_INITIALIZER_P (expr
)
5879 && CONSTRUCTOR_IS_DIRECT_INIT (expr
)))
5881 error ("converting to %qT from initializer list would use "
5882 "explicit constructor %qD", totype
, convfn
);
5885 /* If we're initializing from {}, it's value-initialization. */
5886 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
5887 && CONSTRUCTOR_NELTS (expr
) == 0
5888 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype
))
5890 bool direct
= CONSTRUCTOR_IS_DIRECT_INIT (expr
);
5891 expr
= build_value_init (totype
, complain
);
5892 expr
= get_target_expr_sfinae (expr
, complain
);
5893 if (expr
!= error_mark_node
)
5895 TARGET_EXPR_LIST_INIT_P (expr
) = true;
5896 TARGET_EXPR_DIRECT_INIT_P (expr
) = direct
;
5901 expr
= mark_rvalue_use (expr
);
5903 /* Set user_conv_p on the argument conversions, so rvalue/base
5904 handling knows not to allow any more UDCs. */
5905 for (i
= 0; i
< cand
->num_convs
; ++i
)
5906 cand
->convs
[i
]->user_conv_p
= true;
5908 expr
= build_over_call (cand
, LOOKUP_NORMAL
, complain
);
5910 /* If this is a constructor or a function returning an aggr type,
5911 we need to build up a TARGET_EXPR. */
5912 if (DECL_CONSTRUCTOR_P (convfn
))
5914 expr
= build_cplus_new (totype
, expr
, complain
);
5916 /* Remember that this was list-initialization. */
5917 if (convs
->check_narrowing
&& expr
!= error_mark_node
)
5918 TARGET_EXPR_LIST_INIT_P (expr
) = true;
5924 expr
= mark_rvalue_use (expr
);
5925 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
5927 int nelts
= CONSTRUCTOR_NELTS (expr
);
5929 expr
= build_value_init (totype
, complain
);
5930 else if (nelts
== 1)
5931 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
5936 if (type_unknown_p (expr
))
5937 expr
= instantiate_type (totype
, expr
, complain
);
5938 /* Convert a constant to its underlying value, unless we are
5939 about to bind it to a reference, in which case we need to
5940 leave it as an lvalue. */
5943 expr
= decl_constant_value_safe (expr
);
5944 if (expr
== null_node
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype
))
5945 /* If __null has been converted to an integer type, we do not
5946 want to warn about uses of EXPR as an integer, rather than
5948 expr
= build_int_cst (totype
, 0);
5952 /* We leave bad_p off ck_ambig because overload resolution considers
5953 it valid, it just fails when we try to perform it. So we need to
5954 check complain here, too. */
5955 if (complain
& tf_error
)
5957 /* Call build_user_type_conversion again for the error. */
5958 build_user_type_conversion (totype
, convs
->u
.expr
, LOOKUP_NORMAL
,
5961 inform (input_location
, "initializing argument %P of %q+D",
5964 return error_mark_node
;
5968 /* Conversion to std::initializer_list<T>. */
5969 tree elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype
), 0);
5970 tree new_ctor
= build_constructor (init_list_type_node
, NULL
);
5971 unsigned len
= CONSTRUCTOR_NELTS (expr
);
5972 tree array
, val
, field
;
5973 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
5976 /* Convert all the elements. */
5977 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), ix
, val
)
5979 tree sub
= convert_like_real (convs
->u
.list
[ix
], val
, fn
, argnum
,
5980 1, false, false, complain
);
5981 if (sub
== error_mark_node
)
5983 if (!BRACE_ENCLOSED_INITIALIZER_P (val
))
5984 check_narrowing (TREE_TYPE (sub
), val
);
5985 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor
), NULL_TREE
, sub
);
5986 if (!TREE_CONSTANT (sub
))
5987 TREE_CONSTANT (new_ctor
) = false;
5989 /* Build up the array. */
5990 elttype
= cp_build_qualified_type
5991 (elttype
, cp_type_quals (elttype
) | TYPE_QUAL_CONST
);
5992 array
= build_array_of_n_type (elttype
, len
);
5993 array
= finish_compound_literal (array
, new_ctor
, complain
);
5994 /* Take the address explicitly rather than via decay_conversion
5995 to avoid the error about taking the address of a temporary. */
5996 array
= cp_build_addr_expr (array
, complain
);
5997 array
= cp_convert (build_pointer_type (elttype
), array
, complain
);
5999 /* Build up the initializer_list object. */
6000 totype
= complete_type (totype
);
6001 field
= next_initializable_field (TYPE_FIELDS (totype
));
6002 CONSTRUCTOR_APPEND_ELT (vec
, field
, array
);
6003 field
= next_initializable_field (DECL_CHAIN (field
));
6004 CONSTRUCTOR_APPEND_ELT (vec
, field
, size_int (len
));
6005 new_ctor
= build_constructor (totype
, vec
);
6006 return get_target_expr_sfinae (new_ctor
, complain
);
6010 if (TREE_CODE (totype
) == COMPLEX_TYPE
)
6012 tree real
= CONSTRUCTOR_ELT (expr
, 0)->value
;
6013 tree imag
= CONSTRUCTOR_ELT (expr
, 1)->value
;
6014 real
= perform_implicit_conversion (TREE_TYPE (totype
),
6016 imag
= perform_implicit_conversion (TREE_TYPE (totype
),
6018 expr
= build2 (COMPLEX_EXPR
, totype
, real
, imag
);
6019 return fold_if_not_in_template (expr
);
6021 expr
= reshape_init (totype
, expr
, complain
);
6022 return get_target_expr_sfinae (digest_init (totype
, expr
, complain
),
6029 expr
= convert_like_real (next_conversion (convs
), expr
, fn
, argnum
,
6030 convs
->kind
== ck_ref_bind
? -1 : 1,
6031 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
6034 if (expr
== error_mark_node
)
6035 return error_mark_node
;
6037 switch (convs
->kind
)
6040 expr
= decay_conversion (expr
, complain
);
6041 if (expr
== error_mark_node
)
6042 return error_mark_node
;
6044 if (! MAYBE_CLASS_TYPE_P (totype
))
6046 /* Else fall through. */
6048 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
6050 /* We are going to bind a reference directly to a base-class
6051 subobject of EXPR. */
6052 /* Build an expression for `*((base*) &expr)'. */
6053 expr
= cp_build_addr_expr (expr
, complain
);
6054 expr
= convert_to_base (expr
, build_pointer_type (totype
),
6055 !c_cast_p
, /*nonnull=*/true, complain
);
6056 expr
= cp_build_indirect_ref (expr
, RO_IMPLICIT_CONVERSION
, complain
);
6060 /* Copy-initialization where the cv-unqualified version of the source
6061 type is the same class as, or a derived class of, the class of the
6062 destination [is treated as direct-initialization]. [dcl.init] */
6063 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
6064 if (convs
->user_conv_p
)
6065 /* This conversion is being done in the context of a user-defined
6066 conversion (i.e. the second step of copy-initialization), so
6067 don't allow any more. */
6068 flags
|= LOOKUP_NO_CONVERSION
;
6069 if (convs
->rvaluedness_matches_p
)
6070 flags
|= LOOKUP_PREFER_RVALUE
;
6071 if (TREE_CODE (expr
) == TARGET_EXPR
6072 && TARGET_EXPR_LIST_INIT_P (expr
))
6073 /* Copy-list-initialization doesn't actually involve a copy. */
6075 expr
= build_temp (expr
, totype
, flags
, &diag_kind
, complain
);
6076 if (diag_kind
&& fn
&& complain
)
6077 emit_diagnostic (diag_kind
, DECL_SOURCE_LOCATION (fn
), 0,
6078 " initializing argument %P of %qD", argnum
, fn
);
6079 return build_cplus_new (totype
, expr
, complain
);
6083 tree ref_type
= totype
;
6085 if (convs
->bad_p
&& !next_conversion (convs
)->bad_p
)
6087 gcc_assert (TYPE_REF_IS_RVALUE (ref_type
)
6088 && real_lvalue_p (expr
));
6090 error_at (loc
, "cannot bind %qT lvalue to %qT",
6091 TREE_TYPE (expr
), totype
);
6093 inform (input_location
,
6094 "initializing argument %P of %q+D", argnum
, fn
);
6095 return error_mark_node
;
6098 /* If necessary, create a temporary.
6100 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
6101 that need temporaries, even when their types are reference
6102 compatible with the type of reference being bound, so the
6103 upcoming call to cp_build_addr_expr doesn't fail. */
6104 if (convs
->need_temporary_p
6105 || TREE_CODE (expr
) == CONSTRUCTOR
6106 || TREE_CODE (expr
) == VA_ARG_EXPR
)
6108 /* Otherwise, a temporary of type "cv1 T1" is created and
6109 initialized from the initializer expression using the rules
6110 for a non-reference copy-initialization (8.5). */
6112 tree type
= TREE_TYPE (ref_type
);
6113 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
6115 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6116 (type
, next_conversion (convs
)->type
));
6117 if (!CP_TYPE_CONST_NON_VOLATILE_P (type
)
6118 && !TYPE_REF_IS_RVALUE (ref_type
))
6120 /* If the reference is volatile or non-const, we
6121 cannot create a temporary. */
6122 if (lvalue
& clk_bitfield
)
6123 error_at (loc
, "cannot bind bitfield %qE to %qT",
6125 else if (lvalue
& clk_packed
)
6126 error_at (loc
, "cannot bind packed field %qE to %qT",
6129 error_at (loc
, "cannot bind rvalue %qE to %qT",
6131 return error_mark_node
;
6133 /* If the source is a packed field, and we must use a copy
6134 constructor, then building the target expr will require
6135 binding the field to the reference parameter to the
6136 copy constructor, and we'll end up with an infinite
6137 loop. If we can use a bitwise copy, then we'll be
6139 if ((lvalue
& clk_packed
)
6140 && CLASS_TYPE_P (type
)
6141 && type_has_nontrivial_copy_init (type
))
6143 error_at (loc
, "cannot bind packed field %qE to %qT",
6145 return error_mark_node
;
6147 if (lvalue
& clk_bitfield
)
6149 expr
= convert_bitfield_to_declared_type (expr
);
6150 expr
= fold_convert (type
, expr
);
6152 expr
= build_target_expr_with_type (expr
, type
, complain
);
6155 /* Take the address of the thing to which we will bind the
6157 expr
= cp_build_addr_expr (expr
, complain
);
6158 if (expr
== error_mark_node
)
6159 return error_mark_node
;
6161 /* Convert it to a pointer to the type referred to by the
6162 reference. This will adjust the pointer if a derived to
6163 base conversion is being performed. */
6164 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
6166 /* Convert the pointer to the desired reference type. */
6167 return build_nop (ref_type
, expr
);
6171 return decay_conversion (expr
, complain
);
6174 /* Warn about deprecated conversion if appropriate. */
6175 string_conv_p (totype
, expr
, 1);
6180 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
6181 /*nonnull=*/false, complain
);
6182 return build_nop (totype
, expr
);
6185 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
6186 c_cast_p
, complain
);
6192 if (convs
->check_narrowing
)
6193 check_narrowing (totype
, expr
);
6195 if (issue_conversion_warnings
&& (complain
& tf_warning
))
6196 expr
= convert_and_check (totype
, expr
);
6198 expr
= convert (totype
, expr
);
6203 /* ARG is being passed to a varargs function. Perform any conversions
6204 required. Return the converted value. */
6207 convert_arg_to_ellipsis (tree arg
, tsubst_flags_t complain
)
6210 location_t loc
= EXPR_LOC_OR_HERE (arg
);
6214 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
6215 standard conversions are performed. */
6216 arg
= decay_conversion (arg
, complain
);
6217 arg_type
= TREE_TYPE (arg
);
6220 If the argument has integral or enumeration type that is subject
6221 to the integral promotions (_conv.prom_), or a floating point
6222 type that is subject to the floating point promotion
6223 (_conv.fpprom_), the value of the argument is converted to the
6224 promoted type before the call. */
6225 if (TREE_CODE (arg_type
) == REAL_TYPE
6226 && (TYPE_PRECISION (arg_type
)
6227 < TYPE_PRECISION (double_type_node
))
6228 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type
)))
6230 if ((complain
& tf_warning
)
6231 && warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
6232 warning_at (loc
, OPT_Wdouble_promotion
,
6233 "implicit conversion from %qT to %qT when passing "
6234 "argument to function",
6235 arg_type
, double_type_node
);
6236 arg
= convert_to_real (double_type_node
, arg
);
6238 else if (NULLPTR_TYPE_P (arg_type
))
6239 arg
= null_pointer_node
;
6240 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type
))
6242 if (SCOPED_ENUM_P (arg_type
) && !abi_version_at_least (6))
6244 if (complain
& tf_warning
)
6245 warning_at (loc
, OPT_Wabi
, "scoped enum %qT will not promote to an "
6246 "integral type in a future version of GCC", arg_type
);
6247 arg
= cp_convert (ENUM_UNDERLYING_TYPE (arg_type
), arg
, complain
);
6249 arg
= cp_perform_integral_promotions (arg
, complain
);
6252 arg
= require_complete_type_sfinae (arg
, complain
);
6253 arg_type
= TREE_TYPE (arg
);
6255 if (arg
!= error_mark_node
6256 /* In a template (or ill-formed code), we can have an incomplete type
6257 even after require_complete_type_sfinae, in which case we don't know
6258 whether it has trivial copy or not. */
6259 && COMPLETE_TYPE_P (arg_type
))
6261 /* Build up a real lvalue-to-rvalue conversion in case the
6262 copy constructor is trivial but not callable. */
6263 if (!cp_unevaluated_operand
&& CLASS_TYPE_P (arg_type
))
6264 force_rvalue (arg
, complain
);
6266 /* [expr.call] 5.2.2/7:
6267 Passing a potentially-evaluated argument of class type (Clause 9)
6268 with a non-trivial copy constructor or a non-trivial destructor
6269 with no corresponding parameter is conditionally-supported, with
6270 implementation-defined semantics.
6272 We used to just warn here and do a bitwise copy, but now
6273 cp_expr_size will abort if we try to do that.
6275 If the call appears in the context of a sizeof expression,
6276 it is not potentially-evaluated. */
6277 if (cp_unevaluated_operand
== 0
6278 && (type_has_nontrivial_copy_init (arg_type
)
6279 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type
)))
6281 if (complain
& tf_error
)
6282 error_at (loc
, "cannot pass objects of non-trivially-copyable "
6283 "type %q#T through %<...%>", arg_type
);
6285 return error_mark_node
;
6292 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
6295 build_x_va_arg (source_location loc
, tree expr
, tree type
)
6297 if (processing_template_decl
)
6298 return build_min (VA_ARG_EXPR
, type
, expr
);
6300 type
= complete_type_or_else (type
, NULL_TREE
);
6302 if (expr
== error_mark_node
|| !type
)
6303 return error_mark_node
;
6305 expr
= mark_lvalue_use (expr
);
6307 if (type_has_nontrivial_copy_init (type
)
6308 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
6309 || TREE_CODE (type
) == REFERENCE_TYPE
)
6311 /* Remove reference types so we don't ICE later on. */
6312 tree type1
= non_reference (type
);
6313 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
6314 error ("cannot receive objects of non-trivially-copyable type %q#T "
6315 "through %<...%>; ", type
);
6316 expr
= convert (build_pointer_type (type1
), null_node
);
6317 expr
= cp_build_indirect_ref (expr
, RO_NULL
, tf_warning_or_error
);
6321 return build_va_arg (loc
, expr
, type
);
6324 /* TYPE has been given to va_arg. Apply the default conversions which
6325 would have happened when passed via ellipsis. Return the promoted
6326 type, or the passed type if there is no change. */
6329 cxx_type_promotes_to (tree type
)
6333 /* Perform the array-to-pointer and function-to-pointer
6335 type
= type_decays_to (type
);
6337 promote
= type_promotes_to (type
);
6338 if (same_type_p (type
, promote
))
6344 /* ARG is a default argument expression being passed to a parameter of
6345 the indicated TYPE, which is a parameter to FN. PARMNUM is the
6346 zero-based argument number. Do any required conversions. Return
6347 the converted value. */
6349 static GTY(()) vec
<tree
, va_gc
> *default_arg_context
;
6351 push_defarg_context (tree fn
)
6352 { vec_safe_push (default_arg_context
, fn
); }
6355 pop_defarg_context (void)
6356 { default_arg_context
->pop (); }
6359 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
,
6360 tsubst_flags_t complain
)
6365 /* See through clones. */
6366 fn
= DECL_ORIGIN (fn
);
6368 /* Detect recursion. */
6369 FOR_EACH_VEC_SAFE_ELT (default_arg_context
, i
, t
)
6372 if (complain
& tf_error
)
6373 error ("recursive evaluation of default argument for %q#D", fn
);
6374 return error_mark_node
;
6377 /* If the ARG is an unparsed default argument expression, the
6378 conversion cannot be performed. */
6379 if (TREE_CODE (arg
) == DEFAULT_ARG
)
6381 if (complain
& tf_error
)
6382 error ("call to %qD uses the default argument for parameter %P, which "
6383 "is not yet defined", fn
, parmnum
);
6384 return error_mark_node
;
6387 push_defarg_context (fn
);
6389 if (fn
&& DECL_TEMPLATE_INFO (fn
))
6390 arg
= tsubst_default_argument (fn
, type
, arg
);
6396 The names in the expression are bound, and the semantic
6397 constraints are checked, at the point where the default
6398 expressions appears.
6400 we must not perform access checks here. */
6401 push_deferring_access_checks (dk_no_check
);
6402 /* We must make a copy of ARG, in case subsequent processing
6403 alters any part of it. */
6404 arg
= break_out_target_exprs (arg
);
6405 if (TREE_CODE (arg
) == CONSTRUCTOR
)
6407 arg
= digest_init (type
, arg
, complain
);
6408 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6409 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6414 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_IMPLICIT
,
6415 ICR_DEFAULT_ARGUMENT
, fn
, parmnum
,
6417 arg
= convert_for_arg_passing (type
, arg
, complain
);
6419 pop_deferring_access_checks();
6421 pop_defarg_context ();
6426 /* Returns the type which will really be used for passing an argument of
6430 type_passed_as (tree type
)
6432 /* Pass classes with copy ctors by invisible reference. */
6433 if (TREE_ADDRESSABLE (type
))
6435 type
= build_reference_type (type
);
6436 /* There are no other pointers to this temporary. */
6437 type
= cp_build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
6439 else if (targetm
.calls
.promote_prototypes (type
)
6440 && INTEGRAL_TYPE_P (type
)
6441 && COMPLETE_TYPE_P (type
)
6442 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type
),
6443 TYPE_SIZE (integer_type_node
)))
6444 type
= integer_type_node
;
6449 /* Actually perform the appropriate conversion. */
6452 convert_for_arg_passing (tree type
, tree val
, tsubst_flags_t complain
)
6456 /* If VAL is a bitfield, then -- since it has already been converted
6457 to TYPE -- it cannot have a precision greater than TYPE.
6459 If it has a smaller precision, we must widen it here. For
6460 example, passing "int f:3;" to a function expecting an "int" will
6461 not result in any conversion before this point.
6463 If the precision is the same we must not risk widening. For
6464 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
6465 often have type "int", even though the C++ type for the field is
6466 "long long". If the value is being passed to a function
6467 expecting an "int", then no conversions will be required. But,
6468 if we call convert_bitfield_to_declared_type, the bitfield will
6469 be converted to "long long". */
6470 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
6472 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
6473 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
6475 if (val
== error_mark_node
)
6477 /* Pass classes with copy ctors by invisible reference. */
6478 else if (TREE_ADDRESSABLE (type
))
6479 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
6480 else if (targetm
.calls
.promote_prototypes (type
)
6481 && INTEGRAL_TYPE_P (type
)
6482 && COMPLETE_TYPE_P (type
)
6483 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type
),
6484 TYPE_SIZE (integer_type_node
)))
6485 val
= cp_perform_integral_promotions (val
, complain
);
6486 if ((complain
& tf_warning
)
6487 && warn_suggest_attribute_format
)
6489 tree rhstype
= TREE_TYPE (val
);
6490 const enum tree_code coder
= TREE_CODE (rhstype
);
6491 const enum tree_code codel
= TREE_CODE (type
);
6492 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6494 && check_missing_format_attribute (type
, rhstype
))
6495 warning (OPT_Wsuggest_attribute_format
,
6496 "argument of function call might be a candidate for a format attribute");
6501 /* Returns true iff FN is a function with magic varargs, i.e. ones for
6502 which no conversions at all should be done. This is true for some
6503 builtins which don't act like normal functions. */
6506 magic_varargs_p (tree fn
)
6508 if (DECL_BUILT_IN (fn
))
6509 switch (DECL_FUNCTION_CODE (fn
))
6511 case BUILT_IN_CLASSIFY_TYPE
:
6512 case BUILT_IN_CONSTANT_P
:
6513 case BUILT_IN_NEXT_ARG
:
6514 case BUILT_IN_VA_START
:
6518 return lookup_attribute ("type generic",
6519 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
6525 /* Returns the decl of the dispatcher function if FN is a function version. */
6528 get_function_version_dispatcher (tree fn
)
6530 tree dispatcher_decl
= NULL
;
6532 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6533 && DECL_FUNCTION_VERSIONED (fn
));
6535 gcc_assert (targetm
.get_function_versions_dispatcher
);
6536 dispatcher_decl
= targetm
.get_function_versions_dispatcher (fn
);
6538 if (dispatcher_decl
== NULL
)
6540 error_at (input_location
, "use of multiversioned function "
6541 "without a default");
6545 retrofit_lang_decl (dispatcher_decl
);
6546 gcc_assert (dispatcher_decl
!= NULL
);
6547 return dispatcher_decl
;
6550 /* fn is a function version dispatcher that is marked used. Mark all the
6551 semantically identical function versions it will dispatch as used. */
6554 mark_versions_used (tree fn
)
6556 struct cgraph_node
*node
;
6557 struct cgraph_function_version_info
*node_v
;
6558 struct cgraph_function_version_info
*it_v
;
6560 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
6562 node
= cgraph_get_node (fn
);
6566 gcc_assert (node
->dispatcher_function
);
6568 node_v
= get_cgraph_node_version (node
);
6572 /* All semantically identical versions are chained. Traverse and mark each
6573 one of them as used. */
6574 it_v
= node_v
->next
;
6575 while (it_v
!= NULL
)
6577 mark_used (it_v
->this_node
->symbol
.decl
);
6582 /* Subroutine of the various build_*_call functions. Overload resolution
6583 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
6584 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
6585 bitmask of various LOOKUP_* flags which apply to the call itself. */
6588 build_over_call (struct z_candidate
*cand
, int flags
, tsubst_flags_t complain
)
6591 const vec
<tree
, va_gc
> *args
= cand
->args
;
6592 tree first_arg
= cand
->first_arg
;
6593 conversion
**convs
= cand
->convs
;
6595 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6600 unsigned int arg_index
= 0;
6604 bool already_used
= false;
6606 /* In a template, there is no need to perform all of the work that
6607 is normally done. We are only interested in the type of the call
6608 expression, i.e., the return type of the function. Any semantic
6609 errors will be deferred until the template is instantiated. */
6610 if (processing_template_decl
)
6614 const tree
*argarray
;
6617 return_type
= TREE_TYPE (TREE_TYPE (fn
));
6618 nargs
= vec_safe_length (args
);
6619 if (first_arg
== NULL_TREE
)
6620 argarray
= args
->address ();
6628 alcarray
= XALLOCAVEC (tree
, nargs
);
6629 alcarray
[0] = first_arg
;
6630 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
6631 alcarray
[ix
+ 1] = arg
;
6632 argarray
= alcarray
;
6635 addr
= build_addr_func (fn
, complain
);
6636 if (addr
== error_mark_node
)
6637 return error_mark_node
;
6638 expr
= build_call_array_loc (input_location
, return_type
,
6639 addr
, nargs
, argarray
);
6640 if (TREE_THIS_VOLATILE (fn
) && cfun
)
6641 current_function_returns_abnormally
= 1;
6642 return convert_from_reference (expr
);
6645 /* Give any warnings we noticed during overload resolution. */
6646 if (cand
->warnings
&& (complain
& tf_warning
))
6648 struct candidate_warning
*w
;
6649 for (w
= cand
->warnings
; w
; w
= w
->next
)
6650 joust (cand
, w
->loser
, 1, complain
);
6653 /* Make =delete work with SFINAE. */
6654 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
6655 return error_mark_node
;
6657 if (DECL_FUNCTION_MEMBER_P (fn
))
6660 /* If FN is a template function, two cases must be considered.
6665 template <class T> void f();
6667 template <class T> struct B {
6671 struct C : A, B<int> {
6673 using B<int>::g; // #2
6676 In case #1 where `A::f' is a member template, DECL_ACCESS is
6677 recorded in the primary template but not in its specialization.
6678 We check access of FN using its primary template.
6680 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
6681 because it is a member of class template B, DECL_ACCESS is
6682 recorded in the specialization `B<int>::g'. We cannot use its
6683 primary template because `B<T>::g' and `B<int>::g' may have
6684 different access. */
6685 if (DECL_TEMPLATE_INFO (fn
)
6686 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
6687 access_fn
= DECL_TI_TEMPLATE (fn
);
6690 if (!perform_or_defer_access_check (cand
->access_path
, access_fn
,
6692 return error_mark_node
;
6695 /* If we're checking for implicit delete, don't bother with argument
6697 if (flags
& LOOKUP_SPECULATIVE
)
6699 if (DECL_DELETED_FN (fn
))
6701 if (complain
& tf_error
)
6703 return error_mark_node
;
6705 if (cand
->viable
== 1)
6707 else if (!(complain
& tf_error
))
6708 /* Reject bad conversions now. */
6709 return error_mark_node
;
6710 /* else continue to get conversion error. */
6713 /* N3276 magic doesn't apply to nested calls. */
6714 int decltype_flag
= (complain
& tf_decltype
);
6715 complain
&= ~tf_decltype
;
6717 /* Find maximum size of vector to hold converted arguments. */
6718 parmlen
= list_length (parm
);
6719 nargs
= vec_safe_length (args
) + (first_arg
!= NULL_TREE
? 1 : 0);
6720 if (parmlen
> nargs
)
6722 argarray
= XALLOCAVEC (tree
, nargs
);
6724 /* The implicit parameters to a constructor are not considered by overload
6725 resolution, and must be of the proper type. */
6726 if (DECL_CONSTRUCTOR_P (fn
))
6729 if (first_arg
!= NULL_TREE
)
6731 object_arg
= first_arg
;
6732 first_arg
= NULL_TREE
;
6736 object_arg
= (*args
)[arg_index
];
6739 argarray
[j
++] = build_this (object_arg
);
6740 parm
= TREE_CHAIN (parm
);
6741 /* We should never try to call the abstract constructor. */
6742 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
6744 if (DECL_HAS_VTT_PARM_P (fn
))
6746 argarray
[j
++] = (*args
)[arg_index
];
6748 parm
= TREE_CHAIN (parm
);
6751 /* Bypass access control for 'this' parameter. */
6752 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
6754 tree parmtype
= TREE_VALUE (parm
);
6755 tree arg
= build_this (first_arg
!= NULL_TREE
6757 : (*args
)[arg_index
]);
6758 tree argtype
= TREE_TYPE (arg
);
6762 if (convs
[i
]->bad_p
)
6764 if (complain
& tf_error
)
6765 permerror (input_location
, "passing %qT as %<this%> argument of %q#D discards qualifiers",
6766 TREE_TYPE (argtype
), fn
);
6768 return error_mark_node
;
6771 /* See if the function member or the whole class type is declared
6772 final and the call can be devirtualized. */
6773 if (DECL_FINAL_P (fn
)
6774 || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn
))))
6775 flags
|= LOOKUP_NONVIRTUAL
;
6777 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
6778 X is called for an object that is not of type X, or of a type
6779 derived from X, the behavior is undefined.
6781 So we can assume that anything passed as 'this' is non-null, and
6782 optimize accordingly. */
6783 gcc_assert (TYPE_PTR_P (parmtype
));
6784 /* Convert to the base in which the function was declared. */
6785 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
6786 converted_arg
= build_base_path (PLUS_EXPR
,
6788 cand
->conversion_path
,
6790 /* Check that the base class is accessible. */
6791 if (!accessible_base_p (TREE_TYPE (argtype
),
6792 BINFO_TYPE (cand
->conversion_path
), true))
6793 error ("%qT is not an accessible base of %qT",
6794 BINFO_TYPE (cand
->conversion_path
),
6795 TREE_TYPE (argtype
));
6796 /* If fn was found by a using declaration, the conversion path
6797 will be to the derived class, not the base declaring fn. We
6798 must convert from derived to base. */
6799 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
6800 TREE_TYPE (parmtype
), ba_unique
,
6802 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
6803 base_binfo
, 1, complain
);
6805 argarray
[j
++] = converted_arg
;
6806 parm
= TREE_CHAIN (parm
);
6807 if (first_arg
!= NULL_TREE
)
6808 first_arg
= NULL_TREE
;
6815 gcc_assert (first_arg
== NULL_TREE
);
6816 for (; arg_index
< vec_safe_length (args
) && parm
;
6817 parm
= TREE_CHAIN (parm
), ++arg_index
, ++i
)
6819 tree type
= TREE_VALUE (parm
);
6820 tree arg
= (*args
)[arg_index
];
6821 bool conversion_warning
= true;
6825 /* If the argument is NULL and used to (implicitly) instantiate a
6826 template function (and bind one of the template arguments to
6827 the type of 'long int'), we don't want to warn about passing NULL
6828 to non-pointer argument.
6829 For example, if we have this template function:
6831 template<typename T> void func(T x) {}
6833 we want to warn (when -Wconversion is enabled) in this case:
6839 but not in this case:
6845 if (arg
== null_node
6846 && DECL_TEMPLATE_INFO (fn
)
6847 && cand
->template_decl
6848 && !(flags
& LOOKUP_EXPLICIT_TMPL_ARGS
))
6849 conversion_warning
= false;
6851 /* Warn about initializer_list deduction that isn't currently in the
6853 if (cxx_dialect
> cxx98
6854 && flag_deduce_init_list
6855 && cand
->template_decl
6856 && is_std_init_list (non_reference (type
))
6857 && BRACE_ENCLOSED_INITIALIZER_P (arg
))
6859 tree tmpl
= TI_TEMPLATE (cand
->template_decl
);
6860 tree realparm
= chain_index (j
, DECL_ARGUMENTS (cand
->fn
));
6861 tree patparm
= get_pattern_parm (realparm
, tmpl
);
6862 tree pattype
= TREE_TYPE (patparm
);
6863 if (PACK_EXPANSION_P (pattype
))
6864 pattype
= PACK_EXPANSION_PATTERN (pattype
);
6865 pattype
= non_reference (pattype
);
6867 if (TREE_CODE (pattype
) == TEMPLATE_TYPE_PARM
6868 && (cand
->explicit_targs
== NULL_TREE
6869 || (TREE_VEC_LENGTH (cand
->explicit_targs
)
6870 <= TEMPLATE_TYPE_IDX (pattype
))))
6872 pedwarn (input_location
, 0, "deducing %qT as %qT",
6873 non_reference (TREE_TYPE (patparm
)),
6874 non_reference (type
));
6875 pedwarn (input_location
, 0, " in call to %q+D", cand
->fn
);
6876 pedwarn (input_location
, 0,
6877 " (you can disable this with -fno-deduce-init-list)");
6881 val
= convert_like_with_context (conv
, arg
, fn
, i
-is_method
,
6884 : complain
& (~tf_warning
));
6886 val
= convert_for_arg_passing (type
, val
, complain
);
6887 if (val
== error_mark_node
)
6888 return error_mark_node
;
6890 argarray
[j
++] = val
;
6893 /* Default arguments */
6894 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
6896 if (TREE_VALUE (parm
) == error_mark_node
)
6897 return error_mark_node
;
6898 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
6899 TREE_PURPOSE (parm
),
6905 for (; arg_index
< vec_safe_length (args
); ++arg_index
)
6907 tree a
= (*args
)[arg_index
];
6908 if (magic_varargs_p (fn
))
6909 /* Do no conversions for magic varargs. */
6910 a
= mark_type_use (a
);
6912 a
= convert_arg_to_ellipsis (a
, complain
);
6916 gcc_assert (j
<= nargs
);
6919 check_function_arguments (TREE_TYPE (fn
), nargs
, argarray
);
6921 /* Avoid actually calling copy constructors and copy assignment operators,
6924 if (! flag_elide_constructors
)
6925 /* Do things the hard way. */;
6926 else if (cand
->num_convs
== 1
6927 && (DECL_COPY_CONSTRUCTOR_P (fn
)
6928 || DECL_MOVE_CONSTRUCTOR_P (fn
)))
6931 tree arg
= argarray
[num_artificial_parms_for (fn
)];
6933 bool trivial
= trivial_fn_p (fn
);
6935 /* Pull out the real argument, disregarding const-correctness. */
6937 while (CONVERT_EXPR_P (targ
)
6938 || TREE_CODE (targ
) == NON_LVALUE_EXPR
)
6939 targ
= TREE_OPERAND (targ
, 0);
6940 if (TREE_CODE (targ
) == ADDR_EXPR
)
6942 targ
= TREE_OPERAND (targ
, 0);
6943 if (!same_type_ignoring_top_level_qualifiers_p
6944 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
6953 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
6955 /* [class.copy]: the copy constructor is implicitly defined even if
6956 the implementation elided its use. */
6957 if (!trivial
|| DECL_DELETED_FN (fn
))
6960 already_used
= true;
6963 /* If we're creating a temp and we already have one, don't create a
6964 new one. If we're not creating a temp but we get one, use
6965 INIT_EXPR to collapse the temp into our target. Otherwise, if the
6966 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
6967 temp or an INIT_EXPR otherwise. */
6969 if (integer_zerop (fa
))
6971 if (TREE_CODE (arg
) == TARGET_EXPR
)
6974 return force_target_expr (DECL_CONTEXT (fn
), arg
, complain
);
6976 else if (TREE_CODE (arg
) == TARGET_EXPR
|| trivial
)
6978 tree to
= stabilize_reference (cp_build_indirect_ref (fa
, RO_NULL
,
6981 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
6985 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
6986 && trivial_fn_p (fn
)
6987 && !DECL_DELETED_FN (fn
))
6989 tree to
= stabilize_reference
6990 (cp_build_indirect_ref (argarray
[0], RO_NULL
, complain
));
6991 tree type
= TREE_TYPE (to
);
6992 tree as_base
= CLASSTYPE_AS_BASE (type
);
6993 tree arg
= argarray
[1];
6995 if (is_really_empty_class (type
))
6997 /* Avoid copying empty classes. */
6998 val
= build2 (COMPOUND_EXPR
, void_type_node
, to
, arg
);
6999 TREE_NO_WARNING (val
) = 1;
7000 val
= build2 (COMPOUND_EXPR
, type
, val
, to
);
7001 TREE_NO_WARNING (val
) = 1;
7003 else if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
7005 arg
= cp_build_indirect_ref (arg
, RO_NULL
, complain
);
7006 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
7010 /* We must only copy the non-tail padding parts. */
7012 tree array_type
, alias_set
;
7014 arg2
= TYPE_SIZE_UNIT (as_base
);
7015 arg0
= cp_build_addr_expr (to
, complain
);
7017 array_type
= build_array_type (char_type_node
,
7019 (size_binop (MINUS_EXPR
,
7020 arg2
, size_int (1))));
7021 alias_set
= build_int_cst (build_pointer_type (type
), 0);
7022 t
= build2 (MODIFY_EXPR
, void_type_node
,
7023 build2 (MEM_REF
, array_type
, arg0
, alias_set
),
7024 build2 (MEM_REF
, array_type
, arg
, alias_set
));
7025 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (to
), t
, to
);
7026 TREE_NO_WARNING (val
) = 1;
7031 else if (DECL_DESTRUCTOR_P (fn
)
7032 && trivial_fn_p (fn
)
7033 && !DECL_DELETED_FN (fn
))
7034 return fold_convert (void_type_node
, argarray
[0]);
7035 /* FIXME handle trivial default constructor, too. */
7037 /* For calls to a multi-versioned function, overload resolution
7038 returns the function with the highest target priority, that is,
7039 the version that will checked for dispatching first. If this
7040 version is inlinable, a direct call to this version can be made
7041 otherwise the call should go through the dispatcher. */
7043 if (DECL_FUNCTION_VERSIONED (fn
)
7044 && !targetm
.target_option
.can_inline_p (current_function_decl
, fn
))
7046 fn
= get_function_version_dispatcher (fn
);
7050 mark_versions_used (fn
);
7056 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0
7057 /* Don't mess with virtual lookup in fold_non_dependent_expr; virtual
7058 functions can't be constexpr. */
7059 && !in_template_function ())
7062 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
7064 ba_any
, NULL
, complain
);
7065 gcc_assert (binfo
&& binfo
!= error_mark_node
);
7067 /* Warn about deprecated virtual functions now, since we're about
7068 to throw away the decl. */
7069 if (TREE_DEPRECATED (fn
))
7070 warn_deprecated_use (fn
, NULL_TREE
);
7072 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1,
7074 if (TREE_SIDE_EFFECTS (argarray
[0]))
7075 argarray
[0] = save_expr (argarray
[0]);
7076 t
= build_pointer_type (TREE_TYPE (fn
));
7077 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
7078 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
7080 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
7085 fn
= build_addr_func (fn
, complain
);
7086 if (fn
== error_mark_node
)
7087 return error_mark_node
;
7090 return build_cxx_call (fn
, nargs
, argarray
, complain
|decltype_flag
);
7093 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
7094 This function performs no overload resolution, conversion, or other
7095 high-level operations. */
7098 build_cxx_call (tree fn
, int nargs
, tree
*argarray
,
7099 tsubst_flags_t complain
)
7104 /* Remember roughly where this call is. */
7105 location_t loc
= EXPR_LOC_OR_HERE (fn
);
7106 fn
= build_call_a (fn
, nargs
, argarray
);
7107 SET_EXPR_LOCATION (fn
, loc
);
7109 fndecl
= get_callee_fndecl (fn
);
7111 /* Check that arguments to builtin functions match the expectations. */
7113 && DECL_BUILT_IN (fndecl
)
7114 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7115 && !check_builtin_function_arguments (fndecl
, nargs
, argarray
))
7116 return error_mark_node
;
7118 /* Some built-in function calls will be evaluated at compile-time in
7119 fold (). Set optimize to 1 when folding __builtin_constant_p inside
7120 a constexpr function so that fold_builtin_1 doesn't fold it to 0. */
7121 optimize_sav
= optimize
;
7122 if (!optimize
&& fndecl
&& DECL_IS_BUILTIN_CONSTANT_P (fndecl
)
7123 && current_function_decl
7124 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
7126 fn
= fold_if_not_in_template (fn
);
7127 optimize
= optimize_sav
;
7129 if (VOID_TYPE_P (TREE_TYPE (fn
)))
7132 /* 5.2.2/11: If a function call is a prvalue of object type: if the
7133 function call is either the operand of a decltype-specifier or the
7134 right operand of a comma operator that is the operand of a
7135 decltype-specifier, a temporary object is not introduced for the
7136 prvalue. The type of the prvalue may be incomplete. */
7137 if (!(complain
& tf_decltype
))
7139 fn
= require_complete_type_sfinae (fn
, complain
);
7140 if (fn
== error_mark_node
)
7141 return error_mark_node
;
7143 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn
)))
7144 fn
= build_cplus_new (TREE_TYPE (fn
), fn
, complain
);
7146 return convert_from_reference (fn
);
7149 static GTY(()) tree java_iface_lookup_fn
;
7151 /* Make an expression which yields the address of the Java interface
7152 method FN. This is achieved by generating a call to libjava's
7153 _Jv_LookupInterfaceMethodIdx(). */
7156 build_java_interface_fn_ref (tree fn
, tree instance
)
7158 tree lookup_fn
, method
, idx
;
7159 tree klass_ref
, iface
, iface_ref
;
7162 if (!java_iface_lookup_fn
)
7164 tree ftype
= build_function_type_list (ptr_type_node
,
7165 ptr_type_node
, ptr_type_node
,
7166 java_int_type_node
, NULL_TREE
);
7167 java_iface_lookup_fn
7168 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype
,
7169 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
7172 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
7173 This is the first entry in the vtable. */
7174 klass_ref
= build_vtbl_ref (cp_build_indirect_ref (instance
, RO_NULL
,
7175 tf_warning_or_error
),
7178 /* Get the java.lang.Class pointer for the interface being called. */
7179 iface
= DECL_CONTEXT (fn
);
7180 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
7181 if (!iface_ref
|| !VAR_P (iface_ref
)
7182 || DECL_CONTEXT (iface_ref
) != iface
)
7184 error ("could not find class$ field in java interface type %qT",
7186 return error_mark_node
;
7188 iface_ref
= build_address (iface_ref
);
7189 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
7191 /* Determine the itable index of FN. */
7193 for (method
= TYPE_METHODS (iface
); method
; method
= DECL_CHAIN (method
))
7195 if (!DECL_VIRTUAL_P (method
))
7201 idx
= build_int_cst (NULL_TREE
, i
);
7203 lookup_fn
= build1 (ADDR_EXPR
,
7204 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
7205 java_iface_lookup_fn
);
7206 return build_call_nary (ptr_type_node
, lookup_fn
,
7207 3, klass_ref
, iface_ref
, idx
);
7210 /* Returns the value to use for the in-charge parameter when making a
7211 call to a function with the indicated NAME.
7213 FIXME:Can't we find a neater way to do this mapping? */
7216 in_charge_arg_for_name (tree name
)
7218 if (name
== base_ctor_identifier
7219 || name
== base_dtor_identifier
)
7220 return integer_zero_node
;
7221 else if (name
== complete_ctor_identifier
)
7222 return integer_one_node
;
7223 else if (name
== complete_dtor_identifier
)
7224 return integer_two_node
;
7225 else if (name
== deleting_dtor_identifier
)
7226 return integer_three_node
;
7228 /* This function should only be called with one of the names listed
7234 /* Build a call to a constructor, destructor, or an assignment
7235 operator for INSTANCE, an expression with class type. NAME
7236 indicates the special member function to call; *ARGS are the
7237 arguments. ARGS may be NULL. This may change ARGS. BINFO
7238 indicates the base of INSTANCE that is to be passed as the `this'
7239 parameter to the member function called.
7241 FLAGS are the LOOKUP_* flags to use when processing the call.
7243 If NAME indicates a complete object constructor, INSTANCE may be
7244 NULL_TREE. In this case, the caller will call build_cplus_new to
7245 store the newly constructed object into a VAR_DECL. */
7248 build_special_member_call (tree instance
, tree name
, vec
<tree
, va_gc
> **args
,
7249 tree binfo
, int flags
, tsubst_flags_t complain
)
7252 /* The type of the subobject to be constructed or destroyed. */
7254 vec
<tree
, va_gc
> *allocated
= NULL
;
7257 gcc_assert (name
== complete_ctor_identifier
7258 || name
== base_ctor_identifier
7259 || name
== complete_dtor_identifier
7260 || name
== base_dtor_identifier
7261 || name
== deleting_dtor_identifier
7262 || name
== ansi_assopname (NOP_EXPR
));
7265 /* Resolve the name. */
7266 if (!complete_type_or_maybe_complain (binfo
, NULL_TREE
, complain
))
7267 return error_mark_node
;
7269 binfo
= TYPE_BINFO (binfo
);
7272 gcc_assert (binfo
!= NULL_TREE
);
7274 class_type
= BINFO_TYPE (binfo
);
7276 /* Handle the special case where INSTANCE is NULL_TREE. */
7277 if (name
== complete_ctor_identifier
&& !instance
)
7279 instance
= build_int_cst (build_pointer_type (class_type
), 0);
7280 instance
= build1 (INDIRECT_REF
, class_type
, instance
);
7284 if (name
== complete_dtor_identifier
7285 || name
== base_dtor_identifier
7286 || name
== deleting_dtor_identifier
)
7287 gcc_assert (args
== NULL
|| vec_safe_is_empty (*args
));
7289 /* Convert to the base class, if necessary. */
7290 if (!same_type_ignoring_top_level_qualifiers_p
7291 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
7293 if (name
!= ansi_assopname (NOP_EXPR
))
7294 /* For constructors and destructors, either the base is
7295 non-virtual, or it is virtual but we are doing the
7296 conversion from a constructor or destructor for the
7297 complete object. In either case, we can convert
7299 instance
= convert_to_base_statically (instance
, binfo
);
7301 /* However, for assignment operators, we must convert
7302 dynamically if the base is virtual. */
7303 instance
= build_base_path (PLUS_EXPR
, instance
,
7304 binfo
, /*nonnull=*/1, complain
);
7308 gcc_assert (instance
!= NULL_TREE
);
7310 fns
= lookup_fnfields (binfo
, name
, 1);
7312 /* When making a call to a constructor or destructor for a subobject
7313 that uses virtual base classes, pass down a pointer to a VTT for
7315 if ((name
== base_ctor_identifier
7316 || name
== base_dtor_identifier
)
7317 && CLASSTYPE_VBASECLASSES (class_type
))
7322 /* If the current function is a complete object constructor
7323 or destructor, then we fetch the VTT directly.
7324 Otherwise, we look it up using the VTT we were given. */
7325 vtt
= DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
7326 vtt
= decay_conversion (vtt
, complain
);
7327 if (vtt
== error_mark_node
)
7328 return error_mark_node
;
7329 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
7330 build2 (EQ_EXPR
, boolean_type_node
,
7331 current_in_charge_parm
, integer_zero_node
),
7334 if (BINFO_SUBVTT_INDEX (binfo
))
7335 sub_vtt
= fold_build_pointer_plus (vtt
, BINFO_SUBVTT_INDEX (binfo
));
7341 allocated
= make_tree_vector ();
7345 vec_safe_insert (*args
, 0, sub_vtt
);
7348 ret
= build_new_method_call (instance
, fns
, args
,
7349 TYPE_BINFO (BINFO_TYPE (binfo
)),
7353 if (allocated
!= NULL
)
7354 release_tree_vector (allocated
);
7359 /* Return the NAME, as a C string. The NAME indicates a function that
7360 is a member of TYPE. *FREE_P is set to true if the caller must
7361 free the memory returned.
7363 Rather than go through all of this, we should simply set the names
7364 of constructors and destructors appropriately, and dispense with
7365 ctor_identifier, dtor_identifier, etc. */
7368 name_as_c_string (tree name
, tree type
, bool *free_p
)
7372 /* Assume that we will not allocate memory. */
7374 /* Constructors and destructors are special. */
7375 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7378 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type
))));
7379 /* For a destructor, add the '~'. */
7380 if (name
== complete_dtor_identifier
7381 || name
== base_dtor_identifier
7382 || name
== deleting_dtor_identifier
)
7384 pretty_name
= concat ("~", pretty_name
, NULL
);
7385 /* Remember that we need to free the memory allocated. */
7389 else if (IDENTIFIER_TYPENAME_P (name
))
7391 pretty_name
= concat ("operator ",
7392 type_as_string_translate (TREE_TYPE (name
),
7393 TFF_PLAIN_IDENTIFIER
),
7395 /* Remember that we need to free the memory allocated. */
7399 pretty_name
= CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name
)));
7404 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
7405 be set, upon return, to the function called. ARGS may be NULL.
7406 This may change ARGS. */
7409 build_new_method_call_1 (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
7410 tree conversion_path
, int flags
,
7411 tree
*fn_p
, tsubst_flags_t complain
)
7413 struct z_candidate
*candidates
= 0, *cand
;
7414 tree explicit_targs
= NULL_TREE
;
7415 tree basetype
= NULL_TREE
;
7418 tree first_mem_arg
= NULL_TREE
;
7420 bool skip_first_for_error
;
7421 vec
<tree
, va_gc
> *user_args
;
7424 int template_only
= 0;
7428 vec
<tree
, va_gc
> *orig_args
= NULL
;
7431 gcc_assert (instance
!= NULL_TREE
);
7433 /* We don't know what function we're going to call, yet. */
7437 if (error_operand_p (instance
)
7438 || !fns
|| error_operand_p (fns
))
7439 return error_mark_node
;
7441 if (!BASELINK_P (fns
))
7443 if (complain
& tf_error
)
7444 error ("call to non-function %qD", fns
);
7445 return error_mark_node
;
7448 orig_instance
= instance
;
7451 /* Dismantle the baselink to collect all the information we need. */
7452 if (!conversion_path
)
7453 conversion_path
= BASELINK_BINFO (fns
);
7454 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
7455 optype
= BASELINK_OPTYPE (fns
);
7456 fns
= BASELINK_FUNCTIONS (fns
);
7457 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
7459 explicit_targs
= TREE_OPERAND (fns
, 1);
7460 fns
= TREE_OPERAND (fns
, 0);
7463 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
7464 || TREE_CODE (fns
) == TEMPLATE_DECL
7465 || TREE_CODE (fns
) == OVERLOAD
);
7466 fn
= get_first_fn (fns
);
7467 name
= DECL_NAME (fn
);
7469 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
7470 gcc_assert (CLASS_TYPE_P (basetype
));
7472 if (processing_template_decl
)
7474 orig_args
= args
== NULL
? NULL
: make_tree_vector_copy (*args
);
7475 instance
= build_non_dependent_expr (instance
);
7477 make_args_non_dependent (*args
);
7480 user_args
= args
== NULL
? NULL
: *args
;
7481 /* Under DR 147 A::A() is an invalid constructor call,
7482 not a functional cast. */
7483 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
7485 if (! (complain
& tf_error
))
7486 return error_mark_node
;
7488 if (permerror (input_location
,
7489 "cannot call constructor %<%T::%D%> directly",
7491 inform (input_location
, "for a function-style cast, remove the "
7492 "redundant %<::%D%>", name
);
7493 call
= build_functional_cast (basetype
, build_tree_list_vec (user_args
),
7498 /* Figure out whether to skip the first argument for the error
7499 message we will display to users if an error occurs. We don't
7500 want to display any compiler-generated arguments. The "this"
7501 pointer hasn't been added yet. However, we must remove the VTT
7502 pointer if this is a call to a base-class constructor or
7504 skip_first_for_error
= false;
7505 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
7507 /* Callers should explicitly indicate whether they want to construct
7508 the complete object or just the part without virtual bases. */
7509 gcc_assert (name
!= ctor_identifier
);
7510 /* Similarly for destructors. */
7511 gcc_assert (name
!= dtor_identifier
);
7512 /* Remove the VTT pointer, if present. */
7513 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
7514 && CLASSTYPE_VBASECLASSES (basetype
))
7515 skip_first_for_error
= true;
7518 /* Process the argument list. */
7519 if (args
!= NULL
&& *args
!= NULL
)
7521 *args
= resolve_args (*args
, complain
);
7523 return error_mark_node
;
7526 /* Consider the object argument to be used even if we end up selecting a
7527 static member function. */
7528 instance
= mark_type_use (instance
);
7530 /* It's OK to call destructors and constructors on cv-qualified objects.
7531 Therefore, convert the INSTANCE to the unqualified type, if
7533 if (DECL_DESTRUCTOR_P (fn
)
7534 || DECL_CONSTRUCTOR_P (fn
))
7536 if (!same_type_p (basetype
, TREE_TYPE (instance
)))
7538 instance
= build_this (instance
);
7539 instance
= build_nop (build_pointer_type (basetype
), instance
);
7540 instance
= build_fold_indirect_ref (instance
);
7543 if (DECL_DESTRUCTOR_P (fn
))
7544 name
= complete_dtor_identifier
;
7546 first_mem_arg
= instance
;
7548 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7549 p
= conversion_obstack_alloc (0);
7551 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
7552 initializer, not T({ }). */
7553 if (DECL_CONSTRUCTOR_P (fn
) && args
!= NULL
&& !vec_safe_is_empty (*args
)
7554 && BRACE_ENCLOSED_INITIALIZER_P ((**args
)[0])
7555 && CONSTRUCTOR_IS_DIRECT_INIT ((**args
)[0]))
7557 tree init_list
= (**args
)[0];
7558 tree init
= NULL_TREE
;
7560 gcc_assert ((*args
)->length () == 1
7561 && !(flags
& LOOKUP_ONLYCONVERTING
));
7563 /* If the initializer list has no elements and T is a class type with
7564 a default constructor, the object is value-initialized. Handle
7565 this here so we don't need to handle it wherever we use
7566 build_special_member_call. */
7567 if (CONSTRUCTOR_NELTS (init_list
) == 0
7568 && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
7569 /* For a user-provided default constructor, use the normal
7570 mechanisms so that protected access works. */
7571 && !type_has_user_provided_default_constructor (basetype
)
7572 && !processing_template_decl
)
7573 init
= build_value_init (basetype
, complain
);
7575 /* If BASETYPE is an aggregate, we need to do aggregate
7577 else if (CP_AGGREGATE_TYPE_P (basetype
))
7578 init
= digest_init (basetype
, init_list
, complain
);
7582 if (TREE_CODE (instance
) == INDIRECT_REF
7583 && integer_zerop (TREE_OPERAND (instance
, 0)))
7584 return get_target_expr_sfinae (init
, complain
);
7585 init
= build2 (INIT_EXPR
, TREE_TYPE (instance
), instance
, init
);
7586 TREE_SIDE_EFFECTS (init
) = true;
7590 /* Otherwise go ahead with overload resolution. */
7591 add_list_candidates (fns
, first_mem_arg
, init_list
,
7592 basetype
, explicit_targs
, template_only
,
7593 conversion_path
, access_binfo
, flags
,
7594 &candidates
, complain
);
7598 add_candidates (fns
, first_mem_arg
, user_args
, optype
,
7599 explicit_targs
, template_only
, conversion_path
,
7600 access_binfo
, flags
, &candidates
, complain
);
7602 any_viable_p
= false;
7603 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
7607 if (complain
& tf_error
)
7609 if (!COMPLETE_OR_OPEN_TYPE_P (basetype
))
7610 cxx_incomplete_type_error (instance
, basetype
);
7612 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
7613 basetype
, optype
, build_tree_list_vec (user_args
),
7614 TREE_TYPE (instance
));
7621 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
7622 arglist
= build_tree_list_vec (user_args
);
7623 if (skip_first_for_error
)
7624 arglist
= TREE_CHAIN (arglist
);
7625 error ("no matching function for call to %<%T::%s(%A)%#V%>",
7626 basetype
, pretty_name
, arglist
,
7627 TREE_TYPE (instance
));
7631 print_z_candidates (location_of (name
), candidates
);
7633 call
= error_mark_node
;
7637 cand
= tourney (candidates
, complain
);
7644 if (complain
& tf_error
)
7646 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
7647 arglist
= build_tree_list_vec (user_args
);
7648 if (skip_first_for_error
)
7649 arglist
= TREE_CHAIN (arglist
);
7650 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name
,
7652 print_z_candidates (location_of (name
), candidates
);
7656 call
= error_mark_node
;
7663 if (!(flags
& LOOKUP_NONVIRTUAL
)
7664 && DECL_PURE_VIRTUAL_P (fn
)
7665 && instance
== current_class_ref
7666 && (DECL_CONSTRUCTOR_P (current_function_decl
)
7667 || DECL_DESTRUCTOR_P (current_function_decl
))
7668 && (complain
& tf_warning
))
7669 /* This is not an error, it is runtime undefined
7671 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
) ?
7672 "pure virtual %q#D called from constructor"
7673 : "pure virtual %q#D called from destructor"),
7676 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
7677 && is_dummy_object (instance
))
7679 instance
= maybe_resolve_dummy (instance
);
7680 if (instance
== error_mark_node
)
7681 call
= error_mark_node
;
7682 else if (!is_dummy_object (instance
))
7684 /* We captured 'this' in the current lambda now that
7685 we know we really need it. */
7686 cand
->first_arg
= instance
;
7690 if (complain
& tf_error
)
7691 error ("cannot call member function %qD without object",
7693 call
= error_mark_node
;
7697 if (call
!= error_mark_node
)
7699 /* Optimize away vtable lookup if we know that this
7700 function can't be overridden. We need to check if
7701 the context and the instance type are the same,
7702 actually FN might be defined in a different class
7703 type because of a using-declaration. In this case, we
7704 do not want to perform a non-virtual call. */
7705 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
7706 && same_type_ignoring_top_level_qualifiers_p
7707 (DECL_CONTEXT (fn
), TREE_TYPE (instance
))
7708 && resolves_to_fixed_type_p (instance
, 0))
7709 flags
|= LOOKUP_NONVIRTUAL
;
7711 flags
|= LOOKUP_EXPLICIT_TMPL_ARGS
;
7712 /* Now we know what function is being called. */
7715 /* Build the actual CALL_EXPR. */
7716 call
= build_over_call (cand
, flags
, complain
);
7717 /* In an expression of the form `a->f()' where `f' turns
7718 out to be a static member function, `a' is
7719 none-the-less evaluated. */
7720 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
7721 && !is_dummy_object (instance
)
7722 && TREE_SIDE_EFFECTS (instance
))
7723 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
7725 else if (call
!= error_mark_node
7726 && DECL_DESTRUCTOR_P (cand
->fn
)
7727 && !VOID_TYPE_P (TREE_TYPE (call
)))
7728 /* An explicit call of the form "x->~X()" has type
7729 "void". However, on platforms where destructors
7730 return "this" (i.e., those where
7731 targetm.cxx.cdtor_returns_this is true), such calls
7732 will appear to have a return value of pointer type
7733 to the low-level call machinery. We do not want to
7734 change the low-level machinery, since we want to be
7735 able to optimize "delete f()" on such platforms as
7736 "operator delete(~X(f()))" (rather than generating
7737 "t = f(), ~X(t), operator delete (t)"). */
7738 call
= build_nop (void_type_node
, call
);
7743 if (processing_template_decl
&& call
!= error_mark_node
)
7745 bool cast_to_void
= false;
7747 if (TREE_CODE (call
) == COMPOUND_EXPR
)
7748 call
= TREE_OPERAND (call
, 1);
7749 else if (TREE_CODE (call
) == NOP_EXPR
)
7751 cast_to_void
= true;
7752 call
= TREE_OPERAND (call
, 0);
7754 if (INDIRECT_REF_P (call
))
7755 call
= TREE_OPERAND (call
, 0);
7756 call
= (build_min_non_dep_call_vec
7758 build_min (COMPONENT_REF
, TREE_TYPE (CALL_EXPR_FN (call
)),
7759 orig_instance
, orig_fns
, NULL_TREE
),
7761 SET_EXPR_LOCATION (call
, input_location
);
7762 call
= convert_from_reference (call
);
7764 call
= build_nop (void_type_node
, call
);
7767 /* Free all the conversions we allocated. */
7768 obstack_free (&conversion_obstack
, p
);
7770 if (orig_args
!= NULL
)
7771 release_tree_vector (orig_args
);
7776 /* Wrapper for above. */
7779 build_new_method_call (tree instance
, tree fns
, vec
<tree
, va_gc
> **args
,
7780 tree conversion_path
, int flags
,
7781 tree
*fn_p
, tsubst_flags_t complain
)
7784 bool subtime
= timevar_cond_start (TV_OVERLOAD
);
7785 ret
= build_new_method_call_1 (instance
, fns
, args
, conversion_path
, flags
,
7787 timevar_cond_stop (TV_OVERLOAD
, subtime
);
7791 /* Returns true iff standard conversion sequence ICS1 is a proper
7792 subsequence of ICS2. */
7795 is_subseq (conversion
*ics1
, conversion
*ics2
)
7797 /* We can assume that a conversion of the same code
7798 between the same types indicates a subsequence since we only get
7799 here if the types we are converting from are the same. */
7801 while (ics1
->kind
== ck_rvalue
7802 || ics1
->kind
== ck_lvalue
)
7803 ics1
= next_conversion (ics1
);
7807 while (ics2
->kind
== ck_rvalue
7808 || ics2
->kind
== ck_lvalue
)
7809 ics2
= next_conversion (ics2
);
7811 if (ics2
->kind
== ck_user
7812 || ics2
->kind
== ck_ambig
7813 || ics2
->kind
== ck_aggr
7814 || ics2
->kind
== ck_list
7815 || ics2
->kind
== ck_identity
)
7816 /* At this point, ICS1 cannot be a proper subsequence of
7817 ICS2. We can get a USER_CONV when we are comparing the
7818 second standard conversion sequence of two user conversion
7822 ics2
= next_conversion (ics2
);
7824 if (ics2
->kind
== ics1
->kind
7825 && same_type_p (ics2
->type
, ics1
->type
)
7826 && same_type_p (next_conversion (ics2
)->type
,
7827 next_conversion (ics1
)->type
))
7832 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
7833 be any _TYPE nodes. */
7836 is_properly_derived_from (tree derived
, tree base
)
7838 if (!CLASS_TYPE_P (derived
) || !CLASS_TYPE_P (base
))
7841 /* We only allow proper derivation here. The DERIVED_FROM_P macro
7842 considers every class derived from itself. */
7843 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
7844 && DERIVED_FROM_P (base
, derived
));
7847 /* We build the ICS for an implicit object parameter as a pointer
7848 conversion sequence. However, such a sequence should be compared
7849 as if it were a reference conversion sequence. If ICS is the
7850 implicit conversion sequence for an implicit object parameter,
7851 modify it accordingly. */
7854 maybe_handle_implicit_object (conversion
**ics
)
7858 /* [over.match.funcs]
7860 For non-static member functions, the type of the
7861 implicit object parameter is "reference to cv X"
7862 where X is the class of which the function is a
7863 member and cv is the cv-qualification on the member
7864 function declaration. */
7865 conversion
*t
= *ics
;
7866 tree reference_type
;
7868 /* The `this' parameter is a pointer to a class type. Make the
7869 implicit conversion talk about a reference to that same class
7871 reference_type
= TREE_TYPE (t
->type
);
7872 reference_type
= build_reference_type (reference_type
);
7874 if (t
->kind
== ck_qual
)
7875 t
= next_conversion (t
);
7876 if (t
->kind
== ck_ptr
)
7877 t
= next_conversion (t
);
7878 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
7879 t
= direct_reference_binding (reference_type
, t
);
7881 t
->rvaluedness_matches_p
= 0;
7886 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
7887 and return the initial reference binding conversion. Otherwise,
7888 leave *ICS unchanged and return NULL. */
7891 maybe_handle_ref_bind (conversion
**ics
)
7893 if ((*ics
)->kind
== ck_ref_bind
)
7895 conversion
*old_ics
= *ics
;
7896 *ics
= next_conversion (old_ics
);
7897 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
7904 /* Compare two implicit conversion sequences according to the rules set out in
7905 [over.ics.rank]. Return values:
7907 1: ics1 is better than ics2
7908 -1: ics2 is better than ics1
7909 0: ics1 and ics2 are indistinguishable */
7912 compare_ics (conversion
*ics1
, conversion
*ics2
)
7918 tree deref_from_type1
= NULL_TREE
;
7919 tree deref_from_type2
= NULL_TREE
;
7920 tree deref_to_type1
= NULL_TREE
;
7921 tree deref_to_type2
= NULL_TREE
;
7922 conversion_rank rank1
, rank2
;
7924 /* REF_BINDING is nonzero if the result of the conversion sequence
7925 is a reference type. In that case REF_CONV is the reference
7926 binding conversion. */
7927 conversion
*ref_conv1
;
7928 conversion
*ref_conv2
;
7930 /* Handle implicit object parameters. */
7931 maybe_handle_implicit_object (&ics1
);
7932 maybe_handle_implicit_object (&ics2
);
7934 /* Handle reference parameters. */
7935 ref_conv1
= maybe_handle_ref_bind (&ics1
);
7936 ref_conv2
= maybe_handle_ref_bind (&ics2
);
7938 /* List-initialization sequence L1 is a better conversion sequence than
7939 list-initialization sequence L2 if L1 converts to
7940 std::initializer_list<X> for some X and L2 does not. */
7941 if (ics1
->kind
== ck_list
&& ics2
->kind
!= ck_list
)
7943 if (ics2
->kind
== ck_list
&& ics1
->kind
!= ck_list
)
7948 When comparing the basic forms of implicit conversion sequences (as
7949 defined in _over.best.ics_)
7951 --a standard conversion sequence (_over.ics.scs_) is a better
7952 conversion sequence than a user-defined conversion sequence
7953 or an ellipsis conversion sequence, and
7955 --a user-defined conversion sequence (_over.ics.user_) is a
7956 better conversion sequence than an ellipsis conversion sequence
7957 (_over.ics.ellipsis_). */
7958 rank1
= CONVERSION_RANK (ics1
);
7959 rank2
= CONVERSION_RANK (ics2
);
7963 else if (rank1
< rank2
)
7966 if (rank1
== cr_bad
)
7968 /* Both ICS are bad. We try to make a decision based on what would
7969 have happened if they'd been good. This is not an extension,
7970 we'll still give an error when we build up the call; this just
7971 helps us give a more helpful error message. */
7972 rank1
= BAD_CONVERSION_RANK (ics1
);
7973 rank2
= BAD_CONVERSION_RANK (ics2
);
7977 else if (rank1
< rank2
)
7980 /* We couldn't make up our minds; try to figure it out below. */
7983 if (ics1
->ellipsis_p
)
7984 /* Both conversions are ellipsis conversions. */
7987 /* User-defined conversion sequence U1 is a better conversion sequence
7988 than another user-defined conversion sequence U2 if they contain the
7989 same user-defined conversion operator or constructor and if the sec-
7990 ond standard conversion sequence of U1 is better than the second
7991 standard conversion sequence of U2. */
7993 /* Handle list-conversion with the same code even though it isn't always
7994 ranked as a user-defined conversion and it doesn't have a second
7995 standard conversion sequence; it will still have the desired effect.
7996 Specifically, we need to do the reference binding comparison at the
7997 end of this function. */
7999 if (ics1
->user_conv_p
|| ics1
->kind
== ck_list
|| ics1
->kind
== ck_aggr
)
8004 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= next_conversion (t1
))
8005 if (t1
->kind
== ck_ambig
|| t1
->kind
== ck_aggr
8006 || t1
->kind
== ck_list
)
8008 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= next_conversion (t2
))
8009 if (t2
->kind
== ck_ambig
|| t2
->kind
== ck_aggr
8010 || t2
->kind
== ck_list
)
8013 if (t1
->kind
!= t2
->kind
)
8015 else if (t1
->kind
== ck_user
)
8017 if (t1
->cand
->fn
!= t2
->cand
->fn
)
8022 /* For ambiguous or aggregate conversions, use the target type as
8023 a proxy for the conversion function. */
8024 if (!same_type_ignoring_top_level_qualifiers_p (t1
->type
, t2
->type
))
8028 /* We can just fall through here, after setting up
8029 FROM_TYPE1 and FROM_TYPE2. */
8030 from_type1
= t1
->type
;
8031 from_type2
= t2
->type
;
8038 /* We're dealing with two standard conversion sequences.
8042 Standard conversion sequence S1 is a better conversion
8043 sequence than standard conversion sequence S2 if
8045 --S1 is a proper subsequence of S2 (comparing the conversion
8046 sequences in the canonical form defined by _over.ics.scs_,
8047 excluding any Lvalue Transformation; the identity
8048 conversion sequence is considered to be a subsequence of
8049 any non-identity conversion sequence */
8052 while (t1
->kind
!= ck_identity
)
8053 t1
= next_conversion (t1
);
8054 from_type1
= t1
->type
;
8057 while (t2
->kind
!= ck_identity
)
8058 t2
= next_conversion (t2
);
8059 from_type2
= t2
->type
;
8062 /* One sequence can only be a subsequence of the other if they start with
8063 the same type. They can start with different types when comparing the
8064 second standard conversion sequence in two user-defined conversion
8066 if (same_type_p (from_type1
, from_type2
))
8068 if (is_subseq (ics1
, ics2
))
8070 if (is_subseq (ics2
, ics1
))
8078 --the rank of S1 is better than the rank of S2 (by the rules
8081 Standard conversion sequences are ordered by their ranks: an Exact
8082 Match is a better conversion than a Promotion, which is a better
8083 conversion than a Conversion.
8085 Two conversion sequences with the same rank are indistinguishable
8086 unless one of the following rules applies:
8088 --A conversion that does not a convert a pointer, pointer to member,
8089 or std::nullptr_t to bool is better than one that does.
8091 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
8092 so that we do not have to check it explicitly. */
8093 if (ics1
->rank
< ics2
->rank
)
8095 else if (ics2
->rank
< ics1
->rank
)
8098 to_type1
= ics1
->type
;
8099 to_type2
= ics2
->type
;
8101 /* A conversion from scalar arithmetic type to complex is worse than a
8102 conversion between scalar arithmetic types. */
8103 if (same_type_p (from_type1
, from_type2
)
8104 && ARITHMETIC_TYPE_P (from_type1
)
8105 && ARITHMETIC_TYPE_P (to_type1
)
8106 && ARITHMETIC_TYPE_P (to_type2
)
8107 && ((TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8108 != (TREE_CODE (to_type2
) == COMPLEX_TYPE
)))
8110 if (TREE_CODE (to_type1
) == COMPLEX_TYPE
)
8116 if (TYPE_PTR_P (from_type1
)
8117 && TYPE_PTR_P (from_type2
)
8118 && TYPE_PTR_P (to_type1
)
8119 && TYPE_PTR_P (to_type2
))
8121 deref_from_type1
= TREE_TYPE (from_type1
);
8122 deref_from_type2
= TREE_TYPE (from_type2
);
8123 deref_to_type1
= TREE_TYPE (to_type1
);
8124 deref_to_type2
= TREE_TYPE (to_type2
);
8126 /* The rules for pointers to members A::* are just like the rules
8127 for pointers A*, except opposite: if B is derived from A then
8128 A::* converts to B::*, not vice versa. For that reason, we
8129 switch the from_ and to_ variables here. */
8130 else if ((TYPE_PTRDATAMEM_P (from_type1
) && TYPE_PTRDATAMEM_P (from_type2
)
8131 && TYPE_PTRDATAMEM_P (to_type1
) && TYPE_PTRDATAMEM_P (to_type2
))
8132 || (TYPE_PTRMEMFUNC_P (from_type1
)
8133 && TYPE_PTRMEMFUNC_P (from_type2
)
8134 && TYPE_PTRMEMFUNC_P (to_type1
)
8135 && TYPE_PTRMEMFUNC_P (to_type2
)))
8137 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
8138 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
8139 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
8140 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
8143 if (deref_from_type1
!= NULL_TREE
8144 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1
))
8145 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2
)))
8147 /* This was one of the pointer or pointer-like conversions.
8151 --If class B is derived directly or indirectly from class A,
8152 conversion of B* to A* is better than conversion of B* to
8153 void*, and conversion of A* to void* is better than
8154 conversion of B* to void*. */
8155 if (VOID_TYPE_P (deref_to_type1
)
8156 && VOID_TYPE_P (deref_to_type2
))
8158 if (is_properly_derived_from (deref_from_type1
,
8161 else if (is_properly_derived_from (deref_from_type2
,
8165 else if (VOID_TYPE_P (deref_to_type1
)
8166 || VOID_TYPE_P (deref_to_type2
))
8168 if (same_type_p (deref_from_type1
, deref_from_type2
))
8170 if (VOID_TYPE_P (deref_to_type2
))
8172 if (is_properly_derived_from (deref_from_type1
,
8176 /* We know that DEREF_TO_TYPE1 is `void' here. */
8177 else if (is_properly_derived_from (deref_from_type1
,
8182 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1
))
8183 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2
)))
8187 --If class B is derived directly or indirectly from class A
8188 and class C is derived directly or indirectly from B,
8190 --conversion of C* to B* is better than conversion of C* to
8193 --conversion of B* to A* is better than conversion of C* to
8195 if (same_type_p (deref_from_type1
, deref_from_type2
))
8197 if (is_properly_derived_from (deref_to_type1
,
8200 else if (is_properly_derived_from (deref_to_type2
,
8204 else if (same_type_p (deref_to_type1
, deref_to_type2
))
8206 if (is_properly_derived_from (deref_from_type2
,
8209 else if (is_properly_derived_from (deref_from_type1
,
8215 else if (CLASS_TYPE_P (non_reference (from_type1
))
8216 && same_type_p (from_type1
, from_type2
))
8218 tree from
= non_reference (from_type1
);
8222 --binding of an expression of type C to a reference of type
8223 B& is better than binding an expression of type C to a
8224 reference of type A&
8226 --conversion of C to B is better than conversion of C to A, */
8227 if (is_properly_derived_from (from
, to_type1
)
8228 && is_properly_derived_from (from
, to_type2
))
8230 if (is_properly_derived_from (to_type1
, to_type2
))
8232 else if (is_properly_derived_from (to_type2
, to_type1
))
8236 else if (CLASS_TYPE_P (non_reference (to_type1
))
8237 && same_type_p (to_type1
, to_type2
))
8239 tree to
= non_reference (to_type1
);
8243 --binding of an expression of type B to a reference of type
8244 A& is better than binding an expression of type C to a
8245 reference of type A&,
8247 --conversion of B to A is better than conversion of C to A */
8248 if (is_properly_derived_from (from_type1
, to
)
8249 && is_properly_derived_from (from_type2
, to
))
8251 if (is_properly_derived_from (from_type2
, from_type1
))
8253 else if (is_properly_derived_from (from_type1
, from_type2
))
8260 --S1 and S2 differ only in their qualification conversion and yield
8261 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
8262 qualification signature of type T1 is a proper subset of the cv-
8263 qualification signature of type T2 */
8264 if (ics1
->kind
== ck_qual
8265 && ics2
->kind
== ck_qual
8266 && same_type_p (from_type1
, from_type2
))
8268 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
8275 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
8276 to an implicit object parameter, and either S1 binds an lvalue reference
8277 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
8278 reference to an rvalue and S2 binds an lvalue reference
8279 (C++0x draft standard, 13.3.3.2)
8281 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
8282 types to which the references refer are the same type except for
8283 top-level cv-qualifiers, and the type to which the reference
8284 initialized by S2 refers is more cv-qualified than the type to
8285 which the reference initialized by S1 refers.
8287 DR 1328 [over.match.best]: the context is an initialization by
8288 conversion function for direct reference binding (13.3.1.6) of a
8289 reference to function type, the return type of F1 is the same kind of
8290 reference (i.e. lvalue or rvalue) as the reference being initialized,
8291 and the return type of F2 is not. */
8293 if (ref_conv1
&& ref_conv2
)
8295 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
8296 && (ref_conv1
->rvaluedness_matches_p
8297 != ref_conv2
->rvaluedness_matches_p
)
8298 && (same_type_p (ref_conv1
->type
, ref_conv2
->type
)
8299 || (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
8300 != TYPE_REF_IS_RVALUE (ref_conv2
->type
))))
8302 return (ref_conv1
->rvaluedness_matches_p
8303 - ref_conv2
->rvaluedness_matches_p
);
8306 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
8307 return comp_cv_qualification (TREE_TYPE (ref_conv2
->type
),
8308 TREE_TYPE (ref_conv1
->type
));
8311 /* Neither conversion sequence is better than the other. */
8315 /* The source type for this standard conversion sequence. */
8318 source_type (conversion
*t
)
8320 for (;; t
= next_conversion (t
))
8322 if (t
->kind
== ck_user
8323 || t
->kind
== ck_ambig
8324 || t
->kind
== ck_identity
)
8330 /* Note a warning about preferring WINNER to LOSER. We do this by storing
8331 a pointer to LOSER and re-running joust to produce the warning if WINNER
8332 is actually used. */
8335 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
8337 candidate_warning
*cw
= (candidate_warning
*)
8338 conversion_obstack_alloc (sizeof (candidate_warning
));
8340 cw
->next
= winner
->warnings
;
8341 winner
->warnings
= cw
;
8344 /* Compare two candidates for overloading as described in
8345 [over.match.best]. Return values:
8347 1: cand1 is better than cand2
8348 -1: cand2 is better than cand1
8349 0: cand1 and cand2 are indistinguishable */
8352 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
,
8353 tsubst_flags_t complain
)
8356 int off1
= 0, off2
= 0;
8360 /* Candidates that involve bad conversions are always worse than those
8362 if (cand1
->viable
> cand2
->viable
)
8364 if (cand1
->viable
< cand2
->viable
)
8367 /* If we have two pseudo-candidates for conversions to the same type,
8368 or two candidates for the same function, arbitrarily pick one. */
8369 if (cand1
->fn
== cand2
->fn
8370 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
8373 /* Prefer a non-deleted function over an implicitly deleted move
8374 constructor or assignment operator. This differs slightly from the
8375 wording for issue 1402 (which says the move op is ignored by overload
8376 resolution), but this way produces better error messages. */
8377 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
8378 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
8379 && DECL_DELETED_FN (cand1
->fn
) != DECL_DELETED_FN (cand2
->fn
))
8381 if (DECL_DELETED_FN (cand1
->fn
) && DECL_DEFAULTED_FN (cand1
->fn
)
8382 && move_fn_p (cand1
->fn
))
8384 if (DECL_DELETED_FN (cand2
->fn
) && DECL_DEFAULTED_FN (cand2
->fn
)
8385 && move_fn_p (cand2
->fn
))
8389 /* a viable function F1
8390 is defined to be a better function than another viable function F2 if
8391 for all arguments i, ICSi(F1) is not a worse conversion sequence than
8392 ICSi(F2), and then */
8394 /* for some argument j, ICSj(F1) is a better conversion sequence than
8397 /* For comparing static and non-static member functions, we ignore
8398 the implicit object parameter of the non-static function. The
8399 standard says to pretend that the static function has an object
8400 parm, but that won't work with operator overloading. */
8401 len
= cand1
->num_convs
;
8402 if (len
!= cand2
->num_convs
)
8404 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
8405 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
8407 if (DECL_CONSTRUCTOR_P (cand1
->fn
)
8408 && is_list_ctor (cand1
->fn
) != is_list_ctor (cand2
->fn
))
8409 /* We're comparing a near-match list constructor and a near-match
8410 non-list constructor. Just treat them as unordered. */
8413 gcc_assert (static_1
!= static_2
);
8424 for (i
= 0; i
< len
; ++i
)
8426 conversion
*t1
= cand1
->convs
[i
+ off1
];
8427 conversion
*t2
= cand2
->convs
[i
+ off2
];
8428 int comp
= compare_ics (t1
, t2
);
8432 if ((complain
& tf_warning
)
8434 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
8435 == cr_std
+ cr_promotion
)
8436 && t1
->kind
== ck_std
8437 && t2
->kind
== ck_std
8438 && TREE_CODE (t1
->type
) == INTEGER_TYPE
8439 && TREE_CODE (t2
->type
) == INTEGER_TYPE
8440 && (TYPE_PRECISION (t1
->type
)
8441 == TYPE_PRECISION (t2
->type
))
8442 && (TYPE_UNSIGNED (next_conversion (t1
)->type
)
8443 || (TREE_CODE (next_conversion (t1
)->type
)
8446 tree type
= next_conversion (t1
)->type
;
8448 struct z_candidate
*w
, *l
;
8450 type1
= t1
->type
, type2
= t2
->type
,
8451 w
= cand1
, l
= cand2
;
8453 type1
= t2
->type
, type2
= t1
->type
,
8454 w
= cand2
, l
= cand1
;
8458 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
8459 type
, type1
, type2
);
8460 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
8466 if (winner
&& comp
!= winner
)
8475 /* warn about confusing overload resolution for user-defined conversions,
8476 either between a constructor and a conversion op, or between two
8478 if ((complain
& tf_warning
)
8479 && winner
&& warn_conversion
&& cand1
->second_conv
8480 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
8481 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
8483 struct z_candidate
*w
, *l
;
8484 bool give_warning
= false;
8487 w
= cand1
, l
= cand2
;
8489 w
= cand2
, l
= cand1
;
8491 /* We don't want to complain about `X::operator T1 ()'
8492 beating `X::operator T2 () const', when T2 is a no less
8493 cv-qualified version of T1. */
8494 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
8495 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
8497 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
8498 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
8500 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
8505 if (!comp_ptr_ttypes (t
, f
))
8506 give_warning
= true;
8509 give_warning
= true;
8515 tree source
= source_type (w
->convs
[0]);
8516 if (! DECL_CONSTRUCTOR_P (w
->fn
))
8517 source
= TREE_TYPE (source
);
8518 if (warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
)
8519 && warning (OPT_Wconversion
, " for conversion from %qT to %qT",
8520 source
, w
->second_conv
->type
))
8522 inform (input_location
, " because conversion sequence for the argument is better");
8532 /* DR 495 moved this tiebreaker above the template ones. */
8534 the context is an initialization by user-defined conversion (see
8535 _dcl.init_ and _over.match.user_) and the standard conversion
8536 sequence from the return type of F1 to the destination type (i.e.,
8537 the type of the entity being initialized) is a better conversion
8538 sequence than the standard conversion sequence from the return type
8539 of F2 to the destination type. */
8541 if (cand1
->second_conv
)
8543 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
8549 F1 is a non-template function and F2 is a template function
8552 if (!cand1
->template_decl
&& cand2
->template_decl
)
8554 else if (cand1
->template_decl
&& !cand2
->template_decl
)
8558 F1 and F2 are template functions and the function template for F1 is
8559 more specialized than the template for F2 according to the partial
8562 if (cand1
->template_decl
&& cand2
->template_decl
)
8564 winner
= more_specialized_fn
8565 (TI_TEMPLATE (cand1
->template_decl
),
8566 TI_TEMPLATE (cand2
->template_decl
),
8567 /* [temp.func.order]: The presence of unused ellipsis and default
8568 arguments has no effect on the partial ordering of function
8569 templates. add_function_candidate() will not have
8570 counted the "this" argument for constructors. */
8571 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
8576 /* Check whether we can discard a builtin candidate, either because we
8577 have two identical ones or matching builtin and non-builtin candidates.
8579 (Pedantically in the latter case the builtin which matched the user
8580 function should not be added to the overload set, but we spot it here.
8583 ... the builtin candidates include ...
8584 - do not have the same parameter type list as any non-template
8585 non-member candidate. */
8587 if (identifier_p (cand1
->fn
) || identifier_p (cand2
->fn
))
8589 for (i
= 0; i
< len
; ++i
)
8590 if (!same_type_p (cand1
->convs
[i
]->type
,
8591 cand2
->convs
[i
]->type
))
8593 if (i
== cand1
->num_convs
)
8595 if (cand1
->fn
== cand2
->fn
)
8596 /* Two built-in candidates; arbitrarily pick one. */
8598 else if (identifier_p (cand1
->fn
))
8599 /* cand1 is built-in; prefer cand2. */
8602 /* cand2 is built-in; prefer cand1. */
8607 /* For candidates of a multi-versioned function, make the version with
8608 the highest priority win. This version will be checked for dispatching
8609 first. If this version can be inlined into the caller, the front-end
8610 will simply make a direct call to this function. */
8612 if (TREE_CODE (cand1
->fn
) == FUNCTION_DECL
8613 && DECL_FUNCTION_VERSIONED (cand1
->fn
)
8614 && TREE_CODE (cand2
->fn
) == FUNCTION_DECL
8615 && DECL_FUNCTION_VERSIONED (cand2
->fn
))
8617 tree f1
= TREE_TYPE (cand1
->fn
);
8618 tree f2
= TREE_TYPE (cand2
->fn
);
8619 tree p1
= TYPE_ARG_TYPES (f1
);
8620 tree p2
= TYPE_ARG_TYPES (f2
);
8622 /* Check if cand1->fn and cand2->fn are versions of the same function. It
8623 is possible that cand1->fn and cand2->fn are function versions but of
8624 different functions. Check types to see if they are versions of the same
8626 if (compparms (p1
, p2
)
8627 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
8629 /* Always make the version with the higher priority, more
8630 specialized, win. */
8631 gcc_assert (targetm
.compare_version_priority
);
8632 if (targetm
.compare_version_priority (cand1
->fn
, cand2
->fn
) >= 0)
8639 /* If the two function declarations represent the same function (this can
8640 happen with declarations in multiple scopes and arg-dependent lookup),
8641 arbitrarily choose one. But first make sure the default args we're
8643 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
8644 && equal_functions (cand1
->fn
, cand2
->fn
))
8646 tree parms1
= TYPE_ARG_TYPES (TREE_TYPE (cand1
->fn
));
8647 tree parms2
= TYPE_ARG_TYPES (TREE_TYPE (cand2
->fn
));
8649 gcc_assert (!DECL_CONSTRUCTOR_P (cand1
->fn
));
8651 for (i
= 0; i
< len
; ++i
)
8653 /* Don't crash if the fn is variadic. */
8656 parms1
= TREE_CHAIN (parms1
);
8657 parms2
= TREE_CHAIN (parms2
);
8661 parms1
= TREE_CHAIN (parms1
);
8663 parms2
= TREE_CHAIN (parms2
);
8667 if (!cp_tree_equal (TREE_PURPOSE (parms1
),
8668 TREE_PURPOSE (parms2
)))
8672 if (complain
& tf_error
)
8674 if (permerror (input_location
,
8675 "default argument mismatch in "
8676 "overload resolution"))
8678 inform (input_location
,
8679 " candidate 1: %q+#F", cand1
->fn
);
8680 inform (input_location
,
8681 " candidate 2: %q+#F", cand2
->fn
);
8688 add_warning (cand1
, cand2
);
8691 parms1
= TREE_CHAIN (parms1
);
8692 parms2
= TREE_CHAIN (parms2
);
8700 /* Extension: If the worst conversion for one candidate is worse than the
8701 worst conversion for the other, take the first. */
8702 if (!pedantic
&& (complain
& tf_warning_or_error
))
8704 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
8705 struct z_candidate
*w
= 0, *l
= 0;
8707 for (i
= 0; i
< len
; ++i
)
8709 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
8710 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
8711 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
8712 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
8715 winner
= 1, w
= cand1
, l
= cand2
;
8717 winner
= -1, w
= cand2
, l
= cand1
;
8720 /* Don't choose a deleted function over ambiguity. */
8721 if (DECL_P (w
->fn
) && DECL_DELETED_FN (w
->fn
))
8725 pedwarn (input_location
, 0,
8726 "ISO C++ says that these are ambiguous, even "
8727 "though the worst conversion for the first is better than "
8728 "the worst conversion for the second:");
8729 print_z_candidate (input_location
, _("candidate 1:"), w
);
8730 print_z_candidate (input_location
, _("candidate 2:"), l
);
8738 gcc_assert (!winner
);
8742 /* Given a list of candidates for overloading, find the best one, if any.
8743 This algorithm has a worst case of O(2n) (winner is last), and a best
8744 case of O(n/2) (totally ambiguous); much better than a sorting
8747 static struct z_candidate
*
8748 tourney (struct z_candidate
*candidates
, tsubst_flags_t complain
)
8750 struct z_candidate
*champ
= candidates
, *challenger
;
8752 int champ_compared_to_predecessor
= 0;
8754 /* Walk through the list once, comparing each current champ to the next
8755 candidate, knocking out a candidate or two with each comparison. */
8757 for (challenger
= champ
->next
; challenger
; )
8759 fate
= joust (champ
, challenger
, 0, complain
);
8761 challenger
= challenger
->next
;
8766 champ
= challenger
->next
;
8769 champ_compared_to_predecessor
= 0;
8774 champ_compared_to_predecessor
= 1;
8777 challenger
= champ
->next
;
8781 /* Make sure the champ is better than all the candidates it hasn't yet
8782 been compared to. */
8784 for (challenger
= candidates
;
8786 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
8787 challenger
= challenger
->next
)
8789 fate
= joust (champ
, challenger
, 0, complain
);
8797 /* Returns nonzero if things of type FROM can be converted to TO. */
8800 can_convert (tree to
, tree from
, tsubst_flags_t complain
)
8802 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_IMPLICIT
, complain
);
8805 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
8808 can_convert_arg (tree to
, tree from
, tree arg
, int flags
,
8809 tsubst_flags_t complain
)
8815 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8816 p
= conversion_obstack_alloc (0);
8817 /* We want to discard any access checks done for this test,
8818 as we might not be in the appropriate access context and
8819 we'll do the check again when we actually perform the
8821 push_deferring_access_checks (dk_deferred
);
8823 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
8825 ok_p
= (t
&& !t
->bad_p
);
8827 /* Discard the access checks now. */
8828 pop_deferring_access_checks ();
8829 /* Free all the conversions we allocated. */
8830 obstack_free (&conversion_obstack
, p
);
8835 /* Like can_convert_arg, but allows dubious conversions as well. */
8838 can_convert_arg_bad (tree to
, tree from
, tree arg
, int flags
,
8839 tsubst_flags_t complain
)
8844 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8845 p
= conversion_obstack_alloc (0);
8846 /* Try to perform the conversion. */
8847 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
8849 /* Free all the conversions we allocated. */
8850 obstack_free (&conversion_obstack
, p
);
8855 /* Convert EXPR to TYPE. Return the converted expression.
8857 Note that we allow bad conversions here because by the time we get to
8858 this point we are committed to doing the conversion. If we end up
8859 doing a bad conversion, convert_like will complain. */
8862 perform_implicit_conversion_flags (tree type
, tree expr
,
8863 tsubst_flags_t complain
, int flags
)
8867 location_t loc
= EXPR_LOC_OR_HERE (expr
);
8869 if (error_operand_p (expr
))
8870 return error_mark_node
;
8872 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8873 p
= conversion_obstack_alloc (0);
8875 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
8881 if (complain
& tf_error
)
8883 /* If expr has unknown type, then it is an overloaded function.
8884 Call instantiate_type to get good error messages. */
8885 if (TREE_TYPE (expr
) == unknown_type_node
)
8886 instantiate_type (type
, expr
, complain
);
8887 else if (invalid_nonstatic_memfn_p (expr
, complain
))
8888 /* We gave an error. */;
8890 error_at (loc
, "could not convert %qE from %qT to %qT", expr
,
8891 TREE_TYPE (expr
), type
);
8893 expr
= error_mark_node
;
8895 else if (processing_template_decl
&& conv
->kind
!= ck_identity
)
8897 /* In a template, we are only concerned about determining the
8898 type of non-dependent expressions, so we do not have to
8899 perform the actual conversion. But for initializers, we
8900 need to be able to perform it at instantiation
8901 (or fold_non_dependent_expr) time. */
8902 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
8903 if (!(flags
& LOOKUP_ONLYCONVERTING
))
8904 IMPLICIT_CONV_EXPR_DIRECT_INIT (expr
) = true;
8907 expr
= convert_like (conv
, expr
, complain
);
8909 /* Free all the conversions we allocated. */
8910 obstack_free (&conversion_obstack
, p
);
8916 perform_implicit_conversion (tree type
, tree expr
, tsubst_flags_t complain
)
8918 return perform_implicit_conversion_flags (type
, expr
, complain
,
8922 /* Convert EXPR to TYPE (as a direct-initialization) if that is
8923 permitted. If the conversion is valid, the converted expression is
8924 returned. Otherwise, NULL_TREE is returned, except in the case
8925 that TYPE is a class type; in that case, an error is issued. If
8926 C_CAST_P is true, then this direct-initialization is taking
8927 place as part of a static_cast being attempted as part of a C-style
8931 perform_direct_initialization_if_possible (tree type
,
8934 tsubst_flags_t complain
)
8939 if (type
== error_mark_node
|| error_operand_p (expr
))
8940 return error_mark_node
;
8943 If the destination type is a (possibly cv-qualified) class type:
8945 -- If the initialization is direct-initialization ...,
8946 constructors are considered. ... If no constructor applies, or
8947 the overload resolution is ambiguous, the initialization is
8949 if (CLASS_TYPE_P (type
))
8951 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
8952 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
8953 &args
, type
, LOOKUP_NORMAL
, complain
);
8954 release_tree_vector (args
);
8955 return build_cplus_new (type
, expr
, complain
);
8958 /* Get the high-water mark for the CONVERSION_OBSTACK. */
8959 p
= conversion_obstack_alloc (0);
8961 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
8963 LOOKUP_NORMAL
, complain
);
8964 if (!conv
|| conv
->bad_p
)
8967 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
8968 /*issue_conversion_warnings=*/false,
8972 /* Free all the conversions we allocated. */
8973 obstack_free (&conversion_obstack
, p
);
8978 /* When initializing a reference that lasts longer than a full-expression,
8979 this special rule applies:
8983 The temporary to which the reference is bound or the temporary
8984 that is the complete object to which the reference is bound
8985 persists for the lifetime of the reference.
8987 The temporaries created during the evaluation of the expression
8988 initializing the reference, except the temporary to which the
8989 reference is bound, are destroyed at the end of the
8990 full-expression in which they are created.
8992 In that case, we store the converted expression into a new
8993 VAR_DECL in a new scope.
8995 However, we want to be careful not to create temporaries when
8996 they are not required. For example, given:
8999 struct D : public B {};
9003 there is no need to copy the return value from "f"; we can just
9004 extend its lifetime. Similarly, given:
9007 struct T { operator S(); };
9011 we can extend the lifetime of the return value of the conversion
9014 The next several functions are involved in this lifetime extension. */
9016 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
9017 reference is being bound to a temporary. Create and return a new
9018 VAR_DECL with the indicated TYPE; this variable will store the value to
9019 which the reference is bound. */
9022 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
9026 /* Create the variable. */
9027 var
= create_temporary_var (type
);
9029 /* Register the variable. */
9031 && (TREE_STATIC (decl
) || DECL_THREAD_LOCAL_P (decl
)))
9033 /* Namespace-scope or local static; give it a mangled name. */
9034 /* FIXME share comdat with decl? */
9037 TREE_STATIC (var
) = TREE_STATIC (decl
);
9038 DECL_TLS_MODEL (var
) = DECL_TLS_MODEL (decl
);
9039 name
= mangle_ref_init_variable (decl
);
9040 DECL_NAME (var
) = name
;
9041 SET_DECL_ASSEMBLER_NAME (var
, name
);
9042 var
= pushdecl_top_level (var
);
9045 /* Create a new cleanup level if necessary. */
9046 maybe_push_cleanup_level (type
);
9051 /* EXPR is the initializer for a variable DECL of reference or
9052 std::initializer_list type. Create, push and return a new VAR_DECL
9053 for the initializer so that it will live as long as DECL. Any
9054 cleanup for the new variable is returned through CLEANUP, and the
9055 code to initialize the new variable is returned through INITP. */
9058 set_up_extended_ref_temp (tree decl
, tree expr
, vec
<tree
, va_gc
> **cleanups
,
9065 /* Create the temporary variable. */
9066 type
= TREE_TYPE (expr
);
9067 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
9068 layout_decl (var
, 0);
9069 /* If the rvalue is the result of a function call it will be
9070 a TARGET_EXPR. If it is some other construct (such as a
9071 member access expression where the underlying object is
9072 itself the result of a function call), turn it into a
9073 TARGET_EXPR here. It is important that EXPR be a
9074 TARGET_EXPR below since otherwise the INIT_EXPR will
9075 attempt to make a bitwise copy of EXPR to initialize
9077 if (TREE_CODE (expr
) != TARGET_EXPR
)
9078 expr
= get_target_expr (expr
);
9080 if (TREE_CODE (decl
) == FIELD_DECL
9081 && extra_warnings
&& !TREE_NO_WARNING (decl
))
9083 warning (OPT_Wextra
, "a temporary bound to %qD only persists "
9084 "until the constructor exits", decl
);
9085 TREE_NO_WARNING (decl
) = true;
9088 /* Recursively extend temps in this initializer. */
9089 TARGET_EXPR_INITIAL (expr
)
9090 = extend_ref_init_temps (decl
, TARGET_EXPR_INITIAL (expr
), cleanups
);
9092 /* Any reference temp has a non-trivial initializer. */
9093 DECL_NONTRIVIALLY_INITIALIZED_P (var
) = true;
9095 /* If the initializer is constant, put it in DECL_INITIAL so we get
9096 static initialization and use in constant expressions. */
9097 init
= maybe_constant_init (expr
);
9098 if (TREE_CONSTANT (init
))
9100 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
9102 /* 5.19 says that a constant expression can include an
9103 lvalue-rvalue conversion applied to "a glvalue of literal type
9104 that refers to a non-volatile temporary object initialized
9105 with a constant expression". Rather than try to communicate
9106 that this VAR_DECL is a temporary, just mark it constexpr.
9108 Currently this is only useful for initializer_list temporaries,
9109 since reference vars can't appear in constant expressions. */
9110 DECL_DECLARED_CONSTEXPR_P (var
) = true;
9111 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var
) = true;
9112 TREE_CONSTANT (var
) = true;
9114 DECL_INITIAL (var
) = init
;
9118 /* Create the INIT_EXPR that will initialize the temporary
9120 init
= build2 (INIT_EXPR
, type
, var
, expr
);
9121 if (at_function_scope_p ())
9123 add_decl_expr (var
);
9125 if (TREE_STATIC (var
))
9126 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
9129 tree cleanup
= cxx_maybe_build_cleanup (var
, tf_warning_or_error
);
9131 vec_safe_push (*cleanups
, cleanup
);
9134 /* We must be careful to destroy the temporary only
9135 after its initialization has taken place. If the
9136 initialization throws an exception, then the
9137 destructor should not be run. We cannot simply
9138 transform INIT into something like:
9140 (INIT, ({ CLEANUP_STMT; }))
9142 because emit_local_var always treats the
9143 initializer as a full-expression. Thus, the
9144 destructor would run too early; it would run at the
9145 end of initializing the reference variable, rather
9146 than at the end of the block enclosing the
9149 The solution is to pass back a cleanup expression
9150 which the caller is responsible for attaching to
9151 the statement tree. */
9155 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
9156 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
9158 if (DECL_THREAD_LOCAL_P (var
))
9159 tls_aggregates
= tree_cons (NULL_TREE
, var
,
9162 static_aggregates
= tree_cons (NULL_TREE
, var
,
9171 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
9172 initializing a variable of that TYPE. */
9175 initialize_reference (tree type
, tree expr
,
9176 int flags
, tsubst_flags_t complain
)
9180 location_t loc
= EXPR_LOC_OR_HERE (expr
);
9182 if (type
== error_mark_node
|| error_operand_p (expr
))
9183 return error_mark_node
;
9185 /* Get the high-water mark for the CONVERSION_OBSTACK. */
9186 p
= conversion_obstack_alloc (0);
9188 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
9190 if (!conv
|| conv
->bad_p
)
9192 if (complain
& tf_error
)
9195 convert_like (conv
, expr
, complain
);
9196 else if (!CP_TYPE_CONST_P (TREE_TYPE (type
))
9197 && !TYPE_REF_IS_RVALUE (type
)
9198 && !real_lvalue_p (expr
))
9199 error_at (loc
, "invalid initialization of non-const reference of "
9200 "type %qT from an rvalue of type %qT",
9201 type
, TREE_TYPE (expr
));
9203 error_at (loc
, "invalid initialization of reference of type "
9204 "%qT from expression of type %qT", type
,
9207 return error_mark_node
;
9210 gcc_assert (conv
->kind
== ck_ref_bind
);
9212 /* Perform the conversion. */
9213 expr
= convert_like (conv
, expr
, complain
);
9215 /* Free all the conversions we allocated. */
9216 obstack_free (&conversion_obstack
, p
);
9221 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
9222 which is bound either to a reference or a std::initializer_list. */
9225 extend_ref_init_temps_1 (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9230 if (TREE_CODE (sub
) == COMPOUND_EXPR
)
9232 TREE_OPERAND (sub
, 1)
9233 = extend_ref_init_temps_1 (decl
, TREE_OPERAND (sub
, 1), cleanups
);
9236 if (TREE_CODE (sub
) != ADDR_EXPR
)
9238 /* Deal with binding to a subobject. */
9239 for (p
= &TREE_OPERAND (sub
, 0); TREE_CODE (*p
) == COMPONENT_REF
; )
9240 p
= &TREE_OPERAND (*p
, 0);
9241 if (TREE_CODE (*p
) == TARGET_EXPR
)
9243 tree subinit
= NULL_TREE
;
9244 *p
= set_up_extended_ref_temp (decl
, *p
, cleanups
, &subinit
);
9246 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
9247 recompute_tree_invariant_for_addr_expr (sub
);
9252 /* INIT is part of the initializer for DECL. If there are any
9253 reference or initializer lists being initialized, extend their
9254 lifetime to match that of DECL. */
9257 extend_ref_init_temps (tree decl
, tree init
, vec
<tree
, va_gc
> **cleanups
)
9259 tree type
= TREE_TYPE (init
);
9260 if (processing_template_decl
)
9262 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9263 init
= extend_ref_init_temps_1 (decl
, init
, cleanups
);
9264 else if (is_std_init_list (type
))
9266 /* The temporary array underlying a std::initializer_list
9267 is handled like a reference temporary. */
9269 if (TREE_CODE (ctor
) == TARGET_EXPR
)
9270 ctor
= TARGET_EXPR_INITIAL (ctor
);
9271 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
9273 tree array
= CONSTRUCTOR_ELT (ctor
, 0)->value
;
9274 array
= extend_ref_init_temps_1 (decl
, array
, cleanups
);
9275 CONSTRUCTOR_ELT (ctor
, 0)->value
= array
;
9278 else if (TREE_CODE (init
) == CONSTRUCTOR
)
9282 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
9283 FOR_EACH_VEC_SAFE_ELT (elts
, i
, p
)
9284 p
->value
= extend_ref_init_temps (decl
, p
->value
, cleanups
);
9290 /* Returns true iff an initializer for TYPE could contain temporaries that
9291 need to be extended because they are bound to references or
9292 std::initializer_list. */
9295 type_has_extended_temps (tree type
)
9297 type
= strip_array_types (type
);
9298 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9300 if (CLASS_TYPE_P (type
))
9302 if (is_std_init_list (type
))
9304 for (tree f
= next_initializable_field (TYPE_FIELDS (type
));
9305 f
; f
= next_initializable_field (DECL_CHAIN (f
)))
9306 if (type_has_extended_temps (TREE_TYPE (f
)))
9312 /* Returns true iff TYPE is some variant of std::initializer_list. */
9315 is_std_init_list (tree type
)
9317 /* Look through typedefs. */
9320 type
= TYPE_MAIN_VARIANT (type
);
9321 return (CLASS_TYPE_P (type
)
9322 && CP_TYPE_CONTEXT (type
) == std_node
9323 && strcmp (TYPE_NAME_STRING (type
), "initializer_list") == 0);
9326 /* Returns true iff DECL is a list constructor: i.e. a constructor which
9327 will accept an argument list of a single std::initializer_list<T>. */
9330 is_list_ctor (tree decl
)
9332 tree args
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
9335 if (!args
|| args
== void_list_node
)
9338 arg
= non_reference (TREE_VALUE (args
));
9339 if (!is_std_init_list (arg
))
9342 args
= TREE_CHAIN (args
);
9344 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9345 /* There are more non-defaulted parms. */
9351 #include "gt-cp-call.h"