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 = 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)
1621 = build_qualified_type (ctype,
1622 TYPE_QUALS (TREE_TYPE (parmtype)));
1623 parmtype = build_pointer_type (parmtype);
1626 if (ctype && i == 0 && DECL_COPY_CONSTRUCTOR_P (fn)
1629 /* Hack: Direct-initialize copy parm (i.e. suppress
1630 LOOKUP_ONLYCONVERTING) to make explicit conversion ops
1631 work. See also reference_binding. */
1632 lflags |= LOOKUP_COPY_PARM;
1633 if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1634 lflags |= LOOKUP_NO_CONVERSION;
1637 lflags |= LOOKUP_ONLYCONVERTING;
1639 t = implicit_conversion (parmtype, argtype, arg,
1640 /*c_cast_p=*/false, lflags);
1644 t = build_identity_conv (argtype, arg);
1645 t->ellipsis_p = true;
1662 parmnode = TREE_CHAIN (parmnode);
1666 return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
1667 access_path, conversion_path, viable);
1670 /* Create an overload candidate for the conversion function FN which will
1671 be invoked for expression OBJ, producing a pointer-to-function which
1672 will in turn be called with the argument list FIRST_ARG/ARGLIST,
1673 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
1674 passed on to implicit_conversion.
1676 Actually, we don't really care about FN; we care about the type it
1677 converts to. There may be multiple conversion functions that will
1678 convert to that type, and we rely on build_user_type_conversion_1 to
1679 choose the best one; so when we create our candidate, we record the type
1680 instead of the function. */
1682 static struct z_candidate *
1683 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1684 tree first_arg, const VEC(tree,gc) *arglist,
1685 tree access_path, tree conversion_path)
1687 tree totype = TREE_TYPE (TREE_TYPE (fn));
1688 int i, len, viable, flags;
1689 tree parmlist, parmnode;
1692 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1693 parmlist = TREE_TYPE (parmlist);
1694 parmlist = TYPE_ARG_TYPES (parmlist);
1696 len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
1697 convs = alloc_conversions (len);
1698 parmnode = parmlist;
1700 flags = LOOKUP_IMPLICIT;
1702 /* Don't bother looking up the same type twice. */
1703 if (*candidates && (*candidates)->fn == totype)
1706 for (i = 0; i < len; ++i)
1713 else if (i == 1 && first_arg != NULL_TREE)
1716 arg = VEC_index (tree, arglist,
1717 i - (first_arg != NULL_TREE ? 1 : 0) - 1);
1718 argtype = lvalue_type (arg);
1721 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1723 else if (parmnode == void_list_node)
1726 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1727 /*c_cast_p=*/false, flags);
1730 t = build_identity_conv (argtype, arg);
1731 t->ellipsis_p = true;
1745 parmnode = TREE_CHAIN (parmnode);
1751 if (!sufficient_parms_p (parmnode))
1754 return add_candidate (candidates, totype, first_arg, arglist, len, convs,
1755 access_path, conversion_path, viable);
1759 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1760 tree type1, tree type2, tree *args, tree *argtypes,
1772 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1773 convs = alloc_conversions (num_convs);
1775 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
1776 conversion ops are allowed. We handle that here by just checking for
1777 boolean_type_node because other operators don't ask for it. COND_EXPR
1778 also does contextual conversion to bool for the first operand, but we
1779 handle that in build_conditional_expr, and type1 here is operand 2. */
1780 if (type1 != boolean_type_node)
1781 flags |= LOOKUP_ONLYCONVERTING;
1783 for (i = 0; i < 2; ++i)
1788 t = implicit_conversion (types[i], argtypes[i], args[i],
1789 /*c_cast_p=*/false, flags);
1793 /* We need something for printing the candidate. */
1794 t = build_identity_conv (types[i], NULL_TREE);
1801 /* For COND_EXPR we rearranged the arguments; undo that now. */
1804 convs[2] = convs[1];
1805 convs[1] = convs[0];
1806 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1807 /*c_cast_p=*/false, flags);
1814 add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
1816 /*access_path=*/NULL_TREE,
1817 /*conversion_path=*/NULL_TREE,
1822 is_complete (tree t)
1824 return COMPLETE_TYPE_P (complete_type (t));
1827 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1830 promoted_arithmetic_type_p (tree type)
1834 In this section, the term promoted integral type is used to refer
1835 to those integral types which are preserved by integral promotion
1836 (including e.g. int and long but excluding e.g. char).
1837 Similarly, the term promoted arithmetic type refers to promoted
1838 integral types plus floating types. */
1839 return ((CP_INTEGRAL_TYPE_P (type)
1840 && same_type_p (type_promotes_to (type), type))
1841 || TREE_CODE (type) == REAL_TYPE);
1844 /* Create any builtin operator overload candidates for the operator in
1845 question given the converted operand types TYPE1 and TYPE2. The other
1846 args are passed through from add_builtin_candidates to
1847 build_builtin_candidate.
1849 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1850 If CODE is requires candidates operands of the same type of the kind
1851 of which TYPE1 and TYPE2 are, we add both candidates
1852 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1855 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1856 enum tree_code code2, tree fnname, tree type1,
1857 tree type2, tree *args, tree *argtypes, int flags)
1861 case POSTINCREMENT_EXPR:
1862 case POSTDECREMENT_EXPR:
1863 args[1] = integer_zero_node;
1864 type2 = integer_type_node;
1873 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1874 and VQ is either volatile or empty, there exist candidate operator
1875 functions of the form
1876 VQ T& operator++(VQ T&);
1877 T operator++(VQ T&, int);
1878 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1879 type other than bool, and VQ is either volatile or empty, there exist
1880 candidate operator functions of the form
1881 VQ T& operator--(VQ T&);
1882 T operator--(VQ T&, int);
1883 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1884 complete object type, and VQ is either volatile or empty, there exist
1885 candidate operator functions of the form
1886 T*VQ& operator++(T*VQ&);
1887 T*VQ& operator--(T*VQ&);
1888 T* operator++(T*VQ&, int);
1889 T* operator--(T*VQ&, int); */
1891 case POSTDECREMENT_EXPR:
1892 case PREDECREMENT_EXPR:
1893 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1895 case POSTINCREMENT_EXPR:
1896 case PREINCREMENT_EXPR:
1897 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1899 type1 = build_reference_type (type1);
1904 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1905 exist candidate operator functions of the form
1909 8 For every function type T, there exist candidate operator functions of
1911 T& operator*(T*); */
1914 if (TREE_CODE (type1) == POINTER_TYPE
1915 && (TYPE_PTROB_P (type1)
1916 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1920 /* 9 For every type T, there exist candidate operator functions of the form
1923 10For every promoted arithmetic type T, there exist candidate operator
1924 functions of the form
1928 case UNARY_PLUS_EXPR: /* unary + */
1929 if (TREE_CODE (type1) == POINTER_TYPE)
1932 if (ARITHMETIC_TYPE_P (type1))
1936 /* 11For every promoted integral type T, there exist candidate operator
1937 functions of the form
1941 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
1945 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1946 is the same type as C2 or is a derived class of C2, T is a complete
1947 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1948 there exist candidate operator functions of the form
1949 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1950 where CV12 is the union of CV1 and CV2. */
1953 if (TREE_CODE (type1) == POINTER_TYPE
1954 && TYPE_PTR_TO_MEMBER_P (type2))
1956 tree c1 = TREE_TYPE (type1);
1957 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1959 if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
1960 && (TYPE_PTRMEMFUNC_P (type2)
1961 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1966 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1967 didate operator functions of the form
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 bool operator!=(L, R);
1978 where LR is the result of the usual arithmetic conversions between
1981 14For every pair of types T and I, where T is a cv-qualified or cv-
1982 unqualified complete object type and I is a promoted integral type,
1983 there exist candidate operator functions of the form
1984 T* operator+(T*, I);
1985 T& operator[](T*, I);
1986 T* operator-(T*, I);
1987 T* operator+(I, T*);
1988 T& operator[](I, T*);
1990 15For every T, where T is a pointer to complete object type, there exist
1991 candidate operator functions of the form112)
1992 ptrdiff_t operator-(T, T);
1994 16For every pointer or enumeration type T, there exist candidate operator
1995 functions of the form
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);
2001 bool operator!=(T, T);
2003 17For every pointer to member type T, there exist candidate operator
2004 functions of the form
2005 bool operator==(T, T);
2006 bool operator!=(T, T); */
2009 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2011 if (TYPE_PTROB_P (type1)
2012 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2014 type2 = ptrdiff_type_node;
2018 case TRUNC_DIV_EXPR:
2019 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2025 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2026 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2028 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2033 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2045 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2047 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2049 if (TREE_CODE (type1) == ENUMERAL_TYPE
2050 && TREE_CODE (type2) == ENUMERAL_TYPE)
2052 if (TYPE_PTR_P (type1)
2053 && null_ptr_cst_p (args[1])
2054 && !uses_template_parms (type1))
2059 if (null_ptr_cst_p (args[0])
2060 && TYPE_PTR_P (type2)
2061 && !uses_template_parms (type2))
2069 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2072 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2074 type1 = ptrdiff_type_node;
2077 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2079 type2 = ptrdiff_type_node;
2084 /* 18For every pair of promoted integral types L and R, there exist candi-
2085 date operator functions of the form
2092 where LR is the result of the usual arithmetic conversions between
2095 case TRUNC_MOD_EXPR:
2101 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2105 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
2106 type, VQ is either volatile or empty, and R is a promoted arithmetic
2107 type, there exist candidate operator functions of the form
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);
2112 VQ L& operator-=(VQ L&, R);
2114 20For every pair T, VQ), where T is any type and VQ is either volatile
2115 or empty, there exist candidate operator functions of the form
2116 T*VQ& operator=(T*VQ&, T*);
2118 21For every pair T, VQ), where T is a pointer to member type and VQ is
2119 either volatile or empty, there exist candidate operator functions of
2121 VQ T& operator=(VQ T&, T);
2123 22For every triple T, VQ, I), where T is a cv-qualified or cv-
2124 unqualified complete object type, VQ is either volatile or empty, and
2125 I is a promoted integral type, there exist candidate operator func-
2127 T*VQ& operator+=(T*VQ&, I);
2128 T*VQ& operator-=(T*VQ&, I);
2130 23For every triple L, VQ, R), where L is an integral or enumeration
2131 type, VQ is either volatile or empty, and R is a promoted integral
2132 type, there exist candidate operator functions of the form
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);
2139 VQ L& operator|=(VQ L&, R); */
2146 if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2148 type2 = ptrdiff_type_node;
2152 case TRUNC_DIV_EXPR:
2153 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2157 case TRUNC_MOD_EXPR:
2163 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2168 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2170 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2171 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2172 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2173 || ((TYPE_PTRMEMFUNC_P (type1)
2174 || TREE_CODE (type1) == POINTER_TYPE)
2175 && null_ptr_cst_p (args[1])))
2185 type1 = build_reference_type (type1);
2191 For every pair of promoted arithmetic types L and R, there
2192 exist candidate operator functions of the form
2194 LR operator?(bool, L, R);
2196 where LR is the result of the usual arithmetic conversions
2197 between types L and R.
2199 For every type T, where T is a pointer or pointer-to-member
2200 type, there exist candidate operator functions of the form T
2201 operator?(bool, T, T); */
2203 if (promoted_arithmetic_type_p (type1)
2204 && promoted_arithmetic_type_p (type2))
2208 /* Otherwise, the types should be pointers. */
2209 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2210 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2213 /* We don't check that the two types are the same; the logic
2214 below will actually create two candidates; one in which both
2215 parameter types are TYPE1, and one in which both parameter
2223 /* If we're dealing with two pointer types or two enumeral types,
2224 we need candidates for both of them. */
2225 if (type2 && !same_type_p (type1, type2)
2226 && TREE_CODE (type1) == TREE_CODE (type2)
2227 && (TREE_CODE (type1) == REFERENCE_TYPE
2228 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2229 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2230 || TYPE_PTRMEMFUNC_P (type1)
2231 || MAYBE_CLASS_TYPE_P (type1)
2232 || TREE_CODE (type1) == ENUMERAL_TYPE))
2234 build_builtin_candidate
2235 (candidates, fnname, type1, type1, args, argtypes, flags);
2236 build_builtin_candidate
2237 (candidates, fnname, type2, type2, args, argtypes, flags);
2241 build_builtin_candidate
2242 (candidates, fnname, type1, type2, args, argtypes, flags);
2246 type_decays_to (tree type)
2248 if (TREE_CODE (type) == ARRAY_TYPE)
2249 return build_pointer_type (TREE_TYPE (type));
2250 if (TREE_CODE (type) == FUNCTION_TYPE)
2251 return build_pointer_type (type);
2252 if (!MAYBE_CLASS_TYPE_P (type))
2253 type = cv_unqualified (type);
2257 /* There are three conditions of builtin candidates:
2259 1) bool-taking candidates. These are the same regardless of the input.
2260 2) pointer-pair taking candidates. These are generated for each type
2261 one of the input types converts to.
2262 3) arithmetic candidates. According to the standard, we should generate
2263 all of these, but I'm trying not to...
2265 Here we generate a superset of the possible candidates for this particular
2266 case. That is a subset of the full set the standard defines, plus some
2267 other cases which the standard disallows. add_builtin_candidate will
2268 filter out the invalid set. */
2271 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2272 enum tree_code code2, tree fnname, tree *args,
2277 tree type, argtypes[3];
2278 /* TYPES[i] is the set of possible builtin-operator parameter types
2279 we will consider for the Ith argument. These are represented as
2280 a TREE_LIST; the TREE_VALUE of each node is the potential
2284 for (i = 0; i < 3; ++i)
2287 argtypes[i] = unlowered_expr_type (args[i]);
2289 argtypes[i] = NULL_TREE;
2294 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2295 and VQ is either volatile or empty, there exist candidate operator
2296 functions of the form
2297 VQ T& operator++(VQ T&); */
2299 case POSTINCREMENT_EXPR:
2300 case PREINCREMENT_EXPR:
2301 case POSTDECREMENT_EXPR:
2302 case PREDECREMENT_EXPR:
2307 /* 24There also exist candidate operator functions of the form
2308 bool operator!(bool);
2309 bool operator&&(bool, bool);
2310 bool operator||(bool, bool); */
2312 case TRUTH_NOT_EXPR:
2313 build_builtin_candidate
2314 (candidates, fnname, boolean_type_node,
2315 NULL_TREE, args, argtypes, flags);
2318 case TRUTH_ORIF_EXPR:
2319 case TRUTH_ANDIF_EXPR:
2320 build_builtin_candidate
2321 (candidates, fnname, boolean_type_node,
2322 boolean_type_node, args, argtypes, flags);
2344 types[0] = types[1] = NULL_TREE;
2346 for (i = 0; i < 2; ++i)
2350 else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2354 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2357 convs = lookup_conversions (argtypes[i],
2358 /*lookup_template_convs_p=*/false);
2360 if (code == COND_EXPR)
2362 if (real_lvalue_p (args[i]))
2363 types[i] = tree_cons
2364 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2366 types[i] = tree_cons
2367 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2373 for (; convs; convs = TREE_CHAIN (convs))
2375 type = TREE_TYPE (convs);
2378 && (TREE_CODE (type) != REFERENCE_TYPE
2379 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2382 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2383 types[i] = tree_cons (NULL_TREE, type, types[i]);
2385 type = non_reference (type);
2386 if (i != 0 || ! ref1)
2388 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2389 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2390 types[i] = tree_cons (NULL_TREE, type, types[i]);
2391 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2392 type = type_promotes_to (type);
2395 if (! value_member (type, types[i]))
2396 types[i] = tree_cons (NULL_TREE, type, types[i]);
2401 if (code == COND_EXPR && real_lvalue_p (args[i]))
2402 types[i] = tree_cons
2403 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2404 type = non_reference (argtypes[i]);
2405 if (i != 0 || ! ref1)
2407 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2408 if (enum_p && UNSCOPED_ENUM_P (type))
2409 types[i] = tree_cons (NULL_TREE, type, types[i]);
2410 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2411 type = type_promotes_to (type);
2413 types[i] = tree_cons (NULL_TREE, type, types[i]);
2417 /* Run through the possible parameter types of both arguments,
2418 creating candidates with those parameter types. */
2419 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2422 for (type = types[1]; type; type = TREE_CHAIN (type))
2423 add_builtin_candidate
2424 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2425 TREE_VALUE (type), args, argtypes, flags);
2427 add_builtin_candidate
2428 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2429 NULL_TREE, args, argtypes, flags);
2434 /* If TMPL can be successfully instantiated as indicated by
2435 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2437 TMPL is the template. EXPLICIT_TARGS are any explicit template
2438 arguments. ARGLIST is the arguments provided at the call-site.
2439 This does not change ARGLIST. The RETURN_TYPE is the desired type
2440 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
2441 as for add_function_candidate. If an OBJ is supplied, FLAGS and
2442 CTYPE are ignored, and OBJ is as for add_conv_candidate. */
2444 static struct z_candidate*
2445 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2446 tree ctype, tree explicit_targs, tree first_arg,
2447 const VEC(tree,gc) *arglist, tree return_type,
2448 tree access_path, tree conversion_path,
2449 int flags, tree obj, unification_kind_t strict)
2451 int ntparms = DECL_NTPARMS (tmpl);
2452 tree targs = make_tree_vec (ntparms);
2453 unsigned int len = VEC_length (tree, arglist);
2454 unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2455 unsigned int skip_without_in_chrg = 0;
2456 tree first_arg_without_in_chrg = first_arg;
2457 tree *args_without_in_chrg;
2458 unsigned int nargs_without_in_chrg;
2459 unsigned int ia, ix;
2461 struct z_candidate *cand;
2465 /* We don't do deduction on the in-charge parameter, the VTT
2466 parameter or 'this'. */
2467 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2469 if (first_arg_without_in_chrg != NULL_TREE)
2470 first_arg_without_in_chrg = NULL_TREE;
2472 ++skip_without_in_chrg;
2475 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2476 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2477 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2479 if (first_arg_without_in_chrg != NULL_TREE)
2480 first_arg_without_in_chrg = NULL_TREE;
2482 ++skip_without_in_chrg;
2485 if (len < skip_without_in_chrg)
2488 nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2489 + (len - skip_without_in_chrg));
2490 args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2492 if (first_arg_without_in_chrg != NULL_TREE)
2494 args_without_in_chrg[ia] = first_arg_without_in_chrg;
2497 for (ix = skip_without_in_chrg;
2498 VEC_iterate (tree, arglist, ix, arg);
2501 args_without_in_chrg[ia] = arg;
2504 gcc_assert (ia == nargs_without_in_chrg);
2506 i = fn_type_unification (tmpl, explicit_targs, targs,
2507 args_without_in_chrg,
2508 nargs_without_in_chrg,
2509 return_type, strict, flags);
2514 fn = instantiate_template (tmpl, targs, tf_none);
2515 if (fn == error_mark_node)
2520 A member function template is never instantiated to perform the
2521 copy of a class object to an object of its class type.
2523 It's a little unclear what this means; the standard explicitly
2524 does allow a template to be used to copy a class. For example,
2529 template <class T> A(const T&);
2532 void g () { A a (f ()); }
2534 the member template will be used to make the copy. The section
2535 quoted above appears in the paragraph that forbids constructors
2536 whose only parameter is (a possibly cv-qualified variant of) the
2537 class type, and a logical interpretation is that the intent was
2538 to forbid the instantiation of member templates which would then
2540 if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2542 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2543 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2548 if (obj != NULL_TREE)
2549 /* Aha, this is a conversion function. */
2550 cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2551 access_path, conversion_path);
2553 cand = add_function_candidate (candidates, fn, ctype,
2554 first_arg, arglist, access_path,
2555 conversion_path, flags);
2556 if (DECL_TI_TEMPLATE (fn) != tmpl)
2557 /* This situation can occur if a member template of a template
2558 class is specialized. Then, instantiate_template might return
2559 an instantiation of the specialization, in which case the
2560 DECL_TI_TEMPLATE field will point at the original
2561 specialization. For example:
2563 template <class T> struct S { template <class U> void f(U);
2564 template <> void f(int) {}; };
2568 Here, TMPL will be template <class U> S<double>::f(U).
2569 And, instantiate template will give us the specialization
2570 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2571 for this will point at template <class T> template <> S<T>::f(int),
2572 so that we can find the definition. For the purposes of
2573 overload resolution, however, we want the original TMPL. */
2574 cand->template_decl = build_template_info (tmpl, targs);
2576 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2577 cand->explicit_targs = explicit_targs;
2581 return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2582 access_path, conversion_path, 0);
2586 static struct z_candidate *
2587 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2588 tree explicit_targs, tree first_arg,
2589 const VEC(tree,gc) *arglist, tree return_type,
2590 tree access_path, tree conversion_path, int flags,
2591 unification_kind_t strict)
2594 add_template_candidate_real (candidates, tmpl, ctype,
2595 explicit_targs, first_arg, arglist,
2596 return_type, access_path, conversion_path,
2597 flags, NULL_TREE, strict);
2601 static struct z_candidate *
2602 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2603 tree obj, tree first_arg,
2604 const VEC(tree,gc) *arglist,
2605 tree return_type, tree access_path,
2606 tree conversion_path)
2609 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2610 first_arg, arglist, return_type, access_path,
2611 conversion_path, 0, obj, DEDUCE_CONV);
2614 /* The CANDS are the set of candidates that were considered for
2615 overload resolution. Return the set of viable candidates, or CANDS
2616 if none are viable. If any of the candidates were viable, set
2617 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
2618 considered viable only if it is strictly viable. */
2620 static struct z_candidate*
2621 splice_viable (struct z_candidate *cands,
2625 struct z_candidate *viable;
2626 struct z_candidate **last_viable;
2627 struct z_candidate **cand;
2630 last_viable = &viable;
2631 *any_viable_p = false;
2636 struct z_candidate *c = *cand;
2637 if (strict_p ? c->viable == 1 : c->viable)
2642 last_viable = &c->next;
2643 *any_viable_p = true;
2649 return viable ? viable : cands;
2653 any_strictly_viable (struct z_candidate *cands)
2655 for (; cands; cands = cands->next)
2656 if (cands->viable == 1)
2661 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2662 words, it is about to become the "this" pointer for a member
2663 function call. Take the address of the object. */
2666 build_this (tree obj)
2668 /* In a template, we are only concerned about the type of the
2669 expression, so we can take a shortcut. */
2670 if (processing_template_decl)
2671 return build_address (obj);
2673 return cp_build_unary_op (ADDR_EXPR, obj, 0, tf_warning_or_error);
2676 /* Returns true iff functions are equivalent. Equivalent functions are
2677 not '==' only if one is a function-local extern function or if
2678 both are extern "C". */
2681 equal_functions (tree fn1, tree fn2)
2683 if (TREE_CODE (fn1) != TREE_CODE (fn2))
2685 if (TREE_CODE (fn1) == TEMPLATE_DECL)
2687 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2688 || DECL_EXTERN_C_FUNCTION_P (fn1))
2689 return decls_match (fn1, fn2);
2693 /* Print information about one overload candidate CANDIDATE. MSGSTR
2694 is the text to print before the candidate itself.
2696 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2697 to have been run through gettext by the caller. This wart makes
2698 life simpler in print_z_candidates and for the translators. */
2701 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2703 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2705 if (candidate->num_convs == 3)
2706 inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2707 candidate->convs[0]->type,
2708 candidate->convs[1]->type,
2709 candidate->convs[2]->type);
2710 else if (candidate->num_convs == 2)
2711 inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2712 candidate->convs[0]->type,
2713 candidate->convs[1]->type);
2715 inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2716 candidate->convs[0]->type);
2718 else if (TYPE_P (candidate->fn))
2719 inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2720 else if (candidate->viable == -1)
2721 inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2722 else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
2723 inform (input_location, "%s %+#D <deleted>", msgstr, candidate->fn);
2725 inform (input_location, "%s %+#D", msgstr, candidate->fn);
2729 print_z_candidates (struct z_candidate *candidates)
2732 struct z_candidate *cand1;
2733 struct z_candidate **cand2;
2739 /* Remove deleted candidates. */
2741 for (cand2 = &cand1; *cand2; )
2743 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2744 && DECL_DELETED_FN ((*cand2)->fn))
2745 *cand2 = (*cand2)->next;
2747 cand2 = &(*cand2)->next;
2749 /* ...if there are any non-deleted ones. */
2753 /* There may be duplicates in the set of candidates. We put off
2754 checking this condition as long as possible, since we have no way
2755 to eliminate duplicates from a set of functions in less than n^2
2756 time. Now we are about to emit an error message, so it is more
2757 permissible to go slowly. */
2758 for (cand1 = candidates; cand1; cand1 = cand1->next)
2760 tree fn = cand1->fn;
2761 /* Skip builtin candidates and conversion functions. */
2764 cand2 = &cand1->next;
2767 if (DECL_P ((*cand2)->fn)
2768 && equal_functions (fn, (*cand2)->fn))
2769 *cand2 = (*cand2)->next;
2771 cand2 = &(*cand2)->next;
2775 str = candidates->next ? _("candidates are:") : _("candidate is:");
2777 for (; candidates; candidates = candidates->next)
2779 print_z_candidate (spaces ? spaces : str, candidates);
2780 spaces = spaces ? spaces : get_spaces (str);
2785 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2786 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2787 the result of the conversion function to convert it to the final
2788 desired type. Merge the two sequences into a single sequence,
2789 and return the merged sequence. */
2792 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2796 gcc_assert (user_seq->kind == ck_user);
2798 /* Find the end of the second conversion sequence. */
2800 while ((*t)->kind != ck_identity)
2801 t = &((*t)->u.next);
2803 /* Replace the identity conversion with the user conversion
2807 /* The entire sequence is a user-conversion sequence. */
2808 std_seq->user_conv_p = true;
2813 /* Returns the best overload candidate to perform the requested
2814 conversion. This function is used for three the overloading situations
2815 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2816 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2817 per [dcl.init.ref], so we ignore temporary bindings. */
2819 static struct z_candidate *
2820 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2822 struct z_candidate *candidates, *cand;
2823 tree fromtype = TREE_TYPE (expr);
2824 tree ctors = NULL_TREE;
2825 tree conv_fns = NULL_TREE;
2826 conversion *conv = NULL;
2827 tree first_arg = NULL_TREE;
2828 VEC(tree,gc) *args = NULL;
2832 /* We represent conversion within a hierarchy using RVALUE_CONV and
2833 BASE_CONV, as specified by [over.best.ics]; these become plain
2834 constructor calls, as specified in [dcl.init]. */
2835 gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
2836 || !DERIVED_FROM_P (totype, fromtype));
2838 if (MAYBE_CLASS_TYPE_P (totype))
2839 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2841 if (MAYBE_CLASS_TYPE_P (fromtype))
2843 tree to_nonref = non_reference (totype);
2844 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
2845 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
2846 && DERIVED_FROM_P (to_nonref, fromtype)))
2848 /* [class.conv.fct] A conversion function is never used to
2849 convert a (possibly cv-qualified) object to the (possibly
2850 cv-qualified) same object type (or a reference to it), to a
2851 (possibly cv-qualified) base class of that type (or a
2852 reference to it)... */
2855 conv_fns = lookup_conversions (fromtype,
2856 /*lookup_template_convs_p=*/true);
2860 flags |= LOOKUP_NO_CONVERSION;
2861 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2862 flags |= LOOKUP_NO_NARROWING;
2864 /* It's OK to bind a temporary for converting constructor arguments, but
2865 not in converting the return value of a conversion operator. */
2866 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
2867 flags &= ~LOOKUP_NO_TEMP_BIND;
2871 int ctorflags = flags;
2872 bool try_single_arg = true;
2873 ctors = BASELINK_FUNCTIONS (ctors);
2875 first_arg = build_int_cst (build_pointer_type (totype), 0);
2876 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2878 /* For list-initialization we consider explicit constructors, but
2879 give an error if one is selected. */
2880 ctorflags &= ~LOOKUP_ONLYCONVERTING;
2881 /* If the class has a list ctor, try passing the list as a single
2882 argument first, but only consider list ctors. */
2883 if (TYPE_HAS_LIST_CTOR (totype))
2884 ctorflags |= LOOKUP_LIST_ONLY;
2886 try_single_arg = false;
2889 /* We should never try to call the abstract or base constructor
2891 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2892 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2894 /* If EXPR is not an initializer-list, or if totype has a list
2895 constructor, try EXPR as a single argument. */
2898 args = make_tree_vector_single (expr);
2899 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
2900 TYPE_BINFO (totype), TYPE_BINFO (totype),
2901 ctorflags, &candidates);
2904 /* If we didn't find a suitable list constructor for an initializer-list,
2905 try breaking it apart. */
2906 if (!candidates && BRACE_ENCLOSED_INITIALIZER_P (expr))
2908 args = ctor_to_vec (expr);
2909 /* We aren't looking for list-ctors anymore. */
2910 ctorflags &= ~LOOKUP_LIST_ONLY;
2911 /* We still allow more conversions within an init-list. */
2912 ctorflags &= ~LOOKUP_NO_CONVERSION;
2913 /* But not for the copy ctor. */
2914 ctorflags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
2915 add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
2916 TYPE_BINFO (totype), TYPE_BINFO (totype),
2917 ctorflags, &candidates);
2920 for (cand = candidates; cand; cand = cand->next)
2922 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2924 /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
2925 set, then this is copy-initialization. In that case, "The
2926 result of the call is then used to direct-initialize the
2927 object that is the destination of the copy-initialization."
2930 We represent this in the conversion sequence with an
2931 rvalue conversion, which means a constructor call. */
2932 if (TREE_CODE (totype) != REFERENCE_TYPE
2933 && !(convflags & LOOKUP_NO_TEMP_BIND))
2935 = build_conv (ck_rvalue, totype, cand->second_conv);
2940 first_arg = build_this (expr);
2942 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2944 tree conversion_path = TREE_PURPOSE (conv_fns);
2945 struct z_candidate *old_candidates;
2947 /* If we are called to convert to a reference type, we are trying to
2948 find an lvalue binding, so don't even consider temporaries. If
2949 we don't find an lvalue binding, the caller will try again to
2950 look for a temporary binding. */
2951 if (TREE_CODE (totype) == REFERENCE_TYPE)
2952 convflags |= LOOKUP_NO_TEMP_BIND;
2954 old_candidates = candidates;
2955 add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
2957 conversion_path, TYPE_BINFO (fromtype),
2958 flags, &candidates);
2960 for (cand = candidates; cand != old_candidates; cand = cand->next)
2962 tree fn = OVL_CURRENT (fns);
2964 if (DECL_NONCONVERTING_P (fn)
2965 && (flags & LOOKUP_ONLYCONVERTING))
2968 /* [over.match.funcs] For conversion functions, the function
2969 is considered to be a member of the class of the implicit
2970 object argument for the purpose of defining the type of
2971 the implicit object parameter.
2973 So we pass fromtype as CTYPE to add_*_candidate. */
2975 if (TREE_CODE (fn) == TEMPLATE_DECL)
2976 cand = add_template_candidate (&candidates, fn, fromtype,
2978 first_arg, NULL, totype,
2979 TYPE_BINFO (fromtype),
2984 cand = add_function_candidate (&candidates, fn, fromtype,
2986 TYPE_BINFO (fromtype),
2990 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
2991 copy-initialization. In that case, "The result of the
2992 call is then used to direct-initialize the object that is
2993 the destination of the copy-initialization." [dcl.init]
2995 We represent this in the conversion sequence with an
2996 rvalue conversion, which means a constructor call. But
2997 don't add a second rvalue conversion if there's already
2998 one there. Which there really shouldn't be, but it's
2999 harmless since we'd add it here anyway. */
3000 if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3001 && !(convflags & LOOKUP_NO_TEMP_BIND))
3002 ics = build_conv (ck_rvalue, totype, ics);
3004 cand->second_conv = ics;
3008 else if (cand->viable == 1 && ics->bad_p)
3013 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3017 cand = tourney (candidates);
3020 if (flags & LOOKUP_COMPLAIN)
3022 error ("conversion from %qT to %qT is ambiguous",
3024 print_z_candidates (candidates);
3027 cand = candidates; /* any one will do */
3028 cand->second_conv = build_ambiguous_conv (totype, expr);
3029 cand->second_conv->user_conv_p = true;
3030 if (!any_strictly_viable (candidates))
3031 cand->second_conv->bad_p = true;
3032 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3033 ambiguous conversion is no worse than another user-defined
3039 /* Build the user conversion sequence. */
3042 (DECL_CONSTRUCTOR_P (cand->fn)
3043 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3044 build_identity_conv (TREE_TYPE (expr), expr));
3047 /* Remember that this was a list-initialization. */
3048 if (flags & LOOKUP_NO_NARROWING)
3049 conv->check_narrowing = true;
3051 /* Combine it with the second conversion sequence. */
3052 cand->second_conv = merge_conversion_sequences (conv,
3055 if (cand->viable == -1)
3056 cand->second_conv->bad_p = true;
3062 build_user_type_conversion (tree totype, tree expr, int flags)
3064 struct z_candidate *cand
3065 = build_user_type_conversion_1 (totype, expr, flags);
3069 if (cand->second_conv->kind == ck_ambig)
3070 return error_mark_node;
3071 expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3072 return convert_from_reference (expr);
3077 /* Do any initial processing on the arguments to a function call. */
3079 static VEC(tree,gc) *
3080 resolve_args (VEC(tree,gc) *args)
3085 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
3087 if (error_operand_p (arg))
3089 else if (VOID_TYPE_P (TREE_TYPE (arg)))
3091 error ("invalid use of void expression");
3094 else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3100 /* Perform overload resolution on FN, which is called with the ARGS.
3102 Return the candidate function selected by overload resolution, or
3103 NULL if the event that overload resolution failed. In the case
3104 that overload resolution fails, *CANDIDATES will be the set of
3105 candidates considered, and ANY_VIABLE_P will be set to true or
3106 false to indicate whether or not any of the candidates were
3109 The ARGS should already have gone through RESOLVE_ARGS before this
3110 function is called. */
3112 static struct z_candidate *
3113 perform_overload_resolution (tree fn,
3114 const VEC(tree,gc) *args,
3115 struct z_candidate **candidates,
3118 struct z_candidate *cand;
3119 tree explicit_targs = NULL_TREE;
3120 int template_only = 0;
3123 *any_viable_p = true;
3126 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3127 || TREE_CODE (fn) == TEMPLATE_DECL
3128 || TREE_CODE (fn) == OVERLOAD
3129 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3131 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3133 explicit_targs = TREE_OPERAND (fn, 1);
3134 fn = TREE_OPERAND (fn, 0);
3138 /* Add the various candidate functions. */
3139 add_candidates (fn, NULL_TREE, args, NULL_TREE,
3140 explicit_targs, template_only,
3141 /*conversion_path=*/NULL_TREE,
3142 /*access_path=*/NULL_TREE,
3146 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3150 cand = tourney (*candidates);
3154 /* Return an expression for a call to FN (a namespace-scope function,
3155 or a static member function) with the ARGS. This may change
3159 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3160 tsubst_flags_t complain)
3162 struct z_candidate *candidates, *cand;
3167 if (args != NULL && *args != NULL)
3169 *args = resolve_args (*args);
3171 return error_mark_node;
3174 /* If this function was found without using argument dependent
3175 lookup, then we want to ignore any undeclared friend
3181 fn = remove_hidden_names (fn);
3184 if (complain & tf_error)
3185 error ("no matching function for call to %<%D(%A)%>",
3186 DECL_NAME (OVL_CURRENT (orig_fn)),
3187 build_tree_list_vec (*args));
3188 return error_mark_node;
3192 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3193 p = conversion_obstack_alloc (0);
3195 cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3199 if (complain & tf_error)
3201 if (!any_viable_p && candidates && ! candidates->next
3202 && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3203 return cp_build_function_call_vec (candidates->fn, args, complain);
3204 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3205 fn = TREE_OPERAND (fn, 0);
3207 error ("no matching function for call to %<%D(%A)%>",
3208 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3210 error ("call of overloaded %<%D(%A)%> is ambiguous",
3211 DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3213 print_z_candidates (candidates);
3215 result = error_mark_node;
3218 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3220 /* Free all the conversions we allocated. */
3221 obstack_free (&conversion_obstack, p);
3226 /* Build a call to a global operator new. FNNAME is the name of the
3227 operator (either "operator new" or "operator new[]") and ARGS are
3228 the arguments provided. This may change ARGS. *SIZE points to the
3229 total number of bytes required by the allocation, and is updated if
3230 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
3231 be used. If this function determines that no cookie should be
3232 used, after all, *COOKIE_SIZE is set to NULL_TREE. If FN is
3233 non-NULL, it will be set, upon return, to the allocation function
3237 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3238 tree *size, tree *cookie_size,
3242 struct z_candidate *candidates;
3243 struct z_candidate *cand;
3248 VEC_safe_insert (tree, gc, *args, 0, *size);
3249 *args = resolve_args (*args);
3251 return error_mark_node;
3257 If this lookup fails to find the name, or if the allocated type
3258 is not a class type, the allocation function's name is looked
3259 up in the global scope.
3261 we disregard block-scope declarations of "operator new". */
3262 fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3264 /* Figure out what function is being called. */
3265 cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3267 /* If no suitable function could be found, issue an error message
3272 error ("no matching function for call to %<%D(%A)%>",
3273 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3275 error ("call of overloaded %<%D(%A)%> is ambiguous",
3276 DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3278 print_z_candidates (candidates);
3279 return error_mark_node;
3282 /* If a cookie is required, add some extra space. Whether
3283 or not a cookie is required cannot be determined until
3284 after we know which function was called. */
3287 bool use_cookie = true;
3288 if (!abi_version_at_least (2))
3290 /* In G++ 3.2, the check was implemented incorrectly; it
3291 looked at the placement expression, rather than the
3292 type of the function. */
3293 if (VEC_length (tree, *args) == 2
3294 && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3302 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3303 /* Skip the size_t parameter. */
3304 arg_types = TREE_CHAIN (arg_types);
3305 /* Check the remaining parameters (if any). */
3307 && TREE_CHAIN (arg_types) == void_list_node
3308 && same_type_p (TREE_VALUE (arg_types),
3312 /* If we need a cookie, adjust the number of bytes allocated. */
3315 /* Update the total size. */
3316 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3317 /* Update the argument list to reflect the adjusted size. */
3318 VEC_replace (tree, *args, 0, *size);
3321 *cookie_size = NULL_TREE;
3324 /* Tell our caller which function we decided to call. */
3328 /* Build the CALL_EXPR. */
3329 return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3332 /* Build a new call to operator(). This may change ARGS. */
3335 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3337 struct z_candidate *candidates = 0, *cand;
3338 tree fns, convs, first_mem_arg = NULL_TREE;
3339 tree type = TREE_TYPE (obj);
3341 tree result = NULL_TREE;
3344 if (error_operand_p (obj))
3345 return error_mark_node;
3347 obj = prep_operand (obj);
3349 if (TYPE_PTRMEMFUNC_P (type))
3351 if (complain & tf_error)
3352 /* It's no good looking for an overloaded operator() on a
3353 pointer-to-member-function. */
3354 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3355 return error_mark_node;
3358 if (TYPE_BINFO (type))
3360 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3361 if (fns == error_mark_node)
3362 return error_mark_node;
3367 if (args != NULL && *args != NULL)
3369 *args = resolve_args (*args);
3371 return error_mark_node;
3374 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3375 p = conversion_obstack_alloc (0);
3379 first_mem_arg = build_this (obj);
3381 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
3383 tree fn = OVL_CURRENT (fns);
3385 if (TREE_CODE (fn) == TEMPLATE_DECL)
3386 add_template_candidate (&candidates, fn, base, NULL_TREE,
3387 first_mem_arg, *args, NULL_TREE,
3390 LOOKUP_NORMAL, DEDUCE_CALL);
3392 add_function_candidate
3393 (&candidates, fn, base, first_mem_arg, *args, TYPE_BINFO (type),
3394 TYPE_BINFO (type), LOOKUP_NORMAL);
3398 convs = lookup_conversions (type, /*lookup_template_convs_p=*/true);
3400 for (; convs; convs = TREE_CHAIN (convs))
3402 tree fns = TREE_VALUE (convs);
3403 tree totype = TREE_TYPE (convs);
3405 if ((TREE_CODE (totype) == POINTER_TYPE
3406 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3407 || (TREE_CODE (totype) == REFERENCE_TYPE
3408 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3409 || (TREE_CODE (totype) == REFERENCE_TYPE
3410 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3411 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3412 for (; fns; fns = OVL_NEXT (fns))
3414 tree fn = OVL_CURRENT (fns);
3416 if (DECL_NONCONVERTING_P (fn))
3419 if (TREE_CODE (fn) == TEMPLATE_DECL)
3420 add_template_conv_candidate
3421 (&candidates, fn, obj, NULL_TREE, *args, totype,
3422 /*access_path=*/NULL_TREE,
3423 /*conversion_path=*/NULL_TREE);
3425 add_conv_candidate (&candidates, fn, obj, NULL_TREE,
3426 *args, /*conversion_path=*/NULL_TREE,
3427 /*access_path=*/NULL_TREE);
3431 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3434 if (complain & tf_error)
3436 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
3437 build_tree_list_vec (*args));
3438 print_z_candidates (candidates);
3440 result = error_mark_node;
3444 cand = tourney (candidates);
3447 if (complain & tf_error)
3449 error ("call of %<(%T) (%A)%> is ambiguous",
3450 TREE_TYPE (obj), build_tree_list_vec (*args));
3451 print_z_candidates (candidates);
3453 result = error_mark_node;
3455 /* Since cand->fn will be a type, not a function, for a conversion
3456 function, we must be careful not to unconditionally look at
3458 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3459 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3460 result = build_over_call (cand, LOOKUP_NORMAL, complain);
3463 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
3465 obj = convert_from_reference (obj);
3466 result = cp_build_function_call_vec (obj, args, complain);
3470 /* Free all the conversions we allocated. */
3471 obstack_free (&conversion_obstack, p);
3477 op_error (enum tree_code code, enum tree_code code2,
3478 tree arg1, tree arg2, tree arg3, bool match)
3482 if (code == MODIFY_EXPR)
3483 opname = assignment_operator_name_info[code2].name;
3485 opname = operator_name_info[code].name;
3491 error ("ambiguous overload for ternary %<operator?:%> "
3492 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3494 error ("no match for ternary %<operator?:%> "
3495 "in %<%E ? %E : %E%>", arg1, arg2, arg3);
3498 case POSTINCREMENT_EXPR:
3499 case POSTDECREMENT_EXPR:
3501 error ("ambiguous overload for %<operator%s%> in %<%E%s%>",
3502 opname, arg1, opname);
3504 error ("no match for %<operator%s%> in %<%E%s%>",
3505 opname, arg1, opname);
3510 error ("ambiguous overload for %<operator[]%> in %<%E[%E]%>",
3513 error ("no match for %<operator[]%> in %<%E[%E]%>",
3520 error ("ambiguous overload for %qs in %<%s %E%>",
3521 opname, opname, arg1);
3523 error ("no match for %qs in %<%s %E%>",
3524 opname, opname, arg1);
3530 error ("ambiguous overload for %<operator%s%> in %<%E %s %E%>",
3531 opname, arg1, opname, arg2);
3533 error ("no match for %<operator%s%> in %<%E %s %E%>",
3534 opname, arg1, opname, arg2);
3537 error ("ambiguous overload for %<operator%s%> in %<%s%E%>",
3538 opname, opname, arg1);
3540 error ("no match for %<operator%s%> in %<%s%E%>",
3541 opname, opname, arg1);
3546 /* Return the implicit conversion sequence that could be used to
3547 convert E1 to E2 in [expr.cond]. */
3550 conditional_conversion (tree e1, tree e2)
3552 tree t1 = non_reference (TREE_TYPE (e1));
3553 tree t2 = non_reference (TREE_TYPE (e2));
3559 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3560 implicitly converted (clause _conv_) to the type "reference to
3561 T2", subject to the constraint that in the conversion the
3562 reference must bind directly (_dcl.init.ref_) to E1. */
3563 if (real_lvalue_p (e2))
3565 conv = implicit_conversion (build_reference_type (t2),
3569 LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING);
3576 If E1 and E2 have class type, and the underlying class types are
3577 the same or one is a base class of the other: E1 can be converted
3578 to match E2 if the class of T2 is the same type as, or a base
3579 class of, the class of T1, and the cv-qualification of T2 is the
3580 same cv-qualification as, or a greater cv-qualification than, the
3581 cv-qualification of T1. If the conversion is applied, E1 is
3582 changed to an rvalue of type T2 that still refers to the original
3583 source class object (or the appropriate subobject thereof). */
3584 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3585 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3587 if (good_base && at_least_as_qualified_p (t2, t1))
3589 conv = build_identity_conv (t1, e1);
3590 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3591 TYPE_MAIN_VARIANT (t2)))
3592 conv = build_conv (ck_base, t2, conv);
3594 conv = build_conv (ck_rvalue, t2, conv);
3603 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3604 converted to the type that expression E2 would have if E2 were
3605 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3606 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3610 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3611 arguments to the conditional expression. */
3614 build_conditional_expr (tree arg1, tree arg2, tree arg3,
3615 tsubst_flags_t complain)
3619 tree result = NULL_TREE;
3621 tree result_type = NULL_TREE;
3622 bool lvalue_p = true;
3623 struct z_candidate *candidates = 0;
3624 struct z_candidate *cand;
3627 /* As a G++ extension, the second argument to the conditional can be
3628 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3629 c'.) If the second operand is omitted, make sure it is
3630 calculated only once. */
3633 if (complain & tf_error)
3634 pedwarn (input_location, OPT_pedantic,
3635 "ISO C++ forbids omitting the middle term of a ?: expression");
3637 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3638 if (real_lvalue_p (arg1))
3639 arg2 = arg1 = stabilize_reference (arg1);
3641 arg2 = arg1 = save_expr (arg1);
3646 The first expression is implicitly converted to bool (clause
3648 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
3651 /* If something has already gone wrong, just pass that fact up the
3653 if (error_operand_p (arg1)
3654 || error_operand_p (arg2)
3655 || error_operand_p (arg3))
3656 return error_mark_node;
3660 If either the second or the third operand has type (possibly
3661 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3662 array-to-pointer (_conv.array_), and function-to-pointer
3663 (_conv.func_) standard conversions are performed on the second
3664 and third operands. */
3665 arg2_type = unlowered_expr_type (arg2);
3666 arg3_type = unlowered_expr_type (arg3);
3667 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3669 /* Do the conversions. We don't these for `void' type arguments
3670 since it can't have any effect and since decay_conversion
3671 does not handle that case gracefully. */
3672 if (!VOID_TYPE_P (arg2_type))
3673 arg2 = decay_conversion (arg2);
3674 if (!VOID_TYPE_P (arg3_type))
3675 arg3 = decay_conversion (arg3);
3676 arg2_type = TREE_TYPE (arg2);
3677 arg3_type = TREE_TYPE (arg3);
3681 One of the following shall hold:
3683 --The second or the third operand (but not both) is a
3684 throw-expression (_except.throw_); the result is of the
3685 type of the other and is an rvalue.
3687 --Both the second and the third operands have type void; the
3688 result is of type void and is an rvalue.
3690 We must avoid calling force_rvalue for expressions of type
3691 "void" because it will complain that their value is being
3693 if (TREE_CODE (arg2) == THROW_EXPR
3694 && TREE_CODE (arg3) != THROW_EXPR)
3696 if (!VOID_TYPE_P (arg3_type))
3697 arg3 = force_rvalue (arg3);
3698 arg3_type = TREE_TYPE (arg3);
3699 result_type = arg3_type;
3701 else if (TREE_CODE (arg2) != THROW_EXPR
3702 && TREE_CODE (arg3) == THROW_EXPR)
3704 if (!VOID_TYPE_P (arg2_type))
3705 arg2 = force_rvalue (arg2);
3706 arg2_type = TREE_TYPE (arg2);
3707 result_type = arg2_type;
3709 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3710 result_type = void_type_node;
3713 if (complain & tf_error)
3715 if (VOID_TYPE_P (arg2_type))
3716 error ("second operand to the conditional operator "
3717 "is of type %<void%>, "
3718 "but the third operand is neither a throw-expression "
3719 "nor of type %<void%>");
3721 error ("third operand to the conditional operator "
3722 "is of type %<void%>, "
3723 "but the second operand is neither a throw-expression "
3724 "nor of type %<void%>");
3726 return error_mark_node;
3730 goto valid_operands;
3734 Otherwise, if the second and third operand have different types,
3735 and either has (possibly cv-qualified) class type, an attempt is
3736 made to convert each of those operands to the type of the other. */
3737 else if (!same_type_p (arg2_type, arg3_type)
3738 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3743 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3744 p = conversion_obstack_alloc (0);
3746 conv2 = conditional_conversion (arg2, arg3);
3747 conv3 = conditional_conversion (arg3, arg2);
3751 If both can be converted, or one can be converted but the
3752 conversion is ambiguous, the program is ill-formed. If
3753 neither can be converted, the operands are left unchanged and
3754 further checking is performed as described below. If exactly
3755 one conversion is possible, that conversion is applied to the
3756 chosen operand and the converted operand is used in place of
3757 the original operand for the remainder of this section. */
3758 if ((conv2 && !conv2->bad_p
3759 && conv3 && !conv3->bad_p)
3760 || (conv2 && conv2->kind == ck_ambig)
3761 || (conv3 && conv3->kind == ck_ambig))
3763 error ("operands to ?: have different types %qT and %qT",
3764 arg2_type, arg3_type);
3765 result = error_mark_node;
3767 else if (conv2 && (!conv2->bad_p || !conv3))
3769 arg2 = convert_like (conv2, arg2, complain);
3770 arg2 = convert_from_reference (arg2);
3771 arg2_type = TREE_TYPE (arg2);
3772 /* Even if CONV2 is a valid conversion, the result of the
3773 conversion may be invalid. For example, if ARG3 has type
3774 "volatile X", and X does not have a copy constructor
3775 accepting a "volatile X&", then even if ARG2 can be
3776 converted to X, the conversion will fail. */
3777 if (error_operand_p (arg2))
3778 result = error_mark_node;
3780 else if (conv3 && (!conv3->bad_p || !conv2))
3782 arg3 = convert_like (conv3, arg3, complain);
3783 arg3 = convert_from_reference (arg3);
3784 arg3_type = TREE_TYPE (arg3);
3785 if (error_operand_p (arg3))
3786 result = error_mark_node;
3789 /* Free all the conversions we allocated. */
3790 obstack_free (&conversion_obstack, p);
3795 /* If, after the conversion, both operands have class type,
3796 treat the cv-qualification of both operands as if it were the
3797 union of the cv-qualification of the operands.
3799 The standard is not clear about what to do in this
3800 circumstance. For example, if the first operand has type
3801 "const X" and the second operand has a user-defined
3802 conversion to "volatile X", what is the type of the second
3803 operand after this step? Making it be "const X" (matching
3804 the first operand) seems wrong, as that discards the
3805 qualification without actually performing a copy. Leaving it
3806 as "volatile X" seems wrong as that will result in the
3807 conditional expression failing altogether, even though,
3808 according to this step, the one operand could be converted to
3809 the type of the other. */
3810 if ((conv2 || conv3)
3811 && CLASS_TYPE_P (arg2_type)
3812 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3813 arg2_type = arg3_type =
3814 cp_build_qualified_type (arg2_type,
3815 TYPE_QUALS (arg2_type)
3816 | TYPE_QUALS (arg3_type));
3821 If the second and third operands are lvalues and have the same
3822 type, the result is of that type and is an lvalue. */
3823 if (real_lvalue_p (arg2)
3824 && real_lvalue_p (arg3)
3825 && same_type_p (arg2_type, arg3_type))
3827 result_type = arg2_type;
3828 goto valid_operands;
3833 Otherwise, the result is an rvalue. If the second and third
3834 operand do not have the same type, and either has (possibly
3835 cv-qualified) class type, overload resolution is used to
3836 determine the conversions (if any) to be applied to the operands
3837 (_over.match.oper_, _over.built_). */
3839 if (!same_type_p (arg2_type, arg3_type)
3840 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3846 /* Rearrange the arguments so that add_builtin_candidate only has
3847 to know about two args. In build_builtin_candidate, the
3848 arguments are unscrambled. */
3852 add_builtin_candidates (&candidates,
3855 ansi_opname (COND_EXPR),
3861 If the overload resolution fails, the program is
3863 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3866 if (complain & tf_error)
3868 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3869 print_z_candidates (candidates);
3871 return error_mark_node;
3873 cand = tourney (candidates);
3876 if (complain & tf_error)
3878 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
3879 print_z_candidates (candidates);
3881 return error_mark_node;
3886 Otherwise, the conversions thus determined are applied, and
3887 the converted operands are used in place of the original
3888 operands for the remainder of this section. */
3889 conv = cand->convs[0];
3890 arg1 = convert_like (conv, arg1, complain);
3891 conv = cand->convs[1];
3892 arg2 = convert_like (conv, arg2, complain);
3893 arg2_type = TREE_TYPE (arg2);
3894 conv = cand->convs[2];
3895 arg3 = convert_like (conv, arg3, complain);
3896 arg3_type = TREE_TYPE (arg3);
3901 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3902 and function-to-pointer (_conv.func_) standard conversions are
3903 performed on the second and third operands.
3905 We need to force the lvalue-to-rvalue conversion here for class types,
3906 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3907 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3910 arg2 = force_rvalue (arg2);
3911 if (!CLASS_TYPE_P (arg2_type))
3912 arg2_type = TREE_TYPE (arg2);
3914 arg3 = force_rvalue (arg3);
3915 if (!CLASS_TYPE_P (arg3_type))
3916 arg3_type = TREE_TYPE (arg3);
3918 if (arg2 == error_mark_node || arg3 == error_mark_node)
3919 return error_mark_node;
3923 After those conversions, one of the following shall hold:
3925 --The second and third operands have the same type; the result is of
3927 if (same_type_p (arg2_type, arg3_type))
3928 result_type = arg2_type;
3931 --The second and third operands have arithmetic or enumeration
3932 type; the usual arithmetic conversions are performed to bring
3933 them to a common type, and the result is of that type. */
3934 else if ((ARITHMETIC_TYPE_P (arg2_type)
3935 || UNSCOPED_ENUM_P (arg2_type))
3936 && (ARITHMETIC_TYPE_P (arg3_type)
3937 || UNSCOPED_ENUM_P (arg3_type)))
3939 /* In this case, there is always a common type. */
3940 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3943 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3944 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3946 if (complain & tf_warning)
3948 "enumeral mismatch in conditional expression: %qT vs %qT",
3949 arg2_type, arg3_type);
3951 else if (extra_warnings
3952 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3953 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3954 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3955 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3957 if (complain & tf_warning)
3959 "enumeral and non-enumeral type in conditional expression");
3962 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3963 arg3 = perform_implicit_conversion (result_type, arg3, complain);
3967 --The second and third operands have pointer type, or one has
3968 pointer type and the other is a null pointer constant; pointer
3969 conversions (_conv.ptr_) and qualification conversions
3970 (_conv.qual_) are performed to bring them to their composite
3971 pointer type (_expr.rel_). The result is of the composite
3974 --The second and third operands have pointer to member type, or
3975 one has pointer to member type and the other is a null pointer
3976 constant; pointer to member conversions (_conv.mem_) and
3977 qualification conversions (_conv.qual_) are performed to bring
3978 them to a common type, whose cv-qualification shall match the
3979 cv-qualification of either the second or the third operand.
3980 The result is of the common type. */
3981 else if ((null_ptr_cst_p (arg2)
3982 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3983 || (null_ptr_cst_p (arg3)
3984 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3985 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3986 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3987 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3989 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3990 arg3, CPO_CONDITIONAL_EXPR,
3992 if (result_type == error_mark_node)
3993 return error_mark_node;
3994 arg2 = perform_implicit_conversion (result_type, arg2, complain);
3995 arg3 = perform_implicit_conversion (result_type, arg3, complain);
4000 if (complain & tf_error)
4001 error ("operands to ?: have different types %qT and %qT",
4002 arg2_type, arg3_type);
4003 return error_mark_node;
4007 result_save = build3 (COND_EXPR, result_type, arg1, arg2, arg3);
4008 result = fold_if_not_in_template (result_save);
4010 if (cp_unevaluated_operand && TREE_CODE (result) == CALL_EXPR)
4011 /* Avoid folding to a CALL_EXPR within decltype (c++/42013). */
4012 result = result_save;
4014 /* We can't use result_type below, as fold might have returned a
4019 /* Expand both sides into the same slot, hopefully the target of
4020 the ?: expression. We used to check for TARGET_EXPRs here,
4021 but now we sometimes wrap them in NOP_EXPRs so the test would
4023 if (CLASS_TYPE_P (TREE_TYPE (result)))
4024 result = get_target_expr (result);
4025 /* If this expression is an rvalue, but might be mistaken for an
4026 lvalue, we must add a NON_LVALUE_EXPR. */
4027 result = rvalue (result);
4033 /* OPERAND is an operand to an expression. Perform necessary steps
4034 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
4038 prep_operand (tree operand)
4042 if (CLASS_TYPE_P (TREE_TYPE (operand))
4043 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
4044 /* Make sure the template type is instantiated now. */
4045 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
4051 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
4052 OVERLOAD) to the CANDIDATES, returning an updated list of
4053 CANDIDATES. The ARGS are the arguments provided to the call;
4054 if FIRST_ARG is non-null it is the implicit object argument,
4055 otherwise the first element of ARGS is used if needed. The
4056 EXPLICIT_TARGS are explicit template arguments provided.
4057 TEMPLATE_ONLY is true if only template functions should be
4058 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
4059 add_function_candidate. */
4062 add_candidates (tree fns, tree first_arg, const VEC(tree,gc) *args,
4064 tree explicit_targs, bool template_only,
4065 tree conversion_path, tree access_path,
4067 struct z_candidate **candidates)
4070 const VEC(tree,gc) *non_static_args;
4071 bool check_list_ctor;
4072 bool check_converting;
4073 unification_kind_t strict;
4079 /* Precalculate special handling of constructors and conversion ops. */
4080 fn = OVL_CURRENT (fns);
4081 if (DECL_CONV_FN_P (fn))
4083 check_list_ctor = false;
4084 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4085 if (flags & LOOKUP_NO_CONVERSION)
4086 /* We're doing return_type(x). */
4087 strict = DEDUCE_CONV;
4089 /* We're doing x.operator return_type(). */
4090 strict = DEDUCE_EXACT;
4091 /* [over.match.funcs] For conversion functions, the function
4092 is considered to be a member of the class of the implicit
4093 object argument for the purpose of defining the type of
4094 the implicit object parameter. */
4095 ctype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (first_arg)));
4099 if (DECL_CONSTRUCTOR_P (fn))
4101 check_list_ctor = !!(flags & LOOKUP_LIST_ONLY);
4102 check_converting = !!(flags & LOOKUP_ONLYCONVERTING);
4106 check_list_ctor = false;
4107 check_converting = false;
4109 strict = DEDUCE_CALL;
4110 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
4114 non_static_args = args;
4116 /* Delay creating the implicit this parameter until it is needed. */
4117 non_static_args = NULL;
4119 for (; fns; fns = OVL_NEXT (fns))
4122 const VEC(tree,gc) *fn_args;
4124 fn = OVL_CURRENT (fns);
4126 if (check_converting && DECL_NONCONVERTING_P (fn))
4128 if (check_list_ctor && !is_list_ctor (fn))
4131 /* Figure out which set of arguments to use. */
4132 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
4134 /* If this function is a non-static member and we didn't get an
4135 implicit object argument, move it out of args. */
4136 if (first_arg == NULL_TREE)
4140 VEC(tree,gc) *tempvec
4141 = VEC_alloc (tree, gc, VEC_length (tree, args) - 1);
4142 for (ix = 1; VEC_iterate (tree, args, ix, arg); ++ix)
4143 VEC_quick_push (tree, tempvec, arg);
4144 non_static_args = tempvec;
4145 first_arg = build_this (VEC_index (tree, args, 0));
4148 fn_first_arg = first_arg;
4149 fn_args = non_static_args;
4153 /* Otherwise, just use the list of arguments provided. */
4154 fn_first_arg = NULL_TREE;
4158 if (TREE_CODE (fn) == TEMPLATE_DECL)
4159 add_template_candidate (candidates,
4170 else if (!template_only)
4171 add_function_candidate (candidates,
4182 /* Even unsigned enum types promote to signed int. We don't want to
4183 issue -Wsign-compare warnings for this case. Here ORIG_ARG is the
4184 original argument and ARG is the argument after any conversions
4185 have been applied. We set TREE_NO_WARNING if we have added a cast
4186 from an unsigned enum type to a signed integer type. */
4189 avoid_sign_compare_warnings (tree orig_arg, tree arg)
4191 if (orig_arg != NULL_TREE
4194 && TREE_CODE (TREE_TYPE (orig_arg)) == ENUMERAL_TYPE
4195 && TYPE_UNSIGNED (TREE_TYPE (orig_arg))
4196 && INTEGRAL_TYPE_P (TREE_TYPE (arg))
4197 && !TYPE_UNSIGNED (TREE_TYPE (arg)))
4198 TREE_NO_WARNING (arg) = 1;
4202 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
4203 bool *overloaded_p, tsubst_flags_t complain)
4205 tree orig_arg1 = arg1;
4206 tree orig_arg2 = arg2;
4207 tree orig_arg3 = arg3;
4208 struct z_candidate *candidates = 0, *cand;
4209 VEC(tree,gc) *arglist;
4212 tree result = NULL_TREE;
4213 bool result_valid_p = false;
4214 enum tree_code code2 = NOP_EXPR;
4215 enum tree_code code_orig_arg1 = ERROR_MARK;
4216 enum tree_code code_orig_arg2 = ERROR_MARK;
4222 if (error_operand_p (arg1)
4223 || error_operand_p (arg2)
4224 || error_operand_p (arg3))
4225 return error_mark_node;
4227 if (code == MODIFY_EXPR)
4229 code2 = TREE_CODE (arg3);
4231 fnname = ansi_assopname (code2);
4234 fnname = ansi_opname (code);
4236 arg1 = prep_operand (arg1);
4242 case VEC_DELETE_EXPR:
4244 /* Use build_op_new_call and build_op_delete_call instead. */
4248 /* Use build_op_call instead. */
4251 case TRUTH_ORIF_EXPR:
4252 case TRUTH_ANDIF_EXPR:
4253 case TRUTH_AND_EXPR:
4255 /* These are saved for the sake of warn_logical_operator. */
4256 code_orig_arg1 = TREE_CODE (arg1);
4257 code_orig_arg2 = TREE_CODE (arg2);
4263 arg2 = prep_operand (arg2);
4264 arg3 = prep_operand (arg3);
4266 if (code == COND_EXPR)
4267 /* Use build_conditional_expr instead. */
4269 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4270 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4273 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4274 arg2 = integer_zero_node;
4276 arglist = VEC_alloc (tree, gc, 3);
4277 VEC_quick_push (tree, arglist, arg1);
4278 if (arg2 != NULL_TREE)
4279 VEC_quick_push (tree, arglist, arg2);
4280 if (arg3 != NULL_TREE)
4281 VEC_quick_push (tree, arglist, arg3);
4283 /* Get the high-water mark for the CONVERSION_OBSTACK. */
4284 p = conversion_obstack_alloc (0);
4286 /* Add namespace-scope operators to the list of functions to
4288 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
4289 NULL_TREE, arglist, NULL_TREE,
4290 NULL_TREE, false, NULL_TREE, NULL_TREE,
4291 flags, &candidates);
4292 /* Add class-member operators to the candidate set. */
4293 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
4297 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
4298 if (fns == error_mark_node)
4300 result = error_mark_node;
4301 goto user_defined_result_ready;
4304 add_candidates (BASELINK_FUNCTIONS (fns),
4305 NULL_TREE, arglist, NULL_TREE,
4307 BASELINK_BINFO (fns),
4308 BASELINK_ACCESS_BINFO (fns),
4309 flags, &candidates);
4314 args[2] = NULL_TREE;
4316 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
4322 /* For these, the built-in candidates set is empty
4323 [over.match.oper]/3. We don't want non-strict matches
4324 because exact matches are always possible with built-in
4325 operators. The built-in candidate set for COMPONENT_REF
4326 would be empty too, but since there are no such built-in
4327 operators, we accept non-strict matches for them. */
4332 strict_p = pedantic;
4336 candidates = splice_viable (candidates, strict_p, &any_viable_p);
4341 case POSTINCREMENT_EXPR:
4342 case POSTDECREMENT_EXPR:
4343 /* Don't try anything fancy if we're not allowed to produce
4345 if (!(complain & tf_error))
4346 return error_mark_node;
4348 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
4349 distinguish between prefix and postfix ++ and
4350 operator++() was used for both, so we allow this with
4352 if (flags & LOOKUP_COMPLAIN)
4354 const char *msg = (flag_permissive)
4355 ? G_("no %<%D(int)%> declared for postfix %qs,"
4356 " trying prefix operator instead")
4357 : G_("no %<%D(int)%> declared for postfix %qs");
4358 permerror (input_location, msg, fnname,
4359 operator_name_info[code].name);
4362 if (!flag_permissive)
4363 return error_mark_node;
4365 if (code == POSTINCREMENT_EXPR)
4366 code = PREINCREMENT_EXPR;
4368 code = PREDECREMENT_EXPR;
4369 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
4370 overloaded_p, complain);
4373 /* The caller will deal with these. */
4378 result_valid_p = true;
4382 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4384 /* If one of the arguments of the operator represents
4385 an invalid use of member function pointer, try to report
4386 a meaningful error ... */
4387 if (invalid_nonstatic_memfn_p (arg1, tf_error)
4388 || invalid_nonstatic_memfn_p (arg2, tf_error)
4389 || invalid_nonstatic_memfn_p (arg3, tf_error))
4390 /* We displayed the error message. */;
4393 /* ... Otherwise, report the more generic
4394 "no matching operator found" error */
4395 op_error (code, code2, arg1, arg2, arg3, FALSE);
4396 print_z_candidates (candidates);
4399 result = error_mark_node;
4405 cand = tourney (candidates);
4408 if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4410 op_error (code, code2, arg1, arg2, arg3, TRUE);
4411 print_z_candidates (candidates);
4413 result = error_mark_node;
4415 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
4418 *overloaded_p = true;
4420 if (resolve_args (arglist) == NULL)
4421 result = error_mark_node;
4423 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4427 /* Give any warnings we noticed during overload resolution. */
4428 if (cand->warnings && (complain & tf_warning))
4430 struct candidate_warning *w;
4431 for (w = cand->warnings; w; w = w->next)
4432 joust (cand, w->loser, 1);
4435 /* Check for comparison of different enum types. */
4444 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
4445 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
4446 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
4447 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
4448 && (complain & tf_warning))
4450 warning (OPT_Wenum_compare,
4451 "comparison between %q#T and %q#T",
4452 TREE_TYPE (arg1), TREE_TYPE (arg2));
4459 /* We need to strip any leading REF_BIND so that bitfields
4460 don't cause errors. This should not remove any important
4461 conversions, because builtins don't apply to class
4462 objects directly. */
4463 conv = cand->convs[0];
4464 if (conv->kind == ck_ref_bind)
4465 conv = conv->u.next;
4466 arg1 = convert_like (conv, arg1, complain);
4470 /* We need to call warn_logical_operator before
4471 converting arg2 to a boolean_type. */
4472 if (complain & tf_warning)
4473 warn_logical_operator (input_location, code, boolean_type_node,
4474 code_orig_arg1, arg1,
4475 code_orig_arg2, arg2);
4477 conv = cand->convs[1];
4478 if (conv->kind == ck_ref_bind)
4479 conv = conv->u.next;
4480 arg2 = convert_like (conv, arg2, complain);
4484 conv = cand->convs[2];
4485 if (conv->kind == ck_ref_bind)
4486 conv = conv->u.next;
4487 arg3 = convert_like (conv, arg3, complain);
4493 user_defined_result_ready:
4495 /* Free all the conversions we allocated. */
4496 obstack_free (&conversion_obstack, p);
4498 if (result || result_valid_p)
4502 avoid_sign_compare_warnings (orig_arg1, arg1);
4503 avoid_sign_compare_warnings (orig_arg2, arg2);
4504 avoid_sign_compare_warnings (orig_arg3, arg3);
4509 return cp_build_modify_expr (arg1, code2, arg2, complain);
4512 return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
4514 case TRUTH_ANDIF_EXPR:
4515 case TRUTH_ORIF_EXPR:
4516 case TRUTH_AND_EXPR:
4518 warn_logical_operator (input_location, code, boolean_type_node,
4519 code_orig_arg1, arg1, code_orig_arg2, arg2);
4524 case TRUNC_DIV_EXPR:
4535 case TRUNC_MOD_EXPR:
4539 return cp_build_binary_op (input_location, code, arg1, arg2, complain);
4541 case UNARY_PLUS_EXPR:
4544 case TRUTH_NOT_EXPR:
4545 case PREINCREMENT_EXPR:
4546 case POSTINCREMENT_EXPR:
4547 case PREDECREMENT_EXPR:
4548 case POSTDECREMENT_EXPR:
4551 return cp_build_unary_op (code, arg1, candidates != 0, complain);
4554 return cp_build_array_ref (input_location, arg1, arg2, complain);
4557 return build_m_component_ref (cp_build_indirect_ref (arg1, RO_NULL,
4561 /* The caller will deal with these. */
4573 /* Returns true iff T, an element of an OVERLOAD chain, is a usual
4574 deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */
4577 non_placement_deallocation_fn_p (tree t)
4579 /* A template instance is never a usual deallocation function,
4580 regardless of its signature. */
4581 if (TREE_CODE (t) == TEMPLATE_DECL
4582 || primary_template_instantiation_p (t))
4585 /* If a class T has a member deallocation function named operator delete
4586 with exactly one parameter, then that function is a usual
4587 (non-placement) deallocation function. If class T does not declare
4588 such an operator delete but does declare a member deallocation
4589 function named operator delete with exactly two parameters, the second
4590 of which has type std::size_t (18.2), then this function is a usual
4591 deallocation function. */
4592 t = FUNCTION_ARG_CHAIN (t);
4593 if (t == void_list_node
4594 || (t && same_type_p (TREE_VALUE (t), size_type_node)
4595 && TREE_CHAIN (t) == void_list_node))
4600 /* Build a call to operator delete. This has to be handled very specially,
4601 because the restrictions on what signatures match are different from all
4602 other call instances. For a normal delete, only a delete taking (void *)
4603 or (void *, size_t) is accepted. For a placement delete, only an exact
4604 match with the placement new is accepted.
4606 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4607 ADDR is the pointer to be deleted.
4608 SIZE is the size of the memory block to be deleted.
4609 GLOBAL_P is true if the delete-expression should not consider
4610 class-specific delete operators.
4611 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4613 If this call to "operator delete" is being generated as part to
4614 deallocate memory allocated via a new-expression (as per [expr.new]
4615 which requires that if the initialization throws an exception then
4616 we call a deallocation function), then ALLOC_FN is the allocation
4620 build_op_delete_call (enum tree_code code, tree addr, tree size,
4621 bool global_p, tree placement,
4624 tree fn = NULL_TREE;
4625 tree fns, fnname, type, t;
4627 if (addr == error_mark_node)
4628 return error_mark_node;
4630 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4632 fnname = ansi_opname (code);
4634 if (CLASS_TYPE_P (type)
4635 && COMPLETE_TYPE_P (complete_type (type))
4639 If the result of the lookup is ambiguous or inaccessible, or if
4640 the lookup selects a placement deallocation function, the
4641 program is ill-formed.
4643 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4645 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4646 if (fns == error_mark_node)
4647 return error_mark_node;
4652 if (fns == NULL_TREE)
4653 fns = lookup_name_nonclass (fnname);
4655 /* Strip const and volatile from addr. */
4656 addr = cp_convert (ptr_type_node, addr);
4660 /* "A declaration of a placement deallocation function matches the
4661 declaration of a placement allocation function if it has the same
4662 number of parameters and, after parameter transformations (8.3.5),
4663 all parameter types except the first are identical."
4665 So we build up the function type we want and ask instantiate_type
4666 to get it for us. */
4667 t = FUNCTION_ARG_CHAIN (alloc_fn);
4668 t = tree_cons (NULL_TREE, ptr_type_node, t);
4669 t = build_function_type (void_type_node, t);
4671 fn = instantiate_type (t, fns, tf_none);
4672 if (fn == error_mark_node)
4675 if (BASELINK_P (fn))
4676 fn = BASELINK_FUNCTIONS (fn);
4678 /* "If the lookup finds the two-parameter form of a usual deallocation
4679 function (3.7.4.2) and that function, considered as a placement
4680 deallocation function, would have been selected as a match for the
4681 allocation function, the program is ill-formed." */
4682 if (non_placement_deallocation_fn_p (fn))
4684 /* But if the class has an operator delete (void *), then that is
4685 the usual deallocation function, so we shouldn't complain
4686 about using the operator delete (void *, size_t). */
4687 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4688 t; t = OVL_NEXT (t))
4690 tree elt = OVL_CURRENT (t);
4691 if (non_placement_deallocation_fn_p (elt)
4692 && FUNCTION_ARG_CHAIN (elt) == void_list_node)
4695 permerror (0, "non-placement deallocation function %q+D", fn);
4696 permerror (input_location, "selected for placement delete");
4701 /* "Any non-placement deallocation function matches a non-placement
4702 allocation function. If the lookup finds a single matching
4703 deallocation function, that function will be called; otherwise, no
4704 deallocation function will be called." */
4705 for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4706 t; t = OVL_NEXT (t))
4708 tree elt = OVL_CURRENT (t);
4709 if (non_placement_deallocation_fn_p (elt))
4712 /* "If a class T has a member deallocation function named
4713 operator delete with exactly one parameter, then that
4714 function is a usual (non-placement) deallocation
4715 function. If class T does not declare such an operator
4716 delete but does declare a member deallocation function named
4717 operator delete with exactly two parameters, the second of
4718 which has type std::size_t (18.2), then this function is a
4719 usual deallocation function."
4721 So (void*) beats (void*, size_t). */
4722 if (FUNCTION_ARG_CHAIN (fn) == void_list_node)
4727 /* If we have a matching function, call it. */
4730 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
4732 /* If the FN is a member function, make sure that it is
4734 if (BASELINK_P (fns))
4735 perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn);
4737 /* Core issue 901: It's ok to new a type with deleted delete. */
4738 if (DECL_DELETED_FN (fn) && alloc_fn)
4743 /* The placement args might not be suitable for overload
4744 resolution at this point, so build the call directly. */
4745 int nargs = call_expr_nargs (placement);
4746 tree *argarray = (tree *) alloca (nargs * sizeof (tree));
4749 for (i = 1; i < nargs; i++)
4750 argarray[i] = CALL_EXPR_ARG (placement, i);
4752 return build_cxx_call (fn, nargs, argarray);
4757 VEC(tree,gc) *args = VEC_alloc (tree, gc, 2);
4758 VEC_quick_push (tree, args, addr);
4759 if (FUNCTION_ARG_CHAIN (fn) != void_list_node)
4760 VEC_quick_push (tree, args, size);
4761 ret = cp_build_function_call_vec (fn, &args, tf_warning_or_error);
4762 VEC_free (tree, gc, args);
4769 If no unambiguous matching deallocation function can be found,
4770 propagating the exception does not cause the object's memory to
4775 warning (0, "no corresponding deallocation function for %qD",
4780 error ("no suitable %<operator %s%> for %qT",
4781 operator_name_info[(int)code].name, type);
4782 return error_mark_node;
4785 /* If the current scope isn't allowed to access DECL along
4786 BASETYPE_PATH, give an error. The most derived class in
4787 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4788 the declaration to use in the error diagnostic. */
4791 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4793 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4795 if (!accessible_p (basetype_path, decl, true))
4797 if (TREE_PRIVATE (decl))
4798 error ("%q+#D is private", diag_decl);
4799 else if (TREE_PROTECTED (decl))
4800 error ("%q+#D is protected", diag_decl);
4802 error ("%q+#D is inaccessible", diag_decl);
4803 error ("within this context");
4810 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4811 bitwise or of LOOKUP_* values. If any errors are warnings are
4812 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4813 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4817 build_temp (tree expr, tree type, int flags,
4818 diagnostic_t *diagnostic_kind)
4823 savew = warningcount, savee = errorcount;
4824 args = make_tree_vector_single (expr);
4825 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4826 &args, type, flags, tf_warning_or_error);
4827 release_tree_vector (args);
4828 if (warningcount > savew)
4829 *diagnostic_kind = DK_WARNING;
4830 else if (errorcount > savee)
4831 *diagnostic_kind = DK_ERROR;
4833 *diagnostic_kind = DK_UNSPECIFIED;
4837 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4838 EXPR is implicitly converted to type TOTYPE.
4839 FN and ARGNUM are used for diagnostics. */
4842 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
4844 tree t = non_reference (totype);
4846 /* Issue warnings about peculiar, but valid, uses of NULL. */
4847 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4850 warning_at (input_location, OPT_Wconversion_null,
4851 "passing NULL to non-pointer argument %P of %qD",
4854 warning_at (input_location, OPT_Wconversion_null,
4855 "converting to non-pointer type %qT from NULL", t);
4858 /* Issue warnings if "false" is converted to a NULL pointer */
4859 else if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4860 warning_at (input_location, OPT_Wconversion_null,
4861 "converting %<false%> to pointer type for argument %P of %qD",
4865 /* Perform the conversions in CONVS on the expression EXPR. FN and
4866 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4867 indicates the `this' argument of a method. INNER is nonzero when
4868 being called to continue a conversion chain. It is negative when a
4869 reference binding will be applied, positive otherwise. If
4870 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4871 conversions will be emitted if appropriate. If C_CAST_P is true,
4872 this conversion is coming from a C-style cast; in that case,
4873 conversions to inaccessible bases are permitted. */
4876 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4877 int inner, bool issue_conversion_warnings,
4878 bool c_cast_p, tsubst_flags_t complain)
4880 tree totype = convs->type;
4881 diagnostic_t diag_kind;
4885 && convs->kind != ck_user
4886 && convs->kind != ck_list
4887 && convs->kind != ck_ambig
4888 && convs->kind != ck_ref_bind
4889 && convs->kind != ck_rvalue
4890 && convs->kind != ck_base)
4892 conversion *t = convs;
4894 /* Give a helpful error if this is bad because of excess braces. */
4895 if (BRACE_ENCLOSED_INITIALIZER_P (expr)
4896 && SCALAR_TYPE_P (totype)
4897 && CONSTRUCTOR_NELTS (expr) > 0
4898 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value))
4899 permerror (input_location, "too many braces around initializer for %qT", totype);
4901 for (; t; t = convs->u.next)
4903 if (t->kind == ck_user || !t->bad_p)
4905 expr = convert_like_real (t, expr, fn, argnum, 1,
4906 /*issue_conversion_warnings=*/false,
4911 else if (t->kind == ck_ambig)
4912 return convert_like_real (t, expr, fn, argnum, 1,
4913 /*issue_conversion_warnings=*/false,
4916 else if (t->kind == ck_identity)
4919 if (complain & tf_error)
4921 permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4923 permerror (input_location, " initializing argument %P of %qD", argnum, fn);
4926 return error_mark_node;
4928 return cp_convert (totype, expr);
4931 if (issue_conversion_warnings && (complain & tf_warning))
4932 conversion_null_warnings (totype, expr, fn, argnum);
4934 switch (convs->kind)
4938 struct z_candidate *cand = convs->cand;
4939 tree convfn = cand->fn;
4942 expr = mark_rvalue_use (expr);
4944 /* When converting from an init list we consider explicit
4945 constructors, but actually trying to call one is an error. */
4946 if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn))
4948 if (complain & tf_error)
4949 error ("converting to %qT from initializer list would use "
4950 "explicit constructor %qD", totype, convfn);
4952 return error_mark_node;
4955 /* Set user_conv_p on the argument conversions, so rvalue/base
4956 handling knows not to allow any more UDCs. */
4957 for (i = 0; i < cand->num_convs; ++i)
4958 cand->convs[i]->user_conv_p = true;
4960 expr = build_over_call (cand, LOOKUP_NORMAL, complain);
4962 /* If this is a constructor or a function returning an aggr type,
4963 we need to build up a TARGET_EXPR. */
4964 if (DECL_CONSTRUCTOR_P (convfn))
4966 expr = build_cplus_new (totype, expr);
4968 /* Remember that this was list-initialization. */
4969 if (convs->check_narrowing)
4970 TARGET_EXPR_LIST_INIT_P (expr) = true;
4976 expr = mark_rvalue_use (expr);
4977 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
4979 int nelts = CONSTRUCTOR_NELTS (expr);
4981 expr = integer_zero_node;
4982 else if (nelts == 1)
4983 expr = CONSTRUCTOR_ELT (expr, 0)->value;
4988 if (type_unknown_p (expr))
4989 expr = instantiate_type (totype, expr, complain);
4990 /* Convert a constant to its underlying value, unless we are
4991 about to bind it to a reference, in which case we need to
4992 leave it as an lvalue. */
4995 expr = decl_constant_value (expr);
4996 if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
4997 /* If __null has been converted to an integer type, we do not
4998 want to warn about uses of EXPR as an integer, rather than
5000 expr = build_int_cst (totype, 0);
5004 if (!(complain & tf_error))
5005 return error_mark_node;
5006 /* Call build_user_type_conversion again for the error. */
5007 return build_user_type_conversion
5008 (totype, convs->u.expr, LOOKUP_NORMAL);
5012 /* Conversion to std::initializer_list<T>. */
5013 tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
5014 tree new_ctor = build_constructor (init_list_type_node, NULL);
5015 unsigned len = CONSTRUCTOR_NELTS (expr);
5017 VEC(tree,gc) *parms;
5020 /* Convert all the elements. */
5021 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
5023 tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
5024 1, false, false, complain);
5025 if (sub == error_mark_node)
5027 check_narrowing (TREE_TYPE (sub), val);
5028 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
5030 /* Build up the array. */
5031 elttype = cp_build_qualified_type
5032 (elttype, TYPE_QUALS (elttype) | TYPE_QUAL_CONST);
5033 array = build_array_of_n_type (elttype, len);
5034 array = finish_compound_literal (array, new_ctor);
5036 parms = make_tree_vector ();
5037 VEC_safe_push (tree, gc, parms, decay_conversion (array));
5038 VEC_safe_push (tree, gc, parms, size_int (len));
5039 /* Call the private constructor. */
5040 push_deferring_access_checks (dk_no_check);
5041 new_ctor = build_special_member_call
5042 (NULL_TREE, complete_ctor_identifier, &parms, totype, 0, complain);
5043 release_tree_vector (parms);
5044 pop_deferring_access_checks ();
5045 return build_cplus_new (totype, new_ctor);
5049 return get_target_expr (digest_init (totype, expr));
5055 expr = convert_like_real (convs->u.next, expr, fn, argnum,
5056 convs->kind == ck_ref_bind ? -1 : 1,
5057 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
5060 if (expr == error_mark_node)
5061 return error_mark_node;
5063 switch (convs->kind)
5066 expr = decay_conversion (expr);
5067 if (! MAYBE_CLASS_TYPE_P (totype))
5069 /* Else fall through. */
5071 if (convs->kind == ck_base && !convs->need_temporary_p)
5073 /* We are going to bind a reference directly to a base-class
5074 subobject of EXPR. */
5075 /* Build an expression for `*((base*) &expr)'. */
5076 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5077 expr = convert_to_base (expr, build_pointer_type (totype),
5078 !c_cast_p, /*nonnull=*/true, complain);
5079 expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
5083 /* Copy-initialization where the cv-unqualified version of the source
5084 type is the same class as, or a derived class of, the class of the
5085 destination [is treated as direct-initialization]. [dcl.init] */
5086 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
5087 if (convs->user_conv_p)
5088 /* This conversion is being done in the context of a user-defined
5089 conversion (i.e. the second step of copy-initialization), so
5090 don't allow any more. */
5091 flags |= LOOKUP_NO_CONVERSION;
5092 expr = build_temp (expr, totype, flags, &diag_kind);
5093 if (diag_kind && fn)
5095 if ((complain & tf_error))
5096 emit_diagnostic (diag_kind, input_location, 0,
5097 " initializing argument %P of %qD", argnum, fn);
5098 else if (diag_kind == DK_ERROR)
5099 return error_mark_node;
5101 return build_cplus_new (totype, expr);
5105 tree ref_type = totype;
5107 if (convs->bad_p && TYPE_REF_IS_RVALUE (ref_type)
5108 && real_lvalue_p (expr))
5110 if (complain & tf_error)
5112 error ("cannot bind %qT lvalue to %qT",
5113 TREE_TYPE (expr), totype);
5115 error (" initializing argument %P of %q+D", argnum, fn);
5117 return error_mark_node;
5120 /* If necessary, create a temporary.
5122 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
5123 that need temporaries, even when their types are reference
5124 compatible with the type of reference being bound, so the
5125 upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...)
5127 if (convs->need_temporary_p
5128 || TREE_CODE (expr) == CONSTRUCTOR
5129 || TREE_CODE (expr) == VA_ARG_EXPR)
5131 tree type = convs->u.next->type;
5132 cp_lvalue_kind lvalue = real_lvalue_p (expr);
5134 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
5135 && !TYPE_REF_IS_RVALUE (ref_type))
5137 if (complain & tf_error)
5139 /* If the reference is volatile or non-const, we
5140 cannot create a temporary. */
5141 if (lvalue & clk_bitfield)
5142 error ("cannot bind bitfield %qE to %qT",
5144 else if (lvalue & clk_packed)
5145 error ("cannot bind packed field %qE to %qT",
5148 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
5150 return error_mark_node;
5152 /* If the source is a packed field, and we must use a copy
5153 constructor, then building the target expr will require
5154 binding the field to the reference parameter to the
5155 copy constructor, and we'll end up with an infinite
5156 loop. If we can use a bitwise copy, then we'll be
5158 if ((lvalue & clk_packed)
5159 && CLASS_TYPE_P (type)
5160 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
5162 if (complain & tf_error)
5163 error ("cannot bind packed field %qE to %qT",
5165 return error_mark_node;
5167 if (lvalue & clk_bitfield)
5169 expr = convert_bitfield_to_declared_type (expr);
5170 expr = fold_convert (type, expr);
5172 expr = build_target_expr_with_type (expr, type);
5175 /* Take the address of the thing to which we will bind the
5177 expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain);
5178 if (expr == error_mark_node)
5179 return error_mark_node;
5181 /* Convert it to a pointer to the type referred to by the
5182 reference. This will adjust the pointer if a derived to
5183 base conversion is being performed. */
5184 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
5186 /* Convert the pointer to the desired reference type. */
5187 return build_nop (ref_type, expr);
5191 return decay_conversion (expr);
5194 /* Warn about deprecated conversion if appropriate. */
5195 string_conv_p (totype, expr, 1);
5200 expr = convert_to_base (expr, totype, !c_cast_p,
5201 /*nonnull=*/false, complain);
5202 return build_nop (totype, expr);
5205 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
5212 if (convs->check_narrowing)
5213 check_narrowing (totype, expr);
5215 if (issue_conversion_warnings && (complain & tf_warning))
5216 expr = convert_and_check (totype, expr);
5218 expr = convert (totype, expr);
5223 /* ARG is being passed to a varargs function. Perform any conversions
5224 required. Return the converted value. */
5227 convert_arg_to_ellipsis (tree arg)
5231 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5232 standard conversions are performed. */
5233 arg = decay_conversion (arg);
5236 If the argument has integral or enumeration type that is subject
5237 to the integral promotions (_conv.prom_), or a floating point
5238 type that is subject to the floating point promotion
5239 (_conv.fpprom_), the value of the argument is converted to the
5240 promoted type before the call. */
5241 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
5242 && (TYPE_PRECISION (TREE_TYPE (arg))
5243 < TYPE_PRECISION (double_type_node))
5244 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (arg))))
5245 arg = convert_to_real (double_type_node, arg);
5246 else if (NULLPTR_TYPE_P (TREE_TYPE (arg)))
5247 arg = null_pointer_node;
5248 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
5249 arg = perform_integral_promotions (arg);
5251 arg = require_complete_type (arg);
5253 if (arg != error_mark_node
5254 && (type_has_nontrivial_copy_init (TREE_TYPE (arg))
5255 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (arg))))
5257 /* [expr.call] 5.2.2/7:
5258 Passing a potentially-evaluated argument of class type (Clause 9)
5259 with a non-trivial copy constructor or a non-trivial destructor
5260 with no corresponding parameter is conditionally-supported, with
5261 implementation-defined semantics.
5263 We used to just warn here and do a bitwise copy, but now
5264 cp_expr_size will abort if we try to do that.
5266 If the call appears in the context of a sizeof expression,
5267 it is not potentially-evaluated. */
5268 if (cp_unevaluated_operand == 0)
5269 error ("cannot pass objects of non-trivially-copyable "
5270 "type %q#T through %<...%>", TREE_TYPE (arg));
5276 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
5279 build_x_va_arg (tree expr, tree type)
5281 if (processing_template_decl)
5282 return build_min (VA_ARG_EXPR, type, expr);
5284 type = complete_type_or_else (type, NULL_TREE);
5286 if (expr == error_mark_node || !type)
5287 return error_mark_node;
5289 expr = mark_lvalue_use (expr);
5291 if (type_has_nontrivial_copy_init (type)
5292 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5293 || TREE_CODE (type) == REFERENCE_TYPE)
5295 /* Remove reference types so we don't ICE later on. */
5296 tree type1 = non_reference (type);
5297 /* conditionally-supported behavior [expr.call] 5.2.2/7. */
5298 error ("cannot receive objects of non-trivially-copyable type %q#T "
5299 "through %<...%>; ", type);
5300 expr = convert (build_pointer_type (type1), null_node);
5301 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
5305 return build_va_arg (input_location, expr, type);
5308 /* TYPE has been given to va_arg. Apply the default conversions which
5309 would have happened when passed via ellipsis. Return the promoted
5310 type, or the passed type if there is no change. */
5313 cxx_type_promotes_to (tree type)
5317 /* Perform the array-to-pointer and function-to-pointer
5319 type = type_decays_to (type);
5321 promote = type_promotes_to (type);
5322 if (same_type_p (type, promote))
5328 /* ARG is a default argument expression being passed to a parameter of
5329 the indicated TYPE, which is a parameter to FN. Do any required
5330 conversions. Return the converted value. */
5332 static GTY(()) VEC(tree,gc) *default_arg_context;
5335 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
5340 /* If the ARG is an unparsed default argument expression, the
5341 conversion cannot be performed. */
5342 if (TREE_CODE (arg) == DEFAULT_ARG)
5344 error ("the default argument for parameter %d of %qD has "
5345 "not yet been parsed",
5347 return error_mark_node;
5350 /* Detect recursion. */
5351 for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
5354 error ("recursive evaluation of default argument for %q#D", fn);
5355 return error_mark_node;
5357 VEC_safe_push (tree, gc, default_arg_context, fn);
5359 if (fn && DECL_TEMPLATE_INFO (fn))
5360 arg = tsubst_default_argument (fn, type, arg);
5366 The names in the expression are bound, and the semantic
5367 constraints are checked, at the point where the default
5368 expressions appears.
5370 we must not perform access checks here. */
5371 push_deferring_access_checks (dk_no_check);
5372 arg = break_out_target_exprs (arg);
5373 if (TREE_CODE (arg) == CONSTRUCTOR)
5375 arg = digest_init (type, arg);
5376 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5377 "default argument", fn, parmnum,
5378 tf_warning_or_error);
5382 /* We must make a copy of ARG, in case subsequent processing
5383 alters any part of it. For example, during gimplification a
5384 cast of the form (T) &X::f (where "f" is a member function)
5385 will lead to replacing the PTRMEM_CST for &X::f with a
5386 VAR_DECL. We can avoid the copy for constants, since they
5387 are never modified in place. */
5388 if (!CONSTANT_CLASS_P (arg))
5389 arg = unshare_expr (arg);
5390 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5391 "default argument", fn, parmnum,
5392 tf_warning_or_error);
5393 arg = convert_for_arg_passing (type, arg);
5395 pop_deferring_access_checks();
5397 VEC_pop (tree, default_arg_context);
5402 /* Returns the type which will really be used for passing an argument of
5406 type_passed_as (tree type)
5408 /* Pass classes with copy ctors by invisible reference. */
5409 if (TREE_ADDRESSABLE (type))
5411 type = build_reference_type (type);
5412 /* There are no other pointers to this temporary. */
5413 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
5415 else if (targetm.calls.promote_prototypes (type)
5416 && INTEGRAL_TYPE_P (type)
5417 && COMPLETE_TYPE_P (type)
5418 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5419 TYPE_SIZE (integer_type_node)))
5420 type = integer_type_node;
5425 /* Actually perform the appropriate conversion. */
5428 convert_for_arg_passing (tree type, tree val)
5432 /* If VAL is a bitfield, then -- since it has already been converted
5433 to TYPE -- it cannot have a precision greater than TYPE.
5435 If it has a smaller precision, we must widen it here. For
5436 example, passing "int f:3;" to a function expecting an "int" will
5437 not result in any conversion before this point.
5439 If the precision is the same we must not risk widening. For
5440 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
5441 often have type "int", even though the C++ type for the field is
5442 "long long". If the value is being passed to a function
5443 expecting an "int", then no conversions will be required. But,
5444 if we call convert_bitfield_to_declared_type, the bitfield will
5445 be converted to "long long". */
5446 bitfield_type = is_bitfield_expr_with_lowered_type (val);
5448 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
5449 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
5451 if (val == error_mark_node)
5453 /* Pass classes with copy ctors by invisible reference. */
5454 else if (TREE_ADDRESSABLE (type))
5455 val = build1 (ADDR_EXPR, build_reference_type (type), val);
5456 else if (targetm.calls.promote_prototypes (type)
5457 && INTEGRAL_TYPE_P (type)
5458 && COMPLETE_TYPE_P (type)
5459 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5460 TYPE_SIZE (integer_type_node)))
5461 val = perform_integral_promotions (val);
5462 if (warn_missing_format_attribute)
5464 tree rhstype = TREE_TYPE (val);
5465 const enum tree_code coder = TREE_CODE (rhstype);
5466 const enum tree_code codel = TREE_CODE (type);
5467 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5469 && check_missing_format_attribute (type, rhstype))
5470 warning (OPT_Wmissing_format_attribute,
5471 "argument of function call might be a candidate for a format attribute");
5476 /* Returns true iff FN is a function with magic varargs, i.e. ones for
5477 which no conversions at all should be done. This is true for some
5478 builtins which don't act like normal functions. */
5481 magic_varargs_p (tree fn)
5483 if (DECL_BUILT_IN (fn))
5484 switch (DECL_FUNCTION_CODE (fn))
5486 case BUILT_IN_CLASSIFY_TYPE:
5487 case BUILT_IN_CONSTANT_P:
5488 case BUILT_IN_NEXT_ARG:
5489 case BUILT_IN_VA_START:
5493 return lookup_attribute ("type generic",
5494 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
5500 /* Subroutine of the various build_*_call functions. Overload resolution
5501 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
5502 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
5503 bitmask of various LOOKUP_* flags which apply to the call itself. */
5506 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
5509 const VEC(tree,gc) *args = cand->args;
5510 tree first_arg = cand->first_arg;
5511 conversion **convs = cand->convs;
5513 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5518 unsigned int arg_index = 0;
5522 bool already_used = false;
5524 /* In a template, there is no need to perform all of the work that
5525 is normally done. We are only interested in the type of the call
5526 expression, i.e., the return type of the function. Any semantic
5527 errors will be deferred until the template is instantiated. */
5528 if (processing_template_decl)
5532 const tree *argarray;
5535 return_type = TREE_TYPE (TREE_TYPE (fn));
5536 nargs = VEC_length (tree, args);
5537 if (first_arg == NULL_TREE)
5538 argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
5546 alcarray = XALLOCAVEC (tree, nargs);
5547 alcarray[0] = first_arg;
5548 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
5549 alcarray[ix + 1] = arg;
5550 argarray = alcarray;
5552 expr = build_call_array_loc (input_location,
5553 return_type, build_addr_func (fn), nargs,
5555 if (TREE_THIS_VOLATILE (fn) && cfun)
5556 current_function_returns_abnormally = 1;
5557 if (!VOID_TYPE_P (return_type))
5558 require_complete_type (return_type);
5559 return convert_from_reference (expr);
5562 /* Give any warnings we noticed during overload resolution. */
5565 struct candidate_warning *w;
5566 for (w = cand->warnings; w; w = w->next)
5567 joust (cand, w->loser, 1);
5570 /* Make =delete work with SFINAE. */
5571 if (DECL_DELETED_FN (fn) && !(complain & tf_error))
5572 return error_mark_node;
5574 if (DECL_FUNCTION_MEMBER_P (fn))
5576 /* If FN is a template function, two cases must be considered.
5581 template <class T> void f();
5583 template <class T> struct B {
5587 struct C : A, B<int> {
5589 using B<int>::g; // #2
5592 In case #1 where `A::f' is a member template, DECL_ACCESS is
5593 recorded in the primary template but not in its specialization.
5594 We check access of FN using its primary template.
5596 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
5597 because it is a member of class template B, DECL_ACCESS is
5598 recorded in the specialization `B<int>::g'. We cannot use its
5599 primary template because `B<T>::g' and `B<int>::g' may have
5600 different access. */
5601 if (DECL_TEMPLATE_INFO (fn)
5602 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
5603 perform_or_defer_access_check (cand->access_path,
5604 DECL_TI_TEMPLATE (fn), fn);
5606 perform_or_defer_access_check (cand->access_path, fn, fn);
5609 /* Find maximum size of vector to hold converted arguments. */
5610 parmlen = list_length (parm);
5611 nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
5612 if (parmlen > nargs)
5614 argarray = (tree *) alloca (nargs * sizeof (tree));
5616 /* The implicit parameters to a constructor are not considered by overload
5617 resolution, and must be of the proper type. */
5618 if (DECL_CONSTRUCTOR_P (fn))
5620 if (first_arg != NULL_TREE)
5622 argarray[j++] = first_arg;
5623 first_arg = NULL_TREE;
5627 argarray[j++] = VEC_index (tree, args, arg_index);
5630 parm = TREE_CHAIN (parm);
5631 /* We should never try to call the abstract constructor. */
5632 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
5634 if (DECL_HAS_VTT_PARM_P (fn))
5636 argarray[j++] = VEC_index (tree, args, arg_index);
5638 parm = TREE_CHAIN (parm);
5641 /* Bypass access control for 'this' parameter. */
5642 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5644 tree parmtype = TREE_VALUE (parm);
5645 tree arg = (first_arg != NULL_TREE
5647 : VEC_index (tree, args, arg_index));
5648 tree argtype = TREE_TYPE (arg);
5652 if (convs[i]->bad_p)
5654 if (complain & tf_error)
5655 permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
5656 TREE_TYPE (argtype), fn);
5658 return error_mark_node;
5661 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
5662 X is called for an object that is not of type X, or of a type
5663 derived from X, the behavior is undefined.
5665 So we can assume that anything passed as 'this' is non-null, and
5666 optimize accordingly. */
5667 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
5668 /* Convert to the base in which the function was declared. */
5669 gcc_assert (cand->conversion_path != NULL_TREE);
5670 converted_arg = build_base_path (PLUS_EXPR,
5672 cand->conversion_path,
5674 /* Check that the base class is accessible. */
5675 if (!accessible_base_p (TREE_TYPE (argtype),
5676 BINFO_TYPE (cand->conversion_path), true))
5677 error ("%qT is not an accessible base of %qT",
5678 BINFO_TYPE (cand->conversion_path),
5679 TREE_TYPE (argtype));
5680 /* If fn was found by a using declaration, the conversion path
5681 will be to the derived class, not the base declaring fn. We
5682 must convert from derived to base. */
5683 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
5684 TREE_TYPE (parmtype), ba_unique, NULL);
5685 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
5688 argarray[j++] = converted_arg;
5689 parm = TREE_CHAIN (parm);
5690 if (first_arg != NULL_TREE)
5691 first_arg = NULL_TREE;
5698 gcc_assert (first_arg == NULL_TREE);
5699 for (; arg_index < VEC_length (tree, args) && parm;
5700 parm = TREE_CHAIN (parm), ++arg_index, ++i)
5702 tree type = TREE_VALUE (parm);
5703 tree arg = VEC_index (tree, args, arg_index);
5707 /* Don't make a copy here if build_call is going to. */
5708 if (conv->kind == ck_rvalue
5709 && COMPLETE_TYPE_P (complete_type (type))
5710 && !TREE_ADDRESSABLE (type))
5711 conv = conv->u.next;
5713 /* Warn about initializer_list deduction that isn't currently in the
5715 if (cxx_dialect > cxx98
5716 && flag_deduce_init_list
5717 && cand->template_decl
5718 && is_std_init_list (non_reference (type))
5719 && BRACE_ENCLOSED_INITIALIZER_P (arg))
5721 tree tmpl = TI_TEMPLATE (cand->template_decl);
5722 tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
5723 tree patparm = get_pattern_parm (realparm, tmpl);
5724 tree pattype = TREE_TYPE (patparm);
5725 if (PACK_EXPANSION_P (pattype))
5726 pattype = PACK_EXPANSION_PATTERN (pattype);
5727 pattype = non_reference (pattype);
5729 if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM
5730 && (cand->explicit_targs == NULL_TREE
5731 || (TREE_VEC_LENGTH (cand->explicit_targs)
5732 <= TEMPLATE_TYPE_IDX (pattype))))
5734 pedwarn (input_location, 0, "deducing %qT as %qT",
5735 non_reference (TREE_TYPE (patparm)),
5736 non_reference (type));
5737 pedwarn (input_location, 0, " in call to %q+D", cand->fn);
5738 pedwarn (input_location, 0,
5739 " (you can disable this with -fno-deduce-init-list)");
5743 val = convert_like_with_context (conv, arg, fn, i-is_method, complain);
5745 val = convert_for_arg_passing (type, val);
5746 if (val == error_mark_node)
5747 return error_mark_node;
5749 argarray[j++] = val;
5752 /* Default arguments */
5753 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5754 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5755 TREE_PURPOSE (parm),
5758 for (; arg_index < VEC_length (tree, args); ++arg_index)
5760 tree a = VEC_index (tree, args, arg_index);
5761 if (magic_varargs_p (fn))
5762 /* Do no conversions for magic varargs. */
5763 a = mark_type_use (a);
5765 a = convert_arg_to_ellipsis (a);
5769 gcc_assert (j <= nargs);
5772 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5773 nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5775 /* Avoid actually calling copy constructors and copy assignment operators,
5778 if (! flag_elide_constructors)
5779 /* Do things the hard way. */;
5780 else if (cand->num_convs == 1
5781 && (DECL_COPY_CONSTRUCTOR_P (fn)
5782 || DECL_MOVE_CONSTRUCTOR_P (fn)))
5785 tree arg = argarray[num_artificial_parms_for (fn)];
5788 /* Pull out the real argument, disregarding const-correctness. */
5790 while (CONVERT_EXPR_P (targ)
5791 || TREE_CODE (targ) == NON_LVALUE_EXPR)
5792 targ = TREE_OPERAND (targ, 0);
5793 if (TREE_CODE (targ) == ADDR_EXPR)
5795 targ = TREE_OPERAND (targ, 0);
5796 if (!same_type_ignoring_top_level_qualifiers_p
5797 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5806 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5808 if (TREE_CODE (arg) == TARGET_EXPR
5809 && TARGET_EXPR_LIST_INIT_P (arg))
5811 /* Copy-list-initialization doesn't require the copy constructor
5814 /* [class.copy]: the copy constructor is implicitly defined even if
5815 the implementation elided its use. */
5816 else if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn))
5820 already_used = true;
5823 /* If we're creating a temp and we already have one, don't create a
5824 new one. If we're not creating a temp but we get one, use
5825 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5826 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5827 temp or an INIT_EXPR otherwise. */
5828 fa = (cand->first_arg != NULL_TREE
5830 : VEC_index (tree, args, 0));
5831 if (integer_zerop (fa))
5833 if (TREE_CODE (arg) == TARGET_EXPR)
5835 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5837 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5839 else if (TREE_CODE (arg) == TARGET_EXPR
5840 || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5841 && !move_fn_p (fn)))
5843 tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
5846 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5850 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5852 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5854 tree to = stabilize_reference
5855 (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
5856 tree type = TREE_TYPE (to);
5857 tree as_base = CLASSTYPE_AS_BASE (type);
5858 tree arg = argarray[1];
5860 if (is_really_empty_class (type))
5862 /* Avoid copying empty classes. */
5863 val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
5864 TREE_NO_WARNING (val) = 1;
5865 val = build2 (COMPOUND_EXPR, type, val, to);
5866 TREE_NO_WARNING (val) = 1;
5868 else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5870 arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5871 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5875 /* We must only copy the non-tail padding parts.
5876 Use __builtin_memcpy for the bitwise copy.
5877 FIXME fix 22488 so we can go back to using MODIFY_EXPR
5878 instead of an explicit call to memcpy. */
5880 tree arg0, arg1, arg2, t;
5881 tree test = NULL_TREE;
5883 arg2 = TYPE_SIZE_UNIT (as_base);
5885 arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5887 if (!can_trust_pointer_alignment ())
5889 /* If we can't be sure about pointer alignment, a call
5890 to __builtin_memcpy is expanded as a call to memcpy, which
5891 is invalid with identical args. Otherwise it is
5892 expanded as a block move, which should be safe. */
5893 arg0 = save_expr (arg0);
5894 arg1 = save_expr (arg1);
5895 test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5897 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5898 t = build_call_n (t, 3, arg0, arg1, arg2);
5900 t = convert (TREE_TYPE (arg0), t);
5902 t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5903 val = cp_build_indirect_ref (t, RO_NULL, complain);
5904 TREE_NO_WARNING (val) = 1;
5913 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5916 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5919 gcc_assert (binfo && binfo != error_mark_node);
5921 /* Warn about deprecated virtual functions now, since we're about
5922 to throw away the decl. */
5923 if (TREE_DEPRECATED (fn))
5924 warn_deprecated_use (fn, NULL_TREE);
5926 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5927 if (TREE_SIDE_EFFECTS (argarray[0]))
5928 argarray[0] = save_expr (argarray[0]);
5929 t = build_pointer_type (TREE_TYPE (fn));
5930 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5931 fn = build_java_interface_fn_ref (fn, argarray[0]);
5933 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5937 fn = build_addr_func (fn);
5939 return build_cxx_call (fn, nargs, argarray);
5942 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5943 This function performs no overload resolution, conversion, or other
5944 high-level operations. */
5947 build_cxx_call (tree fn, int nargs, tree *argarray)
5951 fn = build_call_a (fn, nargs, argarray);
5953 /* If this call might throw an exception, note that fact. */
5954 fndecl = get_callee_fndecl (fn);
5955 if ((!fndecl || !TREE_NOTHROW (fndecl))
5956 && at_function_scope_p ()
5958 cp_function_chain->can_throw = 1;
5960 /* Check that arguments to builtin functions match the expectations. */
5962 && DECL_BUILT_IN (fndecl)
5963 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5964 && !check_builtin_function_arguments (fndecl, nargs, argarray))
5965 return error_mark_node;
5967 /* Some built-in function calls will be evaluated at compile-time in
5969 fn = fold_if_not_in_template (fn);
5971 if (VOID_TYPE_P (TREE_TYPE (fn)))
5974 fn = require_complete_type (fn);
5975 if (fn == error_mark_node)
5976 return error_mark_node;
5978 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
5979 fn = build_cplus_new (TREE_TYPE (fn), fn);
5980 return convert_from_reference (fn);
5983 static GTY(()) tree java_iface_lookup_fn;
5985 /* Make an expression which yields the address of the Java interface
5986 method FN. This is achieved by generating a call to libjava's
5987 _Jv_LookupInterfaceMethodIdx(). */
5990 build_java_interface_fn_ref (tree fn, tree instance)
5992 tree lookup_fn, method, idx;
5993 tree klass_ref, iface, iface_ref;
5996 if (!java_iface_lookup_fn)
5998 tree endlink = build_void_list_node ();
5999 tree t = tree_cons (NULL_TREE, ptr_type_node,
6000 tree_cons (NULL_TREE, ptr_type_node,
6001 tree_cons (NULL_TREE, java_int_type_node,
6003 java_iface_lookup_fn
6004 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
6005 build_function_type (ptr_type_node, t),
6006 0, NOT_BUILT_IN, NULL, NULL_TREE);
6009 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
6010 This is the first entry in the vtable. */
6011 klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
6012 tf_warning_or_error),
6015 /* Get the java.lang.Class pointer for the interface being called. */
6016 iface = DECL_CONTEXT (fn);
6017 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
6018 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
6019 || DECL_CONTEXT (iface_ref) != iface)
6021 error ("could not find class$ field in java interface type %qT",
6023 return error_mark_node;
6025 iface_ref = build_address (iface_ref);
6026 iface_ref = convert (build_pointer_type (iface), iface_ref);
6028 /* Determine the itable index of FN. */
6030 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
6032 if (!DECL_VIRTUAL_P (method))
6038 idx = build_int_cst (NULL_TREE, i);
6040 lookup_fn = build1 (ADDR_EXPR,
6041 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6042 java_iface_lookup_fn);
6043 return build_call_nary (ptr_type_node, lookup_fn,
6044 3, klass_ref, iface_ref, idx);
6047 /* Returns the value to use for the in-charge parameter when making a
6048 call to a function with the indicated NAME.
6050 FIXME:Can't we find a neater way to do this mapping? */
6053 in_charge_arg_for_name (tree name)
6055 if (name == base_ctor_identifier
6056 || name == base_dtor_identifier)
6057 return integer_zero_node;
6058 else if (name == complete_ctor_identifier)
6059 return integer_one_node;
6060 else if (name == complete_dtor_identifier)
6061 return integer_two_node;
6062 else if (name == deleting_dtor_identifier)
6063 return integer_three_node;
6065 /* This function should only be called with one of the names listed
6071 /* Build a call to a constructor, destructor, or an assignment
6072 operator for INSTANCE, an expression with class type. NAME
6073 indicates the special member function to call; *ARGS are the
6074 arguments. ARGS may be NULL. This may change ARGS. BINFO
6075 indicates the base of INSTANCE that is to be passed as the `this'
6076 parameter to the member function called.
6078 FLAGS are the LOOKUP_* flags to use when processing the call.
6080 If NAME indicates a complete object constructor, INSTANCE may be
6081 NULL_TREE. In this case, the caller will call build_cplus_new to
6082 store the newly constructed object into a VAR_DECL. */
6085 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6086 tree binfo, int flags, tsubst_flags_t complain)
6089 /* The type of the subobject to be constructed or destroyed. */
6091 VEC(tree,gc) *allocated = NULL;
6094 gcc_assert (name == complete_ctor_identifier
6095 || name == base_ctor_identifier
6096 || name == complete_dtor_identifier
6097 || name == base_dtor_identifier
6098 || name == deleting_dtor_identifier
6099 || name == ansi_assopname (NOP_EXPR));
6102 /* Resolve the name. */
6103 if (!complete_type_or_else (binfo, NULL_TREE))
6104 return error_mark_node;
6106 binfo = TYPE_BINFO (binfo);
6109 gcc_assert (binfo != NULL_TREE);
6111 class_type = BINFO_TYPE (binfo);
6113 /* Handle the special case where INSTANCE is NULL_TREE. */
6114 if (name == complete_ctor_identifier && !instance)
6116 instance = build_int_cst (build_pointer_type (class_type), 0);
6117 instance = build1 (INDIRECT_REF, class_type, instance);
6121 if (name == complete_dtor_identifier
6122 || name == base_dtor_identifier
6123 || name == deleting_dtor_identifier)
6124 gcc_assert (args == NULL || VEC_empty (tree, *args));
6126 /* Convert to the base class, if necessary. */
6127 if (!same_type_ignoring_top_level_qualifiers_p
6128 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6130 if (name != ansi_assopname (NOP_EXPR))
6131 /* For constructors and destructors, either the base is
6132 non-virtual, or it is virtual but we are doing the
6133 conversion from a constructor or destructor for the
6134 complete object. In either case, we can convert
6136 instance = convert_to_base_statically (instance, binfo);
6138 /* However, for assignment operators, we must convert
6139 dynamically if the base is virtual. */
6140 instance = build_base_path (PLUS_EXPR, instance,
6141 binfo, /*nonnull=*/1);
6145 gcc_assert (instance != NULL_TREE);
6147 fns = lookup_fnfields (binfo, name, 1);
6149 /* When making a call to a constructor or destructor for a subobject
6150 that uses virtual base classes, pass down a pointer to a VTT for
6152 if ((name == base_ctor_identifier
6153 || name == base_dtor_identifier)
6154 && CLASSTYPE_VBASECLASSES (class_type))
6159 /* If the current function is a complete object constructor
6160 or destructor, then we fetch the VTT directly.
6161 Otherwise, we look it up using the VTT we were given. */
6162 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6163 vtt = decay_conversion (vtt);
6164 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6165 build2 (EQ_EXPR, boolean_type_node,
6166 current_in_charge_parm, integer_zero_node),
6169 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6170 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6171 BINFO_SUBVTT_INDEX (binfo));
6175 allocated = make_tree_vector ();
6179 VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6182 ret = build_new_method_call (instance, fns, args,
6183 TYPE_BINFO (BINFO_TYPE (binfo)),
6187 if (allocated != NULL)
6188 release_tree_vector (allocated);
6193 /* Return the NAME, as a C string. The NAME indicates a function that
6194 is a member of TYPE. *FREE_P is set to true if the caller must
6195 free the memory returned.
6197 Rather than go through all of this, we should simply set the names
6198 of constructors and destructors appropriately, and dispense with
6199 ctor_identifier, dtor_identifier, etc. */
6202 name_as_c_string (tree name, tree type, bool *free_p)
6206 /* Assume that we will not allocate memory. */
6208 /* Constructors and destructors are special. */
6209 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6212 = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6213 /* For a destructor, add the '~'. */
6214 if (name == complete_dtor_identifier
6215 || name == base_dtor_identifier
6216 || name == deleting_dtor_identifier)
6218 pretty_name = concat ("~", pretty_name, NULL);
6219 /* Remember that we need to free the memory allocated. */
6223 else if (IDENTIFIER_TYPENAME_P (name))
6225 pretty_name = concat ("operator ",
6226 type_as_string_translate (TREE_TYPE (name),
6227 TFF_PLAIN_IDENTIFIER),
6229 /* Remember that we need to free the memory allocated. */
6233 pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6238 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
6239 be set, upon return, to the function called. ARGS may be NULL.
6240 This may change ARGS. */
6243 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
6244 tree conversion_path, int flags,
6245 tree *fn_p, tsubst_flags_t complain)
6247 struct z_candidate *candidates = 0, *cand;
6248 tree explicit_targs = NULL_TREE;
6249 tree basetype = NULL_TREE;
6252 tree first_mem_arg = NULL_TREE;
6255 bool skip_first_for_error;
6256 VEC(tree,gc) *user_args;
6259 int template_only = 0;
6263 VEC(tree,gc) *orig_args = NULL;
6265 tree list = NULL_TREE;
6268 gcc_assert (instance != NULL_TREE);
6270 /* We don't know what function we're going to call, yet. */
6274 if (error_operand_p (instance)
6275 || !fns || error_operand_p (fns))
6276 return error_mark_node;
6278 if (!BASELINK_P (fns))
6280 if (complain & tf_error)
6281 error ("call to non-function %qD", fns);
6282 return error_mark_node;
6285 orig_instance = instance;
6288 /* Dismantle the baselink to collect all the information we need. */
6289 if (!conversion_path)
6290 conversion_path = BASELINK_BINFO (fns);
6291 access_binfo = BASELINK_ACCESS_BINFO (fns);
6292 optype = BASELINK_OPTYPE (fns);
6293 fns = BASELINK_FUNCTIONS (fns);
6294 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6296 explicit_targs = TREE_OPERAND (fns, 1);
6297 fns = TREE_OPERAND (fns, 0);
6300 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6301 || TREE_CODE (fns) == TEMPLATE_DECL
6302 || TREE_CODE (fns) == OVERLOAD);
6303 fn = get_first_fn (fns);
6304 name = DECL_NAME (fn);
6306 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6307 gcc_assert (CLASS_TYPE_P (basetype));
6309 if (processing_template_decl)
6311 orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6312 instance = build_non_dependent_expr (instance);
6314 make_args_non_dependent (*args);
6317 user_args = args == NULL ? NULL : *args;
6318 /* Under DR 147 A::A() is an invalid constructor call,
6319 not a functional cast. */
6320 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
6322 if (! (complain & tf_error))
6323 return error_mark_node;
6325 permerror (input_location,
6326 "cannot call constructor %<%T::%D%> directly",
6328 permerror (input_location, " for a function-style cast, remove the "
6329 "redundant %<::%D%>", name);
6330 call = build_functional_cast (basetype, build_tree_list_vec (user_args),
6335 /* Figure out whether to skip the first argument for the error
6336 message we will display to users if an error occurs. We don't
6337 want to display any compiler-generated arguments. The "this"
6338 pointer hasn't been added yet. However, we must remove the VTT
6339 pointer if this is a call to a base-class constructor or
6341 skip_first_for_error = false;
6342 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6344 /* Callers should explicitly indicate whether they want to construct
6345 the complete object or just the part without virtual bases. */
6346 gcc_assert (name != ctor_identifier);
6347 /* Similarly for destructors. */
6348 gcc_assert (name != dtor_identifier);
6349 /* Remove the VTT pointer, if present. */
6350 if ((name == base_ctor_identifier || name == base_dtor_identifier)
6351 && CLASSTYPE_VBASECLASSES (basetype))
6352 skip_first_for_error = true;
6355 /* Process the argument list. */
6356 if (args != NULL && *args != NULL)
6358 *args = resolve_args (*args);
6360 return error_mark_node;
6363 instance_ptr = build_this (instance);
6365 /* It's OK to call destructors and constructors on cv-qualified objects.
6366 Therefore, convert the INSTANCE_PTR to the unqualified type, if
6368 if (DECL_DESTRUCTOR_P (fn)
6369 || DECL_CONSTRUCTOR_P (fn))
6371 tree type = build_pointer_type (basetype);
6372 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6373 instance_ptr = build_nop (type, instance_ptr);
6375 if (DECL_DESTRUCTOR_P (fn))
6376 name = complete_dtor_identifier;
6378 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6379 initializer, not T({ }). If the type doesn't have a list ctor (or no
6380 viable list ctor), break apart the list into separate ctor args. */
6382 if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6383 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6384 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
6386 gcc_assert (VEC_length (tree, *args) == 1);
6387 list = VEC_index (tree, *args, 0);
6389 if (TYPE_HAS_LIST_CTOR (basetype))
6390 flags |= LOOKUP_LIST_ONLY;
6395 first_mem_arg = instance_ptr;
6397 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6398 p = conversion_obstack_alloc (0);
6400 any_viable_p = false;
6403 add_candidates (fns, first_mem_arg, user_args, optype,
6404 explicit_targs, template_only, conversion_path,
6405 access_binfo, flags, &candidates);
6406 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6409 if (!any_viable_p && list)
6411 VEC(tree,gc) *list_args = ctor_to_vec (list);
6412 flags &= ~LOOKUP_LIST_ONLY;
6413 add_candidates (fns, first_mem_arg, list_args, optype,
6414 explicit_targs, template_only, conversion_path,
6415 access_binfo, flags, &candidates);
6416 candidates = splice_viable (candidates, pedantic, &any_viable_p);
6421 if (complain & tf_error)
6423 if (!COMPLETE_TYPE_P (basetype))
6424 cxx_incomplete_type_error (instance_ptr, basetype);
6426 error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
6427 basetype, optype, build_tree_list_vec (user_args),
6428 TREE_TYPE (TREE_TYPE (instance_ptr)));
6435 pretty_name = name_as_c_string (name, basetype, &free_p);
6436 arglist = build_tree_list_vec (user_args);
6437 if (skip_first_for_error)
6438 arglist = TREE_CHAIN (arglist);
6439 error ("no matching function for call to %<%T::%s(%A)%#V%>",
6440 basetype, pretty_name, arglist,
6441 TREE_TYPE (TREE_TYPE (instance_ptr)));
6445 print_z_candidates (candidates);
6447 call = error_mark_node;
6451 cand = tourney (candidates);
6458 if (complain & tf_error)
6460 pretty_name = name_as_c_string (name, basetype, &free_p);
6461 arglist = build_tree_list_vec (user_args);
6462 if (skip_first_for_error)
6463 arglist = TREE_CHAIN (arglist);
6464 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6466 print_z_candidates (candidates);
6470 call = error_mark_node;
6476 if (!(flags & LOOKUP_NONVIRTUAL)
6477 && DECL_PURE_VIRTUAL_P (fn)
6478 && instance == current_class_ref
6479 && (DECL_CONSTRUCTOR_P (current_function_decl)
6480 || DECL_DESTRUCTOR_P (current_function_decl))
6481 && (complain & tf_warning))
6482 /* This is not an error, it is runtime undefined
6484 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6485 "pure virtual %q#D called from constructor"
6486 : "pure virtual %q#D called from destructor"),
6489 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6490 && is_dummy_object (instance_ptr))
6492 if (complain & tf_error)
6493 error ("cannot call member function %qD without object",
6495 call = error_mark_node;
6499 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6500 && resolves_to_fixed_type_p (instance, 0))
6501 flags |= LOOKUP_NONVIRTUAL;
6502 /* Now we know what function is being called. */
6505 /* Build the actual CALL_EXPR. */
6506 call = build_over_call (cand, flags, complain);
6507 /* In an expression of the form `a->f()' where `f' turns
6508 out to be a static member function, `a' is
6509 none-the-less evaluated. */
6510 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6511 && !is_dummy_object (instance_ptr)
6512 && TREE_SIDE_EFFECTS (instance_ptr))
6513 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6514 instance_ptr, call);
6515 else if (call != error_mark_node
6516 && DECL_DESTRUCTOR_P (cand->fn)
6517 && !VOID_TYPE_P (TREE_TYPE (call)))
6518 /* An explicit call of the form "x->~X()" has type
6519 "void". However, on platforms where destructors
6520 return "this" (i.e., those where
6521 targetm.cxx.cdtor_returns_this is true), such calls
6522 will appear to have a return value of pointer type
6523 to the low-level call machinery. We do not want to
6524 change the low-level machinery, since we want to be
6525 able to optimize "delete f()" on such platforms as
6526 "operator delete(~X(f()))" (rather than generating
6527 "t = f(), ~X(t), operator delete (t)"). */
6528 call = build_nop (void_type_node, call);
6533 if (processing_template_decl && call != error_mark_node)
6535 bool cast_to_void = false;
6537 if (TREE_CODE (call) == COMPOUND_EXPR)
6538 call = TREE_OPERAND (call, 1);
6539 else if (TREE_CODE (call) == NOP_EXPR)
6541 cast_to_void = true;
6542 call = TREE_OPERAND (call, 0);
6544 if (TREE_CODE (call) == INDIRECT_REF)
6545 call = TREE_OPERAND (call, 0);
6546 call = (build_min_non_dep_call_vec
6548 build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6549 orig_instance, orig_fns, NULL_TREE),
6551 call = convert_from_reference (call);
6553 call = build_nop (void_type_node, call);
6556 /* Free all the conversions we allocated. */
6557 obstack_free (&conversion_obstack, p);
6559 if (orig_args != NULL)
6560 release_tree_vector (orig_args);
6565 /* Returns true iff standard conversion sequence ICS1 is a proper
6566 subsequence of ICS2. */
6569 is_subseq (conversion *ics1, conversion *ics2)
6571 /* We can assume that a conversion of the same code
6572 between the same types indicates a subsequence since we only get
6573 here if the types we are converting from are the same. */
6575 while (ics1->kind == ck_rvalue
6576 || ics1->kind == ck_lvalue)
6577 ics1 = ics1->u.next;
6581 while (ics2->kind == ck_rvalue
6582 || ics2->kind == ck_lvalue)
6583 ics2 = ics2->u.next;
6585 if (ics2->kind == ck_user
6586 || ics2->kind == ck_ambig
6587 || ics2->kind == ck_identity)
6588 /* At this point, ICS1 cannot be a proper subsequence of
6589 ICS2. We can get a USER_CONV when we are comparing the
6590 second standard conversion sequence of two user conversion
6594 ics2 = ics2->u.next;
6596 if (ics2->kind == ics1->kind
6597 && same_type_p (ics2->type, ics1->type)
6598 && same_type_p (ics2->u.next->type,
6599 ics1->u.next->type))
6604 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
6605 be any _TYPE nodes. */
6608 is_properly_derived_from (tree derived, tree base)
6610 if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6613 /* We only allow proper derivation here. The DERIVED_FROM_P macro
6614 considers every class derived from itself. */
6615 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6616 && DERIVED_FROM_P (base, derived));
6619 /* We build the ICS for an implicit object parameter as a pointer
6620 conversion sequence. However, such a sequence should be compared
6621 as if it were a reference conversion sequence. If ICS is the
6622 implicit conversion sequence for an implicit object parameter,
6623 modify it accordingly. */
6626 maybe_handle_implicit_object (conversion **ics)
6630 /* [over.match.funcs]
6632 For non-static member functions, the type of the
6633 implicit object parameter is "reference to cv X"
6634 where X is the class of which the function is a
6635 member and cv is the cv-qualification on the member
6636 function declaration. */
6637 conversion *t = *ics;
6638 tree reference_type;
6640 /* The `this' parameter is a pointer to a class type. Make the
6641 implicit conversion talk about a reference to that same class
6643 reference_type = TREE_TYPE (t->type);
6644 reference_type = build_reference_type (reference_type);
6646 if (t->kind == ck_qual)
6648 if (t->kind == ck_ptr)
6650 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6651 t = direct_reference_binding (reference_type, t);
6653 t->rvaluedness_matches_p = 0;
6658 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6659 and return the initial reference binding conversion. Otherwise,
6660 leave *ICS unchanged and return NULL. */
6663 maybe_handle_ref_bind (conversion **ics)
6665 if ((*ics)->kind == ck_ref_bind)
6667 conversion *old_ics = *ics;
6668 *ics = old_ics->u.next;
6669 (*ics)->user_conv_p = old_ics->user_conv_p;
6676 /* Compare two implicit conversion sequences according to the rules set out in
6677 [over.ics.rank]. Return values:
6679 1: ics1 is better than ics2
6680 -1: ics2 is better than ics1
6681 0: ics1 and ics2 are indistinguishable */
6684 compare_ics (conversion *ics1, conversion *ics2)
6690 tree deref_from_type1 = NULL_TREE;
6691 tree deref_from_type2 = NULL_TREE;
6692 tree deref_to_type1 = NULL_TREE;
6693 tree deref_to_type2 = NULL_TREE;
6694 conversion_rank rank1, rank2;
6696 /* REF_BINDING is nonzero if the result of the conversion sequence
6697 is a reference type. In that case REF_CONV is the reference
6698 binding conversion. */
6699 conversion *ref_conv1;
6700 conversion *ref_conv2;
6702 /* Handle implicit object parameters. */
6703 maybe_handle_implicit_object (&ics1);
6704 maybe_handle_implicit_object (&ics2);
6706 /* Handle reference parameters. */
6707 ref_conv1 = maybe_handle_ref_bind (&ics1);
6708 ref_conv2 = maybe_handle_ref_bind (&ics2);
6710 /* List-initialization sequence L1 is a better conversion sequence than
6711 list-initialization sequence L2 if L1 converts to
6712 std::initializer_list<X> for some X and L2 does not. */
6713 if (ics1->kind == ck_list && ics2->kind != ck_list)
6715 if (ics2->kind == ck_list && ics1->kind != ck_list)
6720 When comparing the basic forms of implicit conversion sequences (as
6721 defined in _over.best.ics_)
6723 --a standard conversion sequence (_over.ics.scs_) is a better
6724 conversion sequence than a user-defined conversion sequence
6725 or an ellipsis conversion sequence, and
6727 --a user-defined conversion sequence (_over.ics.user_) is a
6728 better conversion sequence than an ellipsis conversion sequence
6729 (_over.ics.ellipsis_). */
6730 rank1 = CONVERSION_RANK (ics1);
6731 rank2 = CONVERSION_RANK (ics2);
6735 else if (rank1 < rank2)
6738 if (rank1 == cr_bad)
6740 /* XXX Isn't this an extension? */
6741 /* Both ICS are bad. We try to make a decision based on what
6742 would have happened if they'd been good. */
6743 if (ics1->user_conv_p > ics2->user_conv_p
6744 || ics1->rank > ics2->rank)
6746 else if (ics1->user_conv_p < ics2->user_conv_p
6747 || ics1->rank < ics2->rank)
6750 /* We couldn't make up our minds; try to figure it out below. */
6753 if (ics1->ellipsis_p || ics1->kind == ck_list)
6754 /* Both conversions are ellipsis conversions or both are building a
6755 std::initializer_list. */
6758 /* User-defined conversion sequence U1 is a better conversion sequence
6759 than another user-defined conversion sequence U2 if they contain the
6760 same user-defined conversion operator or constructor and if the sec-
6761 ond standard conversion sequence of U1 is better than the second
6762 standard conversion sequence of U2. */
6764 if (ics1->user_conv_p)
6769 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
6770 if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6772 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
6773 if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6776 if (t1->cand->fn != t2->cand->fn)
6779 /* We can just fall through here, after setting up
6780 FROM_TYPE1 and FROM_TYPE2. */
6781 from_type1 = t1->type;
6782 from_type2 = t2->type;
6789 /* We're dealing with two standard conversion sequences.
6793 Standard conversion sequence S1 is a better conversion
6794 sequence than standard conversion sequence S2 if
6796 --S1 is a proper subsequence of S2 (comparing the conversion
6797 sequences in the canonical form defined by _over.ics.scs_,
6798 excluding any Lvalue Transformation; the identity
6799 conversion sequence is considered to be a subsequence of
6800 any non-identity conversion sequence */
6803 while (t1->kind != ck_identity)
6805 from_type1 = t1->type;
6808 while (t2->kind != ck_identity)
6810 from_type2 = t2->type;
6813 /* One sequence can only be a subsequence of the other if they start with
6814 the same type. They can start with different types when comparing the
6815 second standard conversion sequence in two user-defined conversion
6817 if (same_type_p (from_type1, from_type2))
6819 if (is_subseq (ics1, ics2))
6821 if (is_subseq (ics2, ics1))
6829 --the rank of S1 is better than the rank of S2 (by the rules
6832 Standard conversion sequences are ordered by their ranks: an Exact
6833 Match is a better conversion than a Promotion, which is a better
6834 conversion than a Conversion.
6836 Two conversion sequences with the same rank are indistinguishable
6837 unless one of the following rules applies:
6839 --A conversion that does not a convert a pointer, pointer to member,
6840 or std::nullptr_t to bool is better than one that does.
6842 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6843 so that we do not have to check it explicitly. */
6844 if (ics1->rank < ics2->rank)
6846 else if (ics2->rank < ics1->rank)
6849 to_type1 = ics1->type;
6850 to_type2 = ics2->type;
6852 /* A conversion from scalar arithmetic type to complex is worse than a
6853 conversion between scalar arithmetic types. */
6854 if (same_type_p (from_type1, from_type2)
6855 && ARITHMETIC_TYPE_P (from_type1)
6856 && ARITHMETIC_TYPE_P (to_type1)
6857 && ARITHMETIC_TYPE_P (to_type2)
6858 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6859 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6861 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6867 if (TYPE_PTR_P (from_type1)
6868 && TYPE_PTR_P (from_type2)
6869 && TYPE_PTR_P (to_type1)
6870 && TYPE_PTR_P (to_type2))
6872 deref_from_type1 = TREE_TYPE (from_type1);
6873 deref_from_type2 = TREE_TYPE (from_type2);
6874 deref_to_type1 = TREE_TYPE (to_type1);
6875 deref_to_type2 = TREE_TYPE (to_type2);
6877 /* The rules for pointers to members A::* are just like the rules
6878 for pointers A*, except opposite: if B is derived from A then
6879 A::* converts to B::*, not vice versa. For that reason, we
6880 switch the from_ and to_ variables here. */
6881 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6882 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6883 || (TYPE_PTRMEMFUNC_P (from_type1)
6884 && TYPE_PTRMEMFUNC_P (from_type2)
6885 && TYPE_PTRMEMFUNC_P (to_type1)
6886 && TYPE_PTRMEMFUNC_P (to_type2)))
6888 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6889 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6890 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6891 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6894 if (deref_from_type1 != NULL_TREE
6895 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6896 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6898 /* This was one of the pointer or pointer-like conversions.
6902 --If class B is derived directly or indirectly from class A,
6903 conversion of B* to A* is better than conversion of B* to
6904 void*, and conversion of A* to void* is better than
6905 conversion of B* to void*. */
6906 if (TREE_CODE (deref_to_type1) == VOID_TYPE
6907 && TREE_CODE (deref_to_type2) == VOID_TYPE)
6909 if (is_properly_derived_from (deref_from_type1,
6912 else if (is_properly_derived_from (deref_from_type2,
6916 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6917 || TREE_CODE (deref_to_type2) == VOID_TYPE)
6919 if (same_type_p (deref_from_type1, deref_from_type2))
6921 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6923 if (is_properly_derived_from (deref_from_type1,
6927 /* We know that DEREF_TO_TYPE1 is `void' here. */
6928 else if (is_properly_derived_from (deref_from_type1,
6933 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6934 && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6938 --If class B is derived directly or indirectly from class A
6939 and class C is derived directly or indirectly from B,
6941 --conversion of C* to B* is better than conversion of C* to
6944 --conversion of B* to A* is better than conversion of C* to
6946 if (same_type_p (deref_from_type1, deref_from_type2))
6948 if (is_properly_derived_from (deref_to_type1,
6951 else if (is_properly_derived_from (deref_to_type2,
6955 else if (same_type_p (deref_to_type1, deref_to_type2))
6957 if (is_properly_derived_from (deref_from_type2,
6960 else if (is_properly_derived_from (deref_from_type1,
6966 else if (CLASS_TYPE_P (non_reference (from_type1))
6967 && same_type_p (from_type1, from_type2))
6969 tree from = non_reference (from_type1);
6973 --binding of an expression of type C to a reference of type
6974 B& is better than binding an expression of type C to a
6975 reference of type A&
6977 --conversion of C to B is better than conversion of C to A, */
6978 if (is_properly_derived_from (from, to_type1)
6979 && is_properly_derived_from (from, to_type2))
6981 if (is_properly_derived_from (to_type1, to_type2))
6983 else if (is_properly_derived_from (to_type2, to_type1))
6987 else if (CLASS_TYPE_P (non_reference (to_type1))
6988 && same_type_p (to_type1, to_type2))
6990 tree to = non_reference (to_type1);
6994 --binding of an expression of type B to a reference of type
6995 A& is better than binding an expression of type C to a
6996 reference of type A&,
6998 --conversion of B to A is better than conversion of C to A */
6999 if (is_properly_derived_from (from_type1, to)
7000 && is_properly_derived_from (from_type2, to))
7002 if (is_properly_derived_from (from_type2, from_type1))
7004 else if (is_properly_derived_from (from_type1, from_type2))
7011 --S1 and S2 differ only in their qualification conversion and yield
7012 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
7013 qualification signature of type T1 is a proper subset of the cv-
7014 qualification signature of type T2 */
7015 if (ics1->kind == ck_qual
7016 && ics2->kind == ck_qual
7017 && same_type_p (from_type1, from_type2))
7019 int result = comp_cv_qual_signature (to_type1, to_type2);
7026 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
7027 to an implicit object parameter, and either S1 binds an lvalue reference
7028 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
7029 reference to an rvalue and S2 binds an lvalue reference
7030 (C++0x draft standard, 13.3.3.2)
7032 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
7033 types to which the references refer are the same type except for
7034 top-level cv-qualifiers, and the type to which the reference
7035 initialized by S2 refers is more cv-qualified than the type to
7036 which the reference initialized by S1 refers */
7038 if (ref_conv1 && ref_conv2)
7040 if (!ref_conv1->this_p && !ref_conv2->this_p
7041 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7042 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7044 if (ref_conv1->rvaluedness_matches_p)
7046 if (ref_conv2->rvaluedness_matches_p)
7050 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7051 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7052 TREE_TYPE (ref_conv1->type));
7055 /* Neither conversion sequence is better than the other. */
7059 /* The source type for this standard conversion sequence. */
7062 source_type (conversion *t)
7064 for (;; t = t->u.next)
7066 if (t->kind == ck_user
7067 || t->kind == ck_ambig
7068 || t->kind == ck_identity)
7074 /* Note a warning about preferring WINNER to LOSER. We do this by storing
7075 a pointer to LOSER and re-running joust to produce the warning if WINNER
7076 is actually used. */
7079 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7081 candidate_warning *cw = (candidate_warning *)
7082 conversion_obstack_alloc (sizeof (candidate_warning));
7084 cw->next = winner->warnings;
7085 winner->warnings = cw;
7088 /* Compare two candidates for overloading as described in
7089 [over.match.best]. Return values:
7091 1: cand1 is better than cand2
7092 -1: cand2 is better than cand1
7093 0: cand1 and cand2 are indistinguishable */
7096 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7099 int off1 = 0, off2 = 0;
7103 /* Candidates that involve bad conversions are always worse than those
7105 if (cand1->viable > cand2->viable)
7107 if (cand1->viable < cand2->viable)
7110 /* If we have two pseudo-candidates for conversions to the same type,
7111 or two candidates for the same function, arbitrarily pick one. */
7112 if (cand1->fn == cand2->fn
7113 && (IS_TYPE_OR_DECL_P (cand1->fn)))
7116 /* a viable function F1
7117 is defined to be a better function than another viable function F2 if
7118 for all arguments i, ICSi(F1) is not a worse conversion sequence than
7119 ICSi(F2), and then */
7121 /* for some argument j, ICSj(F1) is a better conversion sequence than
7124 /* For comparing static and non-static member functions, we ignore
7125 the implicit object parameter of the non-static function. The
7126 standard says to pretend that the static function has an object
7127 parm, but that won't work with operator overloading. */
7128 len = cand1->num_convs;
7129 if (len != cand2->num_convs)
7131 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7132 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7134 gcc_assert (static_1 != static_2);
7145 for (i = 0; i < len; ++i)
7147 conversion *t1 = cand1->convs[i + off1];
7148 conversion *t2 = cand2->convs[i + off2];
7149 int comp = compare_ics (t1, t2);
7154 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7155 == cr_std + cr_promotion)
7156 && t1->kind == ck_std
7157 && t2->kind == ck_std
7158 && TREE_CODE (t1->type) == INTEGER_TYPE
7159 && TREE_CODE (t2->type) == INTEGER_TYPE
7160 && (TYPE_PRECISION (t1->type)
7161 == TYPE_PRECISION (t2->type))
7162 && (TYPE_UNSIGNED (t1->u.next->type)
7163 || (TREE_CODE (t1->u.next->type)
7166 tree type = t1->u.next->type;
7168 struct z_candidate *w, *l;
7170 type1 = t1->type, type2 = t2->type,
7171 w = cand1, l = cand2;
7173 type1 = t2->type, type2 = t1->type,
7174 w = cand2, l = cand1;
7178 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7179 type, type1, type2);
7180 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
7186 if (winner && comp != winner)
7195 /* warn about confusing overload resolution for user-defined conversions,
7196 either between a constructor and a conversion op, or between two
7198 if (winner && warn_conversion && cand1->second_conv
7199 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7200 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7202 struct z_candidate *w, *l;
7203 bool give_warning = false;
7206 w = cand1, l = cand2;
7208 w = cand2, l = cand1;
7210 /* We don't want to complain about `X::operator T1 ()'
7211 beating `X::operator T2 () const', when T2 is a no less
7212 cv-qualified version of T1. */
7213 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7214 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7216 tree t = TREE_TYPE (TREE_TYPE (l->fn));
7217 tree f = TREE_TYPE (TREE_TYPE (w->fn));
7219 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7224 if (!comp_ptr_ttypes (t, f))
7225 give_warning = true;
7228 give_warning = true;
7234 tree source = source_type (w->convs[0]);
7235 if (! DECL_CONSTRUCTOR_P (w->fn))
7236 source = TREE_TYPE (source);
7237 if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7238 && warning (OPT_Wconversion, " for conversion from %qT to %qT",
7239 source, w->second_conv->type))
7241 inform (input_location, " because conversion sequence for the argument is better");
7252 F1 is a non-template function and F2 is a template function
7255 if (!cand1->template_decl && cand2->template_decl)
7257 else if (cand1->template_decl && !cand2->template_decl)
7261 F1 and F2 are template functions and the function template for F1 is
7262 more specialized than the template for F2 according to the partial
7265 if (cand1->template_decl && cand2->template_decl)
7267 winner = more_specialized_fn
7268 (TI_TEMPLATE (cand1->template_decl),
7269 TI_TEMPLATE (cand2->template_decl),
7270 /* [temp.func.order]: The presence of unused ellipsis and default
7271 arguments has no effect on the partial ordering of function
7272 templates. add_function_candidate() will not have
7273 counted the "this" argument for constructors. */
7274 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
7280 the context is an initialization by user-defined conversion (see
7281 _dcl.init_ and _over.match.user_) and the standard conversion
7282 sequence from the return type of F1 to the destination type (i.e.,
7283 the type of the entity being initialized) is a better conversion
7284 sequence than the standard conversion sequence from the return type
7285 of F2 to the destination type. */
7287 if (cand1->second_conv)
7289 winner = compare_ics (cand1->second_conv, cand2->second_conv);
7294 /* Check whether we can discard a builtin candidate, either because we
7295 have two identical ones or matching builtin and non-builtin candidates.
7297 (Pedantically in the latter case the builtin which matched the user
7298 function should not be added to the overload set, but we spot it here.
7301 ... the builtin candidates include ...
7302 - do not have the same parameter type list as any non-template
7303 non-member candidate. */
7305 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7306 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7308 for (i = 0; i < len; ++i)
7309 if (!same_type_p (cand1->convs[i]->type,
7310 cand2->convs[i]->type))
7312 if (i == cand1->num_convs)
7314 if (cand1->fn == cand2->fn)
7315 /* Two built-in candidates; arbitrarily pick one. */
7317 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7318 /* cand1 is built-in; prefer cand2. */
7321 /* cand2 is built-in; prefer cand1. */
7326 /* If the two function declarations represent the same function (this can
7327 happen with declarations in multiple scopes and arg-dependent lookup),
7328 arbitrarily choose one. But first make sure the default args we're
7330 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7331 && equal_functions (cand1->fn, cand2->fn))
7333 tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7334 tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7336 gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7338 for (i = 0; i < len; ++i)
7340 /* Don't crash if the fn is variadic. */
7343 parms1 = TREE_CHAIN (parms1);
7344 parms2 = TREE_CHAIN (parms2);
7348 parms1 = TREE_CHAIN (parms1);
7350 parms2 = TREE_CHAIN (parms2);
7354 if (!cp_tree_equal (TREE_PURPOSE (parms1),
7355 TREE_PURPOSE (parms2)))
7359 permerror (input_location, "default argument mismatch in "
7360 "overload resolution");
7361 inform (input_location,
7362 " candidate 1: %q+#F", cand1->fn);
7363 inform (input_location,
7364 " candidate 2: %q+#F", cand2->fn);
7367 add_warning (cand1, cand2);
7370 parms1 = TREE_CHAIN (parms1);
7371 parms2 = TREE_CHAIN (parms2);
7379 /* Extension: If the worst conversion for one candidate is worse than the
7380 worst conversion for the other, take the first. */
7383 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7384 struct z_candidate *w = 0, *l = 0;
7386 for (i = 0; i < len; ++i)
7388 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7389 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7390 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7391 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7394 winner = 1, w = cand1, l = cand2;
7396 winner = -1, w = cand2, l = cand1;
7401 pedwarn (input_location, 0,
7402 "ISO C++ says that these are ambiguous, even "
7403 "though the worst conversion for the first is better than "
7404 "the worst conversion for the second:");
7405 print_z_candidate (_("candidate 1:"), w);
7406 print_z_candidate (_("candidate 2:"), l);
7414 gcc_assert (!winner);
7418 /* Given a list of candidates for overloading, find the best one, if any.
7419 This algorithm has a worst case of O(2n) (winner is last), and a best
7420 case of O(n/2) (totally ambiguous); much better than a sorting
7423 static struct z_candidate *
7424 tourney (struct z_candidate *candidates)
7426 struct z_candidate *champ = candidates, *challenger;
7428 int champ_compared_to_predecessor = 0;
7430 /* Walk through the list once, comparing each current champ to the next
7431 candidate, knocking out a candidate or two with each comparison. */
7433 for (challenger = champ->next; challenger; )
7435 fate = joust (champ, challenger, 0);
7437 challenger = challenger->next;
7442 champ = challenger->next;
7445 champ_compared_to_predecessor = 0;
7450 champ_compared_to_predecessor = 1;
7453 challenger = champ->next;
7457 /* Make sure the champ is better than all the candidates it hasn't yet
7458 been compared to. */
7460 for (challenger = candidates;
7462 && !(champ_compared_to_predecessor && challenger->next == champ);
7463 challenger = challenger->next)
7465 fate = joust (champ, challenger, 0);
7473 /* Returns nonzero if things of type FROM can be converted to TO. */
7476 can_convert (tree to, tree from)
7478 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
7481 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
7484 can_convert_arg (tree to, tree from, tree arg, int flags)
7490 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7491 p = conversion_obstack_alloc (0);
7493 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7495 ok_p = (t && !t->bad_p);
7497 /* Free all the conversions we allocated. */
7498 obstack_free (&conversion_obstack, p);
7503 /* Like can_convert_arg, but allows dubious conversions as well. */
7506 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
7511 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7512 p = conversion_obstack_alloc (0);
7513 /* Try to perform the conversion. */
7514 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7516 /* Free all the conversions we allocated. */
7517 obstack_free (&conversion_obstack, p);
7522 /* Convert EXPR to TYPE. Return the converted expression.
7524 Note that we allow bad conversions here because by the time we get to
7525 this point we are committed to doing the conversion. If we end up
7526 doing a bad conversion, convert_like will complain. */
7529 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7534 if (error_operand_p (expr))
7535 return error_mark_node;
7537 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7538 p = conversion_obstack_alloc (0);
7540 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7546 if (complain & tf_error)
7548 /* If expr has unknown type, then it is an overloaded function.
7549 Call instantiate_type to get good error messages. */
7550 if (TREE_TYPE (expr) == unknown_type_node)
7551 instantiate_type (type, expr, complain);
7552 else if (invalid_nonstatic_memfn_p (expr, complain))
7553 /* We gave an error. */;
7555 error ("could not convert %qE to %qT", expr, type);
7557 expr = error_mark_node;
7559 else if (processing_template_decl)
7561 /* In a template, we are only concerned about determining the
7562 type of non-dependent expressions, so we do not have to
7563 perform the actual conversion. */
7564 if (TREE_TYPE (expr) != type)
7565 expr = build_nop (type, expr);
7568 expr = convert_like (conv, expr, complain);
7570 /* Free all the conversions we allocated. */
7571 obstack_free (&conversion_obstack, p);
7577 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7579 return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
7582 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7583 permitted. If the conversion is valid, the converted expression is
7584 returned. Otherwise, NULL_TREE is returned, except in the case
7585 that TYPE is a class type; in that case, an error is issued. If
7586 C_CAST_P is true, then this direction initialization is taking
7587 place as part of a static_cast being attempted as part of a C-style
7591 perform_direct_initialization_if_possible (tree type,
7594 tsubst_flags_t complain)
7599 if (type == error_mark_node || error_operand_p (expr))
7600 return error_mark_node;
7603 If the destination type is a (possibly cv-qualified) class type:
7605 -- If the initialization is direct-initialization ...,
7606 constructors are considered. ... If no constructor applies, or
7607 the overload resolution is ambiguous, the initialization is
7609 if (CLASS_TYPE_P (type))
7611 VEC(tree,gc) *args = make_tree_vector_single (expr);
7612 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7613 &args, type, LOOKUP_NORMAL, complain);
7614 release_tree_vector (args);
7615 return build_cplus_new (type, expr);
7618 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7619 p = conversion_obstack_alloc (0);
7621 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7624 if (!conv || conv->bad_p)
7627 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7628 /*issue_conversion_warnings=*/false,
7632 /* Free all the conversions we allocated. */
7633 obstack_free (&conversion_obstack, p);
7638 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
7639 is being bound to a temporary. Create and return a new VAR_DECL
7640 with the indicated TYPE; this variable will store the value to
7641 which the reference is bound. */
7644 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7648 /* Create the variable. */
7649 var = create_temporary_var (type);
7651 /* Register the variable. */
7652 if (TREE_STATIC (decl))
7654 /* Namespace-scope or local static; give it a mangled name. */
7657 TREE_STATIC (var) = 1;
7658 name = mangle_ref_init_variable (decl);
7659 DECL_NAME (var) = name;
7660 SET_DECL_ASSEMBLER_NAME (var, name);
7661 var = pushdecl_top_level (var);
7664 /* Create a new cleanup level if necessary. */
7665 maybe_push_cleanup_level (type);
7670 /* EXPR is the initializer for a variable DECL of reference or
7671 std::initializer_list type. Create, push and return a new VAR_DECL
7672 for the initializer so that it will live as long as DECL. Any
7673 cleanup for the new variable is returned through CLEANUP, and the
7674 code to initialize the new variable is returned through INITP. */
7677 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7683 /* Create the temporary variable. */
7684 type = TREE_TYPE (expr);
7685 var = make_temporary_var_for_ref_to_temp (decl, type);
7686 layout_decl (var, 0);
7687 /* If the rvalue is the result of a function call it will be
7688 a TARGET_EXPR. If it is some other construct (such as a
7689 member access expression where the underlying object is
7690 itself the result of a function call), turn it into a
7691 TARGET_EXPR here. It is important that EXPR be a
7692 TARGET_EXPR below since otherwise the INIT_EXPR will
7693 attempt to make a bitwise copy of EXPR to initialize
7695 if (TREE_CODE (expr) != TARGET_EXPR)
7696 expr = get_target_expr (expr);
7697 /* Create the INIT_EXPR that will initialize the temporary
7699 init = build2 (INIT_EXPR, type, var, expr);
7700 if (at_function_scope_p ())
7702 add_decl_expr (var);
7704 if (TREE_STATIC (var))
7705 init = add_stmt_to_compound (init, register_dtor_fn (var));
7707 *cleanup = cxx_maybe_build_cleanup (var);
7709 /* We must be careful to destroy the temporary only
7710 after its initialization has taken place. If the
7711 initialization throws an exception, then the
7712 destructor should not be run. We cannot simply
7713 transform INIT into something like:
7715 (INIT, ({ CLEANUP_STMT; }))
7717 because emit_local_var always treats the
7718 initializer as a full-expression. Thus, the
7719 destructor would run too early; it would run at the
7720 end of initializing the reference variable, rather
7721 than at the end of the block enclosing the
7724 The solution is to pass back a cleanup expression
7725 which the caller is responsible for attaching to
7726 the statement tree. */
7730 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7731 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7732 static_aggregates = tree_cons (NULL_TREE, var,
7740 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7741 initializing a variable of that TYPE. If DECL is non-NULL, it is
7742 the VAR_DECL being initialized with the EXPR. (In that case, the
7743 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
7744 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
7745 return, if *CLEANUP is no longer NULL, it will be an expression
7746 that should be pushed as a cleanup after the returned expression
7747 is used to initialize DECL.
7749 Return the converted expression. */
7752 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
7753 tsubst_flags_t complain)
7758 if (type == error_mark_node || error_operand_p (expr))
7759 return error_mark_node;
7761 /* Get the high-water mark for the CONVERSION_OBSTACK. */
7762 p = conversion_obstack_alloc (0);
7764 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7766 if (!conv || conv->bad_p)
7768 if (complain & tf_error)
7770 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
7771 && !TYPE_REF_IS_RVALUE (type)
7772 && !real_lvalue_p (expr))
7773 error ("invalid initialization of non-const reference of "
7774 "type %qT from an rvalue of type %qT",
7775 type, TREE_TYPE (expr));
7777 error ("invalid initialization of reference of type "
7778 "%qT from expression of type %qT", type,
7781 return error_mark_node;
7784 /* If DECL is non-NULL, then this special rule applies:
7788 The temporary to which the reference is bound or the temporary
7789 that is the complete object to which the reference is bound
7790 persists for the lifetime of the reference.
7792 The temporaries created during the evaluation of the expression
7793 initializing the reference, except the temporary to which the
7794 reference is bound, are destroyed at the end of the
7795 full-expression in which they are created.
7797 In that case, we store the converted expression into a new
7798 VAR_DECL in a new scope.
7800 However, we want to be careful not to create temporaries when
7801 they are not required. For example, given:
7804 struct D : public B {};
7808 there is no need to copy the return value from "f"; we can just
7809 extend its lifetime. Similarly, given:
7812 struct T { operator S(); };
7816 we can extend the lifetime of the return value of the conversion
7818 gcc_assert (conv->kind == ck_ref_bind);
7822 tree base_conv_type;
7824 /* Skip over the REF_BIND. */
7825 conv = conv->u.next;
7826 /* If the next conversion is a BASE_CONV, skip that too -- but
7827 remember that the conversion was required. */
7828 if (conv->kind == ck_base)
7830 base_conv_type = conv->type;
7831 conv = conv->u.next;
7834 base_conv_type = NULL_TREE;
7835 /* Perform the remainder of the conversion. */
7836 expr = convert_like_real (conv, expr,
7837 /*fn=*/NULL_TREE, /*argnum=*/0,
7839 /*issue_conversion_warnings=*/true,
7841 tf_warning_or_error);
7842 if (error_operand_p (expr))
7843 expr = error_mark_node;
7846 if (!lvalue_or_rvalue_with_address_p (expr))
7849 var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7850 /* Use its address to initialize the reference variable. */
7851 expr = build_address (var);
7853 expr = convert_to_base (expr,
7854 build_pointer_type (base_conv_type),
7855 /*check_access=*/true,
7856 /*nonnull=*/true, complain);
7857 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7860 /* Take the address of EXPR. */
7861 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7862 /* If a BASE_CONV was required, perform it now. */
7864 expr = (perform_implicit_conversion
7865 (build_pointer_type (base_conv_type), expr,
7866 tf_warning_or_error));
7867 expr = build_nop (type, expr);
7871 /* Perform the conversion. */
7872 expr = convert_like (conv, expr, tf_warning_or_error);
7874 /* Free all the conversions we allocated. */
7875 obstack_free (&conversion_obstack, p);
7880 /* Returns true iff TYPE is some variant of std::initializer_list. */
7883 is_std_init_list (tree type)
7885 return (CLASS_TYPE_P (type)
7886 && CP_TYPE_CONTEXT (type) == std_node
7887 && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7890 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7891 will accept an argument list of a single std::initializer_list<T>. */
7894 is_list_ctor (tree decl)
7896 tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7899 if (!args || args == void_list_node)
7902 arg = non_reference (TREE_VALUE (args));
7903 if (!is_std_init_list (arg))
7906 args = TREE_CHAIN (args);
7908 if (args && args != void_list_node && !TREE_PURPOSE (args))
7909 /* There are more non-defaulted parms. */
7915 #include "gt-cp-call.h"