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 if (DECL_INTEGRAL_CONSTANT_VAR_P (t))
432 t = decl_constant_value (t);
434 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
439 /* Returns nonzero if PARMLIST consists of only default parms and/or
443 sufficient_parms_p (tree parmlist)
445 for (; parmlist && parmlist != void_list_node;
446 parmlist = TREE_CHAIN (parmlist))
447 if (!TREE_PURPOSE (parmlist))
452 /* Allocate N bytes of memory from the conversion obstack. The memory
453 is zeroed before being returned. */
456 conversion_obstack_alloc (size_t n)
459 if (!conversion_obstack_initialized)
461 gcc_obstack_init (&conversion_obstack);
462 conversion_obstack_initialized = true;
464 p = obstack_alloc (&conversion_obstack, n);
469 /* Dynamically allocate a conversion. */
472 alloc_conversion (conversion_kind kind)
475 c = conversion_obstack_alloc (sizeof (conversion));
480 #ifdef ENABLE_CHECKING
482 /* Make sure that all memory on the conversion obstack has been
486 validate_conversion_obstack (void)
488 if (conversion_obstack_initialized)
489 gcc_assert ((obstack_next_free (&conversion_obstack)
490 == obstack_base (&conversion_obstack)));
493 #endif /* ENABLE_CHECKING */
495 /* Dynamically allocate an array of N conversions. */
498 alloc_conversions (size_t n)
500 return conversion_obstack_alloc (n * sizeof (conversion *));
504 build_conv (conversion_kind code, tree type, conversion *from)
507 conversion_rank rank = CONVERSION_RANK (from);
509 /* We can't use buildl1 here because CODE could be USER_CONV, which
510 takes two arguments. In that case, the caller is responsible for
511 filling in the second argument. */
512 t = alloc_conversion (code);
535 t->user_conv_p = (code == ck_user || from->user_conv_p);
536 t->bad_p = from->bad_p;
541 /* Build a representation of the identity conversion from EXPR to
542 itself. The TYPE should match the the type of EXPR, if EXPR is
546 build_identity_conv (tree type, tree expr)
550 c = alloc_conversion (ck_identity);
557 /* Converting from EXPR to TYPE was ambiguous in the sense that there
558 were multiple user-defined conversions to accomplish the job.
559 Build a conversion that indicates that ambiguity. */
562 build_ambiguous_conv (tree type, tree expr)
566 c = alloc_conversion (ck_ambig);
574 strip_top_quals (tree t)
576 if (TREE_CODE (t) == ARRAY_TYPE)
578 return cp_build_qualified_type (t, 0);
581 /* Returns the standard conversion path (see [conv]) from type FROM to type
582 TO, if any. For proper handling of null pointer constants, you must
583 also pass the expression EXPR to convert from. */
586 standard_conversion (tree to, tree from, tree expr, int flags)
588 enum tree_code fcode, tcode;
590 bool fromref = false;
592 to = non_reference (to);
593 if (TREE_CODE (from) == REFERENCE_TYPE)
596 from = TREE_TYPE (from);
598 to = strip_top_quals (to);
599 from = strip_top_quals (from);
601 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
602 && expr && type_unknown_p (expr))
604 expr = instantiate_type (to, expr, tf_conv);
605 if (expr == error_mark_node)
607 from = TREE_TYPE (expr);
610 fcode = TREE_CODE (from);
611 tcode = TREE_CODE (to);
613 conv = build_identity_conv (from, expr);
614 if (fcode == FUNCTION_TYPE)
616 from = build_pointer_type (from);
617 fcode = TREE_CODE (from);
618 conv = build_conv (ck_lvalue, from, conv);
620 else if (fcode == ARRAY_TYPE)
622 from = build_pointer_type (TREE_TYPE (from));
623 fcode = TREE_CODE (from);
624 conv = build_conv (ck_lvalue, from, conv);
626 else if (fromref || (expr && lvalue_p (expr)))
627 conv = build_conv (ck_rvalue, from, conv);
629 /* Allow conversion between `__complex__' data types. */
630 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
632 /* The standard conversion sequence to convert FROM to TO is
633 the standard conversion sequence to perform componentwise
635 conversion *part_conv = standard_conversion
636 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, flags);
640 conv = build_conv (part_conv->kind, to, conv);
641 conv->rank = part_conv->rank;
649 if (same_type_p (from, to))
652 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
653 && expr && null_ptr_cst_p (expr))
654 conv = build_conv (ck_std, to, conv);
655 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
656 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
658 /* For backwards brain damage compatibility, allow interconversion of
659 pointers and integers with a pedwarn. */
660 conv = build_conv (ck_std, to, conv);
663 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
665 /* For backwards brain damage compatibility, allow interconversion of
666 enums and integers with a pedwarn. */
667 conv = build_conv (ck_std, to, conv);
670 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
671 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
676 if (tcode == POINTER_TYPE
677 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
680 else if (VOID_TYPE_P (TREE_TYPE (to))
681 && !TYPE_PTRMEM_P (from)
682 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
684 from = build_pointer_type
685 (cp_build_qualified_type (void_type_node,
686 cp_type_quals (TREE_TYPE (from))));
687 conv = build_conv (ck_ptr, from, conv);
689 else if (TYPE_PTRMEM_P (from))
691 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
692 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
694 if (DERIVED_FROM_P (fbase, tbase)
695 && (same_type_ignoring_top_level_qualifiers_p
696 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
697 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
699 from = build_ptrmem_type (tbase,
700 TYPE_PTRMEM_POINTED_TO_TYPE (from));
701 conv = build_conv (ck_pmem, from, conv);
703 else if (!same_type_p (fbase, tbase))
706 else if (IS_AGGR_TYPE (TREE_TYPE (from))
707 && IS_AGGR_TYPE (TREE_TYPE (to))
710 An rvalue of type "pointer to cv D," where D is a
711 class type, can be converted to an rvalue of type
712 "pointer to cv B," where B is a base class (clause
713 _class.derived_) of D. If B is an inaccessible
714 (clause _class.access_) or ambiguous
715 (_class.member.lookup_) base class of D, a program
716 that necessitates this conversion is ill-formed.
717 Therefore, we use DERIVED_FROM_P, and do not check
718 access or uniqueness. */
719 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
722 cp_build_qualified_type (TREE_TYPE (to),
723 cp_type_quals (TREE_TYPE (from)));
724 from = build_pointer_type (from);
725 conv = build_conv (ck_ptr, from, conv);
729 if (tcode == POINTER_TYPE)
731 to_pointee = TREE_TYPE (to);
732 from_pointee = TREE_TYPE (from);
736 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
737 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
740 if (same_type_p (from, to))
742 else if (comp_ptr_ttypes (to_pointee, from_pointee))
743 conv = build_conv (ck_qual, to, conv);
744 else if (expr && string_conv_p (to, expr, 0))
745 /* converting from string constant to char *. */
746 conv = build_conv (ck_qual, to, conv);
747 else if (ptr_reasonably_similar (to_pointee, from_pointee))
749 conv = build_conv (ck_ptr, to, conv);
757 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
759 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
760 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
761 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
762 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
764 if (!DERIVED_FROM_P (fbase, tbase)
765 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
766 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
767 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
768 || cp_type_quals (fbase) != cp_type_quals (tbase))
771 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
772 from = build_method_type_directly (from,
774 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
775 from = build_ptrmemfunc_type (build_pointer_type (from));
776 conv = build_conv (ck_pmem, from, conv);
779 else if (tcode == BOOLEAN_TYPE)
783 An rvalue of arithmetic, enumeration, pointer, or pointer to
784 member type can be converted to an rvalue of type bool. */
785 if (ARITHMETIC_TYPE_P (from)
786 || fcode == ENUMERAL_TYPE
787 || fcode == POINTER_TYPE
788 || TYPE_PTR_TO_MEMBER_P (from))
790 conv = build_conv (ck_std, to, conv);
791 if (fcode == POINTER_TYPE
792 || TYPE_PTRMEM_P (from)
793 || (TYPE_PTRMEMFUNC_P (from)
794 && conv->rank < cr_pbool))
795 conv->rank = cr_pbool;
801 /* We don't check for ENUMERAL_TYPE here because there are no standard
802 conversions to enum type. */
803 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
804 || tcode == REAL_TYPE)
806 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
808 conv = build_conv (ck_std, to, conv);
810 /* Give this a better rank if it's a promotion. */
811 if (same_type_p (to, type_promotes_to (from))
812 && conv->u.next->rank <= cr_promotion)
813 conv->rank = cr_promotion;
815 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
816 && vector_types_convertible_p (from, to))
817 return build_conv (ck_std, to, conv);
818 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
819 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
820 && is_properly_derived_from (from, to))
822 if (conv->kind == ck_rvalue)
824 conv = build_conv (ck_base, to, conv);
825 /* The derived-to-base conversion indicates the initialization
826 of a parameter with base type from an object of a derived
827 type. A temporary object is created to hold the result of
829 conv->need_temporary_p = true;
837 /* Returns nonzero if T1 is reference-related to T2. */
840 reference_related_p (tree t1, tree t2)
842 t1 = TYPE_MAIN_VARIANT (t1);
843 t2 = TYPE_MAIN_VARIANT (t2);
847 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
848 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
850 return (same_type_p (t1, t2)
851 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
852 && DERIVED_FROM_P (t1, t2)));
855 /* Returns nonzero if T1 is reference-compatible with T2. */
858 reference_compatible_p (tree t1, tree t2)
862 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
863 reference-related to T2 and cv1 is the same cv-qualification as,
864 or greater cv-qualification than, cv2. */
865 return (reference_related_p (t1, t2)
866 && at_least_as_qualified_p (t1, t2));
869 /* Determine whether or not the EXPR (of class type S) can be
870 converted to T as in [over.match.ref]. */
873 convert_class_to_reference (tree t, tree s, tree expr)
879 struct z_candidate *candidates;
880 struct z_candidate *cand;
883 conversions = lookup_conversions (s);
889 Assuming that "cv1 T" is the underlying type of the reference
890 being initialized, and "cv S" is the type of the initializer
891 expression, with S a class type, the candidate functions are
894 --The conversion functions of S and its base classes are
895 considered. Those that are not hidden within S and yield type
896 "reference to cv2 T2", where "cv1 T" is reference-compatible
897 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
899 The argument list has one argument, which is the initializer
904 /* Conceptually, we should take the address of EXPR and put it in
905 the argument list. Unfortunately, however, that can result in
906 error messages, which we should not issue now because we are just
907 trying to find a conversion operator. Therefore, we use NULL,
908 cast to the appropriate type. */
909 arglist = build_int_cst (build_pointer_type (s), 0);
910 arglist = build_tree_list (NULL_TREE, arglist);
912 reference_type = build_reference_type (t);
916 tree fns = TREE_VALUE (conversions);
918 for (; fns; fns = OVL_NEXT (fns))
920 tree f = OVL_CURRENT (fns);
921 tree t2 = TREE_TYPE (TREE_TYPE (f));
925 /* If this is a template function, try to get an exact
927 if (TREE_CODE (f) == TEMPLATE_DECL)
929 cand = add_template_candidate (&candidates,
935 TREE_PURPOSE (conversions),
941 /* Now, see if the conversion function really returns
942 an lvalue of the appropriate type. From the
943 point of view of unification, simply returning an
944 rvalue of the right type is good enough. */
946 t2 = TREE_TYPE (TREE_TYPE (f));
947 if (TREE_CODE (t2) != REFERENCE_TYPE
948 || !reference_compatible_p (t, TREE_TYPE (t2)))
950 candidates = candidates->next;
955 else if (TREE_CODE (t2) == REFERENCE_TYPE
956 && reference_compatible_p (t, TREE_TYPE (t2)))
957 cand = add_function_candidate (&candidates, f, s, arglist,
959 TREE_PURPOSE (conversions),
964 conversion *identity_conv;
965 /* Build a standard conversion sequence indicating the
966 binding from the reference type returned by the
967 function to the desired REFERENCE_TYPE. */
969 = build_identity_conv (TREE_TYPE (TREE_TYPE
970 (TREE_TYPE (cand->fn))),
973 = (direct_reference_binding
974 (reference_type, identity_conv));
975 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
978 conversions = TREE_CHAIN (conversions);
981 candidates = splice_viable (candidates, pedantic, &any_viable_p);
982 /* If none of the conversion functions worked out, let our caller
987 cand = tourney (candidates);
991 /* Now that we know that this is the function we're going to use fix
992 the dummy first argument. */
993 cand->args = tree_cons (NULL_TREE,
995 TREE_CHAIN (cand->args));
997 /* Build a user-defined conversion sequence representing the
999 conv = build_conv (ck_user,
1000 TREE_TYPE (TREE_TYPE (cand->fn)),
1001 build_identity_conv (TREE_TYPE (expr), expr));
1004 /* Merge it with the standard conversion sequence from the
1005 conversion function's return type to the desired type. */
1006 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1008 if (cand->viable == -1)
1011 return cand->second_conv;
1014 /* A reference of the indicated TYPE is being bound directly to the
1015 expression represented by the implicit conversion sequence CONV.
1016 Return a conversion sequence for this binding. */
1019 direct_reference_binding (tree type, conversion *conv)
1023 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1024 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1026 t = TREE_TYPE (type);
1030 When a parameter of reference type binds directly
1031 (_dcl.init.ref_) to an argument expression, the implicit
1032 conversion sequence is the identity conversion, unless the
1033 argument expression has a type that is a derived class of the
1034 parameter type, in which case the implicit conversion sequence is
1035 a derived-to-base Conversion.
1037 If the parameter binds directly to the result of applying a
1038 conversion function to the argument expression, the implicit
1039 conversion sequence is a user-defined conversion sequence
1040 (_over.ics.user_), with the second standard conversion sequence
1041 either an identity conversion or, if the conversion function
1042 returns an entity of a type that is a derived class of the
1043 parameter type, a derived-to-base conversion. */
1044 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1046 /* Represent the derived-to-base conversion. */
1047 conv = build_conv (ck_base, t, conv);
1048 /* We will actually be binding to the base-class subobject in
1049 the derived class, so we mark this conversion appropriately.
1050 That way, convert_like knows not to generate a temporary. */
1051 conv->need_temporary_p = false;
1053 return build_conv (ck_ref_bind, type, conv);
1056 /* Returns the conversion path from type FROM to reference type TO for
1057 purposes of reference binding. For lvalue binding, either pass a
1058 reference type to FROM or an lvalue expression to EXPR. If the
1059 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1060 the conversion returned. */
1063 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1065 conversion *conv = NULL;
1066 tree to = TREE_TYPE (rto);
1070 cp_lvalue_kind lvalue_p = clk_none;
1072 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1074 expr = instantiate_type (to, expr, tf_none);
1075 if (expr == error_mark_node)
1077 from = TREE_TYPE (expr);
1080 if (TREE_CODE (from) == REFERENCE_TYPE)
1082 /* Anything with reference type is an lvalue. */
1083 lvalue_p = clk_ordinary;
1084 from = TREE_TYPE (from);
1087 lvalue_p = real_lvalue_p (expr);
1089 /* Figure out whether or not the types are reference-related and
1090 reference compatible. We have do do this after stripping
1091 references from FROM. */
1092 related_p = reference_related_p (to, from);
1093 compatible_p = reference_compatible_p (to, from);
1095 if (lvalue_p && compatible_p)
1099 If the initializer expression
1101 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1102 is reference-compatible with "cv2 T2,"
1104 the reference is bound directly to the initializer expression
1106 conv = build_identity_conv (from, expr);
1107 conv = direct_reference_binding (rto, conv);
1108 if ((lvalue_p & clk_bitfield) != 0
1109 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1110 /* For the purposes of overload resolution, we ignore the fact
1111 this expression is a bitfield or packed field. (In particular,
1112 [over.ics.ref] says specifically that a function with a
1113 non-const reference parameter is viable even if the
1114 argument is a bitfield.)
1116 However, when we actually call the function we must create
1117 a temporary to which to bind the reference. If the
1118 reference is volatile, or isn't const, then we cannot make
1119 a temporary, so we just issue an error when the conversion
1121 conv->need_temporary_p = true;
1125 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1129 If the initializer expression
1131 -- has a class type (i.e., T2 is a class type) can be
1132 implicitly converted to an lvalue of type "cv3 T3," where
1133 "cv1 T1" is reference-compatible with "cv3 T3". (this
1134 conversion is selected by enumerating the applicable
1135 conversion functions (_over.match.ref_) and choosing the
1136 best one through overload resolution. (_over.match_).
1138 the reference is bound to the lvalue result of the conversion
1139 in the second case. */
1140 conv = convert_class_to_reference (to, from, expr);
1145 /* From this point on, we conceptually need temporaries, even if we
1146 elide them. Only the cases above are "direct bindings". */
1147 if (flags & LOOKUP_NO_TEMP_BIND)
1152 When a parameter of reference type is not bound directly to an
1153 argument expression, the conversion sequence is the one required
1154 to convert the argument expression to the underlying type of the
1155 reference according to _over.best.ics_. Conceptually, this
1156 conversion sequence corresponds to copy-initializing a temporary
1157 of the underlying type with the argument expression. Any
1158 difference in top-level cv-qualification is subsumed by the
1159 initialization itself and does not constitute a conversion. */
1163 Otherwise, the reference shall be to a non-volatile const type. */
1164 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1169 If the initializer expression is an rvalue, with T2 a class type,
1170 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1171 is bound in one of the following ways:
1173 -- The reference is bound to the object represented by the rvalue
1174 or to a sub-object within that object.
1178 We use the first alternative. The implicit conversion sequence
1179 is supposed to be same as we would obtain by generating a
1180 temporary. Fortunately, if the types are reference compatible,
1181 then this is either an identity conversion or the derived-to-base
1182 conversion, just as for direct binding. */
1183 if (CLASS_TYPE_P (from) && compatible_p)
1185 conv = build_identity_conv (from, expr);
1186 conv = direct_reference_binding (rto, conv);
1187 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1188 conv->u.next->check_copy_constructor_p = true;
1194 Otherwise, a temporary of type "cv1 T1" is created and
1195 initialized from the initializer expression using the rules for a
1196 non-reference copy initialization. If T1 is reference-related to
1197 T2, cv1 must be the same cv-qualification as, or greater
1198 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1199 if (related_p && !at_least_as_qualified_p (to, from))
1202 conv = implicit_conversion (to, from, expr, flags);
1206 conv = build_conv (ck_ref_bind, rto, conv);
1207 /* This reference binding, unlike those above, requires the
1208 creation of a temporary. */
1209 conv->need_temporary_p = true;
1214 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1215 to type TO. The optional expression EXPR may affect the conversion.
1216 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1220 implicit_conversion (tree to, tree from, tree expr, int flags)
1224 if (from == error_mark_node || to == error_mark_node
1225 || expr == error_mark_node)
1228 if (TREE_CODE (to) == REFERENCE_TYPE)
1229 conv = reference_binding (to, from, expr, flags);
1231 conv = standard_conversion (to, from, expr, flags);
1236 if (expr != NULL_TREE
1237 && (IS_AGGR_TYPE (from)
1238 || IS_AGGR_TYPE (to))
1239 && (flags & LOOKUP_NO_CONVERSION) == 0)
1241 struct z_candidate *cand;
1243 cand = build_user_type_conversion_1
1244 (to, expr, LOOKUP_ONLYCONVERTING);
1246 conv = cand->second_conv;
1248 /* We used to try to bind a reference to a temporary here, but that
1249 is now handled by the recursive call to this function at the end
1250 of reference_binding. */
1257 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1260 static struct z_candidate *
1261 add_candidate (struct z_candidate **candidates,
1263 size_t num_convs, conversion **convs,
1264 tree access_path, tree conversion_path,
1267 struct z_candidate *cand
1268 = conversion_obstack_alloc (sizeof (struct z_candidate));
1272 cand->convs = convs;
1273 cand->num_convs = num_convs;
1274 cand->access_path = access_path;
1275 cand->conversion_path = conversion_path;
1276 cand->viable = viable;
1277 cand->next = *candidates;
1283 /* Create an overload candidate for the function or method FN called with
1284 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1285 to implicit_conversion.
1287 CTYPE, if non-NULL, is the type we want to pretend this function
1288 comes from for purposes of overload resolution. */
1290 static struct z_candidate *
1291 add_function_candidate (struct z_candidate **candidates,
1292 tree fn, tree ctype, tree arglist,
1293 tree access_path, tree conversion_path,
1296 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1299 tree parmnode, argnode;
1303 /* Built-in functions that haven't been declared don't really
1305 if (DECL_ANTICIPATED (fn))
1308 /* The `this', `in_chrg' and VTT arguments to constructors are not
1309 considered in overload resolution. */
1310 if (DECL_CONSTRUCTOR_P (fn))
1312 parmlist = skip_artificial_parms_for (fn, parmlist);
1313 orig_arglist = arglist;
1314 arglist = skip_artificial_parms_for (fn, arglist);
1317 orig_arglist = arglist;
1319 len = list_length (arglist);
1320 convs = alloc_conversions (len);
1322 /* 13.3.2 - Viable functions [over.match.viable]
1323 First, to be a viable function, a candidate function shall have enough
1324 parameters to agree in number with the arguments in the list.
1326 We need to check this first; otherwise, checking the ICSes might cause
1327 us to produce an ill-formed template instantiation. */
1329 parmnode = parmlist;
1330 for (i = 0; i < len; ++i)
1332 if (parmnode == NULL_TREE || parmnode == void_list_node)
1334 parmnode = TREE_CHAIN (parmnode);
1337 if (i < len && parmnode)
1340 /* Make sure there are default args for the rest of the parms. */
1341 else if (!sufficient_parms_p (parmnode))
1347 /* Second, for F to be a viable function, there shall exist for each
1348 argument an implicit conversion sequence that converts that argument
1349 to the corresponding parameter of F. */
1351 parmnode = parmlist;
1354 for (i = 0; i < len; ++i)
1356 tree arg = TREE_VALUE (argnode);
1357 tree argtype = lvalue_type (arg);
1361 if (parmnode == void_list_node)
1364 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1365 && ! DECL_CONSTRUCTOR_P (fn));
1369 tree parmtype = TREE_VALUE (parmnode);
1371 /* The type of the implicit object parameter ('this') for
1372 overload resolution is not always the same as for the
1373 function itself; conversion functions are considered to
1374 be members of the class being converted, and functions
1375 introduced by a using-declaration are considered to be
1376 members of the class that uses them.
1378 Since build_over_call ignores the ICS for the `this'
1379 parameter, we can just change the parm type. */
1380 if (ctype && is_this)
1383 = build_qualified_type (ctype,
1384 TYPE_QUALS (TREE_TYPE (parmtype)));
1385 parmtype = build_pointer_type (parmtype);
1388 t = implicit_conversion (parmtype, argtype, arg, flags);
1392 t = build_identity_conv (argtype, arg);
1393 t->ellipsis_p = true;
1410 parmnode = TREE_CHAIN (parmnode);
1411 argnode = TREE_CHAIN (argnode);
1415 return add_candidate (candidates, fn, orig_arglist, len, convs,
1416 access_path, conversion_path, viable);
1419 /* Create an overload candidate for the conversion function FN which will
1420 be invoked for expression OBJ, producing a pointer-to-function which
1421 will in turn be called with the argument list ARGLIST, and add it to
1422 CANDIDATES. FLAGS is passed on to implicit_conversion.
1424 Actually, we don't really care about FN; we care about the type it
1425 converts to. There may be multiple conversion functions that will
1426 convert to that type, and we rely on build_user_type_conversion_1 to
1427 choose the best one; so when we create our candidate, we record the type
1428 instead of the function. */
1430 static struct z_candidate *
1431 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1432 tree arglist, tree access_path, tree conversion_path)
1434 tree totype = TREE_TYPE (TREE_TYPE (fn));
1435 int i, len, viable, flags;
1436 tree parmlist, parmnode, argnode;
1439 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1440 parmlist = TREE_TYPE (parmlist);
1441 parmlist = TYPE_ARG_TYPES (parmlist);
1443 len = list_length (arglist) + 1;
1444 convs = alloc_conversions (len);
1445 parmnode = parmlist;
1448 flags = LOOKUP_NORMAL;
1450 /* Don't bother looking up the same type twice. */
1451 if (*candidates && (*candidates)->fn == totype)
1454 for (i = 0; i < len; ++i)
1456 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1457 tree argtype = lvalue_type (arg);
1461 t = implicit_conversion (totype, argtype, arg, flags);
1462 else if (parmnode == void_list_node)
1465 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1468 t = build_identity_conv (argtype, arg);
1469 t->ellipsis_p = true;
1483 parmnode = TREE_CHAIN (parmnode);
1484 argnode = TREE_CHAIN (argnode);
1490 if (!sufficient_parms_p (parmnode))
1493 return add_candidate (candidates, totype, arglist, len, convs,
1494 access_path, conversion_path, viable);
1498 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1499 tree type1, tree type2, tree *args, tree *argtypes,
1511 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1512 convs = alloc_conversions (num_convs);
1514 for (i = 0; i < 2; ++i)
1519 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1523 /* We need something for printing the candidate. */
1524 t = build_identity_conv (types[i], NULL_TREE);
1531 /* For COND_EXPR we rearranged the arguments; undo that now. */
1534 convs[2] = convs[1];
1535 convs[1] = convs[0];
1536 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1543 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1545 /*access_path=*/NULL_TREE,
1546 /*conversion_path=*/NULL_TREE,
1551 is_complete (tree t)
1553 return COMPLETE_TYPE_P (complete_type (t));
1556 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1559 promoted_arithmetic_type_p (tree type)
1563 In this section, the term promoted integral type is used to refer
1564 to those integral types which are preserved by integral promotion
1565 (including e.g. int and long but excluding e.g. char).
1566 Similarly, the term promoted arithmetic type refers to promoted
1567 integral types plus floating types. */
1568 return ((INTEGRAL_TYPE_P (type)
1569 && same_type_p (type_promotes_to (type), type))
1570 || TREE_CODE (type) == REAL_TYPE);
1573 /* Create any builtin operator overload candidates for the operator in
1574 question given the converted operand types TYPE1 and TYPE2. The other
1575 args are passed through from add_builtin_candidates to
1576 build_builtin_candidate.
1578 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1579 If CODE is requires candidates operands of the same type of the kind
1580 of which TYPE1 and TYPE2 are, we add both candidates
1581 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1584 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1585 enum tree_code code2, tree fnname, tree type1,
1586 tree type2, tree *args, tree *argtypes, int flags)
1590 case POSTINCREMENT_EXPR:
1591 case POSTDECREMENT_EXPR:
1592 args[1] = integer_zero_node;
1593 type2 = integer_type_node;
1602 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1603 and VQ is either volatile or empty, there exist candidate operator
1604 functions of the form
1605 VQ T& operator++(VQ T&);
1606 T operator++(VQ T&, int);
1607 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1608 type other than bool, and VQ is either volatile or empty, there exist
1609 candidate operator functions of the form
1610 VQ T& operator--(VQ T&);
1611 T operator--(VQ T&, int);
1612 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1613 complete object type, and VQ is either volatile or empty, there exist
1614 candidate operator functions of the form
1615 T*VQ& operator++(T*VQ&);
1616 T*VQ& operator--(T*VQ&);
1617 T* operator++(T*VQ&, int);
1618 T* operator--(T*VQ&, int); */
1620 case POSTDECREMENT_EXPR:
1621 case PREDECREMENT_EXPR:
1622 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1624 case POSTINCREMENT_EXPR:
1625 case PREINCREMENT_EXPR:
1626 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1628 type1 = build_reference_type (type1);
1633 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1634 exist candidate operator functions of the form
1638 8 For every function type T, there exist candidate operator functions of
1640 T& operator*(T*); */
1643 if (TREE_CODE (type1) == POINTER_TYPE
1644 && (TYPE_PTROB_P (type1)
1645 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1649 /* 9 For every type T, there exist candidate operator functions of the form
1652 10For every promoted arithmetic type T, there exist candidate operator
1653 functions of the form
1657 case CONVERT_EXPR: /* unary + */
1658 if (TREE_CODE (type1) == POINTER_TYPE)
1661 if (ARITHMETIC_TYPE_P (type1))
1665 /* 11For every promoted integral type T, there exist candidate operator
1666 functions of the form
1670 if (INTEGRAL_TYPE_P (type1))
1674 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1675 is the same type as C2 or is a derived class of C2, T is a complete
1676 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1677 there exist candidate operator functions of the form
1678 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1679 where CV12 is the union of CV1 and CV2. */
1682 if (TREE_CODE (type1) == POINTER_TYPE
1683 && TYPE_PTR_TO_MEMBER_P (type2))
1685 tree c1 = TREE_TYPE (type1);
1686 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1688 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1689 && (TYPE_PTRMEMFUNC_P (type2)
1690 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1695 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1696 didate operator functions of the form
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 bool operator!=(L, R);
1707 where LR is the result of the usual arithmetic conversions between
1710 14For every pair of types T and I, where T is a cv-qualified or cv-
1711 unqualified complete object type and I is a promoted integral type,
1712 there exist candidate operator functions of the form
1713 T* operator+(T*, I);
1714 T& operator[](T*, I);
1715 T* operator-(T*, I);
1716 T* operator+(I, T*);
1717 T& operator[](I, T*);
1719 15For every T, where T is a pointer to complete object type, there exist
1720 candidate operator functions of the form112)
1721 ptrdiff_t operator-(T, T);
1723 16For every pointer or enumeration type T, there exist candidate operator
1724 functions of the form
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);
1730 bool operator!=(T, T);
1732 17For every pointer to member type T, there exist candidate operator
1733 functions of the form
1734 bool operator==(T, T);
1735 bool operator!=(T, T); */
1738 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1740 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1742 type2 = ptrdiff_type_node;
1746 case TRUNC_DIV_EXPR:
1747 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1753 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1754 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1756 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1761 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1773 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1775 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1777 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1779 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1784 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1792 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1795 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1797 type1 = ptrdiff_type_node;
1800 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1802 type2 = ptrdiff_type_node;
1807 /* 18For every pair of promoted integral types L and R, there exist candi-
1808 date operator functions of the form
1815 where LR is the result of the usual arithmetic conversions between
1818 case TRUNC_MOD_EXPR:
1824 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1828 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1829 type, VQ is either volatile or empty, and R is a promoted arithmetic
1830 type, there exist candidate operator functions of the form
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);
1835 VQ L& operator-=(VQ L&, R);
1837 20For every pair T, VQ), where T is any type and VQ is either volatile
1838 or empty, there exist candidate operator functions of the form
1839 T*VQ& operator=(T*VQ&, T*);
1841 21For every pair T, VQ), where T is a pointer to member type and VQ is
1842 either volatile or empty, there exist candidate operator functions of
1844 VQ T& operator=(VQ T&, T);
1846 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1847 unqualified complete object type, VQ is either volatile or empty, and
1848 I is a promoted integral type, there exist candidate operator func-
1850 T*VQ& operator+=(T*VQ&, I);
1851 T*VQ& operator-=(T*VQ&, I);
1853 23For every triple L, VQ, R), where L is an integral or enumeration
1854 type, VQ is either volatile or empty, and R is a promoted integral
1855 type, there exist candidate operator functions of the form
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);
1862 VQ L& operator|=(VQ L&, R); */
1869 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1871 type2 = ptrdiff_type_node;
1875 case TRUNC_DIV_EXPR:
1876 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1880 case TRUNC_MOD_EXPR:
1886 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1891 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1893 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1894 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1895 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1896 || ((TYPE_PTRMEMFUNC_P (type1)
1897 || TREE_CODE (type1) == POINTER_TYPE)
1898 && null_ptr_cst_p (args[1])))
1908 type1 = build_reference_type (type1);
1914 For every pair of promoted arithmetic types L and R, there
1915 exist candidate operator functions of the form
1917 LR operator?(bool, L, R);
1919 where LR is the result of the usual arithmetic conversions
1920 between types L and R.
1922 For every type T, where T is a pointer or pointer-to-member
1923 type, there exist candidate operator functions of the form T
1924 operator?(bool, T, T); */
1926 if (promoted_arithmetic_type_p (type1)
1927 && promoted_arithmetic_type_p (type2))
1931 /* Otherwise, the types should be pointers. */
1932 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1933 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1936 /* We don't check that the two types are the same; the logic
1937 below will actually create two candidates; one in which both
1938 parameter types are TYPE1, and one in which both parameter
1946 /* If we're dealing with two pointer types or two enumeral types,
1947 we need candidates for both of them. */
1948 if (type2 && !same_type_p (type1, type2)
1949 && TREE_CODE (type1) == TREE_CODE (type2)
1950 && (TREE_CODE (type1) == REFERENCE_TYPE
1951 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1952 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1953 || TYPE_PTRMEMFUNC_P (type1)
1954 || IS_AGGR_TYPE (type1)
1955 || TREE_CODE (type1) == ENUMERAL_TYPE))
1957 build_builtin_candidate
1958 (candidates, fnname, type1, type1, args, argtypes, flags);
1959 build_builtin_candidate
1960 (candidates, fnname, type2, type2, args, argtypes, flags);
1964 build_builtin_candidate
1965 (candidates, fnname, type1, type2, args, argtypes, flags);
1969 type_decays_to (tree type)
1971 if (TREE_CODE (type) == ARRAY_TYPE)
1972 return build_pointer_type (TREE_TYPE (type));
1973 if (TREE_CODE (type) == FUNCTION_TYPE)
1974 return build_pointer_type (type);
1978 /* There are three conditions of builtin candidates:
1980 1) bool-taking candidates. These are the same regardless of the input.
1981 2) pointer-pair taking candidates. These are generated for each type
1982 one of the input types converts to.
1983 3) arithmetic candidates. According to the standard, we should generate
1984 all of these, but I'm trying not to...
1986 Here we generate a superset of the possible candidates for this particular
1987 case. That is a subset of the full set the standard defines, plus some
1988 other cases which the standard disallows. add_builtin_candidate will
1989 filter out the invalid set. */
1992 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
1993 enum tree_code code2, tree fnname, tree *args,
1998 tree type, argtypes[3];
1999 /* TYPES[i] is the set of possible builtin-operator parameter types
2000 we will consider for the Ith argument. These are represented as
2001 a TREE_LIST; the TREE_VALUE of each node is the potential
2005 for (i = 0; i < 3; ++i)
2008 argtypes[i] = lvalue_type (args[i]);
2010 argtypes[i] = NULL_TREE;
2015 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2016 and VQ is either volatile or empty, there exist candidate operator
2017 functions of the form
2018 VQ T& operator++(VQ T&); */
2020 case POSTINCREMENT_EXPR:
2021 case PREINCREMENT_EXPR:
2022 case POSTDECREMENT_EXPR:
2023 case PREDECREMENT_EXPR:
2028 /* 24There also exist candidate operator functions of the form
2029 bool operator!(bool);
2030 bool operator&&(bool, bool);
2031 bool operator||(bool, bool); */
2033 case TRUTH_NOT_EXPR:
2034 build_builtin_candidate
2035 (candidates, fnname, boolean_type_node,
2036 NULL_TREE, args, argtypes, flags);
2039 case TRUTH_ORIF_EXPR:
2040 case TRUTH_ANDIF_EXPR:
2041 build_builtin_candidate
2042 (candidates, fnname, boolean_type_node,
2043 boolean_type_node, args, argtypes, flags);
2065 types[0] = types[1] = NULL_TREE;
2067 for (i = 0; i < 2; ++i)
2071 else if (IS_AGGR_TYPE (argtypes[i]))
2075 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2078 convs = lookup_conversions (argtypes[i]);
2080 if (code == COND_EXPR)
2082 if (real_lvalue_p (args[i]))
2083 types[i] = tree_cons
2084 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2086 types[i] = tree_cons
2087 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2093 for (; convs; convs = TREE_CHAIN (convs))
2095 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2098 && (TREE_CODE (type) != REFERENCE_TYPE
2099 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2102 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2103 types[i] = tree_cons (NULL_TREE, type, types[i]);
2105 type = non_reference (type);
2106 if (i != 0 || ! ref1)
2108 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2109 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2110 types[i] = tree_cons (NULL_TREE, type, types[i]);
2111 if (INTEGRAL_TYPE_P (type))
2112 type = type_promotes_to (type);
2115 if (! value_member (type, types[i]))
2116 types[i] = tree_cons (NULL_TREE, type, types[i]);
2121 if (code == COND_EXPR && real_lvalue_p (args[i]))
2122 types[i] = tree_cons
2123 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2124 type = non_reference (argtypes[i]);
2125 if (i != 0 || ! ref1)
2127 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2128 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2129 types[i] = tree_cons (NULL_TREE, type, types[i]);
2130 if (INTEGRAL_TYPE_P (type))
2131 type = type_promotes_to (type);
2133 types[i] = tree_cons (NULL_TREE, type, types[i]);
2137 /* Run through the possible parameter types of both arguments,
2138 creating candidates with those parameter types. */
2139 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2142 for (type = types[1]; type; type = TREE_CHAIN (type))
2143 add_builtin_candidate
2144 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2145 TREE_VALUE (type), args, argtypes, flags);
2147 add_builtin_candidate
2148 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2149 NULL_TREE, args, argtypes, flags);
2156 /* If TMPL can be successfully instantiated as indicated by
2157 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2159 TMPL is the template. EXPLICIT_TARGS are any explicit template
2160 arguments. ARGLIST is the arguments provided at the call-site.
2161 The RETURN_TYPE is the desired type for conversion operators. If
2162 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2163 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2164 add_conv_candidate. */
2166 static struct z_candidate*
2167 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2168 tree ctype, tree explicit_targs, tree arglist,
2169 tree return_type, tree access_path,
2170 tree conversion_path, int flags, tree obj,
2171 unification_kind_t strict)
2173 int ntparms = DECL_NTPARMS (tmpl);
2174 tree targs = make_tree_vec (ntparms);
2175 tree args_without_in_chrg = arglist;
2176 struct z_candidate *cand;
2180 /* We don't do deduction on the in-charge parameter, the VTT
2181 parameter or 'this'. */
2182 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2183 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2185 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2186 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2187 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2188 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2190 i = fn_type_unification (tmpl, explicit_targs, targs,
2191 args_without_in_chrg,
2192 return_type, strict, -1);
2197 fn = instantiate_template (tmpl, targs, tf_none);
2198 if (fn == error_mark_node)
2203 A member function template is never instantiated to perform the
2204 copy of a class object to an object of its class type.
2206 It's a little unclear what this means; the standard explicitly
2207 does allow a template to be used to copy a class. For example,
2212 template <class T> A(const T&);
2215 void g () { A a (f ()); }
2217 the member template will be used to make the copy. The section
2218 quoted above appears in the paragraph that forbids constructors
2219 whose only parameter is (a possibly cv-qualified variant of) the
2220 class type, and a logical interpretation is that the intent was
2221 to forbid the instantiation of member templates which would then
2223 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2225 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2226 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2231 if (obj != NULL_TREE)
2232 /* Aha, this is a conversion function. */
2233 cand = add_conv_candidate (candidates, fn, obj, access_path,
2234 conversion_path, arglist);
2236 cand = add_function_candidate (candidates, fn, ctype,
2237 arglist, access_path,
2238 conversion_path, flags);
2239 if (DECL_TI_TEMPLATE (fn) != tmpl)
2240 /* This situation can occur if a member template of a template
2241 class is specialized. Then, instantiate_template might return
2242 an instantiation of the specialization, in which case the
2243 DECL_TI_TEMPLATE field will point at the original
2244 specialization. For example:
2246 template <class T> struct S { template <class U> void f(U);
2247 template <> void f(int) {}; };
2251 Here, TMPL will be template <class U> S<double>::f(U).
2252 And, instantiate template will give us the specialization
2253 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2254 for this will point at template <class T> template <> S<T>::f(int),
2255 so that we can find the definition. For the purposes of
2256 overload resolution, however, we want the original TMPL. */
2257 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2259 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2265 static struct z_candidate *
2266 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2267 tree explicit_targs, tree arglist, tree return_type,
2268 tree access_path, tree conversion_path, int flags,
2269 unification_kind_t strict)
2272 add_template_candidate_real (candidates, tmpl, ctype,
2273 explicit_targs, arglist, return_type,
2274 access_path, conversion_path,
2275 flags, NULL_TREE, strict);
2279 static struct z_candidate *
2280 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2281 tree obj, tree arglist, tree return_type,
2282 tree access_path, tree conversion_path)
2285 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2286 arglist, return_type, access_path,
2287 conversion_path, 0, obj, DEDUCE_CONV);
2290 /* The CANDS are the set of candidates that were considered for
2291 overload resolution. Return the set of viable candidates. If none
2292 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2293 is true if a candidate should be considered viable only if it is
2296 static struct z_candidate*
2297 splice_viable (struct z_candidate *cands,
2301 struct z_candidate *viable;
2302 struct z_candidate **last_viable;
2303 struct z_candidate **cand;
2306 last_viable = &viable;
2307 *any_viable_p = false;
2312 struct z_candidate *c = *cand;
2313 if (strict_p ? c->viable == 1 : c->viable)
2318 last_viable = &c->next;
2319 *any_viable_p = true;
2325 return viable ? viable : cands;
2329 any_strictly_viable (struct z_candidate *cands)
2331 for (; cands; cands = cands->next)
2332 if (cands->viable == 1)
2338 build_this (tree obj)
2340 /* Fix this to work on non-lvalues. */
2341 return build_unary_op (ADDR_EXPR, obj, 0);
2344 /* Returns true iff functions are equivalent. Equivalent functions are
2345 not '==' only if one is a function-local extern function or if
2346 both are extern "C". */
2349 equal_functions (tree fn1, tree fn2)
2351 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2352 || DECL_EXTERN_C_FUNCTION_P (fn1))
2353 return decls_match (fn1, fn2);
2357 /* Print information about one overload candidate CANDIDATE. MSGSTR
2358 is the text to print before the candidate itself.
2360 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2361 to have been run through gettext by the caller. This wart makes
2362 life simpler in print_z_candidates and for the translators. */
2365 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2367 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2369 if (candidate->num_convs == 3)
2370 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2371 candidate->convs[0]->type,
2372 candidate->convs[1]->type,
2373 candidate->convs[2]->type);
2374 else if (candidate->num_convs == 2)
2375 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2376 candidate->convs[0]->type,
2377 candidate->convs[1]->type);
2379 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2380 candidate->convs[0]->type);
2382 else if (TYPE_P (candidate->fn))
2383 inform ("%s %T <conversion>", msgstr, candidate->fn);
2384 else if (candidate->viable == -1)
2385 inform ("%J%s %+#D <near match>", candidate->fn, msgstr, candidate->fn);
2387 inform ("%J%s %+#D", candidate->fn, msgstr, candidate->fn);
2391 print_z_candidates (struct z_candidate *candidates)
2394 struct z_candidate *cand1;
2395 struct z_candidate **cand2;
2397 /* There may be duplicates in the set of candidates. We put off
2398 checking this condition as long as possible, since we have no way
2399 to eliminate duplicates from a set of functions in less than n^2
2400 time. Now we are about to emit an error message, so it is more
2401 permissible to go slowly. */
2402 for (cand1 = candidates; cand1; cand1 = cand1->next)
2404 tree fn = cand1->fn;
2405 /* Skip builtin candidates and conversion functions. */
2406 if (TREE_CODE (fn) != FUNCTION_DECL)
2408 cand2 = &cand1->next;
2411 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2412 && equal_functions (fn, (*cand2)->fn))
2413 *cand2 = (*cand2)->next;
2415 cand2 = &(*cand2)->next;
2422 str = _("candidates are:");
2423 print_z_candidate (str, candidates);
2424 if (candidates->next)
2426 /* Indent successive candidates by the width of the translation
2427 of the above string. */
2428 size_t len = gcc_gettext_width (str) + 1;
2429 char *spaces = alloca (len);
2430 memset (spaces, ' ', len-1);
2431 spaces[len - 1] = '\0';
2433 candidates = candidates->next;
2436 print_z_candidate (spaces, candidates);
2437 candidates = candidates->next;
2443 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2444 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2445 the result of the conversion function to convert it to the final
2446 desired type. Merge the the two sequences into a single sequence,
2447 and return the merged sequence. */
2450 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2454 gcc_assert (user_seq->kind == ck_user);
2456 /* Find the end of the second conversion sequence. */
2458 while ((*t)->kind != ck_identity)
2459 t = &((*t)->u.next);
2461 /* Replace the identity conversion with the user conversion
2465 /* The entire sequence is a user-conversion sequence. */
2466 std_seq->user_conv_p = true;
2471 /* Returns the best overload candidate to perform the requested
2472 conversion. This function is used for three the overloading situations
2473 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2474 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2475 per [dcl.init.ref], so we ignore temporary bindings. */
2477 static struct z_candidate *
2478 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2480 struct z_candidate *candidates, *cand;
2481 tree fromtype = TREE_TYPE (expr);
2482 tree ctors = NULL_TREE;
2483 tree conv_fns = NULL_TREE;
2484 conversion *conv = NULL;
2485 tree args = NULL_TREE;
2488 /* We represent conversion within a hierarchy using RVALUE_CONV and
2489 BASE_CONV, as specified by [over.best.ics]; these become plain
2490 constructor calls, as specified in [dcl.init]. */
2491 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2492 || !DERIVED_FROM_P (totype, fromtype));
2494 if (IS_AGGR_TYPE (totype))
2495 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2497 if (IS_AGGR_TYPE (fromtype))
2498 conv_fns = lookup_conversions (fromtype);
2501 flags |= LOOKUP_NO_CONVERSION;
2507 ctors = BASELINK_FUNCTIONS (ctors);
2509 t = build_int_cst (build_pointer_type (totype), 0);
2510 args = build_tree_list (NULL_TREE, expr);
2511 /* We should never try to call the abstract or base constructor
2513 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2514 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2515 args = tree_cons (NULL_TREE, t, args);
2517 for (; ctors; ctors = OVL_NEXT (ctors))
2519 tree ctor = OVL_CURRENT (ctors);
2520 if (DECL_NONCONVERTING_P (ctor))
2523 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2524 cand = add_template_candidate (&candidates, ctor, totype,
2525 NULL_TREE, args, NULL_TREE,
2526 TYPE_BINFO (totype),
2527 TYPE_BINFO (totype),
2531 cand = add_function_candidate (&candidates, ctor, totype,
2532 args, TYPE_BINFO (totype),
2533 TYPE_BINFO (totype),
2537 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2541 args = build_tree_list (NULL_TREE, build_this (expr));
2543 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2546 tree conversion_path = TREE_PURPOSE (conv_fns);
2547 int convflags = LOOKUP_NO_CONVERSION;
2549 /* If we are called to convert to a reference type, we are trying to
2550 find an lvalue binding, so don't even consider temporaries. If
2551 we don't find an lvalue binding, the caller will try again to
2552 look for a temporary binding. */
2553 if (TREE_CODE (totype) == REFERENCE_TYPE)
2554 convflags |= LOOKUP_NO_TEMP_BIND;
2556 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2558 tree fn = OVL_CURRENT (fns);
2560 /* [over.match.funcs] For conversion functions, the function
2561 is considered to be a member of the class of the implicit
2562 object argument for the purpose of defining the type of
2563 the implicit object parameter.
2565 So we pass fromtype as CTYPE to add_*_candidate. */
2567 if (TREE_CODE (fn) == TEMPLATE_DECL)
2568 cand = add_template_candidate (&candidates, fn, fromtype,
2571 TYPE_BINFO (fromtype),
2576 cand = add_function_candidate (&candidates, fn, fromtype,
2578 TYPE_BINFO (fromtype),
2585 = implicit_conversion (totype,
2586 TREE_TYPE (TREE_TYPE (cand->fn)),
2589 cand->second_conv = ics;
2593 else if (candidates->viable == 1 && ics->bad_p)
2599 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2603 cand = tourney (candidates);
2606 if (flags & LOOKUP_COMPLAIN)
2608 error ("conversion from %qT to %qT is ambiguous",
2610 print_z_candidates (candidates);
2613 cand = candidates; /* any one will do */
2614 cand->second_conv = build_ambiguous_conv (totype, expr);
2615 cand->second_conv->user_conv_p = true;
2616 if (!any_strictly_viable (candidates))
2617 cand->second_conv->bad_p = true;
2618 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2619 ambiguous conversion is no worse than another user-defined
2625 /* Build the user conversion sequence. */
2628 (DECL_CONSTRUCTOR_P (cand->fn)
2629 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2630 build_identity_conv (TREE_TYPE (expr), expr));
2633 /* Combine it with the second conversion sequence. */
2634 cand->second_conv = merge_conversion_sequences (conv,
2637 if (cand->viable == -1)
2638 cand->second_conv->bad_p = true;
2644 build_user_type_conversion (tree totype, tree expr, int flags)
2646 struct z_candidate *cand
2647 = build_user_type_conversion_1 (totype, expr, flags);
2651 if (cand->second_conv->kind == ck_ambig)
2652 return error_mark_node;
2653 return convert_from_reference (convert_like (cand->second_conv, expr));
2658 /* Do any initial processing on the arguments to a function call. */
2661 resolve_args (tree args)
2664 for (t = args; t; t = TREE_CHAIN (t))
2666 tree arg = TREE_VALUE (t);
2668 if (arg == error_mark_node)
2669 return error_mark_node;
2670 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2672 error ("invalid use of void expression");
2673 return error_mark_node;
2675 arg = convert_from_reference (arg);
2676 TREE_VALUE (t) = arg;
2681 /* Perform overload resolution on FN, which is called with the ARGS.
2683 Return the candidate function selected by overload resolution, or
2684 NULL if the event that overload resolution failed. In the case
2685 that overload resolution fails, *CANDIDATES will be the set of
2686 candidates considered, and ANY_VIABLE_P will be set to true or
2687 false to indicate whether or not any of the candidates were
2690 The ARGS should already have gone through RESOLVE_ARGS before this
2691 function is called. */
2693 static struct z_candidate *
2694 perform_overload_resolution (tree fn,
2696 struct z_candidate **candidates,
2699 struct z_candidate *cand;
2700 tree explicit_targs = NULL_TREE;
2701 int template_only = 0;
2704 *any_viable_p = true;
2706 /* Check FN and ARGS. */
2707 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2708 || TREE_CODE (fn) == TEMPLATE_DECL
2709 || TREE_CODE (fn) == OVERLOAD
2710 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2711 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2713 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2715 explicit_targs = TREE_OPERAND (fn, 1);
2716 fn = TREE_OPERAND (fn, 0);
2720 /* Add the various candidate functions. */
2721 add_candidates (fn, args, explicit_targs, template_only,
2722 /*conversion_path=*/NULL_TREE,
2723 /*access_path=*/NULL_TREE,
2727 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2731 cand = tourney (*candidates);
2735 /* Return an expression for a call to FN (a namespace-scope function,
2736 or a static member function) with the ARGS. */
2739 build_new_function_call (tree fn, tree args)
2741 struct z_candidate *candidates, *cand;
2746 args = resolve_args (args);
2747 if (args == error_mark_node)
2748 return error_mark_node;
2750 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2751 p = conversion_obstack_alloc (0);
2753 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2757 if (!any_viable_p && candidates && ! candidates->next)
2758 return build_function_call (candidates->fn, args);
2759 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2760 fn = TREE_OPERAND (fn, 0);
2762 error ("no matching function for call to %<%D(%A)%>",
2763 DECL_NAME (OVL_CURRENT (fn)), args);
2765 error ("call of overloaded %<%D(%A)%> is ambiguous",
2766 DECL_NAME (OVL_CURRENT (fn)), args);
2768 print_z_candidates (candidates);
2769 result = error_mark_node;
2772 result = build_over_call (cand, LOOKUP_NORMAL);
2774 /* Free all the conversions we allocated. */
2775 obstack_free (&conversion_obstack, p);
2780 /* Build a call to a global operator new. FNNAME is the name of the
2781 operator (either "operator new" or "operator new[]") and ARGS are
2782 the arguments provided. *SIZE points to the total number of bytes
2783 required by the allocation, and is updated if that is changed here.
2784 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2785 function determines that no cookie should be used, after all,
2786 *COOKIE_SIZE is set to NULL_TREE. */
2789 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2792 struct z_candidate *candidates;
2793 struct z_candidate *cand;
2796 args = tree_cons (NULL_TREE, *size, args);
2797 args = resolve_args (args);
2798 if (args == error_mark_node)
2805 If this lookup fails to find the name, or if the allocated type
2806 is not a class type, the allocation function's name is looked
2807 up in the global scope.
2809 we disregard block-scope declarations of "operator new". */
2810 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2812 /* Figure out what function is being called. */
2813 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2815 /* If no suitable function could be found, issue an error message
2820 error ("no matching function for call to %<%D(%A)%>",
2821 DECL_NAME (OVL_CURRENT (fns)), args);
2823 error ("call of overloaded %<%D(%A)%> is ambiguous",
2824 DECL_NAME (OVL_CURRENT (fns)), args);
2826 print_z_candidates (candidates);
2827 return error_mark_node;
2830 /* If a cookie is required, add some extra space. Whether
2831 or not a cookie is required cannot be determined until
2832 after we know which function was called. */
2835 bool use_cookie = true;
2836 if (!abi_version_at_least (2))
2838 tree placement = TREE_CHAIN (args);
2839 /* In G++ 3.2, the check was implemented incorrectly; it
2840 looked at the placement expression, rather than the
2841 type of the function. */
2842 if (placement && !TREE_CHAIN (placement)
2843 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2851 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2852 /* Skip the size_t parameter. */
2853 arg_types = TREE_CHAIN (arg_types);
2854 /* Check the remaining parameters (if any). */
2856 && TREE_CHAIN (arg_types) == void_list_node
2857 && same_type_p (TREE_VALUE (arg_types),
2861 /* If we need a cookie, adjust the number of bytes allocated. */
2864 /* Update the total size. */
2865 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2866 /* Update the argument list to reflect the adjusted size. */
2867 TREE_VALUE (args) = *size;
2870 *cookie_size = NULL_TREE;
2873 /* Build the CALL_EXPR. */
2874 return build_over_call (cand, LOOKUP_NORMAL);
2878 build_object_call (tree obj, tree args)
2880 struct z_candidate *candidates = 0, *cand;
2881 tree fns, convs, mem_args = NULL_TREE;
2882 tree type = TREE_TYPE (obj);
2884 tree result = NULL_TREE;
2887 if (TYPE_PTRMEMFUNC_P (type))
2889 /* It's no good looking for an overloaded operator() on a
2890 pointer-to-member-function. */
2891 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2892 return error_mark_node;
2895 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2896 if (fns == error_mark_node)
2897 return error_mark_node;
2899 args = resolve_args (args);
2901 if (args == error_mark_node)
2902 return error_mark_node;
2904 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2905 p = conversion_obstack_alloc (0);
2909 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2910 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2912 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2914 tree fn = OVL_CURRENT (fns);
2915 if (TREE_CODE (fn) == TEMPLATE_DECL)
2916 add_template_candidate (&candidates, fn, base, NULL_TREE,
2917 mem_args, NULL_TREE,
2920 LOOKUP_NORMAL, DEDUCE_CALL);
2922 add_function_candidate
2923 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2924 TYPE_BINFO (type), LOOKUP_NORMAL);
2928 convs = lookup_conversions (type);
2930 for (; convs; convs = TREE_CHAIN (convs))
2932 tree fns = TREE_VALUE (convs);
2933 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2935 if ((TREE_CODE (totype) == POINTER_TYPE
2936 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2937 || (TREE_CODE (totype) == REFERENCE_TYPE
2938 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2939 || (TREE_CODE (totype) == REFERENCE_TYPE
2940 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2941 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
2942 for (; fns; fns = OVL_NEXT (fns))
2944 tree fn = OVL_CURRENT (fns);
2945 if (TREE_CODE (fn) == TEMPLATE_DECL)
2946 add_template_conv_candidate
2947 (&candidates, fn, obj, args, totype,
2948 /*access_path=*/NULL_TREE,
2949 /*conversion_path=*/NULL_TREE);
2951 add_conv_candidate (&candidates, fn, obj, args,
2952 /*conversion_path=*/NULL_TREE,
2953 /*access_path=*/NULL_TREE);
2957 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2960 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
2961 print_z_candidates (candidates);
2962 result = error_mark_node;
2966 cand = tourney (candidates);
2969 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
2970 print_z_candidates (candidates);
2971 result = error_mark_node;
2973 /* Since cand->fn will be a type, not a function, for a conversion
2974 function, we must be careful not to unconditionally look at
2976 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
2977 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
2978 result = build_over_call (cand, LOOKUP_NORMAL);
2981 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
2982 result = build_function_call (obj, args);
2986 /* Free all the conversions we allocated. */
2987 obstack_free (&conversion_obstack, p);
2993 op_error (enum tree_code code, enum tree_code code2,
2994 tree arg1, tree arg2, tree arg3, const char *problem)
2998 if (code == MODIFY_EXPR)
2999 opname = assignment_operator_name_info[code2].name;
3001 opname = operator_name_info[code].name;
3006 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3007 problem, arg1, arg2, arg3);
3010 case POSTINCREMENT_EXPR:
3011 case POSTDECREMENT_EXPR:
3012 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3016 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3021 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3026 error ("%s for %<operator%s%> in %<%E %s %E%>",
3027 problem, opname, arg1, opname, arg2);
3029 error ("%s for %<operator%s%> in %<%s%E%>",
3030 problem, opname, opname, arg1);
3035 /* Return the implicit conversion sequence that could be used to
3036 convert E1 to E2 in [expr.cond]. */
3039 conditional_conversion (tree e1, tree e2)
3041 tree t1 = non_reference (TREE_TYPE (e1));
3042 tree t2 = non_reference (TREE_TYPE (e2));
3048 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3049 implicitly converted (clause _conv_) to the type "reference to
3050 T2", subject to the constraint that in the conversion the
3051 reference must bind directly (_dcl.init.ref_) to E1. */
3052 if (real_lvalue_p (e2))
3054 conv = implicit_conversion (build_reference_type (t2),
3057 LOOKUP_NO_TEMP_BIND);
3064 If E1 and E2 have class type, and the underlying class types are
3065 the same or one is a base class of the other: E1 can be converted
3066 to match E2 if the class of T2 is the same type as, or a base
3067 class of, the class of T1, and the cv-qualification of T2 is the
3068 same cv-qualification as, or a greater cv-qualification than, the
3069 cv-qualification of T1. If the conversion is applied, E1 is
3070 changed to an rvalue of type T2 that still refers to the original
3071 source class object (or the appropriate subobject thereof). */
3072 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3073 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3075 if (good_base && at_least_as_qualified_p (t2, t1))
3077 conv = build_identity_conv (t1, e1);
3078 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3079 TYPE_MAIN_VARIANT (t2)))
3080 conv = build_conv (ck_base, t2, conv);
3082 conv = build_conv (ck_rvalue, t2, conv);
3091 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3092 converted to the type that expression E2 would have if E2 were
3093 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3094 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3097 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3098 arguments to the conditional expression. */
3101 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3105 tree result = NULL_TREE;
3106 tree result_type = NULL_TREE;
3107 bool lvalue_p = true;
3108 struct z_candidate *candidates = 0;
3109 struct z_candidate *cand;
3112 /* As a G++ extension, the second argument to the conditional can be
3113 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3114 c'.) If the second operand is omitted, make sure it is
3115 calculated only once. */
3119 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3121 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3122 if (real_lvalue_p (arg1))
3123 arg2 = arg1 = stabilize_reference (arg1);
3125 arg2 = arg1 = save_expr (arg1);
3130 The first expr ession is implicitly converted to bool (clause
3132 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3134 /* If something has already gone wrong, just pass that fact up the
3136 if (error_operand_p (arg1)
3137 || error_operand_p (arg2)
3138 || error_operand_p (arg3))
3139 return error_mark_node;
3143 If either the second or the third operand has type (possibly
3144 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3145 array-to-pointer (_conv.array_), and function-to-pointer
3146 (_conv.func_) standard conversions are performed on the second
3147 and third operands. */
3148 arg2_type = TREE_TYPE (arg2);
3149 arg3_type = TREE_TYPE (arg3);
3150 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3152 /* Do the conversions. We don't these for `void' type arguments
3153 since it can't have any effect and since decay_conversion
3154 does not handle that case gracefully. */
3155 if (!VOID_TYPE_P (arg2_type))
3156 arg2 = decay_conversion (arg2);
3157 if (!VOID_TYPE_P (arg3_type))
3158 arg3 = decay_conversion (arg3);
3159 arg2_type = TREE_TYPE (arg2);
3160 arg3_type = TREE_TYPE (arg3);
3164 One of the following shall hold:
3166 --The second or the third operand (but not both) is a
3167 throw-expression (_except.throw_); the result is of the
3168 type of the other and is an rvalue.
3170 --Both the second and the third operands have type void; the
3171 result is of type void and is an rvalue.
3173 We must avoid calling force_rvalue for expressions of type
3174 "void" because it will complain that their value is being
3176 if (TREE_CODE (arg2) == THROW_EXPR
3177 && TREE_CODE (arg3) != THROW_EXPR)
3179 if (!VOID_TYPE_P (arg3_type))
3180 arg3 = force_rvalue (arg3);
3181 arg3_type = TREE_TYPE (arg3);
3182 result_type = arg3_type;
3184 else if (TREE_CODE (arg2) != THROW_EXPR
3185 && TREE_CODE (arg3) == THROW_EXPR)
3187 if (!VOID_TYPE_P (arg2_type))
3188 arg2 = force_rvalue (arg2);
3189 arg2_type = TREE_TYPE (arg2);
3190 result_type = arg2_type;
3192 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3193 result_type = void_type_node;
3196 error ("%qE has type %<void%> and is not a throw-expression",
3197 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3198 return error_mark_node;
3202 goto valid_operands;
3206 Otherwise, if the second and third operand have different types,
3207 and either has (possibly cv-qualified) class type, an attempt is
3208 made to convert each of those operands to the type of the other. */
3209 else if (!same_type_p (arg2_type, arg3_type)
3210 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3215 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3216 p = conversion_obstack_alloc (0);
3218 conv2 = conditional_conversion (arg2, arg3);
3219 conv3 = conditional_conversion (arg3, arg2);
3223 If both can be converted, or one can be converted but the
3224 conversion is ambiguous, the program is ill-formed. If
3225 neither can be converted, the operands are left unchanged and
3226 further checking is performed as described below. If exactly
3227 one conversion is possible, that conversion is applied to the
3228 chosen operand and the converted operand is used in place of
3229 the original operand for the remainder of this section. */
3230 if ((conv2 && !conv2->bad_p
3231 && conv3 && !conv3->bad_p)
3232 || (conv2 && conv2->kind == ck_ambig)
3233 || (conv3 && conv3->kind == ck_ambig))
3235 error ("operands to ?: have different types");
3236 result = error_mark_node;
3238 else if (conv2 && !conv2->bad_p)
3240 arg2 = convert_like (conv2, arg2);
3241 arg2 = convert_from_reference (arg2);
3242 arg2_type = TREE_TYPE (arg2);
3244 else if (conv3 && !conv3->bad_p)
3246 arg3 = convert_like (conv3, arg3);
3247 arg3 = convert_from_reference (arg3);
3248 arg3_type = TREE_TYPE (arg3);
3251 /* Free all the conversions we allocated. */
3252 obstack_free (&conversion_obstack, p);
3257 /* If, after the conversion, both operands have class type,
3258 treat the cv-qualification of both operands as if it were the
3259 union of the cv-qualification of the operands.
3261 The standard is not clear about what to do in this
3262 circumstance. For example, if the first operand has type
3263 "const X" and the second operand has a user-defined
3264 conversion to "volatile X", what is the type of the second
3265 operand after this step? Making it be "const X" (matching
3266 the first operand) seems wrong, as that discards the
3267 qualification without actually performing a copy. Leaving it
3268 as "volatile X" seems wrong as that will result in the
3269 conditional expression failing altogether, even though,
3270 according to this step, the one operand could be converted to
3271 the type of the other. */
3272 if ((conv2 || conv3)
3273 && CLASS_TYPE_P (arg2_type)
3274 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3275 arg2_type = arg3_type =
3276 cp_build_qualified_type (arg2_type,
3277 TYPE_QUALS (arg2_type)
3278 | TYPE_QUALS (arg3_type));
3283 If the second and third operands are lvalues and have the same
3284 type, the result is of that type and is an lvalue. */
3285 if (real_lvalue_p (arg2)
3286 && real_lvalue_p (arg3)
3287 && same_type_p (arg2_type, arg3_type))
3289 result_type = arg2_type;
3290 goto valid_operands;
3295 Otherwise, the result is an rvalue. If the second and third
3296 operand do not have the same type, and either has (possibly
3297 cv-qualified) class type, overload resolution is used to
3298 determine the conversions (if any) to be applied to the operands
3299 (_over.match.oper_, _over.built_). */
3301 if (!same_type_p (arg2_type, arg3_type)
3302 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3308 /* Rearrange the arguments so that add_builtin_candidate only has
3309 to know about two args. In build_builtin_candidates, the
3310 arguments are unscrambled. */
3314 add_builtin_candidates (&candidates,
3317 ansi_opname (COND_EXPR),
3323 If the overload resolution fails, the program is
3325 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3328 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3329 print_z_candidates (candidates);
3330 return error_mark_node;
3332 cand = tourney (candidates);
3335 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3336 print_z_candidates (candidates);
3337 return error_mark_node;
3342 Otherwise, the conversions thus determined are applied, and
3343 the converted operands are used in place of the original
3344 operands for the remainder of this section. */
3345 conv = cand->convs[0];
3346 arg1 = convert_like (conv, arg1);
3347 conv = cand->convs[1];
3348 arg2 = convert_like (conv, arg2);
3349 conv = cand->convs[2];
3350 arg3 = convert_like (conv, arg3);
3355 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3356 and function-to-pointer (_conv.func_) standard conversions are
3357 performed on the second and third operands.
3359 We need to force the lvalue-to-rvalue conversion here for class types,
3360 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3361 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3364 arg2 = force_rvalue (arg2);
3365 if (!CLASS_TYPE_P (arg2_type))
3366 arg2_type = TREE_TYPE (arg2);
3368 arg3 = force_rvalue (arg3);
3369 if (!CLASS_TYPE_P (arg2_type))
3370 arg3_type = TREE_TYPE (arg3);
3372 if (arg2 == error_mark_node || arg3 == error_mark_node)
3373 return error_mark_node;
3377 After those conversions, one of the following shall hold:
3379 --The second and third operands have the same type; the result is of
3381 if (same_type_p (arg2_type, arg3_type))
3382 result_type = arg2_type;
3385 --The second and third operands have arithmetic or enumeration
3386 type; the usual arithmetic conversions are performed to bring
3387 them to a common type, and the result is of that type. */
3388 else if ((ARITHMETIC_TYPE_P (arg2_type)
3389 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3390 && (ARITHMETIC_TYPE_P (arg3_type)
3391 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3393 /* In this case, there is always a common type. */
3394 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3397 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3398 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3399 warning ("enumeral mismatch in conditional expression: %qT vs %qT",
3400 arg2_type, arg3_type);
3401 else if (extra_warnings
3402 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3403 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3404 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3405 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3406 warning ("enumeral and non-enumeral type in conditional expression");
3408 arg2 = perform_implicit_conversion (result_type, arg2);
3409 arg3 = perform_implicit_conversion (result_type, arg3);
3413 --The second and third operands have pointer type, or one has
3414 pointer type and the other is a null pointer constant; pointer
3415 conversions (_conv.ptr_) and qualification conversions
3416 (_conv.qual_) are performed to bring them to their composite
3417 pointer type (_expr.rel_). The result is of the composite
3420 --The second and third operands have pointer to member type, or
3421 one has pointer to member type and the other is a null pointer
3422 constant; pointer to member conversions (_conv.mem_) and
3423 qualification conversions (_conv.qual_) are performed to bring
3424 them to a common type, whose cv-qualification shall match the
3425 cv-qualification of either the second or the third operand.
3426 The result is of the common type. */
3427 else if ((null_ptr_cst_p (arg2)
3428 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3429 || (null_ptr_cst_p (arg3)
3430 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3431 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3432 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3433 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3435 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3436 arg3, "conditional expression");
3437 if (result_type == error_mark_node)
3438 return error_mark_node;
3439 arg2 = perform_implicit_conversion (result_type, arg2);
3440 arg3 = perform_implicit_conversion (result_type, arg3);
3445 error ("operands to ?: have different types");
3446 return error_mark_node;
3450 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3452 /* We can't use result_type below, as fold might have returned a
3455 /* Expand both sides into the same slot, hopefully the target of the
3456 ?: expression. We used to check for TARGET_EXPRs here, but now we
3457 sometimes wrap them in NOP_EXPRs so the test would fail. */
3458 if (!lvalue_p && CLASS_TYPE_P (TREE_TYPE (result)))
3459 result = get_target_expr (result);
3461 /* If this expression is an rvalue, but might be mistaken for an
3462 lvalue, we must add a NON_LVALUE_EXPR. */
3463 if (!lvalue_p && real_lvalue_p (result))
3464 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3469 /* OPERAND is an operand to an expression. Perform necessary steps
3470 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3474 prep_operand (tree operand)
3478 operand = convert_from_reference (operand);
3479 if (CLASS_TYPE_P (TREE_TYPE (operand))
3480 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3481 /* Make sure the template type is instantiated now. */
3482 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3488 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3489 OVERLOAD) to the CANDIDATES, returning an updated list of
3490 CANDIDATES. The ARGS are the arguments provided to the call,
3491 without any implicit object parameter. The EXPLICIT_TARGS are
3492 explicit template arguments provided. TEMPLATE_ONLY is true if
3493 only template functions should be considered. CONVERSION_PATH,
3494 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3497 add_candidates (tree fns, tree args,
3498 tree explicit_targs, bool template_only,
3499 tree conversion_path, tree access_path,
3501 struct z_candidate **candidates)
3504 tree non_static_args;
3506 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3507 /* Delay creating the implicit this parameter until it is needed. */
3508 non_static_args = NULL_TREE;
3515 fn = OVL_CURRENT (fns);
3516 /* Figure out which set of arguments to use. */
3517 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3519 /* If this function is a non-static member, prepend the implicit
3520 object parameter. */
3521 if (!non_static_args)
3522 non_static_args = tree_cons (NULL_TREE,
3523 build_this (TREE_VALUE (args)),
3525 fn_args = non_static_args;
3528 /* Otherwise, just use the list of arguments provided. */
3531 if (TREE_CODE (fn) == TEMPLATE_DECL)
3532 add_template_candidate (candidates,
3542 else if (!template_only)
3543 add_function_candidate (candidates,
3550 fns = OVL_NEXT (fns);
3555 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3558 struct z_candidate *candidates = 0, *cand;
3559 tree arglist, fnname;
3561 tree result = NULL_TREE;
3562 bool result_valid_p = false;
3563 enum tree_code code2 = NOP_EXPR;
3569 if (error_operand_p (arg1)
3570 || error_operand_p (arg2)
3571 || error_operand_p (arg3))
3572 return error_mark_node;
3574 if (code == MODIFY_EXPR)
3576 code2 = TREE_CODE (arg3);
3578 fnname = ansi_assopname (code2);
3581 fnname = ansi_opname (code);
3583 arg1 = prep_operand (arg1);
3589 case VEC_DELETE_EXPR:
3591 /* Use build_op_new_call and build_op_delete_call instead. */
3595 return build_object_call (arg1, arg2);
3601 arg2 = prep_operand (arg2);
3602 arg3 = prep_operand (arg3);
3604 if (code == COND_EXPR)
3606 if (arg2 == NULL_TREE
3607 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3608 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3609 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3610 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3613 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3614 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3617 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3618 arg2 = integer_zero_node;
3620 arglist = NULL_TREE;
3622 arglist = tree_cons (NULL_TREE, arg3, arglist);
3624 arglist = tree_cons (NULL_TREE, arg2, arglist);
3625 arglist = tree_cons (NULL_TREE, arg1, arglist);
3627 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3628 p = conversion_obstack_alloc (0);
3630 /* Add namespace-scope operators to the list of functions to
3632 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3633 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3634 flags, &candidates);
3635 /* Add class-member operators to the candidate set. */
3636 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3640 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3641 if (fns == error_mark_node)
3643 result = error_mark_node;
3644 goto user_defined_result_ready;
3647 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3649 BASELINK_BINFO (fns),
3650 TYPE_BINFO (TREE_TYPE (arg1)),
3651 flags, &candidates);
3654 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3655 to know about two args; a builtin candidate will always have a first
3656 parameter of type bool. We'll handle that in
3657 build_builtin_candidate. */
3658 if (code == COND_EXPR)
3668 args[2] = NULL_TREE;
3671 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3677 /* For these, the built-in candidates set is empty
3678 [over.match.oper]/3. We don't want non-strict matches
3679 because exact matches are always possible with built-in
3680 operators. The built-in candidate set for COMPONENT_REF
3681 would be empty too, but since there are no such built-in
3682 operators, we accept non-strict matches for them. */
3687 strict_p = pedantic;
3691 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3696 case POSTINCREMENT_EXPR:
3697 case POSTDECREMENT_EXPR:
3698 /* Look for an `operator++ (int)'. If they didn't have
3699 one, then we fall back to the old way of doing things. */
3700 if (flags & LOOKUP_COMPLAIN)
3701 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3702 "trying prefix operator instead",
3704 operator_name_info[code].name);
3705 if (code == POSTINCREMENT_EXPR)
3706 code = PREINCREMENT_EXPR;
3708 code = PREDECREMENT_EXPR;
3709 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3713 /* The caller will deal with these. */
3718 result_valid_p = true;
3722 if (flags & LOOKUP_COMPLAIN)
3724 op_error (code, code2, arg1, arg2, arg3, "no match");
3725 print_z_candidates (candidates);
3727 result = error_mark_node;
3733 cand = tourney (candidates);
3736 if (flags & LOOKUP_COMPLAIN)
3738 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3739 print_z_candidates (candidates);
3741 result = error_mark_node;
3743 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3746 *overloaded_p = true;
3749 && fnname == ansi_assopname (NOP_EXPR)
3750 && DECL_ARTIFICIAL (cand->fn)
3752 && ! candidates->next->next)
3754 warning ("using synthesized %q#D for copy assignment",
3756 cp_warning_at (" where cfront would use %q#D",
3758 ? candidates->next->fn
3762 result = build_over_call (cand, LOOKUP_NORMAL);
3766 /* Give any warnings we noticed during overload resolution. */
3769 struct candidate_warning *w;
3770 for (w = cand->warnings; w; w = w->next)
3771 joust (cand, w->loser, 1);
3774 /* Check for comparison of different enum types. */
3783 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3784 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3785 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3786 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3788 warning ("comparison between %q#T and %q#T",
3789 TREE_TYPE (arg1), TREE_TYPE (arg2));
3796 /* We need to strip any leading REF_BIND so that bitfields
3797 don't cause errors. This should not remove any important
3798 conversions, because builtins don't apply to class
3799 objects directly. */
3800 conv = cand->convs[0];
3801 if (conv->kind == ck_ref_bind)
3802 conv = conv->u.next;
3803 arg1 = convert_like (conv, arg1);
3806 conv = cand->convs[1];
3807 if (conv->kind == ck_ref_bind)
3808 conv = conv->u.next;
3809 arg2 = convert_like (conv, arg2);
3813 conv = cand->convs[2];
3814 if (conv->kind == ck_ref_bind)
3815 conv = conv->u.next;
3816 arg3 = convert_like (conv, arg3);
3821 user_defined_result_ready:
3823 /* Free all the conversions we allocated. */
3824 obstack_free (&conversion_obstack, p);
3826 if (result || result_valid_p)
3833 return build_modify_expr (arg1, code2, arg2);
3836 return build_indirect_ref (arg1, "unary *");
3841 case TRUNC_DIV_EXPR:
3852 case TRUNC_MOD_EXPR:
3856 case TRUTH_ANDIF_EXPR:
3857 case TRUTH_ORIF_EXPR:
3858 return cp_build_binary_op (code, arg1, arg2);
3863 case TRUTH_NOT_EXPR:
3864 case PREINCREMENT_EXPR:
3865 case POSTINCREMENT_EXPR:
3866 case PREDECREMENT_EXPR:
3867 case POSTDECREMENT_EXPR:
3870 return build_unary_op (code, arg1, candidates != 0);
3873 return build_array_ref (arg1, arg2);
3876 return build_conditional_expr (arg1, arg2, arg3);
3879 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
3881 /* The caller will deal with these. */
3893 /* Build a call to operator delete. This has to be handled very specially,
3894 because the restrictions on what signatures match are different from all
3895 other call instances. For a normal delete, only a delete taking (void *)
3896 or (void *, size_t) is accepted. For a placement delete, only an exact
3897 match with the placement new is accepted.
3899 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3900 ADDR is the pointer to be deleted.
3901 SIZE is the size of the memory block to be deleted.
3902 GLOBAL_P is true if the delete-expression should not consider
3903 class-specific delete operators.
3904 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3907 build_op_delete_call (enum tree_code code, tree addr, tree size,
3908 bool global_p, tree placement)
3910 tree fn = NULL_TREE;
3911 tree fns, fnname, argtypes, args, type;
3914 if (addr == error_mark_node)
3915 return error_mark_node;
3917 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3919 fnname = ansi_opname (code);
3921 if (IS_AGGR_TYPE (type) && !global_p)
3924 If the result of the lookup is ambiguous or inaccessible, or if
3925 the lookup selects a placement deallocation function, the
3926 program is ill-formed.
3928 Therefore, we ask lookup_fnfields to complain about ambiguity. */
3930 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3931 if (fns == error_mark_node)
3932 return error_mark_node;
3937 if (fns == NULL_TREE)
3938 fns = lookup_name_nonclass (fnname);
3945 /* Find the allocation function that is being called. */
3946 call_expr = placement;
3947 /* Extract the function. */
3948 alloc_fn = get_callee_fndecl (call_expr);
3949 gcc_assert (alloc_fn != NULL_TREE);
3950 /* Then the second parm type. */
3951 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3952 /* Also the second argument. */
3953 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3957 /* First try it without the size argument. */
3958 argtypes = void_list_node;
3962 /* Strip const and volatile from addr. */
3963 addr = cp_convert (ptr_type_node, addr);
3965 /* We make two tries at finding a matching `operator delete'. On
3966 the first pass, we look for a one-operator (or placement)
3967 operator delete. If we're not doing placement delete, then on
3968 the second pass we look for a two-argument delete. */
3969 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
3971 /* Go through the `operator delete' functions looking for one
3972 with a matching type. */
3973 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
3979 /* The first argument must be "void *". */
3980 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3981 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3984 /* On the first pass, check the rest of the arguments. */
3990 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
3998 /* On the second pass, the second argument must be
4001 && same_type_p (TREE_VALUE (t), sizetype)
4002 && TREE_CHAIN (t) == void_list_node)
4006 /* If we found a match, we're done. */
4011 /* If we have a matching function, call it. */
4014 /* Make sure we have the actual function, and not an
4016 fn = OVL_CURRENT (fn);
4018 /* If the FN is a member function, make sure that it is
4020 if (DECL_CLASS_SCOPE_P (fn))
4021 perform_or_defer_access_check (TYPE_BINFO (type), fn);
4024 args = tree_cons (NULL_TREE, addr, args);
4026 args = tree_cons (NULL_TREE, addr,
4027 build_tree_list (NULL_TREE, size));
4031 /* The placement args might not be suitable for overload
4032 resolution at this point, so build the call directly. */
4034 return build_cxx_call (fn, args);
4037 return build_function_call (fn, args);
4040 /* If we are doing placement delete we do nothing if we don't find a
4041 matching op delete. */
4045 error ("no suitable %<operator %s> for %qT",
4046 operator_name_info[(int)code].name, type);
4047 return error_mark_node;
4050 /* If the current scope isn't allowed to access DECL along
4051 BASETYPE_PATH, give an error. The most derived class in
4052 BASETYPE_PATH is the one used to qualify DECL. */
4055 enforce_access (tree basetype_path, tree decl)
4057 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4059 if (!accessible_p (basetype_path, decl, true))
4061 if (TREE_PRIVATE (decl))
4062 cp_error_at ("%q+#D is private", decl);
4063 else if (TREE_PROTECTED (decl))
4064 cp_error_at ("%q+#D is protected", decl);
4066 cp_error_at ("%q+#D is inaccessible", decl);
4067 error ("within this context");
4074 /* Check that a callable constructor to initialize a temporary of
4075 TYPE from an EXPR exists. */
4078 check_constructor_callable (tree type, tree expr)
4080 build_special_member_call (NULL_TREE,
4081 complete_ctor_identifier,
4082 build_tree_list (NULL_TREE, expr),
4084 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4085 | LOOKUP_NO_CONVERSION
4086 | LOOKUP_CONSTRUCTOR_CALLABLE);
4089 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4090 bitwise or of LOOKUP_* values. If any errors are warnings are
4091 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4092 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4096 build_temp (tree expr, tree type, int flags,
4097 void (**diagnostic_fn)(const char *, ...))
4101 savew = warningcount, savee = errorcount;
4102 expr = build_special_member_call (NULL_TREE,
4103 complete_ctor_identifier,
4104 build_tree_list (NULL_TREE, expr),
4106 if (warningcount > savew)
4107 *diagnostic_fn = warning;
4108 else if (errorcount > savee)
4109 *diagnostic_fn = error;
4111 *diagnostic_fn = NULL;
4116 /* Perform the conversions in CONVS on the expression EXPR. FN and
4117 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4118 indicates the `this' argument of a method. INNER is nonzero when
4119 being called to continue a conversion chain. It is negative when a
4120 reference binding will be applied, positive otherwise. If
4121 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4122 conversions will be emitted if appropriate. If C_CAST_P is true,
4123 this conversion is coming from a C-style cast; in that case,
4124 conversions to inaccessible bases are permitted. */
4127 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4128 int inner, bool issue_conversion_warnings,
4131 tree totype = convs->type;
4132 void (*diagnostic_fn)(const char *, ...);
4135 && convs->kind != ck_user
4136 && convs->kind != ck_ambig
4137 && convs->kind != ck_ref_bind)
4139 conversion *t = convs;
4140 for (; t; t = convs->u.next)
4142 if (t->kind == ck_user || !t->bad_p)
4144 expr = convert_like_real (t, expr, fn, argnum, 1,
4145 /*issue_conversion_warnings=*/false,
4146 /*c_cast_p=*/false);
4149 else if (t->kind == ck_ambig)
4150 return convert_like_real (t, expr, fn, argnum, 1,
4151 /*issue_conversion_warnings=*/false,
4152 /*c_cast_p=*/false);
4153 else if (t->kind == ck_identity)
4156 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4158 pedwarn (" initializing argument %P of %qD", argnum, fn);
4159 return cp_convert (totype, expr);
4162 if (issue_conversion_warnings)
4163 expr = dubious_conversion_warnings
4164 (totype, expr, "converting", fn, argnum);
4165 switch (convs->kind)
4169 struct z_candidate *cand = convs->cand;
4170 tree convfn = cand->fn;
4173 if (DECL_CONSTRUCTOR_P (convfn))
4175 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4178 args = build_tree_list (NULL_TREE, expr);
4179 /* We should never try to call the abstract or base constructor
4181 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4182 && !DECL_HAS_VTT_PARM_P (convfn));
4183 args = tree_cons (NULL_TREE, t, args);
4186 args = build_this (expr);
4187 expr = build_over_call (cand, LOOKUP_NORMAL);
4189 /* If this is a constructor or a function returning an aggr type,
4190 we need to build up a TARGET_EXPR. */
4191 if (DECL_CONSTRUCTOR_P (convfn))
4192 expr = build_cplus_new (totype, expr);
4194 /* The result of the call is then used to direct-initialize the object
4195 that is the destination of the copy-initialization. [dcl.init]
4197 Note that this step is not reflected in the conversion sequence;
4198 it affects the semantics when we actually perform the
4199 conversion, but is not considered during overload resolution.
4201 If the target is a class, that means call a ctor. */
4202 if (IS_AGGR_TYPE (totype)
4203 && (inner >= 0 || !lvalue_p (expr)))
4207 /* Core issue 84, now a DR, says that we don't
4208 allow UDCs for these args (which deliberately
4209 breaks copy-init of an auto_ptr<Base> from an
4210 auto_ptr<Derived>). */
4211 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4218 (" initializing argument %P of %qD from result of %qD",
4219 argnum, fn, convfn);
4222 (" initializing temporary from result of %qD", convfn);
4224 expr = build_cplus_new (totype, expr);
4229 if (type_unknown_p (expr))
4230 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4231 /* Convert a non-array constant variable to its underlying value, unless we
4232 are about to bind it to a reference, in which case we need to
4233 leave it as an lvalue. */
4235 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4236 expr = decl_constant_value (expr);
4237 if (convs->check_copy_constructor_p)
4238 check_constructor_callable (totype, expr);
4241 /* Call build_user_type_conversion again for the error. */
4242 return build_user_type_conversion
4243 (totype, convs->u.expr, LOOKUP_NORMAL);
4249 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4250 convs->kind == ck_ref_bind ? -1 : 1,
4251 /*issue_conversion_warnings=*/false,
4253 if (expr == error_mark_node)
4254 return error_mark_node;
4256 switch (convs->kind)
4259 if (! IS_AGGR_TYPE (totype))
4261 /* Else fall through. */
4263 if (convs->kind == ck_base && !convs->need_temporary_p)
4265 /* We are going to bind a reference directly to a base-class
4266 subobject of EXPR. */
4267 if (convs->check_copy_constructor_p)
4268 check_constructor_callable (TREE_TYPE (expr), expr);
4269 /* Build an expression for `*((base*) &expr)'. */
4270 expr = build_unary_op (ADDR_EXPR, expr, 0);
4271 expr = convert_to_base (expr, build_pointer_type (totype),
4272 !c_cast_p, /*nonnull=*/true);
4273 expr = build_indirect_ref (expr, "implicit conversion");
4277 /* Copy-initialization where the cv-unqualified version of the source
4278 type is the same class as, or a derived class of, the class of the
4279 destination [is treated as direct-initialization]. [dcl.init] */
4280 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4282 if (diagnostic_fn && fn)
4283 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4284 return build_cplus_new (totype, expr);
4288 tree ref_type = totype;
4290 /* If necessary, create a temporary. */
4291 if (convs->need_temporary_p || !lvalue_p (expr))
4293 tree type = convs->u.next->type;
4295 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4297 /* If the reference is volatile or non-const, we
4298 cannot create a temporary. */
4299 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4301 if (lvalue & clk_bitfield)
4302 error ("cannot bind bitfield %qE to %qT",
4304 else if (lvalue & clk_packed)
4305 error ("cannot bind packed field %qE to %qT",
4308 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4309 return error_mark_node;
4311 expr = build_target_expr_with_type (expr, type);
4314 /* Take the address of the thing to which we will bind the
4316 expr = build_unary_op (ADDR_EXPR, expr, 1);
4317 if (expr == error_mark_node)
4318 return error_mark_node;
4320 /* Convert it to a pointer to the type referred to by the
4321 reference. This will adjust the pointer if a derived to
4322 base conversion is being performed. */
4323 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4325 /* Convert the pointer to the desired reference type. */
4326 return build_nop (ref_type, expr);
4330 return decay_conversion (expr);
4333 /* Warn about deprecated conversion if appropriate. */
4334 string_conv_p (totype, expr, 1);
4339 expr = convert_to_base (expr, totype, !c_cast_p,
4341 return build_nop (totype, expr);
4344 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4350 return ocp_convert (totype, expr, CONV_IMPLICIT,
4351 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4354 /* Build a call to __builtin_trap. */
4357 call_builtin_trap (void)
4359 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4361 gcc_assert (fn != NULL);
4362 fn = build_call (fn, NULL_TREE);
4366 /* ARG is being passed to a varargs function. Perform any conversions
4367 required. Return the converted value. */
4370 convert_arg_to_ellipsis (tree arg)
4374 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4375 standard conversions are performed. */
4376 arg = decay_conversion (arg);
4379 If the argument has integral or enumeration type that is subject
4380 to the integral promotions (_conv.prom_), or a floating point
4381 type that is subject to the floating point promotion
4382 (_conv.fpprom_), the value of the argument is converted to the
4383 promoted type before the call. */
4384 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4385 && (TYPE_PRECISION (TREE_TYPE (arg))
4386 < TYPE_PRECISION (double_type_node)))
4387 arg = convert_to_real (double_type_node, arg);
4388 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4389 arg = perform_integral_promotions (arg);
4391 arg = require_complete_type (arg);
4393 if (arg != error_mark_node
4394 && !pod_type_p (TREE_TYPE (arg)))
4396 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4397 here and do a bitwise copy, but now cp_expr_size will abort if we
4399 If the call appears in the context of a sizeof expression,
4400 there is no need to emit a warning, since the expression won't be
4401 evaluated. We keep the builtin_trap just as a safety check. */
4402 if (!skip_evaluation)
4403 warning ("cannot pass objects of non-POD type %q#T through %<...%>; "
4404 "call will abort at runtime", TREE_TYPE (arg));
4405 arg = call_builtin_trap ();
4406 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4413 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4416 build_x_va_arg (tree expr, tree type)
4418 if (processing_template_decl)
4419 return build_min (VA_ARG_EXPR, type, expr);
4421 type = complete_type_or_else (type, NULL_TREE);
4423 if (expr == error_mark_node || !type)
4424 return error_mark_node;
4426 if (! pod_type_p (type))
4428 /* Undefined behavior [expr.call] 5.2.2/7. */
4429 warning ("cannot receive objects of non-POD type %q#T through %<...%>; "
4430 "call will abort at runtime", type);
4431 expr = convert (build_pointer_type (type), null_node);
4432 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4433 call_builtin_trap (), expr);
4434 expr = build_indirect_ref (expr, NULL);
4438 return build_va_arg (expr, type);
4441 /* TYPE has been given to va_arg. Apply the default conversions which
4442 would have happened when passed via ellipsis. Return the promoted
4443 type, or the passed type if there is no change. */
4446 cxx_type_promotes_to (tree type)
4450 /* Perform the array-to-pointer and function-to-pointer
4452 type = type_decays_to (type);
4454 promote = type_promotes_to (type);
4455 if (same_type_p (type, promote))
4461 /* ARG is a default argument expression being passed to a parameter of
4462 the indicated TYPE, which is a parameter to FN. Do any required
4463 conversions. Return the converted value. */
4466 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4468 /* If the ARG is an unparsed default argument expression, the
4469 conversion cannot be performed. */
4470 if (TREE_CODE (arg) == DEFAULT_ARG)
4472 error ("the default argument for parameter %d of %qD has "
4473 "not yet been parsed",
4475 return error_mark_node;
4478 if (fn && DECL_TEMPLATE_INFO (fn))
4479 arg = tsubst_default_argument (fn, type, arg);
4481 arg = break_out_target_exprs (arg);
4483 if (TREE_CODE (arg) == CONSTRUCTOR)
4485 arg = digest_init (type, arg, 0);
4486 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4487 "default argument", fn, parmnum);
4491 /* This could get clobbered by the following call. */
4492 if (TREE_HAS_CONSTRUCTOR (arg))
4493 arg = copy_node (arg);
4495 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4496 "default argument", fn, parmnum);
4497 arg = convert_for_arg_passing (type, arg);
4503 /* Returns the type which will really be used for passing an argument of
4507 type_passed_as (tree type)
4509 /* Pass classes with copy ctors by invisible reference. */
4510 if (TREE_ADDRESSABLE (type))
4512 type = build_reference_type (type);
4513 /* There are no other pointers to this temporary. */
4514 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4516 else if (targetm.calls.promote_prototypes (type)
4517 && INTEGRAL_TYPE_P (type)
4518 && COMPLETE_TYPE_P (type)
4519 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4520 TYPE_SIZE (integer_type_node)))
4521 type = integer_type_node;
4526 /* Actually perform the appropriate conversion. */
4529 convert_for_arg_passing (tree type, tree val)
4531 if (val == error_mark_node)
4533 /* Pass classes with copy ctors by invisible reference. */
4534 else if (TREE_ADDRESSABLE (type))
4535 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4536 else if (targetm.calls.promote_prototypes (type)
4537 && INTEGRAL_TYPE_P (type)
4538 && COMPLETE_TYPE_P (type)
4539 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4540 TYPE_SIZE (integer_type_node)))
4541 val = perform_integral_promotions (val);
4545 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4546 which no conversions at all should be done. This is true for some
4547 builtins which don't act like normal functions. */
4550 magic_varargs_p (tree fn)
4552 if (DECL_BUILT_IN (fn))
4553 switch (DECL_FUNCTION_CODE (fn))
4555 case BUILT_IN_CLASSIFY_TYPE:
4556 case BUILT_IN_CONSTANT_P:
4557 case BUILT_IN_NEXT_ARG:
4558 case BUILT_IN_STDARG_START:
4559 case BUILT_IN_VA_START:
4568 /* Subroutine of the various build_*_call functions. Overload resolution
4569 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4570 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4571 bitmask of various LOOKUP_* flags which apply to the call itself. */
4574 build_over_call (struct z_candidate *cand, int flags)
4577 tree args = cand->args;
4578 conversion **convs = cand->convs;
4580 tree converted_args = NULL_TREE;
4581 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4586 /* In a template, there is no need to perform all of the work that
4587 is normally done. We are only interested in the type of the call
4588 expression, i.e., the return type of the function. Any semantic
4589 errors will be deferred until the template is instantiated. */
4590 if (processing_template_decl)
4594 return_type = TREE_TYPE (TREE_TYPE (fn));
4595 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4596 if (TREE_THIS_VOLATILE (fn) && cfun)
4597 current_function_returns_abnormally = 1;
4598 if (!VOID_TYPE_P (return_type))
4599 require_complete_type (return_type);
4600 return convert_from_reference (expr);
4603 /* Give any warnings we noticed during overload resolution. */
4606 struct candidate_warning *w;
4607 for (w = cand->warnings; w; w = w->next)
4608 joust (cand, w->loser, 1);
4611 if (DECL_FUNCTION_MEMBER_P (fn))
4613 /* If FN is a template function, two cases must be considered.
4618 template <class T> void f();
4620 template <class T> struct B {
4624 struct C : A, B<int> {
4626 using B<int>::g; // #2
4629 In case #1 where `A::f' is a member template, DECL_ACCESS is
4630 recorded in the primary template but not in its specialization.
4631 We check access of FN using its primary template.
4633 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4634 because it is a member of class template B, DECL_ACCESS is
4635 recorded in the specialization `B<int>::g'. We cannot use its
4636 primary template because `B<T>::g' and `B<int>::g' may have
4637 different access. */
4638 if (DECL_TEMPLATE_INFO (fn)
4639 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4640 perform_or_defer_access_check (cand->access_path,
4641 DECL_TI_TEMPLATE (fn));
4643 perform_or_defer_access_check (cand->access_path, fn);
4646 if (args && TREE_CODE (args) != TREE_LIST)
4647 args = build_tree_list (NULL_TREE, args);
4650 /* The implicit parameters to a constructor are not considered by overload
4651 resolution, and must be of the proper type. */
4652 if (DECL_CONSTRUCTOR_P (fn))
4654 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4655 arg = TREE_CHAIN (arg);
4656 parm = TREE_CHAIN (parm);
4657 /* We should never try to call the abstract constructor. */
4658 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4660 if (DECL_HAS_VTT_PARM_P (fn))
4662 converted_args = tree_cons
4663 (NULL_TREE, TREE_VALUE (arg), converted_args);
4664 arg = TREE_CHAIN (arg);
4665 parm = TREE_CHAIN (parm);
4668 /* Bypass access control for 'this' parameter. */
4669 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4671 tree parmtype = TREE_VALUE (parm);
4672 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4676 if (convs[i]->bad_p)
4677 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4678 TREE_TYPE (argtype), fn);
4680 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4681 X is called for an object that is not of type X, or of a type
4682 derived from X, the behavior is undefined.
4684 So we can assume that anything passed as 'this' is non-null, and
4685 optimize accordingly. */
4686 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4687 /* Convert to the base in which the function was declared. */
4688 gcc_assert (cand->conversion_path != NULL_TREE);
4689 converted_arg = build_base_path (PLUS_EXPR,
4691 cand->conversion_path,
4693 /* Check that the base class is accessible. */
4694 if (!accessible_base_p (TREE_TYPE (argtype),
4695 BINFO_TYPE (cand->conversion_path), true))
4696 error ("%qT is not an accessible base of %qT",
4697 BINFO_TYPE (cand->conversion_path),
4698 TREE_TYPE (argtype));
4699 /* If fn was found by a using declaration, the conversion path
4700 will be to the derived class, not the base declaring fn. We
4701 must convert from derived to base. */
4702 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4703 TREE_TYPE (parmtype), ba_unique, NULL);
4704 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4707 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4708 parm = TREE_CHAIN (parm);
4709 arg = TREE_CHAIN (arg);
4715 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4717 tree type = TREE_VALUE (parm);
4720 val = convert_like_with_context
4721 (conv, TREE_VALUE (arg), fn, i - is_method);
4723 val = convert_for_arg_passing (type, val);
4724 converted_args = tree_cons (NULL_TREE, val, converted_args);
4727 /* Default arguments */
4728 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4730 = tree_cons (NULL_TREE,
4731 convert_default_arg (TREE_VALUE (parm),
4732 TREE_PURPOSE (parm),
4737 for (; arg; arg = TREE_CHAIN (arg))
4739 tree a = TREE_VALUE (arg);
4740 if (magic_varargs_p (fn))
4741 /* Do no conversions for magic varargs. */;
4743 a = convert_arg_to_ellipsis (a);
4744 converted_args = tree_cons (NULL_TREE, a, converted_args);
4747 converted_args = nreverse (converted_args);
4749 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4752 /* Avoid actually calling copy constructors and copy assignment operators,
4755 if (! flag_elide_constructors)
4756 /* Do things the hard way. */;
4757 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4760 arg = skip_artificial_parms_for (fn, converted_args);
4761 arg = TREE_VALUE (arg);
4763 /* Pull out the real argument, disregarding const-correctness. */
4765 while (TREE_CODE (targ) == NOP_EXPR
4766 || TREE_CODE (targ) == NON_LVALUE_EXPR
4767 || TREE_CODE (targ) == CONVERT_EXPR)
4768 targ = TREE_OPERAND (targ, 0);
4769 if (TREE_CODE (targ) == ADDR_EXPR)
4771 targ = TREE_OPERAND (targ, 0);
4772 if (!same_type_ignoring_top_level_qualifiers_p
4773 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4782 arg = build_indirect_ref (arg, 0);
4784 /* [class.copy]: the copy constructor is implicitly defined even if
4785 the implementation elided its use. */
4786 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4789 /* If we're creating a temp and we already have one, don't create a
4790 new one. If we're not creating a temp but we get one, use
4791 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4792 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4793 temp or an INIT_EXPR otherwise. */
4794 if (integer_zerop (TREE_VALUE (args)))
4796 if (TREE_CODE (arg) == TARGET_EXPR)
4798 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4799 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4801 else if (TREE_CODE (arg) == TARGET_EXPR
4802 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4804 tree to = stabilize_reference
4805 (build_indirect_ref (TREE_VALUE (args), 0));
4807 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4811 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4813 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4815 tree to = stabilize_reference
4816 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4817 tree type = TREE_TYPE (to);
4818 tree as_base = CLASSTYPE_AS_BASE (type);
4820 arg = TREE_VALUE (TREE_CHAIN (converted_args));
4821 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4823 arg = build_indirect_ref (arg, 0);
4824 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4828 /* We must only copy the non-tail padding parts.
4829 Use __builtin_memcpy for the bitwise copy. */
4833 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
4834 args = tree_cons (NULL, arg, args);
4835 t = build_unary_op (ADDR_EXPR, to, 0);
4836 args = tree_cons (NULL, t, args);
4837 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
4838 t = build_call (t, args);
4840 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
4841 val = build_indirect_ref (t, 0);
4849 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4851 tree t, *p = &TREE_VALUE (converted_args);
4852 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4855 gcc_assert (binfo && binfo != error_mark_node);
4857 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4858 if (TREE_SIDE_EFFECTS (*p))
4859 *p = save_expr (*p);
4860 t = build_pointer_type (TREE_TYPE (fn));
4861 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4862 fn = build_java_interface_fn_ref (fn, *p);
4864 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
4867 else if (DECL_INLINE (fn))
4868 fn = inline_conversion (fn);
4870 fn = build_addr_func (fn);
4872 return build_cxx_call (fn, converted_args);
4875 /* Build and return a call to FN, using ARGS. This function performs
4876 no overload resolution, conversion, or other high-level
4880 build_cxx_call (tree fn, tree args)
4884 fn = build_call (fn, args);
4886 /* If this call might throw an exception, note that fact. */
4887 fndecl = get_callee_fndecl (fn);
4888 if ((!fndecl || !TREE_NOTHROW (fndecl))
4889 && at_function_scope_p ()
4891 cp_function_chain->can_throw = 1;
4893 /* Some built-in function calls will be evaluated at compile-time in
4895 fn = fold_if_not_in_template (fn);
4897 if (VOID_TYPE_P (TREE_TYPE (fn)))
4900 fn = require_complete_type (fn);
4901 if (fn == error_mark_node)
4902 return error_mark_node;
4904 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4905 fn = build_cplus_new (TREE_TYPE (fn), fn);
4906 return convert_from_reference (fn);
4909 static GTY(()) tree java_iface_lookup_fn;
4911 /* Make an expression which yields the address of the Java interface
4912 method FN. This is achieved by generating a call to libjava's
4913 _Jv_LookupInterfaceMethodIdx(). */
4916 build_java_interface_fn_ref (tree fn, tree instance)
4918 tree lookup_args, lookup_fn, method, idx;
4919 tree klass_ref, iface, iface_ref;
4922 if (!java_iface_lookup_fn)
4924 tree endlink = build_void_list_node ();
4925 tree t = tree_cons (NULL_TREE, ptr_type_node,
4926 tree_cons (NULL_TREE, ptr_type_node,
4927 tree_cons (NULL_TREE, java_int_type_node,
4929 java_iface_lookup_fn
4930 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4931 build_function_type (ptr_type_node, t),
4932 0, NOT_BUILT_IN, NULL, NULL_TREE);
4935 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4936 This is the first entry in the vtable. */
4937 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4940 /* Get the java.lang.Class pointer for the interface being called. */
4941 iface = DECL_CONTEXT (fn);
4942 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4943 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4944 || DECL_CONTEXT (iface_ref) != iface)
4946 error ("could not find class$ field in java interface type %qT",
4948 return error_mark_node;
4950 iface_ref = build_address (iface_ref);
4951 iface_ref = convert (build_pointer_type (iface), iface_ref);
4953 /* Determine the itable index of FN. */
4955 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4957 if (!DECL_VIRTUAL_P (method))
4963 idx = build_int_cst (NULL_TREE, i);
4965 lookup_args = tree_cons (NULL_TREE, klass_ref,
4966 tree_cons (NULL_TREE, iface_ref,
4967 build_tree_list (NULL_TREE, idx)));
4968 lookup_fn = build1 (ADDR_EXPR,
4969 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4970 java_iface_lookup_fn);
4971 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4974 /* Returns the value to use for the in-charge parameter when making a
4975 call to a function with the indicated NAME.
4977 FIXME:Can't we find a neater way to do this mapping? */
4980 in_charge_arg_for_name (tree name)
4982 if (name == base_ctor_identifier
4983 || name == base_dtor_identifier)
4984 return integer_zero_node;
4985 else if (name == complete_ctor_identifier)
4986 return integer_one_node;
4987 else if (name == complete_dtor_identifier)
4988 return integer_two_node;
4989 else if (name == deleting_dtor_identifier)
4990 return integer_three_node;
4992 /* This function should only be called with one of the names listed
4998 /* Build a call to a constructor, destructor, or an assignment
4999 operator for INSTANCE, an expression with class type. NAME
5000 indicates the special member function to call; ARGS are the
5001 arguments. BINFO indicates the base of INSTANCE that is to be
5002 passed as the `this' parameter to the member function called.
5004 FLAGS are the LOOKUP_* flags to use when processing the call.
5006 If NAME indicates a complete object constructor, INSTANCE may be
5007 NULL_TREE. In this case, the caller will call build_cplus_new to
5008 store the newly constructed object into a VAR_DECL. */
5011 build_special_member_call (tree instance, tree name, tree args,
5012 tree binfo, int flags)
5015 /* The type of the subobject to be constructed or destroyed. */
5018 gcc_assert (name == complete_ctor_identifier
5019 || name == base_ctor_identifier
5020 || name == complete_dtor_identifier
5021 || name == base_dtor_identifier
5022 || name == deleting_dtor_identifier
5023 || name == ansi_assopname (NOP_EXPR));
5026 /* Resolve the name. */
5027 if (!complete_type_or_else (binfo, NULL_TREE))
5028 return error_mark_node;
5030 binfo = TYPE_BINFO (binfo);
5033 gcc_assert (binfo != NULL_TREE);
5035 class_type = BINFO_TYPE (binfo);
5037 /* Handle the special case where INSTANCE is NULL_TREE. */
5038 if (name == complete_ctor_identifier && !instance)
5040 instance = build_int_cst (build_pointer_type (class_type), 0);
5041 instance = build1 (INDIRECT_REF, class_type, instance);
5045 if (name == complete_dtor_identifier
5046 || name == base_dtor_identifier
5047 || name == deleting_dtor_identifier)
5048 gcc_assert (args == NULL_TREE);
5050 /* Convert to the base class, if necessary. */
5051 if (!same_type_ignoring_top_level_qualifiers_p
5052 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5054 if (name != ansi_assopname (NOP_EXPR))
5055 /* For constructors and destructors, either the base is
5056 non-virtual, or it is virtual but we are doing the
5057 conversion from a constructor or destructor for the
5058 complete object. In either case, we can convert
5060 instance = convert_to_base_statically (instance, binfo);
5062 /* However, for assignment operators, we must convert
5063 dynamically if the base is virtual. */
5064 instance = build_base_path (PLUS_EXPR, instance,
5065 binfo, /*nonnull=*/1);
5069 gcc_assert (instance != NULL_TREE);
5071 fns = lookup_fnfields (binfo, name, 1);
5073 /* When making a call to a constructor or destructor for a subobject
5074 that uses virtual base classes, pass down a pointer to a VTT for
5076 if ((name == base_ctor_identifier
5077 || name == base_dtor_identifier)
5078 && CLASSTYPE_VBASECLASSES (class_type))
5083 /* If the current function is a complete object constructor
5084 or destructor, then we fetch the VTT directly.
5085 Otherwise, we look it up using the VTT we were given. */
5086 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5087 vtt = decay_conversion (vtt);
5088 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5089 build2 (EQ_EXPR, boolean_type_node,
5090 current_in_charge_parm, integer_zero_node),
5093 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5094 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5095 BINFO_SUBVTT_INDEX (binfo));
5097 args = tree_cons (NULL_TREE, sub_vtt, args);
5100 return build_new_method_call (instance, fns, args,
5101 TYPE_BINFO (BINFO_TYPE (binfo)),
5105 /* Return the NAME, as a C string. The NAME indicates a function that
5106 is a member of TYPE. *FREE_P is set to true if the caller must
5107 free the memory returned.
5109 Rather than go through all of this, we should simply set the names
5110 of constructors and destructors appropriately, and dispense with
5111 ctor_identifier, dtor_identifier, etc. */
5114 name_as_c_string (tree name, tree type, bool *free_p)
5118 /* Assume that we will not allocate memory. */
5120 /* Constructors and destructors are special. */
5121 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5124 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5125 /* For a destructor, add the '~'. */
5126 if (name == complete_dtor_identifier
5127 || name == base_dtor_identifier
5128 || name == deleting_dtor_identifier)
5130 pretty_name = concat ("~", pretty_name, NULL);
5131 /* Remember that we need to free the memory allocated. */
5135 else if (IDENTIFIER_TYPENAME_P (name))
5137 pretty_name = concat ("operator ",
5138 type_as_string (TREE_TYPE (name),
5139 TFF_PLAIN_IDENTIFIER),
5141 /* Remember that we need to free the memory allocated. */
5145 pretty_name = (char *) IDENTIFIER_POINTER (name);
5150 /* Build a call to "INSTANCE.FN (ARGS)". */
5153 build_new_method_call (tree instance, tree fns, tree args,
5154 tree conversion_path, int flags)
5156 struct z_candidate *candidates = 0, *cand;
5157 tree explicit_targs = NULL_TREE;
5158 tree basetype = NULL_TREE;
5161 tree mem_args = NULL_TREE, instance_ptr;
5167 int template_only = 0;
5174 gcc_assert (instance != NULL_TREE);
5176 if (error_operand_p (instance)
5177 || error_operand_p (fns)
5178 || args == error_mark_node)
5179 return error_mark_node;
5181 orig_instance = instance;
5185 if (processing_template_decl)
5187 instance = build_non_dependent_expr (instance);
5188 if (!BASELINK_P (fns)
5189 && TREE_CODE (fns) != PSEUDO_DTOR_EXPR
5190 && TREE_TYPE (fns) != unknown_type_node)
5191 fns = build_non_dependent_expr (fns);
5192 args = build_non_dependent_args (orig_args);
5195 /* Process the argument list. */
5197 args = resolve_args (args);
5198 if (args == error_mark_node)
5199 return error_mark_node;
5201 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5202 instance = convert_from_reference (instance);
5203 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5204 instance_ptr = build_this (instance);
5206 if (!BASELINK_P (fns))
5208 error ("call to non-function %qD", fns);
5209 return error_mark_node;
5212 if (!conversion_path)
5213 conversion_path = BASELINK_BINFO (fns);
5214 access_binfo = BASELINK_ACCESS_BINFO (fns);
5215 optype = BASELINK_OPTYPE (fns);
5216 fns = BASELINK_FUNCTIONS (fns);
5218 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5220 explicit_targs = TREE_OPERAND (fns, 1);
5221 fns = TREE_OPERAND (fns, 0);
5225 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5226 || TREE_CODE (fns) == TEMPLATE_DECL
5227 || TREE_CODE (fns) == OVERLOAD);
5229 /* XXX this should be handled before we get here. */
5230 if (! IS_AGGR_TYPE (basetype))
5232 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5233 error ("request for member %qD in %qE, which is of non-aggregate "
5235 fns, instance, basetype);
5237 return error_mark_node;
5240 fn = get_first_fn (fns);
5241 name = DECL_NAME (fn);
5243 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5245 /* Callers should explicitly indicate whether they want to construct
5246 the complete object or just the part without virtual bases. */
5247 gcc_assert (name != ctor_identifier);
5248 /* Similarly for destructors. */
5249 gcc_assert (name != dtor_identifier);
5252 /* It's OK to call destructors on cv-qualified objects. Therefore,
5253 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5254 if (DECL_DESTRUCTOR_P (fn))
5256 tree type = build_pointer_type (basetype);
5257 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5258 instance_ptr = build_nop (type, instance_ptr);
5261 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5262 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5264 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5265 p = conversion_obstack_alloc (0);
5267 for (fn = fns; fn; fn = OVL_NEXT (fn))
5269 tree t = OVL_CURRENT (fn);
5272 /* We can end up here for copy-init of same or base class. */
5273 if ((flags & LOOKUP_ONLYCONVERTING)
5274 && DECL_NONCONVERTING_P (t))
5277 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5278 this_arglist = mem_args;
5280 this_arglist = args;
5282 if (TREE_CODE (t) == TEMPLATE_DECL)
5283 /* A member template. */
5284 add_template_candidate (&candidates, t,
5287 this_arglist, optype,
5292 else if (! template_only)
5293 add_function_candidate (&candidates, t,
5301 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5304 if (!COMPLETE_TYPE_P (basetype))
5305 cxx_incomplete_type_error (instance_ptr, basetype);
5311 pretty_name = name_as_c_string (name, basetype, &free_p);
5312 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5313 basetype, pretty_name, user_args,
5314 TREE_TYPE (TREE_TYPE (instance_ptr)));
5318 print_z_candidates (candidates);
5319 call = error_mark_node;
5323 cand = tourney (candidates);
5329 pretty_name = name_as_c_string (name, basetype, &free_p);
5330 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5332 print_z_candidates (candidates);
5335 call = error_mark_node;
5339 if (!(flags & LOOKUP_NONVIRTUAL)
5340 && DECL_PURE_VIRTUAL_P (cand->fn)
5341 && instance == current_class_ref
5342 && (DECL_CONSTRUCTOR_P (current_function_decl)
5343 || DECL_DESTRUCTOR_P (current_function_decl)))
5344 /* This is not an error, it is runtime undefined
5346 warning ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5347 "abstract virtual %q#D called from constructor"
5348 : "abstract virtual %q#D called from destructor"),
5351 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5352 && is_dummy_object (instance_ptr))
5354 error ("cannot call member function %qD without object",
5356 call = error_mark_node;
5360 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5361 && resolves_to_fixed_type_p (instance, 0))
5362 flags |= LOOKUP_NONVIRTUAL;
5364 call = build_over_call (cand, flags);
5366 /* In an expression of the form `a->f()' where `f' turns
5367 out to be a static member function, `a' is
5368 none-the-less evaluated. */
5369 if (TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE
5370 && !is_dummy_object (instance_ptr)
5371 && TREE_SIDE_EFFECTS (instance))
5372 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5378 if (processing_template_decl && call != error_mark_node)
5379 call = (build_min_non_dep
5381 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5382 orig_args, NULL_TREE));
5384 /* Free all the conversions we allocated. */
5385 obstack_free (&conversion_obstack, p);
5390 /* Returns true iff standard conversion sequence ICS1 is a proper
5391 subsequence of ICS2. */
5394 is_subseq (conversion *ics1, conversion *ics2)
5396 /* We can assume that a conversion of the same code
5397 between the same types indicates a subsequence since we only get
5398 here if the types we are converting from are the same. */
5400 while (ics1->kind == ck_rvalue
5401 || ics1->kind == ck_lvalue)
5402 ics1 = ics1->u.next;
5406 while (ics2->kind == ck_rvalue
5407 || ics2->kind == ck_lvalue)
5408 ics2 = ics2->u.next;
5410 if (ics2->kind == ck_user
5411 || ics2->kind == ck_ambig
5412 || ics2->kind == ck_identity)
5413 /* At this point, ICS1 cannot be a proper subsequence of
5414 ICS2. We can get a USER_CONV when we are comparing the
5415 second standard conversion sequence of two user conversion
5419 ics2 = ics2->u.next;
5421 if (ics2->kind == ics1->kind
5422 && same_type_p (ics2->type, ics1->type)
5423 && same_type_p (ics2->u.next->type,
5424 ics1->u.next->type))
5429 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5430 be any _TYPE nodes. */
5433 is_properly_derived_from (tree derived, tree base)
5435 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5436 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5439 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5440 considers every class derived from itself. */
5441 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5442 && DERIVED_FROM_P (base, derived));
5445 /* We build the ICS for an implicit object parameter as a pointer
5446 conversion sequence. However, such a sequence should be compared
5447 as if it were a reference conversion sequence. If ICS is the
5448 implicit conversion sequence for an implicit object parameter,
5449 modify it accordingly. */
5452 maybe_handle_implicit_object (conversion **ics)
5456 /* [over.match.funcs]
5458 For non-static member functions, the type of the
5459 implicit object parameter is "reference to cv X"
5460 where X is the class of which the function is a
5461 member and cv is the cv-qualification on the member
5462 function declaration. */
5463 conversion *t = *ics;
5464 tree reference_type;
5466 /* The `this' parameter is a pointer to a class type. Make the
5467 implicit conversion talk about a reference to that same class
5469 reference_type = TREE_TYPE (t->type);
5470 reference_type = build_reference_type (reference_type);
5472 if (t->kind == ck_qual)
5474 if (t->kind == ck_ptr)
5476 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5477 t = direct_reference_binding (reference_type, t);
5482 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5483 and return the type to which the reference refers. Otherwise,
5484 leave *ICS unchanged and return NULL_TREE. */
5487 maybe_handle_ref_bind (conversion **ics)
5489 if ((*ics)->kind == ck_ref_bind)
5491 conversion *old_ics = *ics;
5492 tree type = TREE_TYPE (old_ics->type);
5493 *ics = old_ics->u.next;
5494 (*ics)->user_conv_p = old_ics->user_conv_p;
5495 (*ics)->bad_p = old_ics->bad_p;
5502 /* Compare two implicit conversion sequences according to the rules set out in
5503 [over.ics.rank]. Return values:
5505 1: ics1 is better than ics2
5506 -1: ics2 is better than ics1
5507 0: ics1 and ics2 are indistinguishable */
5510 compare_ics (conversion *ics1, conversion *ics2)
5516 tree deref_from_type1 = NULL_TREE;
5517 tree deref_from_type2 = NULL_TREE;
5518 tree deref_to_type1 = NULL_TREE;
5519 tree deref_to_type2 = NULL_TREE;
5520 conversion_rank rank1, rank2;
5522 /* REF_BINDING is nonzero if the result of the conversion sequence
5523 is a reference type. In that case TARGET_TYPE is the
5524 type referred to by the reference. */
5528 /* Handle implicit object parameters. */
5529 maybe_handle_implicit_object (&ics1);
5530 maybe_handle_implicit_object (&ics2);
5532 /* Handle reference parameters. */
5533 target_type1 = maybe_handle_ref_bind (&ics1);
5534 target_type2 = maybe_handle_ref_bind (&ics2);
5538 When comparing the basic forms of implicit conversion sequences (as
5539 defined in _over.best.ics_)
5541 --a standard conversion sequence (_over.ics.scs_) is a better
5542 conversion sequence than a user-defined conversion sequence
5543 or an ellipsis conversion sequence, and
5545 --a user-defined conversion sequence (_over.ics.user_) is a
5546 better conversion sequence than an ellipsis conversion sequence
5547 (_over.ics.ellipsis_). */
5548 rank1 = CONVERSION_RANK (ics1);
5549 rank2 = CONVERSION_RANK (ics2);
5553 else if (rank1 < rank2)
5556 if (rank1 == cr_bad)
5558 /* XXX Isn't this an extension? */
5559 /* Both ICS are bad. We try to make a decision based on what
5560 would have happened if they'd been good. */
5561 if (ics1->user_conv_p > ics2->user_conv_p
5562 || ics1->rank > ics2->rank)
5564 else if (ics1->user_conv_p < ics2->user_conv_p
5565 || ics1->rank < ics2->rank)
5568 /* We couldn't make up our minds; try to figure it out below. */
5571 if (ics1->ellipsis_p)
5572 /* Both conversions are ellipsis conversions. */
5575 /* User-defined conversion sequence U1 is a better conversion sequence
5576 than another user-defined conversion sequence U2 if they contain the
5577 same user-defined conversion operator or constructor and if the sec-
5578 ond standard conversion sequence of U1 is better than the second
5579 standard conversion sequence of U2. */
5581 if (ics1->user_conv_p)
5586 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5587 if (t1->kind == ck_ambig)
5589 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5590 if (t2->kind == ck_ambig)
5593 if (t1->cand->fn != t2->cand->fn)
5596 /* We can just fall through here, after setting up
5597 FROM_TYPE1 and FROM_TYPE2. */
5598 from_type1 = t1->type;
5599 from_type2 = t2->type;
5606 /* We're dealing with two standard conversion sequences.
5610 Standard conversion sequence S1 is a better conversion
5611 sequence than standard conversion sequence S2 if
5613 --S1 is a proper subsequence of S2 (comparing the conversion
5614 sequences in the canonical form defined by _over.ics.scs_,
5615 excluding any Lvalue Transformation; the identity
5616 conversion sequence is considered to be a subsequence of
5617 any non-identity conversion sequence */
5620 while (t1->kind != ck_identity)
5622 from_type1 = t1->type;
5625 while (t2->kind != ck_identity)
5627 from_type2 = t2->type;
5630 if (same_type_p (from_type1, from_type2))
5632 if (is_subseq (ics1, ics2))
5634 if (is_subseq (ics2, ics1))
5637 /* Otherwise, one sequence cannot be a subsequence of the other; they
5638 don't start with the same type. This can happen when comparing the
5639 second standard conversion sequence in two user-defined conversion
5646 --the rank of S1 is better than the rank of S2 (by the rules
5649 Standard conversion sequences are ordered by their ranks: an Exact
5650 Match is a better conversion than a Promotion, which is a better
5651 conversion than a Conversion.
5653 Two conversion sequences with the same rank are indistinguishable
5654 unless one of the following rules applies:
5656 --A conversion that is not a conversion of a pointer, or pointer
5657 to member, to bool is better than another conversion that is such
5660 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5661 so that we do not have to check it explicitly. */
5662 if (ics1->rank < ics2->rank)
5664 else if (ics2->rank < ics1->rank)
5667 to_type1 = ics1->type;
5668 to_type2 = ics2->type;
5670 if (TYPE_PTR_P (from_type1)
5671 && TYPE_PTR_P (from_type2)
5672 && TYPE_PTR_P (to_type1)
5673 && TYPE_PTR_P (to_type2))
5675 deref_from_type1 = TREE_TYPE (from_type1);
5676 deref_from_type2 = TREE_TYPE (from_type2);
5677 deref_to_type1 = TREE_TYPE (to_type1);
5678 deref_to_type2 = TREE_TYPE (to_type2);
5680 /* The rules for pointers to members A::* are just like the rules
5681 for pointers A*, except opposite: if B is derived from A then
5682 A::* converts to B::*, not vice versa. For that reason, we
5683 switch the from_ and to_ variables here. */
5684 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5685 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5686 || (TYPE_PTRMEMFUNC_P (from_type1)
5687 && TYPE_PTRMEMFUNC_P (from_type2)
5688 && TYPE_PTRMEMFUNC_P (to_type1)
5689 && TYPE_PTRMEMFUNC_P (to_type2)))
5691 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5692 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5693 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5694 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5697 if (deref_from_type1 != NULL_TREE
5698 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5699 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5701 /* This was one of the pointer or pointer-like conversions.
5705 --If class B is derived directly or indirectly from class A,
5706 conversion of B* to A* is better than conversion of B* to
5707 void*, and conversion of A* to void* is better than
5708 conversion of B* to void*. */
5709 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5710 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5712 if (is_properly_derived_from (deref_from_type1,
5715 else if (is_properly_derived_from (deref_from_type2,
5719 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5720 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5722 if (same_type_p (deref_from_type1, deref_from_type2))
5724 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5726 if (is_properly_derived_from (deref_from_type1,
5730 /* We know that DEREF_TO_TYPE1 is `void' here. */
5731 else if (is_properly_derived_from (deref_from_type1,
5736 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5737 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5741 --If class B is derived directly or indirectly from class A
5742 and class C is derived directly or indirectly from B,
5744 --conversion of C* to B* is better than conversion of C* to
5747 --conversion of B* to A* is better than conversion of C* to
5749 if (same_type_p (deref_from_type1, deref_from_type2))
5751 if (is_properly_derived_from (deref_to_type1,
5754 else if (is_properly_derived_from (deref_to_type2,
5758 else if (same_type_p (deref_to_type1, deref_to_type2))
5760 if (is_properly_derived_from (deref_from_type2,
5763 else if (is_properly_derived_from (deref_from_type1,
5769 else if (CLASS_TYPE_P (non_reference (from_type1))
5770 && same_type_p (from_type1, from_type2))
5772 tree from = non_reference (from_type1);
5776 --binding of an expression of type C to a reference of type
5777 B& is better than binding an expression of type C to a
5778 reference of type A&
5780 --conversion of C to B is better than conversion of C to A, */
5781 if (is_properly_derived_from (from, to_type1)
5782 && is_properly_derived_from (from, to_type2))
5784 if (is_properly_derived_from (to_type1, to_type2))
5786 else if (is_properly_derived_from (to_type2, to_type1))
5790 else if (CLASS_TYPE_P (non_reference (to_type1))
5791 && same_type_p (to_type1, to_type2))
5793 tree to = non_reference (to_type1);
5797 --binding of an expression of type B to a reference of type
5798 A& is better than binding an expression of type C to a
5799 reference of type A&,
5801 --conversion of B to A is better than conversion of C to A */
5802 if (is_properly_derived_from (from_type1, to)
5803 && is_properly_derived_from (from_type2, to))
5805 if (is_properly_derived_from (from_type2, from_type1))
5807 else if (is_properly_derived_from (from_type1, from_type2))
5814 --S1 and S2 differ only in their qualification conversion and yield
5815 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5816 qualification signature of type T1 is a proper subset of the cv-
5817 qualification signature of type T2 */
5818 if (ics1->kind == ck_qual
5819 && ics2->kind == ck_qual
5820 && same_type_p (from_type1, from_type2))
5821 return comp_cv_qual_signature (to_type1, to_type2);
5825 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5826 types to which the references refer are the same type except for
5827 top-level cv-qualifiers, and the type to which the reference
5828 initialized by S2 refers is more cv-qualified than the type to
5829 which the reference initialized by S1 refers */
5831 if (target_type1 && target_type2
5832 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5833 return comp_cv_qualification (target_type2, target_type1);
5835 /* Neither conversion sequence is better than the other. */
5839 /* The source type for this standard conversion sequence. */
5842 source_type (conversion *t)
5844 for (;; t = t->u.next)
5846 if (t->kind == ck_user
5847 || t->kind == ck_ambig
5848 || t->kind == ck_identity)
5854 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5855 a pointer to LOSER and re-running joust to produce the warning if WINNER
5856 is actually used. */
5859 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5861 candidate_warning *cw;
5863 cw = conversion_obstack_alloc (sizeof (candidate_warning));
5865 cw->next = winner->warnings;
5866 winner->warnings = cw;
5869 /* Compare two candidates for overloading as described in
5870 [over.match.best]. Return values:
5872 1: cand1 is better than cand2
5873 -1: cand2 is better than cand1
5874 0: cand1 and cand2 are indistinguishable */
5877 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5880 int off1 = 0, off2 = 0;
5884 /* Candidates that involve bad conversions are always worse than those
5886 if (cand1->viable > cand2->viable)
5888 if (cand1->viable < cand2->viable)
5891 /* If we have two pseudo-candidates for conversions to the same type,
5892 or two candidates for the same function, arbitrarily pick one. */
5893 if (cand1->fn == cand2->fn
5894 && (IS_TYPE_OR_DECL_P (cand1->fn)))
5897 /* a viable function F1
5898 is defined to be a better function than another viable function F2 if
5899 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5900 ICSi(F2), and then */
5902 /* for some argument j, ICSj(F1) is a better conversion sequence than
5905 /* For comparing static and non-static member functions, we ignore
5906 the implicit object parameter of the non-static function. The
5907 standard says to pretend that the static function has an object
5908 parm, but that won't work with operator overloading. */
5909 len = cand1->num_convs;
5910 if (len != cand2->num_convs)
5912 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
5913 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
5915 gcc_assert (static_1 != static_2);
5926 for (i = 0; i < len; ++i)
5928 conversion *t1 = cand1->convs[i + off1];
5929 conversion *t2 = cand2->convs[i + off2];
5930 int comp = compare_ics (t1, t2);
5935 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
5936 == cr_std + cr_promotion)
5937 && t1->kind == ck_std
5938 && t2->kind == ck_std
5939 && TREE_CODE (t1->type) == INTEGER_TYPE
5940 && TREE_CODE (t2->type) == INTEGER_TYPE
5941 && (TYPE_PRECISION (t1->type)
5942 == TYPE_PRECISION (t2->type))
5943 && (TYPE_UNSIGNED (t1->u.next->type)
5944 || (TREE_CODE (t1->u.next->type)
5947 tree type = t1->u.next->type;
5949 struct z_candidate *w, *l;
5951 type1 = t1->type, type2 = t2->type,
5952 w = cand1, l = cand2;
5954 type1 = t2->type, type2 = t1->type,
5955 w = cand2, l = cand1;
5959 warning ("passing %qT chooses %qT over %qT",
5960 type, type1, type2);
5961 warning (" in call to %qD", w->fn);
5967 if (winner && comp != winner)
5976 /* warn about confusing overload resolution for user-defined conversions,
5977 either between a constructor and a conversion op, or between two
5979 if (winner && warn_conversion && cand1->second_conv
5980 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5981 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5983 struct z_candidate *w, *l;
5984 bool give_warning = false;
5987 w = cand1, l = cand2;
5989 w = cand2, l = cand1;
5991 /* We don't want to complain about `X::operator T1 ()'
5992 beating `X::operator T2 () const', when T2 is a no less
5993 cv-qualified version of T1. */
5994 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5995 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5997 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5998 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6000 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6005 if (!comp_ptr_ttypes (t, f))
6006 give_warning = true;
6009 give_warning = true;
6015 tree source = source_type (w->convs[0]);
6016 if (! DECL_CONSTRUCTOR_P (w->fn))
6017 source = TREE_TYPE (source);
6018 warning ("choosing %qD over %qD", w->fn, l->fn);
6019 warning (" for conversion from %qT to %qT",
6020 source, w->second_conv->type);
6021 warning (" because conversion sequence for the argument is better");
6031 F1 is a non-template function and F2 is a template function
6034 if (!cand1->template_decl && cand2->template_decl)
6036 else if (cand1->template_decl && !cand2->template_decl)
6040 F1 and F2 are template functions and the function template for F1 is
6041 more specialized than the template for F2 according to the partial
6044 if (cand1->template_decl && cand2->template_decl)
6046 winner = more_specialized
6047 (TI_TEMPLATE (cand1->template_decl),
6048 TI_TEMPLATE (cand2->template_decl),
6050 /* Tell the deduction code how many real function arguments
6051 we saw, not counting the implicit 'this' argument. But,
6052 add_function_candidate() suppresses the "this" argument
6055 [temp.func.order]: The presence of unused ellipsis and default
6056 arguments has no effect on the partial ordering of function
6059 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
6060 - DECL_CONSTRUCTOR_P (cand1->fn)));
6066 the context is an initialization by user-defined conversion (see
6067 _dcl.init_ and _over.match.user_) and the standard conversion
6068 sequence from the return type of F1 to the destination type (i.e.,
6069 the type of the entity being initialized) is a better conversion
6070 sequence than the standard conversion sequence from the return type
6071 of F2 to the destination type. */
6073 if (cand1->second_conv)
6075 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6080 /* Check whether we can discard a builtin candidate, either because we
6081 have two identical ones or matching builtin and non-builtin candidates.
6083 (Pedantically in the latter case the builtin which matched the user
6084 function should not be added to the overload set, but we spot it here.
6087 ... the builtin candidates include ...
6088 - do not have the same parameter type list as any non-template
6089 non-member candidate. */
6091 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6092 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6094 for (i = 0; i < len; ++i)
6095 if (!same_type_p (cand1->convs[i]->type,
6096 cand2->convs[i]->type))
6098 if (i == cand1->num_convs)
6100 if (cand1->fn == cand2->fn)
6101 /* Two built-in candidates; arbitrarily pick one. */
6103 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6104 /* cand1 is built-in; prefer cand2. */
6107 /* cand2 is built-in; prefer cand1. */
6112 /* If the two functions are the same (this can happen with declarations
6113 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6114 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6115 && equal_functions (cand1->fn, cand2->fn))
6120 /* Extension: If the worst conversion for one candidate is worse than the
6121 worst conversion for the other, take the first. */
6124 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6125 struct z_candidate *w = 0, *l = 0;
6127 for (i = 0; i < len; ++i)
6129 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6130 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6131 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6132 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6135 winner = 1, w = cand1, l = cand2;
6137 winner = -1, w = cand2, l = cand1;
6143 ISO C++ says that these are ambiguous, even \
6144 though the worst conversion for the first is better than \
6145 the worst conversion for the second:");
6146 print_z_candidate (_("candidate 1:"), w);
6147 print_z_candidate (_("candidate 2:"), l);
6155 gcc_assert (!winner);
6159 /* Given a list of candidates for overloading, find the best one, if any.
6160 This algorithm has a worst case of O(2n) (winner is last), and a best
6161 case of O(n/2) (totally ambiguous); much better than a sorting
6164 static struct z_candidate *
6165 tourney (struct z_candidate *candidates)
6167 struct z_candidate *champ = candidates, *challenger;
6169 int champ_compared_to_predecessor = 0;
6171 /* Walk through the list once, comparing each current champ to the next
6172 candidate, knocking out a candidate or two with each comparison. */
6174 for (challenger = champ->next; challenger; )
6176 fate = joust (champ, challenger, 0);
6178 challenger = challenger->next;
6183 champ = challenger->next;
6186 champ_compared_to_predecessor = 0;
6191 champ_compared_to_predecessor = 1;
6194 challenger = champ->next;
6198 /* Make sure the champ is better than all the candidates it hasn't yet
6199 been compared to. */
6201 for (challenger = candidates;
6203 && !(champ_compared_to_predecessor && challenger->next == champ);
6204 challenger = challenger->next)
6206 fate = joust (champ, challenger, 0);
6214 /* Returns nonzero if things of type FROM can be converted to TO. */
6217 can_convert (tree to, tree from)
6219 return can_convert_arg (to, from, NULL_TREE);
6222 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6225 can_convert_arg (tree to, tree from, tree arg)
6231 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6232 p = conversion_obstack_alloc (0);
6234 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6235 ok_p = (t && !t->bad_p);
6237 /* Free all the conversions we allocated. */
6238 obstack_free (&conversion_obstack, p);
6243 /* Like can_convert_arg, but allows dubious conversions as well. */
6246 can_convert_arg_bad (tree to, tree from, tree arg)
6251 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6252 p = conversion_obstack_alloc (0);
6253 /* Try to perform the conversion. */
6254 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6255 /* Free all the conversions we allocated. */
6256 obstack_free (&conversion_obstack, p);
6261 /* Convert EXPR to TYPE. Return the converted expression.
6263 Note that we allow bad conversions here because by the time we get to
6264 this point we are committed to doing the conversion. If we end up
6265 doing a bad conversion, convert_like will complain. */
6268 perform_implicit_conversion (tree type, tree expr)
6273 if (error_operand_p (expr))
6274 return error_mark_node;
6276 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6277 p = conversion_obstack_alloc (0);
6279 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6283 error ("could not convert %qE to %qT", expr, type);
6284 expr = error_mark_node;
6287 expr = convert_like (conv, expr);
6289 /* Free all the conversions we allocated. */
6290 obstack_free (&conversion_obstack, p);
6295 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6296 permitted. If the conversion is valid, the converted expression is
6297 returned. Otherwise, NULL_TREE is returned, except in the case
6298 that TYPE is a class type; in that case, an error is issued. If
6299 C_CAST_P is true, then this direction initialization is taking
6300 place as part of a static_cast being attempted as part of a C-style
6304 perform_direct_initialization_if_possible (tree type,
6311 if (type == error_mark_node || error_operand_p (expr))
6312 return error_mark_node;
6315 If the destination type is a (possibly cv-qualified) class type:
6317 -- If the initialization is direct-initialization ...,
6318 constructors are considered. ... If no constructor applies, or
6319 the overload resolution is ambiguous, the initialization is
6321 if (CLASS_TYPE_P (type))
6323 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6324 build_tree_list (NULL_TREE, expr),
6325 type, LOOKUP_NORMAL);
6326 return build_cplus_new (type, expr);
6329 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6330 p = conversion_obstack_alloc (0);
6332 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6334 if (!conv || conv->bad_p)
6337 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6338 /*issue_conversion_warnings=*/false,
6341 /* Free all the conversions we allocated. */
6342 obstack_free (&conversion_obstack, p);
6347 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6348 is being bound to a temporary. Create and return a new VAR_DECL
6349 with the indicated TYPE; this variable will store the value to
6350 which the reference is bound. */
6353 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6357 /* Create the variable. */
6358 var = build_decl (VAR_DECL, NULL_TREE, type);
6359 DECL_ARTIFICIAL (var) = 1;
6360 TREE_USED (var) = 1;
6362 /* Register the variable. */
6363 if (TREE_STATIC (decl))
6365 /* Namespace-scope or local static; give it a mangled name. */
6368 TREE_STATIC (var) = 1;
6369 name = mangle_ref_init_variable (decl);
6370 DECL_NAME (var) = name;
6371 SET_DECL_ASSEMBLER_NAME (var, name);
6372 var = pushdecl_top_level (var);
6376 /* Create a new cleanup level if necessary. */
6377 maybe_push_cleanup_level (type);
6378 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6379 DECL_CONTEXT (var) = current_function_decl;
6385 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6386 initializing a variable of that TYPE. If DECL is non-NULL, it is
6387 the VAR_DECL being initialized with the EXPR. (In that case, the
6388 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6389 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6390 return, if *CLEANUP is no longer NULL, it will be an expression
6391 that should be pushed as a cleanup after the returned expression
6392 is used to initialize DECL.
6394 Return the converted expression. */
6397 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6402 if (type == error_mark_node || error_operand_p (expr))
6403 return error_mark_node;
6405 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6406 p = conversion_obstack_alloc (0);
6408 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6409 if (!conv || conv->bad_p)
6411 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6412 && !real_lvalue_p (expr))
6413 error ("invalid initialization of non-const reference of "
6414 "type %qT from a temporary of type %qT",
6415 type, TREE_TYPE (expr));
6417 error ("invalid initialization of reference of type "
6418 "%qT from expression of type %qT", type,
6420 return error_mark_node;
6423 /* If DECL is non-NULL, then this special rule applies:
6427 The temporary to which the reference is bound or the temporary
6428 that is the complete object to which the reference is bound
6429 persists for the lifetime of the reference.
6431 The temporaries created during the evaluation of the expression
6432 initializing the reference, except the temporary to which the
6433 reference is bound, are destroyed at the end of the
6434 full-expression in which they are created.
6436 In that case, we store the converted expression into a new
6437 VAR_DECL in a new scope.
6439 However, we want to be careful not to create temporaries when
6440 they are not required. For example, given:
6443 struct D : public B {};
6447 there is no need to copy the return value from "f"; we can just
6448 extend its lifetime. Similarly, given:
6451 struct T { operator S(); };
6455 we can extend the lifetime of the return value of the conversion
6457 gcc_assert (conv->kind == ck_ref_bind);
6461 tree base_conv_type;
6463 /* Skip over the REF_BIND. */
6464 conv = conv->u.next;
6465 /* If the next conversion is a BASE_CONV, skip that too -- but
6466 remember that the conversion was required. */
6467 if (conv->kind == ck_base)
6469 if (conv->check_copy_constructor_p)
6470 check_constructor_callable (TREE_TYPE (expr), expr);
6471 base_conv_type = conv->type;
6472 conv = conv->u.next;
6475 base_conv_type = NULL_TREE;
6476 /* Perform the remainder of the conversion. */
6477 expr = convert_like_real (conv, expr,
6478 /*fn=*/NULL_TREE, /*argnum=*/0,
6480 /*issue_conversion_warnings=*/true,
6481 /*c_cast_p=*/false);
6482 if (!real_lvalue_p (expr))
6487 /* Create the temporary variable. */
6488 type = TREE_TYPE (expr);
6489 var = make_temporary_var_for_ref_to_temp (decl, type);
6490 layout_decl (var, 0);
6491 /* If the rvalue is the result of a function call it will be
6492 a TARGET_EXPR. If it is some other construct (such as a
6493 member access expression where the underlying object is
6494 itself the result of a function call), turn it into a
6495 TARGET_EXPR here. It is important that EXPR be a
6496 TARGET_EXPR below since otherwise the INIT_EXPR will
6497 attempt to make a bitwise copy of EXPR to initialize
6499 if (TREE_CODE (expr) != TARGET_EXPR)
6500 expr = get_target_expr (expr);
6501 /* Create the INIT_EXPR that will initialize the temporary
6503 init = build2 (INIT_EXPR, type, var, expr);
6504 if (at_function_scope_p ())
6506 add_decl_expr (var);
6507 *cleanup = cxx_maybe_build_cleanup (var);
6509 /* We must be careful to destroy the temporary only
6510 after its initialization has taken place. If the
6511 initialization throws an exception, then the
6512 destructor should not be run. We cannot simply
6513 transform INIT into something like:
6515 (INIT, ({ CLEANUP_STMT; }))
6517 because emit_local_var always treats the
6518 initializer as a full-expression. Thus, the
6519 destructor would run too early; it would run at the
6520 end of initializing the reference variable, rather
6521 than at the end of the block enclosing the
6524 The solution is to pass back a cleanup expression
6525 which the caller is responsible for attaching to
6526 the statement tree. */
6530 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6531 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6532 static_aggregates = tree_cons (NULL_TREE, var,
6535 /* Use its address to initialize the reference variable. */
6536 expr = build_address (var);
6538 expr = convert_to_base (expr,
6539 build_pointer_type (base_conv_type),
6540 /*check_access=*/true,
6542 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6545 /* Take the address of EXPR. */
6546 expr = build_unary_op (ADDR_EXPR, expr, 0);
6547 /* If a BASE_CONV was required, perform it now. */
6549 expr = (perform_implicit_conversion
6550 (build_pointer_type (base_conv_type), expr));
6551 expr = build_nop (type, expr);
6554 /* Perform the conversion. */
6555 expr = convert_like (conv, expr);
6557 /* Free all the conversions we allocated. */
6558 obstack_free (&conversion_obstack, p);
6563 #include "gt-cp-call.h"