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
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"
38 #include "diagnostic.h"
42 #include "langhooks.h"
44 /* The various kinds of conversion. */
46 typedef enum conversion_kind {
62 /* The rank of the conversion. Order of the enumerals matters; better
63 conversions should come earlier in the list. */
65 typedef enum conversion_rank {
76 /* An implicit conversion sequence, in the sense of [over.best.ics].
77 The first conversion to be performed is at the end of the chain.
78 That conversion is always a cr_identity conversion. */
80 typedef struct conversion conversion;
82 /* The kind of conversion represented by this step. */
84 /* The rank of this conversion. */
86 BOOL_BITFIELD user_conv_p : 1;
87 BOOL_BITFIELD ellipsis_p : 1;
88 BOOL_BITFIELD this_p : 1;
89 BOOL_BITFIELD bad_p : 1;
90 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
91 temporary should be created to hold the result of the
93 BOOL_BITFIELD need_temporary_p : 1;
94 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
95 from a pointer-to-derived to pointer-to-base is being performed. */
96 BOOL_BITFIELD base_p : 1;
97 /* If KIND is ck_ref_bind, true when either an lvalue reference is
98 being bound to an lvalue expression or an rvalue reference is
99 being bound to an rvalue expression. */
100 BOOL_BITFIELD rvaluedness_matches_p: 1;
101 BOOL_BITFIELD check_narrowing: 1;
102 /* The type of the expression resulting from the conversion. */
105 /* The next conversion in the chain. Since the conversions are
106 arranged from outermost to innermost, the NEXT conversion will
107 actually be performed before this conversion. This variant is
108 used only when KIND is neither ck_identity nor ck_ambig. */
110 /* The expression at the beginning of the conversion chain. This
111 variant is used only if KIND is ck_identity or ck_ambig. */
113 /* The array of conversions for an initializer_list. */
116 /* The function candidate corresponding to this conversion
117 sequence. This field is only used if KIND is ck_user. */
118 struct z_candidate *cand;
121 #define CONVERSION_RANK(NODE) \
122 ((NODE)->bad_p ? cr_bad \
123 : (NODE)->ellipsis_p ? cr_ellipsis \
124 : (NODE)->user_conv_p ? cr_user \
127 static struct obstack conversion_obstack;
128 static bool conversion_obstack_initialized;
130 static struct z_candidate * tourney (struct z_candidate *);
131 static int equal_functions (tree, tree);
132 static int joust (struct z_candidate *, struct z_candidate *, bool);
133 static int compare_ics (conversion *, conversion *);
134 static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
135 static tree build_java_interface_fn_ref (tree, tree);
136 #define convert_like(CONV, EXPR, COMPLAIN) \
137 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
138 /*issue_conversion_warnings=*/true, \
139 /*c_cast_p=*/false, (COMPLAIN))
140 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \
141 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
142 /*issue_conversion_warnings=*/true, \
143 /*c_cast_p=*/false, (COMPLAIN))
144 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
145 bool, tsubst_flags_t);
146 static void op_error (enum tree_code, enum tree_code, tree, tree,
148 static VEC(tree,gc) *resolve_args (VEC(tree,gc) *);
149 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
150 static void print_z_candidate (const char *, struct z_candidate *);
151 static void print_z_candidates (struct z_candidate *);
152 static tree build_this (tree);
153 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
154 static bool any_strictly_viable (struct z_candidate *);
155 static struct z_candidate *add_template_candidate
156 (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
157 tree, tree, tree, int, unification_kind_t);
158 static struct z_candidate *add_template_candidate_real
159 (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
160 tree, tree, tree, int, tree, unification_kind_t);
161 static struct z_candidate *add_template_conv_candidate
162 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
164 static void add_builtin_candidates
165 (struct z_candidate **, enum tree_code, enum tree_code,
167 static void add_builtin_candidate
168 (struct z_candidate **, enum tree_code, enum tree_code,
169 tree, tree, tree, tree *, tree *, int);
170 static bool is_complete (tree);
171 static void build_builtin_candidate
172 (struct z_candidate **, tree, tree, tree, tree *, tree *,
174 static struct z_candidate *add_conv_candidate
175 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
177 static struct z_candidate *add_function_candidate
178 (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
180 static conversion *implicit_conversion (tree, tree, tree, bool, int);
181 static conversion *standard_conversion (tree, tree, tree, bool, int);
182 static conversion *reference_binding (tree, tree, tree, bool, int);
183 static conversion *build_conv (conversion_kind, tree, conversion *);
184 static conversion *build_list_conv (tree, tree, int);
185 static bool is_subseq (conversion *, conversion *);
186 static conversion *maybe_handle_ref_bind (conversion **);
187 static void maybe_handle_implicit_object (conversion **);
188 static struct z_candidate *add_candidate
189 (struct z_candidate **, tree, tree, const VEC(tree,gc) *, size_t,
190 conversion **, tree, tree, int);
191 static tree source_type (conversion *);
192 static void add_warning (struct z_candidate *, struct z_candidate *);
193 static bool reference_compatible_p (tree, tree);
194 static conversion *convert_class_to_reference (tree, tree, tree, int);
195 static conversion *direct_reference_binding (tree, conversion *);
196 static bool promoted_arithmetic_type_p (tree);
197 static conversion *conditional_conversion (tree, tree);
198 static char *name_as_c_string (tree, tree, bool *);
199 static tree prep_operand (tree);
200 static void add_candidates (tree, tree, const VEC(tree,gc) *, tree, tree, bool,
201 tree, tree, int, struct z_candidate **);
202 static conversion *merge_conversion_sequences (conversion *, conversion *);
203 static bool magic_varargs_p (tree);
204 static tree build_temp (tree, tree, int, diagnostic_t *);
206 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
207 NAME can take many forms... */
210 check_dtor_name (tree basetype, tree name)
212 /* Just accept something we've already complained about. */
213 if (name == error_mark_node)
216 if (TREE_CODE (name) == TYPE_DECL)
217 name = TREE_TYPE (name);
218 else if (TYPE_P (name))
220 else if (TREE_CODE (name) == IDENTIFIER_NODE)
222 if ((MAYBE_CLASS_TYPE_P (basetype)
223 && name == constructor_name (basetype))
224 || (TREE_CODE (basetype) == ENUMERAL_TYPE
225 && name == TYPE_IDENTIFIER (basetype)))
228 name = get_type_value (name);
234 template <class T> struct S { ~S(); };
238 NAME will be a class template. */
239 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
243 if (!name || name == error_mark_node)
245 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
248 /* We want the address of a function or method. We avoid creating a
249 pointer-to-member function. */
252 build_addr_func (tree function)
254 tree type = TREE_TYPE (function);
256 /* We have to do these by hand to avoid real pointer to member
258 if (TREE_CODE (type) == METHOD_TYPE)
260 if (TREE_CODE (function) == OFFSET_REF)
262 tree object = build_address (TREE_OPERAND (function, 0));
263 return get_member_function_from_ptrfunc (&object,
264 TREE_OPERAND (function, 1));
266 function = build_address (function);
269 function = decay_conversion (function);
274 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
275 POINTER_TYPE to those. Note, pointer to member function types
276 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
277 two variants. build_call_a is the primitive taking an array of
278 arguments, while build_call_n is a wrapper that handles varargs. */
281 build_call_n (tree function, int n, ...)
284 return build_call_a (function, 0, NULL);
287 tree *argarray = (tree *) alloca (n * sizeof (tree));
292 for (i = 0; i < n; i++)
293 argarray[i] = va_arg (ap, tree);
295 return build_call_a (function, n, argarray);
300 build_call_a (tree function, int n, tree *argarray)
302 int is_constructor = 0;
309 function = build_addr_func (function);
311 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
312 fntype = TREE_TYPE (TREE_TYPE (function));
313 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
314 || TREE_CODE (fntype) == METHOD_TYPE);
315 result_type = TREE_TYPE (fntype);
316 /* An rvalue has no cv-qualifiers. */
317 if (SCALAR_TYPE_P (result_type) || VOID_TYPE_P (result_type))
318 result_type = cv_unqualified (result_type);
320 if (TREE_CODE (function) == ADDR_EXPR
321 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
323 decl = TREE_OPERAND (function, 0);
324 if (!TREE_USED (decl))
326 /* We invoke build_call directly for several library
327 functions. These may have been declared normally if
328 we're building libgcc, so we can't just check
330 gcc_assert (DECL_ARTIFICIAL (decl)
331 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
339 /* We check both the decl and the type; a function may be known not to
340 throw without being declared throw(). */
341 nothrow = ((decl && TREE_NOTHROW (decl))
342 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
344 if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)
345 current_function_returns_abnormally = 1;
347 if (decl && TREE_DEPRECATED (decl))
348 warn_deprecated_use (decl, NULL_TREE);
349 require_complete_eh_spec_types (fntype, decl);
351 if (decl && DECL_CONSTRUCTOR_P (decl))
354 /* Don't pass empty class objects by value. This is useful
355 for tags in STL, which are used to control overload resolution.
356 We don't need to handle other cases of copying empty classes. */
357 if (! decl || ! DECL_BUILT_IN (decl))
358 for (i = 0; i < n; i++)
359 if (is_empty_class (TREE_TYPE (argarray[i]))
360 && ! TREE_ADDRESSABLE (TREE_TYPE (argarray[i])))
362 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (argarray[i]));
363 argarray[i] = build2 (COMPOUND_EXPR, TREE_TYPE (t),
367 function = build_call_array_loc (input_location,
368 result_type, function, n, argarray);
369 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
370 TREE_NOTHROW (function) = nothrow;
375 /* Build something of the form ptr->method (args)
376 or object.method (args). This can also build
377 calls to constructors, and find friends.
379 Member functions always take their class variable
382 INSTANCE is a class instance.
384 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
386 PARMS help to figure out what that NAME really refers to.
388 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
389 down to the real instance type to use for access checking. We need this
390 information to get protected accesses correct.
392 FLAGS is the logical disjunction of zero or more LOOKUP_
393 flags. See cp-tree.h for more info.
395 If this is all OK, calls build_function_call with the resolved
398 This function must also handle being called to perform
399 initialization, promotion/coercion of arguments, and
400 instantiation of default parameters.
402 Note that NAME may refer to an instance variable name. If
403 `operator()()' is defined for the type of that field, then we return
406 /* New overloading code. */
408 typedef struct z_candidate z_candidate;
410 typedef struct candidate_warning candidate_warning;
411 struct candidate_warning {
413 candidate_warning *next;
417 /* The FUNCTION_DECL that will be called if this candidate is
418 selected by overload resolution. */
420 /* If not NULL_TREE, the first argument to use when calling this
423 /* The rest of the arguments to use when calling this function. If
424 there are no further arguments this may be NULL or it may be an
426 const VEC(tree,gc) *args;
427 /* The implicit conversion sequences for each of the arguments to
430 /* The number of implicit conversion sequences. */
432 /* If FN is a user-defined conversion, the standard conversion
433 sequence from the type returned by FN to the desired destination
435 conversion *second_conv;
437 /* If FN is a member function, the binfo indicating the path used to
438 qualify the name of FN at the call site. This path is used to
439 determine whether or not FN is accessible if it is selected by
440 overload resolution. The DECL_CONTEXT of FN will always be a
441 (possibly improper) base of this binfo. */
443 /* If FN is a non-static member function, the binfo indicating the
444 subobject to which the `this' pointer should be converted if FN
445 is selected by overload resolution. The type pointed to the by
446 the `this' pointer must correspond to the most derived class
447 indicated by the CONVERSION_PATH. */
448 tree conversion_path;
450 candidate_warning *warnings;
454 /* Returns true iff T is a null pointer constant in the sense of
458 null_ptr_cst_p (tree t)
462 A null pointer constant is an integral constant expression
463 (_expr.const_) rvalue of integer type that evaluates to zero or
464 an rvalue of type std::nullptr_t. */
465 t = integral_constant_value (t);
467 || NULLPTR_TYPE_P (TREE_TYPE (t)))
469 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
472 if (!TREE_OVERFLOW (t))
478 /* Returns nonzero if PARMLIST consists of only default parms and/or
482 sufficient_parms_p (const_tree parmlist)
484 for (; parmlist && parmlist != void_list_node;
485 parmlist = TREE_CHAIN (parmlist))
486 if (!TREE_PURPOSE (parmlist))
491 /* Allocate N bytes of memory from the conversion obstack. The memory
492 is zeroed before being returned. */
495 conversion_obstack_alloc (size_t n)
498 if (!conversion_obstack_initialized)
500 gcc_obstack_init (&conversion_obstack);
501 conversion_obstack_initialized = true;
503 p = obstack_alloc (&conversion_obstack, n);
508 /* Dynamically allocate a conversion. */
511 alloc_conversion (conversion_kind kind)
514 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
519 #ifdef ENABLE_CHECKING
521 /* Make sure that all memory on the conversion obstack has been
525 validate_conversion_obstack (void)
527 if (conversion_obstack_initialized)
528 gcc_assert ((obstack_next_free (&conversion_obstack)
529 == obstack_base (&conversion_obstack)));
532 #endif /* ENABLE_CHECKING */
534 /* Dynamically allocate an array of N conversions. */
537 alloc_conversions (size_t n)
539 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
543 build_conv (conversion_kind code, tree type, conversion *from)
546 conversion_rank rank = CONVERSION_RANK (from);
548 /* Note that the caller is responsible for filling in t->cand for
549 user-defined conversions. */
550 t = alloc_conversion (code);
573 t->user_conv_p = (code == ck_user || from->user_conv_p);
574 t->bad_p = from->bad_p;
579 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
580 specialization of std::initializer_list<T>, if such a conversion is
584 build_list_conv (tree type, tree ctor, int flags)
586 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
587 unsigned len = CONSTRUCTOR_NELTS (ctor);
588 conversion **subconvs = alloc_conversions (len);
593 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
596 = implicit_conversion (elttype, TREE_TYPE (val), val,
604 t = alloc_conversion (ck_list);
606 t->u.list = subconvs;
609 for (i = 0; i < len; ++i)
611 conversion *sub = subconvs[i];
612 if (sub->rank > t->rank)
614 if (sub->user_conv_p)
615 t->user_conv_p = true;
623 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
624 aggregate class, if such a conversion is possible. */
627 build_aggr_conv (tree type, tree ctor, int flags)
629 unsigned HOST_WIDE_INT i = 0;
631 tree field = next_initializable_field (TYPE_FIELDS (type));
633 for (; field; field = next_initializable_field (TREE_CHAIN (field)))
635 if (i < CONSTRUCTOR_NELTS (ctor))
637 constructor_elt *ce = CONSTRUCTOR_ELT (ctor, i);
638 if (!can_convert_arg (TREE_TYPE (field), TREE_TYPE (ce->value),
642 if (TREE_CODE (type) == UNION_TYPE)
645 else if (build_value_init (TREE_TYPE (field)) == error_mark_node)
649 if (i < CONSTRUCTOR_NELTS (ctor))
652 c = alloc_conversion (ck_aggr);
655 c->user_conv_p = true;
660 /* Build a representation of the identity conversion from EXPR to
661 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
664 build_identity_conv (tree type, tree expr)
668 c = alloc_conversion (ck_identity);
675 /* Converting from EXPR to TYPE was ambiguous in the sense that there
676 were multiple user-defined conversions to accomplish the job.
677 Build a conversion that indicates that ambiguity. */
680 build_ambiguous_conv (tree type, tree expr)
684 c = alloc_conversion (ck_ambig);
692 strip_top_quals (tree t)
694 if (TREE_CODE (t) == ARRAY_TYPE)
696 return cp_build_qualified_type (t, 0);
699 /* Returns the standard conversion path (see [conv]) from type FROM to type
700 TO, if any. For proper handling of null pointer constants, you must
701 also pass the expression EXPR to convert from. If C_CAST_P is true,
702 this conversion is coming from a C-style cast. */
705 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
708 enum tree_code fcode, tcode;
710 bool fromref = false;
712 to = non_reference (to);
713 if (TREE_CODE (from) == REFERENCE_TYPE)
716 from = TREE_TYPE (from);
718 to = strip_top_quals (to);
719 from = strip_top_quals (from);
721 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
722 && expr && type_unknown_p (expr))
724 tsubst_flags_t tflags = tf_conv;
725 if (!(flags & LOOKUP_PROTECT))
726 tflags |= tf_no_access_control;
727 expr = instantiate_type (to, expr, tflags);
728 if (expr == error_mark_node)
730 from = TREE_TYPE (expr);
733 fcode = TREE_CODE (from);
734 tcode = TREE_CODE (to);
736 conv = build_identity_conv (from, expr);
737 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
739 from = type_decays_to (from);
740 fcode = TREE_CODE (from);
741 conv = build_conv (ck_lvalue, from, conv);
743 else if (fromref || (expr && lvalue_p (expr)))
748 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
751 from = strip_top_quals (bitfield_type);
752 fcode = TREE_CODE (from);
755 conv = build_conv (ck_rvalue, from, conv);
758 /* Allow conversion between `__complex__' data types. */
759 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
761 /* The standard conversion sequence to convert FROM to TO is
762 the standard conversion sequence to perform componentwise
764 conversion *part_conv = standard_conversion
765 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
769 conv = build_conv (part_conv->kind, to, conv);
770 conv->rank = part_conv->rank;
778 if (same_type_p (from, to))
782 A null pointer constant can be converted to a pointer type; ... A
783 null pointer constant of integral type can be converted to an
784 rvalue of type std::nullptr_t. */
785 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)
786 || NULLPTR_TYPE_P (to))
787 && expr && null_ptr_cst_p (expr))
788 conv = build_conv (ck_std, to, conv);
789 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
790 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
792 /* For backwards brain damage compatibility, allow interconversion of
793 pointers and integers with a pedwarn. */
794 conv = build_conv (ck_std, to, conv);
797 else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
799 /* For backwards brain damage compatibility, allow interconversion of
800 enums and integers with a pedwarn. */
801 conv = build_conv (ck_std, to, conv);
804 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
805 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
810 if (tcode == POINTER_TYPE
811 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
814 else if (VOID_TYPE_P (TREE_TYPE (to))
815 && !TYPE_PTRMEM_P (from)
816 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
818 from = build_pointer_type
819 (cp_build_qualified_type (void_type_node,
820 cp_type_quals (TREE_TYPE (from))));
821 conv = build_conv (ck_ptr, from, conv);
823 else if (TYPE_PTRMEM_P (from))
825 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
826 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
828 if (DERIVED_FROM_P (fbase, tbase)
829 && (same_type_ignoring_top_level_qualifiers_p
830 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
831 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
833 from = build_ptrmem_type (tbase,
834 TYPE_PTRMEM_POINTED_TO_TYPE (from));
835 conv = build_conv (ck_pmem, from, conv);
837 else if (!same_type_p (fbase, tbase))
840 else if (CLASS_TYPE_P (TREE_TYPE (from))
841 && CLASS_TYPE_P (TREE_TYPE (to))
844 An rvalue of type "pointer to cv D," where D is a
845 class type, can be converted to an rvalue of type
846 "pointer to cv B," where B is a base class (clause
847 _class.derived_) of D. If B is an inaccessible
848 (clause _class.access_) or ambiguous
849 (_class.member.lookup_) base class of D, a program
850 that necessitates this conversion is ill-formed.
851 Therefore, we use DERIVED_FROM_P, and do not check
852 access or uniqueness. */
853 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
856 cp_build_qualified_type (TREE_TYPE (to),
857 cp_type_quals (TREE_TYPE (from)));
858 from = build_pointer_type (from);
859 conv = build_conv (ck_ptr, from, conv);
863 if (tcode == POINTER_TYPE)
865 to_pointee = TREE_TYPE (to);
866 from_pointee = TREE_TYPE (from);
870 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
871 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
874 if (same_type_p (from, to))
876 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
877 /* In a C-style cast, we ignore CV-qualification because we
878 are allowed to perform a static_cast followed by a
880 conv = build_conv (ck_qual, to, conv);
881 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
882 conv = build_conv (ck_qual, to, conv);
883 else if (expr && string_conv_p (to, expr, 0))
884 /* converting from string constant to char *. */
885 conv = build_conv (ck_qual, to, conv);
886 else if (ptr_reasonably_similar (to_pointee, from_pointee))
888 conv = build_conv (ck_ptr, to, conv);
896 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
898 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
899 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
900 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
901 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
903 if (!DERIVED_FROM_P (fbase, tbase)
904 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
905 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
906 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
907 || cp_type_quals (fbase) != cp_type_quals (tbase))
910 from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
911 from = build_ptrmemfunc_type (build_pointer_type (from));
912 conv = build_conv (ck_pmem, from, conv);
915 else if (tcode == BOOLEAN_TYPE)
919 An rvalue of arithmetic, unscoped enumeration, pointer, or
920 pointer to member type can be converted to an rvalue of type
921 bool. ... An rvalue of type std::nullptr_t can be converted
922 to an rvalue of type bool; */
923 if (ARITHMETIC_TYPE_P (from)
924 || UNSCOPED_ENUM_P (from)
925 || fcode == POINTER_TYPE
926 || TYPE_PTR_TO_MEMBER_P (from)
927 || NULLPTR_TYPE_P (from))
929 conv = build_conv (ck_std, to, conv);
930 if (fcode == POINTER_TYPE
931 || TYPE_PTRMEM_P (from)
932 || (TYPE_PTRMEMFUNC_P (from)
933 && conv->rank < cr_pbool)
934 || NULLPTR_TYPE_P (from))
935 conv->rank = cr_pbool;
941 /* We don't check for ENUMERAL_TYPE here because there are no standard
942 conversions to enum type. */
943 /* As an extension, allow conversion to complex type. */
944 else if (ARITHMETIC_TYPE_P (to))
946 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
947 || SCOPED_ENUM_P (from))
949 conv = build_conv (ck_std, to, conv);
951 /* Give this a better rank if it's a promotion. */
952 if (same_type_p (to, type_promotes_to (from))
953 && conv->u.next->rank <= cr_promotion)
954 conv->rank = cr_promotion;
956 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
957 && vector_types_convertible_p (from, to, false))
958 return build_conv (ck_std, to, conv);
959 else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
960 && is_properly_derived_from (from, to))
962 if (conv->kind == ck_rvalue)
964 conv = build_conv (ck_base, to, conv);
965 /* The derived-to-base conversion indicates the initialization
966 of a parameter with base type from an object of a derived
967 type. A temporary object is created to hold the result of
968 the conversion unless we're binding directly to a reference. */
969 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
974 if (flags & LOOKUP_NO_NARROWING)
975 conv->check_narrowing = true;
980 /* Returns nonzero if T1 is reference-related to T2. */
983 reference_related_p (tree t1, tree t2)
985 t1 = TYPE_MAIN_VARIANT (t1);
986 t2 = TYPE_MAIN_VARIANT (t2);
990 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
991 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
993 return (same_type_p (t1, t2)
994 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
995 && DERIVED_FROM_P (t1, t2)));
998 /* Returns nonzero if T1 is reference-compatible with T2. */
1001 reference_compatible_p (tree t1, tree t2)
1005 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1006 reference-related to T2 and cv1 is the same cv-qualification as,
1007 or greater cv-qualification than, cv2. */
1008 return (reference_related_p (t1, t2)
1009 && at_least_as_qualified_p (t1, t2));
1012 /* Determine whether or not the EXPR (of class type S) can be
1013 converted to T as in [over.match.ref]. */
1016 convert_class_to_reference (tree reference_type, tree s, tree expr, int flags)
1022 struct z_candidate *candidates;
1023 struct z_candidate *cand;
1026 conversions = lookup_conversions (s, /*lookup_template_convs_p=*/true);
1032 Assuming that "cv1 T" is the underlying type of the reference
1033 being initialized, and "cv S" is the type of the initializer
1034 expression, with S a class type, the candidate functions are
1035 selected as follows:
1037 --The conversion functions of S and its base classes are
1038 considered. Those that are not hidden within S and yield type
1039 "reference to cv2 T2", where "cv1 T" is reference-compatible
1040 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1042 The argument list has one argument, which is the initializer
1047 /* Conceptually, we should take the address of EXPR and put it in
1048 the argument list. Unfortunately, however, that can result in
1049 error messages, which we should not issue now because we are just
1050 trying to find a conversion operator. Therefore, we use NULL,
1051 cast to the appropriate type. */
1052 first_arg = build_int_cst (build_pointer_type (s), 0);
1054 t = TREE_TYPE (reference_type);
1056 /* We're performing a user-defined conversion to a desired type, so set
1057 this for the benefit of add_candidates. */
1058 flags |= LOOKUP_NO_CONVERSION;
1060 for (; conversions; conversions = TREE_CHAIN (conversions))
1062 tree fns = TREE_VALUE (conversions);
1063 tree binfo = TREE_PURPOSE (conversions);
1064 struct z_candidate *old_candidates = candidates;;
1066 add_candidates (fns, first_arg, NULL, reference_type,
1068 binfo, TYPE_BINFO (s),
1069 flags, &candidates);
1071 for (cand = candidates; cand != old_candidates; cand = cand->next)
1073 /* Now, see if the conversion function really returns
1074 an lvalue of the appropriate type. From the
1075 point of view of unification, simply returning an
1076 rvalue of the right type is good enough. */
1078 tree t2 = TREE_TYPE (TREE_TYPE (f));
1079 if (TREE_CODE (t2) != REFERENCE_TYPE
1080 || !reference_compatible_p (t, TREE_TYPE (t2)))
1086 conversion *identity_conv;
1087 /* Build a standard conversion sequence indicating the
1088 binding from the reference type returned by the
1089 function to the desired REFERENCE_TYPE. */
1091 = build_identity_conv (TREE_TYPE (TREE_TYPE
1092 (TREE_TYPE (cand->fn))),
1095 = (direct_reference_binding
1096 (reference_type, identity_conv));
1097 cand->second_conv->rvaluedness_matches_p
1098 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1099 == TYPE_REF_IS_RVALUE (reference_type);
1100 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1102 /* Don't allow binding of lvalues to rvalue references. */
1103 if (TYPE_REF_IS_RVALUE (reference_type)
1104 && !TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn))))
1105 cand->second_conv->bad_p = true;
1110 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1111 /* If none of the conversion functions worked out, let our caller
1116 cand = tourney (candidates);
1120 /* Now that we know that this is the function we're going to use fix
1121 the dummy first argument. */
1122 gcc_assert (cand->first_arg == NULL_TREE
1123 || integer_zerop (cand->first_arg));
1124 cand->first_arg = build_this (expr);
1126 /* Build a user-defined conversion sequence representing the
1128 conv = build_conv (ck_user,
1129 TREE_TYPE (TREE_TYPE (cand->fn)),
1130 build_identity_conv (TREE_TYPE (expr), expr));
1133 if (cand->viable == -1)
1136 /* Merge it with the standard conversion sequence from the
1137 conversion function's return type to the desired type. */
1138 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1140 return cand->second_conv;
1143 /* A reference of the indicated TYPE is being bound directly to the
1144 expression represented by the implicit conversion sequence CONV.
1145 Return a conversion sequence for this binding. */
1148 direct_reference_binding (tree type, conversion *conv)
1152 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1153 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1155 t = TREE_TYPE (type);
1159 When a parameter of reference type binds directly
1160 (_dcl.init.ref_) to an argument expression, the implicit
1161 conversion sequence is the identity conversion, unless the
1162 argument expression has a type that is a derived class of the
1163 parameter type, in which case the implicit conversion sequence is
1164 a derived-to-base Conversion.
1166 If the parameter binds directly to the result of applying a
1167 conversion function to the argument expression, the implicit
1168 conversion sequence is a user-defined conversion sequence
1169 (_over.ics.user_), with the second standard conversion sequence
1170 either an identity conversion or, if the conversion function
1171 returns an entity of a type that is a derived class of the
1172 parameter type, a derived-to-base conversion. */
1173 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1175 /* Represent the derived-to-base conversion. */
1176 conv = build_conv (ck_base, t, conv);
1177 /* We will actually be binding to the base-class subobject in
1178 the derived class, so we mark this conversion appropriately.
1179 That way, convert_like knows not to generate a temporary. */
1180 conv->need_temporary_p = false;
1182 return build_conv (ck_ref_bind, type, conv);
1185 /* Returns the conversion path from type FROM to reference type TO for
1186 purposes of reference binding. For lvalue binding, either pass a
1187 reference type to FROM or an lvalue expression to EXPR. If the
1188 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1189 the conversion returned. If C_CAST_P is true, this
1190 conversion is coming from a C-style cast. */
1193 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1195 conversion *conv = NULL;
1196 tree to = TREE_TYPE (rto);
1201 cp_lvalue_kind is_lvalue = clk_none;
1203 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1205 expr = instantiate_type (to, expr, tf_none);
1206 if (expr == error_mark_node)
1208 from = TREE_TYPE (expr);
1211 if (TREE_CODE (from) == REFERENCE_TYPE)
1213 /* Anything with reference type is an lvalue. */
1214 is_lvalue = clk_ordinary;
1215 from = TREE_TYPE (from);
1218 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1220 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1221 conv = implicit_conversion (to, from, expr, c_cast_p,
1223 if (!CLASS_TYPE_P (to)
1224 && CONSTRUCTOR_NELTS (expr) == 1)
1226 expr = CONSTRUCTOR_ELT (expr, 0)->value;
1227 if (error_operand_p (expr))
1229 from = TREE_TYPE (expr);
1233 if (is_lvalue == clk_none && expr)
1234 is_lvalue = real_lvalue_p (expr);
1237 if ((is_lvalue & clk_bitfield) != 0)
1238 tfrom = unlowered_expr_type (expr);
1240 /* Figure out whether or not the types are reference-related and
1241 reference compatible. We have do do this after stripping
1242 references from FROM. */
1243 related_p = reference_related_p (to, tfrom);
1244 /* If this is a C cast, first convert to an appropriately qualified
1245 type, so that we can later do a const_cast to the desired type. */
1246 if (related_p && c_cast_p
1247 && !at_least_as_qualified_p (to, tfrom))
1248 to = build_qualified_type (to, cp_type_quals (tfrom));
1249 compatible_p = reference_compatible_p (to, tfrom);
1251 /* Directly bind reference when target expression's type is compatible with
1252 the reference and expression is an lvalue. In DR391, the wording in
1253 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1254 const and rvalue references to rvalues of compatible class type.
1255 We should also do direct bindings for non-class "rvalues" derived from
1256 rvalue references. */
1259 || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1260 && !(flags & LOOKUP_NO_TEMP_BIND))
1261 || TYPE_REF_IS_RVALUE (rto))
1262 && (CLASS_TYPE_P (from) || (expr && lvalue_p (expr))))))
1266 If the initializer expression
1268 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1269 is reference-compatible with "cv2 T2,"
1271 the reference is bound directly to the initializer expression
1275 If the initializer expression is an rvalue, with T2 a class type,
1276 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1277 is bound to the object represented by the rvalue or to a sub-object
1278 within that object. */
1280 conv = build_identity_conv (tfrom, expr);
1281 conv = direct_reference_binding (rto, conv);
1283 if (flags & LOOKUP_PREFER_RVALUE)
1284 /* The top-level caller requested that we pretend that the lvalue
1285 be treated as an rvalue. */
1286 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1288 conv->rvaluedness_matches_p
1289 = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1291 if ((is_lvalue & clk_bitfield) != 0
1292 || ((is_lvalue & clk_packed) != 0 && !TYPE_PACKED (to)))
1293 /* For the purposes of overload resolution, we ignore the fact
1294 this expression is a bitfield or packed field. (In particular,
1295 [over.ics.ref] says specifically that a function with a
1296 non-const reference parameter is viable even if the
1297 argument is a bitfield.)
1299 However, when we actually call the function we must create
1300 a temporary to which to bind the reference. If the
1301 reference is volatile, or isn't const, then we cannot make
1302 a temporary, so we just issue an error when the conversion
1304 conv->need_temporary_p = true;
1306 /* Don't allow binding of lvalues to rvalue references. */
1307 if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1308 && !(flags & LOOKUP_PREFER_RVALUE))
1313 /* [class.conv.fct] A conversion function is never used to convert a
1314 (possibly cv-qualified) object to the (possibly cv-qualified) same
1315 object type (or a reference to it), to a (possibly cv-qualified) base
1316 class of that type (or a reference to it).... */
1317 else if (CLASS_TYPE_P (from) && !related_p
1318 && !(flags & LOOKUP_NO_CONVERSION))
1322 If the initializer expression
1324 -- has a class type (i.e., T2 is a class type) can be
1325 implicitly converted to an lvalue of type "cv3 T3," where
1326 "cv1 T1" is reference-compatible with "cv3 T3". (this
1327 conversion is selected by enumerating the applicable
1328 conversion functions (_over.match.ref_) and choosing the
1329 best one through overload resolution. (_over.match_).
1331 the reference is bound to the lvalue result of the conversion
1332 in the second case. */
1333 conv = convert_class_to_reference (rto, from, expr, flags);
1338 /* From this point on, we conceptually need temporaries, even if we
1339 elide them. Only the cases above are "direct bindings". */
1340 if (flags & LOOKUP_NO_TEMP_BIND)
1345 When a parameter of reference type is not bound directly to an
1346 argument expression, the conversion sequence is the one required
1347 to convert the argument expression to the underlying type of the
1348 reference according to _over.best.ics_. Conceptually, this
1349 conversion sequence corresponds to copy-initializing a temporary
1350 of the underlying type with the argument expression. Any
1351 difference in top-level cv-qualification is subsumed by the
1352 initialization itself and does not constitute a conversion. */
1356 Otherwise, the reference shall be to a non-volatile const type.
1358 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1359 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1364 Otherwise, a temporary of type "cv1 T1" is created and
1365 initialized from the initializer expression using the rules for a
1366 non-reference copy initialization. If T1 is reference-related to
1367 T2, cv1 must be the same cv-qualification as, or greater
1368 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1369 if (related_p && !at_least_as_qualified_p (to, from))
1372 /* We're generating a temporary now, but don't bind any more in the
1373 conversion (specifically, don't slice the temporary returned by a
1374 conversion operator). */
1375 flags |= LOOKUP_NO_TEMP_BIND;
1377 /* Temporaries are copy-initialized, except for this hack to allow
1378 explicit conversion ops to the copy ctor. See also
1379 add_function_candidate. */
1380 if (!(flags & LOOKUP_COPY_PARM))
1381 flags |= LOOKUP_ONLYCONVERTING;
1384 conv = implicit_conversion (to, from, expr, c_cast_p,
1389 conv = build_conv (ck_ref_bind, rto, conv);
1390 /* This reference binding, unlike those above, requires the
1391 creation of a temporary. */
1392 conv->need_temporary_p = true;
1393 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1398 /* Returns the implicit conversion sequence (see [over.ics]) from type
1399 FROM to type TO. The optional expression EXPR may affect the
1400 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1401 true, this conversion is coming from a C-style cast. */
1404 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1409 if (from == error_mark_node || to == error_mark_node
1410 || expr == error_mark_node)
1413 if (TREE_CODE (to) == REFERENCE_TYPE)
1414 conv = reference_binding (to, from, expr, c_cast_p, flags);
1416 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1421 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1423 if (is_std_init_list (to))
1424 return build_list_conv (to, expr, flags);
1426 /* Allow conversion from an initializer-list with one element to a
1428 if (SCALAR_TYPE_P (to))
1430 int nelts = CONSTRUCTOR_NELTS (expr);
1434 elt = integer_zero_node;
1435 else if (nelts == 1)
1436 elt = CONSTRUCTOR_ELT (expr, 0)->value;
1438 elt = error_mark_node;
1440 conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1444 conv->check_narrowing = true;
1445 if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1446 /* Too many levels of braces, i.e. '{{1}}'. */
1453 if (expr != NULL_TREE
1454 && (MAYBE_CLASS_TYPE_P (from)
1455 || MAYBE_CLASS_TYPE_P (to))
1456 && (flags & LOOKUP_NO_CONVERSION) == 0)
1458 struct z_candidate *cand;
1459 int convflags = (flags & (LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING));
1461 if (CLASS_TYPE_P (to)
1462 && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1463 && BRACE_ENCLOSED_INITIALIZER_P (expr))
1464 return build_aggr_conv (to, expr, flags);
1466 cand = build_user_type_conversion_1 (to, expr, convflags);
1468 conv = cand->second_conv;
1470 /* We used to try to bind a reference to a temporary here, but that
1471 is now handled after the recursive call to this function at the end
1472 of reference_binding. */
1479 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1480 functions. ARGS will not be changed until a single candidate is
1483 static struct z_candidate *
1484 add_candidate (struct z_candidate **candidates,
1485 tree fn, tree first_arg, const VEC(tree,gc) *args,
1486 size_t num_convs, conversion **convs,
1487 tree access_path, tree conversion_path,
1490 struct z_candidate *cand = (struct z_candidate *)
1491 conversion_obstack_alloc (sizeof (struct z_candidate));
1494 cand->first_arg = first_arg;
1496 cand->convs = convs;
1497 cand->num_convs = num_convs;
1498 cand->access_path = access_path;
1499 cand->conversion_path = conversion_path;
1500 cand->viable = viable;
1501 cand->next = *candidates;
1507 /* Create an overload candidate for the function or method FN called
1508 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1509 FLAGS is passed on to implicit_conversion.
1511 This does not change ARGS.
1513 CTYPE, if non-NULL, is the type we want to pretend this function
1514 comes from for purposes of overload resolution. */
1516 static struct z_candidate *
1517 add_function_candidate (struct z_candidate **candidates,
1518 tree fn, tree ctype, tree first_arg,
1519 const VEC(tree,gc) *args, tree access_path,
1520 tree conversion_path, int flags)
1522 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1526 tree orig_first_arg = first_arg;
1530 /* At this point we should not see any functions which haven't been
1531 explicitly declared, except for friend functions which will have
1532 been found using argument dependent lookup. */
1533 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1535 /* The `this', `in_chrg' and VTT arguments to constructors are not
1536 considered in overload resolution. */
1537 if (DECL_CONSTRUCTOR_P (fn))
1539 parmlist = skip_artificial_parms_for (fn, parmlist);
1540 skip = num_artificial_parms_for (fn);
1541 if (skip > 0 && first_arg != NULL_TREE)
1544 first_arg = NULL_TREE;
1550 len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1551 convs = alloc_conversions (len);
1553 /* 13.3.2 - Viable functions [over.match.viable]
1554 First, to be a viable function, a candidate function shall have enough
1555 parameters to agree in number with the arguments in the list.
1557 We need to check this first; otherwise, checking the ICSes might cause
1558 us to produce an ill-formed template instantiation. */
1560 parmnode = parmlist;
1561 for (i = 0; i < len; ++i)
1563 if (parmnode == NULL_TREE || parmnode == void_list_node)
1565 parmnode = TREE_CHAIN (parmnode);
1568 if (i < len && parmnode)
1571 /* Make sure there are default args for the rest of the parms. */
1572 else if (!sufficient_parms_p (parmnode))
1578 /* Second, for F to be a viable function, there shall exist for each
1579 argument an implicit conversion sequence that converts that argument
1580 to the corresponding parameter of F. */
1582 parmnode = parmlist;
1584 for (i = 0; i < len; ++i)
1590 if (parmnode == void_list_node)
1593 if (i == 0 && first_arg != NULL_TREE)
1596 arg = VEC_index (tree, args,
1597 i + skip - (first_arg != NULL_TREE ? 1 : 0));
1598 argtype = lvalue_type (arg);
1600 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1601 && ! DECL_CONSTRUCTOR_P (fn));
1605 tree parmtype = TREE_VALUE (parmnode);
1608 /* The type of the implicit object parameter ('this') for
1609 overload resolution is not always the same as for the
1610 function itself; conversion functions are considered to
1611 be members of the class being converted, and functions
1612 introduced by a using-declaration are considered to be
1613 members of the class that uses them.
1615 Since build_over_call ignores the ICS for the `this'
1616 parameter, we can just change the parm type. */
1617 if (ctype && is_this)
1620 = build_qualified_type (ctype,
1621 TYPE_QUALS (TREE_TYPE (parmtype)));
1622 parmtype = build_pointer_type (parmtype);
1625 if (ctype && i == 0 && DECL_COPY_CONSTRUCTOR_P (fn)
1628 /* Hack: Direct-initialize copy parm (i.e. suppress
1629 LOOKUP_ONLYCONVERTING) to make explicit conversion ops
1630 work. See also reference_binding. */
1631 lflags |= LOOKUP_COPY_PARM;
1632 if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1633 lflags |= LOOKUP_NO_CONVERSION;
1636 lflags |= LOOKUP_ONLYCONVERTING;
1638 t = implicit_conversion (parmtype, argtype, arg,
1639 /*c_cast_p=*/false, lflags);
1643 t = build_identity_conv (argtype, arg);
1644 t->ellipsis_p = true;
1661 parmnode = TREE_CHAIN (parmnode);
1665 return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
1666 access_path, conversion_path, viable);
1669 /* Create an overload candidate for the conversion function FN which will
1670 be invoked for expression OBJ, producing a pointer-to-function which
1671 will in turn be called with the argument list FIRST_ARG/ARGLIST,
1672 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
1673 passed on to implicit_conversion.
1675 Actually, we don't really care about FN; we care about the type it
1676 converts to. There may be multiple conversion functions that will
1677 convert to that type, and we rely on build_user_type_conversion_1 to
1678 choose the best one; so when we create our candidate, we record the type
1679 instead of the function. */
1681 static struct z_candidate *
1682 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1683 tree first_arg, const VEC(tree,gc) *arglist,
1684 tree access_path, tree conversion_path)
1686 tree totype = TREE_TYPE (TREE_TYPE (fn));
1687 int i, len, viable, flags;
1688 tree parmlist, parmnode;
1691 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1692 parmlist = TREE_TYPE (parmlist);
1693 parmlist = TYPE_ARG_TYPES (parmlist);
1695 len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
1696 convs = alloc_conversions (len);
1697 parmnode = parmlist;
1699 flags = LOOKUP_IMPLICIT;
1701 /* Don't bother looking up the same type twice. */
1702 if (*candidates && (*candidates)->fn == totype)
1705 for (i = 0; i < len; ++i)
1712 else if (i == 1 && first_arg != NULL_TREE)
1715 arg = VEC_index (tree, arglist,
1716 i - (first_arg != NULL_TREE ? 1 : 0) - 1);
1717 argtype = lvalue_type (arg);
1720 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1722 else if (parmnode == void_list_node)
1725 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1726 /*c_cast_p=*/false, flags);
1729 t = build_identity_conv (argtype, arg);
1730 t->ellipsis_p = true;
1744 parmnode = TREE_CHAIN (parmnode);
1750 if (!sufficient_parms_p (parmnode))
1753 return add_candidate (candidates, totype, first_arg, arglist, len, convs,
1754 access_path, conversion_path, viable);
1758 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1759 tree type1, tree type2, tree *args, tree *argtypes,
1771 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1772 convs = alloc_conversions (num_convs);
1774 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
1775 conversion ops are allowed. We handle that here by just checking for
1776 boolean_type_node because other operators don't ask for it. COND_EXPR
1777 also does contextual conversion to bool for the first operand, but we
1778 handle that in build_conditional_expr, and type1 here is operand 2. */
1779 if (type1 != boolean_type_node)
1780 flags |= LOOKUP_ONLYCONVERTING;
1782 for (i = 0; i < 2; ++i)
1787 t = implicit_conversion (types[i], argtypes[i], args[i],
1788 /*c_cast_p=*/false, flags);
1792 /* We need something for printing the candidate. */
1793 t = build_identity_conv (types[i], NULL_TREE);
1800 /* For COND_EXPR we rearranged the arguments; undo that now. */
1803 convs[2] = convs[1];
1804 convs[1] = convs[0];
1805 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1806 /*c_cast_p=*/false, flags);
1813 add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
1815 /*access_path=*/NULL_TREE,
1816 /*conversion_path=*/NULL_TREE,
1821 is_complete (tree t)
1823 return COMPLETE_TYPE_P (complete_type (t));
1826 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1829 promoted_arithmetic_type_p (tree type)
1833 In this section, the term promoted integral type is used to refer
1834 to those integral types which are preserved by integral promotion
1835 (including e.g. int and long but excluding e.g. char).
1836 Similarly, the term promoted arithmetic type refers to promoted
1837 integral types plus floating types. */
1838 return ((CP_INTEGRAL_TYPE_P (type)
1839 && same_type_p (type_promotes_to (type), type))
1840 || TREE_CODE (type) == REAL_TYPE);
1843 /* Create any builtin operator overload candidates for the operator in
1844 question given the converted operand types TYPE1 and TYPE2. The other
1845 args are passed through from add_builtin_candidates to
1846 build_builtin_candidate.
1848 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1849 If CODE is requires candidates operands of the same type of the kind
1850 of which TYPE1 and TYPE2 are, we add both candidates
1851 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1854 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1855 enum tree_code code2, tree fnname, tree type1,
1856 tree type2, tree *args, tree *argtypes, int flags)
1860 case POSTINCREMENT_EXPR:
1861 case POSTDECREMENT_EXPR:
1862 args[1] = integer_zero_node;
1863 type2 = integer_type_node;
1872 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1873 and VQ is either volatile or empty, there exist candidate operator
1874 functions of the form
1875 VQ T& operator++(VQ T&);
1876 T operator++(VQ T&, int);
1877 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1878 type other than bool, and VQ is either volatile or empty, there exist
1879 candidate operator functions of the form
1880 VQ T& operator--(VQ T&);
1881 T operator--(VQ T&, int);
1882 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1883 complete object type, and VQ is either volatile or empty, there exist
1884 candidate operator functions of the form
1885 T*VQ& operator++(T*VQ&);
1886 T*VQ& operator--(T*VQ&);
1887 T* operator++(T*VQ&, int);
1888 T* operator--(T*VQ&, int); */
1890 case POSTDECREMENT_EXPR:
1891 case PREDECREMENT_EXPR:
1892 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1894 case POSTINCREMENT_EXPR:
1895 case PREINCREMENT_EXPR:
1896 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1898 type1 = build_reference_type (type1);
1903 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1904 exist candidate operator functions of the form
1908 8 For every function type T, there exist candidate operator functions of
1910 T& operator*(T*); */
1913 if (TREE_CODE (type1) == POINTER_TYPE
1914 && (TYPE_PTROB_P (type1)
1915 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1919 /* 9 For every type T, there exist candidate operator functions of the form
1922 10For every promoted arithmetic type T, there exist candidate operator
1923 functions of the form
1927 case UNARY_PLUS_EXPR: /* unary + */
1928 if (TREE_CODE (type1) == POINTER_TYPE)
1931 if (ARITHMETIC_TYPE_P (type1))
1935 /* 11For every promoted integral type T, there exist candidate operator
1936 functions of the form
1940 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
1944 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1945 is the same type as C2 or is a derived class of C2, T is a complete
1946 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1947 there exist candidate operator functions of the form
1948 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1949 where CV12 is the union of CV1 and CV2. */
1952 if (TREE_CODE (type1) == POINTER_TYPE
1953 && TYPE_PTR_TO_MEMBER_P (type2))
1955 tree c1 = TREE_TYPE (type1);
1956 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1958 if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
1959 && (TYPE_PTRMEMFUNC_P (type2)
1960 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1965 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1966 didate operator functions of the form
1971 bool operator<(L, R);
1972 bool operator>(L, R);
1973 bool operator<=(L, R);
1974 bool operator>=(L, R);
1975 bool operator==(L, R);
1976 bool operator!=(L, R);
1977 where LR is the result of the usual arithmetic conversions between
1980 14For every pair of types T and I, where T is a cv-qualified or cv-
1981 unqualified complete object type and I is a promoted integral type,
1982 there exist candidate operator functions of the form
1983 T* operator+(T*, I);
1984 T& operator[](T*, I);
1985 T* operator-(T*, I);
1986 T* operator+(I, T*);
1987 T& operator[](I, T*);
1989 15For every T, where T is a pointer to complete object type, there exist
1990 candidate operator functions of the form112)
1991 ptrdiff_t operator-(T, T);
1993 16For every pointer or enumeration type T, there exist candidate operator
1994 functions of the form
1995 bool operator<(T, T);
1996 bool operator>(T, T);
1997 bool operator<=(T, T);
1998 bool operator>=(T, T);
1999 bool operator==(T, T);
2000 bool operator!=(T, T);
2002 17For every pointer to member type T, there exist candidate operator
2003 functions of the form
2004 bool operator==(T, T);
2005 bool operator!=(T, T); */
2008 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2010 if (TYPE_PTROB_P (type1)
2011 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2013 type2 = ptrdiff_type_node;
2017 case TRUNC_DIV_EXPR:
2018 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2024 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2025 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2027 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2032 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2044 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2046 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2048 if (TREE_CODE (type1) == ENUMERAL_TYPE
2049 && TREE_CODE (type2) == ENUMERAL_TYPE)
2051 if (TYPE_PTR_P (type1)
2052 && null_ptr_cst_p (args[1])
2053 && !uses_template_parms (type1))
2058 if (null_ptr_cst_p (args[0])
2059 && TYPE_PTR_P (type2)
2060 && !uses_template_parms (type2))
2068 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2071 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2073 type1 = ptrdiff_type_node;
2076 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2078 type2 = ptrdiff_type_node;
2083 /* 18For every pair of promoted integral types L and R, there exist candi-
2084 date operator functions of the form
2091 where LR is the result of the usual arithmetic conversions between
2094 case TRUNC_MOD_EXPR:
2100 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2104 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2105 type, VQ is either volatile or empty, and R is a promoted arithmetic
2106 type, there exist candidate operator functions of the form
2107 VQ L& operator=(VQ L&, R);
2108 VQ L& operator*=(VQ L&, R);
2109 VQ L& operator/=(VQ L&, R);
2110 VQ L& operator+=(VQ L&, R);
2111 VQ L& operator-=(VQ L&, R);
2113 20For every pair T, VQ), where T is any type and VQ is either volatile
2114 or empty, there exist candidate operator functions of the form
2115 T*VQ& operator=(T*VQ&, T*);
2117 21For every pair T, VQ), where T is a pointer to member type and VQ is
2118 either volatile or empty, there exist candidate operator functions of
2120 VQ T& operator=(VQ T&, T);
2122 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2123 unqualified complete object type, VQ is either volatile or empty, and
2124 I is a promoted integral type, there exist candidate operator func-
2126 T*VQ& operator+=(T*VQ&, I);
2127 T*VQ& operator-=(T*VQ&, I);
2129 23For every triple L, VQ, R), where L is an integral or enumeration
2130 type, VQ is either volatile or empty, and R is a promoted integral
2131 type, there exist candidate operator functions of the form
2133 VQ L& operator%=(VQ L&, R);
2134 VQ L& operator<<=(VQ L&, R);
2135 VQ L& operator>>=(VQ L&, R);
2136 VQ L& operator&=(VQ L&, R);
2137 VQ L& operator^=(VQ L&, R);
2138 VQ L& operator|=(VQ L&, R); */
2145 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2147 type2 = ptrdiff_type_node;
2151 case TRUNC_DIV_EXPR:
2152 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2156 case TRUNC_MOD_EXPR:
2162 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2167 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2169 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2170 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2171 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2172 || ((TYPE_PTRMEMFUNC_P (type1)
2173 || TREE_CODE (type1) == POINTER_TYPE)
2174 && null_ptr_cst_p (args[1])))
2184 type1 = build_reference_type (type1);
2190 For every pair of promoted arithmetic types L and R, there
2191 exist candidate operator functions of the form
2193 LR operator?(bool, L, R);
2195 where LR is the result of the usual arithmetic conversions
2196 between types L and R.
2198 For every type T, where T is a pointer or pointer-to-member
2199 type, there exist candidate operator functions of the form T
2200 operator?(bool, T, T); */
2202 if (promoted_arithmetic_type_p (type1)
2203 && promoted_arithmetic_type_p (type2))
2207 /* Otherwise, the types should be pointers. */
2208 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2209 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2212 /* We don't check that the two types are the same; the logic
2213 below will actually create two candidates; one in which both
2214 parameter types are TYPE1, and one in which both parameter
2222 /* If we're dealing with two pointer types or two enumeral types,
2223 we need candidates for both of them. */
2224 if (type2 && !same_type_p (type1, type2)
2225 && TREE_CODE (type1) == TREE_CODE (type2)
2226 && (TREE_CODE (type1) == REFERENCE_TYPE
2227 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2228 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2229 || TYPE_PTRMEMFUNC_P (type1)
2230 || MAYBE_CLASS_TYPE_P (type1)
2231 || TREE_CODE (type1) == ENUMERAL_TYPE))
2233 build_builtin_candidate
2234 (candidates, fnname, type1, type1, args, argtypes, flags);
2235 build_builtin_candidate
2236 (candidates, fnname, type2, type2, args, argtypes, flags);
2240 build_builtin_candidate
2241 (candidates, fnname, type1, type2, args, argtypes, flags);
2245 type_decays_to (tree type)
2247 if (TREE_CODE (type) == ARRAY_TYPE)
2248 return build_pointer_type (TREE_TYPE (type));
2249 if (TREE_CODE (type) == FUNCTION_TYPE)
2250 return build_pointer_type (type);
2251 if (!MAYBE_CLASS_TYPE_P (type))
2252 type = cv_unqualified (type);
2256 /* There are three conditions of builtin candidates:
2258 1) bool-taking candidates. These are the same regardless of the input.
2259 2) pointer-pair taking candidates. These are generated for each type
2260 one of the input types converts to.
2261 3) arithmetic candidates. According to the standard, we should generate
2262 all of these, but I'm trying not to...
2264 Here we generate a superset of the possible candidates for this particular
2265 case. That is a subset of the full set the standard defines, plus some
2266 other cases which the standard disallows. add_builtin_candidate will
2267 filter out the invalid set. */
2270 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2271 enum tree_code code2, tree fnname, tree *args,
2276 tree type, argtypes[3];
2277 /* TYPES[i] is the set of possible builtin-operator parameter types
2278 we will consider for the Ith argument. These are represented as
2279 a TREE_LIST; the TREE_VALUE of each node is the potential
2283 for (i = 0; i < 3; ++i)
2286 argtypes[i] = unlowered_expr_type (args[i]);
2288 argtypes[i] = NULL_TREE;
2293 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2294 and VQ is either volatile or empty, there exist candidate operator
2295 functions of the form
2296 VQ T& operator++(VQ T&); */
2298 case POSTINCREMENT_EXPR:
2299 case PREINCREMENT_EXPR:
2300 case POSTDECREMENT_EXPR:
2301 case PREDECREMENT_EXPR:
2306 /* 24There also exist candidate operator functions of the form
2307 bool operator!(bool);
2308 bool operator&&(bool, bool);
2309 bool operator||(bool, bool); */
2311 case TRUTH_NOT_EXPR:
2312 build_builtin_candidate
2313 (candidates, fnname, boolean_type_node,
2314 NULL_TREE, args, argtypes, flags);
2317 case TRUTH_ORIF_EXPR:
2318 case TRUTH_ANDIF_EXPR:
2319 build_builtin_candidate
2320 (candidates, fnname, boolean_type_node,
2321 boolean_type_node, args, argtypes, flags);
2343 types[0] = types[1] = NULL_TREE;
2345 for (i = 0; i < 2; ++i)
2349 else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2353 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2356 convs = lookup_conversions (argtypes[i],
2357 /*lookup_template_convs_p=*/false);
2359 if (code == COND_EXPR)
2361 if (real_lvalue_p (args[i]))
2362 types[i] = tree_cons
2363 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2365 types[i] = tree_cons
2366 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2372 for (; convs; convs = TREE_CHAIN (convs))
2374 type = TREE_TYPE (convs);
2377 && (TREE_CODE (type) != REFERENCE_TYPE
2378 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2381 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2382 types[i] = tree_cons (NULL_TREE, type, types[i]);
2384 type = non_reference (type);
2385 if (i != 0 || ! ref1)
2387 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2388 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2389 types[i] = tree_cons (NULL_TREE, type, types[i]);
2390 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2391 type = type_promotes_to (type);
2394 if (! value_member (type, types[i]))
2395 types[i] = tree_cons (NULL_TREE, type, types[i]);
2400 if (code == COND_EXPR && real_lvalue_p (args[i]))
2401 types[i] = tree_cons
2402 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2403 type = non_reference (argtypes[i]);
2404 if (i != 0 || ! ref1)
2406 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2407 if (enum_p && UNSCOPED_ENUM_P (type))
2408 types[i] = tree_cons (NULL_TREE, type, types[i]);
2409 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2410 type = type_promotes_to (type);
2412 types[i] = tree_cons (NULL_TREE, type, types[i]);
2416 /* Run through the possible parameter types of both arguments,
2417 creating candidates with those parameter types. */
2418 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2421 for (type = types[1]; type; type = TREE_CHAIN (type))
2422 add_builtin_candidate
2423 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2424 TREE_VALUE (type), args, argtypes, flags);
2426 add_builtin_candidate
2427 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2428 NULL_TREE, args, argtypes, flags);
2433 /* If TMPL can be successfully instantiated as indicated by
2434 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2436 TMPL is the template. EXPLICIT_TARGS are any explicit template
2437 arguments. ARGLIST is the arguments provided at the call-site.
2438 This does not change ARGLIST. The RETURN_TYPE is the desired type
2439 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2440 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2441 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2443 static struct z_candidate*
2444 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2445 tree ctype, tree explicit_targs, tree first_arg,
2446 const VEC(tree,gc) *arglist, tree return_type,
2447 tree access_path, tree conversion_path,
2448 int flags, tree obj, unification_kind_t strict)
2450 int ntparms = DECL_NTPARMS (tmpl);
2451 tree targs = make_tree_vec (ntparms);
2452 unsigned int len = VEC_length (tree, arglist);
2453 unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2454 unsigned int skip_without_in_chrg = 0;
2455 tree first_arg_without_in_chrg = first_arg;
2456 tree *args_without_in_chrg;
2457 unsigned int nargs_without_in_chrg;
2458 unsigned int ia, ix;
2460 struct z_candidate *cand;
2464 /* We don't do deduction on the in-charge parameter, the VTT
2465 parameter or 'this'. */
2466 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2468 if (first_arg_without_in_chrg != NULL_TREE)
2469 first_arg_without_in_chrg = NULL_TREE;
2471 ++skip_without_in_chrg;
2474 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2475 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2476 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2478 if (first_arg_without_in_chrg != NULL_TREE)
2479 first_arg_without_in_chrg = NULL_TREE;
2481 ++skip_without_in_chrg;
2484 if (len < skip_without_in_chrg)
2487 nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2488 + (len - skip_without_in_chrg));
2489 args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2491 if (first_arg_without_in_chrg != NULL_TREE)
2493 args_without_in_chrg[ia] = first_arg_without_in_chrg;
2496 for (ix = skip_without_in_chrg;
2497 VEC_iterate (tree, arglist, ix, arg);
2500 args_without_in_chrg[ia] = arg;
2503 gcc_assert (ia == nargs_without_in_chrg);
2505 i = fn_type_unification (tmpl, explicit_targs, targs,
2506 args_without_in_chrg,
2507 nargs_without_in_chrg,
2508 return_type, strict, flags);
2513 fn = instantiate_template (tmpl, targs, tf_none);
2514 if (fn == error_mark_node)
2519 A member function template is never instantiated to perform the
2520 copy of a class object to an object of its class type.
2522 It's a little unclear what this means; the standard explicitly
2523 does allow a template to be used to copy a class. For example,
2528 template <class T> A(const T&);
2531 void g () { A a (f ()); }
2533 the member template will be used to make the copy. The section
2534 quoted above appears in the paragraph that forbids constructors
2535 whose only parameter is (a possibly cv-qualified variant of) the
2536 class type, and a logical interpretation is that the intent was
2537 to forbid the instantiation of member templates which would then
2539 if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2541 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2542 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2547 if (obj != NULL_TREE)
2548 /* Aha, this is a conversion function. */
2549 cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2550 access_path, conversion_path);
2552 cand = add_function_candidate (candidates, fn, ctype,
2553 first_arg, arglist, access_path,
2554 conversion_path, flags);
2555 if (DECL_TI_TEMPLATE (fn) != tmpl)
2556 /* This situation can occur if a member template of a template
2557 class is specialized. Then, instantiate_template might return
2558 an instantiation of the specialization, in which case the
2559 DECL_TI_TEMPLATE field will point at the original
2560 specialization. For example:
2562 template <class T> struct S { template <class U> void f(U);
2563 template <> void f(int) {}; };
2567 Here, TMPL will be template <class U> S<double>::f(U).
2568 And, instantiate template will give us the specialization
2569 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2570 for this will point at template <class T> template <> S<T>::f(int),
2571 so that we can find the definition. For the purposes of
2572 overload resolution, however, we want the original TMPL. */
2573 cand->template_decl = build_template_info (tmpl, targs);
2575 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2579 return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2580 access_path, conversion_path, 0);
2584 static struct z_candidate *
2585 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2586 tree explicit_targs, tree first_arg,
2587 const VEC(tree,gc) *arglist, tree return_type,
2588 tree access_path, tree conversion_path, int flags,
2589 unification_kind_t strict)
2592 add_template_candidate_real (candidates, tmpl, ctype,
2593 explicit_targs, first_arg, arglist,
2594 return_type, access_path, conversion_path,
2595 flags, NULL_TREE, strict);
2599 static struct z_candidate *
2600 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2601 tree obj, tree first_arg,
2602 const VEC(tree,gc) *arglist,
2603 tree return_type, tree access_path,
2604 tree conversion_path)
2607 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2608 first_arg, arglist, return_type, access_path,
2609 conversion_path, 0, obj, DEDUCE_CONV);
2612 /* The CANDS are the set of candidates that were considered for
2613 overload resolution. Return the set of viable candidates, or CANDS
2614 if none are viable. If any of the candidates were viable, set
2615 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
2616 considered viable only if it is strictly viable. */
2618 static struct z_candidate*
2619 splice_viable (struct z_candidate *cands,
2623 struct z_candidate *viable;
2624 struct z_candidate **last_viable;
2625 struct z_candidate **cand;
2628 last_viable = &viable;
2629 *any_viable_p = false;
2634 struct z_candidate *c = *cand;
2635 if (strict_p ? c->viable == 1 : c->viable)
2640 last_viable = &c->next;
2641 *any_viable_p = true;
2647 return viable ? viable : cands;
2651 any_strictly_viable (struct z_candidate *cands)
2653 for (; cands; cands = cands->next)
2654 if (cands->viable == 1)
2659 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2660 words, it is about to become the "this" pointer for a member
2661 function call. Take the address of the object. */
2664 build_this (tree obj)
2666 /* In a template, we are only concerned about the type of the
2667 expression, so we can take a shortcut. */
2668 if (processing_template_decl)
2669 return build_address (obj);
2671 return cp_build_unary_op (ADDR_EXPR, obj, 0, tf_warning_or_error);
2674 /* Returns true iff functions are equivalent. Equivalent functions are
2675 not '==' only if one is a function-local extern function or if
2676 both are extern "C". */
2679 equal_functions (tree fn1, tree fn2)
2681 if (TREE_CODE (fn1) != TREE_CODE (fn2))
2683 if (TREE_CODE (fn1) == TEMPLATE_DECL)
2685 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2686 || DECL_EXTERN_C_FUNCTION_P (fn1))
2687 return decls_match (fn1, fn2);
2691 /* Print information about one overload candidate CANDIDATE. MSGSTR
2692 is the text to print before the candidate itself.
2694 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2695 to have been run through gettext by the caller. This wart makes
2696 life simpler in print_z_candidates and for the translators. */
2699 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2701 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2703 if (candidate->num_convs == 3)
2704 inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2705 candidate->convs[0]->type,
2706 candidate->convs[1]->type,
2707 candidate->convs[2]->type);
2708 else if (candidate->num_convs == 2)
2709 inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2710 candidate->convs[0]->type,
2711 candidate->convs[1]->type);
2713 inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2714 candidate->convs[0]->type);
2716 else if (TYPE_P (candidate->fn))
2717 inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2718 else if (candidate->viable == -1)
2719 inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2720 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
2721 inform (input_location, "%s %+#D <deleted>", msgstr, candidate->fn);
2723 inform (input_location, "%s %+#D", msgstr, candidate->fn);
2727 print_z_candidates (struct z_candidate *candidates)
2730 struct z_candidate *cand1;
2731 struct z_candidate **cand2;
2737 /* Remove deleted candidates. */
2739 for (cand2 = &cand1; *cand2; )
2741 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2742 && DECL_DELETED_FN ((*cand2)->fn))
2743 *cand2 = (*cand2)->next;
2745 cand2 = &(*cand2)->next;
2747 /* ...if there are any non-deleted ones. */
2751 /* There may be duplicates in the set of candidates. We put off
2752 checking this condition as long as possible, since we have no way
2753 to eliminate duplicates from a set of functions in less than n^2
2754 time. Now we are about to emit an error message, so it is more
2755 permissible to go slowly. */
2756 for (cand1 = candidates; cand1; cand1 = cand1->next)
2758 tree fn = cand1->fn;
2759 /* Skip builtin candidates and conversion functions. */
2762 cand2 = &cand1->next;
2765 if (DECL_P ((*cand2)->fn)
2766 && equal_functions (fn, (*cand2)->fn))
2767 *cand2 = (*cand2)->next;
2769 cand2 = &(*cand2)->next;
2773 str = candidates->next ? _("candidates are:") : _("candidate is:");
2775 for (; candidates; candidates = candidates->next)
2777 print_z_candidate (spaces ? spaces : str, candidates);
2778 spaces = spaces ? spaces : get_spaces (str);
2783 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2784 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2785 the result of the conversion function to convert it to the final
2786 desired type. Merge the two sequences into a single sequence,
2787 and return the merged sequence. */
2790 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2794 gcc_assert (user_seq->kind == ck_user);
2796 /* Find the end of the second conversion sequence. */
2798 while ((*t)->kind != ck_identity)
2799 t = &((*t)->u.next);
2801 /* Replace the identity conversion with the user conversion
2805 /* The entire sequence is a user-conversion sequence. */
2806 std_seq->user_conv_p = true;
2811 /* Returns the best overload candidate to perform the requested
2812 conversion. This function is used for three the overloading situations
2813 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2814 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2815 per [dcl.init.ref], so we ignore temporary bindings. */
2817 static struct z_candidate *
2818 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2820 struct z_candidate *candidates, *cand;
2821 tree fromtype = TREE_TYPE (expr);
2822 tree ctors = NULL_TREE;
2823 tree conv_fns = NULL_TREE;
2824 conversion *conv = NULL;
2825 tree first_arg = NULL_TREE;
2826 VEC(tree,gc) *args = NULL;
2830 /* We represent conversion within a hierarchy using RVALUE_CONV and
2831 BASE_CONV, as specified by [over.best.ics]; these become plain
2832 constructor calls, as specified in [dcl.init]. */
2833 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
2834 || !DERIVED_FROM_P (totype, fromtype));
2836 if (MAYBE_CLASS_TYPE_P (totype))
2837 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2839 if (MAYBE_CLASS_TYPE_P (fromtype))
2841 tree to_nonref = non_reference (totype);
2842 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
2843 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
2844 && DERIVED_FROM_P (to_nonref, fromtype)))
2846 /* [class.conv.fct] A conversion function is never used to
2847 convert a (possibly cv-qualified) object to the (possibly
2848 cv-qualified) same object type (or a reference to it), to a
2849 (possibly cv-qualified) base class of that type (or a
2850 reference to it)... */
2853 conv_fns = lookup_conversions (fromtype,
2854 /*lookup_template_convs_p=*/true);
2858 flags |= LOOKUP_NO_CONVERSION;
2859 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2860 flags |= LOOKUP_NO_NARROWING;
2862 /* It's OK to bind a temporary for converting constructor arguments, but
2863 not in converting the return value of a conversion operator. */
2864 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
2865 flags &= ~LOOKUP_NO_TEMP_BIND;
2869 int ctorflags = flags;
2870 bool try_single_arg = true;
2871 ctors = BASELINK_FUNCTIONS (ctors);
2873 first_arg = build_int_cst (build_pointer_type (totype), 0);
2874 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2876 /* For list-initialization we consider explicit constructors, but
2877 give an error if one is selected. */
2878 ctorflags &= ~LOOKUP_ONLYCONVERTING;
2879 /* If the class has a list ctor, try passing the list as a single
2880 argument first, but only consider list ctors. */
2881 if (TYPE_HAS_LIST_CTOR (totype))
2882 ctorflags |= LOOKUP_LIST_ONLY;
2884 try_single_arg = false;
2887 /* We should never try to call the abstract or base constructor
2889 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2890 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2892 /* If EXPR is not an initializer-list, or if totype has a list
2893 constructor, try EXPR as a single argument. */
2896 args = make_tree_vector_single (expr);
2897 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
2898 TYPE_BINFO (totype), TYPE_BINFO (totype),
2899 ctorflags, &candidates);
2902 /* If we didn't find a suitable list constructor for an initializer-list,
2903 try breaking it apart. */
2904 if (!candidates && BRACE_ENCLOSED_INITIALIZER_P (expr))
2906 args = ctor_to_vec (expr);
2907 /* We aren't looking for list-ctors anymore. */
2908 ctorflags &= ~LOOKUP_LIST_ONLY;
2909 /* We still allow more conversions within an init-list. */
2910 ctorflags &= ~LOOKUP_NO_CONVERSION;
2911 /* But not for the copy ctor. */
2912 ctorflags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
2913 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
2914 TYPE_BINFO (totype), TYPE_BINFO (totype),
2915 ctorflags, &candidates);
2918 for (cand = candidates; cand; cand = cand->next)
2920 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2922 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
2923 set, then this is copy-initialization. In that case, "The
2924 result of the call is then used to direct-initialize the
2925 object that is the destination of the copy-initialization."
2928 We represent this in the conversion sequence with an
2929 rvalue conversion, which means a constructor call. */
2930 if (TREE_CODE (totype) != REFERENCE_TYPE
2931 && !(convflags & LOOKUP_NO_TEMP_BIND))
2933 = build_conv (ck_rvalue, totype, cand->second_conv);
2938 first_arg = build_this (expr);
2940 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2942 tree conversion_path = TREE_PURPOSE (conv_fns);
2943 struct z_candidate *old_candidates;
2945 /* If we are called to convert to a reference type, we are trying to
2946 find an lvalue binding, so don't even consider temporaries. If
2947 we don't find an lvalue binding, the caller will try again to
2948 look for a temporary binding. */
2949 if (TREE_CODE (totype) == REFERENCE_TYPE)
2950 convflags |= LOOKUP_NO_TEMP_BIND;
2952 old_candidates = candidates;
2953 add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
2955 conversion_path, TYPE_BINFO (fromtype),
2956 flags, &candidates);
2958 for (cand = candidates; cand != old_candidates; cand = cand->next)
2961 = implicit_conversion (totype,
2962 TREE_TYPE (TREE_TYPE (cand->fn)),
2964 /*c_cast_p=*/false, convflags);
2966 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
2967 copy-initialization. In that case, "The result of the
2968 call is then used to direct-initialize the object that is
2969 the destination of the copy-initialization." [dcl.init]
2971 We represent this in the conversion sequence with an
2972 rvalue conversion, which means a constructor call. But
2973 don't add a second rvalue conversion if there's already
2974 one there. Which there really shouldn't be, but it's
2975 harmless since we'd add it here anyway. */
2976 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
2977 && !(convflags & LOOKUP_NO_TEMP_BIND))
2978 ics = build_conv (ck_rvalue, totype, ics);
2980 cand->second_conv = ics;
2984 else if (cand->viable == 1 && ics->bad_p)
2989 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2993 cand = tourney (candidates);
2996 if (flags & LOOKUP_COMPLAIN)
2998 error ("conversion from %qT to %qT is ambiguous",
3000 print_z_candidates (candidates);
3003 cand = candidates; /* any one will do */
3004 cand->second_conv = build_ambiguous_conv (totype, expr);
3005 cand->second_conv->user_conv_p = true;
3006 if (!any_strictly_viable (candidates))
3007 cand->second_conv->bad_p = true;
3008 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3009 ambiguous conversion is no worse than another user-defined
3015 /* Build the user conversion sequence. */
3018 (DECL_CONSTRUCTOR_P (cand->fn)
3019 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3020 build_identity_conv (TREE_TYPE (expr), expr));
3023 /* Remember that this was a list-initialization. */
3024 if (flags & LOOKUP_NO_NARROWING)
3025 conv->check_narrowing = true;
3027 /* Combine it with the second conversion sequence. */
3028 cand->second_conv = merge_conversion_sequences (conv,
3031 if (cand->viable == -1)
3032 cand->second_conv->bad_p = true;
3038 build_user_type_conversion (tree totype, tree expr, int flags)
3040 struct z_candidate *cand
3041 = build_user_type_conversion_1 (totype, expr, flags);
3045 if (cand->second_conv->kind == ck_ambig)
3046 return error_mark_node;
3047 expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3048 return convert_from_reference (expr);
3053 /* Do any initial processing on the arguments to a function call. */
3055 static VEC(tree,gc) *
3056 resolve_args (VEC(tree,gc) *args)
3061 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
3063 if (error_operand_p (arg))
3065 else if (VOID_TYPE_P (TREE_TYPE (arg)))
3067 error ("invalid use of void expression");
3070 else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3076 /* Perform overload resolution on FN, which is called with the ARGS.
3078 Return the candidate function selected by overload resolution, or
3079 NULL if the event that overload resolution failed. In the case
3080 that overload resolution fails, *CANDIDATES will be the set of
3081 candidates considered, and ANY_VIABLE_P will be set to true or
3082 false to indicate whether or not any of the candidates were
3085 The ARGS should already have gone through RESOLVE_ARGS before this
3086 function is called. */
3088 static struct z_candidate *
3089 perform_overload_resolution (tree fn,
3090 const VEC(tree,gc) *args,
3091 struct z_candidate **candidates,
3094 struct z_candidate *cand;
3095 tree explicit_targs = NULL_TREE;
3096 int template_only = 0;
3099 *any_viable_p = true;
3102 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3103 || TREE_CODE (fn) == TEMPLATE_DECL
3104 || TREE_CODE (fn) == OVERLOAD
3105 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3107 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3109 explicit_targs = TREE_OPERAND (fn, 1);
3110 fn = TREE_OPERAND (fn, 0);
3114 /* Add the various candidate functions. */
3115 add_candidates (fn, NULL_TREE, args, NULL_TREE,
3116 explicit_targs, template_only,
3117 /*conversion_path=*/NULL_TREE,
3118 /*access_path=*/NULL_TREE,
3122 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3126 cand = tourney (*candidates);
3130 /* Return an expression for a call to FN (a namespace-scope function,
3131 or a static member function) with the ARGS. This may change
3135 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3136 tsubst_flags_t complain)
3138 struct z_candidate *candidates, *cand;
3143 if (args != NULL && *args != NULL)
3145 *args = resolve_args (*args);
3147 return error_mark_node;
3150 /* If this function was found without using argument dependent
3151 lookup, then we want to ignore any undeclared friend
3157 fn = remove_hidden_names (fn);
3160 if (complain & tf_error)
3161 error ("no matching function for call to %<%D(%A)%>",
3162 DECL_NAME (OVL_CURRENT (orig_fn)),
3163 build_tree_list_vec (*args));
3164 return error_mark_node;
3168 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3169 p = conversion_obstack_alloc (0);
3171 cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3175 if (complain & tf_error)
3177 if (!any_viable_p && candidates && ! candidates->next
3178 && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3179 return cp_build_function_call_vec (candidates->fn, args, complain);
3180 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3181 fn = TREE_OPERAND (fn, 0);
3183 error ("no matching function for call to %<%D(%A)%>",
3184 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3186 error ("call of overloaded %<%D(%A)%> is ambiguous",
3187 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3189 print_z_candidates (candidates);
3191 result = error_mark_node;
3194 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3196 /* Free all the conversions we allocated. */
3197 obstack_free (&conversion_obstack, p);
3202 /* Build a call to a global operator new. FNNAME is the name of the
3203 operator (either "operator new" or "operator new[]") and ARGS are
3204 the arguments provided. This may change ARGS. *SIZE points to the
3205 total number of bytes required by the allocation, and is updated if
3206 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3207 be used. If this function determines that no cookie should be
3208 used, after all, *COOKIE_SIZE is set to NULL_TREE. If FN is
3209 non-NULL, it will be set, upon return, to the allocation function
3213 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3214 tree *size, tree *cookie_size,
3218 struct z_candidate *candidates;
3219 struct z_candidate *cand;
3224 VEC_safe_insert (tree, gc, *args, 0, *size);
3225 *args = resolve_args (*args);
3227 return error_mark_node;
3233 If this lookup fails to find the name, or if the allocated type
3234 is not a class type, the allocation function's name is looked
3235 up in the global scope.
3237 we disregard block-scope declarations of "operator new". */
3238 fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3240 /* Figure out what function is being called. */
3241 cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3243 /* If no suitable function could be found, issue an error message
3248 error ("no matching function for call to %<%D(%A)%>",
3249 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3251 error ("call of overloaded %<%D(%A)%> is ambiguous",
3252 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3254 print_z_candidates (candidates);
3255 return error_mark_node;
3258 /* If a cookie is required, add some extra space. Whether
3259 or not a cookie is required cannot be determined until
3260 after we know which function was called. */
3263 bool use_cookie = true;
3264 if (!abi_version_at_least (2))
3266 /* In G++ 3.2, the check was implemented incorrectly; it
3267 looked at the placement expression, rather than the
3268 type of the function. */
3269 if (VEC_length (tree, *args) == 2
3270 && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3278 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3279 /* Skip the size_t parameter. */
3280 arg_types = TREE_CHAIN (arg_types);
3281 /* Check the remaining parameters (if any). */
3283 && TREE_CHAIN (arg_types) == void_list_node
3284 && same_type_p (TREE_VALUE (arg_types),
3288 /* If we need a cookie, adjust the number of bytes allocated. */
3291 /* Update the total size. */
3292 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3293 /* Update the argument list to reflect the adjusted size. */
3294 VEC_replace (tree, *args, 0, *size);
3297 *cookie_size = NULL_TREE;
3300 /* Tell our caller which function we decided to call. */
3304 /* Build the CALL_EXPR. */
3305 return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3308 /* Build a new call to operator(). This may change ARGS. */
3311 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3313 struct z_candidate *candidates = 0, *cand;
3314 tree fns, convs, first_mem_arg = NULL_TREE;
3315 tree type = TREE_TYPE (obj);
3317 tree result = NULL_TREE;
3320 if (error_operand_p (obj))
3321 return error_mark_node;
3323 obj = prep_operand (obj);
3325 if (TYPE_PTRMEMFUNC_P (type))
3327 if (complain & tf_error)
3328 /* It's no good looking for an overloaded operator() on a
3329 pointer-to-member-function. */
3330 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3331 return error_mark_node;
3334 if (TYPE_BINFO (type))
3336 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3337 if (fns == error_mark_node)
3338 return error_mark_node;
3343 if (args != NULL && *args != NULL)
3345 *args = resolve_args (*args);
3347 return error_mark_node;
3350 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3351 p = conversion_obstack_alloc (0);
3355 first_mem_arg = build_this (obj);
3357 add_candidates (BASELINK_FUNCTIONS (fns),
3358 first_mem_arg, *args, NULL_TREE,
3360 BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
3361 LOOKUP_NORMAL, &candidates);
3364 convs = lookup_conversions (type, /*lookup_template_convs_p=*/true);
3366 for (; convs; convs = TREE_CHAIN (convs))
3368 tree fns = TREE_VALUE (convs);
3369 tree totype = TREE_TYPE (convs);
3371 if ((TREE_CODE (totype) == POINTER_TYPE
3372 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3373 || (TREE_CODE (totype) == REFERENCE_TYPE
3374 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3375 || (TREE_CODE (totype) == REFERENCE_TYPE
3376 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3377 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3378 for (; fns; fns = OVL_NEXT (fns))
3380 tree fn = OVL_CURRENT (fns);
3382 if (DECL_NONCONVERTING_P (fn))
3385 if (TREE_CODE (fn) == TEMPLATE_DECL)
3386 add_template_conv_candidate
3387 (&candidates, fn, obj, NULL_TREE, *args, totype,
3388 /*access_path=*/NULL_TREE,
3389 /*conversion_path=*/NULL_TREE);
3391 add_conv_candidate (&candidates, fn, obj, NULL_TREE,
3392 *args, /*conversion_path=*/NULL_TREE,
3393 /*access_path=*/NULL_TREE);
3397 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3400 if (complain & tf_error)
3402 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
3403 build_tree_list_vec (*args));
3404 print_z_candidates (candidates);
3406 result = error_mark_node;
3410 cand = tourney (candidates);
3413 if (complain & tf_error)
3415 error ("call of %<(%T) (%A)%> is ambiguous",
3416 TREE_TYPE (obj), build_tree_list_vec (*args));
3417 print_z_candidates (candidates);
3419 result = error_mark_node;
3421 /* Since cand->fn will be a type, not a function, for a conversion
3422 function, we must be careful not to unconditionally look at
3424 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3425 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3426 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3429 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
3431 obj = convert_from_reference (obj);
3432 result = cp_build_function_call_vec (obj, args, complain);
3436 /* Free all the conversions we allocated. */
3437 obstack_free (&conversion_obstack, p);
3443 op_error (enum tree_code code, enum tree_code code2,
3444 tree arg1, tree arg2, tree arg3, bool match)
3448 if (code == MODIFY_EXPR)
3449 opname = assignment_operator_name_info[code2].name;
3451 opname = operator_name_info[code].name;
3457 error ("ambiguous overload for ternary %<operator?:%> "
3458 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3460 error ("no match for ternary %<operator?:%> "
3461 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3464 case POSTINCREMENT_EXPR:
3465 case POSTDECREMENT_EXPR:
3467 error ("ambiguous overload for %<operator%s%> in %<%E%s%>",
3468 opname, arg1, opname);
3470 error ("no match for %<operator%s%> in %<%E%s%>",
3471 opname, arg1, opname);
3476 error ("ambiguous overload for %<operator[]%> in %<%E[%E]%>",
3479 error ("no match for %<operator[]%> in %<%E[%E]%>",
3486 error ("ambiguous overload for %qs in %<%s %E%>",
3487 opname, opname, arg1);
3489 error ("no match for %qs in %<%s %E%>",
3490 opname, opname, arg1);
3496 error ("ambiguous overload for %<operator%s%> in %<%E %s %E%>",
3497 opname, arg1, opname, arg2);
3499 error ("no match for %<operator%s%> in %<%E %s %E%>",
3500 opname, arg1, opname, arg2);
3503 error ("ambiguous overload for %<operator%s%> in %<%s%E%>",
3504 opname, opname, arg1);
3506 error ("no match for %<operator%s%> in %<%s%E%>",
3507 opname, opname, arg1);
3512 /* Return the implicit conversion sequence that could be used to
3513 convert E1 to E2 in [expr.cond]. */
3516 conditional_conversion (tree e1, tree e2)
3518 tree t1 = non_reference (TREE_TYPE (e1));
3519 tree t2 = non_reference (TREE_TYPE (e2));
3525 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3526 implicitly converted (clause _conv_) to the type "reference to
3527 T2", subject to the constraint that in the conversion the
3528 reference must bind directly (_dcl.init.ref_) to E1. */
3529 if (real_lvalue_p (e2))
3531 conv = implicit_conversion (build_reference_type (t2),
3535 LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING);
3542 If E1 and E2 have class type, and the underlying class types are
3543 the same or one is a base class of the other: E1 can be converted
3544 to match E2 if the class of T2 is the same type as, or a base
3545 class of, the class of T1, and the cv-qualification of T2 is the
3546 same cv-qualification as, or a greater cv-qualification than, the
3547 cv-qualification of T1. If the conversion is applied, E1 is
3548 changed to an rvalue of type T2 that still refers to the original
3549 source class object (or the appropriate subobject thereof). */
3550 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3551 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3553 if (good_base && at_least_as_qualified_p (t2, t1))
3555 conv = build_identity_conv (t1, e1);
3556 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3557 TYPE_MAIN_VARIANT (t2)))
3558 conv = build_conv (ck_base, t2, conv);
3560 conv = build_conv (ck_rvalue, t2, conv);
3569 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3570 converted to the type that expression E2 would have if E2 were
3571 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3572 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3576 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3577 arguments to the conditional expression. */
3580 build_conditional_expr (tree arg1, tree arg2, tree arg3,
3581 tsubst_flags_t complain)
3585 tree result = NULL_TREE;
3587 tree result_type = NULL_TREE;
3588 bool lvalue_p = true;
3589 struct z_candidate *candidates = 0;
3590 struct z_candidate *cand;
3593 /* As a G++ extension, the second argument to the conditional can be
3594 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3595 c'.) If the second operand is omitted, make sure it is
3596 calculated only once. */
3599 if (complain & tf_error)
3600 pedwarn (input_location, OPT_pedantic,
3601 "ISO C++ forbids omitting the middle term of a ?: expression");
3603 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3604 if (real_lvalue_p (arg1))
3605 arg2 = arg1 = stabilize_reference (arg1);
3607 arg2 = arg1 = save_expr (arg1);
3612 The first expression is implicitly converted to bool (clause
3614 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
3617 /* If something has already gone wrong, just pass that fact up the
3619 if (error_operand_p (arg1)
3620 || error_operand_p (arg2)
3621 || error_operand_p (arg3))
3622 return error_mark_node;
3626 If either the second or the third operand has type (possibly
3627 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3628 array-to-pointer (_conv.array_), and function-to-pointer
3629 (_conv.func_) standard conversions are performed on the second
3630 and third operands. */
3631 arg2_type = unlowered_expr_type (arg2);
3632 arg3_type = unlowered_expr_type (arg3);
3633 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3635 /* Do the conversions. We don't these for `void' type arguments
3636 since it can't have any effect and since decay_conversion
3637 does not handle that case gracefully. */
3638 if (!VOID_TYPE_P (arg2_type))
3639 arg2 = decay_conversion (arg2);
3640 if (!VOID_TYPE_P (arg3_type))
3641 arg3 = decay_conversion (arg3);
3642 arg2_type = TREE_TYPE (arg2);
3643 arg3_type = TREE_TYPE (arg3);
3647 One of the following shall hold:
3649 --The second or the third operand (but not both) is a
3650 throw-expression (_except.throw_); the result is of the
3651 type of the other and is an rvalue.
3653 --Both the second and the third operands have type void; the
3654 result is of type void and is an rvalue.
3656 We must avoid calling force_rvalue for expressions of type
3657 "void" because it will complain that their value is being
3659 if (TREE_CODE (arg2) == THROW_EXPR
3660 && TREE_CODE (arg3) != THROW_EXPR)
3662 if (!VOID_TYPE_P (arg3_type))
3663 arg3 = force_rvalue (arg3);
3664 arg3_type = TREE_TYPE (arg3);
3665 result_type = arg3_type;
3667 else if (TREE_CODE (arg2) != THROW_EXPR
3668 && TREE_CODE (arg3) == THROW_EXPR)
3670 if (!VOID_TYPE_P (arg2_type))
3671 arg2 = force_rvalue (arg2);
3672 arg2_type = TREE_TYPE (arg2);
3673 result_type = arg2_type;
3675 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3676 result_type = void_type_node;
3679 if (complain & tf_error)
3681 if (VOID_TYPE_P (arg2_type))
3682 error ("second operand to the conditional operator "
3683 "is of type %<void%>, "
3684 "but the third operand is neither a throw-expression "
3685 "nor of type %<void%>");
3687 error ("third operand to the conditional operator "
3688 "is of type %<void%>, "
3689 "but the second operand is neither a throw-expression "
3690 "nor of type %<void%>");
3692 return error_mark_node;
3696 goto valid_operands;
3700 Otherwise, if the second and third operand have different types,
3701 and either has (possibly cv-qualified) class type, an attempt is
3702 made to convert each of those operands to the type of the other. */
3703 else if (!same_type_p (arg2_type, arg3_type)
3704 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3709 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3710 p = conversion_obstack_alloc (0);
3712 conv2 = conditional_conversion (arg2, arg3);
3713 conv3 = conditional_conversion (arg3, arg2);
3717 If both can be converted, or one can be converted but the
3718 conversion is ambiguous, the program is ill-formed. If
3719 neither can be converted, the operands are left unchanged and
3720 further checking is performed as described below. If exactly
3721 one conversion is possible, that conversion is applied to the
3722 chosen operand and the converted operand is used in place of
3723 the original operand for the remainder of this section. */
3724 if ((conv2 && !conv2->bad_p
3725 && conv3 && !conv3->bad_p)
3726 || (conv2 && conv2->kind == ck_ambig)
3727 || (conv3 && conv3->kind == ck_ambig))
3729 error ("operands to ?: have different types %qT and %qT",
3730 arg2_type, arg3_type);
3731 result = error_mark_node;
3733 else if (conv2 && (!conv2->bad_p || !conv3))
3735 arg2 = convert_like (conv2, arg2, complain);
3736 arg2 = convert_from_reference (arg2);
3737 arg2_type = TREE_TYPE (arg2);
3738 /* Even if CONV2 is a valid conversion, the result of the
3739 conversion may be invalid. For example, if ARG3 has type
3740 "volatile X", and X does not have a copy constructor
3741 accepting a "volatile X&", then even if ARG2 can be
3742 converted to X, the conversion will fail. */
3743 if (error_operand_p (arg2))
3744 result = error_mark_node;
3746 else if (conv3 && (!conv3->bad_p || !conv2))
3748 arg3 = convert_like (conv3, arg3, complain);
3749 arg3 = convert_from_reference (arg3);
3750 arg3_type = TREE_TYPE (arg3);
3751 if (error_operand_p (arg3))
3752 result = error_mark_node;
3755 /* Free all the conversions we allocated. */
3756 obstack_free (&conversion_obstack, p);
3761 /* If, after the conversion, both operands have class type,
3762 treat the cv-qualification of both operands as if it were the
3763 union of the cv-qualification of the operands.
3765 The standard is not clear about what to do in this
3766 circumstance. For example, if the first operand has type
3767 "const X" and the second operand has a user-defined
3768 conversion to "volatile X", what is the type of the second
3769 operand after this step? Making it be "const X" (matching
3770 the first operand) seems wrong, as that discards the
3771 qualification without actually performing a copy. Leaving it
3772 as "volatile X" seems wrong as that will result in the
3773 conditional expression failing altogether, even though,
3774 according to this step, the one operand could be converted to
3775 the type of the other. */
3776 if ((conv2 || conv3)
3777 && CLASS_TYPE_P (arg2_type)
3778 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3779 arg2_type = arg3_type =
3780 cp_build_qualified_type (arg2_type,
3781 TYPE_QUALS (arg2_type)
3782 | TYPE_QUALS (arg3_type));
3787 If the second and third operands are lvalues and have the same
3788 type, the result is of that type and is an lvalue. */
3789 if (real_lvalue_p (arg2)
3790 && real_lvalue_p (arg3)
3791 && same_type_p (arg2_type, arg3_type))
3793 result_type = arg2_type;
3794 goto valid_operands;
3799 Otherwise, the result is an rvalue. If the second and third
3800 operand do not have the same type, and either has (possibly
3801 cv-qualified) class type, overload resolution is used to
3802 determine the conversions (if any) to be applied to the operands
3803 (_over.match.oper_, _over.built_). */
3805 if (!same_type_p (arg2_type, arg3_type)
3806 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3812 /* Rearrange the arguments so that add_builtin_candidate only has
3813 to know about two args. In build_builtin_candidate, the
3814 arguments are unscrambled. */
3818 add_builtin_candidates (&candidates,
3821 ansi_opname (COND_EXPR),
3827 If the overload resolution fails, the program is
3829 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3832 if (complain & tf_error)
3834 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3835 print_z_candidates (candidates);
3837 return error_mark_node;
3839 cand = tourney (candidates);
3842 if (complain & tf_error)
3844 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3845 print_z_candidates (candidates);
3847 return error_mark_node;
3852 Otherwise, the conversions thus determined are applied, and
3853 the converted operands are used in place of the original
3854 operands for the remainder of this section. */
3855 conv = cand->convs[0];
3856 arg1 = convert_like (conv, arg1, complain);
3857 conv = cand->convs[1];
3858 arg2 = convert_like (conv, arg2, complain);
3859 arg2_type = TREE_TYPE (arg2);
3860 conv = cand->convs[2];
3861 arg3 = convert_like (conv, arg3, complain);
3862 arg3_type = TREE_TYPE (arg3);
3867 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3868 and function-to-pointer (_conv.func_) standard conversions are
3869 performed on the second and third operands.
3871 We need to force the lvalue-to-rvalue conversion here for class types,
3872 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3873 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3876 arg2 = force_rvalue (arg2);
3877 if (!CLASS_TYPE_P (arg2_type))
3878 arg2_type = TREE_TYPE (arg2);
3880 arg3 = force_rvalue (arg3);
3881 if (!CLASS_TYPE_P (arg3_type))
3882 arg3_type = TREE_TYPE (arg3);
3884 if (arg2 == error_mark_node || arg3 == error_mark_node)
3885 return error_mark_node;
3889 After those conversions, one of the following shall hold:
3891 --The second and third operands have the same type; the result is of
3893 if (same_type_p (arg2_type, arg3_type))
3894 result_type = arg2_type;
3897 --The second and third operands have arithmetic or enumeration
3898 type; the usual arithmetic conversions are performed to bring
3899 them to a common type, and the result is of that type. */
3900 else if ((ARITHMETIC_TYPE_P (arg2_type)
3901 || UNSCOPED_ENUM_P (arg2_type))
3902 && (ARITHMETIC_TYPE_P (arg3_type)
3903 || UNSCOPED_ENUM_P (arg3_type)))
3905 /* In this case, there is always a common type. */
3906 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3909 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3910 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3912 if (complain & tf_warning)
3914 "enumeral mismatch in conditional expression: %qT vs %qT",
3915 arg2_type, arg3_type);
3917 else if (extra_warnings
3918 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3919 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3920 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3921 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3923 if (complain & tf_warning)
3925 "enumeral and non-enumeral type in conditional expression");
3928 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3929 arg3 = perform_implicit_conversion (result_type, arg3, complain);
3933 --The second and third operands have pointer type, or one has
3934 pointer type and the other is a null pointer constant; pointer
3935 conversions (_conv.ptr_) and qualification conversions
3936 (_conv.qual_) are performed to bring them to their composite
3937 pointer type (_expr.rel_). The result is of the composite
3940 --The second and third operands have pointer to member type, or
3941 one has pointer to member type and the other is a null pointer
3942 constant; pointer to member conversions (_conv.mem_) and
3943 qualification conversions (_conv.qual_) are performed to bring
3944 them to a common type, whose cv-qualification shall match the
3945 cv-qualification of either the second or the third operand.
3946 The result is of the common type. */
3947 else if ((null_ptr_cst_p (arg2)
3948 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3949 || (null_ptr_cst_p (arg3)
3950 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3951 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3952 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3953 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3955 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3956 arg3, CPO_CONDITIONAL_EXPR,
3958 if (result_type == error_mark_node)
3959 return error_mark_node;
3960 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3961 arg3 = perform_implicit_conversion (result_type, arg3, complain);
3966 if (complain & tf_error)
3967 error ("operands to ?: have different types %qT and %qT",
3968 arg2_type, arg3_type);
3969 return error_mark_node;
3973 result_save = build3 (COND_EXPR, result_type, arg1, arg2, arg3);
3974 result = fold_if_not_in_template (result_save);
3976 if (cp_unevaluated_operand && TREE_CODE (result) == CALL_EXPR)
3977 /* Avoid folding to a CALL_EXPR within decltype (c++/42013). */
3978 result = result_save;
3980 /* We can't use result_type below, as fold might have returned a
3985 /* Expand both sides into the same slot, hopefully the target of
3986 the ?: expression. We used to check for TARGET_EXPRs here,
3987 but now we sometimes wrap them in NOP_EXPRs so the test would
3989 if (CLASS_TYPE_P (TREE_TYPE (result)))
3990 result = get_target_expr (result);
3991 /* If this expression is an rvalue, but might be mistaken for an
3992 lvalue, we must add a NON_LVALUE_EXPR. */
3993 result = rvalue (result);
3999 /* OPERAND is an operand to an expression. Perform necessary steps
4000 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4004 prep_operand (tree operand)
4008 if (CLASS_TYPE_P (TREE_TYPE (operand))
4009 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
4010 /* Make sure the template type is instantiated now. */
4011 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
4017 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4018 OVERLOAD) to the CANDIDATES, returning an updated list of
4019 CANDIDATES. The ARGS are the arguments provided to the call;
4020 if FIRST_ARG is non-null it is the implicit object argument,
4021 otherwise the first element of ARGS is used if needed. The
4022 EXPLICIT_TARGS are explicit template arguments provided.
4023 TEMPLATE_ONLY is true if only template functions should be
4024 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4025 add_function_candidate. */
4028 add_candidates (tree fns, tree first_arg, const VEC(tree,gc) *args,
4030 tree explicit_targs, bool template_only,
4031 tree conversion_path, tree access_path,
4033 struct z_candidate **candidates)
4036 const VEC(tree,gc) *non_static_args;
4037 bool check_list_ctor;
4038 bool check_converting;
4039 unification_kind_t strict;
4045 /* Precalculate special handling of constructors and conversion ops. */
4046 fn = OVL_CURRENT (fns);
4047 if (DECL_CONV_FN_P (fn))
4049 check_list_ctor = false;
4050 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4051 if (flags & LOOKUP_NO_CONVERSION)
4052 /* We're doing return_type(x). */
4053 strict = DEDUCE_CONV;
4055 /* We're doing x.operator return_type(). */
4056 strict = DEDUCE_EXACT;
4057 /* [over.match.funcs] For conversion functions, the function
4058 is considered to be a member of the class of the implicit
4059 object argument for the purpose of defining the type of
4060 the implicit object parameter. */
4061 ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
4065 if (DECL_CONSTRUCTOR_P (fn))
4067 check_list_ctor = !!(flags & LOOKUP_LIST_ONLY);
4068 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4072 check_list_ctor = false;
4073 check_converting = false;
4075 strict = DEDUCE_CALL;
4076 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
4080 non_static_args = args;
4082 /* Delay creating the implicit this parameter until it is needed. */
4083 non_static_args = NULL;
4085 for (; fns; fns = OVL_NEXT (fns))
4088 const VEC(tree,gc) *fn_args;
4090 fn = OVL_CURRENT (fns);
4092 if (check_converting && DECL_NONCONVERTING_P (fn))
4094 if (check_list_ctor && !is_list_ctor (fn))
4097 /* Figure out which set of arguments to use. */
4098 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
4100 /* If this function is a non-static member and we didn't get an
4101 implicit object argument, move it out of args. */
4102 if (first_arg == NULL_TREE)
4106 VEC(tree,gc) *tempvec
4107 = VEC_alloc (tree, gc, VEC_length (tree, args) - 1);
4108 for (ix = 1; VEC_iterate (tree, args, ix, arg); ++ix)
4109 VEC_quick_push (tree, tempvec, arg);
4110 non_static_args = tempvec;
4111 first_arg = build_this (VEC_index (tree, args, 0));
4114 fn_first_arg = first_arg;
4115 fn_args = non_static_args;
4119 /* Otherwise, just use the list of arguments provided. */
4120 fn_first_arg = NULL_TREE;
4124 if (TREE_CODE (fn) == TEMPLATE_DECL)
4125 add_template_candidate (candidates,
4136 else if (!template_only)
4137 add_function_candidate (candidates,
4148 /* Even unsigned enum types promote to signed int. We don't want to
4149 issue -Wsign-compare warnings for this case. Here ORIG_ARG is the
4150 original argument and ARG is the argument after any conversions
4151 have been applied. We set TREE_NO_WARNING if we have added a cast
4152 from an unsigned enum type to a signed integer type. */
4155 avoid_sign_compare_warnings (tree orig_arg, tree arg)
4157 if (orig_arg != NULL_TREE
4160 && TREE_CODE (TREE_TYPE (orig_arg)) == ENUMERAL_TYPE
4161 && TYPE_UNSIGNED (TREE_TYPE (orig_arg))
4162 && INTEGRAL_TYPE_P (TREE_TYPE (arg))
4163 && !TYPE_UNSIGNED (TREE_TYPE (arg)))
4164 TREE_NO_WARNING (arg) = 1;
4168 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
4169 bool *overloaded_p, tsubst_flags_t complain)
4171 tree orig_arg1 = arg1;
4172 tree orig_arg2 = arg2;
4173 tree orig_arg3 = arg3;
4174 struct z_candidate *candidates = 0, *cand;
4175 VEC(tree,gc) *arglist;
4178 tree result = NULL_TREE;
4179 bool result_valid_p = false;
4180 enum tree_code code2 = NOP_EXPR;
4181 enum tree_code code_orig_arg1 = ERROR_MARK;
4182 enum tree_code code_orig_arg2 = ERROR_MARK;
4188 if (error_operand_p (arg1)
4189 || error_operand_p (arg2)
4190 || error_operand_p (arg3))
4191 return error_mark_node;
4193 if (code == MODIFY_EXPR)
4195 code2 = TREE_CODE (arg3);
4197 fnname = ansi_assopname (code2);
4200 fnname = ansi_opname (code);
4202 arg1 = prep_operand (arg1);
4208 case VEC_DELETE_EXPR:
4210 /* Use build_op_new_call and build_op_delete_call instead. */
4214 /* Use build_op_call instead. */
4217 case TRUTH_ORIF_EXPR:
4218 case TRUTH_ANDIF_EXPR:
4219 case TRUTH_AND_EXPR:
4221 /* These are saved for the sake of warn_logical_operator. */
4222 code_orig_arg1 = TREE_CODE (arg1);
4223 code_orig_arg2 = TREE_CODE (arg2);
4229 arg2 = prep_operand (arg2);
4230 arg3 = prep_operand (arg3);
4232 if (code == COND_EXPR)
4233 /* Use build_conditional_expr instead. */
4235 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4236 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4239 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4240 arg2 = integer_zero_node;
4242 arglist = VEC_alloc (tree, gc, 3);
4243 VEC_quick_push (tree, arglist, arg1);
4244 if (arg2 != NULL_TREE)
4245 VEC_quick_push (tree, arglist, arg2);
4246 if (arg3 != NULL_TREE)
4247 VEC_quick_push (tree, arglist, arg3);
4249 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4250 p = conversion_obstack_alloc (0);
4252 /* Add namespace-scope operators to the list of functions to
4254 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
4255 NULL_TREE, arglist, NULL_TREE,
4256 NULL_TREE, false, NULL_TREE, NULL_TREE,
4257 flags, &candidates);
4258 /* Add class-member operators to the candidate set. */
4259 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
4263 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
4264 if (fns == error_mark_node)
4266 result = error_mark_node;
4267 goto user_defined_result_ready;
4270 add_candidates (BASELINK_FUNCTIONS (fns),
4271 NULL_TREE, arglist, NULL_TREE,
4273 BASELINK_BINFO (fns),
4274 BASELINK_ACCESS_BINFO (fns),
4275 flags, &candidates);
4280 args[2] = NULL_TREE;
4282 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
4288 /* For these, the built-in candidates set is empty
4289 [over.match.oper]/3. We don't want non-strict matches
4290 because exact matches are always possible with built-in
4291 operators. The built-in candidate set for COMPONENT_REF
4292 would be empty too, but since there are no such built-in
4293 operators, we accept non-strict matches for them. */
4298 strict_p = pedantic;
4302 candidates = splice_viable (candidates, strict_p, &any_viable_p);
4307 case POSTINCREMENT_EXPR:
4308 case POSTDECREMENT_EXPR:
4309 /* Don't try anything fancy if we're not allowed to produce
4311 if (!(complain & tf_error))
4312 return error_mark_node;
4314 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
4315 distinguish between prefix and postfix ++ and
4316 operator++() was used for both, so we allow this with
4318 if (flags & LOOKUP_COMPLAIN)
4320 const char *msg = (flag_permissive)
4321 ? G_("no %<%D(int)%> declared for postfix %qs,"
4322 " trying prefix operator instead")
4323 : G_("no %<%D(int)%> declared for postfix %qs");
4324 permerror (input_location, msg, fnname,
4325 operator_name_info[code].name);
4328 if (!flag_permissive)
4329 return error_mark_node;
4331 if (code == POSTINCREMENT_EXPR)
4332 code = PREINCREMENT_EXPR;
4334 code = PREDECREMENT_EXPR;
4335 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
4336 overloaded_p, complain);
4339 /* The caller will deal with these. */
4344 result_valid_p = true;
4348 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4350 /* If one of the arguments of the operator represents
4351 an invalid use of member function pointer, try to report
4352 a meaningful error ... */
4353 if (invalid_nonstatic_memfn_p (arg1, tf_error)
4354 || invalid_nonstatic_memfn_p (arg2, tf_error)
4355 || invalid_nonstatic_memfn_p (arg3, tf_error))
4356 /* We displayed the error message. */;
4359 /* ... Otherwise, report the more generic
4360 "no matching operator found" error */
4361 op_error (code, code2, arg1, arg2, arg3, FALSE);
4362 print_z_candidates (candidates);
4365 result = error_mark_node;
4371 cand = tourney (candidates);
4374 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4376 op_error (code, code2, arg1, arg2, arg3, TRUE);
4377 print_z_candidates (candidates);
4379 result = error_mark_node;
4381 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
4384 *overloaded_p = true;
4386 if (resolve_args (arglist) == NULL)
4387 result = error_mark_node;
4389 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4393 /* Give any warnings we noticed during overload resolution. */
4394 if (cand->warnings && (complain & tf_warning))
4396 struct candidate_warning *w;
4397 for (w = cand->warnings; w; w = w->next)
4398 joust (cand, w->loser, 1);
4401 /* Check for comparison of different enum types. */
4410 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
4411 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
4412 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
4413 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
4414 && (complain & tf_warning))
4416 warning (OPT_Wenum_compare,
4417 "comparison between %q#T and %q#T",
4418 TREE_TYPE (arg1), TREE_TYPE (arg2));
4425 /* We need to strip any leading REF_BIND so that bitfields
4426 don't cause errors. This should not remove any important
4427 conversions, because builtins don't apply to class
4428 objects directly. */
4429 conv = cand->convs[0];
4430 if (conv->kind == ck_ref_bind)
4431 conv = conv->u.next;
4432 arg1 = convert_like (conv, arg1, complain);
4436 /* We need to call warn_logical_operator before
4437 converting arg2 to a boolean_type. */
4438 if (complain & tf_warning)
4439 warn_logical_operator (input_location, code, boolean_type_node,
4440 code_orig_arg1, arg1,
4441 code_orig_arg2, arg2);
4443 conv = cand->convs[1];
4444 if (conv->kind == ck_ref_bind)
4445 conv = conv->u.next;
4446 arg2 = convert_like (conv, arg2, complain);
4450 conv = cand->convs[2];
4451 if (conv->kind == ck_ref_bind)
4452 conv = conv->u.next;
4453 arg3 = convert_like (conv, arg3, complain);
4459 user_defined_result_ready:
4461 /* Free all the conversions we allocated. */
4462 obstack_free (&conversion_obstack, p);
4464 if (result || result_valid_p)
4468 avoid_sign_compare_warnings (orig_arg1, arg1);
4469 avoid_sign_compare_warnings (orig_arg2, arg2);
4470 avoid_sign_compare_warnings (orig_arg3, arg3);
4475 return cp_build_modify_expr (arg1, code2, arg2, complain);
4478 return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
4480 case TRUTH_ANDIF_EXPR:
4481 case TRUTH_ORIF_EXPR:
4482 case TRUTH_AND_EXPR:
4484 warn_logical_operator (input_location, code, boolean_type_node,
4485 code_orig_arg1, arg1, code_orig_arg2, arg2);
4490 case TRUNC_DIV_EXPR:
4501 case TRUNC_MOD_EXPR:
4505 return cp_build_binary_op (input_location, code, arg1, arg2, complain);
4507 case UNARY_PLUS_EXPR:
4510 case TRUTH_NOT_EXPR:
4511 case PREINCREMENT_EXPR:
4512 case POSTINCREMENT_EXPR:
4513 case PREDECREMENT_EXPR:
4514 case POSTDECREMENT_EXPR:
4517 return cp_build_unary_op (code, arg1, candidates != 0, complain);
4520 return build_array_ref (input_location, arg1, arg2, complain);
4523 return build_m_component_ref (cp_build_indirect_ref (arg1, RO_NULL,
4527 /* The caller will deal with these. */
4539 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
4540 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
4543 non_placement_deallocation_fn_p (tree t)
4545 /* A template instance is never a usual deallocation function,
4546 regardless of its signature. */
4547 if (TREE_CODE (t) == TEMPLATE_DECL
4548 || primary_template_instantiation_p (t))
4551 /* If a class T has a member deallocation function named operator delete
4552 with exactly one parameter, then that function is a usual
4553 (non-placement) deallocation function. If class T does not declare
4554 such an operator delete but does declare a member deallocation
4555 function named operator delete with exactly two parameters, the second
4556 of which has type std::size_t (18.2), then this function is a usual
4557 deallocation function. */
4558 t = FUNCTION_ARG_CHAIN (t);
4559 if (t == void_list_node
4560 || (t && same_type_p (TREE_VALUE (t), size_type_node)
4561 && TREE_CHAIN (t) == void_list_node))
4566 /* Build a call to operator delete. This has to be handled very specially,
4567 because the restrictions on what signatures match are different from all
4568 other call instances. For a normal delete, only a delete taking (void *)
4569 or (void *, size_t) is accepted. For a placement delete, only an exact
4570 match with the placement new is accepted.
4572 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4573 ADDR is the pointer to be deleted.
4574 SIZE is the size of the memory block to be deleted.
4575 GLOBAL_P is true if the delete-expression should not consider
4576 class-specific delete operators.
4577 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4579 If this call to "operator delete" is being generated as part to
4580 deallocate memory allocated via a new-expression (as per [expr.new]
4581 which requires that if the initialization throws an exception then
4582 we call a deallocation function), then ALLOC_FN is the allocation
4586 build_op_delete_call (enum tree_code code, tree addr, tree size,
4587 bool global_p, tree placement,
4590 tree fn = NULL_TREE;
4591 tree fns, fnname, type, t;
4593 if (addr == error_mark_node)
4594 return error_mark_node;
4596 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4598 fnname = ansi_opname (code);
4600 if (CLASS_TYPE_P (type)
4601 && COMPLETE_TYPE_P (complete_type (type))
4605 If the result of the lookup is ambiguous or inaccessible, or if
4606 the lookup selects a placement deallocation function, the
4607 program is ill-formed.
4609 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4611 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4612 if (fns == error_mark_node)
4613 return error_mark_node;
4618 if (fns == NULL_TREE)
4619 fns = lookup_name_nonclass (fnname);
4621 /* Strip const and volatile from addr. */
4622 addr = cp_convert (ptr_type_node, addr);
4626 /* "A declaration of a placement deallocation function matches the
4627 declaration of a placement allocation function if it has the same
4628 number of parameters and, after parameter transformations (8.3.5),
4629 all parameter types except the first are identical."
4631 So we build up the function type we want and ask instantiate_type
4632 to get it for us. */
4633 t = FUNCTION_ARG_CHAIN (alloc_fn);
4634 t = tree_cons (NULL_TREE, ptr_type_node, t);
4635 t = build_function_type (void_type_node, t);
4637 fn = instantiate_type (t, fns, tf_none);
4638 if (fn == error_mark_node)
4641 if (BASELINK_P (fn))
4642 fn = BASELINK_FUNCTIONS (fn);
4644 /* "If the lookup finds the two-parameter form of a usual deallocation
4645 function (3.7.4.2) and that function, considered as a placement
4646 deallocation function, would have been selected as a match for the
4647 allocation function, the program is ill-formed." */
4648 if (non_placement_deallocation_fn_p (fn))
4650 /* But if the class has an operator delete (void *), then that is
4651 the usual deallocation function, so we shouldn't complain
4652 about using the operator delete (void *, size_t). */
4653 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4654 t; t = OVL_NEXT (t))
4656 tree elt = OVL_CURRENT (t);
4657 if (non_placement_deallocation_fn_p (elt)
4658 && FUNCTION_ARG_CHAIN (elt) == void_list_node)
4661 permerror (0, "non-placement deallocation function %q+D", fn);
4662 permerror (input_location, "selected for placement delete");
4667 /* "Any non-placement deallocation function matches a non-placement
4668 allocation function. If the lookup finds a single matching
4669 deallocation function, that function will be called; otherwise, no
4670 deallocation function will be called." */
4671 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4672 t; t = OVL_NEXT (t))
4674 tree elt = OVL_CURRENT (t);
4675 if (non_placement_deallocation_fn_p (elt))
4678 /* "If a class T has a member deallocation function named
4679 operator delete with exactly one parameter, then that
4680 function is a usual (non-placement) deallocation
4681 function. If class T does not declare such an operator
4682 delete but does declare a member deallocation function named
4683 operator delete with exactly two parameters, the second of
4684 which has type std::size_t (18.2), then this function is a
4685 usual deallocation function."
4687 So (void*) beats (void*, size_t). */
4688 if (FUNCTION_ARG_CHAIN (fn) == void_list_node)
4693 /* If we have a matching function, call it. */
4696 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
4698 /* If the FN is a member function, make sure that it is
4700 if (BASELINK_P (fns))
4701 perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn);
4703 /* Core issue 901: It's ok to new a type with deleted delete. */
4704 if (DECL_DELETED_FN (fn) && alloc_fn)
4709 /* The placement args might not be suitable for overload
4710 resolution at this point, so build the call directly. */
4711 int nargs = call_expr_nargs (placement);
4712 tree *argarray = (tree *) alloca (nargs * sizeof (tree));
4715 for (i = 1; i < nargs; i++)
4716 argarray[i] = CALL_EXPR_ARG (placement, i);
4718 return build_cxx_call (fn, nargs, argarray);
4723 VEC(tree,gc) *args = VEC_alloc (tree, gc, 2);
4724 VEC_quick_push (tree, args, addr);
4725 if (FUNCTION_ARG_CHAIN (fn) != void_list_node)
4726 VEC_quick_push (tree, args, size);
4727 ret = cp_build_function_call_vec (fn, &args, tf_warning_or_error);
4728 VEC_free (tree, gc, args);
4735 If no unambiguous matching deallocation function can be found,
4736 propagating the exception does not cause the object's memory to
4741 warning (0, "no corresponding deallocation function for %qD",
4746 error ("no suitable %<operator %s%> for %qT",
4747 operator_name_info[(int)code].name, type);
4748 return error_mark_node;
4751 /* If the current scope isn't allowed to access DECL along
4752 BASETYPE_PATH, give an error. The most derived class in
4753 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4754 the declaration to use in the error diagnostic. */
4757 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4759 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4761 if (!accessible_p (basetype_path, decl, true))
4763 if (TREE_PRIVATE (decl))
4764 error ("%q+#D is private", diag_decl);
4765 else if (TREE_PROTECTED (decl))
4766 error ("%q+#D is protected", diag_decl);
4768 error ("%q+#D is inaccessible", diag_decl);
4769 error ("within this context");
4776 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4777 bitwise or of LOOKUP_* values. If any errors are warnings are
4778 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4779 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4783 build_temp (tree expr, tree type, int flags,
4784 diagnostic_t *diagnostic_kind)
4789 savew = warningcount, savee = errorcount;
4790 args = make_tree_vector_single (expr);
4791 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4792 &args, type, flags, tf_warning_or_error);
4793 release_tree_vector (args);
4794 if (warningcount > savew)
4795 *diagnostic_kind = DK_WARNING;
4796 else if (errorcount > savee)
4797 *diagnostic_kind = DK_ERROR;
4799 *diagnostic_kind = DK_UNSPECIFIED;
4803 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4804 EXPR is implicitly converted to type TOTYPE.
4805 FN and ARGNUM are used for diagnostics. */
4808 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
4810 tree t = non_reference (totype);
4812 /* Issue warnings about peculiar, but valid, uses of NULL. */
4813 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4816 warning_at (input_location, OPT_Wconversion_null,
4817 "passing NULL to non-pointer argument %P of %qD",
4820 warning_at (input_location, OPT_Wconversion_null,
4821 "converting to non-pointer type %qT from NULL", t);
4824 /* Issue warnings if "false" is converted to a NULL pointer */
4825 else if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4826 warning_at (input_location, OPT_Wconversion_null,
4827 "converting %<false%> to pointer type for argument %P of %qD",
4831 /* Perform the conversions in CONVS on the expression EXPR. FN and
4832 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4833 indicates the `this' argument of a method. INNER is nonzero when
4834 being called to continue a conversion chain. It is negative when a
4835 reference binding will be applied, positive otherwise. If
4836 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4837 conversions will be emitted if appropriate. If C_CAST_P is true,
4838 this conversion is coming from a C-style cast; in that case,
4839 conversions to inaccessible bases are permitted. */
4842 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4843 int inner, bool issue_conversion_warnings,
4844 bool c_cast_p, tsubst_flags_t complain)
4846 tree totype = convs->type;
4847 diagnostic_t diag_kind;
4851 && convs->kind != ck_user
4852 && convs->kind != ck_list
4853 && convs->kind != ck_ambig
4854 && convs->kind != ck_ref_bind
4855 && convs->kind != ck_rvalue
4856 && convs->kind != ck_base)
4858 conversion *t = convs;
4860 /* Give a helpful error if this is bad because of excess braces. */
4861 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
4862 && SCALAR_TYPE_P (totype)
4863 && CONSTRUCTOR_NELTS (expr) > 0
4864 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
4865 permerror (input_location, "too many braces around initializer for %qT", totype);
4867 for (; t; t = convs->u.next)
4869 if (t->kind == ck_user || !t->bad_p)
4871 expr = convert_like_real (t, expr, fn, argnum, 1,
4872 /*issue_conversion_warnings=*/false,
4877 else if (t->kind == ck_ambig)
4878 return convert_like_real (t, expr, fn, argnum, 1,
4879 /*issue_conversion_warnings=*/false,
4882 else if (t->kind == ck_identity)
4885 if (complain & tf_error)
4887 permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4889 permerror (input_location, " initializing argument %P of %qD", argnum, fn);
4892 return error_mark_node;
4894 return cp_convert (totype, expr);
4897 if (issue_conversion_warnings && (complain & tf_warning))
4898 conversion_null_warnings (totype, expr, fn, argnum);
4900 switch (convs->kind)
4904 struct z_candidate *cand = convs->cand;
4905 tree convfn = cand->fn;
4908 expr = mark_rvalue_use (expr);
4910 /* When converting from an init list we consider explicit
4911 constructors, but actually trying to call one is an error. */
4912 if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn))
4914 if (complain & tf_error)
4915 error ("converting to %qT from initializer list would use "
4916 "explicit constructor %qD", totype, convfn);
4918 return error_mark_node;
4921 /* Set user_conv_p on the argument conversions, so rvalue/base
4922 handling knows not to allow any more UDCs. */
4923 for (i = 0; i < cand->num_convs; ++i)
4924 cand->convs[i]->user_conv_p = true;
4926 expr = build_over_call (cand, LOOKUP_NORMAL, complain);
4928 /* If this is a constructor or a function returning an aggr type,
4929 we need to build up a TARGET_EXPR. */
4930 if (DECL_CONSTRUCTOR_P (convfn))
4932 expr = build_cplus_new (totype, expr);
4934 /* Remember that this was list-initialization. */
4935 if (convs->check_narrowing)
4936 TARGET_EXPR_LIST_INIT_P (expr) = true;
4942 expr = mark_rvalue_use (expr);
4943 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
4945 int nelts = CONSTRUCTOR_NELTS (expr);
4947 expr = integer_zero_node;
4948 else if (nelts == 1)
4949 expr = CONSTRUCTOR_ELT (expr, 0)->value;
4954 if (type_unknown_p (expr))
4955 expr = instantiate_type (totype, expr, complain);
4956 /* Convert a constant to its underlying value, unless we are
4957 about to bind it to a reference, in which case we need to
4958 leave it as an lvalue. */
4961 expr = decl_constant_value (expr);
4962 if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
4963 /* If __null has been converted to an integer type, we do not
4964 want to warn about uses of EXPR as an integer, rather than
4966 expr = build_int_cst (totype, 0);
4970 if (!(complain & tf_error))
4971 return error_mark_node;
4972 /* Call build_user_type_conversion again for the error. */
4973 return build_user_type_conversion
4974 (totype, convs->u.expr, LOOKUP_NORMAL);
4978 /* Conversion to std::initializer_list<T>. */
4979 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
4980 tree new_ctor = build_constructor (init_list_type_node, NULL);
4981 unsigned len = CONSTRUCTOR_NELTS (expr);
4983 VEC(tree,gc) *parms;
4986 /* Convert all the elements. */
4987 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
4989 tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
4990 1, false, false, complain);
4991 if (sub == error_mark_node)
4993 check_narrowing (TREE_TYPE (sub), val);
4994 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
4996 /* Build up the array. */
4997 elttype = cp_build_qualified_type
4998 (elttype, TYPE_QUALS (elttype) | TYPE_QUAL_CONST);
4999 array = build_array_of_n_type (elttype, len);
5000 array = finish_compound_literal (array, new_ctor);
5002 parms = make_tree_vector ();
5003 VEC_safe_push (tree, gc, parms, decay_conversion (array));
5004 VEC_safe_push (tree, gc, parms, size_int (len));
5005 /* Call the private constructor. */
5006 push_deferring_access_checks (dk_no_check);
5007 new_ctor = build_special_member_call
5008 (NULL_TREE, complete_ctor_identifier, &parms, totype, 0, complain);
5009 release_tree_vector (parms);
5010 pop_deferring_access_checks ();
5011 return build_cplus_new (totype, new_ctor);
5015 return get_target_expr (digest_init (totype, expr));
5021 expr = convert_like_real (convs->u.next, expr, fn, argnum,
5022 convs->kind == ck_ref_bind ? -1 : 1,
5023 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
5026 if (expr == error_mark_node)
5027 return error_mark_node;
5029 switch (convs->kind)
5032 expr = decay_conversion (expr);
5033 if (! MAYBE_CLASS_TYPE_P (totype))
5035 /* Else fall through. */
5037 if (convs->kind == ck_base && !convs->need_temporary_p)
5039 /* We are going to bind a reference directly to a base-class
5040 subobject of EXPR. */
5041 /* Build an expression for `*((base*) &expr)'. */
5042 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5043 expr = convert_to_base (expr, build_pointer_type (totype),
5044 !c_cast_p, /*nonnull=*/true, complain);
5045 expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
5049 /* Copy-initialization where the cv-unqualified version of the source
5050 type is the same class as, or a derived class of, the class of the
5051 destination [is treated as direct-initialization]. [dcl.init] */
5052 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
5053 if (convs->user_conv_p)
5054 /* This conversion is being done in the context of a user-defined
5055 conversion (i.e. the second step of copy-initialization), so
5056 don't allow any more. */
5057 flags |= LOOKUP_NO_CONVERSION;
5058 expr = build_temp (expr, totype, flags, &diag_kind);
5059 if (diag_kind && fn)
5061 if ((complain & tf_error))
5062 emit_diagnostic (diag_kind, input_location, 0,
5063 " initializing argument %P of %qD", argnum, fn);
5064 else if (diag_kind == DK_ERROR)
5065 return error_mark_node;
5067 return build_cplus_new (totype, expr);
5071 tree ref_type = totype;
5073 if (convs->bad_p && TYPE_REF_IS_RVALUE (ref_type)
5074 && real_lvalue_p (expr))
5076 if (complain & tf_error)
5078 error ("cannot bind %qT lvalue to %qT",
5079 TREE_TYPE (expr), totype);
5081 error (" initializing argument %P of %q+D", argnum, fn);
5083 return error_mark_node;
5086 /* If necessary, create a temporary.
5088 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
5089 that need temporaries, even when their types are reference
5090 compatible with the type of reference being bound, so the
5091 upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...)
5093 if (convs->need_temporary_p
5094 || TREE_CODE (expr) == CONSTRUCTOR
5095 || TREE_CODE (expr) == VA_ARG_EXPR)
5097 tree type = convs->u.next->type;
5098 cp_lvalue_kind lvalue = real_lvalue_p (expr);
5100 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
5101 && !TYPE_REF_IS_RVALUE (ref_type))
5103 if (complain & tf_error)
5105 /* If the reference is volatile or non-const, we
5106 cannot create a temporary. */
5107 if (lvalue & clk_bitfield)
5108 error ("cannot bind bitfield %qE to %qT",
5110 else if (lvalue & clk_packed)
5111 error ("cannot bind packed field %qE to %qT",
5114 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
5116 return error_mark_node;
5118 /* If the source is a packed field, and we must use a copy
5119 constructor, then building the target expr will require
5120 binding the field to the reference parameter to the
5121 copy constructor, and we'll end up with an infinite
5122 loop. If we can use a bitwise copy, then we'll be
5124 if ((lvalue & clk_packed)
5125 && CLASS_TYPE_P (type)
5126 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
5128 if (complain & tf_error)
5129 error ("cannot bind packed field %qE to %qT",
5131 return error_mark_node;
5133 if (lvalue & clk_bitfield)
5135 expr = convert_bitfield_to_declared_type (expr);
5136 expr = fold_convert (type, expr);
5138 expr = build_target_expr_with_type (expr, type);
5141 /* Take the address of the thing to which we will bind the
5143 expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain);
5144 if (expr == error_mark_node)
5145 return error_mark_node;
5147 /* Convert it to a pointer to the type referred to by the
5148 reference. This will adjust the pointer if a derived to
5149 base conversion is being performed. */
5150 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
5152 /* Convert the pointer to the desired reference type. */
5153 return build_nop (ref_type, expr);
5157 return decay_conversion (expr);
5160 /* Warn about deprecated conversion if appropriate. */
5161 string_conv_p (totype, expr, 1);
5166 expr = convert_to_base (expr, totype, !c_cast_p,
5167 /*nonnull=*/false, complain);
5168 return build_nop (totype, expr);
5171 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
5178 if (convs->check_narrowing)
5179 check_narrowing (totype, expr);
5181 if (issue_conversion_warnings && (complain & tf_warning))
5182 expr = convert_and_check (totype, expr);
5184 expr = convert (totype, expr);
5189 /* ARG is being passed to a varargs function. Perform any conversions
5190 required. Return the converted value. */
5193 convert_arg_to_ellipsis (tree arg)
5197 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5198 standard conversions are performed. */
5199 arg = decay_conversion (arg);
5202 If the argument has integral or enumeration type that is subject
5203 to the integral promotions (_conv.prom_), or a floating point
5204 type that is subject to the floating point promotion
5205 (_conv.fpprom_), the value of the argument is converted to the
5206 promoted type before the call. */
5207 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
5208 && (TYPE_PRECISION (TREE_TYPE (arg))
5209 < TYPE_PRECISION (double_type_node))
5210 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (arg))))
5211 arg = convert_to_real (double_type_node, arg);
5212 else if (NULLPTR_TYPE_P (TREE_TYPE (arg)))
5213 arg = null_pointer_node;
5214 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
5215 arg = perform_integral_promotions (arg);
5217 arg = require_complete_type (arg);
5219 if (arg != error_mark_node
5220 && (type_has_nontrivial_copy_init (TREE_TYPE (arg))
5221 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (arg))))
5223 /* [expr.call] 5.2.2/7:
5224 Passing a potentially-evaluated argument of class type (Clause 9)
5225 with a non-trivial copy constructor or a non-trivial destructor
5226 with no corresponding parameter is conditionally-supported, with
5227 implementation-defined semantics.
5229 We used to just warn here and do a bitwise copy, but now
5230 cp_expr_size will abort if we try to do that.
5232 If the call appears in the context of a sizeof expression,
5233 it is not potentially-evaluated. */
5234 if (cp_unevaluated_operand == 0)
5235 error ("cannot pass objects of non-trivially-copyable "
5236 "type %q#T through %<...%>", TREE_TYPE (arg));
5242 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
5245 build_x_va_arg (tree expr, tree type)
5247 if (processing_template_decl)
5248 return build_min (VA_ARG_EXPR, type, expr);
5250 type = complete_type_or_else (type, NULL_TREE);
5252 if (expr == error_mark_node || !type)
5253 return error_mark_node;
5255 expr = mark_lvalue_use (expr);
5257 if (type_has_nontrivial_copy_init (type)
5258 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5259 || TREE_CODE (type) == REFERENCE_TYPE)
5261 /* Remove reference types so we don't ICE later on. */
5262 tree type1 = non_reference (type);
5263 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
5264 error ("cannot receive objects of non-trivially-copyable type %q#T "
5265 "through %<...%>; ", type);
5266 expr = convert (build_pointer_type (type1), null_node);
5267 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
5271 return build_va_arg (input_location, expr, type);
5274 /* TYPE has been given to va_arg. Apply the default conversions which
5275 would have happened when passed via ellipsis. Return the promoted
5276 type, or the passed type if there is no change. */
5279 cxx_type_promotes_to (tree type)
5283 /* Perform the array-to-pointer and function-to-pointer
5285 type = type_decays_to (type);
5287 promote = type_promotes_to (type);
5288 if (same_type_p (type, promote))
5294 /* ARG is a default argument expression being passed to a parameter of
5295 the indicated TYPE, which is a parameter to FN. Do any required
5296 conversions. Return the converted value. */
5298 static GTY(()) VEC(tree,gc) *default_arg_context;
5301 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
5306 /* If the ARG is an unparsed default argument expression, the
5307 conversion cannot be performed. */
5308 if (TREE_CODE (arg) == DEFAULT_ARG)
5310 error ("the default argument for parameter %d of %qD has "
5311 "not yet been parsed",
5313 return error_mark_node;
5316 /* Detect recursion. */
5317 for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
5320 error ("recursive evaluation of default argument for %q#D", fn);
5321 return error_mark_node;
5323 VEC_safe_push (tree, gc, default_arg_context, fn);
5325 if (fn && DECL_TEMPLATE_INFO (fn))
5326 arg = tsubst_default_argument (fn, type, arg);
5332 The names in the expression are bound, and the semantic
5333 constraints are checked, at the point where the default
5334 expressions appears.
5336 we must not perform access checks here. */
5337 push_deferring_access_checks (dk_no_check);
5338 arg = break_out_target_exprs (arg);
5339 if (TREE_CODE (arg) == CONSTRUCTOR)
5341 arg = digest_init (type, arg);
5342 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5343 "default argument", fn, parmnum,
5344 tf_warning_or_error);
5348 /* We must make a copy of ARG, in case subsequent processing
5349 alters any part of it. For example, during gimplification a
5350 cast of the form (T) &X::f (where "f" is a member function)
5351 will lead to replacing the PTRMEM_CST for &X::f with a
5352 VAR_DECL. We can avoid the copy for constants, since they
5353 are never modified in place. */
5354 if (!CONSTANT_CLASS_P (arg))
5355 arg = unshare_expr (arg);
5356 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5357 "default argument", fn, parmnum,
5358 tf_warning_or_error);
5359 arg = convert_for_arg_passing (type, arg);
5361 pop_deferring_access_checks();
5363 VEC_pop (tree, default_arg_context);
5368 /* Returns the type which will really be used for passing an argument of
5372 type_passed_as (tree type)
5374 /* Pass classes with copy ctors by invisible reference. */
5375 if (TREE_ADDRESSABLE (type))
5377 type = build_reference_type (type);
5378 /* There are no other pointers to this temporary. */
5379 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
5381 else if (targetm.calls.promote_prototypes (type)
5382 && INTEGRAL_TYPE_P (type)
5383 && COMPLETE_TYPE_P (type)
5384 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5385 TYPE_SIZE (integer_type_node)))
5386 type = integer_type_node;
5391 /* Actually perform the appropriate conversion. */
5394 convert_for_arg_passing (tree type, tree val)
5398 /* If VAL is a bitfield, then -- since it has already been converted
5399 to TYPE -- it cannot have a precision greater than TYPE.
5401 If it has a smaller precision, we must widen it here. For
5402 example, passing "int f:3;" to a function expecting an "int" will
5403 not result in any conversion before this point.
5405 If the precision is the same we must not risk widening. For
5406 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
5407 often have type "int", even though the C++ type for the field is
5408 "long long". If the value is being passed to a function
5409 expecting an "int", then no conversions will be required. But,
5410 if we call convert_bitfield_to_declared_type, the bitfield will
5411 be converted to "long long". */
5412 bitfield_type = is_bitfield_expr_with_lowered_type (val);
5414 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
5415 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
5417 if (val == error_mark_node)
5419 /* Pass classes with copy ctors by invisible reference. */
5420 else if (TREE_ADDRESSABLE (type))
5421 val = build1 (ADDR_EXPR, build_reference_type (type), val);
5422 else if (targetm.calls.promote_prototypes (type)
5423 && INTEGRAL_TYPE_P (type)
5424 && COMPLETE_TYPE_P (type)
5425 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5426 TYPE_SIZE (integer_type_node)))
5427 val = perform_integral_promotions (val);
5428 if (warn_missing_format_attribute)
5430 tree rhstype = TREE_TYPE (val);
5431 const enum tree_code coder = TREE_CODE (rhstype);
5432 const enum tree_code codel = TREE_CODE (type);
5433 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5435 && check_missing_format_attribute (type, rhstype))
5436 warning (OPT_Wmissing_format_attribute,
5437 "argument of function call might be a candidate for a format attribute");
5442 /* Returns true iff FN is a function with magic varargs, i.e. ones for
5443 which no conversions at all should be done. This is true for some
5444 builtins which don't act like normal functions. */
5447 magic_varargs_p (tree fn)
5449 if (DECL_BUILT_IN (fn))
5450 switch (DECL_FUNCTION_CODE (fn))
5452 case BUILT_IN_CLASSIFY_TYPE:
5453 case BUILT_IN_CONSTANT_P:
5454 case BUILT_IN_NEXT_ARG:
5455 case BUILT_IN_VA_START:
5459 return lookup_attribute ("type generic",
5460 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
5466 /* Subroutine of the various build_*_call functions. Overload resolution
5467 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
5468 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
5469 bitmask of various LOOKUP_* flags which apply to the call itself. */
5472 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
5475 const VEC(tree,gc) *args = cand->args;
5476 tree first_arg = cand->first_arg;
5477 conversion **convs = cand->convs;
5479 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5484 unsigned int arg_index = 0;
5488 bool already_used = false;
5490 /* In a template, there is no need to perform all of the work that
5491 is normally done. We are only interested in the type of the call
5492 expression, i.e., the return type of the function. Any semantic
5493 errors will be deferred until the template is instantiated. */
5494 if (processing_template_decl)
5498 const tree *argarray;
5501 return_type = TREE_TYPE (TREE_TYPE (fn));
5502 nargs = VEC_length (tree, args);
5503 if (first_arg == NULL_TREE)
5504 argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
5512 alcarray = XALLOCAVEC (tree, nargs);
5513 alcarray[0] = first_arg;
5514 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
5515 alcarray[ix + 1] = arg;
5516 argarray = alcarray;
5518 expr = build_call_array_loc (input_location,
5519 return_type, build_addr_func (fn), nargs,
5521 if (TREE_THIS_VOLATILE (fn) && cfun)
5522 current_function_returns_abnormally = 1;
5523 if (!VOID_TYPE_P (return_type))
5524 require_complete_type (return_type);
5525 return convert_from_reference (expr);
5528 /* Give any warnings we noticed during overload resolution. */
5531 struct candidate_warning *w;
5532 for (w = cand->warnings; w; w = w->next)
5533 joust (cand, w->loser, 1);
5536 /* Make =delete work with SFINAE. */
5537 if (DECL_DELETED_FN (fn) && !(complain & tf_error))
5538 return error_mark_node;
5540 if (DECL_FUNCTION_MEMBER_P (fn))
5542 /* If FN is a template function, two cases must be considered.
5547 template <class T> void f();
5549 template <class T> struct B {
5553 struct C : A, B<int> {
5555 using B<int>::g; // #2
5558 In case #1 where `A::f' is a member template, DECL_ACCESS is
5559 recorded in the primary template but not in its specialization.
5560 We check access of FN using its primary template.
5562 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
5563 because it is a member of class template B, DECL_ACCESS is
5564 recorded in the specialization `B<int>::g'. We cannot use its
5565 primary template because `B<T>::g' and `B<int>::g' may have
5566 different access. */
5567 if (DECL_TEMPLATE_INFO (fn)
5568 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
5569 perform_or_defer_access_check (cand->access_path,
5570 DECL_TI_TEMPLATE (fn), fn);
5572 perform_or_defer_access_check (cand->access_path, fn, fn);
5575 /* Find maximum size of vector to hold converted arguments. */
5576 parmlen = list_length (parm);
5577 nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
5578 if (parmlen > nargs)
5580 argarray = (tree *) alloca (nargs * sizeof (tree));
5582 /* The implicit parameters to a constructor are not considered by overload
5583 resolution, and must be of the proper type. */
5584 if (DECL_CONSTRUCTOR_P (fn))
5586 if (first_arg != NULL_TREE)
5588 argarray[j++] = first_arg;
5589 first_arg = NULL_TREE;
5593 argarray[j++] = VEC_index (tree, args, arg_index);
5596 parm = TREE_CHAIN (parm);
5597 /* We should never try to call the abstract constructor. */
5598 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
5600 if (DECL_HAS_VTT_PARM_P (fn))
5602 argarray[j++] = VEC_index (tree, args, arg_index);
5604 parm = TREE_CHAIN (parm);
5607 /* Bypass access control for 'this' parameter. */
5608 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5610 tree parmtype = TREE_VALUE (parm);
5611 tree arg = (first_arg != NULL_TREE
5613 : VEC_index (tree, args, arg_index));
5614 tree argtype = TREE_TYPE (arg);
5618 if (convs[i]->bad_p)
5620 if (complain & tf_error)
5621 permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
5622 TREE_TYPE (argtype), fn);
5624 return error_mark_node;
5627 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
5628 X is called for an object that is not of type X, or of a type
5629 derived from X, the behavior is undefined.
5631 So we can assume that anything passed as 'this' is non-null, and
5632 optimize accordingly. */
5633 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
5634 /* Convert to the base in which the function was declared. */
5635 gcc_assert (cand->conversion_path != NULL_TREE);
5636 converted_arg = build_base_path (PLUS_EXPR,
5638 cand->conversion_path,
5640 /* Check that the base class is accessible. */
5641 if (!accessible_base_p (TREE_TYPE (argtype),
5642 BINFO_TYPE (cand->conversion_path), true))
5643 error ("%qT is not an accessible base of %qT",
5644 BINFO_TYPE (cand->conversion_path),
5645 TREE_TYPE (argtype));
5646 /* If fn was found by a using declaration, the conversion path
5647 will be to the derived class, not the base declaring fn. We
5648 must convert from derived to base. */
5649 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
5650 TREE_TYPE (parmtype), ba_unique, NULL);
5651 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
5654 argarray[j++] = converted_arg;
5655 parm = TREE_CHAIN (parm);
5656 if (first_arg != NULL_TREE)
5657 first_arg = NULL_TREE;
5664 gcc_assert (first_arg == NULL_TREE);
5665 for (; arg_index < VEC_length (tree, args) && parm;
5666 parm = TREE_CHAIN (parm), ++arg_index, ++i)
5668 tree type = TREE_VALUE (parm);
5672 /* Don't make a copy here if build_call is going to. */
5673 if (conv->kind == ck_rvalue
5674 && COMPLETE_TYPE_P (complete_type (type))
5675 && !TREE_ADDRESSABLE (type))
5676 conv = conv->u.next;
5678 /* Warn about initializer_list deduction that isn't currently in the
5680 if (cxx_dialect > cxx98
5681 && flag_deduce_init_list
5682 && cand->template_decl
5683 && is_std_init_list (non_reference (type)))
5685 tree tmpl = TI_TEMPLATE (cand->template_decl);
5686 tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
5687 tree patparm = get_pattern_parm (realparm, tmpl);
5688 tree pattype = TREE_TYPE (patparm);
5689 if (PACK_EXPANSION_P (pattype))
5690 pattype = PACK_EXPANSION_PATTERN (pattype);
5691 pattype = non_reference (pattype);
5693 if (!is_std_init_list (pattype))
5695 pedwarn (input_location, 0, "deducing %qT as %qT",
5696 non_reference (TREE_TYPE (patparm)),
5697 non_reference (type));
5698 pedwarn (input_location, 0, " in call to %q+D", cand->fn);
5699 pedwarn (input_location, 0,
5700 " (you can disable this with -fno-deduce-init-list)");
5704 val = convert_like_with_context
5705 (conv, VEC_index (tree, args, arg_index), fn, i - is_method,
5708 val = convert_for_arg_passing (type, val);
5709 if (val == error_mark_node)
5710 return error_mark_node;
5712 argarray[j++] = val;
5715 /* Default arguments */
5716 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5717 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5718 TREE_PURPOSE (parm),
5721 for (; arg_index < VEC_length (tree, args); ++arg_index)
5723 tree a = VEC_index (tree, args, arg_index);
5724 if (magic_varargs_p (fn))
5725 /* Do no conversions for magic varargs. */
5726 a = mark_type_use (a);
5728 a = convert_arg_to_ellipsis (a);
5732 gcc_assert (j <= nargs);
5735 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5736 nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5738 /* Avoid actually calling copy constructors and copy assignment operators,
5741 if (! flag_elide_constructors)
5742 /* Do things the hard way. */;
5743 else if (cand->num_convs == 1
5744 && (DECL_COPY_CONSTRUCTOR_P (fn)
5745 || DECL_MOVE_CONSTRUCTOR_P (fn)))
5748 tree arg = argarray[num_artificial_parms_for (fn)];
5751 /* Pull out the real argument, disregarding const-correctness. */
5753 while (CONVERT_EXPR_P (targ)
5754 || TREE_CODE (targ) == NON_LVALUE_EXPR)
5755 targ = TREE_OPERAND (targ, 0);
5756 if (TREE_CODE (targ) == ADDR_EXPR)
5758 targ = TREE_OPERAND (targ, 0);
5759 if (!same_type_ignoring_top_level_qualifiers_p
5760 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5769 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5771 if (TREE_CODE (arg) == TARGET_EXPR
5772 && TARGET_EXPR_LIST_INIT_P (arg))
5774 /* Copy-list-initialization doesn't require the copy constructor
5777 /* [class.copy]: the copy constructor is implicitly defined even if
5778 the implementation elided its use. */
5779 else if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
5782 already_used = true;
5785 /* If we're creating a temp and we already have one, don't create a
5786 new one. If we're not creating a temp but we get one, use
5787 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5788 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5789 temp or an INIT_EXPR otherwise. */
5790 fa = (cand->first_arg != NULL_TREE
5792 : VEC_index (tree, args, 0));
5793 if (integer_zerop (fa))
5795 if (TREE_CODE (arg) == TARGET_EXPR)
5797 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5798 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5800 else if (TREE_CODE (arg) == TARGET_EXPR
5801 || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5802 && !move_fn_p (fn)))
5804 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
5807 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5811 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5813 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5815 tree to = stabilize_reference
5816 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
5817 tree type = TREE_TYPE (to);
5818 tree as_base = CLASSTYPE_AS_BASE (type);
5819 tree arg = argarray[1];
5821 if (is_really_empty_class (type))
5823 /* Avoid copying empty classes. */
5824 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
5825 TREE_NO_WARNING (val) = 1;
5826 val = build2 (COMPOUND_EXPR, type, val, to);
5827 TREE_NO_WARNING (val) = 1;
5829 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5831 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5832 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5836 /* We must only copy the non-tail padding parts.
5837 Use __builtin_memcpy for the bitwise copy.
5838 FIXME fix 22488 so we can go back to using MODIFY_EXPR
5839 instead of an explicit call to memcpy. */
5841 tree arg0, arg1, arg2, t;
5842 tree test = NULL_TREE;
5844 arg2 = TYPE_SIZE_UNIT (as_base);
5846 arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5848 if (!can_trust_pointer_alignment ())
5850 /* If we can't be sure about pointer alignment, a call
5851 to __builtin_memcpy is expanded as a call to memcpy, which
5852 is invalid with identical args. Otherwise it is
5853 expanded as a block move, which should be safe. */
5854 arg0 = save_expr (arg0);
5855 arg1 = save_expr (arg1);
5856 test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5858 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5859 t = build_call_n (t, 3, arg0, arg1, arg2);
5861 t = convert (TREE_TYPE (arg0), t);
5863 t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5864 val = cp_build_indirect_ref (t, RO_NULL, complain);
5865 TREE_NO_WARNING (val) = 1;
5874 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5877 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5880 gcc_assert (binfo && binfo != error_mark_node);
5882 /* Warn about deprecated virtual functions now, since we're about
5883 to throw away the decl. */
5884 if (TREE_DEPRECATED (fn))
5885 warn_deprecated_use (fn, NULL_TREE);
5887 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5888 if (TREE_SIDE_EFFECTS (argarray[0]))
5889 argarray[0] = save_expr (argarray[0]);
5890 t = build_pointer_type (TREE_TYPE (fn));
5891 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5892 fn = build_java_interface_fn_ref (fn, argarray[0]);
5894 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5898 fn = build_addr_func (fn);
5900 return build_cxx_call (fn, nargs, argarray);
5903 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5904 This function performs no overload resolution, conversion, or other
5905 high-level operations. */
5908 build_cxx_call (tree fn, int nargs, tree *argarray)
5912 fn = build_call_a (fn, nargs, argarray);
5914 /* If this call might throw an exception, note that fact. */
5915 fndecl = get_callee_fndecl (fn);
5916 if ((!fndecl || !TREE_NOTHROW (fndecl))
5917 && at_function_scope_p ()
5919 cp_function_chain->can_throw = 1;
5921 /* Check that arguments to builtin functions match the expectations. */
5923 && DECL_BUILT_IN (fndecl)
5924 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5925 && !check_builtin_function_arguments (fndecl, nargs, argarray))
5926 return error_mark_node;
5928 /* Some built-in function calls will be evaluated at compile-time in
5930 fn = fold_if_not_in_template (fn);
5932 if (VOID_TYPE_P (TREE_TYPE (fn)))
5935 fn = require_complete_type (fn);
5936 if (fn == error_mark_node)
5937 return error_mark_node;
5939 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
5940 fn = build_cplus_new (TREE_TYPE (fn), fn);
5941 return convert_from_reference (fn);
5944 static GTY(()) tree java_iface_lookup_fn;
5946 /* Make an expression which yields the address of the Java interface
5947 method FN. This is achieved by generating a call to libjava's
5948 _Jv_LookupInterfaceMethodIdx(). */
5951 build_java_interface_fn_ref (tree fn, tree instance)
5953 tree lookup_fn, method, idx;
5954 tree klass_ref, iface, iface_ref;
5957 if (!java_iface_lookup_fn)
5959 tree endlink = build_void_list_node ();
5960 tree t = tree_cons (NULL_TREE, ptr_type_node,
5961 tree_cons (NULL_TREE, ptr_type_node,
5962 tree_cons (NULL_TREE, java_int_type_node,
5964 java_iface_lookup_fn
5965 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5966 build_function_type (ptr_type_node, t),
5967 0, NOT_BUILT_IN, NULL, NULL_TREE);
5970 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5971 This is the first entry in the vtable. */
5972 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
5973 tf_warning_or_error),
5976 /* Get the java.lang.Class pointer for the interface being called. */
5977 iface = DECL_CONTEXT (fn);
5978 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5979 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5980 || DECL_CONTEXT (iface_ref) != iface)
5982 error ("could not find class$ field in java interface type %qT",
5984 return error_mark_node;
5986 iface_ref = build_address (iface_ref);
5987 iface_ref = convert (build_pointer_type (iface), iface_ref);
5989 /* Determine the itable index of FN. */
5991 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5993 if (!DECL_VIRTUAL_P (method))
5999 idx = build_int_cst (NULL_TREE, i);
6001 lookup_fn = build1 (ADDR_EXPR,
6002 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6003 java_iface_lookup_fn);
6004 return build_call_nary (ptr_type_node, lookup_fn,
6005 3, klass_ref, iface_ref, idx);
6008 /* Returns the value to use for the in-charge parameter when making a
6009 call to a function with the indicated NAME.
6011 FIXME:Can't we find a neater way to do this mapping? */
6014 in_charge_arg_for_name (tree name)
6016 if (name == base_ctor_identifier
6017 || name == base_dtor_identifier)
6018 return integer_zero_node;
6019 else if (name == complete_ctor_identifier)
6020 return integer_one_node;
6021 else if (name == complete_dtor_identifier)
6022 return integer_two_node;
6023 else if (name == deleting_dtor_identifier)
6024 return integer_three_node;
6026 /* This function should only be called with one of the names listed
6032 /* Build a call to a constructor, destructor, or an assignment
6033 operator for INSTANCE, an expression with class type. NAME
6034 indicates the special member function to call; *ARGS are the
6035 arguments. ARGS may be NULL. This may change ARGS. BINFO
6036 indicates the base of INSTANCE that is to be passed as the `this'
6037 parameter to the member function called.
6039 FLAGS are the LOOKUP_* flags to use when processing the call.
6041 If NAME indicates a complete object constructor, INSTANCE may be
6042 NULL_TREE. In this case, the caller will call build_cplus_new to
6043 store the newly constructed object into a VAR_DECL. */
6046 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6047 tree binfo, int flags, tsubst_flags_t complain)
6050 /* The type of the subobject to be constructed or destroyed. */
6052 VEC(tree,gc) *allocated = NULL;
6055 gcc_assert (name == complete_ctor_identifier
6056 || name == base_ctor_identifier
6057 || name == complete_dtor_identifier
6058 || name == base_dtor_identifier
6059 || name == deleting_dtor_identifier
6060 || name == ansi_assopname (NOP_EXPR));
6063 /* Resolve the name. */
6064 if (!complete_type_or_else (binfo, NULL_TREE))
6065 return error_mark_node;
6067 binfo = TYPE_BINFO (binfo);
6070 gcc_assert (binfo != NULL_TREE);
6072 class_type = BINFO_TYPE (binfo);
6074 /* Handle the special case where INSTANCE is NULL_TREE. */
6075 if (name == complete_ctor_identifier && !instance)
6077 instance = build_int_cst (build_pointer_type (class_type), 0);
6078 instance = build1 (INDIRECT_REF, class_type, instance);
6082 if (name == complete_dtor_identifier
6083 || name == base_dtor_identifier
6084 || name == deleting_dtor_identifier)
6085 gcc_assert (args == NULL || VEC_empty (tree, *args));
6087 /* Convert to the base class, if necessary. */
6088 if (!same_type_ignoring_top_level_qualifiers_p
6089 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6091 if (name != ansi_assopname (NOP_EXPR))
6092 /* For constructors and destructors, either the base is
6093 non-virtual, or it is virtual but we are doing the
6094 conversion from a constructor or destructor for the
6095 complete object. In either case, we can convert
6097 instance = convert_to_base_statically (instance, binfo);
6099 /* However, for assignment operators, we must convert
6100 dynamically if the base is virtual. */
6101 instance = build_base_path (PLUS_EXPR, instance,
6102 binfo, /*nonnull=*/1);
6106 gcc_assert (instance != NULL_TREE);
6108 fns = lookup_fnfields (binfo, name, 1);
6110 /* When making a call to a constructor or destructor for a subobject
6111 that uses virtual base classes, pass down a pointer to a VTT for
6113 if ((name == base_ctor_identifier
6114 || name == base_dtor_identifier)
6115 && CLASSTYPE_VBASECLASSES (class_type))
6120 /* If the current function is a complete object constructor
6121 or destructor, then we fetch the VTT directly.
6122 Otherwise, we look it up using the VTT we were given. */
6123 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6124 vtt = decay_conversion (vtt);
6125 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6126 build2 (EQ_EXPR, boolean_type_node,
6127 current_in_charge_parm, integer_zero_node),
6130 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6131 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6132 BINFO_SUBVTT_INDEX (binfo));
6136 allocated = make_tree_vector ();
6140 VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6143 ret = build_new_method_call (instance, fns, args,
6144 TYPE_BINFO (BINFO_TYPE (binfo)),
6148 if (allocated != NULL)
6149 release_tree_vector (allocated);
6154 /* Return the NAME, as a C string. The NAME indicates a function that
6155 is a member of TYPE. *FREE_P is set to true if the caller must
6156 free the memory returned.
6158 Rather than go through all of this, we should simply set the names
6159 of constructors and destructors appropriately, and dispense with
6160 ctor_identifier, dtor_identifier, etc. */
6163 name_as_c_string (tree name, tree type, bool *free_p)
6167 /* Assume that we will not allocate memory. */
6169 /* Constructors and destructors are special. */
6170 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6173 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6174 /* For a destructor, add the '~'. */
6175 if (name == complete_dtor_identifier
6176 || name == base_dtor_identifier
6177 || name == deleting_dtor_identifier)
6179 pretty_name = concat ("~", pretty_name, NULL);
6180 /* Remember that we need to free the memory allocated. */
6184 else if (IDENTIFIER_TYPENAME_P (name))
6186 pretty_name = concat ("operator ",
6187 type_as_string_translate (TREE_TYPE (name),
6188 TFF_PLAIN_IDENTIFIER),
6190 /* Remember that we need to free the memory allocated. */
6194 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6199 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
6200 be set, upon return, to the function called. ARGS may be NULL.
6201 This may change ARGS. */
6204 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
6205 tree conversion_path, int flags,
6206 tree *fn_p, tsubst_flags_t complain)
6208 struct z_candidate *candidates = 0, *cand;
6209 tree explicit_targs = NULL_TREE;
6210 tree basetype = NULL_TREE;
6213 tree first_mem_arg = NULL_TREE;
6216 bool skip_first_for_error;
6217 VEC(tree,gc) *user_args;
6220 int template_only = 0;
6224 VEC(tree,gc) *orig_args = NULL;
6226 tree list = NULL_TREE;
6229 gcc_assert (instance != NULL_TREE);
6231 /* We don't know what function we're going to call, yet. */
6235 if (error_operand_p (instance)
6236 || !fns || error_operand_p (fns))
6237 return error_mark_node;
6239 if (!BASELINK_P (fns))
6241 if (complain & tf_error)
6242 error ("call to non-function %qD", fns);
6243 return error_mark_node;
6246 orig_instance = instance;
6249 /* Dismantle the baselink to collect all the information we need. */
6250 if (!conversion_path)
6251 conversion_path = BASELINK_BINFO (fns);
6252 access_binfo = BASELINK_ACCESS_BINFO (fns);
6253 optype = BASELINK_OPTYPE (fns);
6254 fns = BASELINK_FUNCTIONS (fns);
6255 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6257 explicit_targs = TREE_OPERAND (fns, 1);
6258 fns = TREE_OPERAND (fns, 0);
6261 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6262 || TREE_CODE (fns) == TEMPLATE_DECL
6263 || TREE_CODE (fns) == OVERLOAD);
6264 fn = get_first_fn (fns);
6265 name = DECL_NAME (fn);
6267 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6268 gcc_assert (CLASS_TYPE_P (basetype));
6270 if (processing_template_decl)
6272 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6273 instance = build_non_dependent_expr (instance);
6275 make_args_non_dependent (*args);
6278 user_args = args == NULL ? NULL : *args;
6279 /* Under DR 147 A::A() is an invalid constructor call,
6280 not a functional cast. */
6281 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
6283 if (! (complain & tf_error))
6284 return error_mark_node;
6286 permerror (input_location,
6287 "cannot call constructor %<%T::%D%> directly",
6289 permerror (input_location, " for a function-style cast, remove the "
6290 "redundant %<::%D%>", name);
6291 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
6296 /* Figure out whether to skip the first argument for the error
6297 message we will display to users if an error occurs. We don't
6298 want to display any compiler-generated arguments. The "this"
6299 pointer hasn't been added yet. However, we must remove the VTT
6300 pointer if this is a call to a base-class constructor or
6302 skip_first_for_error = false;
6303 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6305 /* Callers should explicitly indicate whether they want to construct
6306 the complete object or just the part without virtual bases. */
6307 gcc_assert (name != ctor_identifier);
6308 /* Similarly for destructors. */
6309 gcc_assert (name != dtor_identifier);
6310 /* Remove the VTT pointer, if present. */
6311 if ((name == base_ctor_identifier || name == base_dtor_identifier)
6312 && CLASSTYPE_VBASECLASSES (basetype))
6313 skip_first_for_error = true;
6316 /* Process the argument list. */
6317 if (args != NULL && *args != NULL)
6319 *args = resolve_args (*args);
6321 return error_mark_node;
6324 instance_ptr = build_this (instance);
6326 /* It's OK to call destructors and constructors on cv-qualified objects.
6327 Therefore, convert the INSTANCE_PTR to the unqualified type, if
6329 if (DECL_DESTRUCTOR_P (fn)
6330 || DECL_CONSTRUCTOR_P (fn))
6332 tree type = build_pointer_type (basetype);
6333 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6334 instance_ptr = build_nop (type, instance_ptr);
6336 if (DECL_DESTRUCTOR_P (fn))
6337 name = complete_dtor_identifier;
6339 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6340 initializer, not T({ }). If the type doesn't have a list ctor (or no
6341 viable list ctor), break apart the list into separate ctor args. */
6343 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6344 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6345 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
6347 gcc_assert (VEC_length (tree, *args) == 1);
6348 list = VEC_index (tree, *args, 0);
6350 if (TYPE_HAS_LIST_CTOR (basetype))
6351 flags |= LOOKUP_LIST_ONLY;
6356 first_mem_arg = instance_ptr;
6358 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6359 p = conversion_obstack_alloc (0);
6361 any_viable_p = false;
6364 add_candidates (fns, first_mem_arg, user_args, optype,
6365 explicit_targs, template_only, conversion_path,
6366 access_binfo, flags, &candidates);
6367 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6370 if (!any_viable_p && list)
6372 VEC(tree,gc) *list_args = ctor_to_vec (list);
6373 flags &= ~LOOKUP_LIST_ONLY;
6374 add_candidates (fns, first_mem_arg, list_args, optype,
6375 explicit_targs, template_only, conversion_path,
6376 access_binfo, flags, &candidates);
6377 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6382 if (complain & tf_error)
6384 if (!COMPLETE_TYPE_P (basetype))
6385 cxx_incomplete_type_error (instance_ptr, basetype);
6387 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
6388 basetype, optype, build_tree_list_vec (user_args),
6389 TREE_TYPE (TREE_TYPE (instance_ptr)));
6396 pretty_name = name_as_c_string (name, basetype, &free_p);
6397 arglist = build_tree_list_vec (user_args);
6398 if (skip_first_for_error)
6399 arglist = TREE_CHAIN (arglist);
6400 error ("no matching function for call to %<%T::%s(%A)%#V%>",
6401 basetype, pretty_name, arglist,
6402 TREE_TYPE (TREE_TYPE (instance_ptr)));
6406 print_z_candidates (candidates);
6408 call = error_mark_node;
6412 cand = tourney (candidates);
6419 if (complain & tf_error)
6421 pretty_name = name_as_c_string (name, basetype, &free_p);
6422 arglist = build_tree_list_vec (user_args);
6423 if (skip_first_for_error)
6424 arglist = TREE_CHAIN (arglist);
6425 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6427 print_z_candidates (candidates);
6431 call = error_mark_node;
6437 if (!(flags & LOOKUP_NONVIRTUAL)
6438 && DECL_PURE_VIRTUAL_P (fn)
6439 && instance == current_class_ref
6440 && (DECL_CONSTRUCTOR_P (current_function_decl)
6441 || DECL_DESTRUCTOR_P (current_function_decl))
6442 && (complain & tf_warning))
6443 /* This is not an error, it is runtime undefined
6445 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6446 "abstract virtual %q#D called from constructor"
6447 : "abstract virtual %q#D called from destructor"),
6450 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6451 && is_dummy_object (instance_ptr))
6453 if (complain & tf_error)
6454 error ("cannot call member function %qD without object",
6456 call = error_mark_node;
6460 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6461 && resolves_to_fixed_type_p (instance, 0))
6462 flags |= LOOKUP_NONVIRTUAL;
6463 /* Now we know what function is being called. */
6466 /* Build the actual CALL_EXPR. */
6467 call = build_over_call (cand, flags, complain);
6468 /* In an expression of the form `a->f()' where `f' turns
6469 out to be a static member function, `a' is
6470 none-the-less evaluated. */
6471 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6472 && !is_dummy_object (instance_ptr)
6473 && TREE_SIDE_EFFECTS (instance_ptr))
6474 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6475 instance_ptr, call);
6476 else if (call != error_mark_node
6477 && DECL_DESTRUCTOR_P (cand->fn)
6478 && !VOID_TYPE_P (TREE_TYPE (call)))
6479 /* An explicit call of the form "x->~X()" has type
6480 "void". However, on platforms where destructors
6481 return "this" (i.e., those where
6482 targetm.cxx.cdtor_returns_this is true), such calls
6483 will appear to have a return value of pointer type
6484 to the low-level call machinery. We do not want to
6485 change the low-level machinery, since we want to be
6486 able to optimize "delete f()" on such platforms as
6487 "operator delete(~X(f()))" (rather than generating
6488 "t = f(), ~X(t), operator delete (t)"). */
6489 call = build_nop (void_type_node, call);
6494 if (processing_template_decl && call != error_mark_node)
6496 bool cast_to_void = false;
6498 if (TREE_CODE (call) == COMPOUND_EXPR)
6499 call = TREE_OPERAND (call, 1);
6500 else if (TREE_CODE (call) == NOP_EXPR)
6502 cast_to_void = true;
6503 call = TREE_OPERAND (call, 0);
6505 if (TREE_CODE (call) == INDIRECT_REF)
6506 call = TREE_OPERAND (call, 0);
6507 call = (build_min_non_dep_call_vec
6509 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6510 orig_instance, orig_fns, NULL_TREE),
6512 call = convert_from_reference (call);
6514 call = build_nop (void_type_node, call);
6517 /* Free all the conversions we allocated. */
6518 obstack_free (&conversion_obstack, p);
6520 if (orig_args != NULL)
6521 release_tree_vector (orig_args);
6526 /* Returns true iff standard conversion sequence ICS1 is a proper
6527 subsequence of ICS2. */
6530 is_subseq (conversion *ics1, conversion *ics2)
6532 /* We can assume that a conversion of the same code
6533 between the same types indicates a subsequence since we only get
6534 here if the types we are converting from are the same. */
6536 while (ics1->kind == ck_rvalue
6537 || ics1->kind == ck_lvalue)
6538 ics1 = ics1->u.next;
6542 while (ics2->kind == ck_rvalue
6543 || ics2->kind == ck_lvalue)
6544 ics2 = ics2->u.next;
6546 if (ics2->kind == ck_user
6547 || ics2->kind == ck_ambig
6548 || ics2->kind == ck_identity)
6549 /* At this point, ICS1 cannot be a proper subsequence of
6550 ICS2. We can get a USER_CONV when we are comparing the
6551 second standard conversion sequence of two user conversion
6555 ics2 = ics2->u.next;
6557 if (ics2->kind == ics1->kind
6558 && same_type_p (ics2->type, ics1->type)
6559 && same_type_p (ics2->u.next->type,
6560 ics1->u.next->type))
6565 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
6566 be any _TYPE nodes. */
6569 is_properly_derived_from (tree derived, tree base)
6571 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6574 /* We only allow proper derivation here. The DERIVED_FROM_P macro
6575 considers every class derived from itself. */
6576 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6577 && DERIVED_FROM_P (base, derived));
6580 /* We build the ICS for an implicit object parameter as a pointer
6581 conversion sequence. However, such a sequence should be compared
6582 as if it were a reference conversion sequence. If ICS is the
6583 implicit conversion sequence for an implicit object parameter,
6584 modify it accordingly. */
6587 maybe_handle_implicit_object (conversion **ics)
6591 /* [over.match.funcs]
6593 For non-static member functions, the type of the
6594 implicit object parameter is "reference to cv X"
6595 where X is the class of which the function is a
6596 member and cv is the cv-qualification on the member
6597 function declaration. */
6598 conversion *t = *ics;
6599 tree reference_type;
6601 /* The `this' parameter is a pointer to a class type. Make the
6602 implicit conversion talk about a reference to that same class
6604 reference_type = TREE_TYPE (t->type);
6605 reference_type = build_reference_type (reference_type);
6607 if (t->kind == ck_qual)
6609 if (t->kind == ck_ptr)
6611 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6612 t = direct_reference_binding (reference_type, t);
6614 t->rvaluedness_matches_p = 0;
6619 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6620 and return the initial reference binding conversion. Otherwise,
6621 leave *ICS unchanged and return NULL. */
6624 maybe_handle_ref_bind (conversion **ics)
6626 if ((*ics)->kind == ck_ref_bind)
6628 conversion *old_ics = *ics;
6629 *ics = old_ics->u.next;
6630 (*ics)->user_conv_p = old_ics->user_conv_p;
6637 /* Compare two implicit conversion sequences according to the rules set out in
6638 [over.ics.rank]. Return values:
6640 1: ics1 is better than ics2
6641 -1: ics2 is better than ics1
6642 0: ics1 and ics2 are indistinguishable */
6645 compare_ics (conversion *ics1, conversion *ics2)
6651 tree deref_from_type1 = NULL_TREE;
6652 tree deref_from_type2 = NULL_TREE;
6653 tree deref_to_type1 = NULL_TREE;
6654 tree deref_to_type2 = NULL_TREE;
6655 conversion_rank rank1, rank2;
6657 /* REF_BINDING is nonzero if the result of the conversion sequence
6658 is a reference type. In that case REF_CONV is the reference
6659 binding conversion. */
6660 conversion *ref_conv1;
6661 conversion *ref_conv2;
6663 /* Handle implicit object parameters. */
6664 maybe_handle_implicit_object (&ics1);
6665 maybe_handle_implicit_object (&ics2);
6667 /* Handle reference parameters. */
6668 ref_conv1 = maybe_handle_ref_bind (&ics1);
6669 ref_conv2 = maybe_handle_ref_bind (&ics2);
6671 /* List-initialization sequence L1 is a better conversion sequence than
6672 list-initialization sequence L2 if L1 converts to
6673 std::initializer_list<X> for some X and L2 does not. */
6674 if (ics1->kind == ck_list && ics2->kind != ck_list)
6676 if (ics2->kind == ck_list && ics1->kind != ck_list)
6681 When comparing the basic forms of implicit conversion sequences (as
6682 defined in _over.best.ics_)
6684 --a standard conversion sequence (_over.ics.scs_) is a better
6685 conversion sequence than a user-defined conversion sequence
6686 or an ellipsis conversion sequence, and
6688 --a user-defined conversion sequence (_over.ics.user_) is a
6689 better conversion sequence than an ellipsis conversion sequence
6690 (_over.ics.ellipsis_). */
6691 rank1 = CONVERSION_RANK (ics1);
6692 rank2 = CONVERSION_RANK (ics2);
6696 else if (rank1 < rank2)
6699 if (rank1 == cr_bad)
6701 /* XXX Isn't this an extension? */
6702 /* Both ICS are bad. We try to make a decision based on what
6703 would have happened if they'd been good. */
6704 if (ics1->user_conv_p > ics2->user_conv_p
6705 || ics1->rank > ics2->rank)
6707 else if (ics1->user_conv_p < ics2->user_conv_p
6708 || ics1->rank < ics2->rank)
6711 /* We couldn't make up our minds; try to figure it out below. */
6714 if (ics1->ellipsis_p || ics1->kind == ck_list)
6715 /* Both conversions are ellipsis conversions or both are building a
6716 std::initializer_list. */
6719 /* User-defined conversion sequence U1 is a better conversion sequence
6720 than another user-defined conversion sequence U2 if they contain the
6721 same user-defined conversion operator or constructor and if the sec-
6722 ond standard conversion sequence of U1 is better than the second
6723 standard conversion sequence of U2. */
6725 if (ics1->user_conv_p)
6730 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
6731 if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6733 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
6734 if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6737 if (t1->cand->fn != t2->cand->fn)
6740 /* We can just fall through here, after setting up
6741 FROM_TYPE1 and FROM_TYPE2. */
6742 from_type1 = t1->type;
6743 from_type2 = t2->type;
6750 /* We're dealing with two standard conversion sequences.
6754 Standard conversion sequence S1 is a better conversion
6755 sequence than standard conversion sequence S2 if
6757 --S1 is a proper subsequence of S2 (comparing the conversion
6758 sequences in the canonical form defined by _over.ics.scs_,
6759 excluding any Lvalue Transformation; the identity
6760 conversion sequence is considered to be a subsequence of
6761 any non-identity conversion sequence */
6764 while (t1->kind != ck_identity)
6766 from_type1 = t1->type;
6769 while (t2->kind != ck_identity)
6771 from_type2 = t2->type;
6774 /* One sequence can only be a subsequence of the other if they start with
6775 the same type. They can start with different types when comparing the
6776 second standard conversion sequence in two user-defined conversion
6778 if (same_type_p (from_type1, from_type2))
6780 if (is_subseq (ics1, ics2))
6782 if (is_subseq (ics2, ics1))
6790 --the rank of S1 is better than the rank of S2 (by the rules
6793 Standard conversion sequences are ordered by their ranks: an Exact
6794 Match is a better conversion than a Promotion, which is a better
6795 conversion than a Conversion.
6797 Two conversion sequences with the same rank are indistinguishable
6798 unless one of the following rules applies:
6800 --A conversion that does not a convert a pointer, pointer to member,
6801 or std::nullptr_t to bool is better than one that does.
6803 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6804 so that we do not have to check it explicitly. */
6805 if (ics1->rank < ics2->rank)
6807 else if (ics2->rank < ics1->rank)
6810 to_type1 = ics1->type;
6811 to_type2 = ics2->type;
6813 /* A conversion from scalar arithmetic type to complex is worse than a
6814 conversion between scalar arithmetic types. */
6815 if (same_type_p (from_type1, from_type2)
6816 && ARITHMETIC_TYPE_P (from_type1)
6817 && ARITHMETIC_TYPE_P (to_type1)
6818 && ARITHMETIC_TYPE_P (to_type2)
6819 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6820 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6822 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6828 if (TYPE_PTR_P (from_type1)
6829 && TYPE_PTR_P (from_type2)
6830 && TYPE_PTR_P (to_type1)
6831 && TYPE_PTR_P (to_type2))
6833 deref_from_type1 = TREE_TYPE (from_type1);
6834 deref_from_type2 = TREE_TYPE (from_type2);
6835 deref_to_type1 = TREE_TYPE (to_type1);
6836 deref_to_type2 = TREE_TYPE (to_type2);
6838 /* The rules for pointers to members A::* are just like the rules
6839 for pointers A*, except opposite: if B is derived from A then
6840 A::* converts to B::*, not vice versa. For that reason, we
6841 switch the from_ and to_ variables here. */
6842 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6843 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6844 || (TYPE_PTRMEMFUNC_P (from_type1)
6845 && TYPE_PTRMEMFUNC_P (from_type2)
6846 && TYPE_PTRMEMFUNC_P (to_type1)
6847 && TYPE_PTRMEMFUNC_P (to_type2)))
6849 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6850 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6851 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6852 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6855 if (deref_from_type1 != NULL_TREE
6856 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6857 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6859 /* This was one of the pointer or pointer-like conversions.
6863 --If class B is derived directly or indirectly from class A,
6864 conversion of B* to A* is better than conversion of B* to
6865 void*, and conversion of A* to void* is better than
6866 conversion of B* to void*. */
6867 if (TREE_CODE (deref_to_type1) == VOID_TYPE
6868 && TREE_CODE (deref_to_type2) == VOID_TYPE)
6870 if (is_properly_derived_from (deref_from_type1,
6873 else if (is_properly_derived_from (deref_from_type2,
6877 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6878 || TREE_CODE (deref_to_type2) == VOID_TYPE)
6880 if (same_type_p (deref_from_type1, deref_from_type2))
6882 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6884 if (is_properly_derived_from (deref_from_type1,
6888 /* We know that DEREF_TO_TYPE1 is `void' here. */
6889 else if (is_properly_derived_from (deref_from_type1,
6894 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6895 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6899 --If class B is derived directly or indirectly from class A
6900 and class C is derived directly or indirectly from B,
6902 --conversion of C* to B* is better than conversion of C* to
6905 --conversion of B* to A* is better than conversion of C* to
6907 if (same_type_p (deref_from_type1, deref_from_type2))
6909 if (is_properly_derived_from (deref_to_type1,
6912 else if (is_properly_derived_from (deref_to_type2,
6916 else if (same_type_p (deref_to_type1, deref_to_type2))
6918 if (is_properly_derived_from (deref_from_type2,
6921 else if (is_properly_derived_from (deref_from_type1,
6927 else if (CLASS_TYPE_P (non_reference (from_type1))
6928 && same_type_p (from_type1, from_type2))
6930 tree from = non_reference (from_type1);
6934 --binding of an expression of type C to a reference of type
6935 B& is better than binding an expression of type C to a
6936 reference of type A&
6938 --conversion of C to B is better than conversion of C to A, */
6939 if (is_properly_derived_from (from, to_type1)
6940 && is_properly_derived_from (from, to_type2))
6942 if (is_properly_derived_from (to_type1, to_type2))
6944 else if (is_properly_derived_from (to_type2, to_type1))
6948 else if (CLASS_TYPE_P (non_reference (to_type1))
6949 && same_type_p (to_type1, to_type2))
6951 tree to = non_reference (to_type1);
6955 --binding of an expression of type B to a reference of type
6956 A& is better than binding an expression of type C to a
6957 reference of type A&,
6959 --conversion of B to A is better than conversion of C to A */
6960 if (is_properly_derived_from (from_type1, to)
6961 && is_properly_derived_from (from_type2, to))
6963 if (is_properly_derived_from (from_type2, from_type1))
6965 else if (is_properly_derived_from (from_type1, from_type2))
6972 --S1 and S2 differ only in their qualification conversion and yield
6973 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6974 qualification signature of type T1 is a proper subset of the cv-
6975 qualification signature of type T2 */
6976 if (ics1->kind == ck_qual
6977 && ics2->kind == ck_qual
6978 && same_type_p (from_type1, from_type2))
6980 int result = comp_cv_qual_signature (to_type1, to_type2);
6987 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6988 to an implicit object parameter, and either S1 binds an lvalue reference
6989 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6990 reference to an rvalue and S2 binds an lvalue reference
6991 (C++0x draft standard, 13.3.3.2)
6993 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6994 types to which the references refer are the same type except for
6995 top-level cv-qualifiers, and the type to which the reference
6996 initialized by S2 refers is more cv-qualified than the type to
6997 which the reference initialized by S1 refers */
6999 if (ref_conv1 && ref_conv2)
7001 if (!ref_conv1->this_p && !ref_conv2->this_p
7002 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7003 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7005 if (ref_conv1->rvaluedness_matches_p)
7007 if (ref_conv2->rvaluedness_matches_p)
7011 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7012 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7013 TREE_TYPE (ref_conv1->type));
7016 /* Neither conversion sequence is better than the other. */
7020 /* The source type for this standard conversion sequence. */
7023 source_type (conversion *t)
7025 for (;; t = t->u.next)
7027 if (t->kind == ck_user
7028 || t->kind == ck_ambig
7029 || t->kind == ck_identity)
7035 /* Note a warning about preferring WINNER to LOSER. We do this by storing
7036 a pointer to LOSER and re-running joust to produce the warning if WINNER
7037 is actually used. */
7040 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7042 candidate_warning *cw = (candidate_warning *)
7043 conversion_obstack_alloc (sizeof (candidate_warning));
7045 cw->next = winner->warnings;
7046 winner->warnings = cw;
7049 /* Compare two candidates for overloading as described in
7050 [over.match.best]. Return values:
7052 1: cand1 is better than cand2
7053 -1: cand2 is better than cand1
7054 0: cand1 and cand2 are indistinguishable */
7057 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7060 int off1 = 0, off2 = 0;
7064 /* Candidates that involve bad conversions are always worse than those
7066 if (cand1->viable > cand2->viable)
7068 if (cand1->viable < cand2->viable)
7071 /* If we have two pseudo-candidates for conversions to the same type,
7072 or two candidates for the same function, arbitrarily pick one. */
7073 if (cand1->fn == cand2->fn
7074 && (IS_TYPE_OR_DECL_P (cand1->fn)))
7077 /* a viable function F1
7078 is defined to be a better function than another viable function F2 if
7079 for all arguments i, ICSi(F1) is not a worse conversion sequence than
7080 ICSi(F2), and then */
7082 /* for some argument j, ICSj(F1) is a better conversion sequence than
7085 /* For comparing static and non-static member functions, we ignore
7086 the implicit object parameter of the non-static function. The
7087 standard says to pretend that the static function has an object
7088 parm, but that won't work with operator overloading. */
7089 len = cand1->num_convs;
7090 if (len != cand2->num_convs)
7092 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7093 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7095 gcc_assert (static_1 != static_2);
7106 for (i = 0; i < len; ++i)
7108 conversion *t1 = cand1->convs[i + off1];
7109 conversion *t2 = cand2->convs[i + off2];
7110 int comp = compare_ics (t1, t2);
7115 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7116 == cr_std + cr_promotion)
7117 && t1->kind == ck_std
7118 && t2->kind == ck_std
7119 && TREE_CODE (t1->type) == INTEGER_TYPE
7120 && TREE_CODE (t2->type) == INTEGER_TYPE
7121 && (TYPE_PRECISION (t1->type)
7122 == TYPE_PRECISION (t2->type))
7123 && (TYPE_UNSIGNED (t1->u.next->type)
7124 || (TREE_CODE (t1->u.next->type)
7127 tree type = t1->u.next->type;
7129 struct z_candidate *w, *l;
7131 type1 = t1->type, type2 = t2->type,
7132 w = cand1, l = cand2;
7134 type1 = t2->type, type2 = t1->type,
7135 w = cand2, l = cand1;
7139 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7140 type, type1, type2);
7141 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
7147 if (winner && comp != winner)
7156 /* warn about confusing overload resolution for user-defined conversions,
7157 either between a constructor and a conversion op, or between two
7159 if (winner && warn_conversion && cand1->second_conv
7160 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7161 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7163 struct z_candidate *w, *l;
7164 bool give_warning = false;
7167 w = cand1, l = cand2;
7169 w = cand2, l = cand1;
7171 /* We don't want to complain about `X::operator T1 ()'
7172 beating `X::operator T2 () const', when T2 is a no less
7173 cv-qualified version of T1. */
7174 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7175 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7177 tree t = TREE_TYPE (TREE_TYPE (l->fn));
7178 tree f = TREE_TYPE (TREE_TYPE (w->fn));
7180 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7185 if (!comp_ptr_ttypes (t, f))
7186 give_warning = true;
7189 give_warning = true;
7195 tree source = source_type (w->convs[0]);
7196 if (! DECL_CONSTRUCTOR_P (w->fn))
7197 source = TREE_TYPE (source);
7198 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7199 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
7200 source, w->second_conv->type))
7202 inform (input_location, " because conversion sequence for the argument is better");
7213 F1 is a non-template function and F2 is a template function
7216 if (!cand1->template_decl && cand2->template_decl)
7218 else if (cand1->template_decl && !cand2->template_decl)
7222 F1 and F2 are template functions and the function template for F1 is
7223 more specialized than the template for F2 according to the partial
7226 if (cand1->template_decl && cand2->template_decl)
7228 winner = more_specialized_fn
7229 (TI_TEMPLATE (cand1->template_decl),
7230 TI_TEMPLATE (cand2->template_decl),
7231 /* [temp.func.order]: The presence of unused ellipsis and default
7232 arguments has no effect on the partial ordering of function
7233 templates. add_function_candidate() will not have
7234 counted the "this" argument for constructors. */
7235 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
7241 the context is an initialization by user-defined conversion (see
7242 _dcl.init_ and _over.match.user_) and the standard conversion
7243 sequence from the return type of F1 to the destination type (i.e.,
7244 the type of the entity being initialized) is a better conversion
7245 sequence than the standard conversion sequence from the return type
7246 of F2 to the destination type. */
7248 if (cand1->second_conv)
7250 winner = compare_ics (cand1->second_conv, cand2->second_conv);
7255 /* Check whether we can discard a builtin candidate, either because we
7256 have two identical ones or matching builtin and non-builtin candidates.
7258 (Pedantically in the latter case the builtin which matched the user
7259 function should not be added to the overload set, but we spot it here.
7262 ... the builtin candidates include ...
7263 - do not have the same parameter type list as any non-template
7264 non-member candidate. */
7266 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7267 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7269 for (i = 0; i < len; ++i)
7270 if (!same_type_p (cand1->convs[i]->type,
7271 cand2->convs[i]->type))
7273 if (i == cand1->num_convs)
7275 if (cand1->fn == cand2->fn)
7276 /* Two built-in candidates; arbitrarily pick one. */
7278 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7279 /* cand1 is built-in; prefer cand2. */
7282 /* cand2 is built-in; prefer cand1. */
7287 /* If the two function declarations represent the same function (this can
7288 happen with declarations in multiple scopes and arg-dependent lookup),
7289 arbitrarily choose one. But first make sure the default args we're
7291 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7292 && equal_functions (cand1->fn, cand2->fn))
7294 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7295 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7297 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7299 for (i = 0; i < len; ++i)
7301 /* Don't crash if the fn is variadic. */
7304 parms1 = TREE_CHAIN (parms1);
7305 parms2 = TREE_CHAIN (parms2);
7309 parms1 = TREE_CHAIN (parms1);
7311 parms2 = TREE_CHAIN (parms2);
7315 if (!cp_tree_equal (TREE_PURPOSE (parms1),
7316 TREE_PURPOSE (parms2)))
7320 permerror (input_location, "default argument mismatch in "
7321 "overload resolution");
7322 inform (input_location,
7323 " candidate 1: %q+#F", cand1->fn);
7324 inform (input_location,
7325 " candidate 2: %q+#F", cand2->fn);
7328 add_warning (cand1, cand2);
7331 parms1 = TREE_CHAIN (parms1);
7332 parms2 = TREE_CHAIN (parms2);
7340 /* Extension: If the worst conversion for one candidate is worse than the
7341 worst conversion for the other, take the first. */
7344 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7345 struct z_candidate *w = 0, *l = 0;
7347 for (i = 0; i < len; ++i)
7349 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7350 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7351 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7352 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7355 winner = 1, w = cand1, l = cand2;
7357 winner = -1, w = cand2, l = cand1;
7362 pedwarn (input_location, 0,
7363 "ISO C++ says that these are ambiguous, even "
7364 "though the worst conversion for the first is better than "
7365 "the worst conversion for the second:");
7366 print_z_candidate (_("candidate 1:"), w);
7367 print_z_candidate (_("candidate 2:"), l);
7375 gcc_assert (!winner);
7379 /* Given a list of candidates for overloading, find the best one, if any.
7380 This algorithm has a worst case of O(2n) (winner is last), and a best
7381 case of O(n/2) (totally ambiguous); much better than a sorting
7384 static struct z_candidate *
7385 tourney (struct z_candidate *candidates)
7387 struct z_candidate *champ = candidates, *challenger;
7389 int champ_compared_to_predecessor = 0;
7391 /* Walk through the list once, comparing each current champ to the next
7392 candidate, knocking out a candidate or two with each comparison. */
7394 for (challenger = champ->next; challenger; )
7396 fate = joust (champ, challenger, 0);
7398 challenger = challenger->next;
7403 champ = challenger->next;
7406 champ_compared_to_predecessor = 0;
7411 champ_compared_to_predecessor = 1;
7414 challenger = champ->next;
7418 /* Make sure the champ is better than all the candidates it hasn't yet
7419 been compared to. */
7421 for (challenger = candidates;
7423 && !(champ_compared_to_predecessor && challenger->next == champ);
7424 challenger = challenger->next)
7426 fate = joust (champ, challenger, 0);
7434 /* Returns nonzero if things of type FROM can be converted to TO. */
7437 can_convert (tree to, tree from)
7439 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
7442 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
7445 can_convert_arg (tree to, tree from, tree arg, int flags)
7451 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7452 p = conversion_obstack_alloc (0);
7454 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7456 ok_p = (t && !t->bad_p);
7458 /* Free all the conversions we allocated. */
7459 obstack_free (&conversion_obstack, p);
7464 /* Like can_convert_arg, but allows dubious conversions as well. */
7467 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
7472 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7473 p = conversion_obstack_alloc (0);
7474 /* Try to perform the conversion. */
7475 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7477 /* Free all the conversions we allocated. */
7478 obstack_free (&conversion_obstack, p);
7483 /* Convert EXPR to TYPE. Return the converted expression.
7485 Note that we allow bad conversions here because by the time we get to
7486 this point we are committed to doing the conversion. If we end up
7487 doing a bad conversion, convert_like will complain. */
7490 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7495 if (error_operand_p (expr))
7496 return error_mark_node;
7498 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7499 p = conversion_obstack_alloc (0);
7501 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7507 if (complain & tf_error)
7509 /* If expr has unknown type, then it is an overloaded function.
7510 Call instantiate_type to get good error messages. */
7511 if (TREE_TYPE (expr) == unknown_type_node)
7512 instantiate_type (type, expr, complain);
7513 else if (invalid_nonstatic_memfn_p (expr, complain))
7514 /* We gave an error. */;
7516 error ("could not convert %qE to %qT", expr, type);
7518 expr = error_mark_node;
7520 else if (processing_template_decl)
7522 /* In a template, we are only concerned about determining the
7523 type of non-dependent expressions, so we do not have to
7524 perform the actual conversion. */
7525 if (TREE_TYPE (expr) != type)
7526 expr = build_nop (type, expr);
7529 expr = convert_like (conv, expr, complain);
7531 /* Free all the conversions we allocated. */
7532 obstack_free (&conversion_obstack, p);
7538 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7540 return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
7543 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7544 permitted. If the conversion is valid, the converted expression is
7545 returned. Otherwise, NULL_TREE is returned, except in the case
7546 that TYPE is a class type; in that case, an error is issued. If
7547 C_CAST_P is true, then this direction initialization is taking
7548 place as part of a static_cast being attempted as part of a C-style
7552 perform_direct_initialization_if_possible (tree type,
7555 tsubst_flags_t complain)
7560 if (type == error_mark_node || error_operand_p (expr))
7561 return error_mark_node;
7564 If the destination type is a (possibly cv-qualified) class type:
7566 -- If the initialization is direct-initialization ...,
7567 constructors are considered. ... If no constructor applies, or
7568 the overload resolution is ambiguous, the initialization is
7570 if (CLASS_TYPE_P (type))
7572 VEC(tree,gc) *args = make_tree_vector_single (expr);
7573 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7574 &args, type, LOOKUP_NORMAL, complain);
7575 release_tree_vector (args);
7576 return build_cplus_new (type, expr);
7579 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7580 p = conversion_obstack_alloc (0);
7582 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7585 if (!conv || conv->bad_p)
7588 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7589 /*issue_conversion_warnings=*/false,
7593 /* Free all the conversions we allocated. */
7594 obstack_free (&conversion_obstack, p);
7599 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
7600 is being bound to a temporary. Create and return a new VAR_DECL
7601 with the indicated TYPE; this variable will store the value to
7602 which the reference is bound. */
7605 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7609 /* Create the variable. */
7610 var = create_temporary_var (type);
7612 /* Register the variable. */
7613 if (TREE_STATIC (decl))
7615 /* Namespace-scope or local static; give it a mangled name. */
7618 TREE_STATIC (var) = 1;
7619 name = mangle_ref_init_variable (decl);
7620 DECL_NAME (var) = name;
7621 SET_DECL_ASSEMBLER_NAME (var, name);
7622 var = pushdecl_top_level (var);
7625 /* Create a new cleanup level if necessary. */
7626 maybe_push_cleanup_level (type);
7631 /* EXPR is the initializer for a variable DECL of reference or
7632 std::initializer_list type. Create, push and return a new VAR_DECL
7633 for the initializer so that it will live as long as DECL. Any
7634 cleanup for the new variable is returned through CLEANUP, and the
7635 code to initialize the new variable is returned through INITP. */
7638 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7644 /* Create the temporary variable. */
7645 type = TREE_TYPE (expr);
7646 var = make_temporary_var_for_ref_to_temp (decl, type);
7647 layout_decl (var, 0);
7648 /* If the rvalue is the result of a function call it will be
7649 a TARGET_EXPR. If it is some other construct (such as a
7650 member access expression where the underlying object is
7651 itself the result of a function call), turn it into a
7652 TARGET_EXPR here. It is important that EXPR be a
7653 TARGET_EXPR below since otherwise the INIT_EXPR will
7654 attempt to make a bitwise copy of EXPR to initialize
7656 if (TREE_CODE (expr) != TARGET_EXPR)
7657 expr = get_target_expr (expr);
7658 /* Create the INIT_EXPR that will initialize the temporary
7660 init = build2 (INIT_EXPR, type, var, expr);
7661 if (at_function_scope_p ())
7663 add_decl_expr (var);
7665 if (TREE_STATIC (var))
7666 init = add_stmt_to_compound (init, register_dtor_fn (var));
7668 *cleanup = cxx_maybe_build_cleanup (var);
7670 /* We must be careful to destroy the temporary only
7671 after its initialization has taken place. If the
7672 initialization throws an exception, then the
7673 destructor should not be run. We cannot simply
7674 transform INIT into something like:
7676 (INIT, ({ CLEANUP_STMT; }))
7678 because emit_local_var always treats the
7679 initializer as a full-expression. Thus, the
7680 destructor would run too early; it would run at the
7681 end of initializing the reference variable, rather
7682 than at the end of the block enclosing the
7685 The solution is to pass back a cleanup expression
7686 which the caller is responsible for attaching to
7687 the statement tree. */
7691 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7692 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7693 static_aggregates = tree_cons (NULL_TREE, var,
7701 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7702 initializing a variable of that TYPE. If DECL is non-NULL, it is
7703 the VAR_DECL being initialized with the EXPR. (In that case, the
7704 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
7705 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
7706 return, if *CLEANUP is no longer NULL, it will be an expression
7707 that should be pushed as a cleanup after the returned expression
7708 is used to initialize DECL.
7710 Return the converted expression. */
7713 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
7714 tsubst_flags_t complain)
7719 if (type == error_mark_node || error_operand_p (expr))
7720 return error_mark_node;
7722 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7723 p = conversion_obstack_alloc (0);
7725 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7727 if (!conv || conv->bad_p)
7729 if (complain & tf_error)
7731 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
7732 && !TYPE_REF_IS_RVALUE (type)
7733 && !real_lvalue_p (expr))
7734 error ("invalid initialization of non-const reference of "
7735 "type %qT from an rvalue of type %qT",
7736 type, TREE_TYPE (expr));
7738 error ("invalid initialization of reference of type "
7739 "%qT from expression of type %qT", type,
7742 return error_mark_node;
7745 /* If DECL is non-NULL, then this special rule applies:
7749 The temporary to which the reference is bound or the temporary
7750 that is the complete object to which the reference is bound
7751 persists for the lifetime of the reference.
7753 The temporaries created during the evaluation of the expression
7754 initializing the reference, except the temporary to which the
7755 reference is bound, are destroyed at the end of the
7756 full-expression in which they are created.
7758 In that case, we store the converted expression into a new
7759 VAR_DECL in a new scope.
7761 However, we want to be careful not to create temporaries when
7762 they are not required. For example, given:
7765 struct D : public B {};
7769 there is no need to copy the return value from "f"; we can just
7770 extend its lifetime. Similarly, given:
7773 struct T { operator S(); };
7777 we can extend the lifetime of the return value of the conversion
7779 gcc_assert (conv->kind == ck_ref_bind);
7783 tree base_conv_type;
7785 /* Skip over the REF_BIND. */
7786 conv = conv->u.next;
7787 /* If the next conversion is a BASE_CONV, skip that too -- but
7788 remember that the conversion was required. */
7789 if (conv->kind == ck_base)
7791 base_conv_type = conv->type;
7792 conv = conv->u.next;
7795 base_conv_type = NULL_TREE;
7796 /* Perform the remainder of the conversion. */
7797 expr = convert_like_real (conv, expr,
7798 /*fn=*/NULL_TREE, /*argnum=*/0,
7800 /*issue_conversion_warnings=*/true,
7802 tf_warning_or_error);
7803 if (error_operand_p (expr))
7804 expr = error_mark_node;
7807 if (!lvalue_or_rvalue_with_address_p (expr))
7810 var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7811 /* Use its address to initialize the reference variable. */
7812 expr = build_address (var);
7814 expr = convert_to_base (expr,
7815 build_pointer_type (base_conv_type),
7816 /*check_access=*/true,
7817 /*nonnull=*/true, complain);
7818 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7821 /* Take the address of EXPR. */
7822 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7823 /* If a BASE_CONV was required, perform it now. */
7825 expr = (perform_implicit_conversion
7826 (build_pointer_type (base_conv_type), expr,
7827 tf_warning_or_error));
7828 expr = build_nop (type, expr);
7832 /* Perform the conversion. */
7833 expr = convert_like (conv, expr, tf_warning_or_error);
7835 /* Free all the conversions we allocated. */
7836 obstack_free (&conversion_obstack, p);
7841 /* Returns true iff TYPE is some variant of std::initializer_list. */
7844 is_std_init_list (tree type)
7846 return (CLASS_TYPE_P (type)
7847 && CP_TYPE_CONTEXT (type) == std_node
7848 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7851 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7852 will accept an argument list of a single std::initializer_list<T>. */
7855 is_list_ctor (tree decl)
7857 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7860 if (!args || args == void_list_node)
7863 arg = non_reference (TREE_VALUE (args));
7864 if (!is_std_init_list (arg))
7867 args = TREE_CHAIN (args);
7869 if (args && args != void_list_node && !TREE_PURPOSE (args))
7870 /* There are more non-defaulted parms. */
7876 #include "gt-cp-call.h"