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 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)
4169 expr = dubious_conversion_warnings
4170 (totype, expr, "converting", fn, argnum);
4171 switch (convs->kind)
4175 struct z_candidate *cand = convs->cand;
4176 tree convfn = cand->fn;
4179 if (DECL_CONSTRUCTOR_P (convfn))
4181 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4184 args = build_tree_list (NULL_TREE, expr);
4185 /* We should never try to call the abstract or base constructor
4187 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4188 && !DECL_HAS_VTT_PARM_P (convfn));
4189 args = tree_cons (NULL_TREE, t, args);
4192 args = build_this (expr);
4193 expr = build_over_call (cand, LOOKUP_NORMAL);
4195 /* If this is a constructor or a function returning an aggr type,
4196 we need to build up a TARGET_EXPR. */
4197 if (DECL_CONSTRUCTOR_P (convfn))
4198 expr = build_cplus_new (totype, expr);
4200 /* The result of the call is then used to direct-initialize the object
4201 that is the destination of the copy-initialization. [dcl.init]
4203 Note that this step is not reflected in the conversion sequence;
4204 it affects the semantics when we actually perform the
4205 conversion, but is not considered during overload resolution.
4207 If the target is a class, that means call a ctor. */
4208 if (IS_AGGR_TYPE (totype)
4209 && (inner >= 0 || !lvalue_p (expr)))
4213 /* Core issue 84, now a DR, says that we don't
4214 allow UDCs for these args (which deliberately
4215 breaks copy-init of an auto_ptr<Base> from an
4216 auto_ptr<Derived>). */
4217 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4224 (" initializing argument %P of %qD from result of %qD",
4225 argnum, fn, convfn);
4228 (" initializing temporary from result of %qD", convfn);
4230 expr = build_cplus_new (totype, expr);
4235 if (type_unknown_p (expr))
4236 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4237 /* Convert a constant to its underlying value, unless we are
4238 about to bind it to a reference, in which case we need to
4239 leave it as an lvalue. */
4241 expr = integral_constant_value (expr);
4242 if (convs->check_copy_constructor_p)
4243 check_constructor_callable (totype, expr);
4246 /* Call build_user_type_conversion again for the error. */
4247 return build_user_type_conversion
4248 (totype, convs->u.expr, LOOKUP_NORMAL);
4254 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4255 convs->kind == ck_ref_bind ? -1 : 1,
4256 /*issue_conversion_warnings=*/false,
4258 if (expr == error_mark_node)
4259 return error_mark_node;
4261 switch (convs->kind)
4264 if (! IS_AGGR_TYPE (totype))
4266 /* Else fall through. */
4268 if (convs->kind == ck_base && !convs->need_temporary_p)
4270 /* We are going to bind a reference directly to a base-class
4271 subobject of EXPR. */
4272 if (convs->check_copy_constructor_p)
4273 check_constructor_callable (TREE_TYPE (expr), expr);
4274 /* Build an expression for `*((base*) &expr)'. */
4275 expr = build_unary_op (ADDR_EXPR, expr, 0);
4276 expr = convert_to_base (expr, build_pointer_type (totype),
4277 !c_cast_p, /*nonnull=*/true);
4278 expr = build_indirect_ref (expr, "implicit conversion");
4282 /* Copy-initialization where the cv-unqualified version of the source
4283 type is the same class as, or a derived class of, the class of the
4284 destination [is treated as direct-initialization]. [dcl.init] */
4285 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4287 if (diagnostic_fn && fn)
4288 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4289 return build_cplus_new (totype, expr);
4293 tree ref_type = totype;
4295 /* If necessary, create a temporary. */
4296 if (convs->need_temporary_p || !lvalue_p (expr))
4298 tree type = convs->u.next->type;
4299 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4301 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4303 /* If the reference is volatile or non-const, we
4304 cannot create a temporary. */
4305 if (lvalue & clk_bitfield)
4306 error ("cannot bind bitfield %qE to %qT",
4308 else if (lvalue & clk_packed)
4309 error ("cannot bind packed field %qE to %qT",
4312 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4313 return error_mark_node;
4315 /* If the source is a packed field, and we must use a copy
4316 constructor, then building the target expr will require
4317 binding the field to the reference parameter to the
4318 copy constructor, and we'll end up with an infinite
4319 loop. If we can use a bitwise copy, then we'll be
4321 if ((lvalue & clk_packed)
4322 && CLASS_TYPE_P (type)
4323 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4325 error ("cannot bind packed field %qE to %qT",
4327 return error_mark_node;
4329 expr = build_target_expr_with_type (expr, type);
4332 /* Take the address of the thing to which we will bind the
4334 expr = build_unary_op (ADDR_EXPR, expr, 1);
4335 if (expr == error_mark_node)
4336 return error_mark_node;
4338 /* Convert it to a pointer to the type referred to by the
4339 reference. This will adjust the pointer if a derived to
4340 base conversion is being performed. */
4341 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4343 /* Convert the pointer to the desired reference type. */
4344 return build_nop (ref_type, expr);
4348 return decay_conversion (expr);
4351 /* Warn about deprecated conversion if appropriate. */
4352 string_conv_p (totype, expr, 1);
4357 expr = convert_to_base (expr, totype, !c_cast_p,
4359 return build_nop (totype, expr);
4362 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4368 return ocp_convert (totype, expr, CONV_IMPLICIT,
4369 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4372 /* Build a call to __builtin_trap. */
4375 call_builtin_trap (void)
4377 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4379 gcc_assert (fn != NULL);
4380 fn = build_call (fn, NULL_TREE);
4384 /* ARG is being passed to a varargs function. Perform any conversions
4385 required. Return the converted value. */
4388 convert_arg_to_ellipsis (tree arg)
4392 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4393 standard conversions are performed. */
4394 arg = decay_conversion (arg);
4397 If the argument has integral or enumeration type that is subject
4398 to the integral promotions (_conv.prom_), or a floating point
4399 type that is subject to the floating point promotion
4400 (_conv.fpprom_), the value of the argument is converted to the
4401 promoted type before the call. */
4402 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4403 && (TYPE_PRECISION (TREE_TYPE (arg))
4404 < TYPE_PRECISION (double_type_node)))
4405 arg = convert_to_real (double_type_node, arg);
4406 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4407 arg = perform_integral_promotions (arg);
4409 arg = require_complete_type (arg);
4411 if (arg != error_mark_node
4412 && !pod_type_p (TREE_TYPE (arg)))
4414 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4415 here and do a bitwise copy, but now cp_expr_size will abort if we
4417 If the call appears in the context of a sizeof expression,
4418 there is no need to emit a warning, since the expression won't be
4419 evaluated. We keep the builtin_trap just as a safety check. */
4420 if (!skip_evaluation)
4421 warning ("cannot pass objects of non-POD type %q#T through %<...%>; "
4422 "call will abort at runtime", TREE_TYPE (arg));
4423 arg = call_builtin_trap ();
4424 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4431 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4434 build_x_va_arg (tree expr, tree type)
4436 if (processing_template_decl)
4437 return build_min (VA_ARG_EXPR, type, expr);
4439 type = complete_type_or_else (type, NULL_TREE);
4441 if (expr == error_mark_node || !type)
4442 return error_mark_node;
4444 if (! pod_type_p (type))
4446 /* Undefined behavior [expr.call] 5.2.2/7. */
4447 warning ("cannot receive objects of non-POD type %q#T through %<...%>; "
4448 "call will abort at runtime", type);
4449 expr = convert (build_pointer_type (type), null_node);
4450 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4451 call_builtin_trap (), expr);
4452 expr = build_indirect_ref (expr, NULL);
4456 return build_va_arg (expr, type);
4459 /* TYPE has been given to va_arg. Apply the default conversions which
4460 would have happened when passed via ellipsis. Return the promoted
4461 type, or the passed type if there is no change. */
4464 cxx_type_promotes_to (tree type)
4468 /* Perform the array-to-pointer and function-to-pointer
4470 type = type_decays_to (type);
4472 promote = type_promotes_to (type);
4473 if (same_type_p (type, promote))
4479 /* ARG is a default argument expression being passed to a parameter of
4480 the indicated TYPE, which is a parameter to FN. Do any required
4481 conversions. Return the converted value. */
4484 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4486 /* If the ARG is an unparsed default argument expression, the
4487 conversion cannot be performed. */
4488 if (TREE_CODE (arg) == DEFAULT_ARG)
4490 error ("the default argument for parameter %d of %qD has "
4491 "not yet been parsed",
4493 return error_mark_node;
4496 if (fn && DECL_TEMPLATE_INFO (fn))
4497 arg = tsubst_default_argument (fn, type, arg);
4499 arg = break_out_target_exprs (arg);
4501 if (TREE_CODE (arg) == CONSTRUCTOR)
4503 arg = digest_init (type, arg, 0);
4504 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4505 "default argument", fn, parmnum);
4509 /* This could get clobbered by the following call. */
4510 if (TREE_HAS_CONSTRUCTOR (arg))
4511 arg = copy_node (arg);
4513 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4514 "default argument", fn, parmnum);
4515 arg = convert_for_arg_passing (type, arg);
4521 /* Returns the type which will really be used for passing an argument of
4525 type_passed_as (tree type)
4527 /* Pass classes with copy ctors by invisible reference. */
4528 if (TREE_ADDRESSABLE (type))
4530 type = build_reference_type (type);
4531 /* There are no other pointers to this temporary. */
4532 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4534 else if (targetm.calls.promote_prototypes (type)
4535 && INTEGRAL_TYPE_P (type)
4536 && COMPLETE_TYPE_P (type)
4537 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4538 TYPE_SIZE (integer_type_node)))
4539 type = integer_type_node;
4544 /* Actually perform the appropriate conversion. */
4547 convert_for_arg_passing (tree type, tree val)
4549 if (val == error_mark_node)
4551 /* Pass classes with copy ctors by invisible reference. */
4552 else if (TREE_ADDRESSABLE (type))
4553 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4554 else if (targetm.calls.promote_prototypes (type)
4555 && INTEGRAL_TYPE_P (type)
4556 && COMPLETE_TYPE_P (type)
4557 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4558 TYPE_SIZE (integer_type_node)))
4559 val = perform_integral_promotions (val);
4563 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4564 which no conversions at all should be done. This is true for some
4565 builtins which don't act like normal functions. */
4568 magic_varargs_p (tree fn)
4570 if (DECL_BUILT_IN (fn))
4571 switch (DECL_FUNCTION_CODE (fn))
4573 case BUILT_IN_CLASSIFY_TYPE:
4574 case BUILT_IN_CONSTANT_P:
4575 case BUILT_IN_NEXT_ARG:
4576 case BUILT_IN_STDARG_START:
4577 case BUILT_IN_VA_START:
4586 /* Subroutine of the various build_*_call functions. Overload resolution
4587 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4588 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4589 bitmask of various LOOKUP_* flags which apply to the call itself. */
4592 build_over_call (struct z_candidate *cand, int flags)
4595 tree args = cand->args;
4596 conversion **convs = cand->convs;
4598 tree converted_args = NULL_TREE;
4599 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4604 /* In a template, there is no need to perform all of the work that
4605 is normally done. We are only interested in the type of the call
4606 expression, i.e., the return type of the function. Any semantic
4607 errors will be deferred until the template is instantiated. */
4608 if (processing_template_decl)
4612 return_type = TREE_TYPE (TREE_TYPE (fn));
4613 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4614 if (TREE_THIS_VOLATILE (fn) && cfun)
4615 current_function_returns_abnormally = 1;
4616 if (!VOID_TYPE_P (return_type))
4617 require_complete_type (return_type);
4618 return convert_from_reference (expr);
4621 /* Give any warnings we noticed during overload resolution. */
4624 struct candidate_warning *w;
4625 for (w = cand->warnings; w; w = w->next)
4626 joust (cand, w->loser, 1);
4629 if (DECL_FUNCTION_MEMBER_P (fn))
4631 /* If FN is a template function, two cases must be considered.
4636 template <class T> void f();
4638 template <class T> struct B {
4642 struct C : A, B<int> {
4644 using B<int>::g; // #2
4647 In case #1 where `A::f' is a member template, DECL_ACCESS is
4648 recorded in the primary template but not in its specialization.
4649 We check access of FN using its primary template.
4651 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4652 because it is a member of class template B, DECL_ACCESS is
4653 recorded in the specialization `B<int>::g'. We cannot use its
4654 primary template because `B<T>::g' and `B<int>::g' may have
4655 different access. */
4656 if (DECL_TEMPLATE_INFO (fn)
4657 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4658 perform_or_defer_access_check (cand->access_path,
4659 DECL_TI_TEMPLATE (fn));
4661 perform_or_defer_access_check (cand->access_path, fn);
4664 if (args && TREE_CODE (args) != TREE_LIST)
4665 args = build_tree_list (NULL_TREE, args);
4668 /* The implicit parameters to a constructor are not considered by overload
4669 resolution, and must be of the proper type. */
4670 if (DECL_CONSTRUCTOR_P (fn))
4672 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4673 arg = TREE_CHAIN (arg);
4674 parm = TREE_CHAIN (parm);
4675 /* We should never try to call the abstract constructor. */
4676 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4678 if (DECL_HAS_VTT_PARM_P (fn))
4680 converted_args = tree_cons
4681 (NULL_TREE, TREE_VALUE (arg), converted_args);
4682 arg = TREE_CHAIN (arg);
4683 parm = TREE_CHAIN (parm);
4686 /* Bypass access control for 'this' parameter. */
4687 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4689 tree parmtype = TREE_VALUE (parm);
4690 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4694 if (convs[i]->bad_p)
4695 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4696 TREE_TYPE (argtype), fn);
4698 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4699 X is called for an object that is not of type X, or of a type
4700 derived from X, the behavior is undefined.
4702 So we can assume that anything passed as 'this' is non-null, and
4703 optimize accordingly. */
4704 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4705 /* Convert to the base in which the function was declared. */
4706 gcc_assert (cand->conversion_path != NULL_TREE);
4707 converted_arg = build_base_path (PLUS_EXPR,
4709 cand->conversion_path,
4711 /* Check that the base class is accessible. */
4712 if (!accessible_base_p (TREE_TYPE (argtype),
4713 BINFO_TYPE (cand->conversion_path), true))
4714 error ("%qT is not an accessible base of %qT",
4715 BINFO_TYPE (cand->conversion_path),
4716 TREE_TYPE (argtype));
4717 /* If fn was found by a using declaration, the conversion path
4718 will be to the derived class, not the base declaring fn. We
4719 must convert from derived to base. */
4720 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4721 TREE_TYPE (parmtype), ba_unique, NULL);
4722 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4725 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4726 parm = TREE_CHAIN (parm);
4727 arg = TREE_CHAIN (arg);
4733 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4735 tree type = TREE_VALUE (parm);
4738 val = convert_like_with_context
4739 (conv, TREE_VALUE (arg), fn, i - is_method);
4741 val = convert_for_arg_passing (type, val);
4742 converted_args = tree_cons (NULL_TREE, val, converted_args);
4745 /* Default arguments */
4746 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4748 = tree_cons (NULL_TREE,
4749 convert_default_arg (TREE_VALUE (parm),
4750 TREE_PURPOSE (parm),
4755 for (; arg; arg = TREE_CHAIN (arg))
4757 tree a = TREE_VALUE (arg);
4758 if (magic_varargs_p (fn))
4759 /* Do no conversions for magic varargs. */;
4761 a = convert_arg_to_ellipsis (a);
4762 converted_args = tree_cons (NULL_TREE, a, converted_args);
4765 converted_args = nreverse (converted_args);
4767 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4770 /* Avoid actually calling copy constructors and copy assignment operators,
4773 if (! flag_elide_constructors)
4774 /* Do things the hard way. */;
4775 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4778 arg = skip_artificial_parms_for (fn, converted_args);
4779 arg = TREE_VALUE (arg);
4781 /* Pull out the real argument, disregarding const-correctness. */
4783 while (TREE_CODE (targ) == NOP_EXPR
4784 || TREE_CODE (targ) == NON_LVALUE_EXPR
4785 || TREE_CODE (targ) == CONVERT_EXPR)
4786 targ = TREE_OPERAND (targ, 0);
4787 if (TREE_CODE (targ) == ADDR_EXPR)
4789 targ = TREE_OPERAND (targ, 0);
4790 if (!same_type_ignoring_top_level_qualifiers_p
4791 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4800 arg = build_indirect_ref (arg, 0);
4802 /* [class.copy]: the copy constructor is implicitly defined even if
4803 the implementation elided its use. */
4804 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4807 /* If we're creating a temp and we already have one, don't create a
4808 new one. If we're not creating a temp but we get one, use
4809 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4810 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4811 temp or an INIT_EXPR otherwise. */
4812 if (integer_zerop (TREE_VALUE (args)))
4814 if (TREE_CODE (arg) == TARGET_EXPR)
4816 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4817 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4819 else if (TREE_CODE (arg) == TARGET_EXPR
4820 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4822 tree to = stabilize_reference
4823 (build_indirect_ref (TREE_VALUE (args), 0));
4825 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4829 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4831 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4833 tree to = stabilize_reference
4834 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4835 tree type = TREE_TYPE (to);
4836 tree as_base = CLASSTYPE_AS_BASE (type);
4838 arg = TREE_VALUE (TREE_CHAIN (converted_args));
4839 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4841 arg = build_indirect_ref (arg, 0);
4842 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4846 /* We must only copy the non-tail padding parts.
4847 Use __builtin_memcpy for the bitwise copy. */
4851 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
4852 args = tree_cons (NULL, arg, args);
4853 t = build_unary_op (ADDR_EXPR, to, 0);
4854 args = tree_cons (NULL, t, args);
4855 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
4856 t = build_call (t, args);
4858 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
4859 val = build_indirect_ref (t, 0);
4867 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4869 tree t, *p = &TREE_VALUE (converted_args);
4870 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4873 gcc_assert (binfo && binfo != error_mark_node);
4875 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4876 if (TREE_SIDE_EFFECTS (*p))
4877 *p = save_expr (*p);
4878 t = build_pointer_type (TREE_TYPE (fn));
4879 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4880 fn = build_java_interface_fn_ref (fn, *p);
4882 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
4885 else if (DECL_INLINE (fn))
4886 fn = inline_conversion (fn);
4888 fn = build_addr_func (fn);
4890 return build_cxx_call (fn, converted_args);
4893 /* Build and return a call to FN, using ARGS. This function performs
4894 no overload resolution, conversion, or other high-level
4898 build_cxx_call (tree fn, tree args)
4902 fn = build_call (fn, args);
4904 /* If this call might throw an exception, note that fact. */
4905 fndecl = get_callee_fndecl (fn);
4906 if ((!fndecl || !TREE_NOTHROW (fndecl))
4907 && at_function_scope_p ()
4909 cp_function_chain->can_throw = 1;
4911 /* Some built-in function calls will be evaluated at compile-time in
4913 fn = fold_if_not_in_template (fn);
4915 if (VOID_TYPE_P (TREE_TYPE (fn)))
4918 fn = require_complete_type (fn);
4919 if (fn == error_mark_node)
4920 return error_mark_node;
4922 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4923 fn = build_cplus_new (TREE_TYPE (fn), fn);
4924 return convert_from_reference (fn);
4927 static GTY(()) tree java_iface_lookup_fn;
4929 /* Make an expression which yields the address of the Java interface
4930 method FN. This is achieved by generating a call to libjava's
4931 _Jv_LookupInterfaceMethodIdx(). */
4934 build_java_interface_fn_ref (tree fn, tree instance)
4936 tree lookup_args, lookup_fn, method, idx;
4937 tree klass_ref, iface, iface_ref;
4940 if (!java_iface_lookup_fn)
4942 tree endlink = build_void_list_node ();
4943 tree t = tree_cons (NULL_TREE, ptr_type_node,
4944 tree_cons (NULL_TREE, ptr_type_node,
4945 tree_cons (NULL_TREE, java_int_type_node,
4947 java_iface_lookup_fn
4948 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4949 build_function_type (ptr_type_node, t),
4950 0, NOT_BUILT_IN, NULL, NULL_TREE);
4953 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4954 This is the first entry in the vtable. */
4955 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4958 /* Get the java.lang.Class pointer for the interface being called. */
4959 iface = DECL_CONTEXT (fn);
4960 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4961 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4962 || DECL_CONTEXT (iface_ref) != iface)
4964 error ("could not find class$ field in java interface type %qT",
4966 return error_mark_node;
4968 iface_ref = build_address (iface_ref);
4969 iface_ref = convert (build_pointer_type (iface), iface_ref);
4971 /* Determine the itable index of FN. */
4973 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4975 if (!DECL_VIRTUAL_P (method))
4981 idx = build_int_cst (NULL_TREE, i);
4983 lookup_args = tree_cons (NULL_TREE, klass_ref,
4984 tree_cons (NULL_TREE, iface_ref,
4985 build_tree_list (NULL_TREE, idx)));
4986 lookup_fn = build1 (ADDR_EXPR,
4987 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4988 java_iface_lookup_fn);
4989 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4992 /* Returns the value to use for the in-charge parameter when making a
4993 call to a function with the indicated NAME.
4995 FIXME:Can't we find a neater way to do this mapping? */
4998 in_charge_arg_for_name (tree name)
5000 if (name == base_ctor_identifier
5001 || name == base_dtor_identifier)
5002 return integer_zero_node;
5003 else if (name == complete_ctor_identifier)
5004 return integer_one_node;
5005 else if (name == complete_dtor_identifier)
5006 return integer_two_node;
5007 else if (name == deleting_dtor_identifier)
5008 return integer_three_node;
5010 /* This function should only be called with one of the names listed
5016 /* Build a call to a constructor, destructor, or an assignment
5017 operator for INSTANCE, an expression with class type. NAME
5018 indicates the special member function to call; ARGS are the
5019 arguments. BINFO indicates the base of INSTANCE that is to be
5020 passed as the `this' parameter to the member function called.
5022 FLAGS are the LOOKUP_* flags to use when processing the call.
5024 If NAME indicates a complete object constructor, INSTANCE may be
5025 NULL_TREE. In this case, the caller will call build_cplus_new to
5026 store the newly constructed object into a VAR_DECL. */
5029 build_special_member_call (tree instance, tree name, tree args,
5030 tree binfo, int flags)
5033 /* The type of the subobject to be constructed or destroyed. */
5036 gcc_assert (name == complete_ctor_identifier
5037 || name == base_ctor_identifier
5038 || name == complete_dtor_identifier
5039 || name == base_dtor_identifier
5040 || name == deleting_dtor_identifier
5041 || name == ansi_assopname (NOP_EXPR));
5044 /* Resolve the name. */
5045 if (!complete_type_or_else (binfo, NULL_TREE))
5046 return error_mark_node;
5048 binfo = TYPE_BINFO (binfo);
5051 gcc_assert (binfo != NULL_TREE);
5053 class_type = BINFO_TYPE (binfo);
5055 /* Handle the special case where INSTANCE is NULL_TREE. */
5056 if (name == complete_ctor_identifier && !instance)
5058 instance = build_int_cst (build_pointer_type (class_type), 0);
5059 instance = build1 (INDIRECT_REF, class_type, instance);
5063 if (name == complete_dtor_identifier
5064 || name == base_dtor_identifier
5065 || name == deleting_dtor_identifier)
5066 gcc_assert (args == NULL_TREE);
5068 /* Convert to the base class, if necessary. */
5069 if (!same_type_ignoring_top_level_qualifiers_p
5070 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5072 if (name != ansi_assopname (NOP_EXPR))
5073 /* For constructors and destructors, either the base is
5074 non-virtual, or it is virtual but we are doing the
5075 conversion from a constructor or destructor for the
5076 complete object. In either case, we can convert
5078 instance = convert_to_base_statically (instance, binfo);
5080 /* However, for assignment operators, we must convert
5081 dynamically if the base is virtual. */
5082 instance = build_base_path (PLUS_EXPR, instance,
5083 binfo, /*nonnull=*/1);
5087 gcc_assert (instance != NULL_TREE);
5089 fns = lookup_fnfields (binfo, name, 1);
5091 /* When making a call to a constructor or destructor for a subobject
5092 that uses virtual base classes, pass down a pointer to a VTT for
5094 if ((name == base_ctor_identifier
5095 || name == base_dtor_identifier)
5096 && CLASSTYPE_VBASECLASSES (class_type))
5101 /* If the current function is a complete object constructor
5102 or destructor, then we fetch the VTT directly.
5103 Otherwise, we look it up using the VTT we were given. */
5104 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5105 vtt = decay_conversion (vtt);
5106 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5107 build2 (EQ_EXPR, boolean_type_node,
5108 current_in_charge_parm, integer_zero_node),
5111 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5112 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5113 BINFO_SUBVTT_INDEX (binfo));
5115 args = tree_cons (NULL_TREE, sub_vtt, args);
5118 return build_new_method_call (instance, fns, args,
5119 TYPE_BINFO (BINFO_TYPE (binfo)),
5123 /* Return the NAME, as a C string. The NAME indicates a function that
5124 is a member of TYPE. *FREE_P is set to true if the caller must
5125 free the memory returned.
5127 Rather than go through all of this, we should simply set the names
5128 of constructors and destructors appropriately, and dispense with
5129 ctor_identifier, dtor_identifier, etc. */
5132 name_as_c_string (tree name, tree type, bool *free_p)
5136 /* Assume that we will not allocate memory. */
5138 /* Constructors and destructors are special. */
5139 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5142 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5143 /* For a destructor, add the '~'. */
5144 if (name == complete_dtor_identifier
5145 || name == base_dtor_identifier
5146 || name == deleting_dtor_identifier)
5148 pretty_name = concat ("~", pretty_name, NULL);
5149 /* Remember that we need to free the memory allocated. */
5153 else if (IDENTIFIER_TYPENAME_P (name))
5155 pretty_name = concat ("operator ",
5156 type_as_string (TREE_TYPE (name),
5157 TFF_PLAIN_IDENTIFIER),
5159 /* Remember that we need to free the memory allocated. */
5163 pretty_name = (char *) IDENTIFIER_POINTER (name);
5168 /* Build a call to "INSTANCE.FN (ARGS)". */
5171 build_new_method_call (tree instance, tree fns, tree args,
5172 tree conversion_path, int flags)
5174 struct z_candidate *candidates = 0, *cand;
5175 tree explicit_targs = NULL_TREE;
5176 tree basetype = NULL_TREE;
5179 tree mem_args = NULL_TREE, instance_ptr;
5185 int template_only = 0;
5192 gcc_assert (instance != NULL_TREE);
5194 if (error_operand_p (instance)
5195 || error_operand_p (fns)
5196 || args == error_mark_node)
5197 return error_mark_node;
5199 orig_instance = instance;
5203 if (processing_template_decl)
5205 instance = build_non_dependent_expr (instance);
5206 if (!BASELINK_P (fns)
5207 && TREE_CODE (fns) != PSEUDO_DTOR_EXPR
5208 && TREE_TYPE (fns) != unknown_type_node)
5209 fns = build_non_dependent_expr (fns);
5210 args = build_non_dependent_args (orig_args);
5213 /* Process the argument list. */
5215 args = resolve_args (args);
5216 if (args == error_mark_node)
5217 return error_mark_node;
5219 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5220 instance_ptr = build_this (instance);
5222 if (!BASELINK_P (fns))
5224 error ("call to non-function %qD", fns);
5225 return error_mark_node;
5228 if (!conversion_path)
5229 conversion_path = BASELINK_BINFO (fns);
5230 access_binfo = BASELINK_ACCESS_BINFO (fns);
5231 optype = BASELINK_OPTYPE (fns);
5232 fns = BASELINK_FUNCTIONS (fns);
5234 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5236 explicit_targs = TREE_OPERAND (fns, 1);
5237 fns = TREE_OPERAND (fns, 0);
5241 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5242 || TREE_CODE (fns) == TEMPLATE_DECL
5243 || TREE_CODE (fns) == OVERLOAD);
5245 /* XXX this should be handled before we get here. */
5246 if (! IS_AGGR_TYPE (basetype))
5248 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5249 error ("request for member %qD in %qE, which is of non-aggregate "
5251 fns, instance, basetype);
5253 return error_mark_node;
5256 fn = get_first_fn (fns);
5257 name = DECL_NAME (fn);
5259 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5261 /* Callers should explicitly indicate whether they want to construct
5262 the complete object or just the part without virtual bases. */
5263 gcc_assert (name != ctor_identifier);
5264 /* Similarly for destructors. */
5265 gcc_assert (name != dtor_identifier);
5268 /* It's OK to call destructors on cv-qualified objects. Therefore,
5269 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5270 if (DECL_DESTRUCTOR_P (fn))
5272 tree type = build_pointer_type (basetype);
5273 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5274 instance_ptr = build_nop (type, instance_ptr);
5277 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5278 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5280 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5281 p = conversion_obstack_alloc (0);
5283 for (fn = fns; fn; fn = OVL_NEXT (fn))
5285 tree t = OVL_CURRENT (fn);
5288 /* We can end up here for copy-init of same or base class. */
5289 if ((flags & LOOKUP_ONLYCONVERTING)
5290 && DECL_NONCONVERTING_P (t))
5293 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5294 this_arglist = mem_args;
5296 this_arglist = args;
5298 if (TREE_CODE (t) == TEMPLATE_DECL)
5299 /* A member template. */
5300 add_template_candidate (&candidates, t,
5303 this_arglist, optype,
5308 else if (! template_only)
5309 add_function_candidate (&candidates, t,
5317 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5320 if (!COMPLETE_TYPE_P (basetype))
5321 cxx_incomplete_type_error (instance_ptr, basetype);
5327 pretty_name = name_as_c_string (name, basetype, &free_p);
5328 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5329 basetype, pretty_name, user_args,
5330 TREE_TYPE (TREE_TYPE (instance_ptr)));
5334 print_z_candidates (candidates);
5335 call = error_mark_node;
5339 cand = tourney (candidates);
5345 pretty_name = name_as_c_string (name, basetype, &free_p);
5346 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5348 print_z_candidates (candidates);
5351 call = error_mark_node;
5355 if (!(flags & LOOKUP_NONVIRTUAL)
5356 && DECL_PURE_VIRTUAL_P (cand->fn)
5357 && instance == current_class_ref
5358 && (DECL_CONSTRUCTOR_P (current_function_decl)
5359 || DECL_DESTRUCTOR_P (current_function_decl)))
5360 /* This is not an error, it is runtime undefined
5362 warning ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5363 "abstract virtual %q#D called from constructor"
5364 : "abstract virtual %q#D called from destructor"),
5367 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5368 && is_dummy_object (instance_ptr))
5370 error ("cannot call member function %qD without object",
5372 call = error_mark_node;
5376 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5377 && resolves_to_fixed_type_p (instance, 0))
5378 flags |= LOOKUP_NONVIRTUAL;
5380 call = build_over_call (cand, flags);
5382 /* In an expression of the form `a->f()' where `f' turns
5383 out to be a static member function, `a' is
5384 none-the-less evaluated. */
5385 if (TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE
5386 && !is_dummy_object (instance_ptr)
5387 && TREE_SIDE_EFFECTS (instance))
5388 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5394 if (processing_template_decl && call != error_mark_node)
5395 call = (build_min_non_dep
5397 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5398 orig_args, NULL_TREE));
5400 /* Free all the conversions we allocated. */
5401 obstack_free (&conversion_obstack, p);
5406 /* Returns true iff standard conversion sequence ICS1 is a proper
5407 subsequence of ICS2. */
5410 is_subseq (conversion *ics1, conversion *ics2)
5412 /* We can assume that a conversion of the same code
5413 between the same types indicates a subsequence since we only get
5414 here if the types we are converting from are the same. */
5416 while (ics1->kind == ck_rvalue
5417 || ics1->kind == ck_lvalue)
5418 ics1 = ics1->u.next;
5422 while (ics2->kind == ck_rvalue
5423 || ics2->kind == ck_lvalue)
5424 ics2 = ics2->u.next;
5426 if (ics2->kind == ck_user
5427 || ics2->kind == ck_ambig
5428 || ics2->kind == ck_identity)
5429 /* At this point, ICS1 cannot be a proper subsequence of
5430 ICS2. We can get a USER_CONV when we are comparing the
5431 second standard conversion sequence of two user conversion
5435 ics2 = ics2->u.next;
5437 if (ics2->kind == ics1->kind
5438 && same_type_p (ics2->type, ics1->type)
5439 && same_type_p (ics2->u.next->type,
5440 ics1->u.next->type))
5445 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5446 be any _TYPE nodes. */
5449 is_properly_derived_from (tree derived, tree base)
5451 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5452 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5455 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5456 considers every class derived from itself. */
5457 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5458 && DERIVED_FROM_P (base, derived));
5461 /* We build the ICS for an implicit object parameter as a pointer
5462 conversion sequence. However, such a sequence should be compared
5463 as if it were a reference conversion sequence. If ICS is the
5464 implicit conversion sequence for an implicit object parameter,
5465 modify it accordingly. */
5468 maybe_handle_implicit_object (conversion **ics)
5472 /* [over.match.funcs]
5474 For non-static member functions, the type of the
5475 implicit object parameter is "reference to cv X"
5476 where X is the class of which the function is a
5477 member and cv is the cv-qualification on the member
5478 function declaration. */
5479 conversion *t = *ics;
5480 tree reference_type;
5482 /* The `this' parameter is a pointer to a class type. Make the
5483 implicit conversion talk about a reference to that same class
5485 reference_type = TREE_TYPE (t->type);
5486 reference_type = build_reference_type (reference_type);
5488 if (t->kind == ck_qual)
5490 if (t->kind == ck_ptr)
5492 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5493 t = direct_reference_binding (reference_type, t);
5498 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5499 and return the type to which the reference refers. Otherwise,
5500 leave *ICS unchanged and return NULL_TREE. */
5503 maybe_handle_ref_bind (conversion **ics)
5505 if ((*ics)->kind == ck_ref_bind)
5507 conversion *old_ics = *ics;
5508 tree type = TREE_TYPE (old_ics->type);
5509 *ics = old_ics->u.next;
5510 (*ics)->user_conv_p = old_ics->user_conv_p;
5511 (*ics)->bad_p = old_ics->bad_p;
5518 /* Compare two implicit conversion sequences according to the rules set out in
5519 [over.ics.rank]. Return values:
5521 1: ics1 is better than ics2
5522 -1: ics2 is better than ics1
5523 0: ics1 and ics2 are indistinguishable */
5526 compare_ics (conversion *ics1, conversion *ics2)
5532 tree deref_from_type1 = NULL_TREE;
5533 tree deref_from_type2 = NULL_TREE;
5534 tree deref_to_type1 = NULL_TREE;
5535 tree deref_to_type2 = NULL_TREE;
5536 conversion_rank rank1, rank2;
5538 /* REF_BINDING is nonzero if the result of the conversion sequence
5539 is a reference type. In that case TARGET_TYPE is the
5540 type referred to by the reference. */
5544 /* Handle implicit object parameters. */
5545 maybe_handle_implicit_object (&ics1);
5546 maybe_handle_implicit_object (&ics2);
5548 /* Handle reference parameters. */
5549 target_type1 = maybe_handle_ref_bind (&ics1);
5550 target_type2 = maybe_handle_ref_bind (&ics2);
5554 When comparing the basic forms of implicit conversion sequences (as
5555 defined in _over.best.ics_)
5557 --a standard conversion sequence (_over.ics.scs_) is a better
5558 conversion sequence than a user-defined conversion sequence
5559 or an ellipsis conversion sequence, and
5561 --a user-defined conversion sequence (_over.ics.user_) is a
5562 better conversion sequence than an ellipsis conversion sequence
5563 (_over.ics.ellipsis_). */
5564 rank1 = CONVERSION_RANK (ics1);
5565 rank2 = CONVERSION_RANK (ics2);
5569 else if (rank1 < rank2)
5572 if (rank1 == cr_bad)
5574 /* XXX Isn't this an extension? */
5575 /* Both ICS are bad. We try to make a decision based on what
5576 would have happened if they'd been good. */
5577 if (ics1->user_conv_p > ics2->user_conv_p
5578 || ics1->rank > ics2->rank)
5580 else if (ics1->user_conv_p < ics2->user_conv_p
5581 || ics1->rank < ics2->rank)
5584 /* We couldn't make up our minds; try to figure it out below. */
5587 if (ics1->ellipsis_p)
5588 /* Both conversions are ellipsis conversions. */
5591 /* User-defined conversion sequence U1 is a better conversion sequence
5592 than another user-defined conversion sequence U2 if they contain the
5593 same user-defined conversion operator or constructor and if the sec-
5594 ond standard conversion sequence of U1 is better than the second
5595 standard conversion sequence of U2. */
5597 if (ics1->user_conv_p)
5602 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5603 if (t1->kind == ck_ambig)
5605 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5606 if (t2->kind == ck_ambig)
5609 if (t1->cand->fn != t2->cand->fn)
5612 /* We can just fall through here, after setting up
5613 FROM_TYPE1 and FROM_TYPE2. */
5614 from_type1 = t1->type;
5615 from_type2 = t2->type;
5622 /* We're dealing with two standard conversion sequences.
5626 Standard conversion sequence S1 is a better conversion
5627 sequence than standard conversion sequence S2 if
5629 --S1 is a proper subsequence of S2 (comparing the conversion
5630 sequences in the canonical form defined by _over.ics.scs_,
5631 excluding any Lvalue Transformation; the identity
5632 conversion sequence is considered to be a subsequence of
5633 any non-identity conversion sequence */
5636 while (t1->kind != ck_identity)
5638 from_type1 = t1->type;
5641 while (t2->kind != ck_identity)
5643 from_type2 = t2->type;
5646 if (same_type_p (from_type1, from_type2))
5648 if (is_subseq (ics1, ics2))
5650 if (is_subseq (ics2, ics1))
5653 /* Otherwise, one sequence cannot be a subsequence of the other; they
5654 don't start with the same type. This can happen when comparing the
5655 second standard conversion sequence in two user-defined conversion
5662 --the rank of S1 is better than the rank of S2 (by the rules
5665 Standard conversion sequences are ordered by their ranks: an Exact
5666 Match is a better conversion than a Promotion, which is a better
5667 conversion than a Conversion.
5669 Two conversion sequences with the same rank are indistinguishable
5670 unless one of the following rules applies:
5672 --A conversion that is not a conversion of a pointer, or pointer
5673 to member, to bool is better than another conversion that is such
5676 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5677 so that we do not have to check it explicitly. */
5678 if (ics1->rank < ics2->rank)
5680 else if (ics2->rank < ics1->rank)
5683 to_type1 = ics1->type;
5684 to_type2 = ics2->type;
5686 if (TYPE_PTR_P (from_type1)
5687 && TYPE_PTR_P (from_type2)
5688 && TYPE_PTR_P (to_type1)
5689 && TYPE_PTR_P (to_type2))
5691 deref_from_type1 = TREE_TYPE (from_type1);
5692 deref_from_type2 = TREE_TYPE (from_type2);
5693 deref_to_type1 = TREE_TYPE (to_type1);
5694 deref_to_type2 = TREE_TYPE (to_type2);
5696 /* The rules for pointers to members A::* are just like the rules
5697 for pointers A*, except opposite: if B is derived from A then
5698 A::* converts to B::*, not vice versa. For that reason, we
5699 switch the from_ and to_ variables here. */
5700 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5701 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5702 || (TYPE_PTRMEMFUNC_P (from_type1)
5703 && TYPE_PTRMEMFUNC_P (from_type2)
5704 && TYPE_PTRMEMFUNC_P (to_type1)
5705 && TYPE_PTRMEMFUNC_P (to_type2)))
5707 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5708 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5709 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5710 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5713 if (deref_from_type1 != NULL_TREE
5714 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5715 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5717 /* This was one of the pointer or pointer-like conversions.
5721 --If class B is derived directly or indirectly from class A,
5722 conversion of B* to A* is better than conversion of B* to
5723 void*, and conversion of A* to void* is better than
5724 conversion of B* to void*. */
5725 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5726 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5728 if (is_properly_derived_from (deref_from_type1,
5731 else if (is_properly_derived_from (deref_from_type2,
5735 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5736 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5738 if (same_type_p (deref_from_type1, deref_from_type2))
5740 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5742 if (is_properly_derived_from (deref_from_type1,
5746 /* We know that DEREF_TO_TYPE1 is `void' here. */
5747 else if (is_properly_derived_from (deref_from_type1,
5752 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5753 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5757 --If class B is derived directly or indirectly from class A
5758 and class C is derived directly or indirectly from B,
5760 --conversion of C* to B* is better than conversion of C* to
5763 --conversion of B* to A* is better than conversion of C* to
5765 if (same_type_p (deref_from_type1, deref_from_type2))
5767 if (is_properly_derived_from (deref_to_type1,
5770 else if (is_properly_derived_from (deref_to_type2,
5774 else if (same_type_p (deref_to_type1, deref_to_type2))
5776 if (is_properly_derived_from (deref_from_type2,
5779 else if (is_properly_derived_from (deref_from_type1,
5785 else if (CLASS_TYPE_P (non_reference (from_type1))
5786 && same_type_p (from_type1, from_type2))
5788 tree from = non_reference (from_type1);
5792 --binding of an expression of type C to a reference of type
5793 B& is better than binding an expression of type C to a
5794 reference of type A&
5796 --conversion of C to B is better than conversion of C to A, */
5797 if (is_properly_derived_from (from, to_type1)
5798 && is_properly_derived_from (from, to_type2))
5800 if (is_properly_derived_from (to_type1, to_type2))
5802 else if (is_properly_derived_from (to_type2, to_type1))
5806 else if (CLASS_TYPE_P (non_reference (to_type1))
5807 && same_type_p (to_type1, to_type2))
5809 tree to = non_reference (to_type1);
5813 --binding of an expression of type B to a reference of type
5814 A& is better than binding an expression of type C to a
5815 reference of type A&,
5817 --conversion of B to A is better than conversion of C to A */
5818 if (is_properly_derived_from (from_type1, to)
5819 && is_properly_derived_from (from_type2, to))
5821 if (is_properly_derived_from (from_type2, from_type1))
5823 else if (is_properly_derived_from (from_type1, from_type2))
5830 --S1 and S2 differ only in their qualification conversion and yield
5831 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5832 qualification signature of type T1 is a proper subset of the cv-
5833 qualification signature of type T2 */
5834 if (ics1->kind == ck_qual
5835 && ics2->kind == ck_qual
5836 && same_type_p (from_type1, from_type2))
5837 return comp_cv_qual_signature (to_type1, to_type2);
5841 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5842 types to which the references refer are the same type except for
5843 top-level cv-qualifiers, and the type to which the reference
5844 initialized by S2 refers is more cv-qualified than the type to
5845 which the reference initialized by S1 refers */
5847 if (target_type1 && target_type2
5848 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5849 return comp_cv_qualification (target_type2, target_type1);
5851 /* Neither conversion sequence is better than the other. */
5855 /* The source type for this standard conversion sequence. */
5858 source_type (conversion *t)
5860 for (;; t = t->u.next)
5862 if (t->kind == ck_user
5863 || t->kind == ck_ambig
5864 || t->kind == ck_identity)
5870 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5871 a pointer to LOSER and re-running joust to produce the warning if WINNER
5872 is actually used. */
5875 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5877 candidate_warning *cw;
5879 cw = conversion_obstack_alloc (sizeof (candidate_warning));
5881 cw->next = winner->warnings;
5882 winner->warnings = cw;
5885 /* Compare two candidates for overloading as described in
5886 [over.match.best]. Return values:
5888 1: cand1 is better than cand2
5889 -1: cand2 is better than cand1
5890 0: cand1 and cand2 are indistinguishable */
5893 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5896 int off1 = 0, off2 = 0;
5900 /* Candidates that involve bad conversions are always worse than those
5902 if (cand1->viable > cand2->viable)
5904 if (cand1->viable < cand2->viable)
5907 /* If we have two pseudo-candidates for conversions to the same type,
5908 or two candidates for the same function, arbitrarily pick one. */
5909 if (cand1->fn == cand2->fn
5910 && (IS_TYPE_OR_DECL_P (cand1->fn)))
5913 /* a viable function F1
5914 is defined to be a better function than another viable function F2 if
5915 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5916 ICSi(F2), and then */
5918 /* for some argument j, ICSj(F1) is a better conversion sequence than
5921 /* For comparing static and non-static member functions, we ignore
5922 the implicit object parameter of the non-static function. The
5923 standard says to pretend that the static function has an object
5924 parm, but that won't work with operator overloading. */
5925 len = cand1->num_convs;
5926 if (len != cand2->num_convs)
5928 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
5929 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
5931 gcc_assert (static_1 != static_2);
5942 for (i = 0; i < len; ++i)
5944 conversion *t1 = cand1->convs[i + off1];
5945 conversion *t2 = cand2->convs[i + off2];
5946 int comp = compare_ics (t1, t2);
5951 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
5952 == cr_std + cr_promotion)
5953 && t1->kind == ck_std
5954 && t2->kind == ck_std
5955 && TREE_CODE (t1->type) == INTEGER_TYPE
5956 && TREE_CODE (t2->type) == INTEGER_TYPE
5957 && (TYPE_PRECISION (t1->type)
5958 == TYPE_PRECISION (t2->type))
5959 && (TYPE_UNSIGNED (t1->u.next->type)
5960 || (TREE_CODE (t1->u.next->type)
5963 tree type = t1->u.next->type;
5965 struct z_candidate *w, *l;
5967 type1 = t1->type, type2 = t2->type,
5968 w = cand1, l = cand2;
5970 type1 = t2->type, type2 = t1->type,
5971 w = cand2, l = cand1;
5975 warning ("passing %qT chooses %qT over %qT",
5976 type, type1, type2);
5977 warning (" in call to %qD", w->fn);
5983 if (winner && comp != winner)
5992 /* warn about confusing overload resolution for user-defined conversions,
5993 either between a constructor and a conversion op, or between two
5995 if (winner && warn_conversion && cand1->second_conv
5996 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5997 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5999 struct z_candidate *w, *l;
6000 bool give_warning = false;
6003 w = cand1, l = cand2;
6005 w = cand2, l = cand1;
6007 /* We don't want to complain about `X::operator T1 ()'
6008 beating `X::operator T2 () const', when T2 is a no less
6009 cv-qualified version of T1. */
6010 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6011 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6013 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6014 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6016 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6021 if (!comp_ptr_ttypes (t, f))
6022 give_warning = true;
6025 give_warning = true;
6031 tree source = source_type (w->convs[0]);
6032 if (! DECL_CONSTRUCTOR_P (w->fn))
6033 source = TREE_TYPE (source);
6034 warning ("choosing %qD over %qD", w->fn, l->fn);
6035 warning (" for conversion from %qT to %qT",
6036 source, w->second_conv->type);
6037 warning (" because conversion sequence for the argument is better");
6047 F1 is a non-template function and F2 is a template function
6050 if (!cand1->template_decl && cand2->template_decl)
6052 else if (cand1->template_decl && !cand2->template_decl)
6056 F1 and F2 are template functions and the function template for F1 is
6057 more specialized than the template for F2 according to the partial
6060 if (cand1->template_decl && cand2->template_decl)
6062 winner = more_specialized
6063 (TI_TEMPLATE (cand1->template_decl),
6064 TI_TEMPLATE (cand2->template_decl),
6066 /* Tell the deduction code how many real function arguments
6067 we saw, not counting the implicit 'this' argument. But,
6068 add_function_candidate() suppresses the "this" argument
6071 [temp.func.order]: The presence of unused ellipsis and default
6072 arguments has no effect on the partial ordering of function
6075 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
6076 - DECL_CONSTRUCTOR_P (cand1->fn)));
6082 the context is an initialization by user-defined conversion (see
6083 _dcl.init_ and _over.match.user_) and the standard conversion
6084 sequence from the return type of F1 to the destination type (i.e.,
6085 the type of the entity being initialized) is a better conversion
6086 sequence than the standard conversion sequence from the return type
6087 of F2 to the destination type. */
6089 if (cand1->second_conv)
6091 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6096 /* Check whether we can discard a builtin candidate, either because we
6097 have two identical ones or matching builtin and non-builtin candidates.
6099 (Pedantically in the latter case the builtin which matched the user
6100 function should not be added to the overload set, but we spot it here.
6103 ... the builtin candidates include ...
6104 - do not have the same parameter type list as any non-template
6105 non-member candidate. */
6107 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6108 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6110 for (i = 0; i < len; ++i)
6111 if (!same_type_p (cand1->convs[i]->type,
6112 cand2->convs[i]->type))
6114 if (i == cand1->num_convs)
6116 if (cand1->fn == cand2->fn)
6117 /* Two built-in candidates; arbitrarily pick one. */
6119 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6120 /* cand1 is built-in; prefer cand2. */
6123 /* cand2 is built-in; prefer cand1. */
6128 /* If the two functions are the same (this can happen with declarations
6129 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6130 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6131 && equal_functions (cand1->fn, cand2->fn))
6136 /* Extension: If the worst conversion for one candidate is worse than the
6137 worst conversion for the other, take the first. */
6140 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6141 struct z_candidate *w = 0, *l = 0;
6143 for (i = 0; i < len; ++i)
6145 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6146 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6147 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6148 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6151 winner = 1, w = cand1, l = cand2;
6153 winner = -1, w = cand2, l = cand1;
6159 ISO C++ says that these are ambiguous, even \
6160 though the worst conversion for the first is better than \
6161 the worst conversion for the second:");
6162 print_z_candidate (_("candidate 1:"), w);
6163 print_z_candidate (_("candidate 2:"), l);
6171 gcc_assert (!winner);
6175 /* Given a list of candidates for overloading, find the best one, if any.
6176 This algorithm has a worst case of O(2n) (winner is last), and a best
6177 case of O(n/2) (totally ambiguous); much better than a sorting
6180 static struct z_candidate *
6181 tourney (struct z_candidate *candidates)
6183 struct z_candidate *champ = candidates, *challenger;
6185 int champ_compared_to_predecessor = 0;
6187 /* Walk through the list once, comparing each current champ to the next
6188 candidate, knocking out a candidate or two with each comparison. */
6190 for (challenger = champ->next; challenger; )
6192 fate = joust (champ, challenger, 0);
6194 challenger = challenger->next;
6199 champ = challenger->next;
6202 champ_compared_to_predecessor = 0;
6207 champ_compared_to_predecessor = 1;
6210 challenger = champ->next;
6214 /* Make sure the champ is better than all the candidates it hasn't yet
6215 been compared to. */
6217 for (challenger = candidates;
6219 && !(champ_compared_to_predecessor && challenger->next == champ);
6220 challenger = challenger->next)
6222 fate = joust (champ, challenger, 0);
6230 /* Returns nonzero if things of type FROM can be converted to TO. */
6233 can_convert (tree to, tree from)
6235 return can_convert_arg (to, from, NULL_TREE);
6238 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6241 can_convert_arg (tree to, tree from, tree arg)
6247 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6248 p = conversion_obstack_alloc (0);
6250 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6251 ok_p = (t && !t->bad_p);
6253 /* Free all the conversions we allocated. */
6254 obstack_free (&conversion_obstack, p);
6259 /* Like can_convert_arg, but allows dubious conversions as well. */
6262 can_convert_arg_bad (tree to, tree from, tree arg)
6267 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6268 p = conversion_obstack_alloc (0);
6269 /* Try to perform the conversion. */
6270 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6271 /* Free all the conversions we allocated. */
6272 obstack_free (&conversion_obstack, p);
6277 /* Convert EXPR to TYPE. Return the converted expression.
6279 Note that we allow bad conversions here because by the time we get to
6280 this point we are committed to doing the conversion. If we end up
6281 doing a bad conversion, convert_like will complain. */
6284 perform_implicit_conversion (tree type, tree expr)
6289 if (error_operand_p (expr))
6290 return error_mark_node;
6292 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6293 p = conversion_obstack_alloc (0);
6295 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6299 error ("could not convert %qE to %qT", expr, type);
6300 expr = error_mark_node;
6303 expr = convert_like (conv, expr);
6305 /* Free all the conversions we allocated. */
6306 obstack_free (&conversion_obstack, p);
6311 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6312 permitted. If the conversion is valid, the converted expression is
6313 returned. Otherwise, NULL_TREE is returned, except in the case
6314 that TYPE is a class type; in that case, an error is issued. If
6315 C_CAST_P is true, then this direction initialization is taking
6316 place as part of a static_cast being attempted as part of a C-style
6320 perform_direct_initialization_if_possible (tree type,
6327 if (type == error_mark_node || error_operand_p (expr))
6328 return error_mark_node;
6331 If the destination type is a (possibly cv-qualified) class type:
6333 -- If the initialization is direct-initialization ...,
6334 constructors are considered. ... If no constructor applies, or
6335 the overload resolution is ambiguous, the initialization is
6337 if (CLASS_TYPE_P (type))
6339 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6340 build_tree_list (NULL_TREE, expr),
6341 type, LOOKUP_NORMAL);
6342 return build_cplus_new (type, expr);
6345 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6346 p = conversion_obstack_alloc (0);
6348 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6350 if (!conv || conv->bad_p)
6353 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6354 /*issue_conversion_warnings=*/false,
6357 /* Free all the conversions we allocated. */
6358 obstack_free (&conversion_obstack, p);
6363 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6364 is being bound to a temporary. Create and return a new VAR_DECL
6365 with the indicated TYPE; this variable will store the value to
6366 which the reference is bound. */
6369 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6373 /* Create the variable. */
6374 var = build_decl (VAR_DECL, NULL_TREE, type);
6375 DECL_ARTIFICIAL (var) = 1;
6376 TREE_USED (var) = 1;
6378 /* Register the variable. */
6379 if (TREE_STATIC (decl))
6381 /* Namespace-scope or local static; give it a mangled name. */
6384 TREE_STATIC (var) = 1;
6385 name = mangle_ref_init_variable (decl);
6386 DECL_NAME (var) = name;
6387 SET_DECL_ASSEMBLER_NAME (var, name);
6388 var = pushdecl_top_level (var);
6392 /* Create a new cleanup level if necessary. */
6393 maybe_push_cleanup_level (type);
6394 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6395 DECL_CONTEXT (var) = current_function_decl;
6401 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6402 initializing a variable of that TYPE. If DECL is non-NULL, it is
6403 the VAR_DECL being initialized with the EXPR. (In that case, the
6404 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6405 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6406 return, if *CLEANUP is no longer NULL, it will be an expression
6407 that should be pushed as a cleanup after the returned expression
6408 is used to initialize DECL.
6410 Return the converted expression. */
6413 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6418 if (type == error_mark_node || error_operand_p (expr))
6419 return error_mark_node;
6421 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6422 p = conversion_obstack_alloc (0);
6424 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6425 if (!conv || conv->bad_p)
6427 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6428 && !real_lvalue_p (expr))
6429 error ("invalid initialization of non-const reference of "
6430 "type %qT from a temporary of type %qT",
6431 type, TREE_TYPE (expr));
6433 error ("invalid initialization of reference of type "
6434 "%qT from expression of type %qT", type,
6436 return error_mark_node;
6439 /* If DECL is non-NULL, then this special rule applies:
6443 The temporary to which the reference is bound or the temporary
6444 that is the complete object to which the reference is bound
6445 persists for the lifetime of the reference.
6447 The temporaries created during the evaluation of the expression
6448 initializing the reference, except the temporary to which the
6449 reference is bound, are destroyed at the end of the
6450 full-expression in which they are created.
6452 In that case, we store the converted expression into a new
6453 VAR_DECL in a new scope.
6455 However, we want to be careful not to create temporaries when
6456 they are not required. For example, given:
6459 struct D : public B {};
6463 there is no need to copy the return value from "f"; we can just
6464 extend its lifetime. Similarly, given:
6467 struct T { operator S(); };
6471 we can extend the lifetime of the return value of the conversion
6473 gcc_assert (conv->kind == ck_ref_bind);
6477 tree base_conv_type;
6479 /* Skip over the REF_BIND. */
6480 conv = conv->u.next;
6481 /* If the next conversion is a BASE_CONV, skip that too -- but
6482 remember that the conversion was required. */
6483 if (conv->kind == ck_base)
6485 if (conv->check_copy_constructor_p)
6486 check_constructor_callable (TREE_TYPE (expr), expr);
6487 base_conv_type = conv->type;
6488 conv = conv->u.next;
6491 base_conv_type = NULL_TREE;
6492 /* Perform the remainder of the conversion. */
6493 expr = convert_like_real (conv, expr,
6494 /*fn=*/NULL_TREE, /*argnum=*/0,
6496 /*issue_conversion_warnings=*/true,
6497 /*c_cast_p=*/false);
6498 if (!real_lvalue_p (expr))
6503 /* Create the temporary variable. */
6504 type = TREE_TYPE (expr);
6505 var = make_temporary_var_for_ref_to_temp (decl, type);
6506 layout_decl (var, 0);
6507 /* If the rvalue is the result of a function call it will be
6508 a TARGET_EXPR. If it is some other construct (such as a
6509 member access expression where the underlying object is
6510 itself the result of a function call), turn it into a
6511 TARGET_EXPR here. It is important that EXPR be a
6512 TARGET_EXPR below since otherwise the INIT_EXPR will
6513 attempt to make a bitwise copy of EXPR to initialize
6515 if (TREE_CODE (expr) != TARGET_EXPR)
6516 expr = get_target_expr (expr);
6517 /* Create the INIT_EXPR that will initialize the temporary
6519 init = build2 (INIT_EXPR, type, var, expr);
6520 if (at_function_scope_p ())
6522 add_decl_expr (var);
6523 *cleanup = cxx_maybe_build_cleanup (var);
6525 /* We must be careful to destroy the temporary only
6526 after its initialization has taken place. If the
6527 initialization throws an exception, then the
6528 destructor should not be run. We cannot simply
6529 transform INIT into something like:
6531 (INIT, ({ CLEANUP_STMT; }))
6533 because emit_local_var always treats the
6534 initializer as a full-expression. Thus, the
6535 destructor would run too early; it would run at the
6536 end of initializing the reference variable, rather
6537 than at the end of the block enclosing the
6540 The solution is to pass back a cleanup expression
6541 which the caller is responsible for attaching to
6542 the statement tree. */
6546 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6547 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6548 static_aggregates = tree_cons (NULL_TREE, var,
6551 /* Use its address to initialize the reference variable. */
6552 expr = build_address (var);
6554 expr = convert_to_base (expr,
6555 build_pointer_type (base_conv_type),
6556 /*check_access=*/true,
6558 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6561 /* Take the address of EXPR. */
6562 expr = build_unary_op (ADDR_EXPR, expr, 0);
6563 /* If a BASE_CONV was required, perform it now. */
6565 expr = (perform_implicit_conversion
6566 (build_pointer_type (base_conv_type), expr));
6567 expr = build_nop (type, expr);
6570 /* Perform the conversion. */
6571 expr = convert_like (conv, expr);
6573 /* Free all the conversions we allocated. */
6574 obstack_free (&conversion_obstack, p);
6579 #include "gt-cp-call.h"