1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com) and
6 modified by Brendan Kehoe (brendan@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* High-level class interface. */
29 #include "coretypes.h"
36 #include "diagnostic-core.h"
40 #include "langhooks.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 BOOL_BITFIELD bad_p : 1;
88 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
89 temporary should be created to hold the result of the
91 BOOL_BITFIELD need_temporary_p : 1;
92 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
93 from a pointer-to-derived to pointer-to-base is being performed. */
94 BOOL_BITFIELD base_p : 1;
95 /* If KIND is ck_ref_bind, true when either an lvalue reference is
96 being bound to an lvalue expression or an rvalue reference is
97 being bound to an rvalue expression. */
98 BOOL_BITFIELD rvaluedness_matches_p: 1;
99 BOOL_BITFIELD check_narrowing: 1;
100 /* The type of the expression resulting from the conversion. */
103 /* The next conversion in the chain. Since the conversions are
104 arranged from outermost to innermost, the NEXT conversion will
105 actually be performed before this conversion. This variant is
106 used only when KIND is neither ck_identity nor ck_ambig. */
108 /* The expression at the beginning of the conversion chain. This
109 variant is used only if KIND is ck_identity or ck_ambig. */
111 /* The array of conversions for an initializer_list. */
114 /* The function candidate corresponding to this conversion
115 sequence. This field is only used if KIND is ck_user. */
116 struct z_candidate *cand;
119 #define CONVERSION_RANK(NODE) \
120 ((NODE)->bad_p ? cr_bad \
121 : (NODE)->ellipsis_p ? cr_ellipsis \
122 : (NODE)->user_conv_p ? cr_user \
125 #define BAD_CONVERSION_RANK(NODE) \
126 ((NODE)->ellipsis_p ? cr_ellipsis \
127 : (NODE)->user_conv_p ? cr_user \
130 static struct obstack conversion_obstack;
131 static bool conversion_obstack_initialized;
133 static struct z_candidate * tourney (struct z_candidate *);
134 static int equal_functions (tree, tree);
135 static int joust (struct z_candidate *, struct z_candidate *, bool);
136 static int compare_ics (conversion *, conversion *);
137 static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
138 static tree build_java_interface_fn_ref (tree, tree);
139 #define convert_like(CONV, EXPR, COMPLAIN) \
140 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
141 /*issue_conversion_warnings=*/true, \
142 /*c_cast_p=*/false, (COMPLAIN))
143 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
144 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
145 /*issue_conversion_warnings=*/true, \
146 /*c_cast_p=*/false, (COMPLAIN))
147 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
148 bool, tsubst_flags_t);
149 static void op_error (enum tree_code, enum tree_code, tree, tree,
151 static VEC(tree,gc) *resolve_args (VEC(tree,gc) *);
152 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
153 static void print_z_candidate (const char *, struct z_candidate *);
154 static void print_z_candidates (struct z_candidate *);
155 static tree build_this (tree);
156 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
157 static bool any_strictly_viable (struct z_candidate *);
158 static struct z_candidate *add_template_candidate
159 (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
160 tree, tree, tree, int, unification_kind_t);
161 static struct z_candidate *add_template_candidate_real
162 (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
163 tree, tree, tree, int, tree, unification_kind_t);
164 static struct z_candidate *add_template_conv_candidate
165 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
167 static void add_builtin_candidates
168 (struct z_candidate **, enum tree_code, enum tree_code,
170 static void add_builtin_candidate
171 (struct z_candidate **, enum tree_code, enum tree_code,
172 tree, tree, tree, tree *, tree *, int);
173 static bool is_complete (tree);
174 static void build_builtin_candidate
175 (struct z_candidate **, tree, tree, tree, tree *, tree *,
177 static struct z_candidate *add_conv_candidate
178 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
180 static struct z_candidate *add_function_candidate
181 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
183 static conversion *implicit_conversion (tree, tree, tree, bool, int);
184 static conversion *standard_conversion (tree, tree, tree, bool, int);
185 static conversion *reference_binding (tree, tree, tree, bool, int);
186 static conversion *build_conv (conversion_kind, tree, conversion *);
187 static conversion *build_list_conv (tree, tree, int);
188 static bool is_subseq (conversion *, conversion *);
189 static conversion *maybe_handle_ref_bind (conversion **);
190 static void maybe_handle_implicit_object (conversion **);
191 static struct z_candidate *add_candidate
192 (struct z_candidate **, tree, tree, const VEC(tree,gc) *, size_t,
193 conversion **, tree, tree, int);
194 static tree source_type (conversion *);
195 static void add_warning (struct z_candidate *, struct z_candidate *);
196 static bool reference_compatible_p (tree, tree);
197 static conversion *convert_class_to_reference (tree, tree, tree, int);
198 static conversion *direct_reference_binding (tree, conversion *);
199 static bool promoted_arithmetic_type_p (tree);
200 static conversion *conditional_conversion (tree, tree);
201 static char *name_as_c_string (tree, tree, bool *);
202 static tree prep_operand (tree);
203 static void add_candidates (tree, tree, const VEC(tree,gc) *, tree, tree, bool,
204 tree, tree, int, struct z_candidate **);
205 static conversion *merge_conversion_sequences (conversion *, conversion *);
206 static bool magic_varargs_p (tree);
207 static tree build_temp (tree, tree, int, diagnostic_t *);
209 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
210 NAME can take many forms... */
213 check_dtor_name (tree basetype, tree name)
215 /* Just accept something we've already complained about. */
216 if (name == error_mark_node)
219 if (TREE_CODE (name) == TYPE_DECL)
220 name = TREE_TYPE (name);
221 else if (TYPE_P (name))
223 else if (TREE_CODE (name) == IDENTIFIER_NODE)
225 if ((MAYBE_CLASS_TYPE_P (basetype)
226 && name == constructor_name (basetype))
227 || (TREE_CODE (basetype) == ENUMERAL_TYPE
228 && name == TYPE_IDENTIFIER (basetype)))
231 name = get_type_value (name);
237 template <class T> struct S { ~S(); };
241 NAME will be a class template. */
242 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
246 if (!name || name == error_mark_node)
248 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
251 /* We want the address of a function or method. We avoid creating a
252 pointer-to-member function. */
255 build_addr_func (tree function)
257 tree type = TREE_TYPE (function);
259 /* We have to do these by hand to avoid real pointer to member
261 if (TREE_CODE (type) == METHOD_TYPE)
263 if (TREE_CODE (function) == OFFSET_REF)
265 tree object = build_address (TREE_OPERAND (function, 0));
266 return get_member_function_from_ptrfunc (&object,
267 TREE_OPERAND (function, 1));
269 function = build_address (function);
272 function = decay_conversion (function);
277 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
278 POINTER_TYPE to those. Note, pointer to member function types
279 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
280 two variants. build_call_a is the primitive taking an array of
281 arguments, while build_call_n is a wrapper that handles varargs. */
284 build_call_n (tree function, int n, ...)
287 return build_call_a (function, 0, NULL);
290 tree *argarray = XALLOCAVEC (tree, n);
295 for (i = 0; i < n; i++)
296 argarray[i] = va_arg (ap, tree);
298 return build_call_a (function, n, argarray);
303 build_call_a (tree function, int n, tree *argarray)
305 int is_constructor = 0;
312 function = build_addr_func (function);
314 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
315 fntype = TREE_TYPE (TREE_TYPE (function));
316 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
317 || TREE_CODE (fntype) == METHOD_TYPE);
318 result_type = TREE_TYPE (fntype);
319 /* An rvalue has no cv-qualifiers. */
320 if (SCALAR_TYPE_P (result_type) || VOID_TYPE_P (result_type))
321 result_type = cv_unqualified (result_type);
323 if (TREE_CODE (function) == ADDR_EXPR
324 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
326 decl = TREE_OPERAND (function, 0);
327 if (!TREE_USED (decl))
329 /* We invoke build_call directly for several library
330 functions. These may have been declared normally if
331 we're building libgcc, so we can't just check
333 gcc_assert (DECL_ARTIFICIAL (decl)
334 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
342 /* We check both the decl and the type; a function may be known not to
343 throw without being declared throw(). */
344 nothrow = ((decl && TREE_NOTHROW (decl))
345 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
347 if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)
348 current_function_returns_abnormally = 1;
350 if (decl && TREE_DEPRECATED (decl))
351 warn_deprecated_use (decl, NULL_TREE);
352 require_complete_eh_spec_types (fntype, decl);
354 if (decl && DECL_CONSTRUCTOR_P (decl))
357 /* Don't pass empty class objects by value. This is useful
358 for tags in STL, which are used to control overload resolution.
359 We don't need to handle other cases of copying empty classes. */
360 if (! decl || ! DECL_BUILT_IN (decl))
361 for (i = 0; i < n; i++)
362 if (is_empty_class (TREE_TYPE (argarray[i]))
363 && ! TREE_ADDRESSABLE (TREE_TYPE (argarray[i])))
365 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (argarray[i]));
366 argarray[i] = build2 (COMPOUND_EXPR, TREE_TYPE (t),
370 function = build_call_array_loc (input_location,
371 result_type, function, n, argarray);
372 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
373 TREE_NOTHROW (function) = nothrow;
378 /* Build something of the form ptr->method (args)
379 or object.method (args). This can also build
380 calls to constructors, and find friends.
382 Member functions always take their class variable
385 INSTANCE is a class instance.
387 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
389 PARMS help to figure out what that NAME really refers to.
391 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
392 down to the real instance type to use for access checking. We need this
393 information to get protected accesses correct.
395 FLAGS is the logical disjunction of zero or more LOOKUP_
396 flags. See cp-tree.h for more info.
398 If this is all OK, calls build_function_call with the resolved
401 This function must also handle being called to perform
402 initialization, promotion/coercion of arguments, and
403 instantiation of default parameters.
405 Note that NAME may refer to an instance variable name. If
406 `operator()()' is defined for the type of that field, then we return
409 /* New overloading code. */
411 typedef struct z_candidate z_candidate;
413 typedef struct candidate_warning candidate_warning;
414 struct candidate_warning {
416 candidate_warning *next;
420 /* The FUNCTION_DECL that will be called if this candidate is
421 selected by overload resolution. */
423 /* If not NULL_TREE, the first argument to use when calling this
426 /* The rest of the arguments to use when calling this function. If
427 there are no further arguments this may be NULL or it may be an
429 const VEC(tree,gc) *args;
430 /* The implicit conversion sequences for each of the arguments to
433 /* The number of implicit conversion sequences. */
435 /* If FN is a user-defined conversion, the standard conversion
436 sequence from the type returned by FN to the desired destination
438 conversion *second_conv;
440 /* If FN is a member function, the binfo indicating the path used to
441 qualify the name of FN at the call site. This path is used to
442 determine whether or not FN is accessible if it is selected by
443 overload resolution. The DECL_CONTEXT of FN will always be a
444 (possibly improper) base of this binfo. */
446 /* If FN is a non-static member function, the binfo indicating the
447 subobject to which the `this' pointer should be converted if FN
448 is selected by overload resolution. The type pointed to the by
449 the `this' pointer must correspond to the most derived class
450 indicated by the CONVERSION_PATH. */
451 tree conversion_path;
454 candidate_warning *warnings;
458 /* Returns true iff T is a null pointer constant in the sense of
462 null_ptr_cst_p (tree t)
466 A null pointer constant is an integral constant expression
467 (_expr.const_) rvalue of integer type that evaluates to zero or
468 an rvalue of type std::nullptr_t. */
469 t = integral_constant_value (t);
471 || NULLPTR_TYPE_P (TREE_TYPE (t)))
473 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
476 if (!TREE_OVERFLOW (t))
482 /* Returns nonzero if PARMLIST consists of only default parms and/or
486 sufficient_parms_p (const_tree parmlist)
488 for (; parmlist && parmlist != void_list_node;
489 parmlist = TREE_CHAIN (parmlist))
490 if (!TREE_PURPOSE (parmlist))
495 /* Allocate N bytes of memory from the conversion obstack. The memory
496 is zeroed before being returned. */
499 conversion_obstack_alloc (size_t n)
502 if (!conversion_obstack_initialized)
504 gcc_obstack_init (&conversion_obstack);
505 conversion_obstack_initialized = true;
507 p = obstack_alloc (&conversion_obstack, n);
512 /* Dynamically allocate a conversion. */
515 alloc_conversion (conversion_kind kind)
518 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
523 #ifdef ENABLE_CHECKING
525 /* Make sure that all memory on the conversion obstack has been
529 validate_conversion_obstack (void)
531 if (conversion_obstack_initialized)
532 gcc_assert ((obstack_next_free (&conversion_obstack)
533 == obstack_base (&conversion_obstack)));
536 #endif /* ENABLE_CHECKING */
538 /* Dynamically allocate an array of N conversions. */
541 alloc_conversions (size_t n)
543 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
547 build_conv (conversion_kind code, tree type, conversion *from)
550 conversion_rank rank = CONVERSION_RANK (from);
552 /* Note that the caller is responsible for filling in t->cand for
553 user-defined conversions. */
554 t = alloc_conversion (code);
577 t->user_conv_p = (code == ck_user || from->user_conv_p);
578 t->bad_p = from->bad_p;
583 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
584 specialization of std::initializer_list<T>, if such a conversion is
588 build_list_conv (tree type, tree ctor, int flags)
590 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
591 unsigned len = CONSTRUCTOR_NELTS (ctor);
592 conversion **subconvs = alloc_conversions (len);
597 /* Within a list-initialization we can have more user-defined
599 flags &= ~LOOKUP_NO_CONVERSION;
600 /* But no narrowing conversions. */
601 flags |= LOOKUP_NO_NARROWING;
603 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
606 = implicit_conversion (elttype, TREE_TYPE (val), val,
614 t = alloc_conversion (ck_list);
616 t->u.list = subconvs;
619 for (i = 0; i < len; ++i)
621 conversion *sub = subconvs[i];
622 if (sub->rank > t->rank)
624 if (sub->user_conv_p)
625 t->user_conv_p = true;
633 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
634 aggregate class, if such a conversion is possible. */
637 build_aggr_conv (tree type, tree ctor, int flags)
639 unsigned HOST_WIDE_INT i = 0;
641 tree field = next_initializable_field (TYPE_FIELDS (type));
642 tree empty_ctor = NULL_TREE;
644 for (; field; field = next_initializable_field (TREE_CHAIN (field)))
646 if (i < CONSTRUCTOR_NELTS (ctor))
648 constructor_elt *ce = CONSTRUCTOR_ELT (ctor, i);
649 if (!can_convert_arg (TREE_TYPE (field), TREE_TYPE (ce->value),
653 if (TREE_CODE (type) == UNION_TYPE)
658 if (empty_ctor == NULL_TREE)
659 empty_ctor = build_constructor (init_list_type_node, NULL);
660 if (!can_convert_arg (TREE_TYPE (field), TREE_TYPE (empty_ctor),
666 if (i < CONSTRUCTOR_NELTS (ctor))
669 c = alloc_conversion (ck_aggr);
672 c->user_conv_p = true;
677 /* Build a representation of the identity conversion from EXPR to
678 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
681 build_identity_conv (tree type, tree expr)
685 c = alloc_conversion (ck_identity);
692 /* Converting from EXPR to TYPE was ambiguous in the sense that there
693 were multiple user-defined conversions to accomplish the job.
694 Build a conversion that indicates that ambiguity. */
697 build_ambiguous_conv (tree type, tree expr)
701 c = alloc_conversion (ck_ambig);
709 strip_top_quals (tree t)
711 if (TREE_CODE (t) == ARRAY_TYPE)
713 return cp_build_qualified_type (t, 0);
716 /* Returns the standard conversion path (see [conv]) from type FROM to type
717 TO, if any. For proper handling of null pointer constants, you must
718 also pass the expression EXPR to convert from. If C_CAST_P is true,
719 this conversion is coming from a C-style cast. */
722 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
725 enum tree_code fcode, tcode;
727 bool fromref = false;
729 to = non_reference (to);
730 if (TREE_CODE (from) == REFERENCE_TYPE)
733 from = TREE_TYPE (from);
735 to = strip_top_quals (to);
736 from = strip_top_quals (from);
738 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
739 && expr && type_unknown_p (expr))
741 tsubst_flags_t tflags = tf_conv;
742 if (!(flags & LOOKUP_PROTECT))
743 tflags |= tf_no_access_control;
744 expr = instantiate_type (to, expr, tflags);
745 if (expr == error_mark_node)
747 from = TREE_TYPE (expr);
750 fcode = TREE_CODE (from);
751 tcode = TREE_CODE (to);
753 conv = build_identity_conv (from, expr);
754 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
756 from = type_decays_to (from);
757 fcode = TREE_CODE (from);
758 conv = build_conv (ck_lvalue, from, conv);
760 else if (fromref || (expr && lvalue_p (expr)))
765 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
768 from = strip_top_quals (bitfield_type);
769 fcode = TREE_CODE (from);
772 conv = build_conv (ck_rvalue, from, conv);
775 /* Allow conversion between `__complex__' data types. */
776 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
778 /* The standard conversion sequence to convert FROM to TO is
779 the standard conversion sequence to perform componentwise
781 conversion *part_conv = standard_conversion
782 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
786 conv = build_conv (part_conv->kind, to, conv);
787 conv->rank = part_conv->rank;
795 if (same_type_p (from, to))
799 A null pointer constant can be converted to a pointer type; ... A
800 null pointer constant of integral type can be converted to an
801 rvalue of type std::nullptr_t. */
802 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)
803 || NULLPTR_TYPE_P (to))
804 && expr && null_ptr_cst_p (expr))
805 conv = build_conv (ck_std, to, conv);
806 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
807 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
809 /* For backwards brain damage compatibility, allow interconversion of
810 pointers and integers with a pedwarn. */
811 conv = build_conv (ck_std, to, conv);
814 else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
816 /* For backwards brain damage compatibility, allow interconversion of
817 enums and integers with a pedwarn. */
818 conv = build_conv (ck_std, to, conv);
821 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
822 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
827 if (tcode == POINTER_TYPE
828 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
831 else if (VOID_TYPE_P (TREE_TYPE (to))
832 && !TYPE_PTRMEM_P (from)
833 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
835 from = build_pointer_type
836 (cp_build_qualified_type (void_type_node,
837 cp_type_quals (TREE_TYPE (from))));
838 conv = build_conv (ck_ptr, from, conv);
840 else if (TYPE_PTRMEM_P (from))
842 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
843 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
845 if (DERIVED_FROM_P (fbase, tbase)
846 && (same_type_ignoring_top_level_qualifiers_p
847 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
848 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
850 from = build_ptrmem_type (tbase,
851 TYPE_PTRMEM_POINTED_TO_TYPE (from));
852 conv = build_conv (ck_pmem, from, conv);
854 else if (!same_type_p (fbase, tbase))
857 else if (CLASS_TYPE_P (TREE_TYPE (from))
858 && CLASS_TYPE_P (TREE_TYPE (to))
861 An rvalue of type "pointer to cv D," where D is a
862 class type, can be converted to an rvalue of type
863 "pointer to cv B," where B is a base class (clause
864 _class.derived_) of D. If B is an inaccessible
865 (clause _class.access_) or ambiguous
866 (_class.member.lookup_) base class of D, a program
867 that necessitates this conversion is ill-formed.
868 Therefore, we use DERIVED_FROM_P, and do not check
869 access or uniqueness. */
870 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
873 cp_build_qualified_type (TREE_TYPE (to),
874 cp_type_quals (TREE_TYPE (from)));
875 from = build_pointer_type (from);
876 conv = build_conv (ck_ptr, from, conv);
880 if (tcode == POINTER_TYPE)
882 to_pointee = TREE_TYPE (to);
883 from_pointee = TREE_TYPE (from);
887 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
888 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
891 if (same_type_p (from, to))
893 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
894 /* In a C-style cast, we ignore CV-qualification because we
895 are allowed to perform a static_cast followed by a
897 conv = build_conv (ck_qual, to, conv);
898 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
899 conv = build_conv (ck_qual, to, conv);
900 else if (expr && string_conv_p (to, expr, 0))
901 /* converting from string constant to char *. */
902 conv = build_conv (ck_qual, to, conv);
903 else if (ptr_reasonably_similar (to_pointee, from_pointee))
905 conv = build_conv (ck_ptr, to, conv);
913 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
915 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
916 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
917 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
918 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
920 if (!DERIVED_FROM_P (fbase, tbase)
921 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
922 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
923 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
924 || cp_type_quals (fbase) != cp_type_quals (tbase))
927 from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
928 from = build_ptrmemfunc_type (build_pointer_type (from));
929 conv = build_conv (ck_pmem, from, conv);
932 else if (tcode == BOOLEAN_TYPE)
936 An rvalue of arithmetic, unscoped enumeration, pointer, or
937 pointer to member type can be converted to an rvalue of type
938 bool. ... An rvalue of type std::nullptr_t can be converted
939 to an rvalue of type bool; */
940 if (ARITHMETIC_TYPE_P (from)
941 || UNSCOPED_ENUM_P (from)
942 || fcode == POINTER_TYPE
943 || TYPE_PTR_TO_MEMBER_P (from)
944 || NULLPTR_TYPE_P (from))
946 conv = build_conv (ck_std, to, conv);
947 if (fcode == POINTER_TYPE
948 || TYPE_PTRMEM_P (from)
949 || (TYPE_PTRMEMFUNC_P (from)
950 && conv->rank < cr_pbool)
951 || NULLPTR_TYPE_P (from))
952 conv->rank = cr_pbool;
958 /* We don't check for ENUMERAL_TYPE here because there are no standard
959 conversions to enum type. */
960 /* As an extension, allow conversion to complex type. */
961 else if (ARITHMETIC_TYPE_P (to))
963 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
964 || SCOPED_ENUM_P (from))
966 conv = build_conv (ck_std, to, conv);
968 /* Give this a better rank if it's a promotion. */
969 if (same_type_p (to, type_promotes_to (from))
970 && conv->u.next->rank <= cr_promotion)
971 conv->rank = cr_promotion;
973 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
974 && vector_types_convertible_p (from, to, false))
975 return build_conv (ck_std, to, conv);
976 else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
977 && is_properly_derived_from (from, to))
979 if (conv->kind == ck_rvalue)
981 conv = build_conv (ck_base, to, conv);
982 /* The derived-to-base conversion indicates the initialization
983 of a parameter with base type from an object of a derived
984 type. A temporary object is created to hold the result of
985 the conversion unless we're binding directly to a reference. */
986 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
991 if (flags & LOOKUP_NO_NARROWING)
992 conv->check_narrowing = true;
997 /* Returns nonzero if T1 is reference-related to T2. */
1000 reference_related_p (tree t1, tree t2)
1002 t1 = TYPE_MAIN_VARIANT (t1);
1003 t2 = TYPE_MAIN_VARIANT (t2);
1007 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1008 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1010 return (same_type_p (t1, t2)
1011 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
1012 && DERIVED_FROM_P (t1, t2)));
1015 /* Returns nonzero if T1 is reference-compatible with T2. */
1018 reference_compatible_p (tree t1, tree t2)
1022 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1023 reference-related to T2 and cv1 is the same cv-qualification as,
1024 or greater cv-qualification than, cv2. */
1025 return (reference_related_p (t1, t2)
1026 && at_least_as_qualified_p (t1, t2));
1029 /* Determine whether or not the EXPR (of class type S) can be
1030 converted to T as in [over.match.ref]. */
1033 convert_class_to_reference (tree reference_type, tree s, tree expr, int flags)
1039 struct z_candidate *candidates;
1040 struct z_candidate *cand;
1043 conversions = lookup_conversions (s, /*lookup_template_convs_p=*/true);
1049 Assuming that "cv1 T" is the underlying type of the reference
1050 being initialized, and "cv S" is the type of the initializer
1051 expression, with S a class type, the candidate functions are
1052 selected as follows:
1054 --The conversion functions of S and its base classes are
1055 considered. Those that are not hidden within S and yield type
1056 "reference to cv2 T2", where "cv1 T" is reference-compatible
1057 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1059 The argument list has one argument, which is the initializer
1064 /* Conceptually, we should take the address of EXPR and put it in
1065 the argument list. Unfortunately, however, that can result in
1066 error messages, which we should not issue now because we are just
1067 trying to find a conversion operator. Therefore, we use NULL,
1068 cast to the appropriate type. */
1069 first_arg = build_int_cst (build_pointer_type (s), 0);
1071 t = TREE_TYPE (reference_type);
1073 /* We're performing a user-defined conversion to a desired type, so set
1074 this for the benefit of add_candidates. */
1075 flags |= LOOKUP_NO_CONVERSION;
1077 for (; conversions; conversions = TREE_CHAIN (conversions))
1079 tree fns = TREE_VALUE (conversions);
1080 tree binfo = TREE_PURPOSE (conversions);
1081 struct z_candidate *old_candidates = candidates;;
1083 add_candidates (fns, first_arg, NULL, reference_type,
1085 binfo, TYPE_BINFO (s),
1086 flags, &candidates);
1088 for (cand = candidates; cand != old_candidates; cand = cand->next)
1090 /* Now, see if the conversion function really returns
1091 an lvalue of the appropriate type. From the
1092 point of view of unification, simply returning an
1093 rvalue of the right type is good enough. */
1095 tree t2 = TREE_TYPE (TREE_TYPE (f));
1096 if (TREE_CODE (t2) != REFERENCE_TYPE
1097 || !reference_compatible_p (t, TREE_TYPE (t2)))
1103 conversion *identity_conv;
1104 /* Build a standard conversion sequence indicating the
1105 binding from the reference type returned by the
1106 function to the desired REFERENCE_TYPE. */
1108 = build_identity_conv (TREE_TYPE (TREE_TYPE
1109 (TREE_TYPE (cand->fn))),
1112 = (direct_reference_binding
1113 (reference_type, identity_conv));
1114 cand->second_conv->rvaluedness_matches_p
1115 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1116 == TYPE_REF_IS_RVALUE (reference_type);
1117 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1119 /* Don't allow binding of lvalues to rvalue references. */
1120 if (TYPE_REF_IS_RVALUE (reference_type)
1121 && !TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn))))
1122 cand->second_conv->bad_p = true;
1127 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1128 /* If none of the conversion functions worked out, let our caller
1133 cand = tourney (candidates);
1137 /* Now that we know that this is the function we're going to use fix
1138 the dummy first argument. */
1139 gcc_assert (cand->first_arg == NULL_TREE
1140 || integer_zerop (cand->first_arg));
1141 cand->first_arg = build_this (expr);
1143 /* Build a user-defined conversion sequence representing the
1145 conv = build_conv (ck_user,
1146 TREE_TYPE (TREE_TYPE (cand->fn)),
1147 build_identity_conv (TREE_TYPE (expr), expr));
1150 if (cand->viable == -1)
1153 /* Merge it with the standard conversion sequence from the
1154 conversion function's return type to the desired type. */
1155 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1157 return cand->second_conv;
1160 /* A reference of the indicated TYPE is being bound directly to the
1161 expression represented by the implicit conversion sequence CONV.
1162 Return a conversion sequence for this binding. */
1165 direct_reference_binding (tree type, conversion *conv)
1169 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1170 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1172 t = TREE_TYPE (type);
1176 When a parameter of reference type binds directly
1177 (_dcl.init.ref_) to an argument expression, the implicit
1178 conversion sequence is the identity conversion, unless the
1179 argument expression has a type that is a derived class of the
1180 parameter type, in which case the implicit conversion sequence is
1181 a derived-to-base Conversion.
1183 If the parameter binds directly to the result of applying a
1184 conversion function to the argument expression, the implicit
1185 conversion sequence is a user-defined conversion sequence
1186 (_over.ics.user_), with the second standard conversion sequence
1187 either an identity conversion or, if the conversion function
1188 returns an entity of a type that is a derived class of the
1189 parameter type, a derived-to-base conversion. */
1190 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1192 /* Represent the derived-to-base conversion. */
1193 conv = build_conv (ck_base, t, conv);
1194 /* We will actually be binding to the base-class subobject in
1195 the derived class, so we mark this conversion appropriately.
1196 That way, convert_like knows not to generate a temporary. */
1197 conv->need_temporary_p = false;
1199 return build_conv (ck_ref_bind, type, conv);
1202 /* Returns the conversion path from type FROM to reference type TO for
1203 purposes of reference binding. For lvalue binding, either pass a
1204 reference type to FROM or an lvalue expression to EXPR. If the
1205 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1206 the conversion returned. If C_CAST_P is true, this
1207 conversion is coming from a C-style cast. */
1210 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1212 conversion *conv = NULL;
1213 tree to = TREE_TYPE (rto);
1218 cp_lvalue_kind is_lvalue = clk_none;
1220 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1222 expr = instantiate_type (to, expr, tf_none);
1223 if (expr == error_mark_node)
1225 from = TREE_TYPE (expr);
1228 if (TREE_CODE (from) == REFERENCE_TYPE)
1230 /* Anything with reference type is an lvalue. */
1231 is_lvalue = clk_ordinary;
1232 from = TREE_TYPE (from);
1235 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1237 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1238 conv = implicit_conversion (to, from, expr, c_cast_p,
1240 if (!CLASS_TYPE_P (to)
1241 && CONSTRUCTOR_NELTS (expr) == 1)
1243 expr = CONSTRUCTOR_ELT (expr, 0)->value;
1244 if (error_operand_p (expr))
1246 from = TREE_TYPE (expr);
1250 if (is_lvalue == clk_none && expr)
1251 is_lvalue = real_lvalue_p (expr);
1254 if ((is_lvalue & clk_bitfield) != 0)
1255 tfrom = unlowered_expr_type (expr);
1257 /* Figure out whether or not the types are reference-related and
1258 reference compatible. We have do do this after stripping
1259 references from FROM. */
1260 related_p = reference_related_p (to, tfrom);
1261 /* If this is a C cast, first convert to an appropriately qualified
1262 type, so that we can later do a const_cast to the desired type. */
1263 if (related_p && c_cast_p
1264 && !at_least_as_qualified_p (to, tfrom))
1265 to = cp_build_qualified_type (to, cp_type_quals (tfrom));
1266 compatible_p = reference_compatible_p (to, tfrom);
1268 /* Directly bind reference when target expression's type is compatible with
1269 the reference and expression is an lvalue. In DR391, the wording in
1270 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1271 const and rvalue references to rvalues of compatible class type.
1272 We should also do direct bindings for non-class "rvalues" derived from
1273 rvalue references. */
1276 || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1277 && !(flags & LOOKUP_NO_TEMP_BIND))
1278 || TYPE_REF_IS_RVALUE (rto))
1279 && (CLASS_TYPE_P (from) || (expr && lvalue_p (expr))))))
1283 If the initializer expression
1285 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1286 is reference-compatible with "cv2 T2,"
1288 the reference is bound directly to the initializer expression
1292 If the initializer expression is an rvalue, with T2 a class type,
1293 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1294 is bound to the object represented by the rvalue or to a sub-object
1295 within that object. */
1297 conv = build_identity_conv (tfrom, expr);
1298 conv = direct_reference_binding (rto, conv);
1300 if (flags & LOOKUP_PREFER_RVALUE)
1301 /* The top-level caller requested that we pretend that the lvalue
1302 be treated as an rvalue. */
1303 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1305 conv->rvaluedness_matches_p
1306 = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1308 if ((is_lvalue & clk_bitfield) != 0
1309 || ((is_lvalue & clk_packed) != 0 && !TYPE_PACKED (to)))
1310 /* For the purposes of overload resolution, we ignore the fact
1311 this expression is a bitfield or packed field. (In particular,
1312 [over.ics.ref] says specifically that a function with a
1313 non-const reference parameter is viable even if the
1314 argument is a bitfield.)
1316 However, when we actually call the function we must create
1317 a temporary to which to bind the reference. If the
1318 reference is volatile, or isn't const, then we cannot make
1319 a temporary, so we just issue an error when the conversion
1321 conv->need_temporary_p = true;
1323 /* Don't allow binding of lvalues to rvalue references. */
1324 if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1325 && !(flags & LOOKUP_PREFER_RVALUE))
1330 /* [class.conv.fct] A conversion function is never used to convert a
1331 (possibly cv-qualified) object to the (possibly cv-qualified) same
1332 object type (or a reference to it), to a (possibly cv-qualified) base
1333 class of that type (or a reference to it).... */
1334 else if (CLASS_TYPE_P (from) && !related_p
1335 && !(flags & LOOKUP_NO_CONVERSION))
1339 If the initializer expression
1341 -- has a class type (i.e., T2 is a class type) can be
1342 implicitly converted to an lvalue of type "cv3 T3," where
1343 "cv1 T1" is reference-compatible with "cv3 T3". (this
1344 conversion is selected by enumerating the applicable
1345 conversion functions (_over.match.ref_) and choosing the
1346 best one through overload resolution. (_over.match_).
1348 the reference is bound to the lvalue result of the conversion
1349 in the second case. */
1350 conv = convert_class_to_reference (rto, from, expr, flags);
1355 /* From this point on, we conceptually need temporaries, even if we
1356 elide them. Only the cases above are "direct bindings". */
1357 if (flags & LOOKUP_NO_TEMP_BIND)
1362 When a parameter of reference type is not bound directly to an
1363 argument expression, the conversion sequence is the one required
1364 to convert the argument expression to the underlying type of the
1365 reference according to _over.best.ics_. Conceptually, this
1366 conversion sequence corresponds to copy-initializing a temporary
1367 of the underlying type with the argument expression. Any
1368 difference in top-level cv-qualification is subsumed by the
1369 initialization itself and does not constitute a conversion. */
1373 Otherwise, the reference shall be to a non-volatile const type.
1375 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1376 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1381 Otherwise, a temporary of type "cv1 T1" is created and
1382 initialized from the initializer expression using the rules for a
1383 non-reference copy initialization. If T1 is reference-related to
1384 T2, cv1 must be the same cv-qualification as, or greater
1385 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1386 if (related_p && !at_least_as_qualified_p (to, from))
1389 /* We're generating a temporary now, but don't bind any more in the
1390 conversion (specifically, don't slice the temporary returned by a
1391 conversion operator). */
1392 flags |= LOOKUP_NO_TEMP_BIND;
1394 /* Core issue 899: When [copy-]initializing a temporary to be bound
1395 to the first parameter of a copy constructor (12.8) called with
1396 a single argument in the context of direct-initialization,
1397 explicit conversion functions are also considered.
1399 So don't set LOOKUP_ONLYCONVERTING in that case. */
1400 if (!(flags & LOOKUP_COPY_PARM))
1401 flags |= LOOKUP_ONLYCONVERTING;
1404 conv = implicit_conversion (to, from, expr, c_cast_p,
1409 conv = build_conv (ck_ref_bind, rto, conv);
1410 /* This reference binding, unlike those above, requires the
1411 creation of a temporary. */
1412 conv->need_temporary_p = true;
1413 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1418 /* Returns the implicit conversion sequence (see [over.ics]) from type
1419 FROM to type TO. The optional expression EXPR may affect the
1420 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1421 true, this conversion is coming from a C-style cast. */
1424 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1429 if (from == error_mark_node || to == error_mark_node
1430 || expr == error_mark_node)
1433 if (TREE_CODE (to) == REFERENCE_TYPE)
1434 conv = reference_binding (to, from, expr, c_cast_p, flags);
1436 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1441 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1443 if (is_std_init_list (to))
1444 return build_list_conv (to, expr, flags);
1446 /* Allow conversion from an initializer-list with one element to a
1448 if (SCALAR_TYPE_P (to))
1450 int nelts = CONSTRUCTOR_NELTS (expr);
1454 elt = integer_zero_node;
1455 else if (nelts == 1)
1456 elt = CONSTRUCTOR_ELT (expr, 0)->value;
1458 elt = error_mark_node;
1460 conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1464 conv->check_narrowing = true;
1465 if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1466 /* Too many levels of braces, i.e. '{{1}}'. */
1473 if (expr != NULL_TREE
1474 && (MAYBE_CLASS_TYPE_P (from)
1475 || MAYBE_CLASS_TYPE_P (to))
1476 && (flags & LOOKUP_NO_CONVERSION) == 0)
1478 struct z_candidate *cand;
1479 int convflags = (flags & (LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING
1480 |LOOKUP_NO_NARROWING));
1482 if (CLASS_TYPE_P (to)
1483 && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1484 && BRACE_ENCLOSED_INITIALIZER_P (expr))
1485 return build_aggr_conv (to, expr, flags);
1487 cand = build_user_type_conversion_1 (to, expr, convflags);
1489 conv = cand->second_conv;
1491 /* We used to try to bind a reference to a temporary here, but that
1492 is now handled after the recursive call to this function at the end
1493 of reference_binding. */
1500 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1501 functions. ARGS will not be changed until a single candidate is
1504 static struct z_candidate *
1505 add_candidate (struct z_candidate **candidates,
1506 tree fn, tree first_arg, const VEC(tree,gc) *args,
1507 size_t num_convs, conversion **convs,
1508 tree access_path, tree conversion_path,
1511 struct z_candidate *cand = (struct z_candidate *)
1512 conversion_obstack_alloc (sizeof (struct z_candidate));
1515 cand->first_arg = first_arg;
1517 cand->convs = convs;
1518 cand->num_convs = num_convs;
1519 cand->access_path = access_path;
1520 cand->conversion_path = conversion_path;
1521 cand->viable = viable;
1522 cand->next = *candidates;
1528 /* Create an overload candidate for the function or method FN called
1529 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1530 FLAGS is passed on to implicit_conversion.
1532 This does not change ARGS.
1534 CTYPE, if non-NULL, is the type we want to pretend this function
1535 comes from for purposes of overload resolution. */
1537 static struct z_candidate *
1538 add_function_candidate (struct z_candidate **candidates,
1539 tree fn, tree ctype, tree first_arg,
1540 const VEC(tree,gc) *args, tree access_path,
1541 tree conversion_path, int flags)
1543 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1547 tree orig_first_arg = first_arg;
1551 /* At this point we should not see any functions which haven't been
1552 explicitly declared, except for friend functions which will have
1553 been found using argument dependent lookup. */
1554 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1556 /* The `this', `in_chrg' and VTT arguments to constructors are not
1557 considered in overload resolution. */
1558 if (DECL_CONSTRUCTOR_P (fn))
1560 parmlist = skip_artificial_parms_for (fn, parmlist);
1561 skip = num_artificial_parms_for (fn);
1562 if (skip > 0 && first_arg != NULL_TREE)
1565 first_arg = NULL_TREE;
1571 len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1572 convs = alloc_conversions (len);
1574 /* 13.3.2 - Viable functions [over.match.viable]
1575 First, to be a viable function, a candidate function shall have enough
1576 parameters to agree in number with the arguments in the list.
1578 We need to check this first; otherwise, checking the ICSes might cause
1579 us to produce an ill-formed template instantiation. */
1581 parmnode = parmlist;
1582 for (i = 0; i < len; ++i)
1584 if (parmnode == NULL_TREE || parmnode == void_list_node)
1586 parmnode = TREE_CHAIN (parmnode);
1589 if (i < len && parmnode)
1592 /* Make sure there are default args for the rest of the parms. */
1593 else if (!sufficient_parms_p (parmnode))
1599 /* Second, for F to be a viable function, there shall exist for each
1600 argument an implicit conversion sequence that converts that argument
1601 to the corresponding parameter of F. */
1603 parmnode = parmlist;
1605 for (i = 0; i < len; ++i)
1611 if (parmnode == void_list_node)
1614 if (i == 0 && first_arg != NULL_TREE)
1617 arg = VEC_index (tree, args,
1618 i + skip - (first_arg != NULL_TREE ? 1 : 0));
1619 argtype = lvalue_type (arg);
1621 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1622 && ! DECL_CONSTRUCTOR_P (fn));
1626 tree parmtype = TREE_VALUE (parmnode);
1629 parmnode = TREE_CHAIN (parmnode);
1631 /* The type of the implicit object parameter ('this') for
1632 overload resolution is not always the same as for the
1633 function itself; conversion functions are considered to
1634 be members of the class being converted, and functions
1635 introduced by a using-declaration are considered to be
1636 members of the class that uses them.
1638 Since build_over_call ignores the ICS for the `this'
1639 parameter, we can just change the parm type. */
1640 if (ctype && is_this)
1642 parmtype = cp_build_qualified_type
1643 (ctype, cp_type_quals (TREE_TYPE (parmtype)));
1644 parmtype = build_pointer_type (parmtype);
1647 /* Core issue 899: When [copy-]initializing a temporary to be bound
1648 to the first parameter of a copy constructor (12.8) called with
1649 a single argument in the context of direct-initialization,
1650 explicit conversion functions are also considered.
1652 So set LOOKUP_COPY_PARM to let reference_binding know that
1653 it's being called in that context. We generalize the above
1654 to handle move constructors and template constructors as well;
1655 the standardese should soon be updated similarly. */
1656 if (ctype && i == 0 && (len-skip == 1)
1657 && !(flags & LOOKUP_ONLYCONVERTING)
1658 && DECL_CONSTRUCTOR_P (fn)
1659 && parmtype != error_mark_node
1660 && (same_type_ignoring_top_level_qualifiers_p
1661 (non_reference (parmtype), ctype)))
1663 lflags |= LOOKUP_COPY_PARM;
1664 /* We allow user-defined conversions within init-lists, but
1665 not for the copy constructor. */
1666 if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1667 lflags |= LOOKUP_NO_CONVERSION;
1670 lflags |= LOOKUP_ONLYCONVERTING;
1672 t = implicit_conversion (parmtype, argtype, arg,
1673 /*c_cast_p=*/false, lflags);
1677 t = build_identity_conv (argtype, arg);
1678 t->ellipsis_p = true;
1696 return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
1697 access_path, conversion_path, viable);
1700 /* Create an overload candidate for the conversion function FN which will
1701 be invoked for expression OBJ, producing a pointer-to-function which
1702 will in turn be called with the argument list FIRST_ARG/ARGLIST,
1703 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
1704 passed on to implicit_conversion.
1706 Actually, we don't really care about FN; we care about the type it
1707 converts to. There may be multiple conversion functions that will
1708 convert to that type, and we rely on build_user_type_conversion_1 to
1709 choose the best one; so when we create our candidate, we record the type
1710 instead of the function. */
1712 static struct z_candidate *
1713 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1714 tree first_arg, const VEC(tree,gc) *arglist,
1715 tree access_path, tree conversion_path)
1717 tree totype = TREE_TYPE (TREE_TYPE (fn));
1718 int i, len, viable, flags;
1719 tree parmlist, parmnode;
1722 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1723 parmlist = TREE_TYPE (parmlist);
1724 parmlist = TYPE_ARG_TYPES (parmlist);
1726 len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
1727 convs = alloc_conversions (len);
1728 parmnode = parmlist;
1730 flags = LOOKUP_IMPLICIT;
1732 /* Don't bother looking up the same type twice. */
1733 if (*candidates && (*candidates)->fn == totype)
1736 for (i = 0; i < len; ++i)
1743 else if (i == 1 && first_arg != NULL_TREE)
1746 arg = VEC_index (tree, arglist,
1747 i - (first_arg != NULL_TREE ? 1 : 0) - 1);
1748 argtype = lvalue_type (arg);
1751 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1753 else if (parmnode == void_list_node)
1756 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1757 /*c_cast_p=*/false, flags);
1760 t = build_identity_conv (argtype, arg);
1761 t->ellipsis_p = true;
1775 parmnode = TREE_CHAIN (parmnode);
1781 if (!sufficient_parms_p (parmnode))
1784 return add_candidate (candidates, totype, first_arg, arglist, len, convs,
1785 access_path, conversion_path, viable);
1789 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1790 tree type1, tree type2, tree *args, tree *argtypes,
1802 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1803 convs = alloc_conversions (num_convs);
1805 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
1806 conversion ops are allowed. We handle that here by just checking for
1807 boolean_type_node because other operators don't ask for it. COND_EXPR
1808 also does contextual conversion to bool for the first operand, but we
1809 handle that in build_conditional_expr, and type1 here is operand 2. */
1810 if (type1 != boolean_type_node)
1811 flags |= LOOKUP_ONLYCONVERTING;
1813 for (i = 0; i < 2; ++i)
1818 t = implicit_conversion (types[i], argtypes[i], args[i],
1819 /*c_cast_p=*/false, flags);
1823 /* We need something for printing the candidate. */
1824 t = build_identity_conv (types[i], NULL_TREE);
1831 /* For COND_EXPR we rearranged the arguments; undo that now. */
1834 convs[2] = convs[1];
1835 convs[1] = convs[0];
1836 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1837 /*c_cast_p=*/false, flags);
1844 add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
1846 /*access_path=*/NULL_TREE,
1847 /*conversion_path=*/NULL_TREE,
1852 is_complete (tree t)
1854 return COMPLETE_TYPE_P (complete_type (t));
1857 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1860 promoted_arithmetic_type_p (tree type)
1864 In this section, the term promoted integral type is used to refer
1865 to those integral types which are preserved by integral promotion
1866 (including e.g. int and long but excluding e.g. char).
1867 Similarly, the term promoted arithmetic type refers to promoted
1868 integral types plus floating types. */
1869 return ((CP_INTEGRAL_TYPE_P (type)
1870 && same_type_p (type_promotes_to (type), type))
1871 || TREE_CODE (type) == REAL_TYPE);
1874 /* Create any builtin operator overload candidates for the operator in
1875 question given the converted operand types TYPE1 and TYPE2. The other
1876 args are passed through from add_builtin_candidates to
1877 build_builtin_candidate.
1879 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1880 If CODE is requires candidates operands of the same type of the kind
1881 of which TYPE1 and TYPE2 are, we add both candidates
1882 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1885 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1886 enum tree_code code2, tree fnname, tree type1,
1887 tree type2, tree *args, tree *argtypes, int flags)
1891 case POSTINCREMENT_EXPR:
1892 case POSTDECREMENT_EXPR:
1893 args[1] = integer_zero_node;
1894 type2 = integer_type_node;
1903 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1904 and VQ is either volatile or empty, there exist candidate operator
1905 functions of the form
1906 VQ T& operator++(VQ T&);
1907 T operator++(VQ T&, int);
1908 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1909 type other than bool, and VQ is either volatile or empty, there exist
1910 candidate operator functions of the form
1911 VQ T& operator--(VQ T&);
1912 T operator--(VQ T&, int);
1913 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1914 complete object type, and VQ is either volatile or empty, there exist
1915 candidate operator functions of the form
1916 T*VQ& operator++(T*VQ&);
1917 T*VQ& operator--(T*VQ&);
1918 T* operator++(T*VQ&, int);
1919 T* operator--(T*VQ&, int); */
1921 case POSTDECREMENT_EXPR:
1922 case PREDECREMENT_EXPR:
1923 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1925 case POSTINCREMENT_EXPR:
1926 case PREINCREMENT_EXPR:
1927 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1929 type1 = build_reference_type (type1);
1934 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1935 exist candidate operator functions of the form
1939 8 For every function type T, there exist candidate operator functions of
1941 T& operator*(T*); */
1944 if (TREE_CODE (type1) == POINTER_TYPE
1945 && (TYPE_PTROB_P (type1)
1946 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1950 /* 9 For every type T, there exist candidate operator functions of the form
1953 10For every promoted arithmetic type T, there exist candidate operator
1954 functions of the form
1958 case UNARY_PLUS_EXPR: /* unary + */
1959 if (TREE_CODE (type1) == POINTER_TYPE)
1962 if (ARITHMETIC_TYPE_P (type1))
1966 /* 11For every promoted integral type T, there exist candidate operator
1967 functions of the form
1971 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
1975 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1976 is the same type as C2 or is a derived class of C2, T is a complete
1977 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1978 there exist candidate operator functions of the form
1979 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1980 where CV12 is the union of CV1 and CV2. */
1983 if (TREE_CODE (type1) == POINTER_TYPE
1984 && TYPE_PTR_TO_MEMBER_P (type2))
1986 tree c1 = TREE_TYPE (type1);
1987 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1989 if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
1990 && (TYPE_PTRMEMFUNC_P (type2)
1991 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1996 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1997 didate operator functions of the form
2002 bool operator<(L, R);
2003 bool operator>(L, R);
2004 bool operator<=(L, R);
2005 bool operator>=(L, R);
2006 bool operator==(L, R);
2007 bool operator!=(L, R);
2008 where LR is the result of the usual arithmetic conversions between
2011 14For every pair of types T and I, where T is a cv-qualified or cv-
2012 unqualified complete object type and I is a promoted integral type,
2013 there exist candidate operator functions of the form
2014 T* operator+(T*, I);
2015 T& operator[](T*, I);
2016 T* operator-(T*, I);
2017 T* operator+(I, T*);
2018 T& operator[](I, T*);
2020 15For every T, where T is a pointer to complete object type, there exist
2021 candidate operator functions of the form112)
2022 ptrdiff_t operator-(T, T);
2024 16For every pointer or enumeration type T, there exist candidate operator
2025 functions of the form
2026 bool operator<(T, T);
2027 bool operator>(T, T);
2028 bool operator<=(T, T);
2029 bool operator>=(T, T);
2030 bool operator==(T, T);
2031 bool operator!=(T, T);
2033 17For every pointer to member type T, there exist candidate operator
2034 functions of the form
2035 bool operator==(T, T);
2036 bool operator!=(T, T); */
2039 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2041 if (TYPE_PTROB_P (type1)
2042 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2044 type2 = ptrdiff_type_node;
2048 case TRUNC_DIV_EXPR:
2049 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2055 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2056 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2058 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2063 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2075 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2077 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2079 if (TREE_CODE (type1) == ENUMERAL_TYPE
2080 && TREE_CODE (type2) == ENUMERAL_TYPE)
2082 if (TYPE_PTR_P (type1)
2083 && null_ptr_cst_p (args[1])
2084 && !uses_template_parms (type1))
2089 if (null_ptr_cst_p (args[0])
2090 && TYPE_PTR_P (type2)
2091 && !uses_template_parms (type2))
2099 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2102 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2104 type1 = ptrdiff_type_node;
2107 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2109 type2 = ptrdiff_type_node;
2114 /* 18For every pair of promoted integral types L and R, there exist candi-
2115 date operator functions of the form
2122 where LR is the result of the usual arithmetic conversions between
2125 case TRUNC_MOD_EXPR:
2131 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2135 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2136 type, VQ is either volatile or empty, and R is a promoted arithmetic
2137 type, there exist candidate operator functions of the form
2138 VQ L& operator=(VQ L&, R);
2139 VQ L& operator*=(VQ L&, R);
2140 VQ L& operator/=(VQ L&, R);
2141 VQ L& operator+=(VQ L&, R);
2142 VQ L& operator-=(VQ L&, R);
2144 20For every pair T, VQ), where T is any type and VQ is either volatile
2145 or empty, there exist candidate operator functions of the form
2146 T*VQ& operator=(T*VQ&, T*);
2148 21For every pair T, VQ), where T is a pointer to member type and VQ is
2149 either volatile or empty, there exist candidate operator functions of
2151 VQ T& operator=(VQ T&, T);
2153 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2154 unqualified complete object type, VQ is either volatile or empty, and
2155 I is a promoted integral type, there exist candidate operator func-
2157 T*VQ& operator+=(T*VQ&, I);
2158 T*VQ& operator-=(T*VQ&, I);
2160 23For every triple L, VQ, R), where L is an integral or enumeration
2161 type, VQ is either volatile or empty, and R is a promoted integral
2162 type, there exist candidate operator functions of the form
2164 VQ L& operator%=(VQ L&, R);
2165 VQ L& operator<<=(VQ L&, R);
2166 VQ L& operator>>=(VQ L&, R);
2167 VQ L& operator&=(VQ L&, R);
2168 VQ L& operator^=(VQ L&, R);
2169 VQ L& operator|=(VQ L&, R); */
2176 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2178 type2 = ptrdiff_type_node;
2182 case TRUNC_DIV_EXPR:
2183 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2187 case TRUNC_MOD_EXPR:
2193 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2198 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2200 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2201 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2202 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2203 || ((TYPE_PTRMEMFUNC_P (type1)
2204 || TREE_CODE (type1) == POINTER_TYPE)
2205 && null_ptr_cst_p (args[1])))
2215 type1 = build_reference_type (type1);
2221 For every pair of promoted arithmetic types L and R, there
2222 exist candidate operator functions of the form
2224 LR operator?(bool, L, R);
2226 where LR is the result of the usual arithmetic conversions
2227 between types L and R.
2229 For every type T, where T is a pointer or pointer-to-member
2230 type, there exist candidate operator functions of the form T
2231 operator?(bool, T, T); */
2233 if (promoted_arithmetic_type_p (type1)
2234 && promoted_arithmetic_type_p (type2))
2238 /* Otherwise, the types should be pointers. */
2239 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2240 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2243 /* We don't check that the two types are the same; the logic
2244 below will actually create two candidates; one in which both
2245 parameter types are TYPE1, and one in which both parameter
2253 /* If we're dealing with two pointer types or two enumeral types,
2254 we need candidates for both of them. */
2255 if (type2 && !same_type_p (type1, type2)
2256 && TREE_CODE (type1) == TREE_CODE (type2)
2257 && (TREE_CODE (type1) == REFERENCE_TYPE
2258 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2259 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2260 || TYPE_PTRMEMFUNC_P (type1)
2261 || MAYBE_CLASS_TYPE_P (type1)
2262 || TREE_CODE (type1) == ENUMERAL_TYPE))
2264 build_builtin_candidate
2265 (candidates, fnname, type1, type1, args, argtypes, flags);
2266 build_builtin_candidate
2267 (candidates, fnname, type2, type2, args, argtypes, flags);
2271 build_builtin_candidate
2272 (candidates, fnname, type1, type2, args, argtypes, flags);
2276 type_decays_to (tree type)
2278 if (TREE_CODE (type) == ARRAY_TYPE)
2279 return build_pointer_type (TREE_TYPE (type));
2280 if (TREE_CODE (type) == FUNCTION_TYPE)
2281 return build_pointer_type (type);
2282 if (!MAYBE_CLASS_TYPE_P (type))
2283 type = cv_unqualified (type);
2287 /* There are three conditions of builtin candidates:
2289 1) bool-taking candidates. These are the same regardless of the input.
2290 2) pointer-pair taking candidates. These are generated for each type
2291 one of the input types converts to.
2292 3) arithmetic candidates. According to the standard, we should generate
2293 all of these, but I'm trying not to...
2295 Here we generate a superset of the possible candidates for this particular
2296 case. That is a subset of the full set the standard defines, plus some
2297 other cases which the standard disallows. add_builtin_candidate will
2298 filter out the invalid set. */
2301 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2302 enum tree_code code2, tree fnname, tree *args,
2307 tree type, argtypes[3];
2308 /* TYPES[i] is the set of possible builtin-operator parameter types
2309 we will consider for the Ith argument. These are represented as
2310 a TREE_LIST; the TREE_VALUE of each node is the potential
2314 for (i = 0; i < 3; ++i)
2317 argtypes[i] = unlowered_expr_type (args[i]);
2319 argtypes[i] = NULL_TREE;
2324 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2325 and VQ is either volatile or empty, there exist candidate operator
2326 functions of the form
2327 VQ T& operator++(VQ T&); */
2329 case POSTINCREMENT_EXPR:
2330 case PREINCREMENT_EXPR:
2331 case POSTDECREMENT_EXPR:
2332 case PREDECREMENT_EXPR:
2337 /* 24There also exist candidate operator functions of the form
2338 bool operator!(bool);
2339 bool operator&&(bool, bool);
2340 bool operator||(bool, bool); */
2342 case TRUTH_NOT_EXPR:
2343 build_builtin_candidate
2344 (candidates, fnname, boolean_type_node,
2345 NULL_TREE, args, argtypes, flags);
2348 case TRUTH_ORIF_EXPR:
2349 case TRUTH_ANDIF_EXPR:
2350 build_builtin_candidate
2351 (candidates, fnname, boolean_type_node,
2352 boolean_type_node, args, argtypes, flags);
2374 types[0] = types[1] = NULL_TREE;
2376 for (i = 0; i < 2; ++i)
2380 else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2384 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2387 convs = lookup_conversions (argtypes[i],
2388 /*lookup_template_convs_p=*/false);
2390 if (code == COND_EXPR)
2392 if (real_lvalue_p (args[i]))
2393 types[i] = tree_cons
2394 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2396 types[i] = tree_cons
2397 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2403 for (; convs; convs = TREE_CHAIN (convs))
2405 type = TREE_TYPE (convs);
2408 && (TREE_CODE (type) != REFERENCE_TYPE
2409 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2412 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2413 types[i] = tree_cons (NULL_TREE, type, types[i]);
2415 type = non_reference (type);
2416 if (i != 0 || ! ref1)
2418 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2419 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2420 types[i] = tree_cons (NULL_TREE, type, types[i]);
2421 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2422 type = type_promotes_to (type);
2425 if (! value_member (type, types[i]))
2426 types[i] = tree_cons (NULL_TREE, type, types[i]);
2431 if (code == COND_EXPR && real_lvalue_p (args[i]))
2432 types[i] = tree_cons
2433 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2434 type = non_reference (argtypes[i]);
2435 if (i != 0 || ! ref1)
2437 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2438 if (enum_p && UNSCOPED_ENUM_P (type))
2439 types[i] = tree_cons (NULL_TREE, type, types[i]);
2440 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2441 type = type_promotes_to (type);
2443 types[i] = tree_cons (NULL_TREE, type, types[i]);
2447 /* Run through the possible parameter types of both arguments,
2448 creating candidates with those parameter types. */
2449 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2452 for (type = types[1]; type; type = TREE_CHAIN (type))
2453 add_builtin_candidate
2454 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2455 TREE_VALUE (type), args, argtypes, flags);
2457 add_builtin_candidate
2458 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2459 NULL_TREE, args, argtypes, flags);
2464 /* If TMPL can be successfully instantiated as indicated by
2465 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2467 TMPL is the template. EXPLICIT_TARGS are any explicit template
2468 arguments. ARGLIST is the arguments provided at the call-site.
2469 This does not change ARGLIST. The RETURN_TYPE is the desired type
2470 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2471 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2472 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2474 static struct z_candidate*
2475 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2476 tree ctype, tree explicit_targs, tree first_arg,
2477 const VEC(tree,gc) *arglist, tree return_type,
2478 tree access_path, tree conversion_path,
2479 int flags, tree obj, unification_kind_t strict)
2481 int ntparms = DECL_NTPARMS (tmpl);
2482 tree targs = make_tree_vec (ntparms);
2483 unsigned int len = VEC_length (tree, arglist);
2484 unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2485 unsigned int skip_without_in_chrg = 0;
2486 tree first_arg_without_in_chrg = first_arg;
2487 tree *args_without_in_chrg;
2488 unsigned int nargs_without_in_chrg;
2489 unsigned int ia, ix;
2491 struct z_candidate *cand;
2495 /* We don't do deduction on the in-charge parameter, the VTT
2496 parameter or 'this'. */
2497 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2499 if (first_arg_without_in_chrg != NULL_TREE)
2500 first_arg_without_in_chrg = NULL_TREE;
2502 ++skip_without_in_chrg;
2505 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2506 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2507 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2509 if (first_arg_without_in_chrg != NULL_TREE)
2510 first_arg_without_in_chrg = NULL_TREE;
2512 ++skip_without_in_chrg;
2515 if (len < skip_without_in_chrg)
2518 nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2519 + (len - skip_without_in_chrg));
2520 args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2522 if (first_arg_without_in_chrg != NULL_TREE)
2524 args_without_in_chrg[ia] = first_arg_without_in_chrg;
2527 for (ix = skip_without_in_chrg;
2528 VEC_iterate (tree, arglist, ix, arg);
2531 args_without_in_chrg[ia] = arg;
2534 gcc_assert (ia == nargs_without_in_chrg);
2536 i = fn_type_unification (tmpl, explicit_targs, targs,
2537 args_without_in_chrg,
2538 nargs_without_in_chrg,
2539 return_type, strict, flags);
2544 fn = instantiate_template (tmpl, targs, tf_none);
2545 if (fn == error_mark_node)
2550 A member function template is never instantiated to perform the
2551 copy of a class object to an object of its class type.
2553 It's a little unclear what this means; the standard explicitly
2554 does allow a template to be used to copy a class. For example,
2559 template <class T> A(const T&);
2562 void g () { A a (f ()); }
2564 the member template will be used to make the copy. The section
2565 quoted above appears in the paragraph that forbids constructors
2566 whose only parameter is (a possibly cv-qualified variant of) the
2567 class type, and a logical interpretation is that the intent was
2568 to forbid the instantiation of member templates which would then
2570 if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2572 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2573 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2578 if (obj != NULL_TREE)
2579 /* Aha, this is a conversion function. */
2580 cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2581 access_path, conversion_path);
2583 cand = add_function_candidate (candidates, fn, ctype,
2584 first_arg, arglist, access_path,
2585 conversion_path, flags);
2586 if (DECL_TI_TEMPLATE (fn) != tmpl)
2587 /* This situation can occur if a member template of a template
2588 class is specialized. Then, instantiate_template might return
2589 an instantiation of the specialization, in which case the
2590 DECL_TI_TEMPLATE field will point at the original
2591 specialization. For example:
2593 template <class T> struct S { template <class U> void f(U);
2594 template <> void f(int) {}; };
2598 Here, TMPL will be template <class U> S<double>::f(U).
2599 And, instantiate template will give us the specialization
2600 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2601 for this will point at template <class T> template <> S<T>::f(int),
2602 so that we can find the definition. For the purposes of
2603 overload resolution, however, we want the original TMPL. */
2604 cand->template_decl = build_template_info (tmpl, targs);
2606 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2607 cand->explicit_targs = explicit_targs;
2611 return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2612 access_path, conversion_path, 0);
2616 static struct z_candidate *
2617 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2618 tree explicit_targs, tree first_arg,
2619 const VEC(tree,gc) *arglist, tree return_type,
2620 tree access_path, tree conversion_path, int flags,
2621 unification_kind_t strict)
2624 add_template_candidate_real (candidates, tmpl, ctype,
2625 explicit_targs, first_arg, arglist,
2626 return_type, access_path, conversion_path,
2627 flags, NULL_TREE, strict);
2631 static struct z_candidate *
2632 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2633 tree obj, tree first_arg,
2634 const VEC(tree,gc) *arglist,
2635 tree return_type, tree access_path,
2636 tree conversion_path)
2639 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2640 first_arg, arglist, return_type, access_path,
2641 conversion_path, 0, obj, DEDUCE_CONV);
2644 /* The CANDS are the set of candidates that were considered for
2645 overload resolution. Return the set of viable candidates, or CANDS
2646 if none are viable. If any of the candidates were viable, set
2647 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
2648 considered viable only if it is strictly viable. */
2650 static struct z_candidate*
2651 splice_viable (struct z_candidate *cands,
2655 struct z_candidate *viable;
2656 struct z_candidate **last_viable;
2657 struct z_candidate **cand;
2660 last_viable = &viable;
2661 *any_viable_p = false;
2666 struct z_candidate *c = *cand;
2667 if (strict_p ? c->viable == 1 : c->viable)
2672 last_viable = &c->next;
2673 *any_viable_p = true;
2679 return viable ? viable : cands;
2683 any_strictly_viable (struct z_candidate *cands)
2685 for (; cands; cands = cands->next)
2686 if (cands->viable == 1)
2691 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2692 words, it is about to become the "this" pointer for a member
2693 function call. Take the address of the object. */
2696 build_this (tree obj)
2698 /* In a template, we are only concerned about the type of the
2699 expression, so we can take a shortcut. */
2700 if (processing_template_decl)
2701 return build_address (obj);
2703 return cp_build_unary_op (ADDR_EXPR, obj, 0, tf_warning_or_error);
2706 /* Returns true iff functions are equivalent. Equivalent functions are
2707 not '==' only if one is a function-local extern function or if
2708 both are extern "C". */
2711 equal_functions (tree fn1, tree fn2)
2713 if (TREE_CODE (fn1) != TREE_CODE (fn2))
2715 if (TREE_CODE (fn1) == TEMPLATE_DECL)
2717 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2718 || DECL_EXTERN_C_FUNCTION_P (fn1))
2719 return decls_match (fn1, fn2);
2723 /* Print information about one overload candidate CANDIDATE. MSGSTR
2724 is the text to print before the candidate itself.
2726 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2727 to have been run through gettext by the caller. This wart makes
2728 life simpler in print_z_candidates and for the translators. */
2731 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2733 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2735 if (candidate->num_convs == 3)
2736 inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2737 candidate->convs[0]->type,
2738 candidate->convs[1]->type,
2739 candidate->convs[2]->type);
2740 else if (candidate->num_convs == 2)
2741 inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2742 candidate->convs[0]->type,
2743 candidate->convs[1]->type);
2745 inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2746 candidate->convs[0]->type);
2748 else if (TYPE_P (candidate->fn))
2749 inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2750 else if (candidate->viable == -1)
2751 inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2752 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
2753 inform (input_location, "%s %+#D <deleted>", msgstr, candidate->fn);
2755 inform (input_location, "%s %+#D", msgstr, candidate->fn);
2759 print_z_candidates (struct z_candidate *candidates)
2762 struct z_candidate *cand1;
2763 struct z_candidate **cand2;
2769 /* Remove non-viable deleted candidates. */
2771 for (cand2 = &cand1; *cand2; )
2773 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2774 && !(*cand2)->viable
2775 && DECL_DELETED_FN ((*cand2)->fn))
2776 *cand2 = (*cand2)->next;
2778 cand2 = &(*cand2)->next;
2780 /* ...if there are any non-deleted ones. */
2784 /* There may be duplicates in the set of candidates. We put off
2785 checking this condition as long as possible, since we have no way
2786 to eliminate duplicates from a set of functions in less than n^2
2787 time. Now we are about to emit an error message, so it is more
2788 permissible to go slowly. */
2789 for (cand1 = candidates; cand1; cand1 = cand1->next)
2791 tree fn = cand1->fn;
2792 /* Skip builtin candidates and conversion functions. */
2795 cand2 = &cand1->next;
2798 if (DECL_P ((*cand2)->fn)
2799 && equal_functions (fn, (*cand2)->fn))
2800 *cand2 = (*cand2)->next;
2802 cand2 = &(*cand2)->next;
2806 str = candidates->next ? _("candidates are:") : _("candidate is:");
2808 for (; candidates; candidates = candidates->next)
2810 print_z_candidate (spaces ? spaces : str, candidates);
2811 spaces = spaces ? spaces : get_spaces (str);
2816 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2817 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2818 the result of the conversion function to convert it to the final
2819 desired type. Merge the two sequences into a single sequence,
2820 and return the merged sequence. */
2823 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2827 gcc_assert (user_seq->kind == ck_user);
2829 /* Find the end of the second conversion sequence. */
2831 while ((*t)->kind != ck_identity)
2832 t = &((*t)->u.next);
2834 /* Replace the identity conversion with the user conversion
2838 /* The entire sequence is a user-conversion sequence. */
2839 std_seq->user_conv_p = true;
2844 /* Handle overload resolution for initializing an object of class type from
2845 an initializer list. First we look for a suitable constructor that
2846 takes a std::initializer_list; if we don't find one, we then look for a
2847 non-list constructor.
2849 Parameters are as for add_candidates, except that the arguments are in
2850 the form of a CONSTRUCTOR (the initializer list) rather than a VEC, and
2851 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
2854 add_list_candidates (tree fns, tree first_arg,
2855 tree init_list, tree totype,
2856 tree explicit_targs, bool template_only,
2857 tree conversion_path, tree access_path,
2859 struct z_candidate **candidates)
2863 gcc_assert (*candidates == NULL);
2865 /* For list-initialization we consider explicit constructors, but
2866 give an error if one is selected. */
2867 flags &= ~LOOKUP_ONLYCONVERTING;
2868 /* And we don't allow narrowing conversions. We also use this flag to
2869 avoid the copy constructor call for copy-list-initialization. */
2870 flags |= LOOKUP_NO_NARROWING;
2872 /* Always use the default constructor if the list is empty (DR 990). */
2873 if (CONSTRUCTOR_NELTS (init_list) == 0
2874 && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
2876 /* If the class has a list ctor, try passing the list as a single
2877 argument first, but only consider list ctors. */
2878 else if (TYPE_HAS_LIST_CTOR (totype))
2880 flags |= LOOKUP_LIST_ONLY;
2881 args = make_tree_vector_single (init_list);
2882 add_candidates (fns, first_arg, args, NULL_TREE,
2883 explicit_targs, template_only, conversion_path,
2884 access_path, flags, candidates);
2885 if (any_strictly_viable (*candidates))
2889 args = ctor_to_vec (init_list);
2891 /* We aren't looking for list-ctors anymore. */
2892 flags &= ~LOOKUP_LIST_ONLY;
2893 /* We allow more user-defined conversions within an init-list. */
2894 flags &= ~LOOKUP_NO_CONVERSION;
2895 /* But not for the copy ctor. */
2896 flags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
2898 add_candidates (fns, first_arg, args, NULL_TREE,
2899 explicit_targs, template_only, conversion_path,
2900 access_path, flags, candidates);
2903 /* Returns the best overload candidate to perform the requested
2904 conversion. This function is used for three the overloading situations
2905 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2906 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2907 per [dcl.init.ref], so we ignore temporary bindings. */
2909 static struct z_candidate *
2910 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2912 struct z_candidate *candidates, *cand;
2913 tree fromtype = TREE_TYPE (expr);
2914 tree ctors = NULL_TREE;
2915 tree conv_fns = NULL_TREE;
2916 conversion *conv = NULL;
2917 tree first_arg = NULL_TREE;
2918 VEC(tree,gc) *args = NULL;
2922 /* We represent conversion within a hierarchy using RVALUE_CONV and
2923 BASE_CONV, as specified by [over.best.ics]; these become plain
2924 constructor calls, as specified in [dcl.init]. */
2925 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
2926 || !DERIVED_FROM_P (totype, fromtype));
2928 if (MAYBE_CLASS_TYPE_P (totype))
2929 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2931 if (MAYBE_CLASS_TYPE_P (fromtype))
2933 tree to_nonref = non_reference (totype);
2934 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
2935 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
2936 && DERIVED_FROM_P (to_nonref, fromtype)))
2938 /* [class.conv.fct] A conversion function is never used to
2939 convert a (possibly cv-qualified) object to the (possibly
2940 cv-qualified) same object type (or a reference to it), to a
2941 (possibly cv-qualified) base class of that type (or a
2942 reference to it)... */
2945 conv_fns = lookup_conversions (fromtype,
2946 /*lookup_template_convs_p=*/true);
2950 flags |= LOOKUP_NO_CONVERSION;
2951 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2952 flags |= LOOKUP_NO_NARROWING;
2954 /* It's OK to bind a temporary for converting constructor arguments, but
2955 not in converting the return value of a conversion operator. */
2956 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
2957 flags &= ~LOOKUP_NO_TEMP_BIND;
2961 int ctorflags = flags;
2962 ctors = BASELINK_FUNCTIONS (ctors);
2964 first_arg = build_int_cst (build_pointer_type (totype), 0);
2966 /* We should never try to call the abstract or base constructor
2968 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2969 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2971 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2973 /* List-initialization. */
2974 add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
2975 false, TYPE_BINFO (totype), TYPE_BINFO (totype),
2976 ctorflags, &candidates);
2980 args = make_tree_vector_single (expr);
2981 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
2982 TYPE_BINFO (totype), TYPE_BINFO (totype),
2983 ctorflags, &candidates);
2986 for (cand = candidates; cand; cand = cand->next)
2988 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2990 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
2991 set, then this is copy-initialization. In that case, "The
2992 result of the call is then used to direct-initialize the
2993 object that is the destination of the copy-initialization."
2996 We represent this in the conversion sequence with an
2997 rvalue conversion, which means a constructor call. */
2998 if (TREE_CODE (totype) != REFERENCE_TYPE
2999 && !(convflags & LOOKUP_NO_TEMP_BIND))
3001 = build_conv (ck_rvalue, totype, cand->second_conv);
3006 first_arg = build_this (expr);
3008 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3010 tree conversion_path = TREE_PURPOSE (conv_fns);
3011 struct z_candidate *old_candidates;
3013 /* If we are called to convert to a reference type, we are trying to
3014 find an lvalue binding, so don't even consider temporaries. If
3015 we don't find an lvalue binding, the caller will try again to
3016 look for a temporary binding. */
3017 if (TREE_CODE (totype) == REFERENCE_TYPE)
3018 convflags |= LOOKUP_NO_TEMP_BIND;
3020 old_candidates = candidates;
3021 add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3023 conversion_path, TYPE_BINFO (fromtype),
3024 flags, &candidates);
3026 for (cand = candidates; cand != old_candidates; cand = cand->next)
3029 = implicit_conversion (totype,
3030 TREE_TYPE (TREE_TYPE (cand->fn)),
3032 /*c_cast_p=*/false, convflags);
3034 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3035 copy-initialization. In that case, "The result of the
3036 call is then used to direct-initialize the object that is
3037 the destination of the copy-initialization." [dcl.init]
3039 We represent this in the conversion sequence with an
3040 rvalue conversion, which means a constructor call. But
3041 don't add a second rvalue conversion if there's already
3042 one there. Which there really shouldn't be, but it's
3043 harmless since we'd add it here anyway. */
3044 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3045 && !(convflags & LOOKUP_NO_TEMP_BIND))
3046 ics = build_conv (ck_rvalue, totype, ics);
3048 cand->second_conv = ics;
3052 else if (cand->viable == 1 && ics->bad_p)
3057 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3061 cand = tourney (candidates);
3064 if (flags & LOOKUP_COMPLAIN)
3066 error ("conversion from %qT to %qT is ambiguous",
3068 print_z_candidates (candidates);
3071 cand = candidates; /* any one will do */
3072 cand->second_conv = build_ambiguous_conv (totype, expr);
3073 cand->second_conv->user_conv_p = true;
3074 if (!any_strictly_viable (candidates))
3075 cand->second_conv->bad_p = true;
3076 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3077 ambiguous conversion is no worse than another user-defined
3083 /* Build the user conversion sequence. */
3086 (DECL_CONSTRUCTOR_P (cand->fn)
3087 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3088 build_identity_conv (TREE_TYPE (expr), expr));
3091 /* Remember that this was a list-initialization. */
3092 if (flags & LOOKUP_NO_NARROWING)
3093 conv->check_narrowing = true;
3095 /* Combine it with the second conversion sequence. */
3096 cand->second_conv = merge_conversion_sequences (conv,
3099 if (cand->viable == -1)
3100 cand->second_conv->bad_p = true;
3106 build_user_type_conversion (tree totype, tree expr, int flags)
3108 struct z_candidate *cand
3109 = build_user_type_conversion_1 (totype, expr, flags);
3113 if (cand->second_conv->kind == ck_ambig)
3114 return error_mark_node;
3115 expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3116 return convert_from_reference (expr);
3121 /* Do any initial processing on the arguments to a function call. */
3123 static VEC(tree,gc) *
3124 resolve_args (VEC(tree,gc) *args)
3129 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
3131 if (error_operand_p (arg))
3133 else if (VOID_TYPE_P (TREE_TYPE (arg)))
3135 error ("invalid use of void expression");
3138 else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3144 /* Perform overload resolution on FN, which is called with the ARGS.
3146 Return the candidate function selected by overload resolution, or
3147 NULL if the event that overload resolution failed. In the case
3148 that overload resolution fails, *CANDIDATES will be the set of
3149 candidates considered, and ANY_VIABLE_P will be set to true or
3150 false to indicate whether or not any of the candidates were
3153 The ARGS should already have gone through RESOLVE_ARGS before this
3154 function is called. */
3156 static struct z_candidate *
3157 perform_overload_resolution (tree fn,
3158 const VEC(tree,gc) *args,
3159 struct z_candidate **candidates,
3162 struct z_candidate *cand;
3163 tree explicit_targs = NULL_TREE;
3164 int template_only = 0;
3167 *any_viable_p = true;
3170 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3171 || TREE_CODE (fn) == TEMPLATE_DECL
3172 || TREE_CODE (fn) == OVERLOAD
3173 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3175 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3177 explicit_targs = TREE_OPERAND (fn, 1);
3178 fn = TREE_OPERAND (fn, 0);
3182 /* Add the various candidate functions. */
3183 add_candidates (fn, NULL_TREE, args, NULL_TREE,
3184 explicit_targs, template_only,
3185 /*conversion_path=*/NULL_TREE,
3186 /*access_path=*/NULL_TREE,
3190 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3194 cand = tourney (*candidates);
3198 /* Return an expression for a call to FN (a namespace-scope function,
3199 or a static member function) with the ARGS. This may change
3203 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3204 tsubst_flags_t complain)
3206 struct z_candidate *candidates, *cand;
3211 if (args != NULL && *args != NULL)
3213 *args = resolve_args (*args);
3215 return error_mark_node;
3218 /* If this function was found without using argument dependent
3219 lookup, then we want to ignore any undeclared friend
3225 fn = remove_hidden_names (fn);
3228 if (complain & tf_error)
3229 error ("no matching function for call to %<%D(%A)%>",
3230 DECL_NAME (OVL_CURRENT (orig_fn)),
3231 build_tree_list_vec (*args));
3232 return error_mark_node;
3236 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3237 p = conversion_obstack_alloc (0);
3239 cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3243 if (complain & tf_error)
3245 if (!any_viable_p && candidates && ! candidates->next
3246 && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3247 return cp_build_function_call_vec (candidates->fn, args, complain);
3248 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3249 fn = TREE_OPERAND (fn, 0);
3251 error ("no matching function for call to %<%D(%A)%>",
3252 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3254 error ("call of overloaded %<%D(%A)%> is ambiguous",
3255 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3257 print_z_candidates (candidates);
3259 result = error_mark_node;
3262 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3264 /* Free all the conversions we allocated. */
3265 obstack_free (&conversion_obstack, p);
3270 /* Build a call to a global operator new. FNNAME is the name of the
3271 operator (either "operator new" or "operator new[]") and ARGS are
3272 the arguments provided. This may change ARGS. *SIZE points to the
3273 total number of bytes required by the allocation, and is updated if
3274 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3275 be used. If this function determines that no cookie should be
3276 used, after all, *COOKIE_SIZE is set to NULL_TREE. If FN is
3277 non-NULL, it will be set, upon return, to the allocation function
3281 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3282 tree *size, tree *cookie_size,
3286 struct z_candidate *candidates;
3287 struct z_candidate *cand;
3292 VEC_safe_insert (tree, gc, *args, 0, *size);
3293 *args = resolve_args (*args);
3295 return error_mark_node;
3301 If this lookup fails to find the name, or if the allocated type
3302 is not a class type, the allocation function's name is looked
3303 up in the global scope.
3305 we disregard block-scope declarations of "operator new". */
3306 fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3308 /* Figure out what function is being called. */
3309 cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3311 /* If no suitable function could be found, issue an error message
3316 error ("no matching function for call to %<%D(%A)%>",
3317 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3319 error ("call of overloaded %<%D(%A)%> is ambiguous",
3320 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3322 print_z_candidates (candidates);
3323 return error_mark_node;
3326 /* If a cookie is required, add some extra space. Whether
3327 or not a cookie is required cannot be determined until
3328 after we know which function was called. */
3331 bool use_cookie = true;
3332 if (!abi_version_at_least (2))
3334 /* In G++ 3.2, the check was implemented incorrectly; it
3335 looked at the placement expression, rather than the
3336 type of the function. */
3337 if (VEC_length (tree, *args) == 2
3338 && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3346 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3347 /* Skip the size_t parameter. */
3348 arg_types = TREE_CHAIN (arg_types);
3349 /* Check the remaining parameters (if any). */
3351 && TREE_CHAIN (arg_types) == void_list_node
3352 && same_type_p (TREE_VALUE (arg_types),
3356 /* If we need a cookie, adjust the number of bytes allocated. */
3359 /* Update the total size. */
3360 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3361 /* Update the argument list to reflect the adjusted size. */
3362 VEC_replace (tree, *args, 0, *size);
3365 *cookie_size = NULL_TREE;
3368 /* Tell our caller which function we decided to call. */
3372 /* Build the CALL_EXPR. */
3373 return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3376 /* Build a new call to operator(). This may change ARGS. */
3379 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3381 struct z_candidate *candidates = 0, *cand;
3382 tree fns, convs, first_mem_arg = NULL_TREE;
3383 tree type = TREE_TYPE (obj);
3385 tree result = NULL_TREE;
3388 if (error_operand_p (obj))
3389 return error_mark_node;
3391 obj = prep_operand (obj);
3393 if (TYPE_PTRMEMFUNC_P (type))
3395 if (complain & tf_error)
3396 /* It's no good looking for an overloaded operator() on a
3397 pointer-to-member-function. */
3398 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3399 return error_mark_node;
3402 if (TYPE_BINFO (type))
3404 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3405 if (fns == error_mark_node)
3406 return error_mark_node;
3411 if (args != NULL && *args != NULL)
3413 *args = resolve_args (*args);
3415 return error_mark_node;
3418 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3419 p = conversion_obstack_alloc (0);
3423 first_mem_arg = build_this (obj);
3425 add_candidates (BASELINK_FUNCTIONS (fns),
3426 first_mem_arg, *args, NULL_TREE,
3428 BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
3429 LOOKUP_NORMAL, &candidates);
3432 convs = lookup_conversions (type, /*lookup_template_convs_p=*/true);
3434 for (; convs; convs = TREE_CHAIN (convs))
3436 tree fns = TREE_VALUE (convs);
3437 tree totype = TREE_TYPE (convs);
3439 if ((TREE_CODE (totype) == POINTER_TYPE
3440 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3441 || (TREE_CODE (totype) == REFERENCE_TYPE
3442 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3443 || (TREE_CODE (totype) == REFERENCE_TYPE
3444 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3445 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3446 for (; fns; fns = OVL_NEXT (fns))
3448 tree fn = OVL_CURRENT (fns);
3450 if (DECL_NONCONVERTING_P (fn))
3453 if (TREE_CODE (fn) == TEMPLATE_DECL)
3454 add_template_conv_candidate
3455 (&candidates, fn, obj, NULL_TREE, *args, totype,
3456 /*access_path=*/NULL_TREE,
3457 /*conversion_path=*/NULL_TREE);
3459 add_conv_candidate (&candidates, fn, obj, NULL_TREE,
3460 *args, /*conversion_path=*/NULL_TREE,
3461 /*access_path=*/NULL_TREE);
3465 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3468 if (complain & tf_error)
3470 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
3471 build_tree_list_vec (*args));
3472 print_z_candidates (candidates);
3474 result = error_mark_node;
3478 cand = tourney (candidates);
3481 if (complain & tf_error)
3483 error ("call of %<(%T) (%A)%> is ambiguous",
3484 TREE_TYPE (obj), build_tree_list_vec (*args));
3485 print_z_candidates (candidates);
3487 result = error_mark_node;
3489 /* Since cand->fn will be a type, not a function, for a conversion
3490 function, we must be careful not to unconditionally look at
3492 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3493 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3494 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3497 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
3499 obj = convert_from_reference (obj);
3500 result = cp_build_function_call_vec (obj, args, complain);
3504 /* Free all the conversions we allocated. */
3505 obstack_free (&conversion_obstack, p);
3511 op_error (enum tree_code code, enum tree_code code2,
3512 tree arg1, tree arg2, tree arg3, bool match)
3516 if (code == MODIFY_EXPR)
3517 opname = assignment_operator_name_info[code2].name;
3519 opname = operator_name_info[code].name;
3525 error ("ambiguous overload for ternary %<operator?:%> "
3526 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3528 error ("no match for ternary %<operator?:%> "
3529 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3532 case POSTINCREMENT_EXPR:
3533 case POSTDECREMENT_EXPR:
3535 error ("ambiguous overload for %<operator%s%> in %<%E%s%>",
3536 opname, arg1, opname);
3538 error ("no match for %<operator%s%> in %<%E%s%>",
3539 opname, arg1, opname);
3544 error ("ambiguous overload for %<operator[]%> in %<%E[%E]%>",
3547 error ("no match for %<operator[]%> in %<%E[%E]%>",
3554 error ("ambiguous overload for %qs in %<%s %E%>",
3555 opname, opname, arg1);
3557 error ("no match for %qs in %<%s %E%>",
3558 opname, opname, arg1);
3564 error ("ambiguous overload for %<operator%s%> in %<%E %s %E%>",
3565 opname, arg1, opname, arg2);
3567 error ("no match for %<operator%s%> in %<%E %s %E%>",
3568 opname, arg1, opname, arg2);
3571 error ("ambiguous overload for %<operator%s%> in %<%s%E%>",
3572 opname, opname, arg1);
3574 error ("no match for %<operator%s%> in %<%s%E%>",
3575 opname, opname, arg1);
3580 /* Return the implicit conversion sequence that could be used to
3581 convert E1 to E2 in [expr.cond]. */
3584 conditional_conversion (tree e1, tree e2)
3586 tree t1 = non_reference (TREE_TYPE (e1));
3587 tree t2 = non_reference (TREE_TYPE (e2));
3593 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3594 implicitly converted (clause _conv_) to the type "reference to
3595 T2", subject to the constraint that in the conversion the
3596 reference must bind directly (_dcl.init.ref_) to E1. */
3597 if (real_lvalue_p (e2))
3599 conv = implicit_conversion (build_reference_type (t2),
3603 LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING);
3610 If E1 and E2 have class type, and the underlying class types are
3611 the same or one is a base class of the other: E1 can be converted
3612 to match E2 if the class of T2 is the same type as, or a base
3613 class of, the class of T1, and the cv-qualification of T2 is the
3614 same cv-qualification as, or a greater cv-qualification than, the
3615 cv-qualification of T1. If the conversion is applied, E1 is
3616 changed to an rvalue of type T2 that still refers to the original
3617 source class object (or the appropriate subobject thereof). */
3618 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3619 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3621 if (good_base && at_least_as_qualified_p (t2, t1))
3623 conv = build_identity_conv (t1, e1);
3624 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3625 TYPE_MAIN_VARIANT (t2)))
3626 conv = build_conv (ck_base, t2, conv);
3628 conv = build_conv (ck_rvalue, t2, conv);
3637 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3638 converted to the type that expression E2 would have if E2 were
3639 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3640 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3644 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3645 arguments to the conditional expression. */
3648 build_conditional_expr (tree arg1, tree arg2, tree arg3,
3649 tsubst_flags_t complain)
3653 tree result = NULL_TREE;
3654 tree result_type = NULL_TREE;
3655 bool lvalue_p = true;
3656 struct z_candidate *candidates = 0;
3657 struct z_candidate *cand;
3660 /* As a G++ extension, the second argument to the conditional can be
3661 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3662 c'.) If the second operand is omitted, make sure it is
3663 calculated only once. */
3666 if (complain & tf_error)
3667 pedwarn (input_location, OPT_pedantic,
3668 "ISO C++ forbids omitting the middle term of a ?: expression");
3670 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3671 if (real_lvalue_p (arg1))
3672 arg2 = arg1 = stabilize_reference (arg1);
3674 arg2 = arg1 = save_expr (arg1);
3679 The first expression is implicitly converted to bool (clause
3681 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
3684 /* If something has already gone wrong, just pass that fact up the
3686 if (error_operand_p (arg1)
3687 || error_operand_p (arg2)
3688 || error_operand_p (arg3))
3689 return error_mark_node;
3693 If either the second or the third operand has type (possibly
3694 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3695 array-to-pointer (_conv.array_), and function-to-pointer
3696 (_conv.func_) standard conversions are performed on the second
3697 and third operands. */
3698 arg2_type = unlowered_expr_type (arg2);
3699 arg3_type = unlowered_expr_type (arg3);
3700 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3702 /* Do the conversions. We don't these for `void' type arguments
3703 since it can't have any effect and since decay_conversion
3704 does not handle that case gracefully. */
3705 if (!VOID_TYPE_P (arg2_type))
3706 arg2 = decay_conversion (arg2);
3707 if (!VOID_TYPE_P (arg3_type))
3708 arg3 = decay_conversion (arg3);
3709 arg2_type = TREE_TYPE (arg2);
3710 arg3_type = TREE_TYPE (arg3);
3714 One of the following shall hold:
3716 --The second or the third operand (but not both) is a
3717 throw-expression (_except.throw_); the result is of the
3718 type of the other and is an rvalue.
3720 --Both the second and the third operands have type void; the
3721 result is of type void and is an rvalue.
3723 We must avoid calling force_rvalue for expressions of type
3724 "void" because it will complain that their value is being
3726 if (TREE_CODE (arg2) == THROW_EXPR
3727 && TREE_CODE (arg3) != THROW_EXPR)
3729 if (!VOID_TYPE_P (arg3_type))
3730 arg3 = force_rvalue (arg3);
3731 arg3_type = TREE_TYPE (arg3);
3732 result_type = arg3_type;
3734 else if (TREE_CODE (arg2) != THROW_EXPR
3735 && TREE_CODE (arg3) == THROW_EXPR)
3737 if (!VOID_TYPE_P (arg2_type))
3738 arg2 = force_rvalue (arg2);
3739 arg2_type = TREE_TYPE (arg2);
3740 result_type = arg2_type;
3742 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3743 result_type = void_type_node;
3746 if (complain & tf_error)
3748 if (VOID_TYPE_P (arg2_type))
3749 error ("second operand to the conditional operator "
3750 "is of type %<void%>, "
3751 "but the third operand is neither a throw-expression "
3752 "nor of type %<void%>");
3754 error ("third operand to the conditional operator "
3755 "is of type %<void%>, "
3756 "but the second operand is neither a throw-expression "
3757 "nor of type %<void%>");
3759 return error_mark_node;
3763 goto valid_operands;
3767 Otherwise, if the second and third operand have different types,
3768 and either has (possibly cv-qualified) class type, an attempt is
3769 made to convert each of those operands to the type of the other. */
3770 else if (!same_type_p (arg2_type, arg3_type)
3771 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3776 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3777 p = conversion_obstack_alloc (0);
3779 conv2 = conditional_conversion (arg2, arg3);
3780 conv3 = conditional_conversion (arg3, arg2);
3784 If both can be converted, or one can be converted but the
3785 conversion is ambiguous, the program is ill-formed. If
3786 neither can be converted, the operands are left unchanged and
3787 further checking is performed as described below. If exactly
3788 one conversion is possible, that conversion is applied to the
3789 chosen operand and the converted operand is used in place of
3790 the original operand for the remainder of this section. */
3791 if ((conv2 && !conv2->bad_p
3792 && conv3 && !conv3->bad_p)
3793 || (conv2 && conv2->kind == ck_ambig)
3794 || (conv3 && conv3->kind == ck_ambig))
3796 error ("operands to ?: have different types %qT and %qT",
3797 arg2_type, arg3_type);
3798 result = error_mark_node;
3800 else if (conv2 && (!conv2->bad_p || !conv3))
3802 arg2 = convert_like (conv2, arg2, complain);
3803 arg2 = convert_from_reference (arg2);
3804 arg2_type = TREE_TYPE (arg2);
3805 /* Even if CONV2 is a valid conversion, the result of the
3806 conversion may be invalid. For example, if ARG3 has type
3807 "volatile X", and X does not have a copy constructor
3808 accepting a "volatile X&", then even if ARG2 can be
3809 converted to X, the conversion will fail. */
3810 if (error_operand_p (arg2))
3811 result = error_mark_node;
3813 else if (conv3 && (!conv3->bad_p || !conv2))
3815 arg3 = convert_like (conv3, arg3, complain);
3816 arg3 = convert_from_reference (arg3);
3817 arg3_type = TREE_TYPE (arg3);
3818 if (error_operand_p (arg3))
3819 result = error_mark_node;
3822 /* Free all the conversions we allocated. */
3823 obstack_free (&conversion_obstack, p);
3828 /* If, after the conversion, both operands have class type,
3829 treat the cv-qualification of both operands as if it were the
3830 union of the cv-qualification of the operands.
3832 The standard is not clear about what to do in this
3833 circumstance. For example, if the first operand has type
3834 "const X" and the second operand has a user-defined
3835 conversion to "volatile X", what is the type of the second
3836 operand after this step? Making it be "const X" (matching
3837 the first operand) seems wrong, as that discards the
3838 qualification without actually performing a copy. Leaving it
3839 as "volatile X" seems wrong as that will result in the
3840 conditional expression failing altogether, even though,
3841 according to this step, the one operand could be converted to
3842 the type of the other. */
3843 if ((conv2 || conv3)
3844 && CLASS_TYPE_P (arg2_type)
3845 && cp_type_quals (arg2_type) != cp_type_quals (arg3_type))
3846 arg2_type = arg3_type =
3847 cp_build_qualified_type (arg2_type,
3848 cp_type_quals (arg2_type)
3849 | cp_type_quals (arg3_type));
3854 If the second and third operands are lvalues and have the same
3855 type, the result is of that type and is an lvalue. */
3856 if (real_lvalue_p (arg2)
3857 && real_lvalue_p (arg3)
3858 && same_type_p (arg2_type, arg3_type))
3860 result_type = arg2_type;
3861 mark_lvalue_use (arg2);
3862 mark_lvalue_use (arg3);
3863 goto valid_operands;
3868 Otherwise, the result is an rvalue. If the second and third
3869 operand do not have the same type, and either has (possibly
3870 cv-qualified) class type, overload resolution is used to
3871 determine the conversions (if any) to be applied to the operands
3872 (_over.match.oper_, _over.built_). */
3874 if (!same_type_p (arg2_type, arg3_type)
3875 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3881 /* Rearrange the arguments so that add_builtin_candidate only has
3882 to know about two args. In build_builtin_candidate, the
3883 arguments are unscrambled. */
3887 add_builtin_candidates (&candidates,
3890 ansi_opname (COND_EXPR),
3896 If the overload resolution fails, the program is
3898 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3901 if (complain & tf_error)
3903 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3904 print_z_candidates (candidates);
3906 return error_mark_node;
3908 cand = tourney (candidates);
3911 if (complain & tf_error)
3913 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3914 print_z_candidates (candidates);
3916 return error_mark_node;
3921 Otherwise, the conversions thus determined are applied, and
3922 the converted operands are used in place of the original
3923 operands for the remainder of this section. */
3924 conv = cand->convs[0];
3925 arg1 = convert_like (conv, arg1, complain);
3926 conv = cand->convs[1];
3927 arg2 = convert_like (conv, arg2, complain);
3928 arg2_type = TREE_TYPE (arg2);
3929 conv = cand->convs[2];
3930 arg3 = convert_like (conv, arg3, complain);
3931 arg3_type = TREE_TYPE (arg3);
3936 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3937 and function-to-pointer (_conv.func_) standard conversions are
3938 performed on the second and third operands.
3940 We need to force the lvalue-to-rvalue conversion here for class types,
3941 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3942 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3945 arg2 = force_rvalue (arg2);
3946 if (!CLASS_TYPE_P (arg2_type))
3947 arg2_type = TREE_TYPE (arg2);
3949 arg3 = force_rvalue (arg3);
3950 if (!CLASS_TYPE_P (arg3_type))
3951 arg3_type = TREE_TYPE (arg3);
3953 if (arg2 == error_mark_node || arg3 == error_mark_node)
3954 return error_mark_node;
3958 After those conversions, one of the following shall hold:
3960 --The second and third operands have the same type; the result is of
3962 if (same_type_p (arg2_type, arg3_type))
3963 result_type = arg2_type;
3966 --The second and third operands have arithmetic or enumeration
3967 type; the usual arithmetic conversions are performed to bring
3968 them to a common type, and the result is of that type. */
3969 else if ((ARITHMETIC_TYPE_P (arg2_type)
3970 || UNSCOPED_ENUM_P (arg2_type))
3971 && (ARITHMETIC_TYPE_P (arg3_type)
3972 || UNSCOPED_ENUM_P (arg3_type)))
3974 /* In this case, there is always a common type. */
3975 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3978 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3979 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3981 if (complain & tf_warning)
3983 "enumeral mismatch in conditional expression: %qT vs %qT",
3984 arg2_type, arg3_type);
3986 else if (extra_warnings
3987 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3988 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3989 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3990 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3992 if (complain & tf_warning)
3994 "enumeral and non-enumeral type in conditional expression");
3997 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3998 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4002 --The second and third operands have pointer type, or one has
4003 pointer type and the other is a null pointer constant; pointer
4004 conversions (_conv.ptr_) and qualification conversions
4005 (_conv.qual_) are performed to bring them to their composite
4006 pointer type (_expr.rel_). The result is of the composite
4009 --The second and third operands have pointer to member type, or
4010 one has pointer to member type and the other is a null pointer
4011 constant; pointer to member conversions (_conv.mem_) and
4012 qualification conversions (_conv.qual_) are performed to bring
4013 them to a common type, whose cv-qualification shall match the
4014 cv-qualification of either the second or the third operand.
4015 The result is of the common type. */
4016 else if ((null_ptr_cst_p (arg2)
4017 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
4018 || (null_ptr_cst_p (arg3)
4019 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
4020 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
4021 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
4022 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
4024 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
4025 arg3, CPO_CONDITIONAL_EXPR,
4027 if (result_type == error_mark_node)
4028 return error_mark_node;
4029 arg2 = perform_implicit_conversion (result_type, arg2, complain);
4030 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4035 if (complain & tf_error)
4036 error ("operands to ?: have different types %qT and %qT",
4037 arg2_type, arg3_type);
4038 return error_mark_node;
4042 result = build3 (COND_EXPR, result_type, arg1, arg2, arg3);
4043 if (!cp_unevaluated_operand)
4044 /* Avoid folding within decltype (c++/42013) and noexcept. */
4045 result = fold_if_not_in_template (result);
4047 /* We can't use result_type below, as fold might have returned a
4052 /* Expand both sides into the same slot, hopefully the target of
4053 the ?: expression. We used to check for TARGET_EXPRs here,
4054 but now we sometimes wrap them in NOP_EXPRs so the test would
4056 if (CLASS_TYPE_P (TREE_TYPE (result)))
4057 result = get_target_expr (result);
4058 /* If this expression is an rvalue, but might be mistaken for an
4059 lvalue, we must add a NON_LVALUE_EXPR. */
4060 result = rvalue (result);
4066 /* OPERAND is an operand to an expression. Perform necessary steps
4067 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4071 prep_operand (tree operand)
4075 if (CLASS_TYPE_P (TREE_TYPE (operand))
4076 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
4077 /* Make sure the template type is instantiated now. */
4078 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
4084 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4085 OVERLOAD) to the CANDIDATES, returning an updated list of
4086 CANDIDATES. The ARGS are the arguments provided to the call;
4087 if FIRST_ARG is non-null it is the implicit object argument,
4088 otherwise the first element of ARGS is used if needed. The
4089 EXPLICIT_TARGS are explicit template arguments provided.
4090 TEMPLATE_ONLY is true if only template functions should be
4091 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4092 add_function_candidate. */
4095 add_candidates (tree fns, tree first_arg, const VEC(tree,gc) *args,
4097 tree explicit_targs, bool template_only,
4098 tree conversion_path, tree access_path,
4100 struct z_candidate **candidates)
4103 const VEC(tree,gc) *non_static_args;
4104 bool check_list_ctor;
4105 bool check_converting;
4106 unification_kind_t strict;
4112 /* Precalculate special handling of constructors and conversion ops. */
4113 fn = OVL_CURRENT (fns);
4114 if (DECL_CONV_FN_P (fn))
4116 check_list_ctor = false;
4117 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4118 if (flags & LOOKUP_NO_CONVERSION)
4119 /* We're doing return_type(x). */
4120 strict = DEDUCE_CONV;
4122 /* We're doing x.operator return_type(). */
4123 strict = DEDUCE_EXACT;
4124 /* [over.match.funcs] For conversion functions, the function
4125 is considered to be a member of the class of the implicit
4126 object argument for the purpose of defining the type of
4127 the implicit object parameter. */
4128 ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
4132 if (DECL_CONSTRUCTOR_P (fn))
4134 check_list_ctor = !!(flags & LOOKUP_LIST_ONLY);
4135 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4139 check_list_ctor = false;
4140 check_converting = false;
4142 strict = DEDUCE_CALL;
4143 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
4147 non_static_args = args;
4149 /* Delay creating the implicit this parameter until it is needed. */
4150 non_static_args = NULL;
4152 for (; fns; fns = OVL_NEXT (fns))
4155 const VEC(tree,gc) *fn_args;
4157 fn = OVL_CURRENT (fns);
4159 if (check_converting && DECL_NONCONVERTING_P (fn))
4161 if (check_list_ctor && !is_list_ctor (fn))
4164 /* Figure out which set of arguments to use. */
4165 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
4167 /* If this function is a non-static member and we didn't get an
4168 implicit object argument, move it out of args. */
4169 if (first_arg == NULL_TREE)
4173 VEC(tree,gc) *tempvec
4174 = VEC_alloc (tree, gc, VEC_length (tree, args) - 1);
4175 for (ix = 1; VEC_iterate (tree, args, ix, arg); ++ix)
4176 VEC_quick_push (tree, tempvec, arg);
4177 non_static_args = tempvec;
4178 first_arg = build_this (VEC_index (tree, args, 0));
4181 fn_first_arg = first_arg;
4182 fn_args = non_static_args;
4186 /* Otherwise, just use the list of arguments provided. */
4187 fn_first_arg = NULL_TREE;
4191 if (TREE_CODE (fn) == TEMPLATE_DECL)
4192 add_template_candidate (candidates,
4203 else if (!template_only)
4204 add_function_candidate (candidates,
4215 /* Even unsigned enum types promote to signed int. We don't want to
4216 issue -Wsign-compare warnings for this case. Here ORIG_ARG is the
4217 original argument and ARG is the argument after any conversions
4218 have been applied. We set TREE_NO_WARNING if we have added a cast
4219 from an unsigned enum type to a signed integer type. */
4222 avoid_sign_compare_warnings (tree orig_arg, tree arg)
4224 if (orig_arg != NULL_TREE
4227 && TREE_CODE (TREE_TYPE (orig_arg)) == ENUMERAL_TYPE
4228 && TYPE_UNSIGNED (TREE_TYPE (orig_arg))
4229 && INTEGRAL_TYPE_P (TREE_TYPE (arg))
4230 && !TYPE_UNSIGNED (TREE_TYPE (arg)))
4231 TREE_NO_WARNING (arg) = 1;
4235 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
4236 bool *overloaded_p, tsubst_flags_t complain)
4238 tree orig_arg1 = arg1;
4239 tree orig_arg2 = arg2;
4240 tree orig_arg3 = arg3;
4241 struct z_candidate *candidates = 0, *cand;
4242 VEC(tree,gc) *arglist;
4245 tree result = NULL_TREE;
4246 bool result_valid_p = false;
4247 enum tree_code code2 = NOP_EXPR;
4248 enum tree_code code_orig_arg1 = ERROR_MARK;
4249 enum tree_code code_orig_arg2 = ERROR_MARK;
4255 if (error_operand_p (arg1)
4256 || error_operand_p (arg2)
4257 || error_operand_p (arg3))
4258 return error_mark_node;
4260 if (code == MODIFY_EXPR)
4262 code2 = TREE_CODE (arg3);
4264 fnname = ansi_assopname (code2);
4267 fnname = ansi_opname (code);
4269 arg1 = prep_operand (arg1);
4275 case VEC_DELETE_EXPR:
4277 /* Use build_op_new_call and build_op_delete_call instead. */
4281 /* Use build_op_call instead. */
4284 case TRUTH_ORIF_EXPR:
4285 case TRUTH_ANDIF_EXPR:
4286 case TRUTH_AND_EXPR:
4288 /* These are saved for the sake of warn_logical_operator. */
4289 code_orig_arg1 = TREE_CODE (arg1);
4290 code_orig_arg2 = TREE_CODE (arg2);
4296 arg2 = prep_operand (arg2);
4297 arg3 = prep_operand (arg3);
4299 if (code == COND_EXPR)
4300 /* Use build_conditional_expr instead. */
4302 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4303 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4306 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4307 arg2 = integer_zero_node;
4309 arglist = VEC_alloc (tree, gc, 3);
4310 VEC_quick_push (tree, arglist, arg1);
4311 if (arg2 != NULL_TREE)
4312 VEC_quick_push (tree, arglist, arg2);
4313 if (arg3 != NULL_TREE)
4314 VEC_quick_push (tree, arglist, arg3);
4316 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4317 p = conversion_obstack_alloc (0);
4319 /* Add namespace-scope operators to the list of functions to
4321 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
4322 NULL_TREE, arglist, NULL_TREE,
4323 NULL_TREE, false, NULL_TREE, NULL_TREE,
4324 flags, &candidates);
4325 /* Add class-member operators to the candidate set. */
4326 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
4330 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
4331 if (fns == error_mark_node)
4333 result = error_mark_node;
4334 goto user_defined_result_ready;
4337 add_candidates (BASELINK_FUNCTIONS (fns),
4338 NULL_TREE, arglist, NULL_TREE,
4340 BASELINK_BINFO (fns),
4341 BASELINK_ACCESS_BINFO (fns),
4342 flags, &candidates);
4347 args[2] = NULL_TREE;
4349 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
4355 /* For these, the built-in candidates set is empty
4356 [over.match.oper]/3. We don't want non-strict matches
4357 because exact matches are always possible with built-in
4358 operators. The built-in candidate set for COMPONENT_REF
4359 would be empty too, but since there are no such built-in
4360 operators, we accept non-strict matches for them. */
4365 strict_p = pedantic;
4369 candidates = splice_viable (candidates, strict_p, &any_viable_p);
4374 case POSTINCREMENT_EXPR:
4375 case POSTDECREMENT_EXPR:
4376 /* Don't try anything fancy if we're not allowed to produce
4378 if (!(complain & tf_error))
4379 return error_mark_node;
4381 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
4382 distinguish between prefix and postfix ++ and
4383 operator++() was used for both, so we allow this with
4385 if (flags & LOOKUP_COMPLAIN)
4387 const char *msg = (flag_permissive)
4388 ? G_("no %<%D(int)%> declared for postfix %qs,"
4389 " trying prefix operator instead")
4390 : G_("no %<%D(int)%> declared for postfix %qs");
4391 permerror (input_location, msg, fnname,
4392 operator_name_info[code].name);
4395 if (!flag_permissive)
4396 return error_mark_node;
4398 if (code == POSTINCREMENT_EXPR)
4399 code = PREINCREMENT_EXPR;
4401 code = PREDECREMENT_EXPR;
4402 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
4403 overloaded_p, complain);
4406 /* The caller will deal with these. */
4411 result_valid_p = true;
4415 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4417 /* If one of the arguments of the operator represents
4418 an invalid use of member function pointer, try to report
4419 a meaningful error ... */
4420 if (invalid_nonstatic_memfn_p (arg1, tf_error)
4421 || invalid_nonstatic_memfn_p (arg2, tf_error)
4422 || invalid_nonstatic_memfn_p (arg3, tf_error))
4423 /* We displayed the error message. */;
4426 /* ... Otherwise, report the more generic
4427 "no matching operator found" error */
4428 op_error (code, code2, arg1, arg2, arg3, FALSE);
4429 print_z_candidates (candidates);
4432 result = error_mark_node;
4438 cand = tourney (candidates);
4441 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4443 op_error (code, code2, arg1, arg2, arg3, TRUE);
4444 print_z_candidates (candidates);
4446 result = error_mark_node;
4448 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
4451 *overloaded_p = true;
4453 if (resolve_args (arglist) == NULL)
4454 result = error_mark_node;
4456 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4460 /* Give any warnings we noticed during overload resolution. */
4461 if (cand->warnings && (complain & tf_warning))
4463 struct candidate_warning *w;
4464 for (w = cand->warnings; w; w = w->next)
4465 joust (cand, w->loser, 1);
4468 /* Check for comparison of different enum types. */
4477 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
4478 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
4479 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
4480 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
4481 && (complain & tf_warning))
4483 warning (OPT_Wenum_compare,
4484 "comparison between %q#T and %q#T",
4485 TREE_TYPE (arg1), TREE_TYPE (arg2));
4492 /* We need to strip any leading REF_BIND so that bitfields
4493 don't cause errors. This should not remove any important
4494 conversions, because builtins don't apply to class
4495 objects directly. */
4496 conv = cand->convs[0];
4497 if (conv->kind == ck_ref_bind)
4498 conv = conv->u.next;
4499 arg1 = convert_like (conv, arg1, complain);
4503 /* We need to call warn_logical_operator before
4504 converting arg2 to a boolean_type. */
4505 if (complain & tf_warning)
4506 warn_logical_operator (input_location, code, boolean_type_node,
4507 code_orig_arg1, arg1,
4508 code_orig_arg2, arg2);
4510 conv = cand->convs[1];
4511 if (conv->kind == ck_ref_bind)
4512 conv = conv->u.next;
4513 arg2 = convert_like (conv, arg2, complain);
4517 conv = cand->convs[2];
4518 if (conv->kind == ck_ref_bind)
4519 conv = conv->u.next;
4520 arg3 = convert_like (conv, arg3, complain);
4526 user_defined_result_ready:
4528 /* Free all the conversions we allocated. */
4529 obstack_free (&conversion_obstack, p);
4531 if (result || result_valid_p)
4535 avoid_sign_compare_warnings (orig_arg1, arg1);
4536 avoid_sign_compare_warnings (orig_arg2, arg2);
4537 avoid_sign_compare_warnings (orig_arg3, arg3);
4542 return cp_build_modify_expr (arg1, code2, arg2, complain);
4545 return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
4547 case TRUTH_ANDIF_EXPR:
4548 case TRUTH_ORIF_EXPR:
4549 case TRUTH_AND_EXPR:
4551 warn_logical_operator (input_location, code, boolean_type_node,
4552 code_orig_arg1, arg1, code_orig_arg2, arg2);
4557 case TRUNC_DIV_EXPR:
4568 case TRUNC_MOD_EXPR:
4572 return cp_build_binary_op (input_location, code, arg1, arg2, complain);
4574 case UNARY_PLUS_EXPR:
4577 case TRUTH_NOT_EXPR:
4578 case PREINCREMENT_EXPR:
4579 case POSTINCREMENT_EXPR:
4580 case PREDECREMENT_EXPR:
4581 case POSTDECREMENT_EXPR:
4584 return cp_build_unary_op (code, arg1, candidates != 0, complain);
4587 return cp_build_array_ref (input_location, arg1, arg2, complain);
4590 return build_m_component_ref (cp_build_indirect_ref (arg1, RO_NULL,
4594 /* The caller will deal with these. */
4606 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
4607 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
4610 non_placement_deallocation_fn_p (tree t)
4612 /* A template instance is never a usual deallocation function,
4613 regardless of its signature. */
4614 if (TREE_CODE (t) == TEMPLATE_DECL
4615 || primary_template_instantiation_p (t))
4618 /* If a class T has a member deallocation function named operator delete
4619 with exactly one parameter, then that function is a usual
4620 (non-placement) deallocation function. If class T does not declare
4621 such an operator delete but does declare a member deallocation
4622 function named operator delete with exactly two parameters, the second
4623 of which has type std::size_t (18.2), then this function is a usual
4624 deallocation function. */
4625 t = FUNCTION_ARG_CHAIN (t);
4626 if (t == void_list_node
4627 || (t && same_type_p (TREE_VALUE (t), size_type_node)
4628 && TREE_CHAIN (t) == void_list_node))
4633 /* Build a call to operator delete. This has to be handled very specially,
4634 because the restrictions on what signatures match are different from all
4635 other call instances. For a normal delete, only a delete taking (void *)
4636 or (void *, size_t) is accepted. For a placement delete, only an exact
4637 match with the placement new is accepted.
4639 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4640 ADDR is the pointer to be deleted.
4641 SIZE is the size of the memory block to be deleted.
4642 GLOBAL_P is true if the delete-expression should not consider
4643 class-specific delete operators.
4644 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4646 If this call to "operator delete" is being generated as part to
4647 deallocate memory allocated via a new-expression (as per [expr.new]
4648 which requires that if the initialization throws an exception then
4649 we call a deallocation function), then ALLOC_FN is the allocation
4653 build_op_delete_call (enum tree_code code, tree addr, tree size,
4654 bool global_p, tree placement,
4657 tree fn = NULL_TREE;
4658 tree fns, fnname, type, t;
4660 if (addr == error_mark_node)
4661 return error_mark_node;
4663 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4665 fnname = ansi_opname (code);
4667 if (CLASS_TYPE_P (type)
4668 && COMPLETE_TYPE_P (complete_type (type))
4672 If the result of the lookup is ambiguous or inaccessible, or if
4673 the lookup selects a placement deallocation function, the
4674 program is ill-formed.
4676 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4678 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4679 if (fns == error_mark_node)
4680 return error_mark_node;
4685 if (fns == NULL_TREE)
4686 fns = lookup_name_nonclass (fnname);
4688 /* Strip const and volatile from addr. */
4689 addr = cp_convert (ptr_type_node, addr);
4693 /* "A declaration of a placement deallocation function matches the
4694 declaration of a placement allocation function if it has the same
4695 number of parameters and, after parameter transformations (8.3.5),
4696 all parameter types except the first are identical."
4698 So we build up the function type we want and ask instantiate_type
4699 to get it for us. */
4700 t = FUNCTION_ARG_CHAIN (alloc_fn);
4701 t = tree_cons (NULL_TREE, ptr_type_node, t);
4702 t = build_function_type (void_type_node, t);
4704 fn = instantiate_type (t, fns, tf_none);
4705 if (fn == error_mark_node)
4708 if (BASELINK_P (fn))
4709 fn = BASELINK_FUNCTIONS (fn);
4711 /* "If the lookup finds the two-parameter form of a usual deallocation
4712 function (3.7.4.2) and that function, considered as a placement
4713 deallocation function, would have been selected as a match for the
4714 allocation function, the program is ill-formed." */
4715 if (non_placement_deallocation_fn_p (fn))
4717 /* But if the class has an operator delete (void *), then that is
4718 the usual deallocation function, so we shouldn't complain
4719 about using the operator delete (void *, size_t). */
4720 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4721 t; t = OVL_NEXT (t))
4723 tree elt = OVL_CURRENT (t);
4724 if (non_placement_deallocation_fn_p (elt)
4725 && FUNCTION_ARG_CHAIN (elt) == void_list_node)
4728 permerror (0, "non-placement deallocation function %q+D", fn);
4729 permerror (input_location, "selected for placement delete");
4734 /* "Any non-placement deallocation function matches a non-placement
4735 allocation function. If the lookup finds a single matching
4736 deallocation function, that function will be called; otherwise, no
4737 deallocation function will be called." */
4738 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4739 t; t = OVL_NEXT (t))
4741 tree elt = OVL_CURRENT (t);
4742 if (non_placement_deallocation_fn_p (elt))
4745 /* "If a class T has a member deallocation function named
4746 operator delete with exactly one parameter, then that
4747 function is a usual (non-placement) deallocation
4748 function. If class T does not declare such an operator
4749 delete but does declare a member deallocation function named
4750 operator delete with exactly two parameters, the second of
4751 which has type std::size_t (18.2), then this function is a
4752 usual deallocation function."
4754 So (void*) beats (void*, size_t). */
4755 if (FUNCTION_ARG_CHAIN (fn) == void_list_node)
4760 /* If we have a matching function, call it. */
4763 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
4765 /* If the FN is a member function, make sure that it is
4767 if (BASELINK_P (fns))
4768 perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn);
4770 /* Core issue 901: It's ok to new a type with deleted delete. */
4771 if (DECL_DELETED_FN (fn) && alloc_fn)
4776 /* The placement args might not be suitable for overload
4777 resolution at this point, so build the call directly. */
4778 int nargs = call_expr_nargs (placement);
4779 tree *argarray = XALLOCAVEC (tree, nargs);
4782 for (i = 1; i < nargs; i++)
4783 argarray[i] = CALL_EXPR_ARG (placement, i);
4785 return build_cxx_call (fn, nargs, argarray);
4790 VEC(tree,gc) *args = VEC_alloc (tree, gc, 2);
4791 VEC_quick_push (tree, args, addr);
4792 if (FUNCTION_ARG_CHAIN (fn) != void_list_node)
4793 VEC_quick_push (tree, args, size);
4794 ret = cp_build_function_call_vec (fn, &args, tf_warning_or_error);
4795 VEC_free (tree, gc, args);
4802 If no unambiguous matching deallocation function can be found,
4803 propagating the exception does not cause the object's memory to
4808 warning (0, "no corresponding deallocation function for %qD",
4813 error ("no suitable %<operator %s%> for %qT",
4814 operator_name_info[(int)code].name, type);
4815 return error_mark_node;
4818 /* If the current scope isn't allowed to access DECL along
4819 BASETYPE_PATH, give an error. The most derived class in
4820 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4821 the declaration to use in the error diagnostic. */
4824 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4826 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4828 if (!accessible_p (basetype_path, decl, true))
4830 if (TREE_PRIVATE (decl))
4831 error ("%q+#D is private", diag_decl);
4832 else if (TREE_PROTECTED (decl))
4833 error ("%q+#D is protected", diag_decl);
4835 error ("%q+#D is inaccessible", diag_decl);
4836 error ("within this context");
4843 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4844 bitwise or of LOOKUP_* values. If any errors are warnings are
4845 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4846 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4850 build_temp (tree expr, tree type, int flags,
4851 diagnostic_t *diagnostic_kind)
4856 savew = warningcount, savee = errorcount;
4857 args = make_tree_vector_single (expr);
4858 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4859 &args, type, flags, tf_warning_or_error);
4860 release_tree_vector (args);
4861 if (warningcount > savew)
4862 *diagnostic_kind = DK_WARNING;
4863 else if (errorcount > savee)
4864 *diagnostic_kind = DK_ERROR;
4866 *diagnostic_kind = DK_UNSPECIFIED;
4870 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4871 EXPR is implicitly converted to type TOTYPE.
4872 FN and ARGNUM are used for diagnostics. */
4875 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
4877 tree t = non_reference (totype);
4879 /* Issue warnings about peculiar, but valid, uses of NULL. */
4880 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4883 warning_at (input_location, OPT_Wconversion_null,
4884 "passing NULL to non-pointer argument %P of %qD",
4887 warning_at (input_location, OPT_Wconversion_null,
4888 "converting to non-pointer type %qT from NULL", t);
4891 /* Issue warnings if "false" is converted to a NULL pointer */
4892 else if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4893 warning_at (input_location, OPT_Wconversion_null,
4894 "converting %<false%> to pointer type for argument %P of %qD",
4898 /* Perform the conversions in CONVS on the expression EXPR. FN and
4899 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4900 indicates the `this' argument of a method. INNER is nonzero when
4901 being called to continue a conversion chain. It is negative when a
4902 reference binding will be applied, positive otherwise. If
4903 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4904 conversions will be emitted if appropriate. If C_CAST_P is true,
4905 this conversion is coming from a C-style cast; in that case,
4906 conversions to inaccessible bases are permitted. */
4909 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4910 int inner, bool issue_conversion_warnings,
4911 bool c_cast_p, tsubst_flags_t complain)
4913 tree totype = convs->type;
4914 diagnostic_t diag_kind;
4918 && convs->kind != ck_user
4919 && convs->kind != ck_list
4920 && convs->kind != ck_ambig
4921 && convs->kind != ck_ref_bind
4922 && convs->kind != ck_rvalue
4923 && convs->kind != ck_base)
4925 conversion *t = convs;
4927 /* Give a helpful error if this is bad because of excess braces. */
4928 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
4929 && SCALAR_TYPE_P (totype)
4930 && CONSTRUCTOR_NELTS (expr) > 0
4931 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
4932 permerror (input_location, "too many braces around initializer for %qT", totype);
4934 for (; t; t = convs->u.next)
4936 if (t->kind == ck_user || !t->bad_p)
4938 expr = convert_like_real (t, expr, fn, argnum, 1,
4939 /*issue_conversion_warnings=*/false,
4944 else if (t->kind == ck_ambig)
4945 return convert_like_real (t, expr, fn, argnum, 1,
4946 /*issue_conversion_warnings=*/false,
4949 else if (t->kind == ck_identity)
4952 if (complain & tf_error)
4954 permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4956 permerror (DECL_SOURCE_LOCATION (fn),
4957 " initializing argument %P of %qD", argnum, fn);
4960 return error_mark_node;
4962 return cp_convert (totype, expr);
4965 if (issue_conversion_warnings && (complain & tf_warning))
4966 conversion_null_warnings (totype, expr, fn, argnum);
4968 switch (convs->kind)
4972 struct z_candidate *cand = convs->cand;
4973 tree convfn = cand->fn;
4976 expr = mark_rvalue_use (expr);
4978 /* When converting from an init list we consider explicit
4979 constructors, but actually trying to call one is an error. */
4980 if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn)
4981 /* Unless we're calling it for value-initialization from an
4982 empty list, since that is handled separately in 8.5.4. */
4983 && cand->num_convs > 0)
4985 if (complain & tf_error)
4986 error ("converting to %qT from initializer list would use "
4987 "explicit constructor %qD", totype, convfn);
4989 return error_mark_node;
4992 /* Set user_conv_p on the argument conversions, so rvalue/base
4993 handling knows not to allow any more UDCs. */
4994 for (i = 0; i < cand->num_convs; ++i)
4995 cand->convs[i]->user_conv_p = true;
4997 expr = build_over_call (cand, LOOKUP_NORMAL, complain);
4999 /* If this is a constructor or a function returning an aggr type,
5000 we need to build up a TARGET_EXPR. */
5001 if (DECL_CONSTRUCTOR_P (convfn))
5003 expr = build_cplus_new (totype, expr);
5005 /* Remember that this was list-initialization. */
5006 if (convs->check_narrowing)
5007 TARGET_EXPR_LIST_INIT_P (expr) = true;
5013 expr = mark_rvalue_use (expr);
5014 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
5016 int nelts = CONSTRUCTOR_NELTS (expr);
5018 expr = integer_zero_node;
5019 else if (nelts == 1)
5020 expr = CONSTRUCTOR_ELT (expr, 0)->value;
5025 if (type_unknown_p (expr))
5026 expr = instantiate_type (totype, expr, complain);
5027 /* Convert a constant to its underlying value, unless we are
5028 about to bind it to a reference, in which case we need to
5029 leave it as an lvalue. */
5032 expr = decl_constant_value (expr);
5033 if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
5034 /* If __null has been converted to an integer type, we do not
5035 want to warn about uses of EXPR as an integer, rather than
5037 expr = build_int_cst (totype, 0);
5041 if (complain & tf_error)
5043 /* Call build_user_type_conversion again for the error. */
5044 build_user_type_conversion (totype, convs->u.expr, LOOKUP_NORMAL);
5046 error (" initializing argument %P of %q+D", argnum, fn);
5048 return error_mark_node;
5052 /* Conversion to std::initializer_list<T>. */
5053 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
5054 tree new_ctor = build_constructor (init_list_type_node, NULL);
5055 unsigned len = CONSTRUCTOR_NELTS (expr);
5057 VEC(tree,gc) *parms;
5060 /* Convert all the elements. */
5061 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
5063 tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
5064 1, false, false, complain);
5065 if (sub == error_mark_node)
5067 check_narrowing (TREE_TYPE (sub), val);
5068 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
5070 /* Build up the array. */
5071 elttype = cp_build_qualified_type
5072 (elttype, cp_type_quals (elttype) | TYPE_QUAL_CONST);
5073 array = build_array_of_n_type (elttype, len);
5074 array = finish_compound_literal (array, new_ctor);
5076 parms = make_tree_vector ();
5077 VEC_safe_push (tree, gc, parms, decay_conversion (array));
5078 VEC_safe_push (tree, gc, parms, size_int (len));
5079 /* Call the private constructor. */
5080 push_deferring_access_checks (dk_no_check);
5081 new_ctor = build_special_member_call
5082 (NULL_TREE, complete_ctor_identifier, &parms, totype, 0, complain);
5083 release_tree_vector (parms);
5084 pop_deferring_access_checks ();
5085 return build_cplus_new (totype, new_ctor);
5089 return get_target_expr (digest_init (totype, expr));
5095 expr = convert_like_real (convs->u.next, expr, fn, argnum,
5096 convs->kind == ck_ref_bind ? -1 : 1,
5097 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
5100 if (expr == error_mark_node)
5101 return error_mark_node;
5103 switch (convs->kind)
5106 expr = decay_conversion (expr);
5107 if (! MAYBE_CLASS_TYPE_P (totype))
5109 /* Else fall through. */
5111 if (convs->kind == ck_base && !convs->need_temporary_p)
5113 /* We are going to bind a reference directly to a base-class
5114 subobject of EXPR. */
5115 /* Build an expression for `*((base*) &expr)'. */
5116 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5117 expr = convert_to_base (expr, build_pointer_type (totype),
5118 !c_cast_p, /*nonnull=*/true, complain);
5119 expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
5123 /* Copy-initialization where the cv-unqualified version of the source
5124 type is the same class as, or a derived class of, the class of the
5125 destination [is treated as direct-initialization]. [dcl.init] */
5126 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
5127 if (convs->user_conv_p)
5128 /* This conversion is being done in the context of a user-defined
5129 conversion (i.e. the second step of copy-initialization), so
5130 don't allow any more. */
5131 flags |= LOOKUP_NO_CONVERSION;
5132 expr = build_temp (expr, totype, flags, &diag_kind);
5133 if (diag_kind && fn)
5135 if ((complain & tf_error))
5136 emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (fn), 0,
5137 " initializing argument %P of %qD", argnum, fn);
5138 else if (diag_kind == DK_ERROR)
5139 return error_mark_node;
5141 return build_cplus_new (totype, expr);
5145 tree ref_type = totype;
5147 if (convs->bad_p && TYPE_REF_IS_RVALUE (ref_type)
5148 && real_lvalue_p (expr))
5150 if (complain & tf_error)
5152 error ("cannot bind %qT lvalue to %qT",
5153 TREE_TYPE (expr), totype);
5155 error (" initializing argument %P of %q+D", argnum, fn);
5157 return error_mark_node;
5160 /* If necessary, create a temporary.
5162 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
5163 that need temporaries, even when their types are reference
5164 compatible with the type of reference being bound, so the
5165 upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...)
5167 if (convs->need_temporary_p
5168 || TREE_CODE (expr) == CONSTRUCTOR
5169 || TREE_CODE (expr) == VA_ARG_EXPR)
5171 tree type = convs->u.next->type;
5172 cp_lvalue_kind lvalue = real_lvalue_p (expr);
5174 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
5175 && !TYPE_REF_IS_RVALUE (ref_type))
5177 if (complain & tf_error)
5179 /* If the reference is volatile or non-const, we
5180 cannot create a temporary. */
5181 if (lvalue & clk_bitfield)
5182 error ("cannot bind bitfield %qE to %qT",
5184 else if (lvalue & clk_packed)
5185 error ("cannot bind packed field %qE to %qT",
5188 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
5190 return error_mark_node;
5192 /* If the source is a packed field, and we must use a copy
5193 constructor, then building the target expr will require
5194 binding the field to the reference parameter to the
5195 copy constructor, and we'll end up with an infinite
5196 loop. If we can use a bitwise copy, then we'll be
5198 if ((lvalue & clk_packed)
5199 && CLASS_TYPE_P (type)
5200 && !TYPE_HAS_TRIVIAL_COPY_CTOR (type))
5202 if (complain & tf_error)
5203 error ("cannot bind packed field %qE to %qT",
5205 return error_mark_node;
5207 if (lvalue & clk_bitfield)
5209 expr = convert_bitfield_to_declared_type (expr);
5210 expr = fold_convert (type, expr);
5212 expr = build_target_expr_with_type (expr, type);
5215 /* Take the address of the thing to which we will bind the
5217 expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain);
5218 if (expr == error_mark_node)
5219 return error_mark_node;
5221 /* Convert it to a pointer to the type referred to by the
5222 reference. This will adjust the pointer if a derived to
5223 base conversion is being performed. */
5224 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
5226 /* Convert the pointer to the desired reference type. */
5227 return build_nop (ref_type, expr);
5231 return decay_conversion (expr);
5234 /* Warn about deprecated conversion if appropriate. */
5235 string_conv_p (totype, expr, 1);
5240 expr = convert_to_base (expr, totype, !c_cast_p,
5241 /*nonnull=*/false, complain);
5242 return build_nop (totype, expr);
5245 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
5252 if (convs->check_narrowing)
5253 check_narrowing (totype, expr);
5255 if (issue_conversion_warnings && (complain & tf_warning))
5256 expr = convert_and_check (totype, expr);
5258 expr = convert (totype, expr);
5263 /* ARG is being passed to a varargs function. Perform any conversions
5264 required. Return the converted value. */
5267 convert_arg_to_ellipsis (tree arg)
5271 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5272 standard conversions are performed. */
5273 arg = decay_conversion (arg);
5276 If the argument has integral or enumeration type that is subject
5277 to the integral promotions (_conv.prom_), or a floating point
5278 type that is subject to the floating point promotion
5279 (_conv.fpprom_), the value of the argument is converted to the
5280 promoted type before the call. */
5281 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
5282 && (TYPE_PRECISION (TREE_TYPE (arg))
5283 < TYPE_PRECISION (double_type_node))
5284 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (arg))))
5285 arg = convert_to_real (double_type_node, arg);
5286 else if (NULLPTR_TYPE_P (TREE_TYPE (arg)))
5287 arg = null_pointer_node;
5288 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
5289 arg = perform_integral_promotions (arg);
5291 arg = require_complete_type (arg);
5293 if (arg != error_mark_node
5294 && (type_has_nontrivial_copy_init (TREE_TYPE (arg))
5295 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (arg))))
5297 /* [expr.call] 5.2.2/7:
5298 Passing a potentially-evaluated argument of class type (Clause 9)
5299 with a non-trivial copy constructor or a non-trivial destructor
5300 with no corresponding parameter is conditionally-supported, with
5301 implementation-defined semantics.
5303 We used to just warn here and do a bitwise copy, but now
5304 cp_expr_size will abort if we try to do that.
5306 If the call appears in the context of a sizeof expression,
5307 it is not potentially-evaluated. */
5308 if (cp_unevaluated_operand == 0)
5309 error ("cannot pass objects of non-trivially-copyable "
5310 "type %q#T through %<...%>", TREE_TYPE (arg));
5316 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
5319 build_x_va_arg (tree expr, tree type)
5321 if (processing_template_decl)
5322 return build_min (VA_ARG_EXPR, type, expr);
5324 type = complete_type_or_else (type, NULL_TREE);
5326 if (expr == error_mark_node || !type)
5327 return error_mark_node;
5329 expr = mark_lvalue_use (expr);
5331 if (type_has_nontrivial_copy_init (type)
5332 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5333 || TREE_CODE (type) == REFERENCE_TYPE)
5335 /* Remove reference types so we don't ICE later on. */
5336 tree type1 = non_reference (type);
5337 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
5338 error ("cannot receive objects of non-trivially-copyable type %q#T "
5339 "through %<...%>; ", type);
5340 expr = convert (build_pointer_type (type1), null_node);
5341 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
5345 return build_va_arg (input_location, expr, type);
5348 /* TYPE has been given to va_arg. Apply the default conversions which
5349 would have happened when passed via ellipsis. Return the promoted
5350 type, or the passed type if there is no change. */
5353 cxx_type_promotes_to (tree type)
5357 /* Perform the array-to-pointer and function-to-pointer
5359 type = type_decays_to (type);
5361 promote = type_promotes_to (type);
5362 if (same_type_p (type, promote))
5368 /* ARG is a default argument expression being passed to a parameter of
5369 the indicated TYPE, which is a parameter to FN. Do any required
5370 conversions. Return the converted value. */
5372 static GTY(()) VEC(tree,gc) *default_arg_context;
5375 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
5380 /* If the ARG is an unparsed default argument expression, the
5381 conversion cannot be performed. */
5382 if (TREE_CODE (arg) == DEFAULT_ARG)
5384 error ("the default argument for parameter %d of %qD has "
5385 "not yet been parsed",
5387 return error_mark_node;
5390 /* Detect recursion. */
5391 for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
5394 error ("recursive evaluation of default argument for %q#D", fn);
5395 return error_mark_node;
5397 VEC_safe_push (tree, gc, default_arg_context, fn);
5399 if (fn && DECL_TEMPLATE_INFO (fn))
5400 arg = tsubst_default_argument (fn, type, arg);
5406 The names in the expression are bound, and the semantic
5407 constraints are checked, at the point where the default
5408 expressions appears.
5410 we must not perform access checks here. */
5411 push_deferring_access_checks (dk_no_check);
5412 arg = break_out_target_exprs (arg);
5413 if (TREE_CODE (arg) == CONSTRUCTOR)
5415 arg = digest_init (type, arg);
5416 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5417 ICR_DEFAULT_ARGUMENT, fn, parmnum,
5418 tf_warning_or_error);
5422 /* We must make a copy of ARG, in case subsequent processing
5423 alters any part of it. For example, during gimplification a
5424 cast of the form (T) &X::f (where "f" is a member function)
5425 will lead to replacing the PTRMEM_CST for &X::f with a
5426 VAR_DECL. We can avoid the copy for constants, since they
5427 are never modified in place. */
5428 if (!CONSTANT_CLASS_P (arg))
5429 arg = unshare_expr (arg);
5430 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5431 ICR_DEFAULT_ARGUMENT, fn, parmnum,
5432 tf_warning_or_error);
5433 arg = convert_for_arg_passing (type, arg);
5435 pop_deferring_access_checks();
5437 VEC_pop (tree, default_arg_context);
5442 /* Returns the type which will really be used for passing an argument of
5446 type_passed_as (tree type)
5448 /* Pass classes with copy ctors by invisible reference. */
5449 if (TREE_ADDRESSABLE (type))
5451 type = build_reference_type (type);
5452 /* There are no other pointers to this temporary. */
5453 type = cp_build_qualified_type (type, TYPE_QUAL_RESTRICT);
5455 else if (targetm.calls.promote_prototypes (type)
5456 && INTEGRAL_TYPE_P (type)
5457 && COMPLETE_TYPE_P (type)
5458 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5459 TYPE_SIZE (integer_type_node)))
5460 type = integer_type_node;
5465 /* Actually perform the appropriate conversion. */
5468 convert_for_arg_passing (tree type, tree val)
5472 /* If VAL is a bitfield, then -- since it has already been converted
5473 to TYPE -- it cannot have a precision greater than TYPE.
5475 If it has a smaller precision, we must widen it here. For
5476 example, passing "int f:3;" to a function expecting an "int" will
5477 not result in any conversion before this point.
5479 If the precision is the same we must not risk widening. For
5480 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
5481 often have type "int", even though the C++ type for the field is
5482 "long long". If the value is being passed to a function
5483 expecting an "int", then no conversions will be required. But,
5484 if we call convert_bitfield_to_declared_type, the bitfield will
5485 be converted to "long long". */
5486 bitfield_type = is_bitfield_expr_with_lowered_type (val);
5488 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
5489 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
5491 if (val == error_mark_node)
5493 /* Pass classes with copy ctors by invisible reference. */
5494 else if (TREE_ADDRESSABLE (type))
5495 val = build1 (ADDR_EXPR, build_reference_type (type), val);
5496 else if (targetm.calls.promote_prototypes (type)
5497 && INTEGRAL_TYPE_P (type)
5498 && COMPLETE_TYPE_P (type)
5499 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5500 TYPE_SIZE (integer_type_node)))
5501 val = perform_integral_promotions (val);
5502 if (warn_missing_format_attribute)
5504 tree rhstype = TREE_TYPE (val);
5505 const enum tree_code coder = TREE_CODE (rhstype);
5506 const enum tree_code codel = TREE_CODE (type);
5507 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5509 && check_missing_format_attribute (type, rhstype))
5510 warning (OPT_Wmissing_format_attribute,
5511 "argument of function call might be a candidate for a format attribute");
5516 /* Returns true iff FN is a function with magic varargs, i.e. ones for
5517 which no conversions at all should be done. This is true for some
5518 builtins which don't act like normal functions. */
5521 magic_varargs_p (tree fn)
5523 if (DECL_BUILT_IN (fn))
5524 switch (DECL_FUNCTION_CODE (fn))
5526 case BUILT_IN_CLASSIFY_TYPE:
5527 case BUILT_IN_CONSTANT_P:
5528 case BUILT_IN_NEXT_ARG:
5529 case BUILT_IN_VA_START:
5533 return lookup_attribute ("type generic",
5534 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
5540 /* Subroutine of the various build_*_call functions. Overload resolution
5541 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
5542 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
5543 bitmask of various LOOKUP_* flags which apply to the call itself. */
5546 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
5549 const VEC(tree,gc) *args = cand->args;
5550 tree first_arg = cand->first_arg;
5551 conversion **convs = cand->convs;
5553 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5558 unsigned int arg_index = 0;
5562 bool already_used = false;
5564 /* In a template, there is no need to perform all of the work that
5565 is normally done. We are only interested in the type of the call
5566 expression, i.e., the return type of the function. Any semantic
5567 errors will be deferred until the template is instantiated. */
5568 if (processing_template_decl)
5572 const tree *argarray;
5575 return_type = TREE_TYPE (TREE_TYPE (fn));
5576 nargs = VEC_length (tree, args);
5577 if (first_arg == NULL_TREE)
5578 argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
5586 alcarray = XALLOCAVEC (tree, nargs);
5587 alcarray[0] = first_arg;
5588 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
5589 alcarray[ix + 1] = arg;
5590 argarray = alcarray;
5592 expr = build_call_array_loc (input_location,
5593 return_type, build_addr_func (fn), nargs,
5595 if (TREE_THIS_VOLATILE (fn) && cfun)
5596 current_function_returns_abnormally = 1;
5597 if (!VOID_TYPE_P (return_type))
5598 require_complete_type (return_type);
5599 return convert_from_reference (expr);
5602 /* Give any warnings we noticed during overload resolution. */
5605 struct candidate_warning *w;
5606 for (w = cand->warnings; w; w = w->next)
5607 joust (cand, w->loser, 1);
5610 /* Make =delete work with SFINAE. */
5611 if (DECL_DELETED_FN (fn) && !(complain & tf_error))
5612 return error_mark_node;
5614 if (DECL_FUNCTION_MEMBER_P (fn))
5616 /* If FN is a template function, two cases must be considered.
5621 template <class T> void f();
5623 template <class T> struct B {
5627 struct C : A, B<int> {
5629 using B<int>::g; // #2
5632 In case #1 where `A::f' is a member template, DECL_ACCESS is
5633 recorded in the primary template but not in its specialization.
5634 We check access of FN using its primary template.
5636 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
5637 because it is a member of class template B, DECL_ACCESS is
5638 recorded in the specialization `B<int>::g'. We cannot use its
5639 primary template because `B<T>::g' and `B<int>::g' may have
5640 different access. */
5641 if (DECL_TEMPLATE_INFO (fn)
5642 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
5643 perform_or_defer_access_check (cand->access_path,
5644 DECL_TI_TEMPLATE (fn), fn);
5646 perform_or_defer_access_check (cand->access_path, fn, fn);
5649 /* Find maximum size of vector to hold converted arguments. */
5650 parmlen = list_length (parm);
5651 nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
5652 if (parmlen > nargs)
5654 argarray = XALLOCAVEC (tree, nargs);
5656 /* The implicit parameters to a constructor are not considered by overload
5657 resolution, and must be of the proper type. */
5658 if (DECL_CONSTRUCTOR_P (fn))
5660 if (first_arg != NULL_TREE)
5662 argarray[j++] = first_arg;
5663 first_arg = NULL_TREE;
5667 argarray[j++] = VEC_index (tree, args, arg_index);
5670 parm = TREE_CHAIN (parm);
5671 /* We should never try to call the abstract constructor. */
5672 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
5674 if (DECL_HAS_VTT_PARM_P (fn))
5676 argarray[j++] = VEC_index (tree, args, arg_index);
5678 parm = TREE_CHAIN (parm);
5681 /* Bypass access control for 'this' parameter. */
5682 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5684 tree parmtype = TREE_VALUE (parm);
5685 tree arg = (first_arg != NULL_TREE
5687 : VEC_index (tree, args, arg_index));
5688 tree argtype = TREE_TYPE (arg);
5692 if (convs[i]->bad_p)
5694 if (complain & tf_error)
5695 permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
5696 TREE_TYPE (argtype), fn);
5698 return error_mark_node;
5701 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
5702 X is called for an object that is not of type X, or of a type
5703 derived from X, the behavior is undefined.
5705 So we can assume that anything passed as 'this' is non-null, and
5706 optimize accordingly. */
5707 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
5708 /* Convert to the base in which the function was declared. */
5709 gcc_assert (cand->conversion_path != NULL_TREE);
5710 converted_arg = build_base_path (PLUS_EXPR,
5712 cand->conversion_path,
5714 /* Check that the base class is accessible. */
5715 if (!accessible_base_p (TREE_TYPE (argtype),
5716 BINFO_TYPE (cand->conversion_path), true))
5717 error ("%qT is not an accessible base of %qT",
5718 BINFO_TYPE (cand->conversion_path),
5719 TREE_TYPE (argtype));
5720 /* If fn was found by a using declaration, the conversion path
5721 will be to the derived class, not the base declaring fn. We
5722 must convert from derived to base. */
5723 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
5724 TREE_TYPE (parmtype), ba_unique, NULL);
5725 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
5728 argarray[j++] = converted_arg;
5729 parm = TREE_CHAIN (parm);
5730 if (first_arg != NULL_TREE)
5731 first_arg = NULL_TREE;
5738 gcc_assert (first_arg == NULL_TREE);
5739 for (; arg_index < VEC_length (tree, args) && parm;
5740 parm = TREE_CHAIN (parm), ++arg_index, ++i)
5742 tree type = TREE_VALUE (parm);
5743 tree arg = VEC_index (tree, args, arg_index);
5747 /* Don't make a copy here if build_call is going to. */
5748 if (conv->kind == ck_rvalue
5749 && COMPLETE_TYPE_P (complete_type (type))
5750 && !TREE_ADDRESSABLE (type))
5751 conv = conv->u.next;
5753 /* Warn about initializer_list deduction that isn't currently in the
5755 if (cxx_dialect > cxx98
5756 && flag_deduce_init_list
5757 && cand->template_decl
5758 && is_std_init_list (non_reference (type))
5759 && BRACE_ENCLOSED_INITIALIZER_P (arg))
5761 tree tmpl = TI_TEMPLATE (cand->template_decl);
5762 tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
5763 tree patparm = get_pattern_parm (realparm, tmpl);
5764 tree pattype = TREE_TYPE (patparm);
5765 if (PACK_EXPANSION_P (pattype))
5766 pattype = PACK_EXPANSION_PATTERN (pattype);
5767 pattype = non_reference (pattype);
5769 if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM
5770 && (cand->explicit_targs == NULL_TREE
5771 || (TREE_VEC_LENGTH (cand->explicit_targs)
5772 <= TEMPLATE_TYPE_IDX (pattype))))
5774 pedwarn (input_location, 0, "deducing %qT as %qT",
5775 non_reference (TREE_TYPE (patparm)),
5776 non_reference (type));
5777 pedwarn (input_location, 0, " in call to %q+D", cand->fn);
5778 pedwarn (input_location, 0,
5779 " (you can disable this with -fno-deduce-init-list)");
5783 val = convert_like_with_context (conv, arg, fn, i-is_method, complain);
5785 val = convert_for_arg_passing (type, val);
5786 if (val == error_mark_node)
5787 return error_mark_node;
5789 argarray[j++] = val;
5792 /* Default arguments */
5793 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5794 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5795 TREE_PURPOSE (parm),
5798 for (; arg_index < VEC_length (tree, args); ++arg_index)
5800 tree a = VEC_index (tree, args, arg_index);
5801 if (magic_varargs_p (fn))
5802 /* Do no conversions for magic varargs. */
5803 a = mark_type_use (a);
5805 a = convert_arg_to_ellipsis (a);
5809 gcc_assert (j <= nargs);
5812 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5813 nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5815 /* Avoid actually calling copy constructors and copy assignment operators,
5818 if (! flag_elide_constructors)
5819 /* Do things the hard way. */;
5820 else if (cand->num_convs == 1
5821 && (DECL_COPY_CONSTRUCTOR_P (fn)
5822 || DECL_MOVE_CONSTRUCTOR_P (fn)))
5825 tree arg = argarray[num_artificial_parms_for (fn)];
5828 /* Pull out the real argument, disregarding const-correctness. */
5830 while (CONVERT_EXPR_P (targ)
5831 || TREE_CODE (targ) == NON_LVALUE_EXPR)
5832 targ = TREE_OPERAND (targ, 0);
5833 if (TREE_CODE (targ) == ADDR_EXPR)
5835 targ = TREE_OPERAND (targ, 0);
5836 if (!same_type_ignoring_top_level_qualifiers_p
5837 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5846 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5848 if (TREE_CODE (arg) == TARGET_EXPR
5849 && TARGET_EXPR_LIST_INIT_P (arg))
5851 /* Copy-list-initialization doesn't require the copy constructor
5854 /* [class.copy]: the copy constructor is implicitly defined even if
5855 the implementation elided its use. */
5856 else if (TYPE_HAS_COMPLEX_COPY_CTOR (DECL_CONTEXT (fn))
5860 already_used = true;
5863 /* If we're creating a temp and we already have one, don't create a
5864 new one. If we're not creating a temp but we get one, use
5865 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5866 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5867 temp or an INIT_EXPR otherwise. */
5868 fa = (cand->first_arg != NULL_TREE
5870 : VEC_index (tree, args, 0));
5871 if (integer_zerop (fa))
5873 if (TREE_CODE (arg) == TARGET_EXPR)
5875 else if (TYPE_HAS_TRIVIAL_COPY_CTOR (DECL_CONTEXT (fn))
5877 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5879 else if (TREE_CODE (arg) == TARGET_EXPR
5880 || (TYPE_HAS_TRIVIAL_COPY_CTOR (DECL_CONTEXT (fn))
5881 && !move_fn_p (fn)))
5883 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
5886 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5890 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5892 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (DECL_CONTEXT (fn)))
5894 tree to = stabilize_reference
5895 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
5896 tree type = TREE_TYPE (to);
5897 tree as_base = CLASSTYPE_AS_BASE (type);
5898 tree arg = argarray[1];
5900 if (is_really_empty_class (type))
5902 /* Avoid copying empty classes. */
5903 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
5904 TREE_NO_WARNING (val) = 1;
5905 val = build2 (COMPOUND_EXPR, type, val, to);
5906 TREE_NO_WARNING (val) = 1;
5908 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5910 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5911 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5915 /* We must only copy the non-tail padding parts.
5916 Use __builtin_memcpy for the bitwise copy.
5917 FIXME fix 22488 so we can go back to using MODIFY_EXPR
5918 instead of an explicit call to memcpy. */
5920 tree arg0, arg1, arg2, t;
5921 tree test = NULL_TREE;
5923 arg2 = TYPE_SIZE_UNIT (as_base);
5925 arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5927 if (!can_trust_pointer_alignment ())
5929 /* If we can't be sure about pointer alignment, a call
5930 to __builtin_memcpy is expanded as a call to memcpy, which
5931 is invalid with identical args. Otherwise it is
5932 expanded as a block move, which should be safe. */
5933 arg0 = save_expr (arg0);
5934 arg1 = save_expr (arg1);
5935 test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5937 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5938 t = build_call_n (t, 3, arg0, arg1, arg2);
5940 t = convert (TREE_TYPE (arg0), t);
5942 t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5943 val = cp_build_indirect_ref (t, RO_NULL, complain);
5944 TREE_NO_WARNING (val) = 1;
5953 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5956 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5959 gcc_assert (binfo && binfo != error_mark_node);
5961 /* Warn about deprecated virtual functions now, since we're about
5962 to throw away the decl. */
5963 if (TREE_DEPRECATED (fn))
5964 warn_deprecated_use (fn, NULL_TREE);
5966 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5967 if (TREE_SIDE_EFFECTS (argarray[0]))
5968 argarray[0] = save_expr (argarray[0]);
5969 t = build_pointer_type (TREE_TYPE (fn));
5970 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5971 fn = build_java_interface_fn_ref (fn, argarray[0]);
5973 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5977 fn = build_addr_func (fn);
5979 return build_cxx_call (fn, nargs, argarray);
5982 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5983 This function performs no overload resolution, conversion, or other
5984 high-level operations. */
5987 build_cxx_call (tree fn, int nargs, tree *argarray)
5991 fn = build_call_a (fn, nargs, argarray);
5993 /* If this call might throw an exception, note that fact. */
5994 fndecl = get_callee_fndecl (fn);
5995 if ((!fndecl || !TREE_NOTHROW (fndecl))
5996 && at_function_scope_p ()
5998 cp_function_chain->can_throw = 1;
6000 /* Check that arguments to builtin functions match the expectations. */
6002 && DECL_BUILT_IN (fndecl)
6003 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6004 && !check_builtin_function_arguments (fndecl, nargs, argarray))
6005 return error_mark_node;
6007 /* Some built-in function calls will be evaluated at compile-time in
6009 fn = fold_if_not_in_template (fn);
6011 if (VOID_TYPE_P (TREE_TYPE (fn)))
6014 fn = require_complete_type (fn);
6015 if (fn == error_mark_node)
6016 return error_mark_node;
6018 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
6019 fn = build_cplus_new (TREE_TYPE (fn), fn);
6020 return convert_from_reference (fn);
6023 static GTY(()) tree java_iface_lookup_fn;
6025 /* Make an expression which yields the address of the Java interface
6026 method FN. This is achieved by generating a call to libjava's
6027 _Jv_LookupInterfaceMethodIdx(). */
6030 build_java_interface_fn_ref (tree fn, tree instance)
6032 tree lookup_fn, method, idx;
6033 tree klass_ref, iface, iface_ref;
6036 if (!java_iface_lookup_fn)
6038 tree ftype = build_function_type_list (ptr_type_node,
6039 ptr_type_node, ptr_type_node,
6040 java_int_type_node, NULL_TREE);
6041 java_iface_lookup_fn
6042 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype,
6043 0, NOT_BUILT_IN, NULL, NULL_TREE);
6046 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
6047 This is the first entry in the vtable. */
6048 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
6049 tf_warning_or_error),
6052 /* Get the java.lang.Class pointer for the interface being called. */
6053 iface = DECL_CONTEXT (fn);
6054 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
6055 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
6056 || DECL_CONTEXT (iface_ref) != iface)
6058 error ("could not find class$ field in java interface type %qT",
6060 return error_mark_node;
6062 iface_ref = build_address (iface_ref);
6063 iface_ref = convert (build_pointer_type (iface), iface_ref);
6065 /* Determine the itable index of FN. */
6067 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
6069 if (!DECL_VIRTUAL_P (method))
6075 idx = build_int_cst (NULL_TREE, i);
6077 lookup_fn = build1 (ADDR_EXPR,
6078 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6079 java_iface_lookup_fn);
6080 return build_call_nary (ptr_type_node, lookup_fn,
6081 3, klass_ref, iface_ref, idx);
6084 /* Returns the value to use for the in-charge parameter when making a
6085 call to a function with the indicated NAME.
6087 FIXME:Can't we find a neater way to do this mapping? */
6090 in_charge_arg_for_name (tree name)
6092 if (name == base_ctor_identifier
6093 || name == base_dtor_identifier)
6094 return integer_zero_node;
6095 else if (name == complete_ctor_identifier)
6096 return integer_one_node;
6097 else if (name == complete_dtor_identifier)
6098 return integer_two_node;
6099 else if (name == deleting_dtor_identifier)
6100 return integer_three_node;
6102 /* This function should only be called with one of the names listed
6108 /* Build a call to a constructor, destructor, or an assignment
6109 operator for INSTANCE, an expression with class type. NAME
6110 indicates the special member function to call; *ARGS are the
6111 arguments. ARGS may be NULL. This may change ARGS. BINFO
6112 indicates the base of INSTANCE that is to be passed as the `this'
6113 parameter to the member function called.
6115 FLAGS are the LOOKUP_* flags to use when processing the call.
6117 If NAME indicates a complete object constructor, INSTANCE may be
6118 NULL_TREE. In this case, the caller will call build_cplus_new to
6119 store the newly constructed object into a VAR_DECL. */
6122 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6123 tree binfo, int flags, tsubst_flags_t complain)
6126 /* The type of the subobject to be constructed or destroyed. */
6128 VEC(tree,gc) *allocated = NULL;
6131 gcc_assert (name == complete_ctor_identifier
6132 || name == base_ctor_identifier
6133 || name == complete_dtor_identifier
6134 || name == base_dtor_identifier
6135 || name == deleting_dtor_identifier
6136 || name == ansi_assopname (NOP_EXPR));
6139 /* Resolve the name. */
6140 if (!complete_type_or_else (binfo, NULL_TREE))
6141 return error_mark_node;
6143 binfo = TYPE_BINFO (binfo);
6146 gcc_assert (binfo != NULL_TREE);
6148 class_type = BINFO_TYPE (binfo);
6150 /* Handle the special case where INSTANCE is NULL_TREE. */
6151 if (name == complete_ctor_identifier && !instance)
6153 instance = build_int_cst (build_pointer_type (class_type), 0);
6154 instance = build1 (INDIRECT_REF, class_type, instance);
6158 if (name == complete_dtor_identifier
6159 || name == base_dtor_identifier
6160 || name == deleting_dtor_identifier)
6161 gcc_assert (args == NULL || VEC_empty (tree, *args));
6163 /* Convert to the base class, if necessary. */
6164 if (!same_type_ignoring_top_level_qualifiers_p
6165 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6167 if (name != ansi_assopname (NOP_EXPR))
6168 /* For constructors and destructors, either the base is
6169 non-virtual, or it is virtual but we are doing the
6170 conversion from a constructor or destructor for the
6171 complete object. In either case, we can convert
6173 instance = convert_to_base_statically (instance, binfo);
6175 /* However, for assignment operators, we must convert
6176 dynamically if the base is virtual. */
6177 instance = build_base_path (PLUS_EXPR, instance,
6178 binfo, /*nonnull=*/1);
6182 gcc_assert (instance != NULL_TREE);
6184 fns = lookup_fnfields (binfo, name, 1);
6186 /* When making a call to a constructor or destructor for a subobject
6187 that uses virtual base classes, pass down a pointer to a VTT for
6189 if ((name == base_ctor_identifier
6190 || name == base_dtor_identifier)
6191 && CLASSTYPE_VBASECLASSES (class_type))
6196 /* If the current function is a complete object constructor
6197 or destructor, then we fetch the VTT directly.
6198 Otherwise, we look it up using the VTT we were given. */
6199 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6200 vtt = decay_conversion (vtt);
6201 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6202 build2 (EQ_EXPR, boolean_type_node,
6203 current_in_charge_parm, integer_zero_node),
6206 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6207 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6208 BINFO_SUBVTT_INDEX (binfo));
6212 allocated = make_tree_vector ();
6216 VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6219 ret = build_new_method_call (instance, fns, args,
6220 TYPE_BINFO (BINFO_TYPE (binfo)),
6224 if (allocated != NULL)
6225 release_tree_vector (allocated);
6230 /* Return the NAME, as a C string. The NAME indicates a function that
6231 is a member of TYPE. *FREE_P is set to true if the caller must
6232 free the memory returned.
6234 Rather than go through all of this, we should simply set the names
6235 of constructors and destructors appropriately, and dispense with
6236 ctor_identifier, dtor_identifier, etc. */
6239 name_as_c_string (tree name, tree type, bool *free_p)
6243 /* Assume that we will not allocate memory. */
6245 /* Constructors and destructors are special. */
6246 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6249 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6250 /* For a destructor, add the '~'. */
6251 if (name == complete_dtor_identifier
6252 || name == base_dtor_identifier
6253 || name == deleting_dtor_identifier)
6255 pretty_name = concat ("~", pretty_name, NULL);
6256 /* Remember that we need to free the memory allocated. */
6260 else if (IDENTIFIER_TYPENAME_P (name))
6262 pretty_name = concat ("operator ",
6263 type_as_string_translate (TREE_TYPE (name),
6264 TFF_PLAIN_IDENTIFIER),
6266 /* Remember that we need to free the memory allocated. */
6270 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6275 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
6276 be set, upon return, to the function called. ARGS may be NULL.
6277 This may change ARGS. */
6280 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
6281 tree conversion_path, int flags,
6282 tree *fn_p, tsubst_flags_t complain)
6284 struct z_candidate *candidates = 0, *cand;
6285 tree explicit_targs = NULL_TREE;
6286 tree basetype = NULL_TREE;
6289 tree first_mem_arg = NULL_TREE;
6292 bool skip_first_for_error;
6293 VEC(tree,gc) *user_args;
6296 int template_only = 0;
6300 VEC(tree,gc) *orig_args = NULL;
6303 gcc_assert (instance != NULL_TREE);
6305 /* We don't know what function we're going to call, yet. */
6309 if (error_operand_p (instance)
6310 || !fns || error_operand_p (fns))
6311 return error_mark_node;
6313 if (!BASELINK_P (fns))
6315 if (complain & tf_error)
6316 error ("call to non-function %qD", fns);
6317 return error_mark_node;
6320 orig_instance = instance;
6323 /* Dismantle the baselink to collect all the information we need. */
6324 if (!conversion_path)
6325 conversion_path = BASELINK_BINFO (fns);
6326 access_binfo = BASELINK_ACCESS_BINFO (fns);
6327 optype = BASELINK_OPTYPE (fns);
6328 fns = BASELINK_FUNCTIONS (fns);
6329 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6331 explicit_targs = TREE_OPERAND (fns, 1);
6332 fns = TREE_OPERAND (fns, 0);
6335 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6336 || TREE_CODE (fns) == TEMPLATE_DECL
6337 || TREE_CODE (fns) == OVERLOAD);
6338 fn = get_first_fn (fns);
6339 name = DECL_NAME (fn);
6341 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6342 gcc_assert (CLASS_TYPE_P (basetype));
6344 if (processing_template_decl)
6346 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6347 instance = build_non_dependent_expr (instance);
6349 make_args_non_dependent (*args);
6352 user_args = args == NULL ? NULL : *args;
6353 /* Under DR 147 A::A() is an invalid constructor call,
6354 not a functional cast. */
6355 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
6357 if (! (complain & tf_error))
6358 return error_mark_node;
6360 permerror (input_location,
6361 "cannot call constructor %<%T::%D%> directly",
6363 permerror (input_location, " for a function-style cast, remove the "
6364 "redundant %<::%D%>", name);
6365 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
6370 /* Figure out whether to skip the first argument for the error
6371 message we will display to users if an error occurs. We don't
6372 want to display any compiler-generated arguments. The "this"
6373 pointer hasn't been added yet. However, we must remove the VTT
6374 pointer if this is a call to a base-class constructor or
6376 skip_first_for_error = false;
6377 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6379 /* Callers should explicitly indicate whether they want to construct
6380 the complete object or just the part without virtual bases. */
6381 gcc_assert (name != ctor_identifier);
6382 /* Similarly for destructors. */
6383 gcc_assert (name != dtor_identifier);
6384 /* Remove the VTT pointer, if present. */
6385 if ((name == base_ctor_identifier || name == base_dtor_identifier)
6386 && CLASSTYPE_VBASECLASSES (basetype))
6387 skip_first_for_error = true;
6390 /* Process the argument list. */
6391 if (args != NULL && *args != NULL)
6393 *args = resolve_args (*args);
6395 return error_mark_node;
6398 instance_ptr = build_this (instance);
6400 /* It's OK to call destructors and constructors on cv-qualified objects.
6401 Therefore, convert the INSTANCE_PTR to the unqualified type, if
6403 if (DECL_DESTRUCTOR_P (fn)
6404 || DECL_CONSTRUCTOR_P (fn))
6406 tree type = build_pointer_type (basetype);
6407 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6408 instance_ptr = build_nop (type, instance_ptr);
6410 if (DECL_DESTRUCTOR_P (fn))
6411 name = complete_dtor_identifier;
6413 first_mem_arg = instance_ptr;
6415 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6416 p = conversion_obstack_alloc (0);
6418 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6419 initializer, not T({ }). */
6420 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6421 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6422 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
6424 gcc_assert (VEC_length (tree, *args) == 1
6425 && !(flags & LOOKUP_ONLYCONVERTING));
6427 add_list_candidates (fns, first_mem_arg, VEC_index (tree, *args, 0),
6428 basetype, explicit_targs, template_only,
6429 conversion_path, access_binfo, flags, &candidates);
6433 add_candidates (fns, first_mem_arg, user_args, optype,
6434 explicit_targs, template_only, conversion_path,
6435 access_binfo, flags, &candidates);
6437 any_viable_p = false;
6438 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6442 if (complain & tf_error)
6444 if (!COMPLETE_TYPE_P (basetype))
6445 cxx_incomplete_type_error (instance_ptr, basetype);
6447 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
6448 basetype, optype, build_tree_list_vec (user_args),
6449 TREE_TYPE (TREE_TYPE (instance_ptr)));
6456 pretty_name = name_as_c_string (name, basetype, &free_p);
6457 arglist = build_tree_list_vec (user_args);
6458 if (skip_first_for_error)
6459 arglist = TREE_CHAIN (arglist);
6460 error ("no matching function for call to %<%T::%s(%A)%#V%>",
6461 basetype, pretty_name, arglist,
6462 TREE_TYPE (TREE_TYPE (instance_ptr)));
6466 print_z_candidates (candidates);
6468 call = error_mark_node;
6472 cand = tourney (candidates);
6479 if (complain & tf_error)
6481 pretty_name = name_as_c_string (name, basetype, &free_p);
6482 arglist = build_tree_list_vec (user_args);
6483 if (skip_first_for_error)
6484 arglist = TREE_CHAIN (arglist);
6485 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6487 print_z_candidates (candidates);
6491 call = error_mark_node;
6497 if (!(flags & LOOKUP_NONVIRTUAL)
6498 && DECL_PURE_VIRTUAL_P (fn)
6499 && instance == current_class_ref
6500 && (DECL_CONSTRUCTOR_P (current_function_decl)
6501 || DECL_DESTRUCTOR_P (current_function_decl))
6502 && (complain & tf_warning))
6503 /* This is not an error, it is runtime undefined
6505 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6506 "pure virtual %q#D called from constructor"
6507 : "pure virtual %q#D called from destructor"),
6510 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6511 && is_dummy_object (instance_ptr))
6513 if (complain & tf_error)
6514 error ("cannot call member function %qD without object",
6516 call = error_mark_node;
6520 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6521 && resolves_to_fixed_type_p (instance, 0))
6522 flags |= LOOKUP_NONVIRTUAL;
6523 /* Now we know what function is being called. */
6526 /* Build the actual CALL_EXPR. */
6527 call = build_over_call (cand, flags, complain);
6528 /* In an expression of the form `a->f()' where `f' turns
6529 out to be a static member function, `a' is
6530 none-the-less evaluated. */
6531 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6532 && !is_dummy_object (instance_ptr)
6533 && TREE_SIDE_EFFECTS (instance_ptr))
6534 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6535 instance_ptr, call);
6536 else if (call != error_mark_node
6537 && DECL_DESTRUCTOR_P (cand->fn)
6538 && !VOID_TYPE_P (TREE_TYPE (call)))
6539 /* An explicit call of the form "x->~X()" has type
6540 "void". However, on platforms where destructors
6541 return "this" (i.e., those where
6542 targetm.cxx.cdtor_returns_this is true), such calls
6543 will appear to have a return value of pointer type
6544 to the low-level call machinery. We do not want to
6545 change the low-level machinery, since we want to be
6546 able to optimize "delete f()" on such platforms as
6547 "operator delete(~X(f()))" (rather than generating
6548 "t = f(), ~X(t), operator delete (t)"). */
6549 call = build_nop (void_type_node, call);
6554 if (processing_template_decl && call != error_mark_node)
6556 bool cast_to_void = false;
6558 if (TREE_CODE (call) == COMPOUND_EXPR)
6559 call = TREE_OPERAND (call, 1);
6560 else if (TREE_CODE (call) == NOP_EXPR)
6562 cast_to_void = true;
6563 call = TREE_OPERAND (call, 0);
6565 if (TREE_CODE (call) == INDIRECT_REF)
6566 call = TREE_OPERAND (call, 0);
6567 call = (build_min_non_dep_call_vec
6569 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6570 orig_instance, orig_fns, NULL_TREE),
6572 call = convert_from_reference (call);
6574 call = build_nop (void_type_node, call);
6577 /* Free all the conversions we allocated. */
6578 obstack_free (&conversion_obstack, p);
6580 if (orig_args != NULL)
6581 release_tree_vector (orig_args);
6586 /* Returns true iff standard conversion sequence ICS1 is a proper
6587 subsequence of ICS2. */
6590 is_subseq (conversion *ics1, conversion *ics2)
6592 /* We can assume that a conversion of the same code
6593 between the same types indicates a subsequence since we only get
6594 here if the types we are converting from are the same. */
6596 while (ics1->kind == ck_rvalue
6597 || ics1->kind == ck_lvalue)
6598 ics1 = ics1->u.next;
6602 while (ics2->kind == ck_rvalue
6603 || ics2->kind == ck_lvalue)
6604 ics2 = ics2->u.next;
6606 if (ics2->kind == ck_user
6607 || ics2->kind == ck_ambig
6608 || ics2->kind == ck_aggr
6609 || ics2->kind == ck_list
6610 || ics2->kind == ck_identity)
6611 /* At this point, ICS1 cannot be a proper subsequence of
6612 ICS2. We can get a USER_CONV when we are comparing the
6613 second standard conversion sequence of two user conversion
6617 ics2 = ics2->u.next;
6619 if (ics2->kind == ics1->kind
6620 && same_type_p (ics2->type, ics1->type)
6621 && same_type_p (ics2->u.next->type,
6622 ics1->u.next->type))
6627 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
6628 be any _TYPE nodes. */
6631 is_properly_derived_from (tree derived, tree base)
6633 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6636 /* We only allow proper derivation here. The DERIVED_FROM_P macro
6637 considers every class derived from itself. */
6638 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6639 && DERIVED_FROM_P (base, derived));
6642 /* We build the ICS for an implicit object parameter as a pointer
6643 conversion sequence. However, such a sequence should be compared
6644 as if it were a reference conversion sequence. If ICS is the
6645 implicit conversion sequence for an implicit object parameter,
6646 modify it accordingly. */
6649 maybe_handle_implicit_object (conversion **ics)
6653 /* [over.match.funcs]
6655 For non-static member functions, the type of the
6656 implicit object parameter is "reference to cv X"
6657 where X is the class of which the function is a
6658 member and cv is the cv-qualification on the member
6659 function declaration. */
6660 conversion *t = *ics;
6661 tree reference_type;
6663 /* The `this' parameter is a pointer to a class type. Make the
6664 implicit conversion talk about a reference to that same class
6666 reference_type = TREE_TYPE (t->type);
6667 reference_type = build_reference_type (reference_type);
6669 if (t->kind == ck_qual)
6671 if (t->kind == ck_ptr)
6673 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6674 t = direct_reference_binding (reference_type, t);
6676 t->rvaluedness_matches_p = 0;
6681 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6682 and return the initial reference binding conversion. Otherwise,
6683 leave *ICS unchanged and return NULL. */
6686 maybe_handle_ref_bind (conversion **ics)
6688 if ((*ics)->kind == ck_ref_bind)
6690 conversion *old_ics = *ics;
6691 *ics = old_ics->u.next;
6692 (*ics)->user_conv_p = old_ics->user_conv_p;
6699 /* Compare two implicit conversion sequences according to the rules set out in
6700 [over.ics.rank]. Return values:
6702 1: ics1 is better than ics2
6703 -1: ics2 is better than ics1
6704 0: ics1 and ics2 are indistinguishable */
6707 compare_ics (conversion *ics1, conversion *ics2)
6713 tree deref_from_type1 = NULL_TREE;
6714 tree deref_from_type2 = NULL_TREE;
6715 tree deref_to_type1 = NULL_TREE;
6716 tree deref_to_type2 = NULL_TREE;
6717 conversion_rank rank1, rank2;
6719 /* REF_BINDING is nonzero if the result of the conversion sequence
6720 is a reference type. In that case REF_CONV is the reference
6721 binding conversion. */
6722 conversion *ref_conv1;
6723 conversion *ref_conv2;
6725 /* Handle implicit object parameters. */
6726 maybe_handle_implicit_object (&ics1);
6727 maybe_handle_implicit_object (&ics2);
6729 /* Handle reference parameters. */
6730 ref_conv1 = maybe_handle_ref_bind (&ics1);
6731 ref_conv2 = maybe_handle_ref_bind (&ics2);
6733 /* List-initialization sequence L1 is a better conversion sequence than
6734 list-initialization sequence L2 if L1 converts to
6735 std::initializer_list<X> for some X and L2 does not. */
6736 if (ics1->kind == ck_list && ics2->kind != ck_list)
6738 if (ics2->kind == ck_list && ics1->kind != ck_list)
6743 When comparing the basic forms of implicit conversion sequences (as
6744 defined in _over.best.ics_)
6746 --a standard conversion sequence (_over.ics.scs_) is a better
6747 conversion sequence than a user-defined conversion sequence
6748 or an ellipsis conversion sequence, and
6750 --a user-defined conversion sequence (_over.ics.user_) is a
6751 better conversion sequence than an ellipsis conversion sequence
6752 (_over.ics.ellipsis_). */
6753 rank1 = CONVERSION_RANK (ics1);
6754 rank2 = CONVERSION_RANK (ics2);
6758 else if (rank1 < rank2)
6761 if (rank1 == cr_bad)
6763 /* Both ICS are bad. We try to make a decision based on what would
6764 have happened if they'd been good. This is not an extension,
6765 we'll still give an error when we build up the call; this just
6766 helps us give a more helpful error message. */
6767 rank1 = BAD_CONVERSION_RANK (ics1);
6768 rank2 = BAD_CONVERSION_RANK (ics2);
6772 else if (rank1 < rank2)
6775 /* We couldn't make up our minds; try to figure it out below. */
6778 if (ics1->ellipsis_p || ics1->kind == ck_list)
6779 /* Both conversions are ellipsis conversions or both are building a
6780 std::initializer_list. */
6783 /* User-defined conversion sequence U1 is a better conversion sequence
6784 than another user-defined conversion sequence U2 if they contain the
6785 same user-defined conversion operator or constructor and if the sec-
6786 ond standard conversion sequence of U1 is better than the second
6787 standard conversion sequence of U2. */
6789 if (ics1->user_conv_p)
6794 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
6795 if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6797 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
6798 if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6801 if (t1->kind != t2->kind)
6803 else if (t1->kind == ck_user)
6805 if (t1->cand->fn != t2->cand->fn)
6810 /* For ambiguous or aggregate conversions, use the target type as
6811 a proxy for the conversion function. */
6812 if (!same_type_ignoring_top_level_qualifiers_p (t1->type, t2->type))
6816 /* We can just fall through here, after setting up
6817 FROM_TYPE1 and FROM_TYPE2. */
6818 from_type1 = t1->type;
6819 from_type2 = t2->type;
6826 /* We're dealing with two standard conversion sequences.
6830 Standard conversion sequence S1 is a better conversion
6831 sequence than standard conversion sequence S2 if
6833 --S1 is a proper subsequence of S2 (comparing the conversion
6834 sequences in the canonical form defined by _over.ics.scs_,
6835 excluding any Lvalue Transformation; the identity
6836 conversion sequence is considered to be a subsequence of
6837 any non-identity conversion sequence */
6840 while (t1->kind != ck_identity)
6842 from_type1 = t1->type;
6845 while (t2->kind != ck_identity)
6847 from_type2 = t2->type;
6850 /* One sequence can only be a subsequence of the other if they start with
6851 the same type. They can start with different types when comparing the
6852 second standard conversion sequence in two user-defined conversion
6854 if (same_type_p (from_type1, from_type2))
6856 if (is_subseq (ics1, ics2))
6858 if (is_subseq (ics2, ics1))
6866 --the rank of S1 is better than the rank of S2 (by the rules
6869 Standard conversion sequences are ordered by their ranks: an Exact
6870 Match is a better conversion than a Promotion, which is a better
6871 conversion than a Conversion.
6873 Two conversion sequences with the same rank are indistinguishable
6874 unless one of the following rules applies:
6876 --A conversion that does not a convert a pointer, pointer to member,
6877 or std::nullptr_t to bool is better than one that does.
6879 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6880 so that we do not have to check it explicitly. */
6881 if (ics1->rank < ics2->rank)
6883 else if (ics2->rank < ics1->rank)
6886 to_type1 = ics1->type;
6887 to_type2 = ics2->type;
6889 /* A conversion from scalar arithmetic type to complex is worse than a
6890 conversion between scalar arithmetic types. */
6891 if (same_type_p (from_type1, from_type2)
6892 && ARITHMETIC_TYPE_P (from_type1)
6893 && ARITHMETIC_TYPE_P (to_type1)
6894 && ARITHMETIC_TYPE_P (to_type2)
6895 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6896 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6898 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6904 if (TYPE_PTR_P (from_type1)
6905 && TYPE_PTR_P (from_type2)
6906 && TYPE_PTR_P (to_type1)
6907 && TYPE_PTR_P (to_type2))
6909 deref_from_type1 = TREE_TYPE (from_type1);
6910 deref_from_type2 = TREE_TYPE (from_type2);
6911 deref_to_type1 = TREE_TYPE (to_type1);
6912 deref_to_type2 = TREE_TYPE (to_type2);
6914 /* The rules for pointers to members A::* are just like the rules
6915 for pointers A*, except opposite: if B is derived from A then
6916 A::* converts to B::*, not vice versa. For that reason, we
6917 switch the from_ and to_ variables here. */
6918 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6919 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6920 || (TYPE_PTRMEMFUNC_P (from_type1)
6921 && TYPE_PTRMEMFUNC_P (from_type2)
6922 && TYPE_PTRMEMFUNC_P (to_type1)
6923 && TYPE_PTRMEMFUNC_P (to_type2)))
6925 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6926 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6927 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6928 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6931 if (deref_from_type1 != NULL_TREE
6932 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6933 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6935 /* This was one of the pointer or pointer-like conversions.
6939 --If class B is derived directly or indirectly from class A,
6940 conversion of B* to A* is better than conversion of B* to
6941 void*, and conversion of A* to void* is better than
6942 conversion of B* to void*. */
6943 if (TREE_CODE (deref_to_type1) == VOID_TYPE
6944 && TREE_CODE (deref_to_type2) == VOID_TYPE)
6946 if (is_properly_derived_from (deref_from_type1,
6949 else if (is_properly_derived_from (deref_from_type2,
6953 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6954 || TREE_CODE (deref_to_type2) == VOID_TYPE)
6956 if (same_type_p (deref_from_type1, deref_from_type2))
6958 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6960 if (is_properly_derived_from (deref_from_type1,
6964 /* We know that DEREF_TO_TYPE1 is `void' here. */
6965 else if (is_properly_derived_from (deref_from_type1,
6970 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6971 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6975 --If class B is derived directly or indirectly from class A
6976 and class C is derived directly or indirectly from B,
6978 --conversion of C* to B* is better than conversion of C* to
6981 --conversion of B* to A* is better than conversion of C* to
6983 if (same_type_p (deref_from_type1, deref_from_type2))
6985 if (is_properly_derived_from (deref_to_type1,
6988 else if (is_properly_derived_from (deref_to_type2,
6992 else if (same_type_p (deref_to_type1, deref_to_type2))
6994 if (is_properly_derived_from (deref_from_type2,
6997 else if (is_properly_derived_from (deref_from_type1,
7003 else if (CLASS_TYPE_P (non_reference (from_type1))
7004 && same_type_p (from_type1, from_type2))
7006 tree from = non_reference (from_type1);
7010 --binding of an expression of type C to a reference of type
7011 B& is better than binding an expression of type C to a
7012 reference of type A&
7014 --conversion of C to B is better than conversion of C to A, */
7015 if (is_properly_derived_from (from, to_type1)
7016 && is_properly_derived_from (from, to_type2))
7018 if (is_properly_derived_from (to_type1, to_type2))
7020 else if (is_properly_derived_from (to_type2, to_type1))
7024 else if (CLASS_TYPE_P (non_reference (to_type1))
7025 && same_type_p (to_type1, to_type2))
7027 tree to = non_reference (to_type1);
7031 --binding of an expression of type B to a reference of type
7032 A& is better than binding an expression of type C to a
7033 reference of type A&,
7035 --conversion of B to A is better than conversion of C to A */
7036 if (is_properly_derived_from (from_type1, to)
7037 && is_properly_derived_from (from_type2, to))
7039 if (is_properly_derived_from (from_type2, from_type1))
7041 else if (is_properly_derived_from (from_type1, from_type2))
7048 --S1 and S2 differ only in their qualification conversion and yield
7049 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
7050 qualification signature of type T1 is a proper subset of the cv-
7051 qualification signature of type T2 */
7052 if (ics1->kind == ck_qual
7053 && ics2->kind == ck_qual
7054 && same_type_p (from_type1, from_type2))
7056 int result = comp_cv_qual_signature (to_type1, to_type2);
7063 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
7064 to an implicit object parameter, and either S1 binds an lvalue reference
7065 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
7066 reference to an rvalue and S2 binds an lvalue reference
7067 (C++0x draft standard, 13.3.3.2)
7069 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
7070 types to which the references refer are the same type except for
7071 top-level cv-qualifiers, and the type to which the reference
7072 initialized by S2 refers is more cv-qualified than the type to
7073 which the reference initialized by S1 refers */
7075 if (ref_conv1 && ref_conv2)
7077 if (!ref_conv1->this_p && !ref_conv2->this_p
7078 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7079 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7081 if (ref_conv1->rvaluedness_matches_p)
7083 if (ref_conv2->rvaluedness_matches_p)
7087 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7088 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7089 TREE_TYPE (ref_conv1->type));
7092 /* Neither conversion sequence is better than the other. */
7096 /* The source type for this standard conversion sequence. */
7099 source_type (conversion *t)
7101 for (;; t = t->u.next)
7103 if (t->kind == ck_user
7104 || t->kind == ck_ambig
7105 || t->kind == ck_identity)
7111 /* Note a warning about preferring WINNER to LOSER. We do this by storing
7112 a pointer to LOSER and re-running joust to produce the warning if WINNER
7113 is actually used. */
7116 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7118 candidate_warning *cw = (candidate_warning *)
7119 conversion_obstack_alloc (sizeof (candidate_warning));
7121 cw->next = winner->warnings;
7122 winner->warnings = cw;
7125 /* Compare two candidates for overloading as described in
7126 [over.match.best]. Return values:
7128 1: cand1 is better than cand2
7129 -1: cand2 is better than cand1
7130 0: cand1 and cand2 are indistinguishable */
7133 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7136 int off1 = 0, off2 = 0;
7140 /* Candidates that involve bad conversions are always worse than those
7142 if (cand1->viable > cand2->viable)
7144 if (cand1->viable < cand2->viable)
7147 /* If we have two pseudo-candidates for conversions to the same type,
7148 or two candidates for the same function, arbitrarily pick one. */
7149 if (cand1->fn == cand2->fn
7150 && (IS_TYPE_OR_DECL_P (cand1->fn)))
7153 /* a viable function F1
7154 is defined to be a better function than another viable function F2 if
7155 for all arguments i, ICSi(F1) is not a worse conversion sequence than
7156 ICSi(F2), and then */
7158 /* for some argument j, ICSj(F1) is a better conversion sequence than
7161 /* For comparing static and non-static member functions, we ignore
7162 the implicit object parameter of the non-static function. The
7163 standard says to pretend that the static function has an object
7164 parm, but that won't work with operator overloading. */
7165 len = cand1->num_convs;
7166 if (len != cand2->num_convs)
7168 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7169 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7171 gcc_assert (static_1 != static_2);
7182 for (i = 0; i < len; ++i)
7184 conversion *t1 = cand1->convs[i + off1];
7185 conversion *t2 = cand2->convs[i + off2];
7186 int comp = compare_ics (t1, t2);
7191 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7192 == cr_std + cr_promotion)
7193 && t1->kind == ck_std
7194 && t2->kind == ck_std
7195 && TREE_CODE (t1->type) == INTEGER_TYPE
7196 && TREE_CODE (t2->type) == INTEGER_TYPE
7197 && (TYPE_PRECISION (t1->type)
7198 == TYPE_PRECISION (t2->type))
7199 && (TYPE_UNSIGNED (t1->u.next->type)
7200 || (TREE_CODE (t1->u.next->type)
7203 tree type = t1->u.next->type;
7205 struct z_candidate *w, *l;
7207 type1 = t1->type, type2 = t2->type,
7208 w = cand1, l = cand2;
7210 type1 = t2->type, type2 = t1->type,
7211 w = cand2, l = cand1;
7215 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7216 type, type1, type2);
7217 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
7223 if (winner && comp != winner)
7232 /* warn about confusing overload resolution for user-defined conversions,
7233 either between a constructor and a conversion op, or between two
7235 if (winner && warn_conversion && cand1->second_conv
7236 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7237 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7239 struct z_candidate *w, *l;
7240 bool give_warning = false;
7243 w = cand1, l = cand2;
7245 w = cand2, l = cand1;
7247 /* We don't want to complain about `X::operator T1 ()'
7248 beating `X::operator T2 () const', when T2 is a no less
7249 cv-qualified version of T1. */
7250 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7251 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7253 tree t = TREE_TYPE (TREE_TYPE (l->fn));
7254 tree f = TREE_TYPE (TREE_TYPE (w->fn));
7256 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7261 if (!comp_ptr_ttypes (t, f))
7262 give_warning = true;
7265 give_warning = true;
7271 tree source = source_type (w->convs[0]);
7272 if (! DECL_CONSTRUCTOR_P (w->fn))
7273 source = TREE_TYPE (source);
7274 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7275 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
7276 source, w->second_conv->type))
7278 inform (input_location, " because conversion sequence for the argument is better");
7289 F1 is a non-template function and F2 is a template function
7292 if (!cand1->template_decl && cand2->template_decl)
7294 else if (cand1->template_decl && !cand2->template_decl)
7298 F1 and F2 are template functions and the function template for F1 is
7299 more specialized than the template for F2 according to the partial
7302 if (cand1->template_decl && cand2->template_decl)
7304 winner = more_specialized_fn
7305 (TI_TEMPLATE (cand1->template_decl),
7306 TI_TEMPLATE (cand2->template_decl),
7307 /* [temp.func.order]: The presence of unused ellipsis and default
7308 arguments has no effect on the partial ordering of function
7309 templates. add_function_candidate() will not have
7310 counted the "this" argument for constructors. */
7311 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
7317 the context is an initialization by user-defined conversion (see
7318 _dcl.init_ and _over.match.user_) and the standard conversion
7319 sequence from the return type of F1 to the destination type (i.e.,
7320 the type of the entity being initialized) is a better conversion
7321 sequence than the standard conversion sequence from the return type
7322 of F2 to the destination type. */
7324 if (cand1->second_conv)
7326 winner = compare_ics (cand1->second_conv, cand2->second_conv);
7331 /* Check whether we can discard a builtin candidate, either because we
7332 have two identical ones or matching builtin and non-builtin candidates.
7334 (Pedantically in the latter case the builtin which matched the user
7335 function should not be added to the overload set, but we spot it here.
7338 ... the builtin candidates include ...
7339 - do not have the same parameter type list as any non-template
7340 non-member candidate. */
7342 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7343 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7345 for (i = 0; i < len; ++i)
7346 if (!same_type_p (cand1->convs[i]->type,
7347 cand2->convs[i]->type))
7349 if (i == cand1->num_convs)
7351 if (cand1->fn == cand2->fn)
7352 /* Two built-in candidates; arbitrarily pick one. */
7354 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7355 /* cand1 is built-in; prefer cand2. */
7358 /* cand2 is built-in; prefer cand1. */
7363 /* If the two function declarations represent the same function (this can
7364 happen with declarations in multiple scopes and arg-dependent lookup),
7365 arbitrarily choose one. But first make sure the default args we're
7367 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7368 && equal_functions (cand1->fn, cand2->fn))
7370 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7371 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7373 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7375 for (i = 0; i < len; ++i)
7377 /* Don't crash if the fn is variadic. */
7380 parms1 = TREE_CHAIN (parms1);
7381 parms2 = TREE_CHAIN (parms2);
7385 parms1 = TREE_CHAIN (parms1);
7387 parms2 = TREE_CHAIN (parms2);
7391 if (!cp_tree_equal (TREE_PURPOSE (parms1),
7392 TREE_PURPOSE (parms2)))
7396 permerror (input_location, "default argument mismatch in "
7397 "overload resolution");
7398 inform (input_location,
7399 " candidate 1: %q+#F", cand1->fn);
7400 inform (input_location,
7401 " candidate 2: %q+#F", cand2->fn);
7404 add_warning (cand1, cand2);
7407 parms1 = TREE_CHAIN (parms1);
7408 parms2 = TREE_CHAIN (parms2);
7416 /* Extension: If the worst conversion for one candidate is worse than the
7417 worst conversion for the other, take the first. */
7420 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7421 struct z_candidate *w = 0, *l = 0;
7423 for (i = 0; i < len; ++i)
7425 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7426 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7427 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7428 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7431 winner = 1, w = cand1, l = cand2;
7433 winner = -1, w = cand2, l = cand1;
7436 /* Don't choose a deleted function over ambiguity. */
7437 if (DECL_P (w->fn) && DECL_DELETED_FN (w->fn))
7441 pedwarn (input_location, 0,
7442 "ISO C++ says that these are ambiguous, even "
7443 "though the worst conversion for the first is better than "
7444 "the worst conversion for the second:");
7445 print_z_candidate (_("candidate 1:"), w);
7446 print_z_candidate (_("candidate 2:"), l);
7454 gcc_assert (!winner);
7458 /* Given a list of candidates for overloading, find the best one, if any.
7459 This algorithm has a worst case of O(2n) (winner is last), and a best
7460 case of O(n/2) (totally ambiguous); much better than a sorting
7463 static struct z_candidate *
7464 tourney (struct z_candidate *candidates)
7466 struct z_candidate *champ = candidates, *challenger;
7468 int champ_compared_to_predecessor = 0;
7470 /* Walk through the list once, comparing each current champ to the next
7471 candidate, knocking out a candidate or two with each comparison. */
7473 for (challenger = champ->next; challenger; )
7475 fate = joust (champ, challenger, 0);
7477 challenger = challenger->next;
7482 champ = challenger->next;
7485 champ_compared_to_predecessor = 0;
7490 champ_compared_to_predecessor = 1;
7493 challenger = champ->next;
7497 /* Make sure the champ is better than all the candidates it hasn't yet
7498 been compared to. */
7500 for (challenger = candidates;
7502 && !(champ_compared_to_predecessor && challenger->next == champ);
7503 challenger = challenger->next)
7505 fate = joust (champ, challenger, 0);
7513 /* Returns nonzero if things of type FROM can be converted to TO. */
7516 can_convert (tree to, tree from)
7518 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
7521 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
7524 can_convert_arg (tree to, tree from, tree arg, int flags)
7530 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7531 p = conversion_obstack_alloc (0);
7533 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7535 ok_p = (t && !t->bad_p);
7537 /* Free all the conversions we allocated. */
7538 obstack_free (&conversion_obstack, p);
7543 /* Like can_convert_arg, but allows dubious conversions as well. */
7546 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
7551 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7552 p = conversion_obstack_alloc (0);
7553 /* Try to perform the conversion. */
7554 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7556 /* Free all the conversions we allocated. */
7557 obstack_free (&conversion_obstack, p);
7562 /* Convert EXPR to TYPE. Return the converted expression.
7564 Note that we allow bad conversions here because by the time we get to
7565 this point we are committed to doing the conversion. If we end up
7566 doing a bad conversion, convert_like will complain. */
7569 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7574 if (error_operand_p (expr))
7575 return error_mark_node;
7577 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7578 p = conversion_obstack_alloc (0);
7580 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7586 if (complain & tf_error)
7588 /* If expr has unknown type, then it is an overloaded function.
7589 Call instantiate_type to get good error messages. */
7590 if (TREE_TYPE (expr) == unknown_type_node)
7591 instantiate_type (type, expr, complain);
7592 else if (invalid_nonstatic_memfn_p (expr, complain))
7593 /* We gave an error. */;
7595 error ("could not convert %qE to %qT", expr, type);
7597 expr = error_mark_node;
7599 else if (processing_template_decl)
7601 /* In a template, we are only concerned about determining the
7602 type of non-dependent expressions, so we do not have to
7603 perform the actual conversion. */
7604 if (TREE_TYPE (expr) != type)
7605 expr = build_nop (type, expr);
7608 expr = convert_like (conv, expr, complain);
7610 /* Free all the conversions we allocated. */
7611 obstack_free (&conversion_obstack, p);
7617 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7619 return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
7622 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7623 permitted. If the conversion is valid, the converted expression is
7624 returned. Otherwise, NULL_TREE is returned, except in the case
7625 that TYPE is a class type; in that case, an error is issued. If
7626 C_CAST_P is true, then this direction initialization is taking
7627 place as part of a static_cast being attempted as part of a C-style
7631 perform_direct_initialization_if_possible (tree type,
7634 tsubst_flags_t complain)
7639 if (type == error_mark_node || error_operand_p (expr))
7640 return error_mark_node;
7643 If the destination type is a (possibly cv-qualified) class type:
7645 -- If the initialization is direct-initialization ...,
7646 constructors are considered. ... If no constructor applies, or
7647 the overload resolution is ambiguous, the initialization is
7649 if (CLASS_TYPE_P (type))
7651 VEC(tree,gc) *args = make_tree_vector_single (expr);
7652 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7653 &args, type, LOOKUP_NORMAL, complain);
7654 release_tree_vector (args);
7655 return build_cplus_new (type, expr);
7658 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7659 p = conversion_obstack_alloc (0);
7661 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7664 if (!conv || conv->bad_p)
7667 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7668 /*issue_conversion_warnings=*/false,
7672 /* Free all the conversions we allocated. */
7673 obstack_free (&conversion_obstack, p);
7678 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
7679 is being bound to a temporary. Create and return a new VAR_DECL
7680 with the indicated TYPE; this variable will store the value to
7681 which the reference is bound. */
7684 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7688 /* Create the variable. */
7689 var = create_temporary_var (type);
7691 /* Register the variable. */
7692 if (TREE_STATIC (decl))
7694 /* Namespace-scope or local static; give it a mangled name. */
7697 TREE_STATIC (var) = 1;
7698 name = mangle_ref_init_variable (decl);
7699 DECL_NAME (var) = name;
7700 SET_DECL_ASSEMBLER_NAME (var, name);
7701 var = pushdecl_top_level (var);
7704 /* Create a new cleanup level if necessary. */
7705 maybe_push_cleanup_level (type);
7710 /* EXPR is the initializer for a variable DECL of reference or
7711 std::initializer_list type. Create, push and return a new VAR_DECL
7712 for the initializer so that it will live as long as DECL. Any
7713 cleanup for the new variable is returned through CLEANUP, and the
7714 code to initialize the new variable is returned through INITP. */
7717 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7723 /* Create the temporary variable. */
7724 type = TREE_TYPE (expr);
7725 var = make_temporary_var_for_ref_to_temp (decl, type);
7726 layout_decl (var, 0);
7727 /* If the rvalue is the result of a function call it will be
7728 a TARGET_EXPR. If it is some other construct (such as a
7729 member access expression where the underlying object is
7730 itself the result of a function call), turn it into a
7731 TARGET_EXPR here. It is important that EXPR be a
7732 TARGET_EXPR below since otherwise the INIT_EXPR will
7733 attempt to make a bitwise copy of EXPR to initialize
7735 if (TREE_CODE (expr) != TARGET_EXPR)
7736 expr = get_target_expr (expr);
7737 /* Create the INIT_EXPR that will initialize the temporary
7739 init = build2 (INIT_EXPR, type, var, expr);
7740 if (at_function_scope_p ())
7742 add_decl_expr (var);
7744 if (TREE_STATIC (var))
7745 init = add_stmt_to_compound (init, register_dtor_fn (var));
7747 *cleanup = cxx_maybe_build_cleanup (var);
7749 /* We must be careful to destroy the temporary only
7750 after its initialization has taken place. If the
7751 initialization throws an exception, then the
7752 destructor should not be run. We cannot simply
7753 transform INIT into something like:
7755 (INIT, ({ CLEANUP_STMT; }))
7757 because emit_local_var always treats the
7758 initializer as a full-expression. Thus, the
7759 destructor would run too early; it would run at the
7760 end of initializing the reference variable, rather
7761 than at the end of the block enclosing the
7764 The solution is to pass back a cleanup expression
7765 which the caller is responsible for attaching to
7766 the statement tree. */
7770 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7771 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7772 static_aggregates = tree_cons (NULL_TREE, var,
7780 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7781 initializing a variable of that TYPE. If DECL is non-NULL, it is
7782 the VAR_DECL being initialized with the EXPR. (In that case, the
7783 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
7784 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
7785 return, if *CLEANUP is no longer NULL, it will be an expression
7786 that should be pushed as a cleanup after the returned expression
7787 is used to initialize DECL.
7789 Return the converted expression. */
7792 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
7793 tsubst_flags_t complain)
7798 if (type == error_mark_node || error_operand_p (expr))
7799 return error_mark_node;
7801 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7802 p = conversion_obstack_alloc (0);
7804 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7806 if (!conv || conv->bad_p)
7808 if (complain & tf_error)
7810 if (!CP_TYPE_CONST_P (TREE_TYPE (type))
7811 && !TYPE_REF_IS_RVALUE (type)
7812 && !real_lvalue_p (expr))
7813 error ("invalid initialization of non-const reference of "
7814 "type %qT from an rvalue of type %qT",
7815 type, TREE_TYPE (expr));
7817 error ("invalid initialization of reference of type "
7818 "%qT from expression of type %qT", type,
7821 return error_mark_node;
7824 /* If DECL is non-NULL, then this special rule applies:
7828 The temporary to which the reference is bound or the temporary
7829 that is the complete object to which the reference is bound
7830 persists for the lifetime of the reference.
7832 The temporaries created during the evaluation of the expression
7833 initializing the reference, except the temporary to which the
7834 reference is bound, are destroyed at the end of the
7835 full-expression in which they are created.
7837 In that case, we store the converted expression into a new
7838 VAR_DECL in a new scope.
7840 However, we want to be careful not to create temporaries when
7841 they are not required. For example, given:
7844 struct D : public B {};
7848 there is no need to copy the return value from "f"; we can just
7849 extend its lifetime. Similarly, given:
7852 struct T { operator S(); };
7856 we can extend the lifetime of the return value of the conversion
7858 gcc_assert (conv->kind == ck_ref_bind);
7862 tree base_conv_type;
7864 /* Skip over the REF_BIND. */
7865 conv = conv->u.next;
7866 /* If the next conversion is a BASE_CONV, skip that too -- but
7867 remember that the conversion was required. */
7868 if (conv->kind == ck_base)
7870 base_conv_type = conv->type;
7871 conv = conv->u.next;
7874 base_conv_type = NULL_TREE;
7875 /* Perform the remainder of the conversion. */
7876 expr = convert_like_real (conv, expr,
7877 /*fn=*/NULL_TREE, /*argnum=*/0,
7879 /*issue_conversion_warnings=*/true,
7881 tf_warning_or_error);
7882 if (error_operand_p (expr))
7883 expr = error_mark_node;
7886 if (!lvalue_or_rvalue_with_address_p (expr))
7889 var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7890 /* Use its address to initialize the reference variable. */
7891 expr = build_address (var);
7893 expr = convert_to_base (expr,
7894 build_pointer_type (base_conv_type),
7895 /*check_access=*/true,
7896 /*nonnull=*/true, complain);
7897 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7900 /* Take the address of EXPR. */
7901 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7902 /* If a BASE_CONV was required, perform it now. */
7904 expr = (perform_implicit_conversion
7905 (build_pointer_type (base_conv_type), expr,
7906 tf_warning_or_error));
7907 expr = build_nop (type, expr);
7911 /* Perform the conversion. */
7912 expr = convert_like (conv, expr, tf_warning_or_error);
7914 /* Free all the conversions we allocated. */
7915 obstack_free (&conversion_obstack, p);
7920 /* Returns true iff TYPE is some variant of std::initializer_list. */
7923 is_std_init_list (tree type)
7925 return (CLASS_TYPE_P (type)
7926 && CP_TYPE_CONTEXT (type) == std_node
7927 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7930 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7931 will accept an argument list of a single std::initializer_list<T>. */
7934 is_list_ctor (tree decl)
7936 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7939 if (!args || args == void_list_node)
7942 arg = non_reference (TREE_VALUE (args));
7943 if (!is_std_init_list (arg))
7946 args = TREE_CHAIN (args);
7948 if (args && args != void_list_node && !TREE_PURPOSE (args))
7949 /* There are more non-defaulted parms. */
7955 #include "gt-cp-call.h"