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;
451 candidate_warning *warnings;
455 /* Returns true iff T is a null pointer constant in the sense of
459 null_ptr_cst_p (tree t)
463 A null pointer constant is an integral constant expression
464 (_expr.const_) rvalue of integer type that evaluates to zero or
465 an rvalue of type std::nullptr_t. */
466 t = integral_constant_value (t);
468 || NULLPTR_TYPE_P (TREE_TYPE (t)))
470 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
473 if (!TREE_OVERFLOW (t))
479 /* Returns nonzero if PARMLIST consists of only default parms and/or
483 sufficient_parms_p (const_tree parmlist)
485 for (; parmlist && parmlist != void_list_node;
486 parmlist = TREE_CHAIN (parmlist))
487 if (!TREE_PURPOSE (parmlist))
492 /* Allocate N bytes of memory from the conversion obstack. The memory
493 is zeroed before being returned. */
496 conversion_obstack_alloc (size_t n)
499 if (!conversion_obstack_initialized)
501 gcc_obstack_init (&conversion_obstack);
502 conversion_obstack_initialized = true;
504 p = obstack_alloc (&conversion_obstack, n);
509 /* Dynamically allocate a conversion. */
512 alloc_conversion (conversion_kind kind)
515 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
520 #ifdef ENABLE_CHECKING
522 /* Make sure that all memory on the conversion obstack has been
526 validate_conversion_obstack (void)
528 if (conversion_obstack_initialized)
529 gcc_assert ((obstack_next_free (&conversion_obstack)
530 == obstack_base (&conversion_obstack)));
533 #endif /* ENABLE_CHECKING */
535 /* Dynamically allocate an array of N conversions. */
538 alloc_conversions (size_t n)
540 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
544 build_conv (conversion_kind code, tree type, conversion *from)
547 conversion_rank rank = CONVERSION_RANK (from);
549 /* Note that the caller is responsible for filling in t->cand for
550 user-defined conversions. */
551 t = alloc_conversion (code);
574 t->user_conv_p = (code == ck_user || from->user_conv_p);
575 t->bad_p = from->bad_p;
580 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
581 specialization of std::initializer_list<T>, if such a conversion is
585 build_list_conv (tree type, tree ctor, int flags)
587 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
588 unsigned len = CONSTRUCTOR_NELTS (ctor);
589 conversion **subconvs = alloc_conversions (len);
594 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
597 = implicit_conversion (elttype, TREE_TYPE (val), val,
605 t = alloc_conversion (ck_list);
607 t->u.list = subconvs;
610 for (i = 0; i < len; ++i)
612 conversion *sub = subconvs[i];
613 if (sub->rank > t->rank)
615 if (sub->user_conv_p)
616 t->user_conv_p = true;
624 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
625 aggregate class, if such a conversion is possible. */
628 build_aggr_conv (tree type, tree ctor, int flags)
630 unsigned HOST_WIDE_INT i = 0;
632 tree field = next_initializable_field (TYPE_FIELDS (type));
634 for (; field; field = next_initializable_field (TREE_CHAIN (field)))
636 if (i < CONSTRUCTOR_NELTS (ctor))
638 constructor_elt *ce = CONSTRUCTOR_ELT (ctor, i);
639 if (!can_convert_arg (TREE_TYPE (field), TREE_TYPE (ce->value),
643 if (TREE_CODE (type) == UNION_TYPE)
646 else if (build_value_init (TREE_TYPE (field)) == error_mark_node)
650 if (i < CONSTRUCTOR_NELTS (ctor))
653 c = alloc_conversion (ck_aggr);
656 c->user_conv_p = true;
661 /* Build a representation of the identity conversion from EXPR to
662 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
665 build_identity_conv (tree type, tree expr)
669 c = alloc_conversion (ck_identity);
676 /* Converting from EXPR to TYPE was ambiguous in the sense that there
677 were multiple user-defined conversions to accomplish the job.
678 Build a conversion that indicates that ambiguity. */
681 build_ambiguous_conv (tree type, tree expr)
685 c = alloc_conversion (ck_ambig);
693 strip_top_quals (tree t)
695 if (TREE_CODE (t) == ARRAY_TYPE)
697 return cp_build_qualified_type (t, 0);
700 /* Returns the standard conversion path (see [conv]) from type FROM to type
701 TO, if any. For proper handling of null pointer constants, you must
702 also pass the expression EXPR to convert from. If C_CAST_P is true,
703 this conversion is coming from a C-style cast. */
706 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
709 enum tree_code fcode, tcode;
711 bool fromref = false;
713 to = non_reference (to);
714 if (TREE_CODE (from) == REFERENCE_TYPE)
717 from = TREE_TYPE (from);
719 to = strip_top_quals (to);
720 from = strip_top_quals (from);
722 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
723 && expr && type_unknown_p (expr))
725 tsubst_flags_t tflags = tf_conv;
726 if (!(flags & LOOKUP_PROTECT))
727 tflags |= tf_no_access_control;
728 expr = instantiate_type (to, expr, tflags);
729 if (expr == error_mark_node)
731 from = TREE_TYPE (expr);
734 fcode = TREE_CODE (from);
735 tcode = TREE_CODE (to);
737 conv = build_identity_conv (from, expr);
738 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
740 from = type_decays_to (from);
741 fcode = TREE_CODE (from);
742 conv = build_conv (ck_lvalue, from, conv);
744 else if (fromref || (expr && lvalue_p (expr)))
749 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
752 from = strip_top_quals (bitfield_type);
753 fcode = TREE_CODE (from);
756 conv = build_conv (ck_rvalue, from, conv);
759 /* Allow conversion between `__complex__' data types. */
760 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
762 /* The standard conversion sequence to convert FROM to TO is
763 the standard conversion sequence to perform componentwise
765 conversion *part_conv = standard_conversion
766 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
770 conv = build_conv (part_conv->kind, to, conv);
771 conv->rank = part_conv->rank;
779 if (same_type_p (from, to))
783 A null pointer constant can be converted to a pointer type; ... A
784 null pointer constant of integral type can be converted to an
785 rvalue of type std::nullptr_t. */
786 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)
787 || NULLPTR_TYPE_P (to))
788 && expr && null_ptr_cst_p (expr))
789 conv = build_conv (ck_std, to, conv);
790 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
791 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
793 /* For backwards brain damage compatibility, allow interconversion of
794 pointers and integers with a pedwarn. */
795 conv = build_conv (ck_std, to, conv);
798 else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
800 /* For backwards brain damage compatibility, allow interconversion of
801 enums and integers with a pedwarn. */
802 conv = build_conv (ck_std, to, conv);
805 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
806 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
811 if (tcode == POINTER_TYPE
812 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
815 else if (VOID_TYPE_P (TREE_TYPE (to))
816 && !TYPE_PTRMEM_P (from)
817 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
819 from = build_pointer_type
820 (cp_build_qualified_type (void_type_node,
821 cp_type_quals (TREE_TYPE (from))));
822 conv = build_conv (ck_ptr, from, conv);
824 else if (TYPE_PTRMEM_P (from))
826 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
827 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
829 if (DERIVED_FROM_P (fbase, tbase)
830 && (same_type_ignoring_top_level_qualifiers_p
831 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
832 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
834 from = build_ptrmem_type (tbase,
835 TYPE_PTRMEM_POINTED_TO_TYPE (from));
836 conv = build_conv (ck_pmem, from, conv);
838 else if (!same_type_p (fbase, tbase))
841 else if (CLASS_TYPE_P (TREE_TYPE (from))
842 && CLASS_TYPE_P (TREE_TYPE (to))
845 An rvalue of type "pointer to cv D," where D is a
846 class type, can be converted to an rvalue of type
847 "pointer to cv B," where B is a base class (clause
848 _class.derived_) of D. If B is an inaccessible
849 (clause _class.access_) or ambiguous
850 (_class.member.lookup_) base class of D, a program
851 that necessitates this conversion is ill-formed.
852 Therefore, we use DERIVED_FROM_P, and do not check
853 access or uniqueness. */
854 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
857 cp_build_qualified_type (TREE_TYPE (to),
858 cp_type_quals (TREE_TYPE (from)));
859 from = build_pointer_type (from);
860 conv = build_conv (ck_ptr, from, conv);
864 if (tcode == POINTER_TYPE)
866 to_pointee = TREE_TYPE (to);
867 from_pointee = TREE_TYPE (from);
871 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
872 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
875 if (same_type_p (from, to))
877 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
878 /* In a C-style cast, we ignore CV-qualification because we
879 are allowed to perform a static_cast followed by a
881 conv = build_conv (ck_qual, to, conv);
882 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
883 conv = build_conv (ck_qual, to, conv);
884 else if (expr && string_conv_p (to, expr, 0))
885 /* converting from string constant to char *. */
886 conv = build_conv (ck_qual, to, conv);
887 else if (ptr_reasonably_similar (to_pointee, from_pointee))
889 conv = build_conv (ck_ptr, to, conv);
897 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
899 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
900 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
901 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
902 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
904 if (!DERIVED_FROM_P (fbase, tbase)
905 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
906 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
907 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
908 || cp_type_quals (fbase) != cp_type_quals (tbase))
911 from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
912 from = build_ptrmemfunc_type (build_pointer_type (from));
913 conv = build_conv (ck_pmem, from, conv);
916 else if (tcode == BOOLEAN_TYPE)
920 An rvalue of arithmetic, unscoped enumeration, pointer, or
921 pointer to member type can be converted to an rvalue of type
922 bool. ... An rvalue of type std::nullptr_t can be converted
923 to an rvalue of type bool; */
924 if (ARITHMETIC_TYPE_P (from)
925 || UNSCOPED_ENUM_P (from)
926 || fcode == POINTER_TYPE
927 || TYPE_PTR_TO_MEMBER_P (from)
928 || NULLPTR_TYPE_P (from))
930 conv = build_conv (ck_std, to, conv);
931 if (fcode == POINTER_TYPE
932 || TYPE_PTRMEM_P (from)
933 || (TYPE_PTRMEMFUNC_P (from)
934 && conv->rank < cr_pbool)
935 || NULLPTR_TYPE_P (from))
936 conv->rank = cr_pbool;
942 /* We don't check for ENUMERAL_TYPE here because there are no standard
943 conversions to enum type. */
944 /* As an extension, allow conversion to complex type. */
945 else if (ARITHMETIC_TYPE_P (to))
947 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
948 || SCOPED_ENUM_P (from))
950 conv = build_conv (ck_std, to, conv);
952 /* Give this a better rank if it's a promotion. */
953 if (same_type_p (to, type_promotes_to (from))
954 && conv->u.next->rank <= cr_promotion)
955 conv->rank = cr_promotion;
957 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
958 && vector_types_convertible_p (from, to, false))
959 return build_conv (ck_std, to, conv);
960 else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
961 && is_properly_derived_from (from, to))
963 if (conv->kind == ck_rvalue)
965 conv = build_conv (ck_base, to, conv);
966 /* The derived-to-base conversion indicates the initialization
967 of a parameter with base type from an object of a derived
968 type. A temporary object is created to hold the result of
969 the conversion unless we're binding directly to a reference. */
970 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
975 if (flags & LOOKUP_NO_NARROWING)
976 conv->check_narrowing = true;
981 /* Returns nonzero if T1 is reference-related to T2. */
984 reference_related_p (tree t1, tree t2)
986 t1 = TYPE_MAIN_VARIANT (t1);
987 t2 = TYPE_MAIN_VARIANT (t2);
991 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
992 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
994 return (same_type_p (t1, t2)
995 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
996 && DERIVED_FROM_P (t1, t2)));
999 /* Returns nonzero if T1 is reference-compatible with T2. */
1002 reference_compatible_p (tree t1, tree t2)
1006 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1007 reference-related to T2 and cv1 is the same cv-qualification as,
1008 or greater cv-qualification than, cv2. */
1009 return (reference_related_p (t1, t2)
1010 && at_least_as_qualified_p (t1, t2));
1013 /* Determine whether or not the EXPR (of class type S) can be
1014 converted to T as in [over.match.ref]. */
1017 convert_class_to_reference (tree reference_type, tree s, tree expr, int flags)
1023 struct z_candidate *candidates;
1024 struct z_candidate *cand;
1027 conversions = lookup_conversions (s, /*lookup_template_convs_p=*/true);
1033 Assuming that "cv1 T" is the underlying type of the reference
1034 being initialized, and "cv S" is the type of the initializer
1035 expression, with S a class type, the candidate functions are
1036 selected as follows:
1038 --The conversion functions of S and its base classes are
1039 considered. Those that are not hidden within S and yield type
1040 "reference to cv2 T2", where "cv1 T" is reference-compatible
1041 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1043 The argument list has one argument, which is the initializer
1048 /* Conceptually, we should take the address of EXPR and put it in
1049 the argument list. Unfortunately, however, that can result in
1050 error messages, which we should not issue now because we are just
1051 trying to find a conversion operator. Therefore, we use NULL,
1052 cast to the appropriate type. */
1053 first_arg = build_int_cst (build_pointer_type (s), 0);
1055 t = TREE_TYPE (reference_type);
1057 /* We're performing a user-defined conversion to a desired type, so set
1058 this for the benefit of add_candidates. */
1059 flags |= LOOKUP_NO_CONVERSION;
1061 for (; conversions; conversions = TREE_CHAIN (conversions))
1063 tree fns = TREE_VALUE (conversions);
1064 tree binfo = TREE_PURPOSE (conversions);
1065 struct z_candidate *old_candidates = candidates;;
1067 add_candidates (fns, first_arg, NULL, reference_type,
1069 binfo, TYPE_BINFO (s),
1070 flags, &candidates);
1072 for (cand = candidates; cand != old_candidates; cand = cand->next)
1074 /* Now, see if the conversion function really returns
1075 an lvalue of the appropriate type. From the
1076 point of view of unification, simply returning an
1077 rvalue of the right type is good enough. */
1079 tree t2 = TREE_TYPE (TREE_TYPE (f));
1080 if (TREE_CODE (t2) != REFERENCE_TYPE
1081 || !reference_compatible_p (t, TREE_TYPE (t2)))
1087 conversion *identity_conv;
1088 /* Build a standard conversion sequence indicating the
1089 binding from the reference type returned by the
1090 function to the desired REFERENCE_TYPE. */
1092 = build_identity_conv (TREE_TYPE (TREE_TYPE
1093 (TREE_TYPE (cand->fn))),
1096 = (direct_reference_binding
1097 (reference_type, identity_conv));
1098 cand->second_conv->rvaluedness_matches_p
1099 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1100 == TYPE_REF_IS_RVALUE (reference_type);
1101 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1103 /* Don't allow binding of lvalues to rvalue references. */
1104 if (TYPE_REF_IS_RVALUE (reference_type)
1105 && !TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn))))
1106 cand->second_conv->bad_p = true;
1111 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1112 /* If none of the conversion functions worked out, let our caller
1117 cand = tourney (candidates);
1121 /* Now that we know that this is the function we're going to use fix
1122 the dummy first argument. */
1123 gcc_assert (cand->first_arg == NULL_TREE
1124 || integer_zerop (cand->first_arg));
1125 cand->first_arg = build_this (expr);
1127 /* Build a user-defined conversion sequence representing the
1129 conv = build_conv (ck_user,
1130 TREE_TYPE (TREE_TYPE (cand->fn)),
1131 build_identity_conv (TREE_TYPE (expr), expr));
1134 if (cand->viable == -1)
1137 /* Merge it with the standard conversion sequence from the
1138 conversion function's return type to the desired type. */
1139 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1141 return cand->second_conv;
1144 /* A reference of the indicated TYPE is being bound directly to the
1145 expression represented by the implicit conversion sequence CONV.
1146 Return a conversion sequence for this binding. */
1149 direct_reference_binding (tree type, conversion *conv)
1153 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1154 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1156 t = TREE_TYPE (type);
1160 When a parameter of reference type binds directly
1161 (_dcl.init.ref_) to an argument expression, the implicit
1162 conversion sequence is the identity conversion, unless the
1163 argument expression has a type that is a derived class of the
1164 parameter type, in which case the implicit conversion sequence is
1165 a derived-to-base Conversion.
1167 If the parameter binds directly to the result of applying a
1168 conversion function to the argument expression, the implicit
1169 conversion sequence is a user-defined conversion sequence
1170 (_over.ics.user_), with the second standard conversion sequence
1171 either an identity conversion or, if the conversion function
1172 returns an entity of a type that is a derived class of the
1173 parameter type, a derived-to-base conversion. */
1174 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1176 /* Represent the derived-to-base conversion. */
1177 conv = build_conv (ck_base, t, conv);
1178 /* We will actually be binding to the base-class subobject in
1179 the derived class, so we mark this conversion appropriately.
1180 That way, convert_like knows not to generate a temporary. */
1181 conv->need_temporary_p = false;
1183 return build_conv (ck_ref_bind, type, conv);
1186 /* Returns the conversion path from type FROM to reference type TO for
1187 purposes of reference binding. For lvalue binding, either pass a
1188 reference type to FROM or an lvalue expression to EXPR. If the
1189 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1190 the conversion returned. If C_CAST_P is true, this
1191 conversion is coming from a C-style cast. */
1194 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1196 conversion *conv = NULL;
1197 tree to = TREE_TYPE (rto);
1202 cp_lvalue_kind is_lvalue = clk_none;
1204 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1206 expr = instantiate_type (to, expr, tf_none);
1207 if (expr == error_mark_node)
1209 from = TREE_TYPE (expr);
1212 if (TREE_CODE (from) == REFERENCE_TYPE)
1214 /* Anything with reference type is an lvalue. */
1215 is_lvalue = clk_ordinary;
1216 from = TREE_TYPE (from);
1219 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1221 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1222 conv = implicit_conversion (to, from, expr, c_cast_p,
1224 if (!CLASS_TYPE_P (to)
1225 && CONSTRUCTOR_NELTS (expr) == 1)
1227 expr = CONSTRUCTOR_ELT (expr, 0)->value;
1228 if (error_operand_p (expr))
1230 from = TREE_TYPE (expr);
1234 if (is_lvalue == clk_none && expr)
1235 is_lvalue = real_lvalue_p (expr);
1238 if ((is_lvalue & clk_bitfield) != 0)
1239 tfrom = unlowered_expr_type (expr);
1241 /* Figure out whether or not the types are reference-related and
1242 reference compatible. We have do do this after stripping
1243 references from FROM. */
1244 related_p = reference_related_p (to, tfrom);
1245 /* If this is a C cast, first convert to an appropriately qualified
1246 type, so that we can later do a const_cast to the desired type. */
1247 if (related_p && c_cast_p
1248 && !at_least_as_qualified_p (to, tfrom))
1249 to = cp_build_qualified_type (to, cp_type_quals (tfrom));
1250 compatible_p = reference_compatible_p (to, tfrom);
1252 /* Directly bind reference when target expression's type is compatible with
1253 the reference and expression is an lvalue. In DR391, the wording in
1254 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1255 const and rvalue references to rvalues of compatible class type.
1256 We should also do direct bindings for non-class "rvalues" derived from
1257 rvalue references. */
1260 || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1261 && !(flags & LOOKUP_NO_TEMP_BIND))
1262 || TYPE_REF_IS_RVALUE (rto))
1263 && (CLASS_TYPE_P (from) || (expr && lvalue_p (expr))))))
1267 If the initializer expression
1269 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1270 is reference-compatible with "cv2 T2,"
1272 the reference is bound directly to the initializer expression
1276 If the initializer expression is an rvalue, with T2 a class type,
1277 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1278 is bound to the object represented by the rvalue or to a sub-object
1279 within that object. */
1281 conv = build_identity_conv (tfrom, expr);
1282 conv = direct_reference_binding (rto, conv);
1284 if (flags & LOOKUP_PREFER_RVALUE)
1285 /* The top-level caller requested that we pretend that the lvalue
1286 be treated as an rvalue. */
1287 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1289 conv->rvaluedness_matches_p
1290 = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1292 if ((is_lvalue & clk_bitfield) != 0
1293 || ((is_lvalue & clk_packed) != 0 && !TYPE_PACKED (to)))
1294 /* For the purposes of overload resolution, we ignore the fact
1295 this expression is a bitfield or packed field. (In particular,
1296 [over.ics.ref] says specifically that a function with a
1297 non-const reference parameter is viable even if the
1298 argument is a bitfield.)
1300 However, when we actually call the function we must create
1301 a temporary to which to bind the reference. If the
1302 reference is volatile, or isn't const, then we cannot make
1303 a temporary, so we just issue an error when the conversion
1305 conv->need_temporary_p = true;
1307 /* Don't allow binding of lvalues to rvalue references. */
1308 if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1309 && !(flags & LOOKUP_PREFER_RVALUE))
1314 /* [class.conv.fct] A conversion function is never used to convert a
1315 (possibly cv-qualified) object to the (possibly cv-qualified) same
1316 object type (or a reference to it), to a (possibly cv-qualified) base
1317 class of that type (or a reference to it).... */
1318 else if (CLASS_TYPE_P (from) && !related_p
1319 && !(flags & LOOKUP_NO_CONVERSION))
1323 If the initializer expression
1325 -- has a class type (i.e., T2 is a class type) can be
1326 implicitly converted to an lvalue of type "cv3 T3," where
1327 "cv1 T1" is reference-compatible with "cv3 T3". (this
1328 conversion is selected by enumerating the applicable
1329 conversion functions (_over.match.ref_) and choosing the
1330 best one through overload resolution. (_over.match_).
1332 the reference is bound to the lvalue result of the conversion
1333 in the second case. */
1334 conv = convert_class_to_reference (rto, from, expr, flags);
1339 /* From this point on, we conceptually need temporaries, even if we
1340 elide them. Only the cases above are "direct bindings". */
1341 if (flags & LOOKUP_NO_TEMP_BIND)
1346 When a parameter of reference type is not bound directly to an
1347 argument expression, the conversion sequence is the one required
1348 to convert the argument expression to the underlying type of the
1349 reference according to _over.best.ics_. Conceptually, this
1350 conversion sequence corresponds to copy-initializing a temporary
1351 of the underlying type with the argument expression. Any
1352 difference in top-level cv-qualification is subsumed by the
1353 initialization itself and does not constitute a conversion. */
1357 Otherwise, the reference shall be to a non-volatile const type.
1359 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1360 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1365 Otherwise, a temporary of type "cv1 T1" is created and
1366 initialized from the initializer expression using the rules for a
1367 non-reference copy initialization. If T1 is reference-related to
1368 T2, cv1 must be the same cv-qualification as, or greater
1369 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1370 if (related_p && !at_least_as_qualified_p (to, from))
1373 /* We're generating a temporary now, but don't bind any more in the
1374 conversion (specifically, don't slice the temporary returned by a
1375 conversion operator). */
1376 flags |= LOOKUP_NO_TEMP_BIND;
1378 /* Temporaries are copy-initialized, except for this hack to allow
1379 explicit conversion ops to the copy ctor. See also
1380 add_function_candidate. */
1381 if (!(flags & LOOKUP_COPY_PARM))
1382 flags |= LOOKUP_ONLYCONVERTING;
1385 conv = implicit_conversion (to, from, expr, c_cast_p,
1390 conv = build_conv (ck_ref_bind, rto, conv);
1391 /* This reference binding, unlike those above, requires the
1392 creation of a temporary. */
1393 conv->need_temporary_p = true;
1394 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1399 /* Returns the implicit conversion sequence (see [over.ics]) from type
1400 FROM to type TO. The optional expression EXPR may affect the
1401 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
1402 true, this conversion is coming from a C-style cast. */
1405 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1410 if (from == error_mark_node || to == error_mark_node
1411 || expr == error_mark_node)
1414 if (TREE_CODE (to) == REFERENCE_TYPE)
1415 conv = reference_binding (to, from, expr, c_cast_p, flags);
1417 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1422 if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1424 if (is_std_init_list (to))
1425 return build_list_conv (to, expr, flags);
1427 /* Allow conversion from an initializer-list with one element to a
1429 if (SCALAR_TYPE_P (to))
1431 int nelts = CONSTRUCTOR_NELTS (expr);
1435 elt = integer_zero_node;
1436 else if (nelts == 1)
1437 elt = CONSTRUCTOR_ELT (expr, 0)->value;
1439 elt = error_mark_node;
1441 conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1445 conv->check_narrowing = true;
1446 if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1447 /* Too many levels of braces, i.e. '{{1}}'. */
1454 if (expr != NULL_TREE
1455 && (MAYBE_CLASS_TYPE_P (from)
1456 || MAYBE_CLASS_TYPE_P (to))
1457 && (flags & LOOKUP_NO_CONVERSION) == 0)
1459 struct z_candidate *cand;
1460 int convflags = (flags & (LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING));
1462 if (CLASS_TYPE_P (to)
1463 && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1464 && BRACE_ENCLOSED_INITIALIZER_P (expr))
1465 return build_aggr_conv (to, expr, flags);
1467 cand = build_user_type_conversion_1 (to, expr, convflags);
1469 conv = cand->second_conv;
1471 /* We used to try to bind a reference to a temporary here, but that
1472 is now handled after the recursive call to this function at the end
1473 of reference_binding. */
1480 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1481 functions. ARGS will not be changed until a single candidate is
1484 static struct z_candidate *
1485 add_candidate (struct z_candidate **candidates,
1486 tree fn, tree first_arg, const VEC(tree,gc) *args,
1487 size_t num_convs, conversion **convs,
1488 tree access_path, tree conversion_path,
1491 struct z_candidate *cand = (struct z_candidate *)
1492 conversion_obstack_alloc (sizeof (struct z_candidate));
1495 cand->first_arg = first_arg;
1497 cand->convs = convs;
1498 cand->num_convs = num_convs;
1499 cand->access_path = access_path;
1500 cand->conversion_path = conversion_path;
1501 cand->viable = viable;
1502 cand->next = *candidates;
1508 /* Create an overload candidate for the function or method FN called
1509 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1510 FLAGS is passed on to implicit_conversion.
1512 This does not change ARGS.
1514 CTYPE, if non-NULL, is the type we want to pretend this function
1515 comes from for purposes of overload resolution. */
1517 static struct z_candidate *
1518 add_function_candidate (struct z_candidate **candidates,
1519 tree fn, tree ctype, tree first_arg,
1520 const VEC(tree,gc) *args, tree access_path,
1521 tree conversion_path, int flags)
1523 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1527 tree orig_first_arg = first_arg;
1531 /* At this point we should not see any functions which haven't been
1532 explicitly declared, except for friend functions which will have
1533 been found using argument dependent lookup. */
1534 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1536 /* The `this', `in_chrg' and VTT arguments to constructors are not
1537 considered in overload resolution. */
1538 if (DECL_CONSTRUCTOR_P (fn))
1540 parmlist = skip_artificial_parms_for (fn, parmlist);
1541 skip = num_artificial_parms_for (fn);
1542 if (skip > 0 && first_arg != NULL_TREE)
1545 first_arg = NULL_TREE;
1551 len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1552 convs = alloc_conversions (len);
1554 /* 13.3.2 - Viable functions [over.match.viable]
1555 First, to be a viable function, a candidate function shall have enough
1556 parameters to agree in number with the arguments in the list.
1558 We need to check this first; otherwise, checking the ICSes might cause
1559 us to produce an ill-formed template instantiation. */
1561 parmnode = parmlist;
1562 for (i = 0; i < len; ++i)
1564 if (parmnode == NULL_TREE || parmnode == void_list_node)
1566 parmnode = TREE_CHAIN (parmnode);
1569 if (i < len && parmnode)
1572 /* Make sure there are default args for the rest of the parms. */
1573 else if (!sufficient_parms_p (parmnode))
1579 /* Second, for F to be a viable function, there shall exist for each
1580 argument an implicit conversion sequence that converts that argument
1581 to the corresponding parameter of F. */
1583 parmnode = parmlist;
1585 for (i = 0; i < len; ++i)
1591 if (parmnode == void_list_node)
1594 if (i == 0 && first_arg != NULL_TREE)
1597 arg = VEC_index (tree, args,
1598 i + skip - (first_arg != NULL_TREE ? 1 : 0));
1599 argtype = lvalue_type (arg);
1601 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1602 && ! DECL_CONSTRUCTOR_P (fn));
1606 tree parmtype = TREE_VALUE (parmnode);
1609 /* The type of the implicit object parameter ('this') for
1610 overload resolution is not always the same as for the
1611 function itself; conversion functions are considered to
1612 be members of the class being converted, and functions
1613 introduced by a using-declaration are considered to be
1614 members of the class that uses them.
1616 Since build_over_call ignores the ICS for the `this'
1617 parameter, we can just change the parm type. */
1618 if (ctype && is_this)
1620 parmtype = cp_build_qualified_type
1621 (ctype, cp_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);
2576 cand->explicit_targs = explicit_targs;
2580 return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2581 access_path, conversion_path, 0);
2585 static struct z_candidate *
2586 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2587 tree explicit_targs, tree first_arg,
2588 const VEC(tree,gc) *arglist, tree return_type,
2589 tree access_path, tree conversion_path, int flags,
2590 unification_kind_t strict)
2593 add_template_candidate_real (candidates, tmpl, ctype,
2594 explicit_targs, first_arg, arglist,
2595 return_type, access_path, conversion_path,
2596 flags, NULL_TREE, strict);
2600 static struct z_candidate *
2601 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2602 tree obj, tree first_arg,
2603 const VEC(tree,gc) *arglist,
2604 tree return_type, tree access_path,
2605 tree conversion_path)
2608 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2609 first_arg, arglist, return_type, access_path,
2610 conversion_path, 0, obj, DEDUCE_CONV);
2613 /* The CANDS are the set of candidates that were considered for
2614 overload resolution. Return the set of viable candidates, or CANDS
2615 if none are viable. If any of the candidates were viable, set
2616 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
2617 considered viable only if it is strictly viable. */
2619 static struct z_candidate*
2620 splice_viable (struct z_candidate *cands,
2624 struct z_candidate *viable;
2625 struct z_candidate **last_viable;
2626 struct z_candidate **cand;
2629 last_viable = &viable;
2630 *any_viable_p = false;
2635 struct z_candidate *c = *cand;
2636 if (strict_p ? c->viable == 1 : c->viable)
2641 last_viable = &c->next;
2642 *any_viable_p = true;
2648 return viable ? viable : cands;
2652 any_strictly_viable (struct z_candidate *cands)
2654 for (; cands; cands = cands->next)
2655 if (cands->viable == 1)
2660 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2661 words, it is about to become the "this" pointer for a member
2662 function call. Take the address of the object. */
2665 build_this (tree obj)
2667 /* In a template, we are only concerned about the type of the
2668 expression, so we can take a shortcut. */
2669 if (processing_template_decl)
2670 return build_address (obj);
2672 return cp_build_unary_op (ADDR_EXPR, obj, 0, tf_warning_or_error);
2675 /* Returns true iff functions are equivalent. Equivalent functions are
2676 not '==' only if one is a function-local extern function or if
2677 both are extern "C". */
2680 equal_functions (tree fn1, tree fn2)
2682 if (TREE_CODE (fn1) != TREE_CODE (fn2))
2684 if (TREE_CODE (fn1) == TEMPLATE_DECL)
2686 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2687 || DECL_EXTERN_C_FUNCTION_P (fn1))
2688 return decls_match (fn1, fn2);
2692 /* Print information about one overload candidate CANDIDATE. MSGSTR
2693 is the text to print before the candidate itself.
2695 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2696 to have been run through gettext by the caller. This wart makes
2697 life simpler in print_z_candidates and for the translators. */
2700 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2702 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2704 if (candidate->num_convs == 3)
2705 inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2706 candidate->convs[0]->type,
2707 candidate->convs[1]->type,
2708 candidate->convs[2]->type);
2709 else if (candidate->num_convs == 2)
2710 inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2711 candidate->convs[0]->type,
2712 candidate->convs[1]->type);
2714 inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2715 candidate->convs[0]->type);
2717 else if (TYPE_P (candidate->fn))
2718 inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2719 else if (candidate->viable == -1)
2720 inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2721 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
2722 inform (input_location, "%s %+#D <deleted>", msgstr, candidate->fn);
2724 inform (input_location, "%s %+#D", msgstr, candidate->fn);
2728 print_z_candidates (struct z_candidate *candidates)
2731 struct z_candidate *cand1;
2732 struct z_candidate **cand2;
2738 /* Remove deleted candidates. */
2740 for (cand2 = &cand1; *cand2; )
2742 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2743 && DECL_DELETED_FN ((*cand2)->fn))
2744 *cand2 = (*cand2)->next;
2746 cand2 = &(*cand2)->next;
2748 /* ...if there are any non-deleted ones. */
2752 /* There may be duplicates in the set of candidates. We put off
2753 checking this condition as long as possible, since we have no way
2754 to eliminate duplicates from a set of functions in less than n^2
2755 time. Now we are about to emit an error message, so it is more
2756 permissible to go slowly. */
2757 for (cand1 = candidates; cand1; cand1 = cand1->next)
2759 tree fn = cand1->fn;
2760 /* Skip builtin candidates and conversion functions. */
2763 cand2 = &cand1->next;
2766 if (DECL_P ((*cand2)->fn)
2767 && equal_functions (fn, (*cand2)->fn))
2768 *cand2 = (*cand2)->next;
2770 cand2 = &(*cand2)->next;
2774 str = candidates->next ? _("candidates are:") : _("candidate is:");
2776 for (; candidates; candidates = candidates->next)
2778 print_z_candidate (spaces ? spaces : str, candidates);
2779 spaces = spaces ? spaces : get_spaces (str);
2784 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2785 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2786 the result of the conversion function to convert it to the final
2787 desired type. Merge the two sequences into a single sequence,
2788 and return the merged sequence. */
2791 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2795 gcc_assert (user_seq->kind == ck_user);
2797 /* Find the end of the second conversion sequence. */
2799 while ((*t)->kind != ck_identity)
2800 t = &((*t)->u.next);
2802 /* Replace the identity conversion with the user conversion
2806 /* The entire sequence is a user-conversion sequence. */
2807 std_seq->user_conv_p = true;
2812 /* Returns the best overload candidate to perform the requested
2813 conversion. This function is used for three the overloading situations
2814 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2815 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2816 per [dcl.init.ref], so we ignore temporary bindings. */
2818 static struct z_candidate *
2819 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2821 struct z_candidate *candidates, *cand;
2822 tree fromtype = TREE_TYPE (expr);
2823 tree ctors = NULL_TREE;
2824 tree conv_fns = NULL_TREE;
2825 conversion *conv = NULL;
2826 tree first_arg = NULL_TREE;
2827 VEC(tree,gc) *args = NULL;
2831 /* We represent conversion within a hierarchy using RVALUE_CONV and
2832 BASE_CONV, as specified by [over.best.ics]; these become plain
2833 constructor calls, as specified in [dcl.init]. */
2834 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
2835 || !DERIVED_FROM_P (totype, fromtype));
2837 if (MAYBE_CLASS_TYPE_P (totype))
2838 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2840 if (MAYBE_CLASS_TYPE_P (fromtype))
2842 tree to_nonref = non_reference (totype);
2843 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
2844 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
2845 && DERIVED_FROM_P (to_nonref, fromtype)))
2847 /* [class.conv.fct] A conversion function is never used to
2848 convert a (possibly cv-qualified) object to the (possibly
2849 cv-qualified) same object type (or a reference to it), to a
2850 (possibly cv-qualified) base class of that type (or a
2851 reference to it)... */
2854 conv_fns = lookup_conversions (fromtype,
2855 /*lookup_template_convs_p=*/true);
2859 flags |= LOOKUP_NO_CONVERSION;
2860 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2861 flags |= LOOKUP_NO_NARROWING;
2863 /* It's OK to bind a temporary for converting constructor arguments, but
2864 not in converting the return value of a conversion operator. */
2865 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
2866 flags &= ~LOOKUP_NO_TEMP_BIND;
2870 int ctorflags = flags;
2871 bool try_single_arg = true;
2872 ctors = BASELINK_FUNCTIONS (ctors);
2874 first_arg = build_int_cst (build_pointer_type (totype), 0);
2875 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2877 /* For list-initialization we consider explicit constructors, but
2878 give an error if one is selected. */
2879 ctorflags &= ~LOOKUP_ONLYCONVERTING;
2880 /* If the class has a list ctor, try passing the list as a single
2881 argument first, but only consider list ctors. */
2882 if (TYPE_HAS_LIST_CTOR (totype))
2883 ctorflags |= LOOKUP_LIST_ONLY;
2885 try_single_arg = false;
2888 /* We should never try to call the abstract or base constructor
2890 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2891 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2893 /* If EXPR is not an initializer-list, or if totype has a list
2894 constructor, try EXPR as a single argument. */
2897 args = make_tree_vector_single (expr);
2898 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
2899 TYPE_BINFO (totype), TYPE_BINFO (totype),
2900 ctorflags, &candidates);
2903 /* If we didn't find a suitable list constructor for an initializer-list,
2904 try breaking it apart. */
2905 if (!candidates && BRACE_ENCLOSED_INITIALIZER_P (expr))
2907 args = ctor_to_vec (expr);
2908 /* We aren't looking for list-ctors anymore. */
2909 ctorflags &= ~LOOKUP_LIST_ONLY;
2910 /* We still allow more conversions within an init-list. */
2911 ctorflags &= ~LOOKUP_NO_CONVERSION;
2912 /* But not for the copy ctor. */
2913 ctorflags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
2914 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
2915 TYPE_BINFO (totype), TYPE_BINFO (totype),
2916 ctorflags, &candidates);
2919 for (cand = candidates; cand; cand = cand->next)
2921 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2923 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
2924 set, then this is copy-initialization. In that case, "The
2925 result of the call is then used to direct-initialize the
2926 object that is the destination of the copy-initialization."
2929 We represent this in the conversion sequence with an
2930 rvalue conversion, which means a constructor call. */
2931 if (TREE_CODE (totype) != REFERENCE_TYPE
2932 && !(convflags & LOOKUP_NO_TEMP_BIND))
2934 = build_conv (ck_rvalue, totype, cand->second_conv);
2939 first_arg = build_this (expr);
2941 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2943 tree conversion_path = TREE_PURPOSE (conv_fns);
2944 struct z_candidate *old_candidates;
2946 /* If we are called to convert to a reference type, we are trying to
2947 find an lvalue binding, so don't even consider temporaries. If
2948 we don't find an lvalue binding, the caller will try again to
2949 look for a temporary binding. */
2950 if (TREE_CODE (totype) == REFERENCE_TYPE)
2951 convflags |= LOOKUP_NO_TEMP_BIND;
2953 old_candidates = candidates;
2954 add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
2956 conversion_path, TYPE_BINFO (fromtype),
2957 flags, &candidates);
2959 for (cand = candidates; cand != old_candidates; cand = cand->next)
2962 = implicit_conversion (totype,
2963 TREE_TYPE (TREE_TYPE (cand->fn)),
2965 /*c_cast_p=*/false, convflags);
2967 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
2968 copy-initialization. In that case, "The result of the
2969 call is then used to direct-initialize the object that is
2970 the destination of the copy-initialization." [dcl.init]
2972 We represent this in the conversion sequence with an
2973 rvalue conversion, which means a constructor call. But
2974 don't add a second rvalue conversion if there's already
2975 one there. Which there really shouldn't be, but it's
2976 harmless since we'd add it here anyway. */
2977 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
2978 && !(convflags & LOOKUP_NO_TEMP_BIND))
2979 ics = build_conv (ck_rvalue, totype, ics);
2981 cand->second_conv = ics;
2985 else if (cand->viable == 1 && ics->bad_p)
2990 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2994 cand = tourney (candidates);
2997 if (flags & LOOKUP_COMPLAIN)
2999 error ("conversion from %qT to %qT is ambiguous",
3001 print_z_candidates (candidates);
3004 cand = candidates; /* any one will do */
3005 cand->second_conv = build_ambiguous_conv (totype, expr);
3006 cand->second_conv->user_conv_p = true;
3007 if (!any_strictly_viable (candidates))
3008 cand->second_conv->bad_p = true;
3009 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3010 ambiguous conversion is no worse than another user-defined
3016 /* Build the user conversion sequence. */
3019 (DECL_CONSTRUCTOR_P (cand->fn)
3020 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3021 build_identity_conv (TREE_TYPE (expr), expr));
3024 /* Remember that this was a list-initialization. */
3025 if (flags & LOOKUP_NO_NARROWING)
3026 conv->check_narrowing = true;
3028 /* Combine it with the second conversion sequence. */
3029 cand->second_conv = merge_conversion_sequences (conv,
3032 if (cand->viable == -1)
3033 cand->second_conv->bad_p = true;
3039 build_user_type_conversion (tree totype, tree expr, int flags)
3041 struct z_candidate *cand
3042 = build_user_type_conversion_1 (totype, expr, flags);
3046 if (cand->second_conv->kind == ck_ambig)
3047 return error_mark_node;
3048 expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3049 return convert_from_reference (expr);
3054 /* Do any initial processing on the arguments to a function call. */
3056 static VEC(tree,gc) *
3057 resolve_args (VEC(tree,gc) *args)
3062 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
3064 if (error_operand_p (arg))
3066 else if (VOID_TYPE_P (TREE_TYPE (arg)))
3068 error ("invalid use of void expression");
3071 else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3077 /* Perform overload resolution on FN, which is called with the ARGS.
3079 Return the candidate function selected by overload resolution, or
3080 NULL if the event that overload resolution failed. In the case
3081 that overload resolution fails, *CANDIDATES will be the set of
3082 candidates considered, and ANY_VIABLE_P will be set to true or
3083 false to indicate whether or not any of the candidates were
3086 The ARGS should already have gone through RESOLVE_ARGS before this
3087 function is called. */
3089 static struct z_candidate *
3090 perform_overload_resolution (tree fn,
3091 const VEC(tree,gc) *args,
3092 struct z_candidate **candidates,
3095 struct z_candidate *cand;
3096 tree explicit_targs = NULL_TREE;
3097 int template_only = 0;
3100 *any_viable_p = true;
3103 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3104 || TREE_CODE (fn) == TEMPLATE_DECL
3105 || TREE_CODE (fn) == OVERLOAD
3106 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3108 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3110 explicit_targs = TREE_OPERAND (fn, 1);
3111 fn = TREE_OPERAND (fn, 0);
3115 /* Add the various candidate functions. */
3116 add_candidates (fn, NULL_TREE, args, NULL_TREE,
3117 explicit_targs, template_only,
3118 /*conversion_path=*/NULL_TREE,
3119 /*access_path=*/NULL_TREE,
3123 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3127 cand = tourney (*candidates);
3131 /* Return an expression for a call to FN (a namespace-scope function,
3132 or a static member function) with the ARGS. This may change
3136 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3137 tsubst_flags_t complain)
3139 struct z_candidate *candidates, *cand;
3144 if (args != NULL && *args != NULL)
3146 *args = resolve_args (*args);
3148 return error_mark_node;
3151 /* If this function was found without using argument dependent
3152 lookup, then we want to ignore any undeclared friend
3158 fn = remove_hidden_names (fn);
3161 if (complain & tf_error)
3162 error ("no matching function for call to %<%D(%A)%>",
3163 DECL_NAME (OVL_CURRENT (orig_fn)),
3164 build_tree_list_vec (*args));
3165 return error_mark_node;
3169 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3170 p = conversion_obstack_alloc (0);
3172 cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3176 if (complain & tf_error)
3178 if (!any_viable_p && candidates && ! candidates->next
3179 && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3180 return cp_build_function_call_vec (candidates->fn, args, complain);
3181 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3182 fn = TREE_OPERAND (fn, 0);
3184 error ("no matching function for call to %<%D(%A)%>",
3185 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3187 error ("call of overloaded %<%D(%A)%> is ambiguous",
3188 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3190 print_z_candidates (candidates);
3192 result = error_mark_node;
3195 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3197 /* Free all the conversions we allocated. */
3198 obstack_free (&conversion_obstack, p);
3203 /* Build a call to a global operator new. FNNAME is the name of the
3204 operator (either "operator new" or "operator new[]") and ARGS are
3205 the arguments provided. This may change ARGS. *SIZE points to the
3206 total number of bytes required by the allocation, and is updated if
3207 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3208 be used. If this function determines that no cookie should be
3209 used, after all, *COOKIE_SIZE is set to NULL_TREE. If FN is
3210 non-NULL, it will be set, upon return, to the allocation function
3214 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3215 tree *size, tree *cookie_size,
3219 struct z_candidate *candidates;
3220 struct z_candidate *cand;
3225 VEC_safe_insert (tree, gc, *args, 0, *size);
3226 *args = resolve_args (*args);
3228 return error_mark_node;
3234 If this lookup fails to find the name, or if the allocated type
3235 is not a class type, the allocation function's name is looked
3236 up in the global scope.
3238 we disregard block-scope declarations of "operator new". */
3239 fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3241 /* Figure out what function is being called. */
3242 cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3244 /* If no suitable function could be found, issue an error message
3249 error ("no matching function for call to %<%D(%A)%>",
3250 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3252 error ("call of overloaded %<%D(%A)%> is ambiguous",
3253 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3255 print_z_candidates (candidates);
3256 return error_mark_node;
3259 /* If a cookie is required, add some extra space. Whether
3260 or not a cookie is required cannot be determined until
3261 after we know which function was called. */
3264 bool use_cookie = true;
3265 if (!abi_version_at_least (2))
3267 /* In G++ 3.2, the check was implemented incorrectly; it
3268 looked at the placement expression, rather than the
3269 type of the function. */
3270 if (VEC_length (tree, *args) == 2
3271 && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3279 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3280 /* Skip the size_t parameter. */
3281 arg_types = TREE_CHAIN (arg_types);
3282 /* Check the remaining parameters (if any). */
3284 && TREE_CHAIN (arg_types) == void_list_node
3285 && same_type_p (TREE_VALUE (arg_types),
3289 /* If we need a cookie, adjust the number of bytes allocated. */
3292 /* Update the total size. */
3293 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3294 /* Update the argument list to reflect the adjusted size. */
3295 VEC_replace (tree, *args, 0, *size);
3298 *cookie_size = NULL_TREE;
3301 /* Tell our caller which function we decided to call. */
3305 /* Build the CALL_EXPR. */
3306 return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3309 /* Build a new call to operator(). This may change ARGS. */
3312 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3314 struct z_candidate *candidates = 0, *cand;
3315 tree fns, convs, first_mem_arg = NULL_TREE;
3316 tree type = TREE_TYPE (obj);
3318 tree result = NULL_TREE;
3321 if (error_operand_p (obj))
3322 return error_mark_node;
3324 obj = prep_operand (obj);
3326 if (TYPE_PTRMEMFUNC_P (type))
3328 if (complain & tf_error)
3329 /* It's no good looking for an overloaded operator() on a
3330 pointer-to-member-function. */
3331 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3332 return error_mark_node;
3335 if (TYPE_BINFO (type))
3337 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3338 if (fns == error_mark_node)
3339 return error_mark_node;
3344 if (args != NULL && *args != NULL)
3346 *args = resolve_args (*args);
3348 return error_mark_node;
3351 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3352 p = conversion_obstack_alloc (0);
3356 first_mem_arg = build_this (obj);
3358 add_candidates (BASELINK_FUNCTIONS (fns),
3359 first_mem_arg, *args, NULL_TREE,
3361 BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
3362 LOOKUP_NORMAL, &candidates);
3365 convs = lookup_conversions (type, /*lookup_template_convs_p=*/true);
3367 for (; convs; convs = TREE_CHAIN (convs))
3369 tree fns = TREE_VALUE (convs);
3370 tree totype = TREE_TYPE (convs);
3372 if ((TREE_CODE (totype) == POINTER_TYPE
3373 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3374 || (TREE_CODE (totype) == REFERENCE_TYPE
3375 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3376 || (TREE_CODE (totype) == REFERENCE_TYPE
3377 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3378 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3379 for (; fns; fns = OVL_NEXT (fns))
3381 tree fn = OVL_CURRENT (fns);
3383 if (DECL_NONCONVERTING_P (fn))
3386 if (TREE_CODE (fn) == TEMPLATE_DECL)
3387 add_template_conv_candidate
3388 (&candidates, fn, obj, NULL_TREE, *args, totype,
3389 /*access_path=*/NULL_TREE,
3390 /*conversion_path=*/NULL_TREE);
3392 add_conv_candidate (&candidates, fn, obj, NULL_TREE,
3393 *args, /*conversion_path=*/NULL_TREE,
3394 /*access_path=*/NULL_TREE);
3398 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3401 if (complain & tf_error)
3403 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
3404 build_tree_list_vec (*args));
3405 print_z_candidates (candidates);
3407 result = error_mark_node;
3411 cand = tourney (candidates);
3414 if (complain & tf_error)
3416 error ("call of %<(%T) (%A)%> is ambiguous",
3417 TREE_TYPE (obj), build_tree_list_vec (*args));
3418 print_z_candidates (candidates);
3420 result = error_mark_node;
3422 /* Since cand->fn will be a type, not a function, for a conversion
3423 function, we must be careful not to unconditionally look at
3425 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3426 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3427 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3430 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
3432 obj = convert_from_reference (obj);
3433 result = cp_build_function_call_vec (obj, args, complain);
3437 /* Free all the conversions we allocated. */
3438 obstack_free (&conversion_obstack, p);
3444 op_error (enum tree_code code, enum tree_code code2,
3445 tree arg1, tree arg2, tree arg3, bool match)
3449 if (code == MODIFY_EXPR)
3450 opname = assignment_operator_name_info[code2].name;
3452 opname = operator_name_info[code].name;
3458 error ("ambiguous overload for ternary %<operator?:%> "
3459 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3461 error ("no match for ternary %<operator?:%> "
3462 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3465 case POSTINCREMENT_EXPR:
3466 case POSTDECREMENT_EXPR:
3468 error ("ambiguous overload for %<operator%s%> in %<%E%s%>",
3469 opname, arg1, opname);
3471 error ("no match for %<operator%s%> in %<%E%s%>",
3472 opname, arg1, opname);
3477 error ("ambiguous overload for %<operator[]%> in %<%E[%E]%>",
3480 error ("no match for %<operator[]%> in %<%E[%E]%>",
3487 error ("ambiguous overload for %qs in %<%s %E%>",
3488 opname, opname, arg1);
3490 error ("no match for %qs in %<%s %E%>",
3491 opname, opname, arg1);
3497 error ("ambiguous overload for %<operator%s%> in %<%E %s %E%>",
3498 opname, arg1, opname, arg2);
3500 error ("no match for %<operator%s%> in %<%E %s %E%>",
3501 opname, arg1, opname, arg2);
3504 error ("ambiguous overload for %<operator%s%> in %<%s%E%>",
3505 opname, opname, arg1);
3507 error ("no match for %<operator%s%> in %<%s%E%>",
3508 opname, opname, arg1);
3513 /* Return the implicit conversion sequence that could be used to
3514 convert E1 to E2 in [expr.cond]. */
3517 conditional_conversion (tree e1, tree e2)
3519 tree t1 = non_reference (TREE_TYPE (e1));
3520 tree t2 = non_reference (TREE_TYPE (e2));
3526 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3527 implicitly converted (clause _conv_) to the type "reference to
3528 T2", subject to the constraint that in the conversion the
3529 reference must bind directly (_dcl.init.ref_) to E1. */
3530 if (real_lvalue_p (e2))
3532 conv = implicit_conversion (build_reference_type (t2),
3536 LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING);
3543 If E1 and E2 have class type, and the underlying class types are
3544 the same or one is a base class of the other: E1 can be converted
3545 to match E2 if the class of T2 is the same type as, or a base
3546 class of, the class of T1, and the cv-qualification of T2 is the
3547 same cv-qualification as, or a greater cv-qualification than, the
3548 cv-qualification of T1. If the conversion is applied, E1 is
3549 changed to an rvalue of type T2 that still refers to the original
3550 source class object (or the appropriate subobject thereof). */
3551 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3552 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3554 if (good_base && at_least_as_qualified_p (t2, t1))
3556 conv = build_identity_conv (t1, e1);
3557 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3558 TYPE_MAIN_VARIANT (t2)))
3559 conv = build_conv (ck_base, t2, conv);
3561 conv = build_conv (ck_rvalue, t2, conv);
3570 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3571 converted to the type that expression E2 would have if E2 were
3572 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3573 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3577 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3578 arguments to the conditional expression. */
3581 build_conditional_expr (tree arg1, tree arg2, tree arg3,
3582 tsubst_flags_t complain)
3586 tree result = NULL_TREE;
3588 tree result_type = NULL_TREE;
3589 bool lvalue_p = true;
3590 struct z_candidate *candidates = 0;
3591 struct z_candidate *cand;
3594 /* As a G++ extension, the second argument to the conditional can be
3595 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3596 c'.) If the second operand is omitted, make sure it is
3597 calculated only once. */
3600 if (complain & tf_error)
3601 pedwarn (input_location, OPT_pedantic,
3602 "ISO C++ forbids omitting the middle term of a ?: expression");
3604 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3605 if (real_lvalue_p (arg1))
3606 arg2 = arg1 = stabilize_reference (arg1);
3608 arg2 = arg1 = save_expr (arg1);
3613 The first expression is implicitly converted to bool (clause
3615 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
3618 /* If something has already gone wrong, just pass that fact up the
3620 if (error_operand_p (arg1)
3621 || error_operand_p (arg2)
3622 || error_operand_p (arg3))
3623 return error_mark_node;
3627 If either the second or the third operand has type (possibly
3628 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3629 array-to-pointer (_conv.array_), and function-to-pointer
3630 (_conv.func_) standard conversions are performed on the second
3631 and third operands. */
3632 arg2_type = unlowered_expr_type (arg2);
3633 arg3_type = unlowered_expr_type (arg3);
3634 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3636 /* Do the conversions. We don't these for `void' type arguments
3637 since it can't have any effect and since decay_conversion
3638 does not handle that case gracefully. */
3639 if (!VOID_TYPE_P (arg2_type))
3640 arg2 = decay_conversion (arg2);
3641 if (!VOID_TYPE_P (arg3_type))
3642 arg3 = decay_conversion (arg3);
3643 arg2_type = TREE_TYPE (arg2);
3644 arg3_type = TREE_TYPE (arg3);
3648 One of the following shall hold:
3650 --The second or the third operand (but not both) is a
3651 throw-expression (_except.throw_); the result is of the
3652 type of the other and is an rvalue.
3654 --Both the second and the third operands have type void; the
3655 result is of type void and is an rvalue.
3657 We must avoid calling force_rvalue for expressions of type
3658 "void" because it will complain that their value is being
3660 if (TREE_CODE (arg2) == THROW_EXPR
3661 && TREE_CODE (arg3) != THROW_EXPR)
3663 if (!VOID_TYPE_P (arg3_type))
3664 arg3 = force_rvalue (arg3);
3665 arg3_type = TREE_TYPE (arg3);
3666 result_type = arg3_type;
3668 else if (TREE_CODE (arg2) != THROW_EXPR
3669 && TREE_CODE (arg3) == THROW_EXPR)
3671 if (!VOID_TYPE_P (arg2_type))
3672 arg2 = force_rvalue (arg2);
3673 arg2_type = TREE_TYPE (arg2);
3674 result_type = arg2_type;
3676 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3677 result_type = void_type_node;
3680 if (complain & tf_error)
3682 if (VOID_TYPE_P (arg2_type))
3683 error ("second operand to the conditional operator "
3684 "is of type %<void%>, "
3685 "but the third operand is neither a throw-expression "
3686 "nor of type %<void%>");
3688 error ("third operand to the conditional operator "
3689 "is of type %<void%>, "
3690 "but the second operand is neither a throw-expression "
3691 "nor of type %<void%>");
3693 return error_mark_node;
3697 goto valid_operands;
3701 Otherwise, if the second and third operand have different types,
3702 and either has (possibly cv-qualified) class type, an attempt is
3703 made to convert each of those operands to the type of the other. */
3704 else if (!same_type_p (arg2_type, arg3_type)
3705 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3710 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3711 p = conversion_obstack_alloc (0);
3713 conv2 = conditional_conversion (arg2, arg3);
3714 conv3 = conditional_conversion (arg3, arg2);
3718 If both can be converted, or one can be converted but the
3719 conversion is ambiguous, the program is ill-formed. If
3720 neither can be converted, the operands are left unchanged and
3721 further checking is performed as described below. If exactly
3722 one conversion is possible, that conversion is applied to the
3723 chosen operand and the converted operand is used in place of
3724 the original operand for the remainder of this section. */
3725 if ((conv2 && !conv2->bad_p
3726 && conv3 && !conv3->bad_p)
3727 || (conv2 && conv2->kind == ck_ambig)
3728 || (conv3 && conv3->kind == ck_ambig))
3730 error ("operands to ?: have different types %qT and %qT",
3731 arg2_type, arg3_type);
3732 result = error_mark_node;
3734 else if (conv2 && (!conv2->bad_p || !conv3))
3736 arg2 = convert_like (conv2, arg2, complain);
3737 arg2 = convert_from_reference (arg2);
3738 arg2_type = TREE_TYPE (arg2);
3739 /* Even if CONV2 is a valid conversion, the result of the
3740 conversion may be invalid. For example, if ARG3 has type
3741 "volatile X", and X does not have a copy constructor
3742 accepting a "volatile X&", then even if ARG2 can be
3743 converted to X, the conversion will fail. */
3744 if (error_operand_p (arg2))
3745 result = error_mark_node;
3747 else if (conv3 && (!conv3->bad_p || !conv2))
3749 arg3 = convert_like (conv3, arg3, complain);
3750 arg3 = convert_from_reference (arg3);
3751 arg3_type = TREE_TYPE (arg3);
3752 if (error_operand_p (arg3))
3753 result = error_mark_node;
3756 /* Free all the conversions we allocated. */
3757 obstack_free (&conversion_obstack, p);
3762 /* If, after the conversion, both operands have class type,
3763 treat the cv-qualification of both operands as if it were the
3764 union of the cv-qualification of the operands.
3766 The standard is not clear about what to do in this
3767 circumstance. For example, if the first operand has type
3768 "const X" and the second operand has a user-defined
3769 conversion to "volatile X", what is the type of the second
3770 operand after this step? Making it be "const X" (matching
3771 the first operand) seems wrong, as that discards the
3772 qualification without actually performing a copy. Leaving it
3773 as "volatile X" seems wrong as that will result in the
3774 conditional expression failing altogether, even though,
3775 according to this step, the one operand could be converted to
3776 the type of the other. */
3777 if ((conv2 || conv3)
3778 && CLASS_TYPE_P (arg2_type)
3779 && cp_type_quals (arg2_type) != cp_type_quals (arg3_type))
3780 arg2_type = arg3_type =
3781 cp_build_qualified_type (arg2_type,
3782 cp_type_quals (arg2_type)
3783 | cp_type_quals (arg3_type));
3788 If the second and third operands are lvalues and have the same
3789 type, the result is of that type and is an lvalue. */
3790 if (real_lvalue_p (arg2)
3791 && real_lvalue_p (arg3)
3792 && same_type_p (arg2_type, arg3_type))
3794 result_type = arg2_type;
3795 goto valid_operands;
3800 Otherwise, the result is an rvalue. If the second and third
3801 operand do not have the same type, and either has (possibly
3802 cv-qualified) class type, overload resolution is used to
3803 determine the conversions (if any) to be applied to the operands
3804 (_over.match.oper_, _over.built_). */
3806 if (!same_type_p (arg2_type, arg3_type)
3807 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3813 /* Rearrange the arguments so that add_builtin_candidate only has
3814 to know about two args. In build_builtin_candidate, the
3815 arguments are unscrambled. */
3819 add_builtin_candidates (&candidates,
3822 ansi_opname (COND_EXPR),
3828 If the overload resolution fails, the program is
3830 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3833 if (complain & tf_error)
3835 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3836 print_z_candidates (candidates);
3838 return error_mark_node;
3840 cand = tourney (candidates);
3843 if (complain & tf_error)
3845 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3846 print_z_candidates (candidates);
3848 return error_mark_node;
3853 Otherwise, the conversions thus determined are applied, and
3854 the converted operands are used in place of the original
3855 operands for the remainder of this section. */
3856 conv = cand->convs[0];
3857 arg1 = convert_like (conv, arg1, complain);
3858 conv = cand->convs[1];
3859 arg2 = convert_like (conv, arg2, complain);
3860 arg2_type = TREE_TYPE (arg2);
3861 conv = cand->convs[2];
3862 arg3 = convert_like (conv, arg3, complain);
3863 arg3_type = TREE_TYPE (arg3);
3868 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3869 and function-to-pointer (_conv.func_) standard conversions are
3870 performed on the second and third operands.
3872 We need to force the lvalue-to-rvalue conversion here for class types,
3873 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3874 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3877 arg2 = force_rvalue (arg2);
3878 if (!CLASS_TYPE_P (arg2_type))
3879 arg2_type = TREE_TYPE (arg2);
3881 arg3 = force_rvalue (arg3);
3882 if (!CLASS_TYPE_P (arg3_type))
3883 arg3_type = TREE_TYPE (arg3);
3885 if (arg2 == error_mark_node || arg3 == error_mark_node)
3886 return error_mark_node;
3890 After those conversions, one of the following shall hold:
3892 --The second and third operands have the same type; the result is of
3894 if (same_type_p (arg2_type, arg3_type))
3895 result_type = arg2_type;
3898 --The second and third operands have arithmetic or enumeration
3899 type; the usual arithmetic conversions are performed to bring
3900 them to a common type, and the result is of that type. */
3901 else if ((ARITHMETIC_TYPE_P (arg2_type)
3902 || UNSCOPED_ENUM_P (arg2_type))
3903 && (ARITHMETIC_TYPE_P (arg3_type)
3904 || UNSCOPED_ENUM_P (arg3_type)))
3906 /* In this case, there is always a common type. */
3907 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3910 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3911 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3913 if (complain & tf_warning)
3915 "enumeral mismatch in conditional expression: %qT vs %qT",
3916 arg2_type, arg3_type);
3918 else if (extra_warnings
3919 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3920 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3921 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3922 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3924 if (complain & tf_warning)
3926 "enumeral and non-enumeral type in conditional expression");
3929 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3930 arg3 = perform_implicit_conversion (result_type, arg3, complain);
3934 --The second and third operands have pointer type, or one has
3935 pointer type and the other is a null pointer constant; pointer
3936 conversions (_conv.ptr_) and qualification conversions
3937 (_conv.qual_) are performed to bring them to their composite
3938 pointer type (_expr.rel_). The result is of the composite
3941 --The second and third operands have pointer to member type, or
3942 one has pointer to member type and the other is a null pointer
3943 constant; pointer to member conversions (_conv.mem_) and
3944 qualification conversions (_conv.qual_) are performed to bring
3945 them to a common type, whose cv-qualification shall match the
3946 cv-qualification of either the second or the third operand.
3947 The result is of the common type. */
3948 else if ((null_ptr_cst_p (arg2)
3949 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3950 || (null_ptr_cst_p (arg3)
3951 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3952 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3953 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3954 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3956 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3957 arg3, CPO_CONDITIONAL_EXPR,
3959 if (result_type == error_mark_node)
3960 return error_mark_node;
3961 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3962 arg3 = perform_implicit_conversion (result_type, arg3, complain);
3967 if (complain & tf_error)
3968 error ("operands to ?: have different types %qT and %qT",
3969 arg2_type, arg3_type);
3970 return error_mark_node;
3974 result_save = build3 (COND_EXPR, result_type, arg1, arg2, arg3);
3975 result = fold_if_not_in_template (result_save);
3977 if (cp_unevaluated_operand && TREE_CODE (result) == CALL_EXPR)
3978 /* Avoid folding to a CALL_EXPR within decltype (c++/42013). */
3979 result = result_save;
3981 /* We can't use result_type below, as fold might have returned a
3986 /* Expand both sides into the same slot, hopefully the target of
3987 the ?: expression. We used to check for TARGET_EXPRs here,
3988 but now we sometimes wrap them in NOP_EXPRs so the test would
3990 if (CLASS_TYPE_P (TREE_TYPE (result)))
3991 result = get_target_expr (result);
3992 /* If this expression is an rvalue, but might be mistaken for an
3993 lvalue, we must add a NON_LVALUE_EXPR. */
3994 result = rvalue (result);
4000 /* OPERAND is an operand to an expression. Perform necessary steps
4001 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4005 prep_operand (tree operand)
4009 if (CLASS_TYPE_P (TREE_TYPE (operand))
4010 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
4011 /* Make sure the template type is instantiated now. */
4012 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
4018 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4019 OVERLOAD) to the CANDIDATES, returning an updated list of
4020 CANDIDATES. The ARGS are the arguments provided to the call;
4021 if FIRST_ARG is non-null it is the implicit object argument,
4022 otherwise the first element of ARGS is used if needed. The
4023 EXPLICIT_TARGS are explicit template arguments provided.
4024 TEMPLATE_ONLY is true if only template functions should be
4025 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4026 add_function_candidate. */
4029 add_candidates (tree fns, tree first_arg, const VEC(tree,gc) *args,
4031 tree explicit_targs, bool template_only,
4032 tree conversion_path, tree access_path,
4034 struct z_candidate **candidates)
4037 const VEC(tree,gc) *non_static_args;
4038 bool check_list_ctor;
4039 bool check_converting;
4040 unification_kind_t strict;
4046 /* Precalculate special handling of constructors and conversion ops. */
4047 fn = OVL_CURRENT (fns);
4048 if (DECL_CONV_FN_P (fn))
4050 check_list_ctor = false;
4051 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4052 if (flags & LOOKUP_NO_CONVERSION)
4053 /* We're doing return_type(x). */
4054 strict = DEDUCE_CONV;
4056 /* We're doing x.operator return_type(). */
4057 strict = DEDUCE_EXACT;
4058 /* [over.match.funcs] For conversion functions, the function
4059 is considered to be a member of the class of the implicit
4060 object argument for the purpose of defining the type of
4061 the implicit object parameter. */
4062 ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
4066 if (DECL_CONSTRUCTOR_P (fn))
4068 check_list_ctor = !!(flags & LOOKUP_LIST_ONLY);
4069 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4073 check_list_ctor = false;
4074 check_converting = false;
4076 strict = DEDUCE_CALL;
4077 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
4081 non_static_args = args;
4083 /* Delay creating the implicit this parameter until it is needed. */
4084 non_static_args = NULL;
4086 for (; fns; fns = OVL_NEXT (fns))
4089 const VEC(tree,gc) *fn_args;
4091 fn = OVL_CURRENT (fns);
4093 if (check_converting && DECL_NONCONVERTING_P (fn))
4095 if (check_list_ctor && !is_list_ctor (fn))
4098 /* Figure out which set of arguments to use. */
4099 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
4101 /* If this function is a non-static member and we didn't get an
4102 implicit object argument, move it out of args. */
4103 if (first_arg == NULL_TREE)
4107 VEC(tree,gc) *tempvec
4108 = VEC_alloc (tree, gc, VEC_length (tree, args) - 1);
4109 for (ix = 1; VEC_iterate (tree, args, ix, arg); ++ix)
4110 VEC_quick_push (tree, tempvec, arg);
4111 non_static_args = tempvec;
4112 first_arg = build_this (VEC_index (tree, args, 0));
4115 fn_first_arg = first_arg;
4116 fn_args = non_static_args;
4120 /* Otherwise, just use the list of arguments provided. */
4121 fn_first_arg = NULL_TREE;
4125 if (TREE_CODE (fn) == TEMPLATE_DECL)
4126 add_template_candidate (candidates,
4137 else if (!template_only)
4138 add_function_candidate (candidates,
4149 /* Even unsigned enum types promote to signed int. We don't want to
4150 issue -Wsign-compare warnings for this case. Here ORIG_ARG is the
4151 original argument and ARG is the argument after any conversions
4152 have been applied. We set TREE_NO_WARNING if we have added a cast
4153 from an unsigned enum type to a signed integer type. */
4156 avoid_sign_compare_warnings (tree orig_arg, tree arg)
4158 if (orig_arg != NULL_TREE
4161 && TREE_CODE (TREE_TYPE (orig_arg)) == ENUMERAL_TYPE
4162 && TYPE_UNSIGNED (TREE_TYPE (orig_arg))
4163 && INTEGRAL_TYPE_P (TREE_TYPE (arg))
4164 && !TYPE_UNSIGNED (TREE_TYPE (arg)))
4165 TREE_NO_WARNING (arg) = 1;
4169 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
4170 bool *overloaded_p, tsubst_flags_t complain)
4172 tree orig_arg1 = arg1;
4173 tree orig_arg2 = arg2;
4174 tree orig_arg3 = arg3;
4175 struct z_candidate *candidates = 0, *cand;
4176 VEC(tree,gc) *arglist;
4179 tree result = NULL_TREE;
4180 bool result_valid_p = false;
4181 enum tree_code code2 = NOP_EXPR;
4182 enum tree_code code_orig_arg1 = ERROR_MARK;
4183 enum tree_code code_orig_arg2 = ERROR_MARK;
4189 if (error_operand_p (arg1)
4190 || error_operand_p (arg2)
4191 || error_operand_p (arg3))
4192 return error_mark_node;
4194 if (code == MODIFY_EXPR)
4196 code2 = TREE_CODE (arg3);
4198 fnname = ansi_assopname (code2);
4201 fnname = ansi_opname (code);
4203 arg1 = prep_operand (arg1);
4209 case VEC_DELETE_EXPR:
4211 /* Use build_op_new_call and build_op_delete_call instead. */
4215 /* Use build_op_call instead. */
4218 case TRUTH_ORIF_EXPR:
4219 case TRUTH_ANDIF_EXPR:
4220 case TRUTH_AND_EXPR:
4222 /* These are saved for the sake of warn_logical_operator. */
4223 code_orig_arg1 = TREE_CODE (arg1);
4224 code_orig_arg2 = TREE_CODE (arg2);
4230 arg2 = prep_operand (arg2);
4231 arg3 = prep_operand (arg3);
4233 if (code == COND_EXPR)
4234 /* Use build_conditional_expr instead. */
4236 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4237 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4240 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4241 arg2 = integer_zero_node;
4243 arglist = VEC_alloc (tree, gc, 3);
4244 VEC_quick_push (tree, arglist, arg1);
4245 if (arg2 != NULL_TREE)
4246 VEC_quick_push (tree, arglist, arg2);
4247 if (arg3 != NULL_TREE)
4248 VEC_quick_push (tree, arglist, arg3);
4250 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4251 p = conversion_obstack_alloc (0);
4253 /* Add namespace-scope operators to the list of functions to
4255 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
4256 NULL_TREE, arglist, NULL_TREE,
4257 NULL_TREE, false, NULL_TREE, NULL_TREE,
4258 flags, &candidates);
4259 /* Add class-member operators to the candidate set. */
4260 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
4264 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
4265 if (fns == error_mark_node)
4267 result = error_mark_node;
4268 goto user_defined_result_ready;
4271 add_candidates (BASELINK_FUNCTIONS (fns),
4272 NULL_TREE, arglist, NULL_TREE,
4274 BASELINK_BINFO (fns),
4275 BASELINK_ACCESS_BINFO (fns),
4276 flags, &candidates);
4281 args[2] = NULL_TREE;
4283 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
4289 /* For these, the built-in candidates set is empty
4290 [over.match.oper]/3. We don't want non-strict matches
4291 because exact matches are always possible with built-in
4292 operators. The built-in candidate set for COMPONENT_REF
4293 would be empty too, but since there are no such built-in
4294 operators, we accept non-strict matches for them. */
4299 strict_p = pedantic;
4303 candidates = splice_viable (candidates, strict_p, &any_viable_p);
4308 case POSTINCREMENT_EXPR:
4309 case POSTDECREMENT_EXPR:
4310 /* Don't try anything fancy if we're not allowed to produce
4312 if (!(complain & tf_error))
4313 return error_mark_node;
4315 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
4316 distinguish between prefix and postfix ++ and
4317 operator++() was used for both, so we allow this with
4319 if (flags & LOOKUP_COMPLAIN)
4321 const char *msg = (flag_permissive)
4322 ? G_("no %<%D(int)%> declared for postfix %qs,"
4323 " trying prefix operator instead")
4324 : G_("no %<%D(int)%> declared for postfix %qs");
4325 permerror (input_location, msg, fnname,
4326 operator_name_info[code].name);
4329 if (!flag_permissive)
4330 return error_mark_node;
4332 if (code == POSTINCREMENT_EXPR)
4333 code = PREINCREMENT_EXPR;
4335 code = PREDECREMENT_EXPR;
4336 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
4337 overloaded_p, complain);
4340 /* The caller will deal with these. */
4345 result_valid_p = true;
4349 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4351 /* If one of the arguments of the operator represents
4352 an invalid use of member function pointer, try to report
4353 a meaningful error ... */
4354 if (invalid_nonstatic_memfn_p (arg1, tf_error)
4355 || invalid_nonstatic_memfn_p (arg2, tf_error)
4356 || invalid_nonstatic_memfn_p (arg3, tf_error))
4357 /* We displayed the error message. */;
4360 /* ... Otherwise, report the more generic
4361 "no matching operator found" error */
4362 op_error (code, code2, arg1, arg2, arg3, FALSE);
4363 print_z_candidates (candidates);
4366 result = error_mark_node;
4372 cand = tourney (candidates);
4375 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4377 op_error (code, code2, arg1, arg2, arg3, TRUE);
4378 print_z_candidates (candidates);
4380 result = error_mark_node;
4382 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
4385 *overloaded_p = true;
4387 if (resolve_args (arglist) == NULL)
4388 result = error_mark_node;
4390 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4394 /* Give any warnings we noticed during overload resolution. */
4395 if (cand->warnings && (complain & tf_warning))
4397 struct candidate_warning *w;
4398 for (w = cand->warnings; w; w = w->next)
4399 joust (cand, w->loser, 1);
4402 /* Check for comparison of different enum types. */
4411 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
4412 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
4413 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
4414 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
4415 && (complain & tf_warning))
4417 warning (OPT_Wenum_compare,
4418 "comparison between %q#T and %q#T",
4419 TREE_TYPE (arg1), TREE_TYPE (arg2));
4426 /* We need to strip any leading REF_BIND so that bitfields
4427 don't cause errors. This should not remove any important
4428 conversions, because builtins don't apply to class
4429 objects directly. */
4430 conv = cand->convs[0];
4431 if (conv->kind == ck_ref_bind)
4432 conv = conv->u.next;
4433 arg1 = convert_like (conv, arg1, complain);
4437 /* We need to call warn_logical_operator before
4438 converting arg2 to a boolean_type. */
4439 if (complain & tf_warning)
4440 warn_logical_operator (input_location, code, boolean_type_node,
4441 code_orig_arg1, arg1,
4442 code_orig_arg2, arg2);
4444 conv = cand->convs[1];
4445 if (conv->kind == ck_ref_bind)
4446 conv = conv->u.next;
4447 arg2 = convert_like (conv, arg2, complain);
4451 conv = cand->convs[2];
4452 if (conv->kind == ck_ref_bind)
4453 conv = conv->u.next;
4454 arg3 = convert_like (conv, arg3, complain);
4460 user_defined_result_ready:
4462 /* Free all the conversions we allocated. */
4463 obstack_free (&conversion_obstack, p);
4465 if (result || result_valid_p)
4469 avoid_sign_compare_warnings (orig_arg1, arg1);
4470 avoid_sign_compare_warnings (orig_arg2, arg2);
4471 avoid_sign_compare_warnings (orig_arg3, arg3);
4476 return cp_build_modify_expr (arg1, code2, arg2, complain);
4479 return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
4481 case TRUTH_ANDIF_EXPR:
4482 case TRUTH_ORIF_EXPR:
4483 case TRUTH_AND_EXPR:
4485 warn_logical_operator (input_location, code, boolean_type_node,
4486 code_orig_arg1, arg1, code_orig_arg2, arg2);
4491 case TRUNC_DIV_EXPR:
4502 case TRUNC_MOD_EXPR:
4506 return cp_build_binary_op (input_location, code, arg1, arg2, complain);
4508 case UNARY_PLUS_EXPR:
4511 case TRUTH_NOT_EXPR:
4512 case PREINCREMENT_EXPR:
4513 case POSTINCREMENT_EXPR:
4514 case PREDECREMENT_EXPR:
4515 case POSTDECREMENT_EXPR:
4518 return cp_build_unary_op (code, arg1, candidates != 0, complain);
4521 return cp_build_array_ref (input_location, arg1, arg2, complain);
4524 return build_m_component_ref (cp_build_indirect_ref (arg1, RO_NULL,
4528 /* The caller will deal with these. */
4540 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
4541 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
4544 non_placement_deallocation_fn_p (tree t)
4546 /* A template instance is never a usual deallocation function,
4547 regardless of its signature. */
4548 if (TREE_CODE (t) == TEMPLATE_DECL
4549 || primary_template_instantiation_p (t))
4552 /* If a class T has a member deallocation function named operator delete
4553 with exactly one parameter, then that function is a usual
4554 (non-placement) deallocation function. If class T does not declare
4555 such an operator delete but does declare a member deallocation
4556 function named operator delete with exactly two parameters, the second
4557 of which has type std::size_t (18.2), then this function is a usual
4558 deallocation function. */
4559 t = FUNCTION_ARG_CHAIN (t);
4560 if (t == void_list_node
4561 || (t && same_type_p (TREE_VALUE (t), size_type_node)
4562 && TREE_CHAIN (t) == void_list_node))
4567 /* Build a call to operator delete. This has to be handled very specially,
4568 because the restrictions on what signatures match are different from all
4569 other call instances. For a normal delete, only a delete taking (void *)
4570 or (void *, size_t) is accepted. For a placement delete, only an exact
4571 match with the placement new is accepted.
4573 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4574 ADDR is the pointer to be deleted.
4575 SIZE is the size of the memory block to be deleted.
4576 GLOBAL_P is true if the delete-expression should not consider
4577 class-specific delete operators.
4578 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4580 If this call to "operator delete" is being generated as part to
4581 deallocate memory allocated via a new-expression (as per [expr.new]
4582 which requires that if the initialization throws an exception then
4583 we call a deallocation function), then ALLOC_FN is the allocation
4587 build_op_delete_call (enum tree_code code, tree addr, tree size,
4588 bool global_p, tree placement,
4591 tree fn = NULL_TREE;
4592 tree fns, fnname, type, t;
4594 if (addr == error_mark_node)
4595 return error_mark_node;
4597 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4599 fnname = ansi_opname (code);
4601 if (CLASS_TYPE_P (type)
4602 && COMPLETE_TYPE_P (complete_type (type))
4606 If the result of the lookup is ambiguous or inaccessible, or if
4607 the lookup selects a placement deallocation function, the
4608 program is ill-formed.
4610 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4612 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4613 if (fns == error_mark_node)
4614 return error_mark_node;
4619 if (fns == NULL_TREE)
4620 fns = lookup_name_nonclass (fnname);
4622 /* Strip const and volatile from addr. */
4623 addr = cp_convert (ptr_type_node, addr);
4627 /* "A declaration of a placement deallocation function matches the
4628 declaration of a placement allocation function if it has the same
4629 number of parameters and, after parameter transformations (8.3.5),
4630 all parameter types except the first are identical."
4632 So we build up the function type we want and ask instantiate_type
4633 to get it for us. */
4634 t = FUNCTION_ARG_CHAIN (alloc_fn);
4635 t = tree_cons (NULL_TREE, ptr_type_node, t);
4636 t = build_function_type (void_type_node, t);
4638 fn = instantiate_type (t, fns, tf_none);
4639 if (fn == error_mark_node)
4642 if (BASELINK_P (fn))
4643 fn = BASELINK_FUNCTIONS (fn);
4645 /* "If the lookup finds the two-parameter form of a usual deallocation
4646 function (3.7.4.2) and that function, considered as a placement
4647 deallocation function, would have been selected as a match for the
4648 allocation function, the program is ill-formed." */
4649 if (non_placement_deallocation_fn_p (fn))
4651 /* But if the class has an operator delete (void *), then that is
4652 the usual deallocation function, so we shouldn't complain
4653 about using the operator delete (void *, size_t). */
4654 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4655 t; t = OVL_NEXT (t))
4657 tree elt = OVL_CURRENT (t);
4658 if (non_placement_deallocation_fn_p (elt)
4659 && FUNCTION_ARG_CHAIN (elt) == void_list_node)
4662 permerror (0, "non-placement deallocation function %q+D", fn);
4663 permerror (input_location, "selected for placement delete");
4668 /* "Any non-placement deallocation function matches a non-placement
4669 allocation function. If the lookup finds a single matching
4670 deallocation function, that function will be called; otherwise, no
4671 deallocation function will be called." */
4672 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4673 t; t = OVL_NEXT (t))
4675 tree elt = OVL_CURRENT (t);
4676 if (non_placement_deallocation_fn_p (elt))
4679 /* "If a class T has a member deallocation function named
4680 operator delete with exactly one parameter, then that
4681 function is a usual (non-placement) deallocation
4682 function. If class T does not declare such an operator
4683 delete but does declare a member deallocation function named
4684 operator delete with exactly two parameters, the second of
4685 which has type std::size_t (18.2), then this function is a
4686 usual deallocation function."
4688 So (void*) beats (void*, size_t). */
4689 if (FUNCTION_ARG_CHAIN (fn) == void_list_node)
4694 /* If we have a matching function, call it. */
4697 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
4699 /* If the FN is a member function, make sure that it is
4701 if (BASELINK_P (fns))
4702 perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn);
4704 /* Core issue 901: It's ok to new a type with deleted delete. */
4705 if (DECL_DELETED_FN (fn) && alloc_fn)
4710 /* The placement args might not be suitable for overload
4711 resolution at this point, so build the call directly. */
4712 int nargs = call_expr_nargs (placement);
4713 tree *argarray = (tree *) alloca (nargs * sizeof (tree));
4716 for (i = 1; i < nargs; i++)
4717 argarray[i] = CALL_EXPR_ARG (placement, i);
4719 return build_cxx_call (fn, nargs, argarray);
4724 VEC(tree,gc) *args = VEC_alloc (tree, gc, 2);
4725 VEC_quick_push (tree, args, addr);
4726 if (FUNCTION_ARG_CHAIN (fn) != void_list_node)
4727 VEC_quick_push (tree, args, size);
4728 ret = cp_build_function_call_vec (fn, &args, tf_warning_or_error);
4729 VEC_free (tree, gc, args);
4736 If no unambiguous matching deallocation function can be found,
4737 propagating the exception does not cause the object's memory to
4742 warning (0, "no corresponding deallocation function for %qD",
4747 error ("no suitable %<operator %s%> for %qT",
4748 operator_name_info[(int)code].name, type);
4749 return error_mark_node;
4752 /* If the current scope isn't allowed to access DECL along
4753 BASETYPE_PATH, give an error. The most derived class in
4754 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4755 the declaration to use in the error diagnostic. */
4758 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4760 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4762 if (!accessible_p (basetype_path, decl, true))
4764 if (TREE_PRIVATE (decl))
4765 error ("%q+#D is private", diag_decl);
4766 else if (TREE_PROTECTED (decl))
4767 error ("%q+#D is protected", diag_decl);
4769 error ("%q+#D is inaccessible", diag_decl);
4770 error ("within this context");
4777 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4778 bitwise or of LOOKUP_* values. If any errors are warnings are
4779 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4780 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4784 build_temp (tree expr, tree type, int flags,
4785 diagnostic_t *diagnostic_kind)
4790 savew = warningcount, savee = errorcount;
4791 args = make_tree_vector_single (expr);
4792 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4793 &args, type, flags, tf_warning_or_error);
4794 release_tree_vector (args);
4795 if (warningcount > savew)
4796 *diagnostic_kind = DK_WARNING;
4797 else if (errorcount > savee)
4798 *diagnostic_kind = DK_ERROR;
4800 *diagnostic_kind = DK_UNSPECIFIED;
4804 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4805 EXPR is implicitly converted to type TOTYPE.
4806 FN and ARGNUM are used for diagnostics. */
4809 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
4811 tree t = non_reference (totype);
4813 /* Issue warnings about peculiar, but valid, uses of NULL. */
4814 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4817 warning_at (input_location, OPT_Wconversion_null,
4818 "passing NULL to non-pointer argument %P of %qD",
4821 warning_at (input_location, OPT_Wconversion_null,
4822 "converting to non-pointer type %qT from NULL", t);
4825 /* Issue warnings if "false" is converted to a NULL pointer */
4826 else if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4827 warning_at (input_location, OPT_Wconversion_null,
4828 "converting %<false%> to pointer type for argument %P of %qD",
4832 /* Perform the conversions in CONVS on the expression EXPR. FN and
4833 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4834 indicates the `this' argument of a method. INNER is nonzero when
4835 being called to continue a conversion chain. It is negative when a
4836 reference binding will be applied, positive otherwise. If
4837 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4838 conversions will be emitted if appropriate. If C_CAST_P is true,
4839 this conversion is coming from a C-style cast; in that case,
4840 conversions to inaccessible bases are permitted. */
4843 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4844 int inner, bool issue_conversion_warnings,
4845 bool c_cast_p, tsubst_flags_t complain)
4847 tree totype = convs->type;
4848 diagnostic_t diag_kind;
4852 && convs->kind != ck_user
4853 && convs->kind != ck_list
4854 && convs->kind != ck_ambig
4855 && convs->kind != ck_ref_bind
4856 && convs->kind != ck_rvalue
4857 && convs->kind != ck_base)
4859 conversion *t = convs;
4861 /* Give a helpful error if this is bad because of excess braces. */
4862 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
4863 && SCALAR_TYPE_P (totype)
4864 && CONSTRUCTOR_NELTS (expr) > 0
4865 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
4866 permerror (input_location, "too many braces around initializer for %qT", totype);
4868 for (; t; t = convs->u.next)
4870 if (t->kind == ck_user || !t->bad_p)
4872 expr = convert_like_real (t, expr, fn, argnum, 1,
4873 /*issue_conversion_warnings=*/false,
4878 else if (t->kind == ck_ambig)
4879 return convert_like_real (t, expr, fn, argnum, 1,
4880 /*issue_conversion_warnings=*/false,
4883 else if (t->kind == ck_identity)
4886 if (complain & tf_error)
4888 permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4890 permerror (input_location, " initializing argument %P of %qD", argnum, fn);
4893 return error_mark_node;
4895 return cp_convert (totype, expr);
4898 if (issue_conversion_warnings && (complain & tf_warning))
4899 conversion_null_warnings (totype, expr, fn, argnum);
4901 switch (convs->kind)
4905 struct z_candidate *cand = convs->cand;
4906 tree convfn = cand->fn;
4909 expr = mark_rvalue_use (expr);
4911 /* When converting from an init list we consider explicit
4912 constructors, but actually trying to call one is an error. */
4913 if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn))
4915 if (complain & tf_error)
4916 error ("converting to %qT from initializer list would use "
4917 "explicit constructor %qD", totype, convfn);
4919 return error_mark_node;
4922 /* Set user_conv_p on the argument conversions, so rvalue/base
4923 handling knows not to allow any more UDCs. */
4924 for (i = 0; i < cand->num_convs; ++i)
4925 cand->convs[i]->user_conv_p = true;
4927 expr = build_over_call (cand, LOOKUP_NORMAL, complain);
4929 /* If this is a constructor or a function returning an aggr type,
4930 we need to build up a TARGET_EXPR. */
4931 if (DECL_CONSTRUCTOR_P (convfn))
4933 expr = build_cplus_new (totype, expr);
4935 /* Remember that this was list-initialization. */
4936 if (convs->check_narrowing)
4937 TARGET_EXPR_LIST_INIT_P (expr) = true;
4943 expr = mark_rvalue_use (expr);
4944 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
4946 int nelts = CONSTRUCTOR_NELTS (expr);
4948 expr = integer_zero_node;
4949 else if (nelts == 1)
4950 expr = CONSTRUCTOR_ELT (expr, 0)->value;
4955 if (type_unknown_p (expr))
4956 expr = instantiate_type (totype, expr, complain);
4957 /* Convert a constant to its underlying value, unless we are
4958 about to bind it to a reference, in which case we need to
4959 leave it as an lvalue. */
4962 expr = decl_constant_value (expr);
4963 if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
4964 /* If __null has been converted to an integer type, we do not
4965 want to warn about uses of EXPR as an integer, rather than
4967 expr = build_int_cst (totype, 0);
4971 if (!(complain & tf_error))
4972 return error_mark_node;
4973 /* Call build_user_type_conversion again for the error. */
4974 return build_user_type_conversion
4975 (totype, convs->u.expr, LOOKUP_NORMAL);
4979 /* Conversion to std::initializer_list<T>. */
4980 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
4981 tree new_ctor = build_constructor (init_list_type_node, NULL);
4982 unsigned len = CONSTRUCTOR_NELTS (expr);
4984 VEC(tree,gc) *parms;
4987 /* Convert all the elements. */
4988 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
4990 tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
4991 1, false, false, complain);
4992 if (sub == error_mark_node)
4994 check_narrowing (TREE_TYPE (sub), val);
4995 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
4997 /* Build up the array. */
4998 elttype = cp_build_qualified_type
4999 (elttype, cp_type_quals (elttype) | TYPE_QUAL_CONST);
5000 array = build_array_of_n_type (elttype, len);
5001 array = finish_compound_literal (array, new_ctor);
5003 parms = make_tree_vector ();
5004 VEC_safe_push (tree, gc, parms, decay_conversion (array));
5005 VEC_safe_push (tree, gc, parms, size_int (len));
5006 /* Call the private constructor. */
5007 push_deferring_access_checks (dk_no_check);
5008 new_ctor = build_special_member_call
5009 (NULL_TREE, complete_ctor_identifier, &parms, totype, 0, complain);
5010 release_tree_vector (parms);
5011 pop_deferring_access_checks ();
5012 return build_cplus_new (totype, new_ctor);
5016 return get_target_expr (digest_init (totype, expr));
5022 expr = convert_like_real (convs->u.next, expr, fn, argnum,
5023 convs->kind == ck_ref_bind ? -1 : 1,
5024 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
5027 if (expr == error_mark_node)
5028 return error_mark_node;
5030 switch (convs->kind)
5033 expr = decay_conversion (expr);
5034 if (! MAYBE_CLASS_TYPE_P (totype))
5036 /* Else fall through. */
5038 if (convs->kind == ck_base && !convs->need_temporary_p)
5040 /* We are going to bind a reference directly to a base-class
5041 subobject of EXPR. */
5042 /* Build an expression for `*((base*) &expr)'. */
5043 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5044 expr = convert_to_base (expr, build_pointer_type (totype),
5045 !c_cast_p, /*nonnull=*/true, complain);
5046 expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
5050 /* Copy-initialization where the cv-unqualified version of the source
5051 type is the same class as, or a derived class of, the class of the
5052 destination [is treated as direct-initialization]. [dcl.init] */
5053 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
5054 if (convs->user_conv_p)
5055 /* This conversion is being done in the context of a user-defined
5056 conversion (i.e. the second step of copy-initialization), so
5057 don't allow any more. */
5058 flags |= LOOKUP_NO_CONVERSION;
5059 expr = build_temp (expr, totype, flags, &diag_kind);
5060 if (diag_kind && fn)
5062 if ((complain & tf_error))
5063 emit_diagnostic (diag_kind, input_location, 0,
5064 " initializing argument %P of %qD", argnum, fn);
5065 else if (diag_kind == DK_ERROR)
5066 return error_mark_node;
5068 return build_cplus_new (totype, expr);
5072 tree ref_type = totype;
5074 if (convs->bad_p && TYPE_REF_IS_RVALUE (ref_type)
5075 && real_lvalue_p (expr))
5077 if (complain & tf_error)
5079 error ("cannot bind %qT lvalue to %qT",
5080 TREE_TYPE (expr), totype);
5082 error (" initializing argument %P of %q+D", argnum, fn);
5084 return error_mark_node;
5087 /* If necessary, create a temporary.
5089 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
5090 that need temporaries, even when their types are reference
5091 compatible with the type of reference being bound, so the
5092 upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...)
5094 if (convs->need_temporary_p
5095 || TREE_CODE (expr) == CONSTRUCTOR
5096 || TREE_CODE (expr) == VA_ARG_EXPR)
5098 tree type = convs->u.next->type;
5099 cp_lvalue_kind lvalue = real_lvalue_p (expr);
5101 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
5102 && !TYPE_REF_IS_RVALUE (ref_type))
5104 if (complain & tf_error)
5106 /* If the reference is volatile or non-const, we
5107 cannot create a temporary. */
5108 if (lvalue & clk_bitfield)
5109 error ("cannot bind bitfield %qE to %qT",
5111 else if (lvalue & clk_packed)
5112 error ("cannot bind packed field %qE to %qT",
5115 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
5117 return error_mark_node;
5119 /* If the source is a packed field, and we must use a copy
5120 constructor, then building the target expr will require
5121 binding the field to the reference parameter to the
5122 copy constructor, and we'll end up with an infinite
5123 loop. If we can use a bitwise copy, then we'll be
5125 if ((lvalue & clk_packed)
5126 && CLASS_TYPE_P (type)
5127 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
5129 if (complain & tf_error)
5130 error ("cannot bind packed field %qE to %qT",
5132 return error_mark_node;
5134 if (lvalue & clk_bitfield)
5136 expr = convert_bitfield_to_declared_type (expr);
5137 expr = fold_convert (type, expr);
5139 expr = build_target_expr_with_type (expr, type);
5142 /* Take the address of the thing to which we will bind the
5144 expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain);
5145 if (expr == error_mark_node)
5146 return error_mark_node;
5148 /* Convert it to a pointer to the type referred to by the
5149 reference. This will adjust the pointer if a derived to
5150 base conversion is being performed. */
5151 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
5153 /* Convert the pointer to the desired reference type. */
5154 return build_nop (ref_type, expr);
5158 return decay_conversion (expr);
5161 /* Warn about deprecated conversion if appropriate. */
5162 string_conv_p (totype, expr, 1);
5167 expr = convert_to_base (expr, totype, !c_cast_p,
5168 /*nonnull=*/false, complain);
5169 return build_nop (totype, expr);
5172 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
5179 if (convs->check_narrowing)
5180 check_narrowing (totype, expr);
5182 if (issue_conversion_warnings && (complain & tf_warning))
5183 expr = convert_and_check (totype, expr);
5185 expr = convert (totype, expr);
5190 /* ARG is being passed to a varargs function. Perform any conversions
5191 required. Return the converted value. */
5194 convert_arg_to_ellipsis (tree arg)
5198 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5199 standard conversions are performed. */
5200 arg = decay_conversion (arg);
5203 If the argument has integral or enumeration type that is subject
5204 to the integral promotions (_conv.prom_), or a floating point
5205 type that is subject to the floating point promotion
5206 (_conv.fpprom_), the value of the argument is converted to the
5207 promoted type before the call. */
5208 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
5209 && (TYPE_PRECISION (TREE_TYPE (arg))
5210 < TYPE_PRECISION (double_type_node))
5211 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (arg))))
5212 arg = convert_to_real (double_type_node, arg);
5213 else if (NULLPTR_TYPE_P (TREE_TYPE (arg)))
5214 arg = null_pointer_node;
5215 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
5216 arg = perform_integral_promotions (arg);
5218 arg = require_complete_type (arg);
5220 if (arg != error_mark_node
5221 && (type_has_nontrivial_copy_init (TREE_TYPE (arg))
5222 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (arg))))
5224 /* [expr.call] 5.2.2/7:
5225 Passing a potentially-evaluated argument of class type (Clause 9)
5226 with a non-trivial copy constructor or a non-trivial destructor
5227 with no corresponding parameter is conditionally-supported, with
5228 implementation-defined semantics.
5230 We used to just warn here and do a bitwise copy, but now
5231 cp_expr_size will abort if we try to do that.
5233 If the call appears in the context of a sizeof expression,
5234 it is not potentially-evaluated. */
5235 if (cp_unevaluated_operand == 0)
5236 error ("cannot pass objects of non-trivially-copyable "
5237 "type %q#T through %<...%>", TREE_TYPE (arg));
5243 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
5246 build_x_va_arg (tree expr, tree type)
5248 if (processing_template_decl)
5249 return build_min (VA_ARG_EXPR, type, expr);
5251 type = complete_type_or_else (type, NULL_TREE);
5253 if (expr == error_mark_node || !type)
5254 return error_mark_node;
5256 expr = mark_lvalue_use (expr);
5258 if (type_has_nontrivial_copy_init (type)
5259 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5260 || TREE_CODE (type) == REFERENCE_TYPE)
5262 /* Remove reference types so we don't ICE later on. */
5263 tree type1 = non_reference (type);
5264 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
5265 error ("cannot receive objects of non-trivially-copyable type %q#T "
5266 "through %<...%>; ", type);
5267 expr = convert (build_pointer_type (type1), null_node);
5268 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
5272 return build_va_arg (input_location, expr, type);
5275 /* TYPE has been given to va_arg. Apply the default conversions which
5276 would have happened when passed via ellipsis. Return the promoted
5277 type, or the passed type if there is no change. */
5280 cxx_type_promotes_to (tree type)
5284 /* Perform the array-to-pointer and function-to-pointer
5286 type = type_decays_to (type);
5288 promote = type_promotes_to (type);
5289 if (same_type_p (type, promote))
5295 /* ARG is a default argument expression being passed to a parameter of
5296 the indicated TYPE, which is a parameter to FN. Do any required
5297 conversions. Return the converted value. */
5299 static GTY(()) VEC(tree,gc) *default_arg_context;
5302 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
5307 /* If the ARG is an unparsed default argument expression, the
5308 conversion cannot be performed. */
5309 if (TREE_CODE (arg) == DEFAULT_ARG)
5311 error ("the default argument for parameter %d of %qD has "
5312 "not yet been parsed",
5314 return error_mark_node;
5317 /* Detect recursion. */
5318 for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
5321 error ("recursive evaluation of default argument for %q#D", fn);
5322 return error_mark_node;
5324 VEC_safe_push (tree, gc, default_arg_context, fn);
5326 if (fn && DECL_TEMPLATE_INFO (fn))
5327 arg = tsubst_default_argument (fn, type, arg);
5333 The names in the expression are bound, and the semantic
5334 constraints are checked, at the point where the default
5335 expressions appears.
5337 we must not perform access checks here. */
5338 push_deferring_access_checks (dk_no_check);
5339 arg = break_out_target_exprs (arg);
5340 if (TREE_CODE (arg) == CONSTRUCTOR)
5342 arg = digest_init (type, arg);
5343 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5344 "default argument", fn, parmnum,
5345 tf_warning_or_error);
5349 /* We must make a copy of ARG, in case subsequent processing
5350 alters any part of it. For example, during gimplification a
5351 cast of the form (T) &X::f (where "f" is a member function)
5352 will lead to replacing the PTRMEM_CST for &X::f with a
5353 VAR_DECL. We can avoid the copy for constants, since they
5354 are never modified in place. */
5355 if (!CONSTANT_CLASS_P (arg))
5356 arg = unshare_expr (arg);
5357 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5358 "default argument", fn, parmnum,
5359 tf_warning_or_error);
5360 arg = convert_for_arg_passing (type, arg);
5362 pop_deferring_access_checks();
5364 VEC_pop (tree, default_arg_context);
5369 /* Returns the type which will really be used for passing an argument of
5373 type_passed_as (tree type)
5375 /* Pass classes with copy ctors by invisible reference. */
5376 if (TREE_ADDRESSABLE (type))
5378 type = build_reference_type (type);
5379 /* There are no other pointers to this temporary. */
5380 type = cp_build_qualified_type (type, TYPE_QUAL_RESTRICT);
5382 else if (targetm.calls.promote_prototypes (type)
5383 && INTEGRAL_TYPE_P (type)
5384 && COMPLETE_TYPE_P (type)
5385 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5386 TYPE_SIZE (integer_type_node)))
5387 type = integer_type_node;
5392 /* Actually perform the appropriate conversion. */
5395 convert_for_arg_passing (tree type, tree val)
5399 /* If VAL is a bitfield, then -- since it has already been converted
5400 to TYPE -- it cannot have a precision greater than TYPE.
5402 If it has a smaller precision, we must widen it here. For
5403 example, passing "int f:3;" to a function expecting an "int" will
5404 not result in any conversion before this point.
5406 If the precision is the same we must not risk widening. For
5407 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
5408 often have type "int", even though the C++ type for the field is
5409 "long long". If the value is being passed to a function
5410 expecting an "int", then no conversions will be required. But,
5411 if we call convert_bitfield_to_declared_type, the bitfield will
5412 be converted to "long long". */
5413 bitfield_type = is_bitfield_expr_with_lowered_type (val);
5415 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
5416 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
5418 if (val == error_mark_node)
5420 /* Pass classes with copy ctors by invisible reference. */
5421 else if (TREE_ADDRESSABLE (type))
5422 val = build1 (ADDR_EXPR, build_reference_type (type), val);
5423 else if (targetm.calls.promote_prototypes (type)
5424 && INTEGRAL_TYPE_P (type)
5425 && COMPLETE_TYPE_P (type)
5426 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5427 TYPE_SIZE (integer_type_node)))
5428 val = perform_integral_promotions (val);
5429 if (warn_missing_format_attribute)
5431 tree rhstype = TREE_TYPE (val);
5432 const enum tree_code coder = TREE_CODE (rhstype);
5433 const enum tree_code codel = TREE_CODE (type);
5434 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5436 && check_missing_format_attribute (type, rhstype))
5437 warning (OPT_Wmissing_format_attribute,
5438 "argument of function call might be a candidate for a format attribute");
5443 /* Returns true iff FN is a function with magic varargs, i.e. ones for
5444 which no conversions at all should be done. This is true for some
5445 builtins which don't act like normal functions. */
5448 magic_varargs_p (tree fn)
5450 if (DECL_BUILT_IN (fn))
5451 switch (DECL_FUNCTION_CODE (fn))
5453 case BUILT_IN_CLASSIFY_TYPE:
5454 case BUILT_IN_CONSTANT_P:
5455 case BUILT_IN_NEXT_ARG:
5456 case BUILT_IN_VA_START:
5460 return lookup_attribute ("type generic",
5461 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
5467 /* Subroutine of the various build_*_call functions. Overload resolution
5468 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
5469 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
5470 bitmask of various LOOKUP_* flags which apply to the call itself. */
5473 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
5476 const VEC(tree,gc) *args = cand->args;
5477 tree first_arg = cand->first_arg;
5478 conversion **convs = cand->convs;
5480 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5485 unsigned int arg_index = 0;
5489 bool already_used = false;
5491 /* In a template, there is no need to perform all of the work that
5492 is normally done. We are only interested in the type of the call
5493 expression, i.e., the return type of the function. Any semantic
5494 errors will be deferred until the template is instantiated. */
5495 if (processing_template_decl)
5499 const tree *argarray;
5502 return_type = TREE_TYPE (TREE_TYPE (fn));
5503 nargs = VEC_length (tree, args);
5504 if (first_arg == NULL_TREE)
5505 argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
5513 alcarray = XALLOCAVEC (tree, nargs);
5514 alcarray[0] = first_arg;
5515 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
5516 alcarray[ix + 1] = arg;
5517 argarray = alcarray;
5519 expr = build_call_array_loc (input_location,
5520 return_type, build_addr_func (fn), nargs,
5522 if (TREE_THIS_VOLATILE (fn) && cfun)
5523 current_function_returns_abnormally = 1;
5524 if (!VOID_TYPE_P (return_type))
5525 require_complete_type (return_type);
5526 return convert_from_reference (expr);
5529 /* Give any warnings we noticed during overload resolution. */
5532 struct candidate_warning *w;
5533 for (w = cand->warnings; w; w = w->next)
5534 joust (cand, w->loser, 1);
5537 /* Make =delete work with SFINAE. */
5538 if (DECL_DELETED_FN (fn) && !(complain & tf_error))
5539 return error_mark_node;
5541 if (DECL_FUNCTION_MEMBER_P (fn))
5543 /* If FN is a template function, two cases must be considered.
5548 template <class T> void f();
5550 template <class T> struct B {
5554 struct C : A, B<int> {
5556 using B<int>::g; // #2
5559 In case #1 where `A::f' is a member template, DECL_ACCESS is
5560 recorded in the primary template but not in its specialization.
5561 We check access of FN using its primary template.
5563 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
5564 because it is a member of class template B, DECL_ACCESS is
5565 recorded in the specialization `B<int>::g'. We cannot use its
5566 primary template because `B<T>::g' and `B<int>::g' may have
5567 different access. */
5568 if (DECL_TEMPLATE_INFO (fn)
5569 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
5570 perform_or_defer_access_check (cand->access_path,
5571 DECL_TI_TEMPLATE (fn), fn);
5573 perform_or_defer_access_check (cand->access_path, fn, fn);
5576 /* Find maximum size of vector to hold converted arguments. */
5577 parmlen = list_length (parm);
5578 nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
5579 if (parmlen > nargs)
5581 argarray = (tree *) alloca (nargs * sizeof (tree));
5583 /* The implicit parameters to a constructor are not considered by overload
5584 resolution, and must be of the proper type. */
5585 if (DECL_CONSTRUCTOR_P (fn))
5587 if (first_arg != NULL_TREE)
5589 argarray[j++] = first_arg;
5590 first_arg = NULL_TREE;
5594 argarray[j++] = VEC_index (tree, args, arg_index);
5597 parm = TREE_CHAIN (parm);
5598 /* We should never try to call the abstract constructor. */
5599 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
5601 if (DECL_HAS_VTT_PARM_P (fn))
5603 argarray[j++] = VEC_index (tree, args, arg_index);
5605 parm = TREE_CHAIN (parm);
5608 /* Bypass access control for 'this' parameter. */
5609 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5611 tree parmtype = TREE_VALUE (parm);
5612 tree arg = (first_arg != NULL_TREE
5614 : VEC_index (tree, args, arg_index));
5615 tree argtype = TREE_TYPE (arg);
5619 if (convs[i]->bad_p)
5621 if (complain & tf_error)
5622 permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
5623 TREE_TYPE (argtype), fn);
5625 return error_mark_node;
5628 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
5629 X is called for an object that is not of type X, or of a type
5630 derived from X, the behavior is undefined.
5632 So we can assume that anything passed as 'this' is non-null, and
5633 optimize accordingly. */
5634 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
5635 /* Convert to the base in which the function was declared. */
5636 gcc_assert (cand->conversion_path != NULL_TREE);
5637 converted_arg = build_base_path (PLUS_EXPR,
5639 cand->conversion_path,
5641 /* Check that the base class is accessible. */
5642 if (!accessible_base_p (TREE_TYPE (argtype),
5643 BINFO_TYPE (cand->conversion_path), true))
5644 error ("%qT is not an accessible base of %qT",
5645 BINFO_TYPE (cand->conversion_path),
5646 TREE_TYPE (argtype));
5647 /* If fn was found by a using declaration, the conversion path
5648 will be to the derived class, not the base declaring fn. We
5649 must convert from derived to base. */
5650 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
5651 TREE_TYPE (parmtype), ba_unique, NULL);
5652 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
5655 argarray[j++] = converted_arg;
5656 parm = TREE_CHAIN (parm);
5657 if (first_arg != NULL_TREE)
5658 first_arg = NULL_TREE;
5665 gcc_assert (first_arg == NULL_TREE);
5666 for (; arg_index < VEC_length (tree, args) && parm;
5667 parm = TREE_CHAIN (parm), ++arg_index, ++i)
5669 tree type = TREE_VALUE (parm);
5670 tree arg = VEC_index (tree, args, arg_index);
5674 /* Don't make a copy here if build_call is going to. */
5675 if (conv->kind == ck_rvalue
5676 && COMPLETE_TYPE_P (complete_type (type))
5677 && !TREE_ADDRESSABLE (type))
5678 conv = conv->u.next;
5680 /* Warn about initializer_list deduction that isn't currently in the
5682 if (cxx_dialect > cxx98
5683 && flag_deduce_init_list
5684 && cand->template_decl
5685 && is_std_init_list (non_reference (type))
5686 && BRACE_ENCLOSED_INITIALIZER_P (arg))
5688 tree tmpl = TI_TEMPLATE (cand->template_decl);
5689 tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
5690 tree patparm = get_pattern_parm (realparm, tmpl);
5691 tree pattype = TREE_TYPE (patparm);
5692 if (PACK_EXPANSION_P (pattype))
5693 pattype = PACK_EXPANSION_PATTERN (pattype);
5694 pattype = non_reference (pattype);
5696 if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM
5697 && (cand->explicit_targs == NULL_TREE
5698 || (TREE_VEC_LENGTH (cand->explicit_targs)
5699 <= TEMPLATE_TYPE_IDX (pattype))))
5701 pedwarn (input_location, 0, "deducing %qT as %qT",
5702 non_reference (TREE_TYPE (patparm)),
5703 non_reference (type));
5704 pedwarn (input_location, 0, " in call to %q+D", cand->fn);
5705 pedwarn (input_location, 0,
5706 " (you can disable this with -fno-deduce-init-list)");
5710 val = convert_like_with_context (conv, arg, fn, i-is_method, complain);
5712 val = convert_for_arg_passing (type, val);
5713 if (val == error_mark_node)
5714 return error_mark_node;
5716 argarray[j++] = val;
5719 /* Default arguments */
5720 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5721 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5722 TREE_PURPOSE (parm),
5725 for (; arg_index < VEC_length (tree, args); ++arg_index)
5727 tree a = VEC_index (tree, args, arg_index);
5728 if (magic_varargs_p (fn))
5729 /* Do no conversions for magic varargs. */
5730 a = mark_type_use (a);
5732 a = convert_arg_to_ellipsis (a);
5736 gcc_assert (j <= nargs);
5739 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5740 nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5742 /* Avoid actually calling copy constructors and copy assignment operators,
5745 if (! flag_elide_constructors)
5746 /* Do things the hard way. */;
5747 else if (cand->num_convs == 1
5748 && (DECL_COPY_CONSTRUCTOR_P (fn)
5749 || DECL_MOVE_CONSTRUCTOR_P (fn)))
5752 tree arg = argarray[num_artificial_parms_for (fn)];
5755 /* Pull out the real argument, disregarding const-correctness. */
5757 while (CONVERT_EXPR_P (targ)
5758 || TREE_CODE (targ) == NON_LVALUE_EXPR)
5759 targ = TREE_OPERAND (targ, 0);
5760 if (TREE_CODE (targ) == ADDR_EXPR)
5762 targ = TREE_OPERAND (targ, 0);
5763 if (!same_type_ignoring_top_level_qualifiers_p
5764 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5773 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5775 if (TREE_CODE (arg) == TARGET_EXPR
5776 && TARGET_EXPR_LIST_INIT_P (arg))
5778 /* Copy-list-initialization doesn't require the copy constructor
5781 /* [class.copy]: the copy constructor is implicitly defined even if
5782 the implementation elided its use. */
5783 else if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn))
5787 already_used = true;
5790 /* If we're creating a temp and we already have one, don't create a
5791 new one. If we're not creating a temp but we get one, use
5792 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5793 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5794 temp or an INIT_EXPR otherwise. */
5795 fa = (cand->first_arg != NULL_TREE
5797 : VEC_index (tree, args, 0));
5798 if (integer_zerop (fa))
5800 if (TREE_CODE (arg) == TARGET_EXPR)
5802 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5804 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5806 else if (TREE_CODE (arg) == TARGET_EXPR
5807 || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5808 && !move_fn_p (fn)))
5810 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
5813 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5817 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5819 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5821 tree to = stabilize_reference
5822 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
5823 tree type = TREE_TYPE (to);
5824 tree as_base = CLASSTYPE_AS_BASE (type);
5825 tree arg = argarray[1];
5827 if (is_really_empty_class (type))
5829 /* Avoid copying empty classes. */
5830 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
5831 TREE_NO_WARNING (val) = 1;
5832 val = build2 (COMPOUND_EXPR, type, val, to);
5833 TREE_NO_WARNING (val) = 1;
5835 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5837 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5838 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5842 /* We must only copy the non-tail padding parts.
5843 Use __builtin_memcpy for the bitwise copy.
5844 FIXME fix 22488 so we can go back to using MODIFY_EXPR
5845 instead of an explicit call to memcpy. */
5847 tree arg0, arg1, arg2, t;
5848 tree test = NULL_TREE;
5850 arg2 = TYPE_SIZE_UNIT (as_base);
5852 arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5854 if (!can_trust_pointer_alignment ())
5856 /* If we can't be sure about pointer alignment, a call
5857 to __builtin_memcpy is expanded as a call to memcpy, which
5858 is invalid with identical args. Otherwise it is
5859 expanded as a block move, which should be safe. */
5860 arg0 = save_expr (arg0);
5861 arg1 = save_expr (arg1);
5862 test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5864 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5865 t = build_call_n (t, 3, arg0, arg1, arg2);
5867 t = convert (TREE_TYPE (arg0), t);
5869 t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5870 val = cp_build_indirect_ref (t, RO_NULL, complain);
5871 TREE_NO_WARNING (val) = 1;
5880 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5883 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5886 gcc_assert (binfo && binfo != error_mark_node);
5888 /* Warn about deprecated virtual functions now, since we're about
5889 to throw away the decl. */
5890 if (TREE_DEPRECATED (fn))
5891 warn_deprecated_use (fn, NULL_TREE);
5893 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5894 if (TREE_SIDE_EFFECTS (argarray[0]))
5895 argarray[0] = save_expr (argarray[0]);
5896 t = build_pointer_type (TREE_TYPE (fn));
5897 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5898 fn = build_java_interface_fn_ref (fn, argarray[0]);
5900 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5904 fn = build_addr_func (fn);
5906 return build_cxx_call (fn, nargs, argarray);
5909 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5910 This function performs no overload resolution, conversion, or other
5911 high-level operations. */
5914 build_cxx_call (tree fn, int nargs, tree *argarray)
5918 fn = build_call_a (fn, nargs, argarray);
5920 /* If this call might throw an exception, note that fact. */
5921 fndecl = get_callee_fndecl (fn);
5922 if ((!fndecl || !TREE_NOTHROW (fndecl))
5923 && at_function_scope_p ()
5925 cp_function_chain->can_throw = 1;
5927 /* Check that arguments to builtin functions match the expectations. */
5929 && DECL_BUILT_IN (fndecl)
5930 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5931 && !check_builtin_function_arguments (fndecl, nargs, argarray))
5932 return error_mark_node;
5934 /* Some built-in function calls will be evaluated at compile-time in
5936 fn = fold_if_not_in_template (fn);
5938 if (VOID_TYPE_P (TREE_TYPE (fn)))
5941 fn = require_complete_type (fn);
5942 if (fn == error_mark_node)
5943 return error_mark_node;
5945 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
5946 fn = build_cplus_new (TREE_TYPE (fn), fn);
5947 return convert_from_reference (fn);
5950 static GTY(()) tree java_iface_lookup_fn;
5952 /* Make an expression which yields the address of the Java interface
5953 method FN. This is achieved by generating a call to libjava's
5954 _Jv_LookupInterfaceMethodIdx(). */
5957 build_java_interface_fn_ref (tree fn, tree instance)
5959 tree lookup_fn, method, idx;
5960 tree klass_ref, iface, iface_ref;
5963 if (!java_iface_lookup_fn)
5965 tree endlink = build_void_list_node ();
5966 tree t = tree_cons (NULL_TREE, ptr_type_node,
5967 tree_cons (NULL_TREE, ptr_type_node,
5968 tree_cons (NULL_TREE, java_int_type_node,
5970 java_iface_lookup_fn
5971 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5972 build_function_type (ptr_type_node, t),
5973 0, NOT_BUILT_IN, NULL, NULL_TREE);
5976 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5977 This is the first entry in the vtable. */
5978 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
5979 tf_warning_or_error),
5982 /* Get the java.lang.Class pointer for the interface being called. */
5983 iface = DECL_CONTEXT (fn);
5984 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5985 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5986 || DECL_CONTEXT (iface_ref) != iface)
5988 error ("could not find class$ field in java interface type %qT",
5990 return error_mark_node;
5992 iface_ref = build_address (iface_ref);
5993 iface_ref = convert (build_pointer_type (iface), iface_ref);
5995 /* Determine the itable index of FN. */
5997 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5999 if (!DECL_VIRTUAL_P (method))
6005 idx = build_int_cst (NULL_TREE, i);
6007 lookup_fn = build1 (ADDR_EXPR,
6008 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6009 java_iface_lookup_fn);
6010 return build_call_nary (ptr_type_node, lookup_fn,
6011 3, klass_ref, iface_ref, idx);
6014 /* Returns the value to use for the in-charge parameter when making a
6015 call to a function with the indicated NAME.
6017 FIXME:Can't we find a neater way to do this mapping? */
6020 in_charge_arg_for_name (tree name)
6022 if (name == base_ctor_identifier
6023 || name == base_dtor_identifier)
6024 return integer_zero_node;
6025 else if (name == complete_ctor_identifier)
6026 return integer_one_node;
6027 else if (name == complete_dtor_identifier)
6028 return integer_two_node;
6029 else if (name == deleting_dtor_identifier)
6030 return integer_three_node;
6032 /* This function should only be called with one of the names listed
6038 /* Build a call to a constructor, destructor, or an assignment
6039 operator for INSTANCE, an expression with class type. NAME
6040 indicates the special member function to call; *ARGS are the
6041 arguments. ARGS may be NULL. This may change ARGS. BINFO
6042 indicates the base of INSTANCE that is to be passed as the `this'
6043 parameter to the member function called.
6045 FLAGS are the LOOKUP_* flags to use when processing the call.
6047 If NAME indicates a complete object constructor, INSTANCE may be
6048 NULL_TREE. In this case, the caller will call build_cplus_new to
6049 store the newly constructed object into a VAR_DECL. */
6052 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6053 tree binfo, int flags, tsubst_flags_t complain)
6056 /* The type of the subobject to be constructed or destroyed. */
6058 VEC(tree,gc) *allocated = NULL;
6061 gcc_assert (name == complete_ctor_identifier
6062 || name == base_ctor_identifier
6063 || name == complete_dtor_identifier
6064 || name == base_dtor_identifier
6065 || name == deleting_dtor_identifier
6066 || name == ansi_assopname (NOP_EXPR));
6069 /* Resolve the name. */
6070 if (!complete_type_or_else (binfo, NULL_TREE))
6071 return error_mark_node;
6073 binfo = TYPE_BINFO (binfo);
6076 gcc_assert (binfo != NULL_TREE);
6078 class_type = BINFO_TYPE (binfo);
6080 /* Handle the special case where INSTANCE is NULL_TREE. */
6081 if (name == complete_ctor_identifier && !instance)
6083 instance = build_int_cst (build_pointer_type (class_type), 0);
6084 instance = build1 (INDIRECT_REF, class_type, instance);
6088 if (name == complete_dtor_identifier
6089 || name == base_dtor_identifier
6090 || name == deleting_dtor_identifier)
6091 gcc_assert (args == NULL || VEC_empty (tree, *args));
6093 /* Convert to the base class, if necessary. */
6094 if (!same_type_ignoring_top_level_qualifiers_p
6095 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6097 if (name != ansi_assopname (NOP_EXPR))
6098 /* For constructors and destructors, either the base is
6099 non-virtual, or it is virtual but we are doing the
6100 conversion from a constructor or destructor for the
6101 complete object. In either case, we can convert
6103 instance = convert_to_base_statically (instance, binfo);
6105 /* However, for assignment operators, we must convert
6106 dynamically if the base is virtual. */
6107 instance = build_base_path (PLUS_EXPR, instance,
6108 binfo, /*nonnull=*/1);
6112 gcc_assert (instance != NULL_TREE);
6114 fns = lookup_fnfields (binfo, name, 1);
6116 /* When making a call to a constructor or destructor for a subobject
6117 that uses virtual base classes, pass down a pointer to a VTT for
6119 if ((name == base_ctor_identifier
6120 || name == base_dtor_identifier)
6121 && CLASSTYPE_VBASECLASSES (class_type))
6126 /* If the current function is a complete object constructor
6127 or destructor, then we fetch the VTT directly.
6128 Otherwise, we look it up using the VTT we were given. */
6129 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6130 vtt = decay_conversion (vtt);
6131 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6132 build2 (EQ_EXPR, boolean_type_node,
6133 current_in_charge_parm, integer_zero_node),
6136 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6137 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6138 BINFO_SUBVTT_INDEX (binfo));
6142 allocated = make_tree_vector ();
6146 VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6149 ret = build_new_method_call (instance, fns, args,
6150 TYPE_BINFO (BINFO_TYPE (binfo)),
6154 if (allocated != NULL)
6155 release_tree_vector (allocated);
6160 /* Return the NAME, as a C string. The NAME indicates a function that
6161 is a member of TYPE. *FREE_P is set to true if the caller must
6162 free the memory returned.
6164 Rather than go through all of this, we should simply set the names
6165 of constructors and destructors appropriately, and dispense with
6166 ctor_identifier, dtor_identifier, etc. */
6169 name_as_c_string (tree name, tree type, bool *free_p)
6173 /* Assume that we will not allocate memory. */
6175 /* Constructors and destructors are special. */
6176 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6179 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6180 /* For a destructor, add the '~'. */
6181 if (name == complete_dtor_identifier
6182 || name == base_dtor_identifier
6183 || name == deleting_dtor_identifier)
6185 pretty_name = concat ("~", pretty_name, NULL);
6186 /* Remember that we need to free the memory allocated. */
6190 else if (IDENTIFIER_TYPENAME_P (name))
6192 pretty_name = concat ("operator ",
6193 type_as_string_translate (TREE_TYPE (name),
6194 TFF_PLAIN_IDENTIFIER),
6196 /* Remember that we need to free the memory allocated. */
6200 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6205 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
6206 be set, upon return, to the function called. ARGS may be NULL.
6207 This may change ARGS. */
6210 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
6211 tree conversion_path, int flags,
6212 tree *fn_p, tsubst_flags_t complain)
6214 struct z_candidate *candidates = 0, *cand;
6215 tree explicit_targs = NULL_TREE;
6216 tree basetype = NULL_TREE;
6219 tree first_mem_arg = NULL_TREE;
6222 bool skip_first_for_error;
6223 VEC(tree,gc) *user_args;
6226 int template_only = 0;
6230 VEC(tree,gc) *orig_args = NULL;
6232 tree list = NULL_TREE;
6235 gcc_assert (instance != NULL_TREE);
6237 /* We don't know what function we're going to call, yet. */
6241 if (error_operand_p (instance)
6242 || !fns || error_operand_p (fns))
6243 return error_mark_node;
6245 if (!BASELINK_P (fns))
6247 if (complain & tf_error)
6248 error ("call to non-function %qD", fns);
6249 return error_mark_node;
6252 orig_instance = instance;
6255 /* Dismantle the baselink to collect all the information we need. */
6256 if (!conversion_path)
6257 conversion_path = BASELINK_BINFO (fns);
6258 access_binfo = BASELINK_ACCESS_BINFO (fns);
6259 optype = BASELINK_OPTYPE (fns);
6260 fns = BASELINK_FUNCTIONS (fns);
6261 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6263 explicit_targs = TREE_OPERAND (fns, 1);
6264 fns = TREE_OPERAND (fns, 0);
6267 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6268 || TREE_CODE (fns) == TEMPLATE_DECL
6269 || TREE_CODE (fns) == OVERLOAD);
6270 fn = get_first_fn (fns);
6271 name = DECL_NAME (fn);
6273 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6274 gcc_assert (CLASS_TYPE_P (basetype));
6276 if (processing_template_decl)
6278 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6279 instance = build_non_dependent_expr (instance);
6281 make_args_non_dependent (*args);
6284 user_args = args == NULL ? NULL : *args;
6285 /* Under DR 147 A::A() is an invalid constructor call,
6286 not a functional cast. */
6287 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
6289 if (! (complain & tf_error))
6290 return error_mark_node;
6292 permerror (input_location,
6293 "cannot call constructor %<%T::%D%> directly",
6295 permerror (input_location, " for a function-style cast, remove the "
6296 "redundant %<::%D%>", name);
6297 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
6302 /* Figure out whether to skip the first argument for the error
6303 message we will display to users if an error occurs. We don't
6304 want to display any compiler-generated arguments. The "this"
6305 pointer hasn't been added yet. However, we must remove the VTT
6306 pointer if this is a call to a base-class constructor or
6308 skip_first_for_error = false;
6309 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6311 /* Callers should explicitly indicate whether they want to construct
6312 the complete object or just the part without virtual bases. */
6313 gcc_assert (name != ctor_identifier);
6314 /* Similarly for destructors. */
6315 gcc_assert (name != dtor_identifier);
6316 /* Remove the VTT pointer, if present. */
6317 if ((name == base_ctor_identifier || name == base_dtor_identifier)
6318 && CLASSTYPE_VBASECLASSES (basetype))
6319 skip_first_for_error = true;
6322 /* Process the argument list. */
6323 if (args != NULL && *args != NULL)
6325 *args = resolve_args (*args);
6327 return error_mark_node;
6330 instance_ptr = build_this (instance);
6332 /* It's OK to call destructors and constructors on cv-qualified objects.
6333 Therefore, convert the INSTANCE_PTR to the unqualified type, if
6335 if (DECL_DESTRUCTOR_P (fn)
6336 || DECL_CONSTRUCTOR_P (fn))
6338 tree type = build_pointer_type (basetype);
6339 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6340 instance_ptr = build_nop (type, instance_ptr);
6342 if (DECL_DESTRUCTOR_P (fn))
6343 name = complete_dtor_identifier;
6345 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6346 initializer, not T({ }). If the type doesn't have a list ctor (or no
6347 viable list ctor), break apart the list into separate ctor args. */
6349 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6350 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6351 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
6353 gcc_assert (VEC_length (tree, *args) == 1);
6354 list = VEC_index (tree, *args, 0);
6356 if (TYPE_HAS_LIST_CTOR (basetype))
6357 flags |= LOOKUP_LIST_ONLY;
6362 first_mem_arg = instance_ptr;
6364 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6365 p = conversion_obstack_alloc (0);
6367 any_viable_p = false;
6370 add_candidates (fns, first_mem_arg, user_args, optype,
6371 explicit_targs, template_only, conversion_path,
6372 access_binfo, flags, &candidates);
6373 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6376 if (!any_viable_p && list)
6378 VEC(tree,gc) *list_args = ctor_to_vec (list);
6379 flags &= ~LOOKUP_LIST_ONLY;
6380 add_candidates (fns, first_mem_arg, list_args, optype,
6381 explicit_targs, template_only, conversion_path,
6382 access_binfo, flags, &candidates);
6383 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6388 if (complain & tf_error)
6390 if (!COMPLETE_TYPE_P (basetype))
6391 cxx_incomplete_type_error (instance_ptr, basetype);
6393 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
6394 basetype, optype, build_tree_list_vec (user_args),
6395 TREE_TYPE (TREE_TYPE (instance_ptr)));
6402 pretty_name = name_as_c_string (name, basetype, &free_p);
6403 arglist = build_tree_list_vec (user_args);
6404 if (skip_first_for_error)
6405 arglist = TREE_CHAIN (arglist);
6406 error ("no matching function for call to %<%T::%s(%A)%#V%>",
6407 basetype, pretty_name, arglist,
6408 TREE_TYPE (TREE_TYPE (instance_ptr)));
6412 print_z_candidates (candidates);
6414 call = error_mark_node;
6418 cand = tourney (candidates);
6425 if (complain & tf_error)
6427 pretty_name = name_as_c_string (name, basetype, &free_p);
6428 arglist = build_tree_list_vec (user_args);
6429 if (skip_first_for_error)
6430 arglist = TREE_CHAIN (arglist);
6431 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6433 print_z_candidates (candidates);
6437 call = error_mark_node;
6443 if (!(flags & LOOKUP_NONVIRTUAL)
6444 && DECL_PURE_VIRTUAL_P (fn)
6445 && instance == current_class_ref
6446 && (DECL_CONSTRUCTOR_P (current_function_decl)
6447 || DECL_DESTRUCTOR_P (current_function_decl))
6448 && (complain & tf_warning))
6449 /* This is not an error, it is runtime undefined
6451 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6452 "pure virtual %q#D called from constructor"
6453 : "pure virtual %q#D called from destructor"),
6456 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6457 && is_dummy_object (instance_ptr))
6459 if (complain & tf_error)
6460 error ("cannot call member function %qD without object",
6462 call = error_mark_node;
6466 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6467 && resolves_to_fixed_type_p (instance, 0))
6468 flags |= LOOKUP_NONVIRTUAL;
6469 /* Now we know what function is being called. */
6472 /* Build the actual CALL_EXPR. */
6473 call = build_over_call (cand, flags, complain);
6474 /* In an expression of the form `a->f()' where `f' turns
6475 out to be a static member function, `a' is
6476 none-the-less evaluated. */
6477 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6478 && !is_dummy_object (instance_ptr)
6479 && TREE_SIDE_EFFECTS (instance_ptr))
6480 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6481 instance_ptr, call);
6482 else if (call != error_mark_node
6483 && DECL_DESTRUCTOR_P (cand->fn)
6484 && !VOID_TYPE_P (TREE_TYPE (call)))
6485 /* An explicit call of the form "x->~X()" has type
6486 "void". However, on platforms where destructors
6487 return "this" (i.e., those where
6488 targetm.cxx.cdtor_returns_this is true), such calls
6489 will appear to have a return value of pointer type
6490 to the low-level call machinery. We do not want to
6491 change the low-level machinery, since we want to be
6492 able to optimize "delete f()" on such platforms as
6493 "operator delete(~X(f()))" (rather than generating
6494 "t = f(), ~X(t), operator delete (t)"). */
6495 call = build_nop (void_type_node, call);
6500 if (processing_template_decl && call != error_mark_node)
6502 bool cast_to_void = false;
6504 if (TREE_CODE (call) == COMPOUND_EXPR)
6505 call = TREE_OPERAND (call, 1);
6506 else if (TREE_CODE (call) == NOP_EXPR)
6508 cast_to_void = true;
6509 call = TREE_OPERAND (call, 0);
6511 if (TREE_CODE (call) == INDIRECT_REF)
6512 call = TREE_OPERAND (call, 0);
6513 call = (build_min_non_dep_call_vec
6515 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6516 orig_instance, orig_fns, NULL_TREE),
6518 call = convert_from_reference (call);
6520 call = build_nop (void_type_node, call);
6523 /* Free all the conversions we allocated. */
6524 obstack_free (&conversion_obstack, p);
6526 if (orig_args != NULL)
6527 release_tree_vector (orig_args);
6532 /* Returns true iff standard conversion sequence ICS1 is a proper
6533 subsequence of ICS2. */
6536 is_subseq (conversion *ics1, conversion *ics2)
6538 /* We can assume that a conversion of the same code
6539 between the same types indicates a subsequence since we only get
6540 here if the types we are converting from are the same. */
6542 while (ics1->kind == ck_rvalue
6543 || ics1->kind == ck_lvalue)
6544 ics1 = ics1->u.next;
6548 while (ics2->kind == ck_rvalue
6549 || ics2->kind == ck_lvalue)
6550 ics2 = ics2->u.next;
6552 if (ics2->kind == ck_user
6553 || ics2->kind == ck_ambig
6554 || ics2->kind == ck_identity)
6555 /* At this point, ICS1 cannot be a proper subsequence of
6556 ICS2. We can get a USER_CONV when we are comparing the
6557 second standard conversion sequence of two user conversion
6561 ics2 = ics2->u.next;
6563 if (ics2->kind == ics1->kind
6564 && same_type_p (ics2->type, ics1->type)
6565 && same_type_p (ics2->u.next->type,
6566 ics1->u.next->type))
6571 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
6572 be any _TYPE nodes. */
6575 is_properly_derived_from (tree derived, tree base)
6577 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6580 /* We only allow proper derivation here. The DERIVED_FROM_P macro
6581 considers every class derived from itself. */
6582 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6583 && DERIVED_FROM_P (base, derived));
6586 /* We build the ICS for an implicit object parameter as a pointer
6587 conversion sequence. However, such a sequence should be compared
6588 as if it were a reference conversion sequence. If ICS is the
6589 implicit conversion sequence for an implicit object parameter,
6590 modify it accordingly. */
6593 maybe_handle_implicit_object (conversion **ics)
6597 /* [over.match.funcs]
6599 For non-static member functions, the type of the
6600 implicit object parameter is "reference to cv X"
6601 where X is the class of which the function is a
6602 member and cv is the cv-qualification on the member
6603 function declaration. */
6604 conversion *t = *ics;
6605 tree reference_type;
6607 /* The `this' parameter is a pointer to a class type. Make the
6608 implicit conversion talk about a reference to that same class
6610 reference_type = TREE_TYPE (t->type);
6611 reference_type = build_reference_type (reference_type);
6613 if (t->kind == ck_qual)
6615 if (t->kind == ck_ptr)
6617 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6618 t = direct_reference_binding (reference_type, t);
6620 t->rvaluedness_matches_p = 0;
6625 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6626 and return the initial reference binding conversion. Otherwise,
6627 leave *ICS unchanged and return NULL. */
6630 maybe_handle_ref_bind (conversion **ics)
6632 if ((*ics)->kind == ck_ref_bind)
6634 conversion *old_ics = *ics;
6635 *ics = old_ics->u.next;
6636 (*ics)->user_conv_p = old_ics->user_conv_p;
6643 /* Compare two implicit conversion sequences according to the rules set out in
6644 [over.ics.rank]. Return values:
6646 1: ics1 is better than ics2
6647 -1: ics2 is better than ics1
6648 0: ics1 and ics2 are indistinguishable */
6651 compare_ics (conversion *ics1, conversion *ics2)
6657 tree deref_from_type1 = NULL_TREE;
6658 tree deref_from_type2 = NULL_TREE;
6659 tree deref_to_type1 = NULL_TREE;
6660 tree deref_to_type2 = NULL_TREE;
6661 conversion_rank rank1, rank2;
6663 /* REF_BINDING is nonzero if the result of the conversion sequence
6664 is a reference type. In that case REF_CONV is the reference
6665 binding conversion. */
6666 conversion *ref_conv1;
6667 conversion *ref_conv2;
6669 /* Handle implicit object parameters. */
6670 maybe_handle_implicit_object (&ics1);
6671 maybe_handle_implicit_object (&ics2);
6673 /* Handle reference parameters. */
6674 ref_conv1 = maybe_handle_ref_bind (&ics1);
6675 ref_conv2 = maybe_handle_ref_bind (&ics2);
6677 /* List-initialization sequence L1 is a better conversion sequence than
6678 list-initialization sequence L2 if L1 converts to
6679 std::initializer_list<X> for some X and L2 does not. */
6680 if (ics1->kind == ck_list && ics2->kind != ck_list)
6682 if (ics2->kind == ck_list && ics1->kind != ck_list)
6687 When comparing the basic forms of implicit conversion sequences (as
6688 defined in _over.best.ics_)
6690 --a standard conversion sequence (_over.ics.scs_) is a better
6691 conversion sequence than a user-defined conversion sequence
6692 or an ellipsis conversion sequence, and
6694 --a user-defined conversion sequence (_over.ics.user_) is a
6695 better conversion sequence than an ellipsis conversion sequence
6696 (_over.ics.ellipsis_). */
6697 rank1 = CONVERSION_RANK (ics1);
6698 rank2 = CONVERSION_RANK (ics2);
6702 else if (rank1 < rank2)
6705 if (rank1 == cr_bad)
6707 /* XXX Isn't this an extension? */
6708 /* Both ICS are bad. We try to make a decision based on what
6709 would have happened if they'd been good. */
6710 if (ics1->user_conv_p > ics2->user_conv_p
6711 || ics1->rank > ics2->rank)
6713 else if (ics1->user_conv_p < ics2->user_conv_p
6714 || ics1->rank < ics2->rank)
6717 /* We couldn't make up our minds; try to figure it out below. */
6720 if (ics1->ellipsis_p || ics1->kind == ck_list)
6721 /* Both conversions are ellipsis conversions or both are building a
6722 std::initializer_list. */
6725 /* User-defined conversion sequence U1 is a better conversion sequence
6726 than another user-defined conversion sequence U2 if they contain the
6727 same user-defined conversion operator or constructor and if the sec-
6728 ond standard conversion sequence of U1 is better than the second
6729 standard conversion sequence of U2. */
6731 if (ics1->user_conv_p)
6736 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
6737 if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6739 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
6740 if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6743 if (t1->cand->fn != t2->cand->fn)
6746 /* We can just fall through here, after setting up
6747 FROM_TYPE1 and FROM_TYPE2. */
6748 from_type1 = t1->type;
6749 from_type2 = t2->type;
6756 /* We're dealing with two standard conversion sequences.
6760 Standard conversion sequence S1 is a better conversion
6761 sequence than standard conversion sequence S2 if
6763 --S1 is a proper subsequence of S2 (comparing the conversion
6764 sequences in the canonical form defined by _over.ics.scs_,
6765 excluding any Lvalue Transformation; the identity
6766 conversion sequence is considered to be a subsequence of
6767 any non-identity conversion sequence */
6770 while (t1->kind != ck_identity)
6772 from_type1 = t1->type;
6775 while (t2->kind != ck_identity)
6777 from_type2 = t2->type;
6780 /* One sequence can only be a subsequence of the other if they start with
6781 the same type. They can start with different types when comparing the
6782 second standard conversion sequence in two user-defined conversion
6784 if (same_type_p (from_type1, from_type2))
6786 if (is_subseq (ics1, ics2))
6788 if (is_subseq (ics2, ics1))
6796 --the rank of S1 is better than the rank of S2 (by the rules
6799 Standard conversion sequences are ordered by their ranks: an Exact
6800 Match is a better conversion than a Promotion, which is a better
6801 conversion than a Conversion.
6803 Two conversion sequences with the same rank are indistinguishable
6804 unless one of the following rules applies:
6806 --A conversion that does not a convert a pointer, pointer to member,
6807 or std::nullptr_t to bool is better than one that does.
6809 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6810 so that we do not have to check it explicitly. */
6811 if (ics1->rank < ics2->rank)
6813 else if (ics2->rank < ics1->rank)
6816 to_type1 = ics1->type;
6817 to_type2 = ics2->type;
6819 /* A conversion from scalar arithmetic type to complex is worse than a
6820 conversion between scalar arithmetic types. */
6821 if (same_type_p (from_type1, from_type2)
6822 && ARITHMETIC_TYPE_P (from_type1)
6823 && ARITHMETIC_TYPE_P (to_type1)
6824 && ARITHMETIC_TYPE_P (to_type2)
6825 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6826 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6828 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6834 if (TYPE_PTR_P (from_type1)
6835 && TYPE_PTR_P (from_type2)
6836 && TYPE_PTR_P (to_type1)
6837 && TYPE_PTR_P (to_type2))
6839 deref_from_type1 = TREE_TYPE (from_type1);
6840 deref_from_type2 = TREE_TYPE (from_type2);
6841 deref_to_type1 = TREE_TYPE (to_type1);
6842 deref_to_type2 = TREE_TYPE (to_type2);
6844 /* The rules for pointers to members A::* are just like the rules
6845 for pointers A*, except opposite: if B is derived from A then
6846 A::* converts to B::*, not vice versa. For that reason, we
6847 switch the from_ and to_ variables here. */
6848 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6849 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6850 || (TYPE_PTRMEMFUNC_P (from_type1)
6851 && TYPE_PTRMEMFUNC_P (from_type2)
6852 && TYPE_PTRMEMFUNC_P (to_type1)
6853 && TYPE_PTRMEMFUNC_P (to_type2)))
6855 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6856 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6857 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6858 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6861 if (deref_from_type1 != NULL_TREE
6862 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6863 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6865 /* This was one of the pointer or pointer-like conversions.
6869 --If class B is derived directly or indirectly from class A,
6870 conversion of B* to A* is better than conversion of B* to
6871 void*, and conversion of A* to void* is better than
6872 conversion of B* to void*. */
6873 if (TREE_CODE (deref_to_type1) == VOID_TYPE
6874 && TREE_CODE (deref_to_type2) == VOID_TYPE)
6876 if (is_properly_derived_from (deref_from_type1,
6879 else if (is_properly_derived_from (deref_from_type2,
6883 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6884 || TREE_CODE (deref_to_type2) == VOID_TYPE)
6886 if (same_type_p (deref_from_type1, deref_from_type2))
6888 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6890 if (is_properly_derived_from (deref_from_type1,
6894 /* We know that DEREF_TO_TYPE1 is `void' here. */
6895 else if (is_properly_derived_from (deref_from_type1,
6900 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6901 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6905 --If class B is derived directly or indirectly from class A
6906 and class C is derived directly or indirectly from B,
6908 --conversion of C* to B* is better than conversion of C* to
6911 --conversion of B* to A* is better than conversion of C* to
6913 if (same_type_p (deref_from_type1, deref_from_type2))
6915 if (is_properly_derived_from (deref_to_type1,
6918 else if (is_properly_derived_from (deref_to_type2,
6922 else if (same_type_p (deref_to_type1, deref_to_type2))
6924 if (is_properly_derived_from (deref_from_type2,
6927 else if (is_properly_derived_from (deref_from_type1,
6933 else if (CLASS_TYPE_P (non_reference (from_type1))
6934 && same_type_p (from_type1, from_type2))
6936 tree from = non_reference (from_type1);
6940 --binding of an expression of type C to a reference of type
6941 B& is better than binding an expression of type C to a
6942 reference of type A&
6944 --conversion of C to B is better than conversion of C to A, */
6945 if (is_properly_derived_from (from, to_type1)
6946 && is_properly_derived_from (from, to_type2))
6948 if (is_properly_derived_from (to_type1, to_type2))
6950 else if (is_properly_derived_from (to_type2, to_type1))
6954 else if (CLASS_TYPE_P (non_reference (to_type1))
6955 && same_type_p (to_type1, to_type2))
6957 tree to = non_reference (to_type1);
6961 --binding of an expression of type B to a reference of type
6962 A& is better than binding an expression of type C to a
6963 reference of type A&,
6965 --conversion of B to A is better than conversion of C to A */
6966 if (is_properly_derived_from (from_type1, to)
6967 && is_properly_derived_from (from_type2, to))
6969 if (is_properly_derived_from (from_type2, from_type1))
6971 else if (is_properly_derived_from (from_type1, from_type2))
6978 --S1 and S2 differ only in their qualification conversion and yield
6979 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6980 qualification signature of type T1 is a proper subset of the cv-
6981 qualification signature of type T2 */
6982 if (ics1->kind == ck_qual
6983 && ics2->kind == ck_qual
6984 && same_type_p (from_type1, from_type2))
6986 int result = comp_cv_qual_signature (to_type1, to_type2);
6993 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6994 to an implicit object parameter, and either S1 binds an lvalue reference
6995 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6996 reference to an rvalue and S2 binds an lvalue reference
6997 (C++0x draft standard, 13.3.3.2)
6999 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
7000 types to which the references refer are the same type except for
7001 top-level cv-qualifiers, and the type to which the reference
7002 initialized by S2 refers is more cv-qualified than the type to
7003 which the reference initialized by S1 refers */
7005 if (ref_conv1 && ref_conv2)
7007 if (!ref_conv1->this_p && !ref_conv2->this_p
7008 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7009 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7011 if (ref_conv1->rvaluedness_matches_p)
7013 if (ref_conv2->rvaluedness_matches_p)
7017 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7018 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7019 TREE_TYPE (ref_conv1->type));
7022 /* Neither conversion sequence is better than the other. */
7026 /* The source type for this standard conversion sequence. */
7029 source_type (conversion *t)
7031 for (;; t = t->u.next)
7033 if (t->kind == ck_user
7034 || t->kind == ck_ambig
7035 || t->kind == ck_identity)
7041 /* Note a warning about preferring WINNER to LOSER. We do this by storing
7042 a pointer to LOSER and re-running joust to produce the warning if WINNER
7043 is actually used. */
7046 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7048 candidate_warning *cw = (candidate_warning *)
7049 conversion_obstack_alloc (sizeof (candidate_warning));
7051 cw->next = winner->warnings;
7052 winner->warnings = cw;
7055 /* Compare two candidates for overloading as described in
7056 [over.match.best]. Return values:
7058 1: cand1 is better than cand2
7059 -1: cand2 is better than cand1
7060 0: cand1 and cand2 are indistinguishable */
7063 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7066 int off1 = 0, off2 = 0;
7070 /* Candidates that involve bad conversions are always worse than those
7072 if (cand1->viable > cand2->viable)
7074 if (cand1->viable < cand2->viable)
7077 /* If we have two pseudo-candidates for conversions to the same type,
7078 or two candidates for the same function, arbitrarily pick one. */
7079 if (cand1->fn == cand2->fn
7080 && (IS_TYPE_OR_DECL_P (cand1->fn)))
7083 /* a viable function F1
7084 is defined to be a better function than another viable function F2 if
7085 for all arguments i, ICSi(F1) is not a worse conversion sequence than
7086 ICSi(F2), and then */
7088 /* for some argument j, ICSj(F1) is a better conversion sequence than
7091 /* For comparing static and non-static member functions, we ignore
7092 the implicit object parameter of the non-static function. The
7093 standard says to pretend that the static function has an object
7094 parm, but that won't work with operator overloading. */
7095 len = cand1->num_convs;
7096 if (len != cand2->num_convs)
7098 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7099 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7101 gcc_assert (static_1 != static_2);
7112 for (i = 0; i < len; ++i)
7114 conversion *t1 = cand1->convs[i + off1];
7115 conversion *t2 = cand2->convs[i + off2];
7116 int comp = compare_ics (t1, t2);
7121 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7122 == cr_std + cr_promotion)
7123 && t1->kind == ck_std
7124 && t2->kind == ck_std
7125 && TREE_CODE (t1->type) == INTEGER_TYPE
7126 && TREE_CODE (t2->type) == INTEGER_TYPE
7127 && (TYPE_PRECISION (t1->type)
7128 == TYPE_PRECISION (t2->type))
7129 && (TYPE_UNSIGNED (t1->u.next->type)
7130 || (TREE_CODE (t1->u.next->type)
7133 tree type = t1->u.next->type;
7135 struct z_candidate *w, *l;
7137 type1 = t1->type, type2 = t2->type,
7138 w = cand1, l = cand2;
7140 type1 = t2->type, type2 = t1->type,
7141 w = cand2, l = cand1;
7145 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7146 type, type1, type2);
7147 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
7153 if (winner && comp != winner)
7162 /* warn about confusing overload resolution for user-defined conversions,
7163 either between a constructor and a conversion op, or between two
7165 if (winner && warn_conversion && cand1->second_conv
7166 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7167 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7169 struct z_candidate *w, *l;
7170 bool give_warning = false;
7173 w = cand1, l = cand2;
7175 w = cand2, l = cand1;
7177 /* We don't want to complain about `X::operator T1 ()'
7178 beating `X::operator T2 () const', when T2 is a no less
7179 cv-qualified version of T1. */
7180 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7181 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7183 tree t = TREE_TYPE (TREE_TYPE (l->fn));
7184 tree f = TREE_TYPE (TREE_TYPE (w->fn));
7186 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7191 if (!comp_ptr_ttypes (t, f))
7192 give_warning = true;
7195 give_warning = true;
7201 tree source = source_type (w->convs[0]);
7202 if (! DECL_CONSTRUCTOR_P (w->fn))
7203 source = TREE_TYPE (source);
7204 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7205 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
7206 source, w->second_conv->type))
7208 inform (input_location, " because conversion sequence for the argument is better");
7219 F1 is a non-template function and F2 is a template function
7222 if (!cand1->template_decl && cand2->template_decl)
7224 else if (cand1->template_decl && !cand2->template_decl)
7228 F1 and F2 are template functions and the function template for F1 is
7229 more specialized than the template for F2 according to the partial
7232 if (cand1->template_decl && cand2->template_decl)
7234 winner = more_specialized_fn
7235 (TI_TEMPLATE (cand1->template_decl),
7236 TI_TEMPLATE (cand2->template_decl),
7237 /* [temp.func.order]: The presence of unused ellipsis and default
7238 arguments has no effect on the partial ordering of function
7239 templates. add_function_candidate() will not have
7240 counted the "this" argument for constructors. */
7241 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
7247 the context is an initialization by user-defined conversion (see
7248 _dcl.init_ and _over.match.user_) and the standard conversion
7249 sequence from the return type of F1 to the destination type (i.e.,
7250 the type of the entity being initialized) is a better conversion
7251 sequence than the standard conversion sequence from the return type
7252 of F2 to the destination type. */
7254 if (cand1->second_conv)
7256 winner = compare_ics (cand1->second_conv, cand2->second_conv);
7261 /* Check whether we can discard a builtin candidate, either because we
7262 have two identical ones or matching builtin and non-builtin candidates.
7264 (Pedantically in the latter case the builtin which matched the user
7265 function should not be added to the overload set, but we spot it here.
7268 ... the builtin candidates include ...
7269 - do not have the same parameter type list as any non-template
7270 non-member candidate. */
7272 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7273 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7275 for (i = 0; i < len; ++i)
7276 if (!same_type_p (cand1->convs[i]->type,
7277 cand2->convs[i]->type))
7279 if (i == cand1->num_convs)
7281 if (cand1->fn == cand2->fn)
7282 /* Two built-in candidates; arbitrarily pick one. */
7284 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7285 /* cand1 is built-in; prefer cand2. */
7288 /* cand2 is built-in; prefer cand1. */
7293 /* If the two function declarations represent the same function (this can
7294 happen with declarations in multiple scopes and arg-dependent lookup),
7295 arbitrarily choose one. But first make sure the default args we're
7297 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7298 && equal_functions (cand1->fn, cand2->fn))
7300 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7301 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7303 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7305 for (i = 0; i < len; ++i)
7307 /* Don't crash if the fn is variadic. */
7310 parms1 = TREE_CHAIN (parms1);
7311 parms2 = TREE_CHAIN (parms2);
7315 parms1 = TREE_CHAIN (parms1);
7317 parms2 = TREE_CHAIN (parms2);
7321 if (!cp_tree_equal (TREE_PURPOSE (parms1),
7322 TREE_PURPOSE (parms2)))
7326 permerror (input_location, "default argument mismatch in "
7327 "overload resolution");
7328 inform (input_location,
7329 " candidate 1: %q+#F", cand1->fn);
7330 inform (input_location,
7331 " candidate 2: %q+#F", cand2->fn);
7334 add_warning (cand1, cand2);
7337 parms1 = TREE_CHAIN (parms1);
7338 parms2 = TREE_CHAIN (parms2);
7346 /* Extension: If the worst conversion for one candidate is worse than the
7347 worst conversion for the other, take the first. */
7350 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7351 struct z_candidate *w = 0, *l = 0;
7353 for (i = 0; i < len; ++i)
7355 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7356 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7357 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7358 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7361 winner = 1, w = cand1, l = cand2;
7363 winner = -1, w = cand2, l = cand1;
7368 pedwarn (input_location, 0,
7369 "ISO C++ says that these are ambiguous, even "
7370 "though the worst conversion for the first is better than "
7371 "the worst conversion for the second:");
7372 print_z_candidate (_("candidate 1:"), w);
7373 print_z_candidate (_("candidate 2:"), l);
7381 gcc_assert (!winner);
7385 /* Given a list of candidates for overloading, find the best one, if any.
7386 This algorithm has a worst case of O(2n) (winner is last), and a best
7387 case of O(n/2) (totally ambiguous); much better than a sorting
7390 static struct z_candidate *
7391 tourney (struct z_candidate *candidates)
7393 struct z_candidate *champ = candidates, *challenger;
7395 int champ_compared_to_predecessor = 0;
7397 /* Walk through the list once, comparing each current champ to the next
7398 candidate, knocking out a candidate or two with each comparison. */
7400 for (challenger = champ->next; challenger; )
7402 fate = joust (champ, challenger, 0);
7404 challenger = challenger->next;
7409 champ = challenger->next;
7412 champ_compared_to_predecessor = 0;
7417 champ_compared_to_predecessor = 1;
7420 challenger = champ->next;
7424 /* Make sure the champ is better than all the candidates it hasn't yet
7425 been compared to. */
7427 for (challenger = candidates;
7429 && !(champ_compared_to_predecessor && challenger->next == champ);
7430 challenger = challenger->next)
7432 fate = joust (champ, challenger, 0);
7440 /* Returns nonzero if things of type FROM can be converted to TO. */
7443 can_convert (tree to, tree from)
7445 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
7448 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
7451 can_convert_arg (tree to, tree from, tree arg, int flags)
7457 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7458 p = conversion_obstack_alloc (0);
7460 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7462 ok_p = (t && !t->bad_p);
7464 /* Free all the conversions we allocated. */
7465 obstack_free (&conversion_obstack, p);
7470 /* Like can_convert_arg, but allows dubious conversions as well. */
7473 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
7478 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7479 p = conversion_obstack_alloc (0);
7480 /* Try to perform the conversion. */
7481 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7483 /* Free all the conversions we allocated. */
7484 obstack_free (&conversion_obstack, p);
7489 /* Convert EXPR to TYPE. Return the converted expression.
7491 Note that we allow bad conversions here because by the time we get to
7492 this point we are committed to doing the conversion. If we end up
7493 doing a bad conversion, convert_like will complain. */
7496 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7501 if (error_operand_p (expr))
7502 return error_mark_node;
7504 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7505 p = conversion_obstack_alloc (0);
7507 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7513 if (complain & tf_error)
7515 /* If expr has unknown type, then it is an overloaded function.
7516 Call instantiate_type to get good error messages. */
7517 if (TREE_TYPE (expr) == unknown_type_node)
7518 instantiate_type (type, expr, complain);
7519 else if (invalid_nonstatic_memfn_p (expr, complain))
7520 /* We gave an error. */;
7522 error ("could not convert %qE to %qT", expr, type);
7524 expr = error_mark_node;
7526 else if (processing_template_decl)
7528 /* In a template, we are only concerned about determining the
7529 type of non-dependent expressions, so we do not have to
7530 perform the actual conversion. */
7531 if (TREE_TYPE (expr) != type)
7532 expr = build_nop (type, expr);
7535 expr = convert_like (conv, expr, complain);
7537 /* Free all the conversions we allocated. */
7538 obstack_free (&conversion_obstack, p);
7544 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7546 return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
7549 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7550 permitted. If the conversion is valid, the converted expression is
7551 returned. Otherwise, NULL_TREE is returned, except in the case
7552 that TYPE is a class type; in that case, an error is issued. If
7553 C_CAST_P is true, then this direction initialization is taking
7554 place as part of a static_cast being attempted as part of a C-style
7558 perform_direct_initialization_if_possible (tree type,
7561 tsubst_flags_t complain)
7566 if (type == error_mark_node || error_operand_p (expr))
7567 return error_mark_node;
7570 If the destination type is a (possibly cv-qualified) class type:
7572 -- If the initialization is direct-initialization ...,
7573 constructors are considered. ... If no constructor applies, or
7574 the overload resolution is ambiguous, the initialization is
7576 if (CLASS_TYPE_P (type))
7578 VEC(tree,gc) *args = make_tree_vector_single (expr);
7579 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7580 &args, type, LOOKUP_NORMAL, complain);
7581 release_tree_vector (args);
7582 return build_cplus_new (type, expr);
7585 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7586 p = conversion_obstack_alloc (0);
7588 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7591 if (!conv || conv->bad_p)
7594 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7595 /*issue_conversion_warnings=*/false,
7599 /* Free all the conversions we allocated. */
7600 obstack_free (&conversion_obstack, p);
7605 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
7606 is being bound to a temporary. Create and return a new VAR_DECL
7607 with the indicated TYPE; this variable will store the value to
7608 which the reference is bound. */
7611 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7615 /* Create the variable. */
7616 var = create_temporary_var (type);
7618 /* Register the variable. */
7619 if (TREE_STATIC (decl))
7621 /* Namespace-scope or local static; give it a mangled name. */
7624 TREE_STATIC (var) = 1;
7625 name = mangle_ref_init_variable (decl);
7626 DECL_NAME (var) = name;
7627 SET_DECL_ASSEMBLER_NAME (var, name);
7628 var = pushdecl_top_level (var);
7631 /* Create a new cleanup level if necessary. */
7632 maybe_push_cleanup_level (type);
7637 /* EXPR is the initializer for a variable DECL of reference or
7638 std::initializer_list type. Create, push and return a new VAR_DECL
7639 for the initializer so that it will live as long as DECL. Any
7640 cleanup for the new variable is returned through CLEANUP, and the
7641 code to initialize the new variable is returned through INITP. */
7644 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7650 /* Create the temporary variable. */
7651 type = TREE_TYPE (expr);
7652 var = make_temporary_var_for_ref_to_temp (decl, type);
7653 layout_decl (var, 0);
7654 /* If the rvalue is the result of a function call it will be
7655 a TARGET_EXPR. If it is some other construct (such as a
7656 member access expression where the underlying object is
7657 itself the result of a function call), turn it into a
7658 TARGET_EXPR here. It is important that EXPR be a
7659 TARGET_EXPR below since otherwise the INIT_EXPR will
7660 attempt to make a bitwise copy of EXPR to initialize
7662 if (TREE_CODE (expr) != TARGET_EXPR)
7663 expr = get_target_expr (expr);
7664 /* Create the INIT_EXPR that will initialize the temporary
7666 init = build2 (INIT_EXPR, type, var, expr);
7667 if (at_function_scope_p ())
7669 add_decl_expr (var);
7671 if (TREE_STATIC (var))
7672 init = add_stmt_to_compound (init, register_dtor_fn (var));
7674 *cleanup = cxx_maybe_build_cleanup (var);
7676 /* We must be careful to destroy the temporary only
7677 after its initialization has taken place. If the
7678 initialization throws an exception, then the
7679 destructor should not be run. We cannot simply
7680 transform INIT into something like:
7682 (INIT, ({ CLEANUP_STMT; }))
7684 because emit_local_var always treats the
7685 initializer as a full-expression. Thus, the
7686 destructor would run too early; it would run at the
7687 end of initializing the reference variable, rather
7688 than at the end of the block enclosing the
7691 The solution is to pass back a cleanup expression
7692 which the caller is responsible for attaching to
7693 the statement tree. */
7697 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7698 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7699 static_aggregates = tree_cons (NULL_TREE, var,
7707 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7708 initializing a variable of that TYPE. If DECL is non-NULL, it is
7709 the VAR_DECL being initialized with the EXPR. (In that case, the
7710 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
7711 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
7712 return, if *CLEANUP is no longer NULL, it will be an expression
7713 that should be pushed as a cleanup after the returned expression
7714 is used to initialize DECL.
7716 Return the converted expression. */
7719 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
7720 tsubst_flags_t complain)
7725 if (type == error_mark_node || error_operand_p (expr))
7726 return error_mark_node;
7728 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7729 p = conversion_obstack_alloc (0);
7731 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7733 if (!conv || conv->bad_p)
7735 if (complain & tf_error)
7737 if (!CP_TYPE_CONST_P (TREE_TYPE (type))
7738 && !TYPE_REF_IS_RVALUE (type)
7739 && !real_lvalue_p (expr))
7740 error ("invalid initialization of non-const reference of "
7741 "type %qT from an rvalue of type %qT",
7742 type, TREE_TYPE (expr));
7744 error ("invalid initialization of reference of type "
7745 "%qT from expression of type %qT", type,
7748 return error_mark_node;
7751 /* If DECL is non-NULL, then this special rule applies:
7755 The temporary to which the reference is bound or the temporary
7756 that is the complete object to which the reference is bound
7757 persists for the lifetime of the reference.
7759 The temporaries created during the evaluation of the expression
7760 initializing the reference, except the temporary to which the
7761 reference is bound, are destroyed at the end of the
7762 full-expression in which they are created.
7764 In that case, we store the converted expression into a new
7765 VAR_DECL in a new scope.
7767 However, we want to be careful not to create temporaries when
7768 they are not required. For example, given:
7771 struct D : public B {};
7775 there is no need to copy the return value from "f"; we can just
7776 extend its lifetime. Similarly, given:
7779 struct T { operator S(); };
7783 we can extend the lifetime of the return value of the conversion
7785 gcc_assert (conv->kind == ck_ref_bind);
7789 tree base_conv_type;
7791 /* Skip over the REF_BIND. */
7792 conv = conv->u.next;
7793 /* If the next conversion is a BASE_CONV, skip that too -- but
7794 remember that the conversion was required. */
7795 if (conv->kind == ck_base)
7797 base_conv_type = conv->type;
7798 conv = conv->u.next;
7801 base_conv_type = NULL_TREE;
7802 /* Perform the remainder of the conversion. */
7803 expr = convert_like_real (conv, expr,
7804 /*fn=*/NULL_TREE, /*argnum=*/0,
7806 /*issue_conversion_warnings=*/true,
7808 tf_warning_or_error);
7809 if (error_operand_p (expr))
7810 expr = error_mark_node;
7813 if (!lvalue_or_rvalue_with_address_p (expr))
7816 var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7817 /* Use its address to initialize the reference variable. */
7818 expr = build_address (var);
7820 expr = convert_to_base (expr,
7821 build_pointer_type (base_conv_type),
7822 /*check_access=*/true,
7823 /*nonnull=*/true, complain);
7824 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7827 /* Take the address of EXPR. */
7828 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7829 /* If a BASE_CONV was required, perform it now. */
7831 expr = (perform_implicit_conversion
7832 (build_pointer_type (base_conv_type), expr,
7833 tf_warning_or_error));
7834 expr = build_nop (type, expr);
7838 /* Perform the conversion. */
7839 expr = convert_like (conv, expr, tf_warning_or_error);
7841 /* Free all the conversions we allocated. */
7842 obstack_free (&conversion_obstack, p);
7847 /* Returns true iff TYPE is some variant of std::initializer_list. */
7850 is_std_init_list (tree type)
7852 return (CLASS_TYPE_P (type)
7853 && CP_TYPE_CONTEXT (type) == std_node
7854 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7857 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7858 will accept an argument list of a single std::initializer_list<T>. */
7861 is_list_ctor (tree decl)
7863 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7866 if (!args || args == void_list_node)
7869 arg = non_reference (TREE_VALUE (args));
7870 if (!is_std_init_list (arg))
7873 args = TREE_CHAIN (args);
7875 if (args && args != void_list_node && !TREE_PURPOSE (args))
7876 /* There are more non-defaulted parms. */
7882 #include "gt-cp-call.h"