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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
5 modified by Brendan Kehoe (brendan@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* High-level class interface. */
29 #include "coretypes.h"
38 #include "diagnostic.h"
43 /* The various kinds of conversion. */
45 typedef enum conversion_kind {
59 /* The rank of the conversion. Order of the enumerals matters; better
60 conversions should come earlier in the list. */
62 typedef enum conversion_rank {
73 /* An implicit conversion sequence, in the sense of [over.best.ics].
74 The first conversion to be performed is at the end of the chain.
75 That conversion is always an cr_identity conversion. */
77 typedef struct conversion conversion;
79 /* The kind of conversion represented by this step. */
81 /* The rank of this conversion. */
83 BOOL_BITFIELD user_conv_p : 1;
84 BOOL_BITFIELD ellipsis_p : 1;
85 BOOL_BITFIELD this_p : 1;
86 BOOL_BITFIELD bad_p : 1;
87 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
88 temporary should be created to hold the result of the
90 BOOL_BITFIELD need_temporary_p : 1;
91 /* If KIND is ck_identity or ck_base_conv, true to indicate that the
92 copy constructor must be accessible, even though it is not being
94 BOOL_BITFIELD check_copy_constructor_p : 1;
95 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
96 from a pointer-to-derived to pointer-to-base is being performed. */
97 BOOL_BITFIELD base_p : 1;
98 /* The type of the expression resulting from the conversion. */
101 /* The next conversion in the chain. Since the conversions are
102 arranged from outermost to innermost, the NEXT conversion will
103 actually be performed before this conversion. This variant is
104 used only when KIND is neither ck_identity nor ck_ambig. */
106 /* The expression at the beginning of the conversion chain. This
107 variant is used only if KIND is ck_identity or ck_ambig. */
110 /* The function candidate corresponding to this conversion
111 sequence. This field is only used if KIND is ck_user. */
112 struct z_candidate *cand;
115 #define CONVERSION_RANK(NODE) \
116 ((NODE)->bad_p ? cr_bad \
117 : (NODE)->ellipsis_p ? cr_ellipsis \
118 : (NODE)->user_conv_p ? cr_user \
121 static struct obstack conversion_obstack;
122 static bool conversion_obstack_initialized;
124 static struct z_candidate * tourney (struct z_candidate *);
125 static int equal_functions (tree, tree);
126 static int joust (struct z_candidate *, struct z_candidate *, bool);
127 static int compare_ics (conversion *, conversion *);
128 static tree build_over_call (struct z_candidate *, int);
129 static tree build_java_interface_fn_ref (tree, tree);
130 #define convert_like(CONV, EXPR) \
131 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
132 /*issue_conversion_warnings=*/true, \
134 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
135 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
136 /*issue_conversion_warnings=*/true, \
138 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
140 static void op_error (enum tree_code, enum tree_code, tree, tree,
142 static tree build_object_call (tree, tree);
143 static tree resolve_args (tree);
144 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
145 static void print_z_candidate (const char *, struct z_candidate *);
146 static void print_z_candidates (struct z_candidate *);
147 static tree build_this (tree);
148 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
149 static bool any_strictly_viable (struct z_candidate *);
150 static struct z_candidate *add_template_candidate
151 (struct z_candidate **, tree, tree, tree, tree, tree,
152 tree, tree, int, unification_kind_t);
153 static struct z_candidate *add_template_candidate_real
154 (struct z_candidate **, tree, tree, tree, tree, tree,
155 tree, tree, int, tree, unification_kind_t);
156 static struct z_candidate *add_template_conv_candidate
157 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
158 static void add_builtin_candidates
159 (struct z_candidate **, enum tree_code, enum tree_code,
161 static void add_builtin_candidate
162 (struct z_candidate **, enum tree_code, enum tree_code,
163 tree, tree, tree, tree *, tree *, int);
164 static bool is_complete (tree);
165 static void build_builtin_candidate
166 (struct z_candidate **, tree, tree, tree, tree *, tree *,
168 static struct z_candidate *add_conv_candidate
169 (struct z_candidate **, tree, tree, tree, tree, tree);
170 static struct z_candidate *add_function_candidate
171 (struct z_candidate **, tree, tree, tree, tree, tree, int);
172 static conversion *implicit_conversion (tree, tree, tree, int);
173 static conversion *standard_conversion (tree, tree, tree, int);
174 static conversion *reference_binding (tree, tree, tree, int);
175 static conversion *build_conv (conversion_kind, tree, conversion *);
176 static bool is_subseq (conversion *, conversion *);
177 static tree maybe_handle_ref_bind (conversion **);
178 static void maybe_handle_implicit_object (conversion **);
179 static struct z_candidate *add_candidate
180 (struct z_candidate **, tree, tree, size_t,
181 conversion **, tree, tree, int);
182 static tree source_type (conversion *);
183 static void add_warning (struct z_candidate *, struct z_candidate *);
184 static bool reference_related_p (tree, tree);
185 static bool reference_compatible_p (tree, tree);
186 static conversion *convert_class_to_reference (tree, tree, tree);
187 static conversion *direct_reference_binding (tree, conversion *);
188 static bool promoted_arithmetic_type_p (tree);
189 static conversion *conditional_conversion (tree, tree);
190 static char *name_as_c_string (tree, tree, bool *);
191 static tree call_builtin_trap (void);
192 static tree prep_operand (tree);
193 static void add_candidates (tree, tree, tree, bool, tree, tree,
194 int, struct z_candidate **);
195 static conversion *merge_conversion_sequences (conversion *, conversion *);
196 static bool magic_varargs_p (tree);
197 static tree build_temp (tree, tree, int, void (**)(const char *, ...));
198 static void check_constructor_callable (tree, tree);
200 /* Returns nonzero iff the destructor name specified in NAME
201 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
205 check_dtor_name (tree basetype, tree name)
207 name = TREE_OPERAND (name, 0);
209 /* Just accept something we've already complained about. */
210 if (name == error_mark_node)
213 if (TREE_CODE (name) == TYPE_DECL)
214 name = TREE_TYPE (name);
215 else if (TYPE_P (name))
217 else if (TREE_CODE (name) == IDENTIFIER_NODE)
219 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
220 || (TREE_CODE (basetype) == ENUMERAL_TYPE
221 && name == TYPE_IDENTIFIER (basetype)))
224 name = get_type_value (name);
230 template <class T> struct S { ~S(); };
234 NAME will be a class template. */
235 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
239 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
244 /* We want the address of a function or method. We avoid creating a
245 pointer-to-member function. */
248 build_addr_func (tree function)
250 tree type = TREE_TYPE (function);
252 /* We have to do these by hand to avoid real pointer to member
254 if (TREE_CODE (type) == METHOD_TYPE)
256 if (TREE_CODE (function) == OFFSET_REF)
258 tree object = build_address (TREE_OPERAND (function, 0));
259 return get_member_function_from_ptrfunc (&object,
260 TREE_OPERAND (function, 1));
262 function = build_address (function);
265 function = decay_conversion (function);
270 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
271 POINTER_TYPE to those. Note, pointer to member function types
272 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
275 build_call (tree function, tree parms)
277 int is_constructor = 0;
284 function = build_addr_func (function);
286 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
288 sorry ("unable to call pointer to member function here");
289 return error_mark_node;
292 fntype = TREE_TYPE (TREE_TYPE (function));
293 result_type = TREE_TYPE (fntype);
295 if (TREE_CODE (function) == ADDR_EXPR
296 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
297 decl = TREE_OPERAND (function, 0);
301 /* We check both the decl and the type; a function may be known not to
302 throw without being declared throw(). */
303 nothrow = ((decl && TREE_NOTHROW (decl))
304 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
306 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
307 current_function_returns_abnormally = 1;
309 if (decl && TREE_DEPRECATED (decl))
310 warn_deprecated_use (decl);
311 require_complete_eh_spec_types (fntype, decl);
313 if (decl && DECL_CONSTRUCTOR_P (decl))
316 if (decl && ! TREE_USED (decl))
318 /* We invoke build_call directly for several library functions.
319 These may have been declared normally if we're building libgcc,
320 so we can't just check DECL_ARTIFICIAL. */
321 gcc_assert (DECL_ARTIFICIAL (decl)
322 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
327 /* Don't pass empty class objects by value. This is useful
328 for tags in STL, which are used to control overload resolution.
329 We don't need to handle other cases of copying empty classes. */
330 if (! decl || ! DECL_BUILT_IN (decl))
331 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
332 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
333 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
335 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
336 TREE_VALUE (tmp) = build2 (COMPOUND_EXPR, TREE_TYPE (t),
337 TREE_VALUE (tmp), t);
340 function = build3 (CALL_EXPR, result_type, function, parms, NULL_TREE);
341 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
342 TREE_NOTHROW (function) = nothrow;
347 /* Build something of the form ptr->method (args)
348 or object.method (args). This can also build
349 calls to constructors, and find friends.
351 Member functions always take their class variable
354 INSTANCE is a class instance.
356 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
358 PARMS help to figure out what that NAME really refers to.
360 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
361 down to the real instance type to use for access checking. We need this
362 information to get protected accesses correct.
364 FLAGS is the logical disjunction of zero or more LOOKUP_
365 flags. See cp-tree.h for more info.
367 If this is all OK, calls build_function_call with the resolved
370 This function must also handle being called to perform
371 initialization, promotion/coercion of arguments, and
372 instantiation of default parameters.
374 Note that NAME may refer to an instance variable name. If
375 `operator()()' is defined for the type of that field, then we return
378 /* New overloading code. */
380 typedef struct z_candidate z_candidate;
382 typedef struct candidate_warning candidate_warning;
383 struct candidate_warning {
385 candidate_warning *next;
389 /* The FUNCTION_DECL that will be called if this candidate is
390 selected by overload resolution. */
392 /* The arguments to use when calling this function. */
394 /* The implicit conversion sequences for each of the arguments to
397 /* The number of implicit conversion sequences. */
399 /* If FN is a user-defined conversion, the standard conversion
400 sequence from the type returned by FN to the desired destination
402 conversion *second_conv;
404 /* If FN is a member function, the binfo indicating the path used to
405 qualify the name of FN at the call site. This path is used to
406 determine whether or not FN is accessible if it is selected by
407 overload resolution. The DECL_CONTEXT of FN will always be a
408 (possibly improper) base of this binfo. */
410 /* If FN is a non-static member function, the binfo indicating the
411 subobject to which the `this' pointer should be converted if FN
412 is selected by overload resolution. The type pointed to the by
413 the `this' pointer must correspond to the most derived class
414 indicated by the CONVERSION_PATH. */
415 tree conversion_path;
417 candidate_warning *warnings;
421 /* Returns true iff T is a null pointer constant in the sense of
425 null_ptr_cst_p (tree t)
429 A null pointer constant is an integral constant expression
430 (_expr.const_) rvalue of integer type that evaluates to zero. */
431 t = integral_constant_value (t);
433 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
438 /* Returns nonzero if PARMLIST consists of only default parms and/or
442 sufficient_parms_p (tree parmlist)
444 for (; parmlist && parmlist != void_list_node;
445 parmlist = TREE_CHAIN (parmlist))
446 if (!TREE_PURPOSE (parmlist))
451 /* Allocate N bytes of memory from the conversion obstack. The memory
452 is zeroed before being returned. */
455 conversion_obstack_alloc (size_t n)
458 if (!conversion_obstack_initialized)
460 gcc_obstack_init (&conversion_obstack);
461 conversion_obstack_initialized = true;
463 p = obstack_alloc (&conversion_obstack, n);
468 /* Dynamically allocate a conversion. */
471 alloc_conversion (conversion_kind kind)
474 c = conversion_obstack_alloc (sizeof (conversion));
479 #ifdef ENABLE_CHECKING
481 /* Make sure that all memory on the conversion obstack has been
485 validate_conversion_obstack (void)
487 if (conversion_obstack_initialized)
488 gcc_assert ((obstack_next_free (&conversion_obstack)
489 == obstack_base (&conversion_obstack)));
492 #endif /* ENABLE_CHECKING */
494 /* Dynamically allocate an array of N conversions. */
497 alloc_conversions (size_t n)
499 return conversion_obstack_alloc (n * sizeof (conversion *));
503 build_conv (conversion_kind code, tree type, conversion *from)
506 conversion_rank rank = CONVERSION_RANK (from);
508 /* We can't use buildl1 here because CODE could be USER_CONV, which
509 takes two arguments. In that case, the caller is responsible for
510 filling in the second argument. */
511 t = alloc_conversion (code);
534 t->user_conv_p = (code == ck_user || from->user_conv_p);
535 t->bad_p = from->bad_p;
540 /* Build a representation of the identity conversion from EXPR to
541 itself. The TYPE should match the the type of EXPR, if EXPR is
545 build_identity_conv (tree type, tree expr)
549 c = alloc_conversion (ck_identity);
556 /* Converting from EXPR to TYPE was ambiguous in the sense that there
557 were multiple user-defined conversions to accomplish the job.
558 Build a conversion that indicates that ambiguity. */
561 build_ambiguous_conv (tree type, tree expr)
565 c = alloc_conversion (ck_ambig);
573 strip_top_quals (tree t)
575 if (TREE_CODE (t) == ARRAY_TYPE)
577 return cp_build_qualified_type (t, 0);
580 /* Returns the standard conversion path (see [conv]) from type FROM to type
581 TO, if any. For proper handling of null pointer constants, you must
582 also pass the expression EXPR to convert from. */
585 standard_conversion (tree to, tree from, tree expr, int flags)
587 enum tree_code fcode, tcode;
589 bool fromref = false;
591 to = non_reference (to);
592 if (TREE_CODE (from) == REFERENCE_TYPE)
595 from = TREE_TYPE (from);
597 to = strip_top_quals (to);
598 from = strip_top_quals (from);
600 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
601 && expr && type_unknown_p (expr))
603 expr = instantiate_type (to, expr, tf_conv);
604 if (expr == error_mark_node)
606 from = TREE_TYPE (expr);
609 fcode = TREE_CODE (from);
610 tcode = TREE_CODE (to);
612 conv = build_identity_conv (from, expr);
613 if (fcode == FUNCTION_TYPE)
615 from = build_pointer_type (from);
616 fcode = TREE_CODE (from);
617 conv = build_conv (ck_lvalue, from, conv);
619 else if (fcode == ARRAY_TYPE)
621 from = build_pointer_type (TREE_TYPE (from));
622 fcode = TREE_CODE (from);
623 conv = build_conv (ck_lvalue, from, conv);
625 else if (fromref || (expr && lvalue_p (expr)))
626 conv = build_conv (ck_rvalue, from, conv);
628 /* Allow conversion between `__complex__' data types. */
629 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
631 /* The standard conversion sequence to convert FROM to TO is
632 the standard conversion sequence to perform componentwise
634 conversion *part_conv = standard_conversion
635 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, flags);
639 conv = build_conv (part_conv->kind, to, conv);
640 conv->rank = part_conv->rank;
648 if (same_type_p (from, to))
651 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
652 && expr && null_ptr_cst_p (expr))
653 conv = build_conv (ck_std, to, conv);
654 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
655 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
657 /* For backwards brain damage compatibility, allow interconversion of
658 pointers and integers with a pedwarn. */
659 conv = build_conv (ck_std, to, conv);
662 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
664 /* For backwards brain damage compatibility, allow interconversion of
665 enums and integers with a pedwarn. */
666 conv = build_conv (ck_std, to, conv);
669 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
670 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
675 if (tcode == POINTER_TYPE
676 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
679 else if (VOID_TYPE_P (TREE_TYPE (to))
680 && !TYPE_PTRMEM_P (from)
681 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
683 from = build_pointer_type
684 (cp_build_qualified_type (void_type_node,
685 cp_type_quals (TREE_TYPE (from))));
686 conv = build_conv (ck_ptr, from, conv);
688 else if (TYPE_PTRMEM_P (from))
690 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
691 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
693 if (DERIVED_FROM_P (fbase, tbase)
694 && (same_type_ignoring_top_level_qualifiers_p
695 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
696 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
698 from = build_ptrmem_type (tbase,
699 TYPE_PTRMEM_POINTED_TO_TYPE (from));
700 conv = build_conv (ck_pmem, from, conv);
702 else if (!same_type_p (fbase, tbase))
705 else if (IS_AGGR_TYPE (TREE_TYPE (from))
706 && IS_AGGR_TYPE (TREE_TYPE (to))
709 An rvalue of type "pointer to cv D," where D is a
710 class type, can be converted to an rvalue of type
711 "pointer to cv B," where B is a base class (clause
712 _class.derived_) of D. If B is an inaccessible
713 (clause _class.access_) or ambiguous
714 (_class.member.lookup_) base class of D, a program
715 that necessitates this conversion is ill-formed.
716 Therefore, we use DERIVED_FROM_P, and do not check
717 access or uniqueness. */
718 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
721 cp_build_qualified_type (TREE_TYPE (to),
722 cp_type_quals (TREE_TYPE (from)));
723 from = build_pointer_type (from);
724 conv = build_conv (ck_ptr, from, conv);
728 if (tcode == POINTER_TYPE)
730 to_pointee = TREE_TYPE (to);
731 from_pointee = TREE_TYPE (from);
735 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
736 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
739 if (same_type_p (from, to))
741 else if (comp_ptr_ttypes (to_pointee, from_pointee))
742 conv = build_conv (ck_qual, to, conv);
743 else if (expr && string_conv_p (to, expr, 0))
744 /* converting from string constant to char *. */
745 conv = build_conv (ck_qual, to, conv);
746 else if (ptr_reasonably_similar (to_pointee, from_pointee))
748 conv = build_conv (ck_ptr, to, conv);
756 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
758 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
759 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
760 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
761 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
763 if (!DERIVED_FROM_P (fbase, tbase)
764 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
765 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
766 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
767 || cp_type_quals (fbase) != cp_type_quals (tbase))
770 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
771 from = build_method_type_directly (from,
773 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
774 from = build_ptrmemfunc_type (build_pointer_type (from));
775 conv = build_conv (ck_pmem, from, conv);
778 else if (tcode == BOOLEAN_TYPE)
782 An rvalue of arithmetic, enumeration, pointer, or pointer to
783 member type can be converted to an rvalue of type bool. */
784 if (ARITHMETIC_TYPE_P (from)
785 || fcode == ENUMERAL_TYPE
786 || fcode == POINTER_TYPE
787 || TYPE_PTR_TO_MEMBER_P (from))
789 conv = build_conv (ck_std, to, conv);
790 if (fcode == POINTER_TYPE
791 || TYPE_PTRMEM_P (from)
792 || (TYPE_PTRMEMFUNC_P (from)
793 && conv->rank < cr_pbool))
794 conv->rank = cr_pbool;
800 /* We don't check for ENUMERAL_TYPE here because there are no standard
801 conversions to enum type. */
802 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
803 || tcode == REAL_TYPE)
805 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
807 conv = build_conv (ck_std, to, conv);
809 /* Give this a better rank if it's a promotion. */
810 if (same_type_p (to, type_promotes_to (from))
811 && conv->u.next->rank <= cr_promotion)
812 conv->rank = cr_promotion;
814 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
815 && vector_types_convertible_p (from, to))
816 return build_conv (ck_std, to, conv);
817 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
818 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
819 && is_properly_derived_from (from, to))
821 if (conv->kind == ck_rvalue)
823 conv = build_conv (ck_base, to, conv);
824 /* The derived-to-base conversion indicates the initialization
825 of a parameter with base type from an object of a derived
826 type. A temporary object is created to hold the result of
828 conv->need_temporary_p = true;
836 /* Returns nonzero if T1 is reference-related to T2. */
839 reference_related_p (tree t1, tree t2)
841 t1 = TYPE_MAIN_VARIANT (t1);
842 t2 = TYPE_MAIN_VARIANT (t2);
846 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
847 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
849 return (same_type_p (t1, t2)
850 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
851 && DERIVED_FROM_P (t1, t2)));
854 /* Returns nonzero if T1 is reference-compatible with T2. */
857 reference_compatible_p (tree t1, tree t2)
861 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
862 reference-related to T2 and cv1 is the same cv-qualification as,
863 or greater cv-qualification than, cv2. */
864 return (reference_related_p (t1, t2)
865 && at_least_as_qualified_p (t1, t2));
868 /* Determine whether or not the EXPR (of class type S) can be
869 converted to T as in [over.match.ref]. */
872 convert_class_to_reference (tree t, tree s, tree expr)
878 struct z_candidate *candidates;
879 struct z_candidate *cand;
882 conversions = lookup_conversions (s);
888 Assuming that "cv1 T" is the underlying type of the reference
889 being initialized, and "cv S" is the type of the initializer
890 expression, with S a class type, the candidate functions are
893 --The conversion functions of S and its base classes are
894 considered. Those that are not hidden within S and yield type
895 "reference to cv2 T2", where "cv1 T" is reference-compatible
896 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
898 The argument list has one argument, which is the initializer
903 /* Conceptually, we should take the address of EXPR and put it in
904 the argument list. Unfortunately, however, that can result in
905 error messages, which we should not issue now because we are just
906 trying to find a conversion operator. Therefore, we use NULL,
907 cast to the appropriate type. */
908 arglist = build_int_cst (build_pointer_type (s), 0);
909 arglist = build_tree_list (NULL_TREE, arglist);
911 reference_type = build_reference_type (t);
915 tree fns = TREE_VALUE (conversions);
917 for (; fns; fns = OVL_NEXT (fns))
919 tree f = OVL_CURRENT (fns);
920 tree t2 = TREE_TYPE (TREE_TYPE (f));
924 /* If this is a template function, try to get an exact
926 if (TREE_CODE (f) == TEMPLATE_DECL)
928 cand = add_template_candidate (&candidates,
934 TREE_PURPOSE (conversions),
940 /* Now, see if the conversion function really returns
941 an lvalue of the appropriate type. From the
942 point of view of unification, simply returning an
943 rvalue of the right type is good enough. */
945 t2 = TREE_TYPE (TREE_TYPE (f));
946 if (TREE_CODE (t2) != REFERENCE_TYPE
947 || !reference_compatible_p (t, TREE_TYPE (t2)))
949 candidates = candidates->next;
954 else if (TREE_CODE (t2) == REFERENCE_TYPE
955 && reference_compatible_p (t, TREE_TYPE (t2)))
956 cand = add_function_candidate (&candidates, f, s, arglist,
958 TREE_PURPOSE (conversions),
963 conversion *identity_conv;
964 /* Build a standard conversion sequence indicating the
965 binding from the reference type returned by the
966 function to the desired REFERENCE_TYPE. */
968 = build_identity_conv (TREE_TYPE (TREE_TYPE
969 (TREE_TYPE (cand->fn))),
972 = (direct_reference_binding
973 (reference_type, identity_conv));
974 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
977 conversions = TREE_CHAIN (conversions);
980 candidates = splice_viable (candidates, pedantic, &any_viable_p);
981 /* If none of the conversion functions worked out, let our caller
986 cand = tourney (candidates);
990 /* Now that we know that this is the function we're going to use fix
991 the dummy first argument. */
992 cand->args = tree_cons (NULL_TREE,
994 TREE_CHAIN (cand->args));
996 /* Build a user-defined conversion sequence representing the
998 conv = build_conv (ck_user,
999 TREE_TYPE (TREE_TYPE (cand->fn)),
1000 build_identity_conv (TREE_TYPE (expr), expr));
1003 /* Merge it with the standard conversion sequence from the
1004 conversion function's return type to the desired type. */
1005 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1007 if (cand->viable == -1)
1010 return cand->second_conv;
1013 /* A reference of the indicated TYPE is being bound directly to the
1014 expression represented by the implicit conversion sequence CONV.
1015 Return a conversion sequence for this binding. */
1018 direct_reference_binding (tree type, conversion *conv)
1022 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1023 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1025 t = TREE_TYPE (type);
1029 When a parameter of reference type binds directly
1030 (_dcl.init.ref_) to an argument expression, the implicit
1031 conversion sequence is the identity conversion, unless the
1032 argument expression has a type that is a derived class of the
1033 parameter type, in which case the implicit conversion sequence is
1034 a derived-to-base Conversion.
1036 If the parameter binds directly to the result of applying a
1037 conversion function to the argument expression, the implicit
1038 conversion sequence is a user-defined conversion sequence
1039 (_over.ics.user_), with the second standard conversion sequence
1040 either an identity conversion or, if the conversion function
1041 returns an entity of a type that is a derived class of the
1042 parameter type, a derived-to-base conversion. */
1043 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1045 /* Represent the derived-to-base conversion. */
1046 conv = build_conv (ck_base, t, conv);
1047 /* We will actually be binding to the base-class subobject in
1048 the derived class, so we mark this conversion appropriately.
1049 That way, convert_like knows not to generate a temporary. */
1050 conv->need_temporary_p = false;
1052 return build_conv (ck_ref_bind, type, conv);
1055 /* Returns the conversion path from type FROM to reference type TO for
1056 purposes of reference binding. For lvalue binding, either pass a
1057 reference type to FROM or an lvalue expression to EXPR. If the
1058 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1059 the conversion returned. */
1062 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1064 conversion *conv = NULL;
1065 tree to = TREE_TYPE (rto);
1069 cp_lvalue_kind lvalue_p = clk_none;
1071 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1073 expr = instantiate_type (to, expr, tf_none);
1074 if (expr == error_mark_node)
1076 from = TREE_TYPE (expr);
1079 if (TREE_CODE (from) == REFERENCE_TYPE)
1081 /* Anything with reference type is an lvalue. */
1082 lvalue_p = clk_ordinary;
1083 from = TREE_TYPE (from);
1086 lvalue_p = real_lvalue_p (expr);
1088 /* Figure out whether or not the types are reference-related and
1089 reference compatible. We have do do this after stripping
1090 references from FROM. */
1091 related_p = reference_related_p (to, from);
1092 compatible_p = reference_compatible_p (to, from);
1094 if (lvalue_p && compatible_p)
1098 If the initializer expression
1100 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1101 is reference-compatible with "cv2 T2,"
1103 the reference is bound directly to the initializer expression
1105 conv = build_identity_conv (from, expr);
1106 conv = direct_reference_binding (rto, conv);
1107 if ((lvalue_p & clk_bitfield) != 0
1108 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1109 /* For the purposes of overload resolution, we ignore the fact
1110 this expression is a bitfield or packed field. (In particular,
1111 [over.ics.ref] says specifically that a function with a
1112 non-const reference parameter is viable even if the
1113 argument is a bitfield.)
1115 However, when we actually call the function we must create
1116 a temporary to which to bind the reference. If the
1117 reference is volatile, or isn't const, then we cannot make
1118 a temporary, so we just issue an error when the conversion
1120 conv->need_temporary_p = true;
1124 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1128 If the initializer expression
1130 -- has a class type (i.e., T2 is a class type) can be
1131 implicitly converted to an lvalue of type "cv3 T3," where
1132 "cv1 T1" is reference-compatible with "cv3 T3". (this
1133 conversion is selected by enumerating the applicable
1134 conversion functions (_over.match.ref_) and choosing the
1135 best one through overload resolution. (_over.match_).
1137 the reference is bound to the lvalue result of the conversion
1138 in the second case. */
1139 conv = convert_class_to_reference (to, from, expr);
1144 /* From this point on, we conceptually need temporaries, even if we
1145 elide them. Only the cases above are "direct bindings". */
1146 if (flags & LOOKUP_NO_TEMP_BIND)
1151 When a parameter of reference type is not bound directly to an
1152 argument expression, the conversion sequence is the one required
1153 to convert the argument expression to the underlying type of the
1154 reference according to _over.best.ics_. Conceptually, this
1155 conversion sequence corresponds to copy-initializing a temporary
1156 of the underlying type with the argument expression. Any
1157 difference in top-level cv-qualification is subsumed by the
1158 initialization itself and does not constitute a conversion. */
1162 Otherwise, the reference shall be to a non-volatile const type. */
1163 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1168 If the initializer expression is an rvalue, with T2 a class type,
1169 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1170 is bound in one of the following ways:
1172 -- The reference is bound to the object represented by the rvalue
1173 or to a sub-object within that object.
1177 We use the first alternative. The implicit conversion sequence
1178 is supposed to be same as we would obtain by generating a
1179 temporary. Fortunately, if the types are reference compatible,
1180 then this is either an identity conversion or the derived-to-base
1181 conversion, just as for direct binding. */
1182 if (CLASS_TYPE_P (from) && compatible_p)
1184 conv = build_identity_conv (from, expr);
1185 conv = direct_reference_binding (rto, conv);
1186 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1187 conv->u.next->check_copy_constructor_p = true;
1193 Otherwise, a temporary of type "cv1 T1" is created and
1194 initialized from the initializer expression using the rules for a
1195 non-reference copy initialization. If T1 is reference-related to
1196 T2, cv1 must be the same cv-qualification as, or greater
1197 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1198 if (related_p && !at_least_as_qualified_p (to, from))
1201 conv = implicit_conversion (to, from, expr, flags);
1205 conv = build_conv (ck_ref_bind, rto, conv);
1206 /* This reference binding, unlike those above, requires the
1207 creation of a temporary. */
1208 conv->need_temporary_p = true;
1213 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1214 to type TO. The optional expression EXPR may affect the conversion.
1215 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1219 implicit_conversion (tree to, tree from, tree expr, int flags)
1223 if (from == error_mark_node || to == error_mark_node
1224 || expr == error_mark_node)
1227 if (TREE_CODE (to) == REFERENCE_TYPE)
1228 conv = reference_binding (to, from, expr, flags);
1230 conv = standard_conversion (to, from, expr, flags);
1235 if (expr != NULL_TREE
1236 && (IS_AGGR_TYPE (from)
1237 || IS_AGGR_TYPE (to))
1238 && (flags & LOOKUP_NO_CONVERSION) == 0)
1240 struct z_candidate *cand;
1242 cand = build_user_type_conversion_1
1243 (to, expr, LOOKUP_ONLYCONVERTING);
1245 conv = cand->second_conv;
1247 /* We used to try to bind a reference to a temporary here, but that
1248 is now handled by the recursive call to this function at the end
1249 of reference_binding. */
1256 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1259 static struct z_candidate *
1260 add_candidate (struct z_candidate **candidates,
1262 size_t num_convs, conversion **convs,
1263 tree access_path, tree conversion_path,
1266 struct z_candidate *cand
1267 = conversion_obstack_alloc (sizeof (struct z_candidate));
1271 cand->convs = convs;
1272 cand->num_convs = num_convs;
1273 cand->access_path = access_path;
1274 cand->conversion_path = conversion_path;
1275 cand->viable = viable;
1276 cand->next = *candidates;
1282 /* Create an overload candidate for the function or method FN called with
1283 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1284 to implicit_conversion.
1286 CTYPE, if non-NULL, is the type we want to pretend this function
1287 comes from for purposes of overload resolution. */
1289 static struct z_candidate *
1290 add_function_candidate (struct z_candidate **candidates,
1291 tree fn, tree ctype, tree arglist,
1292 tree access_path, tree conversion_path,
1295 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1298 tree parmnode, argnode;
1302 /* Built-in functions that haven't been declared don't really
1304 if (DECL_ANTICIPATED (fn))
1307 /* The `this', `in_chrg' and VTT arguments to constructors are not
1308 considered in overload resolution. */
1309 if (DECL_CONSTRUCTOR_P (fn))
1311 parmlist = skip_artificial_parms_for (fn, parmlist);
1312 orig_arglist = arglist;
1313 arglist = skip_artificial_parms_for (fn, arglist);
1316 orig_arglist = arglist;
1318 len = list_length (arglist);
1319 convs = alloc_conversions (len);
1321 /* 13.3.2 - Viable functions [over.match.viable]
1322 First, to be a viable function, a candidate function shall have enough
1323 parameters to agree in number with the arguments in the list.
1325 We need to check this first; otherwise, checking the ICSes might cause
1326 us to produce an ill-formed template instantiation. */
1328 parmnode = parmlist;
1329 for (i = 0; i < len; ++i)
1331 if (parmnode == NULL_TREE || parmnode == void_list_node)
1333 parmnode = TREE_CHAIN (parmnode);
1336 if (i < len && parmnode)
1339 /* Make sure there are default args for the rest of the parms. */
1340 else if (!sufficient_parms_p (parmnode))
1346 /* Second, for F to be a viable function, there shall exist for each
1347 argument an implicit conversion sequence that converts that argument
1348 to the corresponding parameter of F. */
1350 parmnode = parmlist;
1353 for (i = 0; i < len; ++i)
1355 tree arg = TREE_VALUE (argnode);
1356 tree argtype = lvalue_type (arg);
1360 if (parmnode == void_list_node)
1363 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1364 && ! DECL_CONSTRUCTOR_P (fn));
1368 tree parmtype = TREE_VALUE (parmnode);
1370 /* The type of the implicit object parameter ('this') for
1371 overload resolution is not always the same as for the
1372 function itself; conversion functions are considered to
1373 be members of the class being converted, and functions
1374 introduced by a using-declaration are considered to be
1375 members of the class that uses them.
1377 Since build_over_call ignores the ICS for the `this'
1378 parameter, we can just change the parm type. */
1379 if (ctype && is_this)
1382 = build_qualified_type (ctype,
1383 TYPE_QUALS (TREE_TYPE (parmtype)));
1384 parmtype = build_pointer_type (parmtype);
1387 t = implicit_conversion (parmtype, argtype, arg, flags);
1391 t = build_identity_conv (argtype, arg);
1392 t->ellipsis_p = true;
1409 parmnode = TREE_CHAIN (parmnode);
1410 argnode = TREE_CHAIN (argnode);
1414 return add_candidate (candidates, fn, orig_arglist, len, convs,
1415 access_path, conversion_path, viable);
1418 /* Create an overload candidate for the conversion function FN which will
1419 be invoked for expression OBJ, producing a pointer-to-function which
1420 will in turn be called with the argument list ARGLIST, and add it to
1421 CANDIDATES. FLAGS is passed on to implicit_conversion.
1423 Actually, we don't really care about FN; we care about the type it
1424 converts to. There may be multiple conversion functions that will
1425 convert to that type, and we rely on build_user_type_conversion_1 to
1426 choose the best one; so when we create our candidate, we record the type
1427 instead of the function. */
1429 static struct z_candidate *
1430 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1431 tree arglist, tree access_path, tree conversion_path)
1433 tree totype = TREE_TYPE (TREE_TYPE (fn));
1434 int i, len, viable, flags;
1435 tree parmlist, parmnode, argnode;
1438 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1439 parmlist = TREE_TYPE (parmlist);
1440 parmlist = TYPE_ARG_TYPES (parmlist);
1442 len = list_length (arglist) + 1;
1443 convs = alloc_conversions (len);
1444 parmnode = parmlist;
1447 flags = LOOKUP_NORMAL;
1449 /* Don't bother looking up the same type twice. */
1450 if (*candidates && (*candidates)->fn == totype)
1453 for (i = 0; i < len; ++i)
1455 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1456 tree argtype = lvalue_type (arg);
1460 t = implicit_conversion (totype, argtype, arg, flags);
1461 else if (parmnode == void_list_node)
1464 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1467 t = build_identity_conv (argtype, arg);
1468 t->ellipsis_p = true;
1482 parmnode = TREE_CHAIN (parmnode);
1483 argnode = TREE_CHAIN (argnode);
1489 if (!sufficient_parms_p (parmnode))
1492 return add_candidate (candidates, totype, arglist, len, convs,
1493 access_path, conversion_path, viable);
1497 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1498 tree type1, tree type2, tree *args, tree *argtypes,
1510 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1511 convs = alloc_conversions (num_convs);
1513 for (i = 0; i < 2; ++i)
1518 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1522 /* We need something for printing the candidate. */
1523 t = build_identity_conv (types[i], NULL_TREE);
1530 /* For COND_EXPR we rearranged the arguments; undo that now. */
1533 convs[2] = convs[1];
1534 convs[1] = convs[0];
1535 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1542 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1544 /*access_path=*/NULL_TREE,
1545 /*conversion_path=*/NULL_TREE,
1550 is_complete (tree t)
1552 return COMPLETE_TYPE_P (complete_type (t));
1555 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1558 promoted_arithmetic_type_p (tree type)
1562 In this section, the term promoted integral type is used to refer
1563 to those integral types which are preserved by integral promotion
1564 (including e.g. int and long but excluding e.g. char).
1565 Similarly, the term promoted arithmetic type refers to promoted
1566 integral types plus floating types. */
1567 return ((INTEGRAL_TYPE_P (type)
1568 && same_type_p (type_promotes_to (type), type))
1569 || TREE_CODE (type) == REAL_TYPE);
1572 /* Create any builtin operator overload candidates for the operator in
1573 question given the converted operand types TYPE1 and TYPE2. The other
1574 args are passed through from add_builtin_candidates to
1575 build_builtin_candidate.
1577 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1578 If CODE is requires candidates operands of the same type of the kind
1579 of which TYPE1 and TYPE2 are, we add both candidates
1580 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1583 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1584 enum tree_code code2, tree fnname, tree type1,
1585 tree type2, tree *args, tree *argtypes, int flags)
1589 case POSTINCREMENT_EXPR:
1590 case POSTDECREMENT_EXPR:
1591 args[1] = integer_zero_node;
1592 type2 = integer_type_node;
1601 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1602 and VQ is either volatile or empty, there exist candidate operator
1603 functions of the form
1604 VQ T& operator++(VQ T&);
1605 T operator++(VQ T&, int);
1606 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1607 type other than bool, and VQ is either volatile or empty, there exist
1608 candidate operator functions of the form
1609 VQ T& operator--(VQ T&);
1610 T operator--(VQ T&, int);
1611 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1612 complete object type, and VQ is either volatile or empty, there exist
1613 candidate operator functions of the form
1614 T*VQ& operator++(T*VQ&);
1615 T*VQ& operator--(T*VQ&);
1616 T* operator++(T*VQ&, int);
1617 T* operator--(T*VQ&, int); */
1619 case POSTDECREMENT_EXPR:
1620 case PREDECREMENT_EXPR:
1621 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1623 case POSTINCREMENT_EXPR:
1624 case PREINCREMENT_EXPR:
1625 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1627 type1 = build_reference_type (type1);
1632 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1633 exist candidate operator functions of the form
1637 8 For every function type T, there exist candidate operator functions of
1639 T& operator*(T*); */
1642 if (TREE_CODE (type1) == POINTER_TYPE
1643 && (TYPE_PTROB_P (type1)
1644 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1648 /* 9 For every type T, there exist candidate operator functions of the form
1651 10For every promoted arithmetic type T, there exist candidate operator
1652 functions of the form
1656 case CONVERT_EXPR: /* unary + */
1657 if (TREE_CODE (type1) == POINTER_TYPE)
1660 if (ARITHMETIC_TYPE_P (type1))
1664 /* 11For every promoted integral type T, there exist candidate operator
1665 functions of the form
1669 if (INTEGRAL_TYPE_P (type1))
1673 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1674 is the same type as C2 or is a derived class of C2, T is a complete
1675 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1676 there exist candidate operator functions of the form
1677 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1678 where CV12 is the union of CV1 and CV2. */
1681 if (TREE_CODE (type1) == POINTER_TYPE
1682 && TYPE_PTR_TO_MEMBER_P (type2))
1684 tree c1 = TREE_TYPE (type1);
1685 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1687 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1688 && (TYPE_PTRMEMFUNC_P (type2)
1689 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1694 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1695 didate operator functions of the form
1700 bool operator<(L, R);
1701 bool operator>(L, R);
1702 bool operator<=(L, R);
1703 bool operator>=(L, R);
1704 bool operator==(L, R);
1705 bool operator!=(L, R);
1706 where LR is the result of the usual arithmetic conversions between
1709 14For every pair of types T and I, where T is a cv-qualified or cv-
1710 unqualified complete object type and I is a promoted integral type,
1711 there exist candidate operator functions of the form
1712 T* operator+(T*, I);
1713 T& operator[](T*, I);
1714 T* operator-(T*, I);
1715 T* operator+(I, T*);
1716 T& operator[](I, T*);
1718 15For every T, where T is a pointer to complete object type, there exist
1719 candidate operator functions of the form112)
1720 ptrdiff_t operator-(T, T);
1722 16For every pointer or enumeration type T, there exist candidate operator
1723 functions of the form
1724 bool operator<(T, T);
1725 bool operator>(T, T);
1726 bool operator<=(T, T);
1727 bool operator>=(T, T);
1728 bool operator==(T, T);
1729 bool operator!=(T, T);
1731 17For every pointer to member type T, there exist candidate operator
1732 functions of the form
1733 bool operator==(T, T);
1734 bool operator!=(T, T); */
1737 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1739 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1741 type2 = ptrdiff_type_node;
1745 case TRUNC_DIV_EXPR:
1746 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1752 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1753 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1755 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1760 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1772 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1774 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1776 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1778 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1783 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1791 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1794 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1796 type1 = ptrdiff_type_node;
1799 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1801 type2 = ptrdiff_type_node;
1806 /* 18For every pair of promoted integral types L and R, there exist candi-
1807 date operator functions of the form
1814 where LR is the result of the usual arithmetic conversions between
1817 case TRUNC_MOD_EXPR:
1823 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1827 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1828 type, VQ is either volatile or empty, and R is a promoted arithmetic
1829 type, there exist candidate operator functions of the form
1830 VQ L& operator=(VQ L&, R);
1831 VQ L& operator*=(VQ L&, R);
1832 VQ L& operator/=(VQ L&, R);
1833 VQ L& operator+=(VQ L&, R);
1834 VQ L& operator-=(VQ L&, R);
1836 20For every pair T, VQ), where T is any type and VQ is either volatile
1837 or empty, there exist candidate operator functions of the form
1838 T*VQ& operator=(T*VQ&, T*);
1840 21For every pair T, VQ), where T is a pointer to member type and VQ is
1841 either volatile or empty, there exist candidate operator functions of
1843 VQ T& operator=(VQ T&, T);
1845 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1846 unqualified complete object type, VQ is either volatile or empty, and
1847 I is a promoted integral type, there exist candidate operator func-
1849 T*VQ& operator+=(T*VQ&, I);
1850 T*VQ& operator-=(T*VQ&, I);
1852 23For every triple L, VQ, R), where L is an integral or enumeration
1853 type, VQ is either volatile or empty, and R is a promoted integral
1854 type, there exist candidate operator functions of the form
1856 VQ L& operator%=(VQ L&, R);
1857 VQ L& operator<<=(VQ L&, R);
1858 VQ L& operator>>=(VQ L&, R);
1859 VQ L& operator&=(VQ L&, R);
1860 VQ L& operator^=(VQ L&, R);
1861 VQ L& operator|=(VQ L&, R); */
1868 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1870 type2 = ptrdiff_type_node;
1874 case TRUNC_DIV_EXPR:
1875 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1879 case TRUNC_MOD_EXPR:
1885 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1890 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1892 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1893 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1894 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1895 || ((TYPE_PTRMEMFUNC_P (type1)
1896 || TREE_CODE (type1) == POINTER_TYPE)
1897 && null_ptr_cst_p (args[1])))
1907 type1 = build_reference_type (type1);
1913 For every pair of promoted arithmetic types L and R, there
1914 exist candidate operator functions of the form
1916 LR operator?(bool, L, R);
1918 where LR is the result of the usual arithmetic conversions
1919 between types L and R.
1921 For every type T, where T is a pointer or pointer-to-member
1922 type, there exist candidate operator functions of the form T
1923 operator?(bool, T, T); */
1925 if (promoted_arithmetic_type_p (type1)
1926 && promoted_arithmetic_type_p (type2))
1930 /* Otherwise, the types should be pointers. */
1931 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1932 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1935 /* We don't check that the two types are the same; the logic
1936 below will actually create two candidates; one in which both
1937 parameter types are TYPE1, and one in which both parameter
1945 /* If we're dealing with two pointer types or two enumeral types,
1946 we need candidates for both of them. */
1947 if (type2 && !same_type_p (type1, type2)
1948 && TREE_CODE (type1) == TREE_CODE (type2)
1949 && (TREE_CODE (type1) == REFERENCE_TYPE
1950 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1951 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1952 || TYPE_PTRMEMFUNC_P (type1)
1953 || IS_AGGR_TYPE (type1)
1954 || TREE_CODE (type1) == ENUMERAL_TYPE))
1956 build_builtin_candidate
1957 (candidates, fnname, type1, type1, args, argtypes, flags);
1958 build_builtin_candidate
1959 (candidates, fnname, type2, type2, args, argtypes, flags);
1963 build_builtin_candidate
1964 (candidates, fnname, type1, type2, args, argtypes, flags);
1968 type_decays_to (tree type)
1970 if (TREE_CODE (type) == ARRAY_TYPE)
1971 return build_pointer_type (TREE_TYPE (type));
1972 if (TREE_CODE (type) == FUNCTION_TYPE)
1973 return build_pointer_type (type);
1977 /* There are three conditions of builtin candidates:
1979 1) bool-taking candidates. These are the same regardless of the input.
1980 2) pointer-pair taking candidates. These are generated for each type
1981 one of the input types converts to.
1982 3) arithmetic candidates. According to the standard, we should generate
1983 all of these, but I'm trying not to...
1985 Here we generate a superset of the possible candidates for this particular
1986 case. That is a subset of the full set the standard defines, plus some
1987 other cases which the standard disallows. add_builtin_candidate will
1988 filter out the invalid set. */
1991 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
1992 enum tree_code code2, tree fnname, tree *args,
1997 tree type, argtypes[3];
1998 /* TYPES[i] is the set of possible builtin-operator parameter types
1999 we will consider for the Ith argument. These are represented as
2000 a TREE_LIST; the TREE_VALUE of each node is the potential
2004 for (i = 0; i < 3; ++i)
2007 argtypes[i] = lvalue_type (args[i]);
2009 argtypes[i] = NULL_TREE;
2014 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2015 and VQ is either volatile or empty, there exist candidate operator
2016 functions of the form
2017 VQ T& operator++(VQ T&); */
2019 case POSTINCREMENT_EXPR:
2020 case PREINCREMENT_EXPR:
2021 case POSTDECREMENT_EXPR:
2022 case PREDECREMENT_EXPR:
2027 /* 24There also exist candidate operator functions of the form
2028 bool operator!(bool);
2029 bool operator&&(bool, bool);
2030 bool operator||(bool, bool); */
2032 case TRUTH_NOT_EXPR:
2033 build_builtin_candidate
2034 (candidates, fnname, boolean_type_node,
2035 NULL_TREE, args, argtypes, flags);
2038 case TRUTH_ORIF_EXPR:
2039 case TRUTH_ANDIF_EXPR:
2040 build_builtin_candidate
2041 (candidates, fnname, boolean_type_node,
2042 boolean_type_node, args, argtypes, flags);
2064 types[0] = types[1] = NULL_TREE;
2066 for (i = 0; i < 2; ++i)
2070 else if (IS_AGGR_TYPE (argtypes[i]))
2074 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2077 convs = lookup_conversions (argtypes[i]);
2079 if (code == COND_EXPR)
2081 if (real_lvalue_p (args[i]))
2082 types[i] = tree_cons
2083 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2085 types[i] = tree_cons
2086 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2092 for (; convs; convs = TREE_CHAIN (convs))
2094 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2097 && (TREE_CODE (type) != REFERENCE_TYPE
2098 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2101 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2102 types[i] = tree_cons (NULL_TREE, type, types[i]);
2104 type = non_reference (type);
2105 if (i != 0 || ! ref1)
2107 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2108 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2109 types[i] = tree_cons (NULL_TREE, type, types[i]);
2110 if (INTEGRAL_TYPE_P (type))
2111 type = type_promotes_to (type);
2114 if (! value_member (type, types[i]))
2115 types[i] = tree_cons (NULL_TREE, type, types[i]);
2120 if (code == COND_EXPR && real_lvalue_p (args[i]))
2121 types[i] = tree_cons
2122 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2123 type = non_reference (argtypes[i]);
2124 if (i != 0 || ! ref1)
2126 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2127 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2128 types[i] = tree_cons (NULL_TREE, type, types[i]);
2129 if (INTEGRAL_TYPE_P (type))
2130 type = type_promotes_to (type);
2132 types[i] = tree_cons (NULL_TREE, type, types[i]);
2136 /* Run through the possible parameter types of both arguments,
2137 creating candidates with those parameter types. */
2138 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2141 for (type = types[1]; type; type = TREE_CHAIN (type))
2142 add_builtin_candidate
2143 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2144 TREE_VALUE (type), args, argtypes, flags);
2146 add_builtin_candidate
2147 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2148 NULL_TREE, args, argtypes, flags);
2155 /* If TMPL can be successfully instantiated as indicated by
2156 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2158 TMPL is the template. EXPLICIT_TARGS are any explicit template
2159 arguments. ARGLIST is the arguments provided at the call-site.
2160 The RETURN_TYPE is the desired type for conversion operators. If
2161 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2162 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2163 add_conv_candidate. */
2165 static struct z_candidate*
2166 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2167 tree ctype, tree explicit_targs, tree arglist,
2168 tree return_type, tree access_path,
2169 tree conversion_path, int flags, tree obj,
2170 unification_kind_t strict)
2172 int ntparms = DECL_NTPARMS (tmpl);
2173 tree targs = make_tree_vec (ntparms);
2174 tree args_without_in_chrg = arglist;
2175 struct z_candidate *cand;
2179 /* We don't do deduction on the in-charge parameter, the VTT
2180 parameter or 'this'. */
2181 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2182 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2184 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2185 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2186 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2187 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2189 i = fn_type_unification (tmpl, explicit_targs, targs,
2190 args_without_in_chrg,
2191 return_type, strict, -1);
2196 fn = instantiate_template (tmpl, targs, tf_none);
2197 if (fn == error_mark_node)
2202 A member function template is never instantiated to perform the
2203 copy of a class object to an object of its class type.
2205 It's a little unclear what this means; the standard explicitly
2206 does allow a template to be used to copy a class. For example,
2211 template <class T> A(const T&);
2214 void g () { A a (f ()); }
2216 the member template will be used to make the copy. The section
2217 quoted above appears in the paragraph that forbids constructors
2218 whose only parameter is (a possibly cv-qualified variant of) the
2219 class type, and a logical interpretation is that the intent was
2220 to forbid the instantiation of member templates which would then
2222 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2224 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2225 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2230 if (obj != NULL_TREE)
2231 /* Aha, this is a conversion function. */
2232 cand = add_conv_candidate (candidates, fn, obj, access_path,
2233 conversion_path, arglist);
2235 cand = add_function_candidate (candidates, fn, ctype,
2236 arglist, access_path,
2237 conversion_path, flags);
2238 if (DECL_TI_TEMPLATE (fn) != tmpl)
2239 /* This situation can occur if a member template of a template
2240 class is specialized. Then, instantiate_template might return
2241 an instantiation of the specialization, in which case the
2242 DECL_TI_TEMPLATE field will point at the original
2243 specialization. For example:
2245 template <class T> struct S { template <class U> void f(U);
2246 template <> void f(int) {}; };
2250 Here, TMPL will be template <class U> S<double>::f(U).
2251 And, instantiate template will give us the specialization
2252 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2253 for this will point at template <class T> template <> S<T>::f(int),
2254 so that we can find the definition. For the purposes of
2255 overload resolution, however, we want the original TMPL. */
2256 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2258 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2264 static struct z_candidate *
2265 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2266 tree explicit_targs, tree arglist, tree return_type,
2267 tree access_path, tree conversion_path, int flags,
2268 unification_kind_t strict)
2271 add_template_candidate_real (candidates, tmpl, ctype,
2272 explicit_targs, arglist, return_type,
2273 access_path, conversion_path,
2274 flags, NULL_TREE, strict);
2278 static struct z_candidate *
2279 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2280 tree obj, tree arglist, tree return_type,
2281 tree access_path, tree conversion_path)
2284 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2285 arglist, return_type, access_path,
2286 conversion_path, 0, obj, DEDUCE_CONV);
2289 /* The CANDS are the set of candidates that were considered for
2290 overload resolution. Return the set of viable candidates. If none
2291 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2292 is true if a candidate should be considered viable only if it is
2295 static struct z_candidate*
2296 splice_viable (struct z_candidate *cands,
2300 struct z_candidate *viable;
2301 struct z_candidate **last_viable;
2302 struct z_candidate **cand;
2305 last_viable = &viable;
2306 *any_viable_p = false;
2311 struct z_candidate *c = *cand;
2312 if (strict_p ? c->viable == 1 : c->viable)
2317 last_viable = &c->next;
2318 *any_viable_p = true;
2324 return viable ? viable : cands;
2328 any_strictly_viable (struct z_candidate *cands)
2330 for (; cands; cands = cands->next)
2331 if (cands->viable == 1)
2336 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2337 words, it is about to become the "this" pointer for a member
2338 function call. Take the address of the object. */
2341 build_this (tree obj)
2343 /* In a template, we are only concerned about the type of the
2344 expression, so we can take a shortcut. */
2345 if (processing_template_decl)
2346 return build_address (obj);
2348 return build_unary_op (ADDR_EXPR, obj, 0);
2351 /* Returns true iff functions are equivalent. Equivalent functions are
2352 not '==' only if one is a function-local extern function or if
2353 both are extern "C". */
2356 equal_functions (tree fn1, tree fn2)
2358 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2359 || DECL_EXTERN_C_FUNCTION_P (fn1))
2360 return decls_match (fn1, fn2);
2364 /* Print information about one overload candidate CANDIDATE. MSGSTR
2365 is the text to print before the candidate itself.
2367 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2368 to have been run through gettext by the caller. This wart makes
2369 life simpler in print_z_candidates and for the translators. */
2372 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2374 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2376 if (candidate->num_convs == 3)
2377 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2378 candidate->convs[0]->type,
2379 candidate->convs[1]->type,
2380 candidate->convs[2]->type);
2381 else if (candidate->num_convs == 2)
2382 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2383 candidate->convs[0]->type,
2384 candidate->convs[1]->type);
2386 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2387 candidate->convs[0]->type);
2389 else if (TYPE_P (candidate->fn))
2390 inform ("%s %T <conversion>", msgstr, candidate->fn);
2391 else if (candidate->viable == -1)
2392 inform ("%J%s %+#D <near match>", candidate->fn, msgstr, candidate->fn);
2394 inform ("%J%s %+#D", candidate->fn, msgstr, candidate->fn);
2398 print_z_candidates (struct z_candidate *candidates)
2401 struct z_candidate *cand1;
2402 struct z_candidate **cand2;
2404 /* There may be duplicates in the set of candidates. We put off
2405 checking this condition as long as possible, since we have no way
2406 to eliminate duplicates from a set of functions in less than n^2
2407 time. Now we are about to emit an error message, so it is more
2408 permissible to go slowly. */
2409 for (cand1 = candidates; cand1; cand1 = cand1->next)
2411 tree fn = cand1->fn;
2412 /* Skip builtin candidates and conversion functions. */
2413 if (TREE_CODE (fn) != FUNCTION_DECL)
2415 cand2 = &cand1->next;
2418 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2419 && equal_functions (fn, (*cand2)->fn))
2420 *cand2 = (*cand2)->next;
2422 cand2 = &(*cand2)->next;
2429 str = _("candidates are:");
2430 print_z_candidate (str, candidates);
2431 if (candidates->next)
2433 /* Indent successive candidates by the width of the translation
2434 of the above string. */
2435 size_t len = gcc_gettext_width (str) + 1;
2436 char *spaces = alloca (len);
2437 memset (spaces, ' ', len-1);
2438 spaces[len - 1] = '\0';
2440 candidates = candidates->next;
2443 print_z_candidate (spaces, candidates);
2444 candidates = candidates->next;
2450 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2451 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2452 the result of the conversion function to convert it to the final
2453 desired type. Merge the the two sequences into a single sequence,
2454 and return the merged sequence. */
2457 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2461 gcc_assert (user_seq->kind == ck_user);
2463 /* Find the end of the second conversion sequence. */
2465 while ((*t)->kind != ck_identity)
2466 t = &((*t)->u.next);
2468 /* Replace the identity conversion with the user conversion
2472 /* The entire sequence is a user-conversion sequence. */
2473 std_seq->user_conv_p = true;
2478 /* Returns the best overload candidate to perform the requested
2479 conversion. This function is used for three the overloading situations
2480 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2481 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2482 per [dcl.init.ref], so we ignore temporary bindings. */
2484 static struct z_candidate *
2485 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2487 struct z_candidate *candidates, *cand;
2488 tree fromtype = TREE_TYPE (expr);
2489 tree ctors = NULL_TREE;
2490 tree conv_fns = NULL_TREE;
2491 conversion *conv = NULL;
2492 tree args = NULL_TREE;
2495 /* We represent conversion within a hierarchy using RVALUE_CONV and
2496 BASE_CONV, as specified by [over.best.ics]; these become plain
2497 constructor calls, as specified in [dcl.init]. */
2498 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2499 || !DERIVED_FROM_P (totype, fromtype));
2501 if (IS_AGGR_TYPE (totype))
2502 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2504 if (IS_AGGR_TYPE (fromtype))
2505 conv_fns = lookup_conversions (fromtype);
2508 flags |= LOOKUP_NO_CONVERSION;
2514 ctors = BASELINK_FUNCTIONS (ctors);
2516 t = build_int_cst (build_pointer_type (totype), 0);
2517 args = build_tree_list (NULL_TREE, expr);
2518 /* We should never try to call the abstract or base constructor
2520 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2521 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2522 args = tree_cons (NULL_TREE, t, args);
2524 for (; ctors; ctors = OVL_NEXT (ctors))
2526 tree ctor = OVL_CURRENT (ctors);
2527 if (DECL_NONCONVERTING_P (ctor))
2530 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2531 cand = add_template_candidate (&candidates, ctor, totype,
2532 NULL_TREE, args, NULL_TREE,
2533 TYPE_BINFO (totype),
2534 TYPE_BINFO (totype),
2538 cand = add_function_candidate (&candidates, ctor, totype,
2539 args, TYPE_BINFO (totype),
2540 TYPE_BINFO (totype),
2544 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2548 args = build_tree_list (NULL_TREE, build_this (expr));
2550 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2553 tree conversion_path = TREE_PURPOSE (conv_fns);
2554 int convflags = LOOKUP_NO_CONVERSION;
2556 /* If we are called to convert to a reference type, we are trying to
2557 find an lvalue binding, so don't even consider temporaries. If
2558 we don't find an lvalue binding, the caller will try again to
2559 look for a temporary binding. */
2560 if (TREE_CODE (totype) == REFERENCE_TYPE)
2561 convflags |= LOOKUP_NO_TEMP_BIND;
2563 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2565 tree fn = OVL_CURRENT (fns);
2567 /* [over.match.funcs] For conversion functions, the function
2568 is considered to be a member of the class of the implicit
2569 object argument for the purpose of defining the type of
2570 the implicit object parameter.
2572 So we pass fromtype as CTYPE to add_*_candidate. */
2574 if (TREE_CODE (fn) == TEMPLATE_DECL)
2575 cand = add_template_candidate (&candidates, fn, fromtype,
2578 TYPE_BINFO (fromtype),
2583 cand = add_function_candidate (&candidates, fn, fromtype,
2585 TYPE_BINFO (fromtype),
2592 = implicit_conversion (totype,
2593 TREE_TYPE (TREE_TYPE (cand->fn)),
2596 cand->second_conv = ics;
2600 else if (candidates->viable == 1 && ics->bad_p)
2606 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2610 cand = tourney (candidates);
2613 if (flags & LOOKUP_COMPLAIN)
2615 error ("conversion from %qT to %qT is ambiguous",
2617 print_z_candidates (candidates);
2620 cand = candidates; /* any one will do */
2621 cand->second_conv = build_ambiguous_conv (totype, expr);
2622 cand->second_conv->user_conv_p = true;
2623 if (!any_strictly_viable (candidates))
2624 cand->second_conv->bad_p = true;
2625 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2626 ambiguous conversion is no worse than another user-defined
2632 /* Build the user conversion sequence. */
2635 (DECL_CONSTRUCTOR_P (cand->fn)
2636 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2637 build_identity_conv (TREE_TYPE (expr), expr));
2640 /* Combine it with the second conversion sequence. */
2641 cand->second_conv = merge_conversion_sequences (conv,
2644 if (cand->viable == -1)
2645 cand->second_conv->bad_p = true;
2651 build_user_type_conversion (tree totype, tree expr, int flags)
2653 struct z_candidate *cand
2654 = build_user_type_conversion_1 (totype, expr, flags);
2658 if (cand->second_conv->kind == ck_ambig)
2659 return error_mark_node;
2660 expr = convert_like (cand->second_conv, expr);
2661 return convert_from_reference (expr);
2666 /* Do any initial processing on the arguments to a function call. */
2669 resolve_args (tree args)
2672 for (t = args; t; t = TREE_CHAIN (t))
2674 tree arg = TREE_VALUE (t);
2676 if (arg == error_mark_node)
2677 return error_mark_node;
2678 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2680 error ("invalid use of void expression");
2681 return error_mark_node;
2687 /* Perform overload resolution on FN, which is called with the ARGS.
2689 Return the candidate function selected by overload resolution, or
2690 NULL if the event that overload resolution failed. In the case
2691 that overload resolution fails, *CANDIDATES will be the set of
2692 candidates considered, and ANY_VIABLE_P will be set to true or
2693 false to indicate whether or not any of the candidates were
2696 The ARGS should already have gone through RESOLVE_ARGS before this
2697 function is called. */
2699 static struct z_candidate *
2700 perform_overload_resolution (tree fn,
2702 struct z_candidate **candidates,
2705 struct z_candidate *cand;
2706 tree explicit_targs = NULL_TREE;
2707 int template_only = 0;
2710 *any_viable_p = true;
2712 /* Check FN and ARGS. */
2713 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2714 || TREE_CODE (fn) == TEMPLATE_DECL
2715 || TREE_CODE (fn) == OVERLOAD
2716 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2717 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2719 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2721 explicit_targs = TREE_OPERAND (fn, 1);
2722 fn = TREE_OPERAND (fn, 0);
2726 /* Add the various candidate functions. */
2727 add_candidates (fn, args, explicit_targs, template_only,
2728 /*conversion_path=*/NULL_TREE,
2729 /*access_path=*/NULL_TREE,
2733 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2737 cand = tourney (*candidates);
2741 /* Return an expression for a call to FN (a namespace-scope function,
2742 or a static member function) with the ARGS. */
2745 build_new_function_call (tree fn, tree args)
2747 struct z_candidate *candidates, *cand;
2752 args = resolve_args (args);
2753 if (args == error_mark_node)
2754 return error_mark_node;
2756 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2757 p = conversion_obstack_alloc (0);
2759 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2763 if (!any_viable_p && candidates && ! candidates->next)
2764 return build_function_call (candidates->fn, args);
2765 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2766 fn = TREE_OPERAND (fn, 0);
2768 error ("no matching function for call to %<%D(%A)%>",
2769 DECL_NAME (OVL_CURRENT (fn)), args);
2771 error ("call of overloaded %<%D(%A)%> is ambiguous",
2772 DECL_NAME (OVL_CURRENT (fn)), args);
2774 print_z_candidates (candidates);
2775 result = error_mark_node;
2778 result = build_over_call (cand, LOOKUP_NORMAL);
2780 /* Free all the conversions we allocated. */
2781 obstack_free (&conversion_obstack, p);
2786 /* Build a call to a global operator new. FNNAME is the name of the
2787 operator (either "operator new" or "operator new[]") and ARGS are
2788 the arguments provided. *SIZE points to the total number of bytes
2789 required by the allocation, and is updated if that is changed here.
2790 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2791 function determines that no cookie should be used, after all,
2792 *COOKIE_SIZE is set to NULL_TREE. */
2795 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2798 struct z_candidate *candidates;
2799 struct z_candidate *cand;
2802 args = tree_cons (NULL_TREE, *size, args);
2803 args = resolve_args (args);
2804 if (args == error_mark_node)
2811 If this lookup fails to find the name, or if the allocated type
2812 is not a class type, the allocation function's name is looked
2813 up in the global scope.
2815 we disregard block-scope declarations of "operator new". */
2816 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2818 /* Figure out what function is being called. */
2819 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2821 /* If no suitable function could be found, issue an error message
2826 error ("no matching function for call to %<%D(%A)%>",
2827 DECL_NAME (OVL_CURRENT (fns)), args);
2829 error ("call of overloaded %<%D(%A)%> is ambiguous",
2830 DECL_NAME (OVL_CURRENT (fns)), args);
2832 print_z_candidates (candidates);
2833 return error_mark_node;
2836 /* If a cookie is required, add some extra space. Whether
2837 or not a cookie is required cannot be determined until
2838 after we know which function was called. */
2841 bool use_cookie = true;
2842 if (!abi_version_at_least (2))
2844 tree placement = TREE_CHAIN (args);
2845 /* In G++ 3.2, the check was implemented incorrectly; it
2846 looked at the placement expression, rather than the
2847 type of the function. */
2848 if (placement && !TREE_CHAIN (placement)
2849 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2857 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2858 /* Skip the size_t parameter. */
2859 arg_types = TREE_CHAIN (arg_types);
2860 /* Check the remaining parameters (if any). */
2862 && TREE_CHAIN (arg_types) == void_list_node
2863 && same_type_p (TREE_VALUE (arg_types),
2867 /* If we need a cookie, adjust the number of bytes allocated. */
2870 /* Update the total size. */
2871 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2872 /* Update the argument list to reflect the adjusted size. */
2873 TREE_VALUE (args) = *size;
2876 *cookie_size = NULL_TREE;
2879 /* Build the CALL_EXPR. */
2880 return build_over_call (cand, LOOKUP_NORMAL);
2884 build_object_call (tree obj, tree args)
2886 struct z_candidate *candidates = 0, *cand;
2887 tree fns, convs, mem_args = NULL_TREE;
2888 tree type = TREE_TYPE (obj);
2890 tree result = NULL_TREE;
2893 if (TYPE_PTRMEMFUNC_P (type))
2895 /* It's no good looking for an overloaded operator() on a
2896 pointer-to-member-function. */
2897 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2898 return error_mark_node;
2901 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2902 if (fns == error_mark_node)
2903 return error_mark_node;
2905 args = resolve_args (args);
2907 if (args == error_mark_node)
2908 return error_mark_node;
2910 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2911 p = conversion_obstack_alloc (0);
2915 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2916 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2918 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2920 tree fn = OVL_CURRENT (fns);
2921 if (TREE_CODE (fn) == TEMPLATE_DECL)
2922 add_template_candidate (&candidates, fn, base, NULL_TREE,
2923 mem_args, NULL_TREE,
2926 LOOKUP_NORMAL, DEDUCE_CALL);
2928 add_function_candidate
2929 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2930 TYPE_BINFO (type), LOOKUP_NORMAL);
2934 convs = lookup_conversions (type);
2936 for (; convs; convs = TREE_CHAIN (convs))
2938 tree fns = TREE_VALUE (convs);
2939 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2941 if ((TREE_CODE (totype) == POINTER_TYPE
2942 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2943 || (TREE_CODE (totype) == REFERENCE_TYPE
2944 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2945 || (TREE_CODE (totype) == REFERENCE_TYPE
2946 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2947 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
2948 for (; fns; fns = OVL_NEXT (fns))
2950 tree fn = OVL_CURRENT (fns);
2951 if (TREE_CODE (fn) == TEMPLATE_DECL)
2952 add_template_conv_candidate
2953 (&candidates, fn, obj, args, totype,
2954 /*access_path=*/NULL_TREE,
2955 /*conversion_path=*/NULL_TREE);
2957 add_conv_candidate (&candidates, fn, obj, args,
2958 /*conversion_path=*/NULL_TREE,
2959 /*access_path=*/NULL_TREE);
2963 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2966 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
2967 print_z_candidates (candidates);
2968 result = error_mark_node;
2972 cand = tourney (candidates);
2975 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
2976 print_z_candidates (candidates);
2977 result = error_mark_node;
2979 /* Since cand->fn will be a type, not a function, for a conversion
2980 function, we must be careful not to unconditionally look at
2982 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
2983 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
2984 result = build_over_call (cand, LOOKUP_NORMAL);
2987 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
2988 obj = convert_from_reference (obj);
2989 result = build_function_call (obj, args);
2993 /* Free all the conversions we allocated. */
2994 obstack_free (&conversion_obstack, p);
3000 op_error (enum tree_code code, enum tree_code code2,
3001 tree arg1, tree arg2, tree arg3, const char *problem)
3005 if (code == MODIFY_EXPR)
3006 opname = assignment_operator_name_info[code2].name;
3008 opname = operator_name_info[code].name;
3013 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3014 problem, arg1, arg2, arg3);
3017 case POSTINCREMENT_EXPR:
3018 case POSTDECREMENT_EXPR:
3019 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3023 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3028 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3033 error ("%s for %<operator%s%> in %<%E %s %E%>",
3034 problem, opname, arg1, opname, arg2);
3036 error ("%s for %<operator%s%> in %<%s%E%>",
3037 problem, opname, opname, arg1);
3042 /* Return the implicit conversion sequence that could be used to
3043 convert E1 to E2 in [expr.cond]. */
3046 conditional_conversion (tree e1, tree e2)
3048 tree t1 = non_reference (TREE_TYPE (e1));
3049 tree t2 = non_reference (TREE_TYPE (e2));
3055 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3056 implicitly converted (clause _conv_) to the type "reference to
3057 T2", subject to the constraint that in the conversion the
3058 reference must bind directly (_dcl.init.ref_) to E1. */
3059 if (real_lvalue_p (e2))
3061 conv = implicit_conversion (build_reference_type (t2),
3064 LOOKUP_NO_TEMP_BIND);
3071 If E1 and E2 have class type, and the underlying class types are
3072 the same or one is a base class of the other: E1 can be converted
3073 to match E2 if the class of T2 is the same type as, or a base
3074 class of, the class of T1, and the cv-qualification of T2 is the
3075 same cv-qualification as, or a greater cv-qualification than, the
3076 cv-qualification of T1. If the conversion is applied, E1 is
3077 changed to an rvalue of type T2 that still refers to the original
3078 source class object (or the appropriate subobject thereof). */
3079 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3080 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3082 if (good_base && at_least_as_qualified_p (t2, t1))
3084 conv = build_identity_conv (t1, e1);
3085 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3086 TYPE_MAIN_VARIANT (t2)))
3087 conv = build_conv (ck_base, t2, conv);
3089 conv = build_conv (ck_rvalue, t2, conv);
3098 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3099 converted to the type that expression E2 would have if E2 were
3100 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3101 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3104 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3105 arguments to the conditional expression. */
3108 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3112 tree result = NULL_TREE;
3113 tree result_type = NULL_TREE;
3114 bool lvalue_p = true;
3115 struct z_candidate *candidates = 0;
3116 struct z_candidate *cand;
3119 /* As a G++ extension, the second argument to the conditional can be
3120 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3121 c'.) If the second operand is omitted, make sure it is
3122 calculated only once. */
3126 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3128 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3129 if (real_lvalue_p (arg1))
3130 arg2 = arg1 = stabilize_reference (arg1);
3132 arg2 = arg1 = save_expr (arg1);
3137 The first expr ession is implicitly converted to bool (clause
3139 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3141 /* If something has already gone wrong, just pass that fact up the
3143 if (error_operand_p (arg1)
3144 || error_operand_p (arg2)
3145 || error_operand_p (arg3))
3146 return error_mark_node;
3150 If either the second or the third operand has type (possibly
3151 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3152 array-to-pointer (_conv.array_), and function-to-pointer
3153 (_conv.func_) standard conversions are performed on the second
3154 and third operands. */
3155 arg2_type = TREE_TYPE (arg2);
3156 arg3_type = TREE_TYPE (arg3);
3157 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3159 /* Do the conversions. We don't these for `void' type arguments
3160 since it can't have any effect and since decay_conversion
3161 does not handle that case gracefully. */
3162 if (!VOID_TYPE_P (arg2_type))
3163 arg2 = decay_conversion (arg2);
3164 if (!VOID_TYPE_P (arg3_type))
3165 arg3 = decay_conversion (arg3);
3166 arg2_type = TREE_TYPE (arg2);
3167 arg3_type = TREE_TYPE (arg3);
3171 One of the following shall hold:
3173 --The second or the third operand (but not both) is a
3174 throw-expression (_except.throw_); the result is of the
3175 type of the other and is an rvalue.
3177 --Both the second and the third operands have type void; the
3178 result is of type void and is an rvalue.
3180 We must avoid calling force_rvalue for expressions of type
3181 "void" because it will complain that their value is being
3183 if (TREE_CODE (arg2) == THROW_EXPR
3184 && TREE_CODE (arg3) != THROW_EXPR)
3186 if (!VOID_TYPE_P (arg3_type))
3187 arg3 = force_rvalue (arg3);
3188 arg3_type = TREE_TYPE (arg3);
3189 result_type = arg3_type;
3191 else if (TREE_CODE (arg2) != THROW_EXPR
3192 && TREE_CODE (arg3) == THROW_EXPR)
3194 if (!VOID_TYPE_P (arg2_type))
3195 arg2 = force_rvalue (arg2);
3196 arg2_type = TREE_TYPE (arg2);
3197 result_type = arg2_type;
3199 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3200 result_type = void_type_node;
3203 error ("%qE has type %<void%> and is not a throw-expression",
3204 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3205 return error_mark_node;
3209 goto valid_operands;
3213 Otherwise, if the second and third operand have different types,
3214 and either has (possibly cv-qualified) class type, an attempt is
3215 made to convert each of those operands to the type of the other. */
3216 else if (!same_type_p (arg2_type, arg3_type)
3217 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3222 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3223 p = conversion_obstack_alloc (0);
3225 conv2 = conditional_conversion (arg2, arg3);
3226 conv3 = conditional_conversion (arg3, arg2);
3230 If both can be converted, or one can be converted but the
3231 conversion is ambiguous, the program is ill-formed. If
3232 neither can be converted, the operands are left unchanged and
3233 further checking is performed as described below. If exactly
3234 one conversion is possible, that conversion is applied to the
3235 chosen operand and the converted operand is used in place of
3236 the original operand for the remainder of this section. */
3237 if ((conv2 && !conv2->bad_p
3238 && conv3 && !conv3->bad_p)
3239 || (conv2 && conv2->kind == ck_ambig)
3240 || (conv3 && conv3->kind == ck_ambig))
3242 error ("operands to ?: have different types");
3243 result = error_mark_node;
3245 else if (conv2 && !conv2->bad_p)
3247 arg2 = convert_like (conv2, arg2);
3248 arg2 = convert_from_reference (arg2);
3249 arg2_type = TREE_TYPE (arg2);
3251 else if (conv3 && !conv3->bad_p)
3253 arg3 = convert_like (conv3, arg3);
3254 arg3 = convert_from_reference (arg3);
3255 arg3_type = TREE_TYPE (arg3);
3258 /* Free all the conversions we allocated. */
3259 obstack_free (&conversion_obstack, p);
3264 /* If, after the conversion, both operands have class type,
3265 treat the cv-qualification of both operands as if it were the
3266 union of the cv-qualification of the operands.
3268 The standard is not clear about what to do in this
3269 circumstance. For example, if the first operand has type
3270 "const X" and the second operand has a user-defined
3271 conversion to "volatile X", what is the type of the second
3272 operand after this step? Making it be "const X" (matching
3273 the first operand) seems wrong, as that discards the
3274 qualification without actually performing a copy. Leaving it
3275 as "volatile X" seems wrong as that will result in the
3276 conditional expression failing altogether, even though,
3277 according to this step, the one operand could be converted to
3278 the type of the other. */
3279 if ((conv2 || conv3)
3280 && CLASS_TYPE_P (arg2_type)
3281 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3282 arg2_type = arg3_type =
3283 cp_build_qualified_type (arg2_type,
3284 TYPE_QUALS (arg2_type)
3285 | TYPE_QUALS (arg3_type));
3290 If the second and third operands are lvalues and have the same
3291 type, the result is of that type and is an lvalue. */
3292 if (real_lvalue_p (arg2)
3293 && real_lvalue_p (arg3)
3294 && same_type_p (arg2_type, arg3_type))
3296 result_type = arg2_type;
3297 goto valid_operands;
3302 Otherwise, the result is an rvalue. If the second and third
3303 operand do not have the same type, and either has (possibly
3304 cv-qualified) class type, overload resolution is used to
3305 determine the conversions (if any) to be applied to the operands
3306 (_over.match.oper_, _over.built_). */
3308 if (!same_type_p (arg2_type, arg3_type)
3309 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3315 /* Rearrange the arguments so that add_builtin_candidate only has
3316 to know about two args. In build_builtin_candidates, the
3317 arguments are unscrambled. */
3321 add_builtin_candidates (&candidates,
3324 ansi_opname (COND_EXPR),
3330 If the overload resolution fails, the program is
3332 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3335 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3336 print_z_candidates (candidates);
3337 return error_mark_node;
3339 cand = tourney (candidates);
3342 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3343 print_z_candidates (candidates);
3344 return error_mark_node;
3349 Otherwise, the conversions thus determined are applied, and
3350 the converted operands are used in place of the original
3351 operands for the remainder of this section. */
3352 conv = cand->convs[0];
3353 arg1 = convert_like (conv, arg1);
3354 conv = cand->convs[1];
3355 arg2 = convert_like (conv, arg2);
3356 conv = cand->convs[2];
3357 arg3 = convert_like (conv, arg3);
3362 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3363 and function-to-pointer (_conv.func_) standard conversions are
3364 performed on the second and third operands.
3366 We need to force the lvalue-to-rvalue conversion here for class types,
3367 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3368 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3371 arg2 = force_rvalue (arg2);
3372 if (!CLASS_TYPE_P (arg2_type))
3373 arg2_type = TREE_TYPE (arg2);
3375 arg3 = force_rvalue (arg3);
3376 if (!CLASS_TYPE_P (arg2_type))
3377 arg3_type = TREE_TYPE (arg3);
3379 if (arg2 == error_mark_node || arg3 == error_mark_node)
3380 return error_mark_node;
3384 After those conversions, one of the following shall hold:
3386 --The second and third operands have the same type; the result is of
3388 if (same_type_p (arg2_type, arg3_type))
3389 result_type = arg2_type;
3392 --The second and third operands have arithmetic or enumeration
3393 type; the usual arithmetic conversions are performed to bring
3394 them to a common type, and the result is of that type. */
3395 else if ((ARITHMETIC_TYPE_P (arg2_type)
3396 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3397 && (ARITHMETIC_TYPE_P (arg3_type)
3398 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3400 /* In this case, there is always a common type. */
3401 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3404 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3405 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3406 warning ("enumeral mismatch in conditional expression: %qT vs %qT",
3407 arg2_type, arg3_type);
3408 else if (extra_warnings
3409 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3410 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3411 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3412 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3413 warning ("enumeral and non-enumeral type in conditional expression");
3415 arg2 = perform_implicit_conversion (result_type, arg2);
3416 arg3 = perform_implicit_conversion (result_type, arg3);
3420 --The second and third operands have pointer type, or one has
3421 pointer type and the other is a null pointer constant; pointer
3422 conversions (_conv.ptr_) and qualification conversions
3423 (_conv.qual_) are performed to bring them to their composite
3424 pointer type (_expr.rel_). The result is of the composite
3427 --The second and third operands have pointer to member type, or
3428 one has pointer to member type and the other is a null pointer
3429 constant; pointer to member conversions (_conv.mem_) and
3430 qualification conversions (_conv.qual_) are performed to bring
3431 them to a common type, whose cv-qualification shall match the
3432 cv-qualification of either the second or the third operand.
3433 The result is of the common type. */
3434 else if ((null_ptr_cst_p (arg2)
3435 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3436 || (null_ptr_cst_p (arg3)
3437 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3438 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3439 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3440 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3442 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3443 arg3, "conditional expression");
3444 if (result_type == error_mark_node)
3445 return error_mark_node;
3446 arg2 = perform_implicit_conversion (result_type, arg2);
3447 arg3 = perform_implicit_conversion (result_type, arg3);
3452 error ("operands to ?: have different types");
3453 return error_mark_node;
3457 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3459 /* We can't use result_type below, as fold might have returned a
3462 /* Expand both sides into the same slot, hopefully the target of the
3463 ?: expression. We used to check for TARGET_EXPRs here, but now we
3464 sometimes wrap them in NOP_EXPRs so the test would fail. */
3465 if (!lvalue_p && CLASS_TYPE_P (TREE_TYPE (result)))
3466 result = get_target_expr (result);
3468 /* If this expression is an rvalue, but might be mistaken for an
3469 lvalue, we must add a NON_LVALUE_EXPR. */
3470 if (!lvalue_p && real_lvalue_p (result))
3471 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3476 /* OPERAND is an operand to an expression. Perform necessary steps
3477 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3481 prep_operand (tree operand)
3485 if (CLASS_TYPE_P (TREE_TYPE (operand))
3486 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3487 /* Make sure the template type is instantiated now. */
3488 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3494 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3495 OVERLOAD) to the CANDIDATES, returning an updated list of
3496 CANDIDATES. The ARGS are the arguments provided to the call,
3497 without any implicit object parameter. The EXPLICIT_TARGS are
3498 explicit template arguments provided. TEMPLATE_ONLY is true if
3499 only template functions should be considered. CONVERSION_PATH,
3500 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3503 add_candidates (tree fns, tree args,
3504 tree explicit_targs, bool template_only,
3505 tree conversion_path, tree access_path,
3507 struct z_candidate **candidates)
3510 tree non_static_args;
3512 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3513 /* Delay creating the implicit this parameter until it is needed. */
3514 non_static_args = NULL_TREE;
3521 fn = OVL_CURRENT (fns);
3522 /* Figure out which set of arguments to use. */
3523 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3525 /* If this function is a non-static member, prepend the implicit
3526 object parameter. */
3527 if (!non_static_args)
3528 non_static_args = tree_cons (NULL_TREE,
3529 build_this (TREE_VALUE (args)),
3531 fn_args = non_static_args;
3534 /* Otherwise, just use the list of arguments provided. */
3537 if (TREE_CODE (fn) == TEMPLATE_DECL)
3538 add_template_candidate (candidates,
3548 else if (!template_only)
3549 add_function_candidate (candidates,
3556 fns = OVL_NEXT (fns);
3561 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3564 struct z_candidate *candidates = 0, *cand;
3565 tree arglist, fnname;
3567 tree result = NULL_TREE;
3568 bool result_valid_p = false;
3569 enum tree_code code2 = NOP_EXPR;
3575 if (error_operand_p (arg1)
3576 || error_operand_p (arg2)
3577 || error_operand_p (arg3))
3578 return error_mark_node;
3580 if (code == MODIFY_EXPR)
3582 code2 = TREE_CODE (arg3);
3584 fnname = ansi_assopname (code2);
3587 fnname = ansi_opname (code);
3589 arg1 = prep_operand (arg1);
3595 case VEC_DELETE_EXPR:
3597 /* Use build_op_new_call and build_op_delete_call instead. */
3601 return build_object_call (arg1, arg2);
3607 arg2 = prep_operand (arg2);
3608 arg3 = prep_operand (arg3);
3610 if (code == COND_EXPR)
3612 if (arg2 == NULL_TREE
3613 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3614 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3615 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3616 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3619 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3620 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3623 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3624 arg2 = integer_zero_node;
3626 arglist = NULL_TREE;
3628 arglist = tree_cons (NULL_TREE, arg3, arglist);
3630 arglist = tree_cons (NULL_TREE, arg2, arglist);
3631 arglist = tree_cons (NULL_TREE, arg1, arglist);
3633 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3634 p = conversion_obstack_alloc (0);
3636 /* Add namespace-scope operators to the list of functions to
3638 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3639 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3640 flags, &candidates);
3641 /* Add class-member operators to the candidate set. */
3642 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3646 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3647 if (fns == error_mark_node)
3649 result = error_mark_node;
3650 goto user_defined_result_ready;
3653 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3655 BASELINK_BINFO (fns),
3656 TYPE_BINFO (TREE_TYPE (arg1)),
3657 flags, &candidates);
3660 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3661 to know about two args; a builtin candidate will always have a first
3662 parameter of type bool. We'll handle that in
3663 build_builtin_candidate. */
3664 if (code == COND_EXPR)
3674 args[2] = NULL_TREE;
3677 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3683 /* For these, the built-in candidates set is empty
3684 [over.match.oper]/3. We don't want non-strict matches
3685 because exact matches are always possible with built-in
3686 operators. The built-in candidate set for COMPONENT_REF
3687 would be empty too, but since there are no such built-in
3688 operators, we accept non-strict matches for them. */
3693 strict_p = pedantic;
3697 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3702 case POSTINCREMENT_EXPR:
3703 case POSTDECREMENT_EXPR:
3704 /* Look for an `operator++ (int)'. If they didn't have
3705 one, then we fall back to the old way of doing things. */
3706 if (flags & LOOKUP_COMPLAIN)
3707 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3708 "trying prefix operator instead",
3710 operator_name_info[code].name);
3711 if (code == POSTINCREMENT_EXPR)
3712 code = PREINCREMENT_EXPR;
3714 code = PREDECREMENT_EXPR;
3715 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3719 /* The caller will deal with these. */
3724 result_valid_p = true;
3728 if (flags & LOOKUP_COMPLAIN)
3730 op_error (code, code2, arg1, arg2, arg3, "no match");
3731 print_z_candidates (candidates);
3733 result = error_mark_node;
3739 cand = tourney (candidates);
3742 if (flags & LOOKUP_COMPLAIN)
3744 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3745 print_z_candidates (candidates);
3747 result = error_mark_node;
3749 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3752 *overloaded_p = true;
3755 && fnname == ansi_assopname (NOP_EXPR)
3756 && DECL_ARTIFICIAL (cand->fn)
3758 && ! candidates->next->next)
3760 warning ("using synthesized %q#D for copy assignment",
3762 cp_warning_at (" where cfront would use %q#D",
3764 ? candidates->next->fn
3768 result = build_over_call (cand, LOOKUP_NORMAL);
3772 /* Give any warnings we noticed during overload resolution. */
3775 struct candidate_warning *w;
3776 for (w = cand->warnings; w; w = w->next)
3777 joust (cand, w->loser, 1);
3780 /* Check for comparison of different enum types. */
3789 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3790 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3791 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3792 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3794 warning ("comparison between %q#T and %q#T",
3795 TREE_TYPE (arg1), TREE_TYPE (arg2));
3802 /* We need to strip any leading REF_BIND so that bitfields
3803 don't cause errors. This should not remove any important
3804 conversions, because builtins don't apply to class
3805 objects directly. */
3806 conv = cand->convs[0];
3807 if (conv->kind == ck_ref_bind)
3808 conv = conv->u.next;
3809 arg1 = convert_like (conv, arg1);
3812 conv = cand->convs[1];
3813 if (conv->kind == ck_ref_bind)
3814 conv = conv->u.next;
3815 arg2 = convert_like (conv, arg2);
3819 conv = cand->convs[2];
3820 if (conv->kind == ck_ref_bind)
3821 conv = conv->u.next;
3822 arg3 = convert_like (conv, arg3);
3827 user_defined_result_ready:
3829 /* Free all the conversions we allocated. */
3830 obstack_free (&conversion_obstack, p);
3832 if (result || result_valid_p)
3839 return build_modify_expr (arg1, code2, arg2);
3842 return build_indirect_ref (arg1, "unary *");
3847 case TRUNC_DIV_EXPR:
3858 case TRUNC_MOD_EXPR:
3862 case TRUTH_ANDIF_EXPR:
3863 case TRUTH_ORIF_EXPR:
3864 return cp_build_binary_op (code, arg1, arg2);
3869 case TRUTH_NOT_EXPR:
3870 case PREINCREMENT_EXPR:
3871 case POSTINCREMENT_EXPR:
3872 case PREDECREMENT_EXPR:
3873 case POSTDECREMENT_EXPR:
3876 return build_unary_op (code, arg1, candidates != 0);
3879 return build_array_ref (arg1, arg2);
3882 return build_conditional_expr (arg1, arg2, arg3);
3885 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
3887 /* The caller will deal with these. */
3899 /* Build a call to operator delete. This has to be handled very specially,
3900 because the restrictions on what signatures match are different from all
3901 other call instances. For a normal delete, only a delete taking (void *)
3902 or (void *, size_t) is accepted. For a placement delete, only an exact
3903 match with the placement new is accepted.
3905 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3906 ADDR is the pointer to be deleted.
3907 SIZE is the size of the memory block to be deleted.
3908 GLOBAL_P is true if the delete-expression should not consider
3909 class-specific delete operators.
3910 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3913 build_op_delete_call (enum tree_code code, tree addr, tree size,
3914 bool global_p, tree placement)
3916 tree fn = NULL_TREE;
3917 tree fns, fnname, argtypes, args, type;
3920 if (addr == error_mark_node)
3921 return error_mark_node;
3923 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3925 fnname = ansi_opname (code);
3927 if (IS_AGGR_TYPE (type) && !global_p)
3930 If the result of the lookup is ambiguous or inaccessible, or if
3931 the lookup selects a placement deallocation function, the
3932 program is ill-formed.
3934 Therefore, we ask lookup_fnfields to complain about ambiguity. */
3936 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3937 if (fns == error_mark_node)
3938 return error_mark_node;
3943 if (fns == NULL_TREE)
3944 fns = lookup_name_nonclass (fnname);
3951 /* Find the allocation function that is being called. */
3952 call_expr = placement;
3953 /* Extract the function. */
3954 alloc_fn = get_callee_fndecl (call_expr);
3955 gcc_assert (alloc_fn != NULL_TREE);
3956 /* Then the second parm type. */
3957 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3958 /* Also the second argument. */
3959 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3963 /* First try it without the size argument. */
3964 argtypes = void_list_node;
3968 /* Strip const and volatile from addr. */
3969 addr = cp_convert (ptr_type_node, addr);
3971 /* We make two tries at finding a matching `operator delete'. On
3972 the first pass, we look for a one-operator (or placement)
3973 operator delete. If we're not doing placement delete, then on
3974 the second pass we look for a two-argument delete. */
3975 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
3977 /* Go through the `operator delete' functions looking for one
3978 with a matching type. */
3979 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
3985 /* The first argument must be "void *". */
3986 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3987 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3990 /* On the first pass, check the rest of the arguments. */
3996 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4004 /* On the second pass, the second argument must be
4007 && same_type_p (TREE_VALUE (t), sizetype)
4008 && TREE_CHAIN (t) == void_list_node)
4012 /* If we found a match, we're done. */
4017 /* If we have a matching function, call it. */
4020 /* Make sure we have the actual function, and not an
4022 fn = OVL_CURRENT (fn);
4024 /* If the FN is a member function, make sure that it is
4026 if (DECL_CLASS_SCOPE_P (fn))
4027 perform_or_defer_access_check (TYPE_BINFO (type), fn);
4030 args = tree_cons (NULL_TREE, addr, args);
4032 args = tree_cons (NULL_TREE, addr,
4033 build_tree_list (NULL_TREE, size));
4037 /* The placement args might not be suitable for overload
4038 resolution at this point, so build the call directly. */
4040 return build_cxx_call (fn, args);
4043 return build_function_call (fn, args);
4046 /* If we are doing placement delete we do nothing if we don't find a
4047 matching op delete. */
4051 error ("no suitable %<operator %s> for %qT",
4052 operator_name_info[(int)code].name, type);
4053 return error_mark_node;
4056 /* If the current scope isn't allowed to access DECL along
4057 BASETYPE_PATH, give an error. The most derived class in
4058 BASETYPE_PATH is the one used to qualify DECL. */
4061 enforce_access (tree basetype_path, tree decl)
4063 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4065 if (!accessible_p (basetype_path, decl, true))
4067 if (TREE_PRIVATE (decl))
4068 cp_error_at ("%q+#D is private", decl);
4069 else if (TREE_PROTECTED (decl))
4070 cp_error_at ("%q+#D is protected", decl);
4072 cp_error_at ("%q+#D is inaccessible", decl);
4073 error ("within this context");
4080 /* Check that a callable constructor to initialize a temporary of
4081 TYPE from an EXPR exists. */
4084 check_constructor_callable (tree type, tree expr)
4086 build_special_member_call (NULL_TREE,
4087 complete_ctor_identifier,
4088 build_tree_list (NULL_TREE, expr),
4090 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4091 | LOOKUP_NO_CONVERSION
4092 | LOOKUP_CONSTRUCTOR_CALLABLE);
4095 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4096 bitwise or of LOOKUP_* values. If any errors are warnings are
4097 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4098 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4102 build_temp (tree expr, tree type, int flags,
4103 void (**diagnostic_fn)(const char *, ...))
4107 savew = warningcount, savee = errorcount;
4108 expr = build_special_member_call (NULL_TREE,
4109 complete_ctor_identifier,
4110 build_tree_list (NULL_TREE, expr),
4112 if (warningcount > savew)
4113 *diagnostic_fn = warning;
4114 else if (errorcount > savee)
4115 *diagnostic_fn = error;
4117 *diagnostic_fn = NULL;
4122 /* Perform the conversions in CONVS on the expression EXPR. FN and
4123 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4124 indicates the `this' argument of a method. INNER is nonzero when
4125 being called to continue a conversion chain. It is negative when a
4126 reference binding will be applied, positive otherwise. If
4127 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4128 conversions will be emitted if appropriate. If C_CAST_P is true,
4129 this conversion is coming from a C-style cast; in that case,
4130 conversions to inaccessible bases are permitted. */
4133 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4134 int inner, bool issue_conversion_warnings,
4137 tree totype = convs->type;
4138 void (*diagnostic_fn)(const char *, ...);
4141 && convs->kind != ck_user
4142 && convs->kind != ck_ambig
4143 && convs->kind != ck_ref_bind)
4145 conversion *t = convs;
4146 for (; t; t = convs->u.next)
4148 if (t->kind == ck_user || !t->bad_p)
4150 expr = convert_like_real (t, expr, fn, argnum, 1,
4151 /*issue_conversion_warnings=*/false,
4152 /*c_cast_p=*/false);
4155 else if (t->kind == ck_ambig)
4156 return convert_like_real (t, expr, fn, argnum, 1,
4157 /*issue_conversion_warnings=*/false,
4158 /*c_cast_p=*/false);
4159 else if (t->kind == ck_identity)
4162 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4164 pedwarn (" initializing argument %P of %qD", argnum, fn);
4165 return cp_convert (totype, expr);
4168 if (issue_conversion_warnings)
4170 tree t = non_reference (totype);
4172 /* Issue warnings about peculiar, but valid, uses of NULL. */
4173 if (ARITHMETIC_TYPE_P (t) && expr == null_node)
4176 warning ("passing NULL to non-pointer argument %P of %qD",
4179 warning ("converting to non-pointer type %qT from NULL", t);
4182 /* Warn about assigning a floating-point type to an integer type. */
4183 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4184 && TREE_CODE (t) == INTEGER_TYPE)
4187 warning ("passing %qT for argument %P to %qD",
4188 TREE_TYPE (expr), argnum, fn);
4190 warning ("converting to %qT from %qT", t, TREE_TYPE (expr));
4192 /* And warn about assigning a negative value to an unsigned
4194 else if (TYPE_UNSIGNED (t) && TREE_CODE (t) != BOOLEAN_TYPE)
4196 if (TREE_CODE (expr) == INTEGER_CST && TREE_NEGATED_INT (expr))
4199 warning ("passing negative value %qE for argument %P to %qD",
4202 warning ("converting negative value %qE to %qT", expr, t);
4205 overflow_warning (expr);
4209 switch (convs->kind)
4213 struct z_candidate *cand = convs->cand;
4214 tree convfn = cand->fn;
4217 if (DECL_CONSTRUCTOR_P (convfn))
4219 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4222 args = build_tree_list (NULL_TREE, expr);
4223 /* We should never try to call the abstract or base constructor
4225 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4226 && !DECL_HAS_VTT_PARM_P (convfn));
4227 args = tree_cons (NULL_TREE, t, args);
4230 args = build_this (expr);
4231 expr = build_over_call (cand, LOOKUP_NORMAL);
4233 /* If this is a constructor or a function returning an aggr type,
4234 we need to build up a TARGET_EXPR. */
4235 if (DECL_CONSTRUCTOR_P (convfn))
4236 expr = build_cplus_new (totype, expr);
4238 /* The result of the call is then used to direct-initialize the object
4239 that is the destination of the copy-initialization. [dcl.init]
4241 Note that this step is not reflected in the conversion sequence;
4242 it affects the semantics when we actually perform the
4243 conversion, but is not considered during overload resolution.
4245 If the target is a class, that means call a ctor. */
4246 if (IS_AGGR_TYPE (totype)
4247 && (inner >= 0 || !lvalue_p (expr)))
4251 /* Core issue 84, now a DR, says that we don't
4252 allow UDCs for these args (which deliberately
4253 breaks copy-init of an auto_ptr<Base> from an
4254 auto_ptr<Derived>). */
4255 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4262 (" initializing argument %P of %qD from result of %qD",
4263 argnum, fn, convfn);
4266 (" initializing temporary from result of %qD", convfn);
4268 expr = build_cplus_new (totype, expr);
4273 if (type_unknown_p (expr))
4274 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4275 /* Convert a constant to its underlying value, unless we are
4276 about to bind it to a reference, in which case we need to
4277 leave it as an lvalue. */
4279 expr = integral_constant_value (expr);
4280 if (convs->check_copy_constructor_p)
4281 check_constructor_callable (totype, expr);
4284 /* Call build_user_type_conversion again for the error. */
4285 return build_user_type_conversion
4286 (totype, convs->u.expr, LOOKUP_NORMAL);
4292 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4293 convs->kind == ck_ref_bind ? -1 : 1,
4294 /*issue_conversion_warnings=*/false,
4296 if (expr == error_mark_node)
4297 return error_mark_node;
4299 switch (convs->kind)
4302 if (! IS_AGGR_TYPE (totype))
4304 /* Else fall through. */
4306 if (convs->kind == ck_base && !convs->need_temporary_p)
4308 /* We are going to bind a reference directly to a base-class
4309 subobject of EXPR. */
4310 if (convs->check_copy_constructor_p)
4311 check_constructor_callable (TREE_TYPE (expr), expr);
4312 /* Build an expression for `*((base*) &expr)'. */
4313 expr = build_unary_op (ADDR_EXPR, expr, 0);
4314 expr = convert_to_base (expr, build_pointer_type (totype),
4315 !c_cast_p, /*nonnull=*/true);
4316 expr = build_indirect_ref (expr, "implicit conversion");
4320 /* Copy-initialization where the cv-unqualified version of the source
4321 type is the same class as, or a derived class of, the class of the
4322 destination [is treated as direct-initialization]. [dcl.init] */
4323 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4325 if (diagnostic_fn && fn)
4326 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4327 return build_cplus_new (totype, expr);
4331 tree ref_type = totype;
4333 /* If necessary, create a temporary. */
4334 if (convs->need_temporary_p || !lvalue_p (expr))
4336 tree type = convs->u.next->type;
4337 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4339 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4341 /* If the reference is volatile or non-const, we
4342 cannot create a temporary. */
4343 if (lvalue & clk_bitfield)
4344 error ("cannot bind bitfield %qE to %qT",
4346 else if (lvalue & clk_packed)
4347 error ("cannot bind packed field %qE to %qT",
4350 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4351 return error_mark_node;
4353 /* If the source is a packed field, and we must use a copy
4354 constructor, then building the target expr will require
4355 binding the field to the reference parameter to the
4356 copy constructor, and we'll end up with an infinite
4357 loop. If we can use a bitwise copy, then we'll be
4359 if ((lvalue & clk_packed)
4360 && CLASS_TYPE_P (type)
4361 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4363 error ("cannot bind packed field %qE to %qT",
4365 return error_mark_node;
4367 expr = build_target_expr_with_type (expr, type);
4370 /* Take the address of the thing to which we will bind the
4372 expr = build_unary_op (ADDR_EXPR, expr, 1);
4373 if (expr == error_mark_node)
4374 return error_mark_node;
4376 /* Convert it to a pointer to the type referred to by the
4377 reference. This will adjust the pointer if a derived to
4378 base conversion is being performed. */
4379 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4381 /* Convert the pointer to the desired reference type. */
4382 return build_nop (ref_type, expr);
4386 return decay_conversion (expr);
4389 /* Warn about deprecated conversion if appropriate. */
4390 string_conv_p (totype, expr, 1);
4395 expr = convert_to_base (expr, totype, !c_cast_p,
4397 return build_nop (totype, expr);
4400 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4406 return ocp_convert (totype, expr, CONV_IMPLICIT,
4407 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4410 /* Build a call to __builtin_trap. */
4413 call_builtin_trap (void)
4415 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4417 gcc_assert (fn != NULL);
4418 fn = build_call (fn, NULL_TREE);
4422 /* ARG is being passed to a varargs function. Perform any conversions
4423 required. Return the converted value. */
4426 convert_arg_to_ellipsis (tree arg)
4430 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4431 standard conversions are performed. */
4432 arg = decay_conversion (arg);
4435 If the argument has integral or enumeration type that is subject
4436 to the integral promotions (_conv.prom_), or a floating point
4437 type that is subject to the floating point promotion
4438 (_conv.fpprom_), the value of the argument is converted to the
4439 promoted type before the call. */
4440 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4441 && (TYPE_PRECISION (TREE_TYPE (arg))
4442 < TYPE_PRECISION (double_type_node)))
4443 arg = convert_to_real (double_type_node, arg);
4444 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4445 arg = perform_integral_promotions (arg);
4447 arg = require_complete_type (arg);
4449 if (arg != error_mark_node
4450 && !pod_type_p (TREE_TYPE (arg)))
4452 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4453 here and do a bitwise copy, but now cp_expr_size will abort if we
4455 If the call appears in the context of a sizeof expression,
4456 there is no need to emit a warning, since the expression won't be
4457 evaluated. We keep the builtin_trap just as a safety check. */
4458 if (!skip_evaluation)
4459 warning ("cannot pass objects of non-POD type %q#T through %<...%>; "
4460 "call will abort at runtime", TREE_TYPE (arg));
4461 arg = call_builtin_trap ();
4462 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4469 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4472 build_x_va_arg (tree expr, tree type)
4474 if (processing_template_decl)
4475 return build_min (VA_ARG_EXPR, type, expr);
4477 type = complete_type_or_else (type, NULL_TREE);
4479 if (expr == error_mark_node || !type)
4480 return error_mark_node;
4482 if (! pod_type_p (type))
4484 /* Undefined behavior [expr.call] 5.2.2/7. */
4485 warning ("cannot receive objects of non-POD type %q#T through %<...%>; "
4486 "call will abort at runtime", type);
4487 expr = convert (build_pointer_type (type), null_node);
4488 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4489 call_builtin_trap (), expr);
4490 expr = build_indirect_ref (expr, NULL);
4494 return build_va_arg (expr, type);
4497 /* TYPE has been given to va_arg. Apply the default conversions which
4498 would have happened when passed via ellipsis. Return the promoted
4499 type, or the passed type if there is no change. */
4502 cxx_type_promotes_to (tree type)
4506 /* Perform the array-to-pointer and function-to-pointer
4508 type = type_decays_to (type);
4510 promote = type_promotes_to (type);
4511 if (same_type_p (type, promote))
4517 /* ARG is a default argument expression being passed to a parameter of
4518 the indicated TYPE, which is a parameter to FN. Do any required
4519 conversions. Return the converted value. */
4522 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4524 /* If the ARG is an unparsed default argument expression, the
4525 conversion cannot be performed. */
4526 if (TREE_CODE (arg) == DEFAULT_ARG)
4528 error ("the default argument for parameter %d of %qD has "
4529 "not yet been parsed",
4531 return error_mark_node;
4534 if (fn && DECL_TEMPLATE_INFO (fn))
4535 arg = tsubst_default_argument (fn, type, arg);
4537 arg = break_out_target_exprs (arg);
4539 if (TREE_CODE (arg) == CONSTRUCTOR)
4541 arg = digest_init (type, arg, 0);
4542 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4543 "default argument", fn, parmnum);
4547 /* This could get clobbered by the following call. */
4548 if (TREE_HAS_CONSTRUCTOR (arg))
4549 arg = copy_node (arg);
4551 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4552 "default argument", fn, parmnum);
4553 arg = convert_for_arg_passing (type, arg);
4559 /* Returns the type which will really be used for passing an argument of
4563 type_passed_as (tree type)
4565 /* Pass classes with copy ctors by invisible reference. */
4566 if (TREE_ADDRESSABLE (type))
4568 type = build_reference_type (type);
4569 /* There are no other pointers to this temporary. */
4570 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4572 else if (targetm.calls.promote_prototypes (type)
4573 && INTEGRAL_TYPE_P (type)
4574 && COMPLETE_TYPE_P (type)
4575 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4576 TYPE_SIZE (integer_type_node)))
4577 type = integer_type_node;
4582 /* Actually perform the appropriate conversion. */
4585 convert_for_arg_passing (tree type, tree val)
4587 if (val == error_mark_node)
4589 /* Pass classes with copy ctors by invisible reference. */
4590 else if (TREE_ADDRESSABLE (type))
4591 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4592 else if (targetm.calls.promote_prototypes (type)
4593 && INTEGRAL_TYPE_P (type)
4594 && COMPLETE_TYPE_P (type)
4595 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4596 TYPE_SIZE (integer_type_node)))
4597 val = perform_integral_promotions (val);
4601 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4602 which no conversions at all should be done. This is true for some
4603 builtins which don't act like normal functions. */
4606 magic_varargs_p (tree fn)
4608 if (DECL_BUILT_IN (fn))
4609 switch (DECL_FUNCTION_CODE (fn))
4611 case BUILT_IN_CLASSIFY_TYPE:
4612 case BUILT_IN_CONSTANT_P:
4613 case BUILT_IN_NEXT_ARG:
4614 case BUILT_IN_STDARG_START:
4615 case BUILT_IN_VA_START:
4624 /* Subroutine of the various build_*_call functions. Overload resolution
4625 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4626 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4627 bitmask of various LOOKUP_* flags which apply to the call itself. */
4630 build_over_call (struct z_candidate *cand, int flags)
4633 tree args = cand->args;
4634 conversion **convs = cand->convs;
4636 tree converted_args = NULL_TREE;
4637 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4642 /* In a template, there is no need to perform all of the work that
4643 is normally done. We are only interested in the type of the call
4644 expression, i.e., the return type of the function. Any semantic
4645 errors will be deferred until the template is instantiated. */
4646 if (processing_template_decl)
4650 return_type = TREE_TYPE (TREE_TYPE (fn));
4651 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4652 if (TREE_THIS_VOLATILE (fn) && cfun)
4653 current_function_returns_abnormally = 1;
4654 if (!VOID_TYPE_P (return_type))
4655 require_complete_type (return_type);
4656 return convert_from_reference (expr);
4659 /* Give any warnings we noticed during overload resolution. */
4662 struct candidate_warning *w;
4663 for (w = cand->warnings; w; w = w->next)
4664 joust (cand, w->loser, 1);
4667 if (DECL_FUNCTION_MEMBER_P (fn))
4669 /* If FN is a template function, two cases must be considered.
4674 template <class T> void f();
4676 template <class T> struct B {
4680 struct C : A, B<int> {
4682 using B<int>::g; // #2
4685 In case #1 where `A::f' is a member template, DECL_ACCESS is
4686 recorded in the primary template but not in its specialization.
4687 We check access of FN using its primary template.
4689 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4690 because it is a member of class template B, DECL_ACCESS is
4691 recorded in the specialization `B<int>::g'. We cannot use its
4692 primary template because `B<T>::g' and `B<int>::g' may have
4693 different access. */
4694 if (DECL_TEMPLATE_INFO (fn)
4695 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4696 perform_or_defer_access_check (cand->access_path,
4697 DECL_TI_TEMPLATE (fn));
4699 perform_or_defer_access_check (cand->access_path, fn);
4702 if (args && TREE_CODE (args) != TREE_LIST)
4703 args = build_tree_list (NULL_TREE, args);
4706 /* The implicit parameters to a constructor are not considered by overload
4707 resolution, and must be of the proper type. */
4708 if (DECL_CONSTRUCTOR_P (fn))
4710 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4711 arg = TREE_CHAIN (arg);
4712 parm = TREE_CHAIN (parm);
4713 /* We should never try to call the abstract constructor. */
4714 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4716 if (DECL_HAS_VTT_PARM_P (fn))
4718 converted_args = tree_cons
4719 (NULL_TREE, TREE_VALUE (arg), converted_args);
4720 arg = TREE_CHAIN (arg);
4721 parm = TREE_CHAIN (parm);
4724 /* Bypass access control for 'this' parameter. */
4725 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4727 tree parmtype = TREE_VALUE (parm);
4728 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4732 if (convs[i]->bad_p)
4733 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4734 TREE_TYPE (argtype), fn);
4736 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4737 X is called for an object that is not of type X, or of a type
4738 derived from X, the behavior is undefined.
4740 So we can assume that anything passed as 'this' is non-null, and
4741 optimize accordingly. */
4742 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4743 /* Convert to the base in which the function was declared. */
4744 gcc_assert (cand->conversion_path != NULL_TREE);
4745 converted_arg = build_base_path (PLUS_EXPR,
4747 cand->conversion_path,
4749 /* Check that the base class is accessible. */
4750 if (!accessible_base_p (TREE_TYPE (argtype),
4751 BINFO_TYPE (cand->conversion_path), true))
4752 error ("%qT is not an accessible base of %qT",
4753 BINFO_TYPE (cand->conversion_path),
4754 TREE_TYPE (argtype));
4755 /* If fn was found by a using declaration, the conversion path
4756 will be to the derived class, not the base declaring fn. We
4757 must convert from derived to base. */
4758 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4759 TREE_TYPE (parmtype), ba_unique, NULL);
4760 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4763 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4764 parm = TREE_CHAIN (parm);
4765 arg = TREE_CHAIN (arg);
4771 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4773 tree type = TREE_VALUE (parm);
4776 val = convert_like_with_context
4777 (conv, TREE_VALUE (arg), fn, i - is_method);
4779 val = convert_for_arg_passing (type, val);
4780 converted_args = tree_cons (NULL_TREE, val, converted_args);
4783 /* Default arguments */
4784 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4786 = tree_cons (NULL_TREE,
4787 convert_default_arg (TREE_VALUE (parm),
4788 TREE_PURPOSE (parm),
4793 for (; arg; arg = TREE_CHAIN (arg))
4795 tree a = TREE_VALUE (arg);
4796 if (magic_varargs_p (fn))
4797 /* Do no conversions for magic varargs. */;
4799 a = convert_arg_to_ellipsis (a);
4800 converted_args = tree_cons (NULL_TREE, a, converted_args);
4803 converted_args = nreverse (converted_args);
4805 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4808 /* Avoid actually calling copy constructors and copy assignment operators,
4811 if (! flag_elide_constructors)
4812 /* Do things the hard way. */;
4813 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4816 arg = skip_artificial_parms_for (fn, converted_args);
4817 arg = TREE_VALUE (arg);
4819 /* Pull out the real argument, disregarding const-correctness. */
4821 while (TREE_CODE (targ) == NOP_EXPR
4822 || TREE_CODE (targ) == NON_LVALUE_EXPR
4823 || TREE_CODE (targ) == CONVERT_EXPR)
4824 targ = TREE_OPERAND (targ, 0);
4825 if (TREE_CODE (targ) == ADDR_EXPR)
4827 targ = TREE_OPERAND (targ, 0);
4828 if (!same_type_ignoring_top_level_qualifiers_p
4829 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4838 arg = build_indirect_ref (arg, 0);
4840 /* [class.copy]: the copy constructor is implicitly defined even if
4841 the implementation elided its use. */
4842 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4845 /* If we're creating a temp and we already have one, don't create a
4846 new one. If we're not creating a temp but we get one, use
4847 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4848 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4849 temp or an INIT_EXPR otherwise. */
4850 if (integer_zerop (TREE_VALUE (args)))
4852 if (TREE_CODE (arg) == TARGET_EXPR)
4854 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4855 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4857 else if (TREE_CODE (arg) == TARGET_EXPR
4858 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4860 tree to = stabilize_reference
4861 (build_indirect_ref (TREE_VALUE (args), 0));
4863 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4867 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4869 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4871 tree to = stabilize_reference
4872 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4873 tree type = TREE_TYPE (to);
4874 tree as_base = CLASSTYPE_AS_BASE (type);
4876 arg = TREE_VALUE (TREE_CHAIN (converted_args));
4877 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4879 arg = build_indirect_ref (arg, 0);
4880 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4884 /* We must only copy the non-tail padding parts.
4885 Use __builtin_memcpy for the bitwise copy. */
4889 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
4890 args = tree_cons (NULL, arg, args);
4891 t = build_unary_op (ADDR_EXPR, to, 0);
4892 args = tree_cons (NULL, t, args);
4893 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
4894 t = build_call (t, args);
4896 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
4897 val = build_indirect_ref (t, 0);
4905 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4907 tree t, *p = &TREE_VALUE (converted_args);
4908 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4911 gcc_assert (binfo && binfo != error_mark_node);
4913 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4914 if (TREE_SIDE_EFFECTS (*p))
4915 *p = save_expr (*p);
4916 t = build_pointer_type (TREE_TYPE (fn));
4917 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4918 fn = build_java_interface_fn_ref (fn, *p);
4920 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
4923 else if (DECL_INLINE (fn))
4924 fn = inline_conversion (fn);
4926 fn = build_addr_func (fn);
4928 return build_cxx_call (fn, converted_args);
4931 /* Build and return a call to FN, using ARGS. This function performs
4932 no overload resolution, conversion, or other high-level
4936 build_cxx_call (tree fn, tree args)
4940 fn = build_call (fn, args);
4942 /* If this call might throw an exception, note that fact. */
4943 fndecl = get_callee_fndecl (fn);
4944 if ((!fndecl || !TREE_NOTHROW (fndecl))
4945 && at_function_scope_p ()
4947 cp_function_chain->can_throw = 1;
4949 /* Some built-in function calls will be evaluated at compile-time in
4951 fn = fold_if_not_in_template (fn);
4953 if (VOID_TYPE_P (TREE_TYPE (fn)))
4956 fn = require_complete_type (fn);
4957 if (fn == error_mark_node)
4958 return error_mark_node;
4960 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4961 fn = build_cplus_new (TREE_TYPE (fn), fn);
4962 return convert_from_reference (fn);
4965 static GTY(()) tree java_iface_lookup_fn;
4967 /* Make an expression which yields the address of the Java interface
4968 method FN. This is achieved by generating a call to libjava's
4969 _Jv_LookupInterfaceMethodIdx(). */
4972 build_java_interface_fn_ref (tree fn, tree instance)
4974 tree lookup_args, lookup_fn, method, idx;
4975 tree klass_ref, iface, iface_ref;
4978 if (!java_iface_lookup_fn)
4980 tree endlink = build_void_list_node ();
4981 tree t = tree_cons (NULL_TREE, ptr_type_node,
4982 tree_cons (NULL_TREE, ptr_type_node,
4983 tree_cons (NULL_TREE, java_int_type_node,
4985 java_iface_lookup_fn
4986 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4987 build_function_type (ptr_type_node, t),
4988 0, NOT_BUILT_IN, NULL, NULL_TREE);
4991 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4992 This is the first entry in the vtable. */
4993 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4996 /* Get the java.lang.Class pointer for the interface being called. */
4997 iface = DECL_CONTEXT (fn);
4998 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4999 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5000 || DECL_CONTEXT (iface_ref) != iface)
5002 error ("could not find class$ field in java interface type %qT",
5004 return error_mark_node;
5006 iface_ref = build_address (iface_ref);
5007 iface_ref = convert (build_pointer_type (iface), iface_ref);
5009 /* Determine the itable index of FN. */
5011 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5013 if (!DECL_VIRTUAL_P (method))
5019 idx = build_int_cst (NULL_TREE, i);
5021 lookup_args = tree_cons (NULL_TREE, klass_ref,
5022 tree_cons (NULL_TREE, iface_ref,
5023 build_tree_list (NULL_TREE, idx)));
5024 lookup_fn = build1 (ADDR_EXPR,
5025 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5026 java_iface_lookup_fn);
5027 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
5030 /* Returns the value to use for the in-charge parameter when making a
5031 call to a function with the indicated NAME.
5033 FIXME:Can't we find a neater way to do this mapping? */
5036 in_charge_arg_for_name (tree name)
5038 if (name == base_ctor_identifier
5039 || name == base_dtor_identifier)
5040 return integer_zero_node;
5041 else if (name == complete_ctor_identifier)
5042 return integer_one_node;
5043 else if (name == complete_dtor_identifier)
5044 return integer_two_node;
5045 else if (name == deleting_dtor_identifier)
5046 return integer_three_node;
5048 /* This function should only be called with one of the names listed
5054 /* Build a call to a constructor, destructor, or an assignment
5055 operator for INSTANCE, an expression with class type. NAME
5056 indicates the special member function to call; ARGS are the
5057 arguments. BINFO indicates the base of INSTANCE that is to be
5058 passed as the `this' parameter to the member function called.
5060 FLAGS are the LOOKUP_* flags to use when processing the call.
5062 If NAME indicates a complete object constructor, INSTANCE may be
5063 NULL_TREE. In this case, the caller will call build_cplus_new to
5064 store the newly constructed object into a VAR_DECL. */
5067 build_special_member_call (tree instance, tree name, tree args,
5068 tree binfo, int flags)
5071 /* The type of the subobject to be constructed or destroyed. */
5074 gcc_assert (name == complete_ctor_identifier
5075 || name == base_ctor_identifier
5076 || name == complete_dtor_identifier
5077 || name == base_dtor_identifier
5078 || name == deleting_dtor_identifier
5079 || name == ansi_assopname (NOP_EXPR));
5082 /* Resolve the name. */
5083 if (!complete_type_or_else (binfo, NULL_TREE))
5084 return error_mark_node;
5086 binfo = TYPE_BINFO (binfo);
5089 gcc_assert (binfo != NULL_TREE);
5091 class_type = BINFO_TYPE (binfo);
5093 /* Handle the special case where INSTANCE is NULL_TREE. */
5094 if (name == complete_ctor_identifier && !instance)
5096 instance = build_int_cst (build_pointer_type (class_type), 0);
5097 instance = build1 (INDIRECT_REF, class_type, instance);
5101 if (name == complete_dtor_identifier
5102 || name == base_dtor_identifier
5103 || name == deleting_dtor_identifier)
5104 gcc_assert (args == NULL_TREE);
5106 /* Convert to the base class, if necessary. */
5107 if (!same_type_ignoring_top_level_qualifiers_p
5108 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5110 if (name != ansi_assopname (NOP_EXPR))
5111 /* For constructors and destructors, either the base is
5112 non-virtual, or it is virtual but we are doing the
5113 conversion from a constructor or destructor for the
5114 complete object. In either case, we can convert
5116 instance = convert_to_base_statically (instance, binfo);
5118 /* However, for assignment operators, we must convert
5119 dynamically if the base is virtual. */
5120 instance = build_base_path (PLUS_EXPR, instance,
5121 binfo, /*nonnull=*/1);
5125 gcc_assert (instance != NULL_TREE);
5127 fns = lookup_fnfields (binfo, name, 1);
5129 /* When making a call to a constructor or destructor for a subobject
5130 that uses virtual base classes, pass down a pointer to a VTT for
5132 if ((name == base_ctor_identifier
5133 || name == base_dtor_identifier)
5134 && CLASSTYPE_VBASECLASSES (class_type))
5139 /* If the current function is a complete object constructor
5140 or destructor, then we fetch the VTT directly.
5141 Otherwise, we look it up using the VTT we were given. */
5142 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5143 vtt = decay_conversion (vtt);
5144 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5145 build2 (EQ_EXPR, boolean_type_node,
5146 current_in_charge_parm, integer_zero_node),
5149 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5150 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5151 BINFO_SUBVTT_INDEX (binfo));
5153 args = tree_cons (NULL_TREE, sub_vtt, args);
5156 return build_new_method_call (instance, fns, args,
5157 TYPE_BINFO (BINFO_TYPE (binfo)),
5161 /* Return the NAME, as a C string. The NAME indicates a function that
5162 is a member of TYPE. *FREE_P is set to true if the caller must
5163 free the memory returned.
5165 Rather than go through all of this, we should simply set the names
5166 of constructors and destructors appropriately, and dispense with
5167 ctor_identifier, dtor_identifier, etc. */
5170 name_as_c_string (tree name, tree type, bool *free_p)
5174 /* Assume that we will not allocate memory. */
5176 /* Constructors and destructors are special. */
5177 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5180 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5181 /* For a destructor, add the '~'. */
5182 if (name == complete_dtor_identifier
5183 || name == base_dtor_identifier
5184 || name == deleting_dtor_identifier)
5186 pretty_name = concat ("~", pretty_name, NULL);
5187 /* Remember that we need to free the memory allocated. */
5191 else if (IDENTIFIER_TYPENAME_P (name))
5193 pretty_name = concat ("operator ",
5194 type_as_string (TREE_TYPE (name),
5195 TFF_PLAIN_IDENTIFIER),
5197 /* Remember that we need to free the memory allocated. */
5201 pretty_name = (char *) IDENTIFIER_POINTER (name);
5206 /* Build a call to "INSTANCE.FN (ARGS)". */
5209 build_new_method_call (tree instance, tree fns, tree args,
5210 tree conversion_path, int flags)
5212 struct z_candidate *candidates = 0, *cand;
5213 tree explicit_targs = NULL_TREE;
5214 tree basetype = NULL_TREE;
5217 tree mem_args = NULL_TREE, instance_ptr;
5223 int template_only = 0;
5230 gcc_assert (instance != NULL_TREE);
5232 if (error_operand_p (instance)
5233 || error_operand_p (fns)
5234 || args == error_mark_node)
5235 return error_mark_node;
5237 orig_instance = instance;
5241 if (processing_template_decl)
5243 instance = build_non_dependent_expr (instance);
5244 if (!BASELINK_P (fns)
5245 && TREE_CODE (fns) != PSEUDO_DTOR_EXPR
5246 && TREE_TYPE (fns) != unknown_type_node)
5247 fns = build_non_dependent_expr (fns);
5248 args = build_non_dependent_args (orig_args);
5251 /* Process the argument list. */
5253 args = resolve_args (args);
5254 if (args == error_mark_node)
5255 return error_mark_node;
5257 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5258 instance_ptr = build_this (instance);
5260 if (!BASELINK_P (fns))
5262 error ("call to non-function %qD", fns);
5263 return error_mark_node;
5266 if (!conversion_path)
5267 conversion_path = BASELINK_BINFO (fns);
5268 access_binfo = BASELINK_ACCESS_BINFO (fns);
5269 optype = BASELINK_OPTYPE (fns);
5270 fns = BASELINK_FUNCTIONS (fns);
5272 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5274 explicit_targs = TREE_OPERAND (fns, 1);
5275 fns = TREE_OPERAND (fns, 0);
5279 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5280 || TREE_CODE (fns) == TEMPLATE_DECL
5281 || TREE_CODE (fns) == OVERLOAD);
5283 /* XXX this should be handled before we get here. */
5284 if (! IS_AGGR_TYPE (basetype))
5286 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5287 error ("request for member %qD in %qE, which is of non-aggregate "
5289 fns, instance, basetype);
5291 return error_mark_node;
5294 fn = get_first_fn (fns);
5295 name = DECL_NAME (fn);
5297 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5299 /* Callers should explicitly indicate whether they want to construct
5300 the complete object or just the part without virtual bases. */
5301 gcc_assert (name != ctor_identifier);
5302 /* Similarly for destructors. */
5303 gcc_assert (name != dtor_identifier);
5306 /* It's OK to call destructors on cv-qualified objects. Therefore,
5307 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5308 if (DECL_DESTRUCTOR_P (fn))
5310 tree type = build_pointer_type (basetype);
5311 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5312 instance_ptr = build_nop (type, instance_ptr);
5315 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5316 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5318 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5319 p = conversion_obstack_alloc (0);
5321 for (fn = fns; fn; fn = OVL_NEXT (fn))
5323 tree t = OVL_CURRENT (fn);
5326 /* We can end up here for copy-init of same or base class. */
5327 if ((flags & LOOKUP_ONLYCONVERTING)
5328 && DECL_NONCONVERTING_P (t))
5331 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5332 this_arglist = mem_args;
5334 this_arglist = args;
5336 if (TREE_CODE (t) == TEMPLATE_DECL)
5337 /* A member template. */
5338 add_template_candidate (&candidates, t,
5341 this_arglist, optype,
5346 else if (! template_only)
5347 add_function_candidate (&candidates, t,
5355 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5358 if (!COMPLETE_TYPE_P (basetype))
5359 cxx_incomplete_type_error (instance_ptr, basetype);
5365 pretty_name = name_as_c_string (name, basetype, &free_p);
5366 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5367 basetype, pretty_name, user_args,
5368 TREE_TYPE (TREE_TYPE (instance_ptr)));
5372 print_z_candidates (candidates);
5373 call = error_mark_node;
5377 cand = tourney (candidates);
5383 pretty_name = name_as_c_string (name, basetype, &free_p);
5384 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5386 print_z_candidates (candidates);
5389 call = error_mark_node;
5393 if (!(flags & LOOKUP_NONVIRTUAL)
5394 && DECL_PURE_VIRTUAL_P (cand->fn)
5395 && instance == current_class_ref
5396 && (DECL_CONSTRUCTOR_P (current_function_decl)
5397 || DECL_DESTRUCTOR_P (current_function_decl)))
5398 /* This is not an error, it is runtime undefined
5400 warning ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5401 "abstract virtual %q#D called from constructor"
5402 : "abstract virtual %q#D called from destructor"),
5405 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5406 && is_dummy_object (instance_ptr))
5408 error ("cannot call member function %qD without object",
5410 call = error_mark_node;
5414 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5415 && resolves_to_fixed_type_p (instance, 0))
5416 flags |= LOOKUP_NONVIRTUAL;
5418 call = build_over_call (cand, flags);
5420 /* In an expression of the form `a->f()' where `f' turns
5421 out to be a static member function, `a' is
5422 none-the-less evaluated. */
5423 if (TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE
5424 && !is_dummy_object (instance_ptr)
5425 && TREE_SIDE_EFFECTS (instance))
5426 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5432 if (processing_template_decl && call != error_mark_node)
5433 call = (build_min_non_dep
5435 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5436 orig_args, NULL_TREE));
5438 /* Free all the conversions we allocated. */
5439 obstack_free (&conversion_obstack, p);
5444 /* Returns true iff standard conversion sequence ICS1 is a proper
5445 subsequence of ICS2. */
5448 is_subseq (conversion *ics1, conversion *ics2)
5450 /* We can assume that a conversion of the same code
5451 between the same types indicates a subsequence since we only get
5452 here if the types we are converting from are the same. */
5454 while (ics1->kind == ck_rvalue
5455 || ics1->kind == ck_lvalue)
5456 ics1 = ics1->u.next;
5460 while (ics2->kind == ck_rvalue
5461 || ics2->kind == ck_lvalue)
5462 ics2 = ics2->u.next;
5464 if (ics2->kind == ck_user
5465 || ics2->kind == ck_ambig
5466 || ics2->kind == ck_identity)
5467 /* At this point, ICS1 cannot be a proper subsequence of
5468 ICS2. We can get a USER_CONV when we are comparing the
5469 second standard conversion sequence of two user conversion
5473 ics2 = ics2->u.next;
5475 if (ics2->kind == ics1->kind
5476 && same_type_p (ics2->type, ics1->type)
5477 && same_type_p (ics2->u.next->type,
5478 ics1->u.next->type))
5483 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5484 be any _TYPE nodes. */
5487 is_properly_derived_from (tree derived, tree base)
5489 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5490 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5493 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5494 considers every class derived from itself. */
5495 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5496 && DERIVED_FROM_P (base, derived));
5499 /* We build the ICS for an implicit object parameter as a pointer
5500 conversion sequence. However, such a sequence should be compared
5501 as if it were a reference conversion sequence. If ICS is the
5502 implicit conversion sequence for an implicit object parameter,
5503 modify it accordingly. */
5506 maybe_handle_implicit_object (conversion **ics)
5510 /* [over.match.funcs]
5512 For non-static member functions, the type of the
5513 implicit object parameter is "reference to cv X"
5514 where X is the class of which the function is a
5515 member and cv is the cv-qualification on the member
5516 function declaration. */
5517 conversion *t = *ics;
5518 tree reference_type;
5520 /* The `this' parameter is a pointer to a class type. Make the
5521 implicit conversion talk about a reference to that same class
5523 reference_type = TREE_TYPE (t->type);
5524 reference_type = build_reference_type (reference_type);
5526 if (t->kind == ck_qual)
5528 if (t->kind == ck_ptr)
5530 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5531 t = direct_reference_binding (reference_type, t);
5536 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5537 and return the type to which the reference refers. Otherwise,
5538 leave *ICS unchanged and return NULL_TREE. */
5541 maybe_handle_ref_bind (conversion **ics)
5543 if ((*ics)->kind == ck_ref_bind)
5545 conversion *old_ics = *ics;
5546 tree type = TREE_TYPE (old_ics->type);
5547 *ics = old_ics->u.next;
5548 (*ics)->user_conv_p = old_ics->user_conv_p;
5549 (*ics)->bad_p = old_ics->bad_p;
5556 /* Compare two implicit conversion sequences according to the rules set out in
5557 [over.ics.rank]. Return values:
5559 1: ics1 is better than ics2
5560 -1: ics2 is better than ics1
5561 0: ics1 and ics2 are indistinguishable */
5564 compare_ics (conversion *ics1, conversion *ics2)
5570 tree deref_from_type1 = NULL_TREE;
5571 tree deref_from_type2 = NULL_TREE;
5572 tree deref_to_type1 = NULL_TREE;
5573 tree deref_to_type2 = NULL_TREE;
5574 conversion_rank rank1, rank2;
5576 /* REF_BINDING is nonzero if the result of the conversion sequence
5577 is a reference type. In that case TARGET_TYPE is the
5578 type referred to by the reference. */
5582 /* Handle implicit object parameters. */
5583 maybe_handle_implicit_object (&ics1);
5584 maybe_handle_implicit_object (&ics2);
5586 /* Handle reference parameters. */
5587 target_type1 = maybe_handle_ref_bind (&ics1);
5588 target_type2 = maybe_handle_ref_bind (&ics2);
5592 When comparing the basic forms of implicit conversion sequences (as
5593 defined in _over.best.ics_)
5595 --a standard conversion sequence (_over.ics.scs_) is a better
5596 conversion sequence than a user-defined conversion sequence
5597 or an ellipsis conversion sequence, and
5599 --a user-defined conversion sequence (_over.ics.user_) is a
5600 better conversion sequence than an ellipsis conversion sequence
5601 (_over.ics.ellipsis_). */
5602 rank1 = CONVERSION_RANK (ics1);
5603 rank2 = CONVERSION_RANK (ics2);
5607 else if (rank1 < rank2)
5610 if (rank1 == cr_bad)
5612 /* XXX Isn't this an extension? */
5613 /* Both ICS are bad. We try to make a decision based on what
5614 would have happened if they'd been good. */
5615 if (ics1->user_conv_p > ics2->user_conv_p
5616 || ics1->rank > ics2->rank)
5618 else if (ics1->user_conv_p < ics2->user_conv_p
5619 || ics1->rank < ics2->rank)
5622 /* We couldn't make up our minds; try to figure it out below. */
5625 if (ics1->ellipsis_p)
5626 /* Both conversions are ellipsis conversions. */
5629 /* User-defined conversion sequence U1 is a better conversion sequence
5630 than another user-defined conversion sequence U2 if they contain the
5631 same user-defined conversion operator or constructor and if the sec-
5632 ond standard conversion sequence of U1 is better than the second
5633 standard conversion sequence of U2. */
5635 if (ics1->user_conv_p)
5640 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5641 if (t1->kind == ck_ambig)
5643 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5644 if (t2->kind == ck_ambig)
5647 if (t1->cand->fn != t2->cand->fn)
5650 /* We can just fall through here, after setting up
5651 FROM_TYPE1 and FROM_TYPE2. */
5652 from_type1 = t1->type;
5653 from_type2 = t2->type;
5660 /* We're dealing with two standard conversion sequences.
5664 Standard conversion sequence S1 is a better conversion
5665 sequence than standard conversion sequence S2 if
5667 --S1 is a proper subsequence of S2 (comparing the conversion
5668 sequences in the canonical form defined by _over.ics.scs_,
5669 excluding any Lvalue Transformation; the identity
5670 conversion sequence is considered to be a subsequence of
5671 any non-identity conversion sequence */
5674 while (t1->kind != ck_identity)
5676 from_type1 = t1->type;
5679 while (t2->kind != ck_identity)
5681 from_type2 = t2->type;
5684 if (same_type_p (from_type1, from_type2))
5686 if (is_subseq (ics1, ics2))
5688 if (is_subseq (ics2, ics1))
5691 /* Otherwise, one sequence cannot be a subsequence of the other; they
5692 don't start with the same type. This can happen when comparing the
5693 second standard conversion sequence in two user-defined conversion
5700 --the rank of S1 is better than the rank of S2 (by the rules
5703 Standard conversion sequences are ordered by their ranks: an Exact
5704 Match is a better conversion than a Promotion, which is a better
5705 conversion than a Conversion.
5707 Two conversion sequences with the same rank are indistinguishable
5708 unless one of the following rules applies:
5710 --A conversion that is not a conversion of a pointer, or pointer
5711 to member, to bool is better than another conversion that is such
5714 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5715 so that we do not have to check it explicitly. */
5716 if (ics1->rank < ics2->rank)
5718 else if (ics2->rank < ics1->rank)
5721 to_type1 = ics1->type;
5722 to_type2 = ics2->type;
5724 if (TYPE_PTR_P (from_type1)
5725 && TYPE_PTR_P (from_type2)
5726 && TYPE_PTR_P (to_type1)
5727 && TYPE_PTR_P (to_type2))
5729 deref_from_type1 = TREE_TYPE (from_type1);
5730 deref_from_type2 = TREE_TYPE (from_type2);
5731 deref_to_type1 = TREE_TYPE (to_type1);
5732 deref_to_type2 = TREE_TYPE (to_type2);
5734 /* The rules for pointers to members A::* are just like the rules
5735 for pointers A*, except opposite: if B is derived from A then
5736 A::* converts to B::*, not vice versa. For that reason, we
5737 switch the from_ and to_ variables here. */
5738 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5739 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5740 || (TYPE_PTRMEMFUNC_P (from_type1)
5741 && TYPE_PTRMEMFUNC_P (from_type2)
5742 && TYPE_PTRMEMFUNC_P (to_type1)
5743 && TYPE_PTRMEMFUNC_P (to_type2)))
5745 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5746 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5747 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5748 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5751 if (deref_from_type1 != NULL_TREE
5752 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5753 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5755 /* This was one of the pointer or pointer-like conversions.
5759 --If class B is derived directly or indirectly from class A,
5760 conversion of B* to A* is better than conversion of B* to
5761 void*, and conversion of A* to void* is better than
5762 conversion of B* to void*. */
5763 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5764 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5766 if (is_properly_derived_from (deref_from_type1,
5769 else if (is_properly_derived_from (deref_from_type2,
5773 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5774 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5776 if (same_type_p (deref_from_type1, deref_from_type2))
5778 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5780 if (is_properly_derived_from (deref_from_type1,
5784 /* We know that DEREF_TO_TYPE1 is `void' here. */
5785 else if (is_properly_derived_from (deref_from_type1,
5790 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5791 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5795 --If class B is derived directly or indirectly from class A
5796 and class C is derived directly or indirectly from B,
5798 --conversion of C* to B* is better than conversion of C* to
5801 --conversion of B* to A* is better than conversion of C* to
5803 if (same_type_p (deref_from_type1, deref_from_type2))
5805 if (is_properly_derived_from (deref_to_type1,
5808 else if (is_properly_derived_from (deref_to_type2,
5812 else if (same_type_p (deref_to_type1, deref_to_type2))
5814 if (is_properly_derived_from (deref_from_type2,
5817 else if (is_properly_derived_from (deref_from_type1,
5823 else if (CLASS_TYPE_P (non_reference (from_type1))
5824 && same_type_p (from_type1, from_type2))
5826 tree from = non_reference (from_type1);
5830 --binding of an expression of type C to a reference of type
5831 B& is better than binding an expression of type C to a
5832 reference of type A&
5834 --conversion of C to B is better than conversion of C to A, */
5835 if (is_properly_derived_from (from, to_type1)
5836 && is_properly_derived_from (from, to_type2))
5838 if (is_properly_derived_from (to_type1, to_type2))
5840 else if (is_properly_derived_from (to_type2, to_type1))
5844 else if (CLASS_TYPE_P (non_reference (to_type1))
5845 && same_type_p (to_type1, to_type2))
5847 tree to = non_reference (to_type1);
5851 --binding of an expression of type B to a reference of type
5852 A& is better than binding an expression of type C to a
5853 reference of type A&,
5855 --conversion of B to A is better than conversion of C to A */
5856 if (is_properly_derived_from (from_type1, to)
5857 && is_properly_derived_from (from_type2, to))
5859 if (is_properly_derived_from (from_type2, from_type1))
5861 else if (is_properly_derived_from (from_type1, from_type2))
5868 --S1 and S2 differ only in their qualification conversion and yield
5869 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5870 qualification signature of type T1 is a proper subset of the cv-
5871 qualification signature of type T2 */
5872 if (ics1->kind == ck_qual
5873 && ics2->kind == ck_qual
5874 && same_type_p (from_type1, from_type2))
5875 return comp_cv_qual_signature (to_type1, to_type2);
5879 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5880 types to which the references refer are the same type except for
5881 top-level cv-qualifiers, and the type to which the reference
5882 initialized by S2 refers is more cv-qualified than the type to
5883 which the reference initialized by S1 refers */
5885 if (target_type1 && target_type2
5886 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5887 return comp_cv_qualification (target_type2, target_type1);
5889 /* Neither conversion sequence is better than the other. */
5893 /* The source type for this standard conversion sequence. */
5896 source_type (conversion *t)
5898 for (;; t = t->u.next)
5900 if (t->kind == ck_user
5901 || t->kind == ck_ambig
5902 || t->kind == ck_identity)
5908 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5909 a pointer to LOSER and re-running joust to produce the warning if WINNER
5910 is actually used. */
5913 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5915 candidate_warning *cw;
5917 cw = conversion_obstack_alloc (sizeof (candidate_warning));
5919 cw->next = winner->warnings;
5920 winner->warnings = cw;
5923 /* Compare two candidates for overloading as described in
5924 [over.match.best]. Return values:
5926 1: cand1 is better than cand2
5927 -1: cand2 is better than cand1
5928 0: cand1 and cand2 are indistinguishable */
5931 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5934 int off1 = 0, off2 = 0;
5938 /* Candidates that involve bad conversions are always worse than those
5940 if (cand1->viable > cand2->viable)
5942 if (cand1->viable < cand2->viable)
5945 /* If we have two pseudo-candidates for conversions to the same type,
5946 or two candidates for the same function, arbitrarily pick one. */
5947 if (cand1->fn == cand2->fn
5948 && (IS_TYPE_OR_DECL_P (cand1->fn)))
5951 /* a viable function F1
5952 is defined to be a better function than another viable function F2 if
5953 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5954 ICSi(F2), and then */
5956 /* for some argument j, ICSj(F1) is a better conversion sequence than
5959 /* For comparing static and non-static member functions, we ignore
5960 the implicit object parameter of the non-static function. The
5961 standard says to pretend that the static function has an object
5962 parm, but that won't work with operator overloading. */
5963 len = cand1->num_convs;
5964 if (len != cand2->num_convs)
5966 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
5967 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
5969 gcc_assert (static_1 != static_2);
5980 for (i = 0; i < len; ++i)
5982 conversion *t1 = cand1->convs[i + off1];
5983 conversion *t2 = cand2->convs[i + off2];
5984 int comp = compare_ics (t1, t2);
5989 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
5990 == cr_std + cr_promotion)
5991 && t1->kind == ck_std
5992 && t2->kind == ck_std
5993 && TREE_CODE (t1->type) == INTEGER_TYPE
5994 && TREE_CODE (t2->type) == INTEGER_TYPE
5995 && (TYPE_PRECISION (t1->type)
5996 == TYPE_PRECISION (t2->type))
5997 && (TYPE_UNSIGNED (t1->u.next->type)
5998 || (TREE_CODE (t1->u.next->type)
6001 tree type = t1->u.next->type;
6003 struct z_candidate *w, *l;
6005 type1 = t1->type, type2 = t2->type,
6006 w = cand1, l = cand2;
6008 type1 = t2->type, type2 = t1->type,
6009 w = cand2, l = cand1;
6013 warning ("passing %qT chooses %qT over %qT",
6014 type, type1, type2);
6015 warning (" in call to %qD", w->fn);
6021 if (winner && comp != winner)
6030 /* warn about confusing overload resolution for user-defined conversions,
6031 either between a constructor and a conversion op, or between two
6033 if (winner && warn_conversion && cand1->second_conv
6034 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6035 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6037 struct z_candidate *w, *l;
6038 bool give_warning = false;
6041 w = cand1, l = cand2;
6043 w = cand2, l = cand1;
6045 /* We don't want to complain about `X::operator T1 ()'
6046 beating `X::operator T2 () const', when T2 is a no less
6047 cv-qualified version of T1. */
6048 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6049 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6051 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6052 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6054 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6059 if (!comp_ptr_ttypes (t, f))
6060 give_warning = true;
6063 give_warning = true;
6069 tree source = source_type (w->convs[0]);
6070 if (! DECL_CONSTRUCTOR_P (w->fn))
6071 source = TREE_TYPE (source);
6072 warning ("choosing %qD over %qD", w->fn, l->fn);
6073 warning (" for conversion from %qT to %qT",
6074 source, w->second_conv->type);
6075 warning (" because conversion sequence for the argument is better");
6085 F1 is a non-template function and F2 is a template function
6088 if (!cand1->template_decl && cand2->template_decl)
6090 else if (cand1->template_decl && !cand2->template_decl)
6094 F1 and F2 are template functions and the function template for F1 is
6095 more specialized than the template for F2 according to the partial
6098 if (cand1->template_decl && cand2->template_decl)
6100 winner = more_specialized
6101 (TI_TEMPLATE (cand1->template_decl),
6102 TI_TEMPLATE (cand2->template_decl),
6104 /* Tell the deduction code how many real function arguments
6105 we saw, not counting the implicit 'this' argument. But,
6106 add_function_candidate() suppresses the "this" argument
6109 [temp.func.order]: The presence of unused ellipsis and default
6110 arguments has no effect on the partial ordering of function
6113 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
6114 - DECL_CONSTRUCTOR_P (cand1->fn)));
6120 the context is an initialization by user-defined conversion (see
6121 _dcl.init_ and _over.match.user_) and the standard conversion
6122 sequence from the return type of F1 to the destination type (i.e.,
6123 the type of the entity being initialized) is a better conversion
6124 sequence than the standard conversion sequence from the return type
6125 of F2 to the destination type. */
6127 if (cand1->second_conv)
6129 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6134 /* Check whether we can discard a builtin candidate, either because we
6135 have two identical ones or matching builtin and non-builtin candidates.
6137 (Pedantically in the latter case the builtin which matched the user
6138 function should not be added to the overload set, but we spot it here.
6141 ... the builtin candidates include ...
6142 - do not have the same parameter type list as any non-template
6143 non-member candidate. */
6145 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6146 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6148 for (i = 0; i < len; ++i)
6149 if (!same_type_p (cand1->convs[i]->type,
6150 cand2->convs[i]->type))
6152 if (i == cand1->num_convs)
6154 if (cand1->fn == cand2->fn)
6155 /* Two built-in candidates; arbitrarily pick one. */
6157 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6158 /* cand1 is built-in; prefer cand2. */
6161 /* cand2 is built-in; prefer cand1. */
6166 /* If the two functions are the same (this can happen with declarations
6167 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6168 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6169 && equal_functions (cand1->fn, cand2->fn))
6174 /* Extension: If the worst conversion for one candidate is worse than the
6175 worst conversion for the other, take the first. */
6178 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6179 struct z_candidate *w = 0, *l = 0;
6181 for (i = 0; i < len; ++i)
6183 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6184 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6185 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6186 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6189 winner = 1, w = cand1, l = cand2;
6191 winner = -1, w = cand2, l = cand1;
6197 ISO C++ says that these are ambiguous, even \
6198 though the worst conversion for the first is better than \
6199 the worst conversion for the second:");
6200 print_z_candidate (_("candidate 1:"), w);
6201 print_z_candidate (_("candidate 2:"), l);
6209 gcc_assert (!winner);
6213 /* Given a list of candidates for overloading, find the best one, if any.
6214 This algorithm has a worst case of O(2n) (winner is last), and a best
6215 case of O(n/2) (totally ambiguous); much better than a sorting
6218 static struct z_candidate *
6219 tourney (struct z_candidate *candidates)
6221 struct z_candidate *champ = candidates, *challenger;
6223 int champ_compared_to_predecessor = 0;
6225 /* Walk through the list once, comparing each current champ to the next
6226 candidate, knocking out a candidate or two with each comparison. */
6228 for (challenger = champ->next; challenger; )
6230 fate = joust (champ, challenger, 0);
6232 challenger = challenger->next;
6237 champ = challenger->next;
6240 champ_compared_to_predecessor = 0;
6245 champ_compared_to_predecessor = 1;
6248 challenger = champ->next;
6252 /* Make sure the champ is better than all the candidates it hasn't yet
6253 been compared to. */
6255 for (challenger = candidates;
6257 && !(champ_compared_to_predecessor && challenger->next == champ);
6258 challenger = challenger->next)
6260 fate = joust (champ, challenger, 0);
6268 /* Returns nonzero if things of type FROM can be converted to TO. */
6271 can_convert (tree to, tree from)
6273 return can_convert_arg (to, from, NULL_TREE);
6276 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6279 can_convert_arg (tree to, tree from, tree arg)
6285 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6286 p = conversion_obstack_alloc (0);
6288 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6289 ok_p = (t && !t->bad_p);
6291 /* Free all the conversions we allocated. */
6292 obstack_free (&conversion_obstack, p);
6297 /* Like can_convert_arg, but allows dubious conversions as well. */
6300 can_convert_arg_bad (tree to, tree from, tree arg)
6305 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6306 p = conversion_obstack_alloc (0);
6307 /* Try to perform the conversion. */
6308 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6309 /* Free all the conversions we allocated. */
6310 obstack_free (&conversion_obstack, p);
6315 /* Convert EXPR to TYPE. Return the converted expression.
6317 Note that we allow bad conversions here because by the time we get to
6318 this point we are committed to doing the conversion. If we end up
6319 doing a bad conversion, convert_like will complain. */
6322 perform_implicit_conversion (tree type, tree expr)
6327 if (error_operand_p (expr))
6328 return error_mark_node;
6330 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6331 p = conversion_obstack_alloc (0);
6333 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6337 error ("could not convert %qE to %qT", expr, type);
6338 expr = error_mark_node;
6341 expr = convert_like (conv, expr);
6343 /* Free all the conversions we allocated. */
6344 obstack_free (&conversion_obstack, p);
6349 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6350 permitted. If the conversion is valid, the converted expression is
6351 returned. Otherwise, NULL_TREE is returned, except in the case
6352 that TYPE is a class type; in that case, an error is issued. If
6353 C_CAST_P is true, then this direction initialization is taking
6354 place as part of a static_cast being attempted as part of a C-style
6358 perform_direct_initialization_if_possible (tree type,
6365 if (type == error_mark_node || error_operand_p (expr))
6366 return error_mark_node;
6369 If the destination type is a (possibly cv-qualified) class type:
6371 -- If the initialization is direct-initialization ...,
6372 constructors are considered. ... If no constructor applies, or
6373 the overload resolution is ambiguous, the initialization is
6375 if (CLASS_TYPE_P (type))
6377 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6378 build_tree_list (NULL_TREE, expr),
6379 type, LOOKUP_NORMAL);
6380 return build_cplus_new (type, expr);
6383 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6384 p = conversion_obstack_alloc (0);
6386 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6388 if (!conv || conv->bad_p)
6391 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6392 /*issue_conversion_warnings=*/false,
6395 /* Free all the conversions we allocated. */
6396 obstack_free (&conversion_obstack, p);
6401 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6402 is being bound to a temporary. Create and return a new VAR_DECL
6403 with the indicated TYPE; this variable will store the value to
6404 which the reference is bound. */
6407 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6411 /* Create the variable. */
6412 var = build_decl (VAR_DECL, NULL_TREE, type);
6413 DECL_ARTIFICIAL (var) = 1;
6414 DECL_IGNORED_P (var) = 1;
6415 TREE_USED (var) = 1;
6417 /* Register the variable. */
6418 if (TREE_STATIC (decl))
6420 /* Namespace-scope or local static; give it a mangled name. */
6423 TREE_STATIC (var) = 1;
6424 name = mangle_ref_init_variable (decl);
6425 DECL_NAME (var) = name;
6426 SET_DECL_ASSEMBLER_NAME (var, name);
6427 var = pushdecl_top_level (var);
6431 /* Create a new cleanup level if necessary. */
6432 maybe_push_cleanup_level (type);
6433 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6434 DECL_CONTEXT (var) = current_function_decl;
6440 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6441 initializing a variable of that TYPE. If DECL is non-NULL, it is
6442 the VAR_DECL being initialized with the EXPR. (In that case, the
6443 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6444 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6445 return, if *CLEANUP is no longer NULL, it will be an expression
6446 that should be pushed as a cleanup after the returned expression
6447 is used to initialize DECL.
6449 Return the converted expression. */
6452 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6457 if (type == error_mark_node || error_operand_p (expr))
6458 return error_mark_node;
6460 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6461 p = conversion_obstack_alloc (0);
6463 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6464 if (!conv || conv->bad_p)
6466 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6467 && !real_lvalue_p (expr))
6468 error ("invalid initialization of non-const reference of "
6469 "type %qT from a temporary of type %qT",
6470 type, TREE_TYPE (expr));
6472 error ("invalid initialization of reference of type "
6473 "%qT from expression of type %qT", type,
6475 return error_mark_node;
6478 /* If DECL is non-NULL, then this special rule applies:
6482 The temporary to which the reference is bound or the temporary
6483 that is the complete object to which the reference is bound
6484 persists for the lifetime of the reference.
6486 The temporaries created during the evaluation of the expression
6487 initializing the reference, except the temporary to which the
6488 reference is bound, are destroyed at the end of the
6489 full-expression in which they are created.
6491 In that case, we store the converted expression into a new
6492 VAR_DECL in a new scope.
6494 However, we want to be careful not to create temporaries when
6495 they are not required. For example, given:
6498 struct D : public B {};
6502 there is no need to copy the return value from "f"; we can just
6503 extend its lifetime. Similarly, given:
6506 struct T { operator S(); };
6510 we can extend the lifetime of the return value of the conversion
6512 gcc_assert (conv->kind == ck_ref_bind);
6516 tree base_conv_type;
6518 /* Skip over the REF_BIND. */
6519 conv = conv->u.next;
6520 /* If the next conversion is a BASE_CONV, skip that too -- but
6521 remember that the conversion was required. */
6522 if (conv->kind == ck_base)
6524 if (conv->check_copy_constructor_p)
6525 check_constructor_callable (TREE_TYPE (expr), expr);
6526 base_conv_type = conv->type;
6527 conv = conv->u.next;
6530 base_conv_type = NULL_TREE;
6531 /* Perform the remainder of the conversion. */
6532 expr = convert_like_real (conv, expr,
6533 /*fn=*/NULL_TREE, /*argnum=*/0,
6535 /*issue_conversion_warnings=*/true,
6536 /*c_cast_p=*/false);
6537 if (!real_lvalue_p (expr))
6542 /* Create the temporary variable. */
6543 type = TREE_TYPE (expr);
6544 var = make_temporary_var_for_ref_to_temp (decl, type);
6545 layout_decl (var, 0);
6546 /* If the rvalue is the result of a function call it will be
6547 a TARGET_EXPR. If it is some other construct (such as a
6548 member access expression where the underlying object is
6549 itself the result of a function call), turn it into a
6550 TARGET_EXPR here. It is important that EXPR be a
6551 TARGET_EXPR below since otherwise the INIT_EXPR will
6552 attempt to make a bitwise copy of EXPR to initialize
6554 if (TREE_CODE (expr) != TARGET_EXPR)
6555 expr = get_target_expr (expr);
6556 /* Create the INIT_EXPR that will initialize the temporary
6558 init = build2 (INIT_EXPR, type, var, expr);
6559 if (at_function_scope_p ())
6561 add_decl_expr (var);
6562 *cleanup = cxx_maybe_build_cleanup (var);
6564 /* We must be careful to destroy the temporary only
6565 after its initialization has taken place. If the
6566 initialization throws an exception, then the
6567 destructor should not be run. We cannot simply
6568 transform INIT into something like:
6570 (INIT, ({ CLEANUP_STMT; }))
6572 because emit_local_var always treats the
6573 initializer as a full-expression. Thus, the
6574 destructor would run too early; it would run at the
6575 end of initializing the reference variable, rather
6576 than at the end of the block enclosing the
6579 The solution is to pass back a cleanup expression
6580 which the caller is responsible for attaching to
6581 the statement tree. */
6585 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6586 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6587 static_aggregates = tree_cons (NULL_TREE, var,
6590 /* Use its address to initialize the reference variable. */
6591 expr = build_address (var);
6593 expr = convert_to_base (expr,
6594 build_pointer_type (base_conv_type),
6595 /*check_access=*/true,
6597 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6600 /* Take the address of EXPR. */
6601 expr = build_unary_op (ADDR_EXPR, expr, 0);
6602 /* If a BASE_CONV was required, perform it now. */
6604 expr = (perform_implicit_conversion
6605 (build_pointer_type (base_conv_type), expr));
6606 expr = build_nop (type, expr);
6609 /* Perform the conversion. */
6610 expr = convert_like (conv, expr);
6612 /* Free all the conversions we allocated. */
6613 obstack_free (&conversion_obstack, p);
6618 #include "gt-cp-call.h"