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 cp_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))
5783 already_used = true;
5786 /* If we're creating a temp and we already have one, don't create a
5787 new one. If we're not creating a temp but we get one, use
5788 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5789 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5790 temp or an INIT_EXPR otherwise. */
5791 fa = (cand->first_arg != NULL_TREE
5793 : VEC_index (tree, args, 0));
5794 if (integer_zerop (fa))
5796 if (TREE_CODE (arg) == TARGET_EXPR)
5798 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5800 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5802 else if (TREE_CODE (arg) == TARGET_EXPR
5803 || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5804 && !move_fn_p (fn)))
5806 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
5809 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5813 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5815 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5817 tree to = stabilize_reference
5818 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
5819 tree type = TREE_TYPE (to);
5820 tree as_base = CLASSTYPE_AS_BASE (type);
5821 tree arg = argarray[1];
5823 if (is_really_empty_class (type))
5825 /* Avoid copying empty classes. */
5826 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
5827 TREE_NO_WARNING (val) = 1;
5828 val = build2 (COMPOUND_EXPR, type, val, to);
5829 TREE_NO_WARNING (val) = 1;
5831 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5833 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5834 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5838 /* We must only copy the non-tail padding parts.
5839 Use __builtin_memcpy for the bitwise copy.
5840 FIXME fix 22488 so we can go back to using MODIFY_EXPR
5841 instead of an explicit call to memcpy. */
5843 tree arg0, arg1, arg2, t;
5844 tree test = NULL_TREE;
5846 arg2 = TYPE_SIZE_UNIT (as_base);
5848 arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5850 if (!can_trust_pointer_alignment ())
5852 /* If we can't be sure about pointer alignment, a call
5853 to __builtin_memcpy is expanded as a call to memcpy, which
5854 is invalid with identical args. Otherwise it is
5855 expanded as a block move, which should be safe. */
5856 arg0 = save_expr (arg0);
5857 arg1 = save_expr (arg1);
5858 test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5860 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5861 t = build_call_n (t, 3, arg0, arg1, arg2);
5863 t = convert (TREE_TYPE (arg0), t);
5865 t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5866 val = cp_build_indirect_ref (t, RO_NULL, complain);
5867 TREE_NO_WARNING (val) = 1;
5876 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5879 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5882 gcc_assert (binfo && binfo != error_mark_node);
5884 /* Warn about deprecated virtual functions now, since we're about
5885 to throw away the decl. */
5886 if (TREE_DEPRECATED (fn))
5887 warn_deprecated_use (fn, NULL_TREE);
5889 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5890 if (TREE_SIDE_EFFECTS (argarray[0]))
5891 argarray[0] = save_expr (argarray[0]);
5892 t = build_pointer_type (TREE_TYPE (fn));
5893 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5894 fn = build_java_interface_fn_ref (fn, argarray[0]);
5896 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5900 fn = build_addr_func (fn);
5902 return build_cxx_call (fn, nargs, argarray);
5905 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5906 This function performs no overload resolution, conversion, or other
5907 high-level operations. */
5910 build_cxx_call (tree fn, int nargs, tree *argarray)
5914 fn = build_call_a (fn, nargs, argarray);
5916 /* If this call might throw an exception, note that fact. */
5917 fndecl = get_callee_fndecl (fn);
5918 if ((!fndecl || !TREE_NOTHROW (fndecl))
5919 && at_function_scope_p ()
5921 cp_function_chain->can_throw = 1;
5923 /* Check that arguments to builtin functions match the expectations. */
5925 && DECL_BUILT_IN (fndecl)
5926 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5927 && !check_builtin_function_arguments (fndecl, nargs, argarray))
5928 return error_mark_node;
5930 /* Some built-in function calls will be evaluated at compile-time in
5932 fn = fold_if_not_in_template (fn);
5934 if (VOID_TYPE_P (TREE_TYPE (fn)))
5937 fn = require_complete_type (fn);
5938 if (fn == error_mark_node)
5939 return error_mark_node;
5941 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
5942 fn = build_cplus_new (TREE_TYPE (fn), fn);
5943 return convert_from_reference (fn);
5946 static GTY(()) tree java_iface_lookup_fn;
5948 /* Make an expression which yields the address of the Java interface
5949 method FN. This is achieved by generating a call to libjava's
5950 _Jv_LookupInterfaceMethodIdx(). */
5953 build_java_interface_fn_ref (tree fn, tree instance)
5955 tree lookup_fn, method, idx;
5956 tree klass_ref, iface, iface_ref;
5959 if (!java_iface_lookup_fn)
5961 tree endlink = build_void_list_node ();
5962 tree t = tree_cons (NULL_TREE, ptr_type_node,
5963 tree_cons (NULL_TREE, ptr_type_node,
5964 tree_cons (NULL_TREE, java_int_type_node,
5966 java_iface_lookup_fn
5967 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5968 build_function_type (ptr_type_node, t),
5969 0, NOT_BUILT_IN, NULL, NULL_TREE);
5972 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5973 This is the first entry in the vtable. */
5974 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
5975 tf_warning_or_error),
5978 /* Get the java.lang.Class pointer for the interface being called. */
5979 iface = DECL_CONTEXT (fn);
5980 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5981 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5982 || DECL_CONTEXT (iface_ref) != iface)
5984 error ("could not find class$ field in java interface type %qT",
5986 return error_mark_node;
5988 iface_ref = build_address (iface_ref);
5989 iface_ref = convert (build_pointer_type (iface), iface_ref);
5991 /* Determine the itable index of FN. */
5993 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5995 if (!DECL_VIRTUAL_P (method))
6001 idx = build_int_cst (NULL_TREE, i);
6003 lookup_fn = build1 (ADDR_EXPR,
6004 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6005 java_iface_lookup_fn);
6006 return build_call_nary (ptr_type_node, lookup_fn,
6007 3, klass_ref, iface_ref, idx);
6010 /* Returns the value to use for the in-charge parameter when making a
6011 call to a function with the indicated NAME.
6013 FIXME:Can't we find a neater way to do this mapping? */
6016 in_charge_arg_for_name (tree name)
6018 if (name == base_ctor_identifier
6019 || name == base_dtor_identifier)
6020 return integer_zero_node;
6021 else if (name == complete_ctor_identifier)
6022 return integer_one_node;
6023 else if (name == complete_dtor_identifier)
6024 return integer_two_node;
6025 else if (name == deleting_dtor_identifier)
6026 return integer_three_node;
6028 /* This function should only be called with one of the names listed
6034 /* Build a call to a constructor, destructor, or an assignment
6035 operator for INSTANCE, an expression with class type. NAME
6036 indicates the special member function to call; *ARGS are the
6037 arguments. ARGS may be NULL. This may change ARGS. BINFO
6038 indicates the base of INSTANCE that is to be passed as the `this'
6039 parameter to the member function called.
6041 FLAGS are the LOOKUP_* flags to use when processing the call.
6043 If NAME indicates a complete object constructor, INSTANCE may be
6044 NULL_TREE. In this case, the caller will call build_cplus_new to
6045 store the newly constructed object into a VAR_DECL. */
6048 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6049 tree binfo, int flags, tsubst_flags_t complain)
6052 /* The type of the subobject to be constructed or destroyed. */
6054 VEC(tree,gc) *allocated = NULL;
6057 gcc_assert (name == complete_ctor_identifier
6058 || name == base_ctor_identifier
6059 || name == complete_dtor_identifier
6060 || name == base_dtor_identifier
6061 || name == deleting_dtor_identifier
6062 || name == ansi_assopname (NOP_EXPR));
6065 /* Resolve the name. */
6066 if (!complete_type_or_else (binfo, NULL_TREE))
6067 return error_mark_node;
6069 binfo = TYPE_BINFO (binfo);
6072 gcc_assert (binfo != NULL_TREE);
6074 class_type = BINFO_TYPE (binfo);
6076 /* Handle the special case where INSTANCE is NULL_TREE. */
6077 if (name == complete_ctor_identifier && !instance)
6079 instance = build_int_cst (build_pointer_type (class_type), 0);
6080 instance = build1 (INDIRECT_REF, class_type, instance);
6084 if (name == complete_dtor_identifier
6085 || name == base_dtor_identifier
6086 || name == deleting_dtor_identifier)
6087 gcc_assert (args == NULL || VEC_empty (tree, *args));
6089 /* Convert to the base class, if necessary. */
6090 if (!same_type_ignoring_top_level_qualifiers_p
6091 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6093 if (name != ansi_assopname (NOP_EXPR))
6094 /* For constructors and destructors, either the base is
6095 non-virtual, or it is virtual but we are doing the
6096 conversion from a constructor or destructor for the
6097 complete object. In either case, we can convert
6099 instance = convert_to_base_statically (instance, binfo);
6101 /* However, for assignment operators, we must convert
6102 dynamically if the base is virtual. */
6103 instance = build_base_path (PLUS_EXPR, instance,
6104 binfo, /*nonnull=*/1);
6108 gcc_assert (instance != NULL_TREE);
6110 fns = lookup_fnfields (binfo, name, 1);
6112 /* When making a call to a constructor or destructor for a subobject
6113 that uses virtual base classes, pass down a pointer to a VTT for
6115 if ((name == base_ctor_identifier
6116 || name == base_dtor_identifier)
6117 && CLASSTYPE_VBASECLASSES (class_type))
6122 /* If the current function is a complete object constructor
6123 or destructor, then we fetch the VTT directly.
6124 Otherwise, we look it up using the VTT we were given. */
6125 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6126 vtt = decay_conversion (vtt);
6127 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6128 build2 (EQ_EXPR, boolean_type_node,
6129 current_in_charge_parm, integer_zero_node),
6132 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6133 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6134 BINFO_SUBVTT_INDEX (binfo));
6138 allocated = make_tree_vector ();
6142 VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6145 ret = build_new_method_call (instance, fns, args,
6146 TYPE_BINFO (BINFO_TYPE (binfo)),
6150 if (allocated != NULL)
6151 release_tree_vector (allocated);
6156 /* Return the NAME, as a C string. The NAME indicates a function that
6157 is a member of TYPE. *FREE_P is set to true if the caller must
6158 free the memory returned.
6160 Rather than go through all of this, we should simply set the names
6161 of constructors and destructors appropriately, and dispense with
6162 ctor_identifier, dtor_identifier, etc. */
6165 name_as_c_string (tree name, tree type, bool *free_p)
6169 /* Assume that we will not allocate memory. */
6171 /* Constructors and destructors are special. */
6172 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6175 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6176 /* For a destructor, add the '~'. */
6177 if (name == complete_dtor_identifier
6178 || name == base_dtor_identifier
6179 || name == deleting_dtor_identifier)
6181 pretty_name = concat ("~", pretty_name, NULL);
6182 /* Remember that we need to free the memory allocated. */
6186 else if (IDENTIFIER_TYPENAME_P (name))
6188 pretty_name = concat ("operator ",
6189 type_as_string_translate (TREE_TYPE (name),
6190 TFF_PLAIN_IDENTIFIER),
6192 /* Remember that we need to free the memory allocated. */
6196 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6201 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
6202 be set, upon return, to the function called. ARGS may be NULL.
6203 This may change ARGS. */
6206 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
6207 tree conversion_path, int flags,
6208 tree *fn_p, tsubst_flags_t complain)
6210 struct z_candidate *candidates = 0, *cand;
6211 tree explicit_targs = NULL_TREE;
6212 tree basetype = NULL_TREE;
6215 tree first_mem_arg = NULL_TREE;
6218 bool skip_first_for_error;
6219 VEC(tree,gc) *user_args;
6222 int template_only = 0;
6226 VEC(tree,gc) *orig_args = NULL;
6228 tree list = NULL_TREE;
6231 gcc_assert (instance != NULL_TREE);
6233 /* We don't know what function we're going to call, yet. */
6237 if (error_operand_p (instance)
6238 || !fns || error_operand_p (fns))
6239 return error_mark_node;
6241 if (!BASELINK_P (fns))
6243 if (complain & tf_error)
6244 error ("call to non-function %qD", fns);
6245 return error_mark_node;
6248 orig_instance = instance;
6251 /* Dismantle the baselink to collect all the information we need. */
6252 if (!conversion_path)
6253 conversion_path = BASELINK_BINFO (fns);
6254 access_binfo = BASELINK_ACCESS_BINFO (fns);
6255 optype = BASELINK_OPTYPE (fns);
6256 fns = BASELINK_FUNCTIONS (fns);
6257 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6259 explicit_targs = TREE_OPERAND (fns, 1);
6260 fns = TREE_OPERAND (fns, 0);
6263 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6264 || TREE_CODE (fns) == TEMPLATE_DECL
6265 || TREE_CODE (fns) == OVERLOAD);
6266 fn = get_first_fn (fns);
6267 name = DECL_NAME (fn);
6269 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6270 gcc_assert (CLASS_TYPE_P (basetype));
6272 if (processing_template_decl)
6274 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6275 instance = build_non_dependent_expr (instance);
6277 make_args_non_dependent (*args);
6280 user_args = args == NULL ? NULL : *args;
6281 /* Under DR 147 A::A() is an invalid constructor call,
6282 not a functional cast. */
6283 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
6285 if (! (complain & tf_error))
6286 return error_mark_node;
6288 permerror (input_location,
6289 "cannot call constructor %<%T::%D%> directly",
6291 permerror (input_location, " for a function-style cast, remove the "
6292 "redundant %<::%D%>", name);
6293 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
6298 /* Figure out whether to skip the first argument for the error
6299 message we will display to users if an error occurs. We don't
6300 want to display any compiler-generated arguments. The "this"
6301 pointer hasn't been added yet. However, we must remove the VTT
6302 pointer if this is a call to a base-class constructor or
6304 skip_first_for_error = false;
6305 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6307 /* Callers should explicitly indicate whether they want to construct
6308 the complete object or just the part without virtual bases. */
6309 gcc_assert (name != ctor_identifier);
6310 /* Similarly for destructors. */
6311 gcc_assert (name != dtor_identifier);
6312 /* Remove the VTT pointer, if present. */
6313 if ((name == base_ctor_identifier || name == base_dtor_identifier)
6314 && CLASSTYPE_VBASECLASSES (basetype))
6315 skip_first_for_error = true;
6318 /* Process the argument list. */
6319 if (args != NULL && *args != NULL)
6321 *args = resolve_args (*args);
6323 return error_mark_node;
6326 instance_ptr = build_this (instance);
6328 /* It's OK to call destructors and constructors on cv-qualified objects.
6329 Therefore, convert the INSTANCE_PTR to the unqualified type, if
6331 if (DECL_DESTRUCTOR_P (fn)
6332 || DECL_CONSTRUCTOR_P (fn))
6334 tree type = build_pointer_type (basetype);
6335 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6336 instance_ptr = build_nop (type, instance_ptr);
6338 if (DECL_DESTRUCTOR_P (fn))
6339 name = complete_dtor_identifier;
6341 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6342 initializer, not T({ }). If the type doesn't have a list ctor (or no
6343 viable list ctor), break apart the list into separate ctor args. */
6345 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6346 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6347 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
6349 gcc_assert (VEC_length (tree, *args) == 1);
6350 list = VEC_index (tree, *args, 0);
6352 if (TYPE_HAS_LIST_CTOR (basetype))
6353 flags |= LOOKUP_LIST_ONLY;
6358 first_mem_arg = instance_ptr;
6360 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6361 p = conversion_obstack_alloc (0);
6363 any_viable_p = false;
6366 add_candidates (fns, first_mem_arg, user_args, optype,
6367 explicit_targs, template_only, conversion_path,
6368 access_binfo, flags, &candidates);
6369 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6372 if (!any_viable_p && list)
6374 VEC(tree,gc) *list_args = ctor_to_vec (list);
6375 flags &= ~LOOKUP_LIST_ONLY;
6376 add_candidates (fns, first_mem_arg, list_args, optype,
6377 explicit_targs, template_only, conversion_path,
6378 access_binfo, flags, &candidates);
6379 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6384 if (complain & tf_error)
6386 if (!COMPLETE_TYPE_P (basetype))
6387 cxx_incomplete_type_error (instance_ptr, basetype);
6389 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
6390 basetype, optype, build_tree_list_vec (user_args),
6391 TREE_TYPE (TREE_TYPE (instance_ptr)));
6398 pretty_name = name_as_c_string (name, basetype, &free_p);
6399 arglist = build_tree_list_vec (user_args);
6400 if (skip_first_for_error)
6401 arglist = TREE_CHAIN (arglist);
6402 error ("no matching function for call to %<%T::%s(%A)%#V%>",
6403 basetype, pretty_name, arglist,
6404 TREE_TYPE (TREE_TYPE (instance_ptr)));
6408 print_z_candidates (candidates);
6410 call = error_mark_node;
6414 cand = tourney (candidates);
6421 if (complain & tf_error)
6423 pretty_name = name_as_c_string (name, basetype, &free_p);
6424 arglist = build_tree_list_vec (user_args);
6425 if (skip_first_for_error)
6426 arglist = TREE_CHAIN (arglist);
6427 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6429 print_z_candidates (candidates);
6433 call = error_mark_node;
6439 if (!(flags & LOOKUP_NONVIRTUAL)
6440 && DECL_PURE_VIRTUAL_P (fn)
6441 && instance == current_class_ref
6442 && (DECL_CONSTRUCTOR_P (current_function_decl)
6443 || DECL_DESTRUCTOR_P (current_function_decl))
6444 && (complain & tf_warning))
6445 /* This is not an error, it is runtime undefined
6447 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6448 "pure virtual %q#D called from constructor"
6449 : "pure virtual %q#D called from destructor"),
6452 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6453 && is_dummy_object (instance_ptr))
6455 if (complain & tf_error)
6456 error ("cannot call member function %qD without object",
6458 call = error_mark_node;
6462 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6463 && resolves_to_fixed_type_p (instance, 0))
6464 flags |= LOOKUP_NONVIRTUAL;
6465 /* Now we know what function is being called. */
6468 /* Build the actual CALL_EXPR. */
6469 call = build_over_call (cand, flags, complain);
6470 /* In an expression of the form `a->f()' where `f' turns
6471 out to be a static member function, `a' is
6472 none-the-less evaluated. */
6473 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6474 && !is_dummy_object (instance_ptr)
6475 && TREE_SIDE_EFFECTS (instance_ptr))
6476 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6477 instance_ptr, call);
6478 else if (call != error_mark_node
6479 && DECL_DESTRUCTOR_P (cand->fn)
6480 && !VOID_TYPE_P (TREE_TYPE (call)))
6481 /* An explicit call of the form "x->~X()" has type
6482 "void". However, on platforms where destructors
6483 return "this" (i.e., those where
6484 targetm.cxx.cdtor_returns_this is true), such calls
6485 will appear to have a return value of pointer type
6486 to the low-level call machinery. We do not want to
6487 change the low-level machinery, since we want to be
6488 able to optimize "delete f()" on such platforms as
6489 "operator delete(~X(f()))" (rather than generating
6490 "t = f(), ~X(t), operator delete (t)"). */
6491 call = build_nop (void_type_node, call);
6496 if (processing_template_decl && call != error_mark_node)
6498 bool cast_to_void = false;
6500 if (TREE_CODE (call) == COMPOUND_EXPR)
6501 call = TREE_OPERAND (call, 1);
6502 else if (TREE_CODE (call) == NOP_EXPR)
6504 cast_to_void = true;
6505 call = TREE_OPERAND (call, 0);
6507 if (TREE_CODE (call) == INDIRECT_REF)
6508 call = TREE_OPERAND (call, 0);
6509 call = (build_min_non_dep_call_vec
6511 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6512 orig_instance, orig_fns, NULL_TREE),
6514 call = convert_from_reference (call);
6516 call = build_nop (void_type_node, call);
6519 /* Free all the conversions we allocated. */
6520 obstack_free (&conversion_obstack, p);
6522 if (orig_args != NULL)
6523 release_tree_vector (orig_args);
6528 /* Returns true iff standard conversion sequence ICS1 is a proper
6529 subsequence of ICS2. */
6532 is_subseq (conversion *ics1, conversion *ics2)
6534 /* We can assume that a conversion of the same code
6535 between the same types indicates a subsequence since we only get
6536 here if the types we are converting from are the same. */
6538 while (ics1->kind == ck_rvalue
6539 || ics1->kind == ck_lvalue)
6540 ics1 = ics1->u.next;
6544 while (ics2->kind == ck_rvalue
6545 || ics2->kind == ck_lvalue)
6546 ics2 = ics2->u.next;
6548 if (ics2->kind == ck_user
6549 || ics2->kind == ck_ambig
6550 || ics2->kind == ck_identity)
6551 /* At this point, ICS1 cannot be a proper subsequence of
6552 ICS2. We can get a USER_CONV when we are comparing the
6553 second standard conversion sequence of two user conversion
6557 ics2 = ics2->u.next;
6559 if (ics2->kind == ics1->kind
6560 && same_type_p (ics2->type, ics1->type)
6561 && same_type_p (ics2->u.next->type,
6562 ics1->u.next->type))
6567 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
6568 be any _TYPE nodes. */
6571 is_properly_derived_from (tree derived, tree base)
6573 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6576 /* We only allow proper derivation here. The DERIVED_FROM_P macro
6577 considers every class derived from itself. */
6578 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6579 && DERIVED_FROM_P (base, derived));
6582 /* We build the ICS for an implicit object parameter as a pointer
6583 conversion sequence. However, such a sequence should be compared
6584 as if it were a reference conversion sequence. If ICS is the
6585 implicit conversion sequence for an implicit object parameter,
6586 modify it accordingly. */
6589 maybe_handle_implicit_object (conversion **ics)
6593 /* [over.match.funcs]
6595 For non-static member functions, the type of the
6596 implicit object parameter is "reference to cv X"
6597 where X is the class of which the function is a
6598 member and cv is the cv-qualification on the member
6599 function declaration. */
6600 conversion *t = *ics;
6601 tree reference_type;
6603 /* The `this' parameter is a pointer to a class type. Make the
6604 implicit conversion talk about a reference to that same class
6606 reference_type = TREE_TYPE (t->type);
6607 reference_type = build_reference_type (reference_type);
6609 if (t->kind == ck_qual)
6611 if (t->kind == ck_ptr)
6613 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6614 t = direct_reference_binding (reference_type, t);
6616 t->rvaluedness_matches_p = 0;
6621 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6622 and return the initial reference binding conversion. Otherwise,
6623 leave *ICS unchanged and return NULL. */
6626 maybe_handle_ref_bind (conversion **ics)
6628 if ((*ics)->kind == ck_ref_bind)
6630 conversion *old_ics = *ics;
6631 *ics = old_ics->u.next;
6632 (*ics)->user_conv_p = old_ics->user_conv_p;
6639 /* Compare two implicit conversion sequences according to the rules set out in
6640 [over.ics.rank]. Return values:
6642 1: ics1 is better than ics2
6643 -1: ics2 is better than ics1
6644 0: ics1 and ics2 are indistinguishable */
6647 compare_ics (conversion *ics1, conversion *ics2)
6653 tree deref_from_type1 = NULL_TREE;
6654 tree deref_from_type2 = NULL_TREE;
6655 tree deref_to_type1 = NULL_TREE;
6656 tree deref_to_type2 = NULL_TREE;
6657 conversion_rank rank1, rank2;
6659 /* REF_BINDING is nonzero if the result of the conversion sequence
6660 is a reference type. In that case REF_CONV is the reference
6661 binding conversion. */
6662 conversion *ref_conv1;
6663 conversion *ref_conv2;
6665 /* Handle implicit object parameters. */
6666 maybe_handle_implicit_object (&ics1);
6667 maybe_handle_implicit_object (&ics2);
6669 /* Handle reference parameters. */
6670 ref_conv1 = maybe_handle_ref_bind (&ics1);
6671 ref_conv2 = maybe_handle_ref_bind (&ics2);
6673 /* List-initialization sequence L1 is a better conversion sequence than
6674 list-initialization sequence L2 if L1 converts to
6675 std::initializer_list<X> for some X and L2 does not. */
6676 if (ics1->kind == ck_list && ics2->kind != ck_list)
6678 if (ics2->kind == ck_list && ics1->kind != ck_list)
6683 When comparing the basic forms of implicit conversion sequences (as
6684 defined in _over.best.ics_)
6686 --a standard conversion sequence (_over.ics.scs_) is a better
6687 conversion sequence than a user-defined conversion sequence
6688 or an ellipsis conversion sequence, and
6690 --a user-defined conversion sequence (_over.ics.user_) is a
6691 better conversion sequence than an ellipsis conversion sequence
6692 (_over.ics.ellipsis_). */
6693 rank1 = CONVERSION_RANK (ics1);
6694 rank2 = CONVERSION_RANK (ics2);
6698 else if (rank1 < rank2)
6701 if (rank1 == cr_bad)
6703 /* XXX Isn't this an extension? */
6704 /* Both ICS are bad. We try to make a decision based on what
6705 would have happened if they'd been good. */
6706 if (ics1->user_conv_p > ics2->user_conv_p
6707 || ics1->rank > ics2->rank)
6709 else if (ics1->user_conv_p < ics2->user_conv_p
6710 || ics1->rank < ics2->rank)
6713 /* We couldn't make up our minds; try to figure it out below. */
6716 if (ics1->ellipsis_p || ics1->kind == ck_list)
6717 /* Both conversions are ellipsis conversions or both are building a
6718 std::initializer_list. */
6721 /* User-defined conversion sequence U1 is a better conversion sequence
6722 than another user-defined conversion sequence U2 if they contain the
6723 same user-defined conversion operator or constructor and if the sec-
6724 ond standard conversion sequence of U1 is better than the second
6725 standard conversion sequence of U2. */
6727 if (ics1->user_conv_p)
6732 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
6733 if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6735 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
6736 if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6739 if (t1->cand->fn != t2->cand->fn)
6742 /* We can just fall through here, after setting up
6743 FROM_TYPE1 and FROM_TYPE2. */
6744 from_type1 = t1->type;
6745 from_type2 = t2->type;
6752 /* We're dealing with two standard conversion sequences.
6756 Standard conversion sequence S1 is a better conversion
6757 sequence than standard conversion sequence S2 if
6759 --S1 is a proper subsequence of S2 (comparing the conversion
6760 sequences in the canonical form defined by _over.ics.scs_,
6761 excluding any Lvalue Transformation; the identity
6762 conversion sequence is considered to be a subsequence of
6763 any non-identity conversion sequence */
6766 while (t1->kind != ck_identity)
6768 from_type1 = t1->type;
6771 while (t2->kind != ck_identity)
6773 from_type2 = t2->type;
6776 /* One sequence can only be a subsequence of the other if they start with
6777 the same type. They can start with different types when comparing the
6778 second standard conversion sequence in two user-defined conversion
6780 if (same_type_p (from_type1, from_type2))
6782 if (is_subseq (ics1, ics2))
6784 if (is_subseq (ics2, ics1))
6792 --the rank of S1 is better than the rank of S2 (by the rules
6795 Standard conversion sequences are ordered by their ranks: an Exact
6796 Match is a better conversion than a Promotion, which is a better
6797 conversion than a Conversion.
6799 Two conversion sequences with the same rank are indistinguishable
6800 unless one of the following rules applies:
6802 --A conversion that does not a convert a pointer, pointer to member,
6803 or std::nullptr_t to bool is better than one that does.
6805 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6806 so that we do not have to check it explicitly. */
6807 if (ics1->rank < ics2->rank)
6809 else if (ics2->rank < ics1->rank)
6812 to_type1 = ics1->type;
6813 to_type2 = ics2->type;
6815 /* A conversion from scalar arithmetic type to complex is worse than a
6816 conversion between scalar arithmetic types. */
6817 if (same_type_p (from_type1, from_type2)
6818 && ARITHMETIC_TYPE_P (from_type1)
6819 && ARITHMETIC_TYPE_P (to_type1)
6820 && ARITHMETIC_TYPE_P (to_type2)
6821 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6822 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6824 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6830 if (TYPE_PTR_P (from_type1)
6831 && TYPE_PTR_P (from_type2)
6832 && TYPE_PTR_P (to_type1)
6833 && TYPE_PTR_P (to_type2))
6835 deref_from_type1 = TREE_TYPE (from_type1);
6836 deref_from_type2 = TREE_TYPE (from_type2);
6837 deref_to_type1 = TREE_TYPE (to_type1);
6838 deref_to_type2 = TREE_TYPE (to_type2);
6840 /* The rules for pointers to members A::* are just like the rules
6841 for pointers A*, except opposite: if B is derived from A then
6842 A::* converts to B::*, not vice versa. For that reason, we
6843 switch the from_ and to_ variables here. */
6844 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6845 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6846 || (TYPE_PTRMEMFUNC_P (from_type1)
6847 && TYPE_PTRMEMFUNC_P (from_type2)
6848 && TYPE_PTRMEMFUNC_P (to_type1)
6849 && TYPE_PTRMEMFUNC_P (to_type2)))
6851 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6852 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6853 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6854 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6857 if (deref_from_type1 != NULL_TREE
6858 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6859 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6861 /* This was one of the pointer or pointer-like conversions.
6865 --If class B is derived directly or indirectly from class A,
6866 conversion of B* to A* is better than conversion of B* to
6867 void*, and conversion of A* to void* is better than
6868 conversion of B* to void*. */
6869 if (TREE_CODE (deref_to_type1) == VOID_TYPE
6870 && TREE_CODE (deref_to_type2) == VOID_TYPE)
6872 if (is_properly_derived_from (deref_from_type1,
6875 else if (is_properly_derived_from (deref_from_type2,
6879 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6880 || TREE_CODE (deref_to_type2) == VOID_TYPE)
6882 if (same_type_p (deref_from_type1, deref_from_type2))
6884 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6886 if (is_properly_derived_from (deref_from_type1,
6890 /* We know that DEREF_TO_TYPE1 is `void' here. */
6891 else if (is_properly_derived_from (deref_from_type1,
6896 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6897 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6901 --If class B is derived directly or indirectly from class A
6902 and class C is derived directly or indirectly from B,
6904 --conversion of C* to B* is better than conversion of C* to
6907 --conversion of B* to A* is better than conversion of C* to
6909 if (same_type_p (deref_from_type1, deref_from_type2))
6911 if (is_properly_derived_from (deref_to_type1,
6914 else if (is_properly_derived_from (deref_to_type2,
6918 else if (same_type_p (deref_to_type1, deref_to_type2))
6920 if (is_properly_derived_from (deref_from_type2,
6923 else if (is_properly_derived_from (deref_from_type1,
6929 else if (CLASS_TYPE_P (non_reference (from_type1))
6930 && same_type_p (from_type1, from_type2))
6932 tree from = non_reference (from_type1);
6936 --binding of an expression of type C to a reference of type
6937 B& is better than binding an expression of type C to a
6938 reference of type A&
6940 --conversion of C to B is better than conversion of C to A, */
6941 if (is_properly_derived_from (from, to_type1)
6942 && is_properly_derived_from (from, to_type2))
6944 if (is_properly_derived_from (to_type1, to_type2))
6946 else if (is_properly_derived_from (to_type2, to_type1))
6950 else if (CLASS_TYPE_P (non_reference (to_type1))
6951 && same_type_p (to_type1, to_type2))
6953 tree to = non_reference (to_type1);
6957 --binding of an expression of type B to a reference of type
6958 A& is better than binding an expression of type C to a
6959 reference of type A&,
6961 --conversion of B to A is better than conversion of C to A */
6962 if (is_properly_derived_from (from_type1, to)
6963 && is_properly_derived_from (from_type2, to))
6965 if (is_properly_derived_from (from_type2, from_type1))
6967 else if (is_properly_derived_from (from_type1, from_type2))
6974 --S1 and S2 differ only in their qualification conversion and yield
6975 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6976 qualification signature of type T1 is a proper subset of the cv-
6977 qualification signature of type T2 */
6978 if (ics1->kind == ck_qual
6979 && ics2->kind == ck_qual
6980 && same_type_p (from_type1, from_type2))
6982 int result = comp_cv_qual_signature (to_type1, to_type2);
6989 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6990 to an implicit object parameter, and either S1 binds an lvalue reference
6991 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6992 reference to an rvalue and S2 binds an lvalue reference
6993 (C++0x draft standard, 13.3.3.2)
6995 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6996 types to which the references refer are the same type except for
6997 top-level cv-qualifiers, and the type to which the reference
6998 initialized by S2 refers is more cv-qualified than the type to
6999 which the reference initialized by S1 refers */
7001 if (ref_conv1 && ref_conv2)
7003 if (!ref_conv1->this_p && !ref_conv2->this_p
7004 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7005 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7007 if (ref_conv1->rvaluedness_matches_p)
7009 if (ref_conv2->rvaluedness_matches_p)
7013 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7014 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7015 TREE_TYPE (ref_conv1->type));
7018 /* Neither conversion sequence is better than the other. */
7022 /* The source type for this standard conversion sequence. */
7025 source_type (conversion *t)
7027 for (;; t = t->u.next)
7029 if (t->kind == ck_user
7030 || t->kind == ck_ambig
7031 || t->kind == ck_identity)
7037 /* Note a warning about preferring WINNER to LOSER. We do this by storing
7038 a pointer to LOSER and re-running joust to produce the warning if WINNER
7039 is actually used. */
7042 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7044 candidate_warning *cw = (candidate_warning *)
7045 conversion_obstack_alloc (sizeof (candidate_warning));
7047 cw->next = winner->warnings;
7048 winner->warnings = cw;
7051 /* Compare two candidates for overloading as described in
7052 [over.match.best]. Return values:
7054 1: cand1 is better than cand2
7055 -1: cand2 is better than cand1
7056 0: cand1 and cand2 are indistinguishable */
7059 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7062 int off1 = 0, off2 = 0;
7066 /* Candidates that involve bad conversions are always worse than those
7068 if (cand1->viable > cand2->viable)
7070 if (cand1->viable < cand2->viable)
7073 /* If we have two pseudo-candidates for conversions to the same type,
7074 or two candidates for the same function, arbitrarily pick one. */
7075 if (cand1->fn == cand2->fn
7076 && (IS_TYPE_OR_DECL_P (cand1->fn)))
7079 /* a viable function F1
7080 is defined to be a better function than another viable function F2 if
7081 for all arguments i, ICSi(F1) is not a worse conversion sequence than
7082 ICSi(F2), and then */
7084 /* for some argument j, ICSj(F1) is a better conversion sequence than
7087 /* For comparing static and non-static member functions, we ignore
7088 the implicit object parameter of the non-static function. The
7089 standard says to pretend that the static function has an object
7090 parm, but that won't work with operator overloading. */
7091 len = cand1->num_convs;
7092 if (len != cand2->num_convs)
7094 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7095 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7097 gcc_assert (static_1 != static_2);
7108 for (i = 0; i < len; ++i)
7110 conversion *t1 = cand1->convs[i + off1];
7111 conversion *t2 = cand2->convs[i + off2];
7112 int comp = compare_ics (t1, t2);
7117 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7118 == cr_std + cr_promotion)
7119 && t1->kind == ck_std
7120 && t2->kind == ck_std
7121 && TREE_CODE (t1->type) == INTEGER_TYPE
7122 && TREE_CODE (t2->type) == INTEGER_TYPE
7123 && (TYPE_PRECISION (t1->type)
7124 == TYPE_PRECISION (t2->type))
7125 && (TYPE_UNSIGNED (t1->u.next->type)
7126 || (TREE_CODE (t1->u.next->type)
7129 tree type = t1->u.next->type;
7131 struct z_candidate *w, *l;
7133 type1 = t1->type, type2 = t2->type,
7134 w = cand1, l = cand2;
7136 type1 = t2->type, type2 = t1->type,
7137 w = cand2, l = cand1;
7141 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7142 type, type1, type2);
7143 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
7149 if (winner && comp != winner)
7158 /* warn about confusing overload resolution for user-defined conversions,
7159 either between a constructor and a conversion op, or between two
7161 if (winner && warn_conversion && cand1->second_conv
7162 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7163 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7165 struct z_candidate *w, *l;
7166 bool give_warning = false;
7169 w = cand1, l = cand2;
7171 w = cand2, l = cand1;
7173 /* We don't want to complain about `X::operator T1 ()'
7174 beating `X::operator T2 () const', when T2 is a no less
7175 cv-qualified version of T1. */
7176 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7177 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7179 tree t = TREE_TYPE (TREE_TYPE (l->fn));
7180 tree f = TREE_TYPE (TREE_TYPE (w->fn));
7182 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7187 if (!comp_ptr_ttypes (t, f))
7188 give_warning = true;
7191 give_warning = true;
7197 tree source = source_type (w->convs[0]);
7198 if (! DECL_CONSTRUCTOR_P (w->fn))
7199 source = TREE_TYPE (source);
7200 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7201 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
7202 source, w->second_conv->type))
7204 inform (input_location, " because conversion sequence for the argument is better");
7215 F1 is a non-template function and F2 is a template function
7218 if (!cand1->template_decl && cand2->template_decl)
7220 else if (cand1->template_decl && !cand2->template_decl)
7224 F1 and F2 are template functions and the function template for F1 is
7225 more specialized than the template for F2 according to the partial
7228 if (cand1->template_decl && cand2->template_decl)
7230 winner = more_specialized_fn
7231 (TI_TEMPLATE (cand1->template_decl),
7232 TI_TEMPLATE (cand2->template_decl),
7233 /* [temp.func.order]: The presence of unused ellipsis and default
7234 arguments has no effect on the partial ordering of function
7235 templates. add_function_candidate() will not have
7236 counted the "this" argument for constructors. */
7237 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
7243 the context is an initialization by user-defined conversion (see
7244 _dcl.init_ and _over.match.user_) and the standard conversion
7245 sequence from the return type of F1 to the destination type (i.e.,
7246 the type of the entity being initialized) is a better conversion
7247 sequence than the standard conversion sequence from the return type
7248 of F2 to the destination type. */
7250 if (cand1->second_conv)
7252 winner = compare_ics (cand1->second_conv, cand2->second_conv);
7257 /* Check whether we can discard a builtin candidate, either because we
7258 have two identical ones or matching builtin and non-builtin candidates.
7260 (Pedantically in the latter case the builtin which matched the user
7261 function should not be added to the overload set, but we spot it here.
7264 ... the builtin candidates include ...
7265 - do not have the same parameter type list as any non-template
7266 non-member candidate. */
7268 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7269 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7271 for (i = 0; i < len; ++i)
7272 if (!same_type_p (cand1->convs[i]->type,
7273 cand2->convs[i]->type))
7275 if (i == cand1->num_convs)
7277 if (cand1->fn == cand2->fn)
7278 /* Two built-in candidates; arbitrarily pick one. */
7280 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7281 /* cand1 is built-in; prefer cand2. */
7284 /* cand2 is built-in; prefer cand1. */
7289 /* If the two function declarations represent the same function (this can
7290 happen with declarations in multiple scopes and arg-dependent lookup),
7291 arbitrarily choose one. But first make sure the default args we're
7293 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7294 && equal_functions (cand1->fn, cand2->fn))
7296 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7297 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7299 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7301 for (i = 0; i < len; ++i)
7303 /* Don't crash if the fn is variadic. */
7306 parms1 = TREE_CHAIN (parms1);
7307 parms2 = TREE_CHAIN (parms2);
7311 parms1 = TREE_CHAIN (parms1);
7313 parms2 = TREE_CHAIN (parms2);
7317 if (!cp_tree_equal (TREE_PURPOSE (parms1),
7318 TREE_PURPOSE (parms2)))
7322 permerror (input_location, "default argument mismatch in "
7323 "overload resolution");
7324 inform (input_location,
7325 " candidate 1: %q+#F", cand1->fn);
7326 inform (input_location,
7327 " candidate 2: %q+#F", cand2->fn);
7330 add_warning (cand1, cand2);
7333 parms1 = TREE_CHAIN (parms1);
7334 parms2 = TREE_CHAIN (parms2);
7342 /* Extension: If the worst conversion for one candidate is worse than the
7343 worst conversion for the other, take the first. */
7346 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7347 struct z_candidate *w = 0, *l = 0;
7349 for (i = 0; i < len; ++i)
7351 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7352 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7353 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7354 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7357 winner = 1, w = cand1, l = cand2;
7359 winner = -1, w = cand2, l = cand1;
7364 pedwarn (input_location, 0,
7365 "ISO C++ says that these are ambiguous, even "
7366 "though the worst conversion for the first is better than "
7367 "the worst conversion for the second:");
7368 print_z_candidate (_("candidate 1:"), w);
7369 print_z_candidate (_("candidate 2:"), l);
7377 gcc_assert (!winner);
7381 /* Given a list of candidates for overloading, find the best one, if any.
7382 This algorithm has a worst case of O(2n) (winner is last), and a best
7383 case of O(n/2) (totally ambiguous); much better than a sorting
7386 static struct z_candidate *
7387 tourney (struct z_candidate *candidates)
7389 struct z_candidate *champ = candidates, *challenger;
7391 int champ_compared_to_predecessor = 0;
7393 /* Walk through the list once, comparing each current champ to the next
7394 candidate, knocking out a candidate or two with each comparison. */
7396 for (challenger = champ->next; challenger; )
7398 fate = joust (champ, challenger, 0);
7400 challenger = challenger->next;
7405 champ = challenger->next;
7408 champ_compared_to_predecessor = 0;
7413 champ_compared_to_predecessor = 1;
7416 challenger = champ->next;
7420 /* Make sure the champ is better than all the candidates it hasn't yet
7421 been compared to. */
7423 for (challenger = candidates;
7425 && !(champ_compared_to_predecessor && challenger->next == champ);
7426 challenger = challenger->next)
7428 fate = joust (champ, challenger, 0);
7436 /* Returns nonzero if things of type FROM can be converted to TO. */
7439 can_convert (tree to, tree from)
7441 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
7444 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
7447 can_convert_arg (tree to, tree from, tree arg, int flags)
7453 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7454 p = conversion_obstack_alloc (0);
7456 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7458 ok_p = (t && !t->bad_p);
7460 /* Free all the conversions we allocated. */
7461 obstack_free (&conversion_obstack, p);
7466 /* Like can_convert_arg, but allows dubious conversions as well. */
7469 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
7474 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7475 p = conversion_obstack_alloc (0);
7476 /* Try to perform the conversion. */
7477 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7479 /* Free all the conversions we allocated. */
7480 obstack_free (&conversion_obstack, p);
7485 /* Convert EXPR to TYPE. Return the converted expression.
7487 Note that we allow bad conversions here because by the time we get to
7488 this point we are committed to doing the conversion. If we end up
7489 doing a bad conversion, convert_like will complain. */
7492 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7497 if (error_operand_p (expr))
7498 return error_mark_node;
7500 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7501 p = conversion_obstack_alloc (0);
7503 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7509 if (complain & tf_error)
7511 /* If expr has unknown type, then it is an overloaded function.
7512 Call instantiate_type to get good error messages. */
7513 if (TREE_TYPE (expr) == unknown_type_node)
7514 instantiate_type (type, expr, complain);
7515 else if (invalid_nonstatic_memfn_p (expr, complain))
7516 /* We gave an error. */;
7518 error ("could not convert %qE to %qT", expr, type);
7520 expr = error_mark_node;
7522 else if (processing_template_decl)
7524 /* In a template, we are only concerned about determining the
7525 type of non-dependent expressions, so we do not have to
7526 perform the actual conversion. */
7527 if (TREE_TYPE (expr) != type)
7528 expr = build_nop (type, expr);
7531 expr = convert_like (conv, expr, complain);
7533 /* Free all the conversions we allocated. */
7534 obstack_free (&conversion_obstack, p);
7540 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7542 return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
7545 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7546 permitted. If the conversion is valid, the converted expression is
7547 returned. Otherwise, NULL_TREE is returned, except in the case
7548 that TYPE is a class type; in that case, an error is issued. If
7549 C_CAST_P is true, then this direction initialization is taking
7550 place as part of a static_cast being attempted as part of a C-style
7554 perform_direct_initialization_if_possible (tree type,
7557 tsubst_flags_t complain)
7562 if (type == error_mark_node || error_operand_p (expr))
7563 return error_mark_node;
7566 If the destination type is a (possibly cv-qualified) class type:
7568 -- If the initialization is direct-initialization ...,
7569 constructors are considered. ... If no constructor applies, or
7570 the overload resolution is ambiguous, the initialization is
7572 if (CLASS_TYPE_P (type))
7574 VEC(tree,gc) *args = make_tree_vector_single (expr);
7575 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7576 &args, type, LOOKUP_NORMAL, complain);
7577 release_tree_vector (args);
7578 return build_cplus_new (type, expr);
7581 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7582 p = conversion_obstack_alloc (0);
7584 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7587 if (!conv || conv->bad_p)
7590 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7591 /*issue_conversion_warnings=*/false,
7595 /* Free all the conversions we allocated. */
7596 obstack_free (&conversion_obstack, p);
7601 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
7602 is being bound to a temporary. Create and return a new VAR_DECL
7603 with the indicated TYPE; this variable will store the value to
7604 which the reference is bound. */
7607 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7611 /* Create the variable. */
7612 var = create_temporary_var (type);
7614 /* Register the variable. */
7615 if (TREE_STATIC (decl))
7617 /* Namespace-scope or local static; give it a mangled name. */
7620 TREE_STATIC (var) = 1;
7621 name = mangle_ref_init_variable (decl);
7622 DECL_NAME (var) = name;
7623 SET_DECL_ASSEMBLER_NAME (var, name);
7624 var = pushdecl_top_level (var);
7627 /* Create a new cleanup level if necessary. */
7628 maybe_push_cleanup_level (type);
7633 /* EXPR is the initializer for a variable DECL of reference or
7634 std::initializer_list type. Create, push and return a new VAR_DECL
7635 for the initializer so that it will live as long as DECL. Any
7636 cleanup for the new variable is returned through CLEANUP, and the
7637 code to initialize the new variable is returned through INITP. */
7640 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7646 /* Create the temporary variable. */
7647 type = TREE_TYPE (expr);
7648 var = make_temporary_var_for_ref_to_temp (decl, type);
7649 layout_decl (var, 0);
7650 /* If the rvalue is the result of a function call it will be
7651 a TARGET_EXPR. If it is some other construct (such as a
7652 member access expression where the underlying object is
7653 itself the result of a function call), turn it into a
7654 TARGET_EXPR here. It is important that EXPR be a
7655 TARGET_EXPR below since otherwise the INIT_EXPR will
7656 attempt to make a bitwise copy of EXPR to initialize
7658 if (TREE_CODE (expr) != TARGET_EXPR)
7659 expr = get_target_expr (expr);
7660 /* Create the INIT_EXPR that will initialize the temporary
7662 init = build2 (INIT_EXPR, type, var, expr);
7663 if (at_function_scope_p ())
7665 add_decl_expr (var);
7667 if (TREE_STATIC (var))
7668 init = add_stmt_to_compound (init, register_dtor_fn (var));
7670 *cleanup = cxx_maybe_build_cleanup (var);
7672 /* We must be careful to destroy the temporary only
7673 after its initialization has taken place. If the
7674 initialization throws an exception, then the
7675 destructor should not be run. We cannot simply
7676 transform INIT into something like:
7678 (INIT, ({ CLEANUP_STMT; }))
7680 because emit_local_var always treats the
7681 initializer as a full-expression. Thus, the
7682 destructor would run too early; it would run at the
7683 end of initializing the reference variable, rather
7684 than at the end of the block enclosing the
7687 The solution is to pass back a cleanup expression
7688 which the caller is responsible for attaching to
7689 the statement tree. */
7693 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7694 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7695 static_aggregates = tree_cons (NULL_TREE, var,
7703 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7704 initializing a variable of that TYPE. If DECL is non-NULL, it is
7705 the VAR_DECL being initialized with the EXPR. (In that case, the
7706 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
7707 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
7708 return, if *CLEANUP is no longer NULL, it will be an expression
7709 that should be pushed as a cleanup after the returned expression
7710 is used to initialize DECL.
7712 Return the converted expression. */
7715 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
7716 tsubst_flags_t complain)
7721 if (type == error_mark_node || error_operand_p (expr))
7722 return error_mark_node;
7724 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7725 p = conversion_obstack_alloc (0);
7727 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7729 if (!conv || conv->bad_p)
7731 if (complain & tf_error)
7733 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
7734 && !TYPE_REF_IS_RVALUE (type)
7735 && !real_lvalue_p (expr))
7736 error ("invalid initialization of non-const reference of "
7737 "type %qT from an rvalue of type %qT",
7738 type, TREE_TYPE (expr));
7740 error ("invalid initialization of reference of type "
7741 "%qT from expression of type %qT", type,
7744 return error_mark_node;
7747 /* If DECL is non-NULL, then this special rule applies:
7751 The temporary to which the reference is bound or the temporary
7752 that is the complete object to which the reference is bound
7753 persists for the lifetime of the reference.
7755 The temporaries created during the evaluation of the expression
7756 initializing the reference, except the temporary to which the
7757 reference is bound, are destroyed at the end of the
7758 full-expression in which they are created.
7760 In that case, we store the converted expression into a new
7761 VAR_DECL in a new scope.
7763 However, we want to be careful not to create temporaries when
7764 they are not required. For example, given:
7767 struct D : public B {};
7771 there is no need to copy the return value from "f"; we can just
7772 extend its lifetime. Similarly, given:
7775 struct T { operator S(); };
7779 we can extend the lifetime of the return value of the conversion
7781 gcc_assert (conv->kind == ck_ref_bind);
7785 tree base_conv_type;
7787 /* Skip over the REF_BIND. */
7788 conv = conv->u.next;
7789 /* If the next conversion is a BASE_CONV, skip that too -- but
7790 remember that the conversion was required. */
7791 if (conv->kind == ck_base)
7793 base_conv_type = conv->type;
7794 conv = conv->u.next;
7797 base_conv_type = NULL_TREE;
7798 /* Perform the remainder of the conversion. */
7799 expr = convert_like_real (conv, expr,
7800 /*fn=*/NULL_TREE, /*argnum=*/0,
7802 /*issue_conversion_warnings=*/true,
7804 tf_warning_or_error);
7805 if (error_operand_p (expr))
7806 expr = error_mark_node;
7809 if (!lvalue_or_rvalue_with_address_p (expr))
7812 var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7813 /* Use its address to initialize the reference variable. */
7814 expr = build_address (var);
7816 expr = convert_to_base (expr,
7817 build_pointer_type (base_conv_type),
7818 /*check_access=*/true,
7819 /*nonnull=*/true, complain);
7820 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7823 /* Take the address of EXPR. */
7824 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7825 /* If a BASE_CONV was required, perform it now. */
7827 expr = (perform_implicit_conversion
7828 (build_pointer_type (base_conv_type), expr,
7829 tf_warning_or_error));
7830 expr = build_nop (type, expr);
7834 /* Perform the conversion. */
7835 expr = convert_like (conv, expr, tf_warning_or_error);
7837 /* Free all the conversions we allocated. */
7838 obstack_free (&conversion_obstack, p);
7843 /* Returns true iff TYPE is some variant of std::initializer_list. */
7846 is_std_init_list (tree type)
7848 return (CLASS_TYPE_P (type)
7849 && CP_TYPE_CONTEXT (type) == std_node
7850 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7853 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7854 will accept an argument list of a single std::initializer_list<T>. */
7857 is_list_ctor (tree decl)
7859 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7862 if (!args || args == void_list_node)
7865 arg = non_reference (TREE_VALUE (args));
7866 if (!is_std_init_list (arg))
7869 args = TREE_CHAIN (args);
7871 if (args && args != void_list_node && !TREE_PURPOSE (args))
7872 /* There are more non-defaulted parms. */
7878 #include "gt-cp-call.h"