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 /* The type of the expression resulting from the conversion. */
98 /* The next conversion in the chain. Since the conversions are
99 arranged from outermost to innermost, the NEXT conversion will
100 actually be performed before this conversion. This variant is
101 used only when KIND is neither ck_identity nor ck_ambig. */
103 /* The expression at the beginning of the conversion chain. This
104 variant is used only if KIND is ck_identity or ck_ambig. */
107 /* The function candidate corresponding to this conversion
108 sequence. This field is only used if KIND is ck_user. */
109 struct z_candidate *cand;
112 #define CONVERSION_RANK(NODE) \
113 ((NODE)->bad_p ? cr_bad \
114 : (NODE)->ellipsis_p ? cr_ellipsis \
115 : (NODE)->user_conv_p ? cr_user \
118 static struct obstack conversion_obstack;
119 static bool conversion_obstack_initialized;
121 static struct z_candidate * tourney (struct z_candidate *);
122 static int equal_functions (tree, tree);
123 static int joust (struct z_candidate *, struct z_candidate *, bool);
124 static int compare_ics (conversion *, conversion *);
125 static tree build_over_call (struct z_candidate *, int);
126 static tree build_java_interface_fn_ref (tree, tree);
127 #define convert_like(CONV, EXPR) \
128 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
129 /*issue_conversion_warnings=*/true)
130 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
131 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
132 /*issue_conversion_warnings=*/true)
133 static tree convert_like_real (conversion *, tree, tree, int, int, bool);
134 static void op_error (enum tree_code, enum tree_code, tree, tree,
136 static tree build_object_call (tree, tree);
137 static tree resolve_args (tree);
138 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
139 static void print_z_candidate (const char *, struct z_candidate *);
140 static void print_z_candidates (struct z_candidate *);
141 static tree build_this (tree);
142 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
143 static bool any_strictly_viable (struct z_candidate *);
144 static struct z_candidate *add_template_candidate
145 (struct z_candidate **, tree, tree, tree, tree, tree,
146 tree, tree, int, unification_kind_t);
147 static struct z_candidate *add_template_candidate_real
148 (struct z_candidate **, tree, tree, tree, tree, tree,
149 tree, tree, int, tree, unification_kind_t);
150 static struct z_candidate *add_template_conv_candidate
151 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
152 static void add_builtin_candidates
153 (struct z_candidate **, enum tree_code, enum tree_code,
155 static void add_builtin_candidate
156 (struct z_candidate **, enum tree_code, enum tree_code,
157 tree, tree, tree, tree *, tree *, int);
158 static bool is_complete (tree);
159 static void build_builtin_candidate
160 (struct z_candidate **, tree, tree, tree, tree *, tree *,
162 static struct z_candidate *add_conv_candidate
163 (struct z_candidate **, tree, tree, tree, tree, tree);
164 static struct z_candidate *add_function_candidate
165 (struct z_candidate **, tree, tree, tree, tree, tree, int);
166 static conversion *implicit_conversion (tree, tree, tree, int);
167 static conversion *standard_conversion (tree, tree, tree);
168 static conversion *reference_binding (tree, tree, tree, int);
169 static conversion *build_conv (conversion_kind, tree, conversion *);
170 static bool is_subseq (conversion *, conversion *);
171 static tree maybe_handle_ref_bind (conversion **);
172 static void maybe_handle_implicit_object (conversion **);
173 static struct z_candidate *add_candidate
174 (struct z_candidate **, tree, tree, size_t,
175 conversion **, tree, tree, int);
176 static tree source_type (conversion *);
177 static void add_warning (struct z_candidate *, struct z_candidate *);
178 static bool reference_related_p (tree, tree);
179 static bool reference_compatible_p (tree, tree);
180 static conversion *convert_class_to_reference (tree, tree, tree);
181 static conversion *direct_reference_binding (tree, conversion *);
182 static bool promoted_arithmetic_type_p (tree);
183 static conversion *conditional_conversion (tree, tree);
184 static char *name_as_c_string (tree, tree, bool *);
185 static tree call_builtin_trap (tree);
186 static tree prep_operand (tree);
187 static void add_candidates (tree, tree, tree, bool, tree, tree,
188 int, struct z_candidate **);
189 static conversion *merge_conversion_sequences (conversion *, conversion *);
190 static bool magic_varargs_p (tree);
193 build_vfield_ref (tree datum, tree type)
195 if (datum == error_mark_node)
196 return error_mark_node;
198 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
199 datum = convert_from_reference (datum);
201 if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
202 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
203 datum = convert_to_base (datum, type, /*check_access=*/false);
205 return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
206 datum, TYPE_VFIELD (type));
209 /* Returns nonzero iff the destructor name specified in NAME
210 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
214 check_dtor_name (tree basetype, tree name)
216 name = TREE_OPERAND (name, 0);
218 /* Just accept something we've already complained about. */
219 if (name == error_mark_node)
222 if (TREE_CODE (name) == TYPE_DECL)
223 name = TREE_TYPE (name);
224 else if (TYPE_P (name))
226 else if (TREE_CODE (name) == IDENTIFIER_NODE)
228 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
229 || (TREE_CODE (basetype) == ENUMERAL_TYPE
230 && name == TYPE_IDENTIFIER (basetype)))
233 name = get_type_value (name);
237 template <class T> struct S { ~S(); };
241 NAME will be a class template. */
242 else if (DECL_CLASS_TEMPLATE_P (name))
247 if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
252 /* We want the address of a function or method. We avoid creating a
253 pointer-to-member function. */
256 build_addr_func (tree function)
258 tree type = TREE_TYPE (function);
260 /* We have to do these by hand to avoid real pointer to member
262 if (TREE_CODE (type) == METHOD_TYPE)
264 if (TREE_CODE (function) == OFFSET_REF)
266 tree object = build_address (TREE_OPERAND (function, 0));
267 return get_member_function_from_ptrfunc (&object,
268 TREE_OPERAND (function, 1));
270 function = build_address (function);
273 function = decay_conversion (function);
278 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
279 POINTER_TYPE to those. Note, pointer to member function types
280 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
283 build_call (tree function, tree parms)
285 int is_constructor = 0;
292 function = build_addr_func (function);
294 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
296 sorry ("unable to call pointer to member function here");
297 return error_mark_node;
300 fntype = TREE_TYPE (TREE_TYPE (function));
301 result_type = TREE_TYPE (fntype);
303 if (TREE_CODE (function) == ADDR_EXPR
304 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
305 decl = TREE_OPERAND (function, 0);
309 /* We check both the decl and the type; a function may be known not to
310 throw without being declared throw(). */
311 nothrow = ((decl && TREE_NOTHROW (decl))
312 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
314 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
315 current_function_returns_abnormally = 1;
317 if (decl && TREE_DEPRECATED (decl))
318 warn_deprecated_use (decl);
319 require_complete_eh_spec_types (fntype, decl);
321 if (decl && DECL_CONSTRUCTOR_P (decl))
324 if (decl && ! TREE_USED (decl))
326 /* We invoke build_call directly for several library functions.
327 These may have been declared normally if we're building libgcc,
328 so we can't just check DECL_ARTIFICIAL. */
329 if (DECL_ARTIFICIAL (decl)
330 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
336 /* Don't pass empty class objects by value. This is useful
337 for tags in STL, which are used to control overload resolution.
338 We don't need to handle other cases of copying empty classes. */
339 if (! decl || ! DECL_BUILT_IN (decl))
340 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
341 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
342 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
344 tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
345 TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
346 TREE_VALUE (tmp), t);
349 function = build (CALL_EXPR, result_type, function, parms);
350 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
351 TREE_NOTHROW (function) = nothrow;
356 /* Build something of the form ptr->method (args)
357 or object.method (args). This can also build
358 calls to constructors, and find friends.
360 Member functions always take their class variable
363 INSTANCE is a class instance.
365 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
367 PARMS help to figure out what that NAME really refers to.
369 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
370 down to the real instance type to use for access checking. We need this
371 information to get protected accesses correct.
373 FLAGS is the logical disjunction of zero or more LOOKUP_
374 flags. See cp-tree.h for more info.
376 If this is all OK, calls build_function_call with the resolved
379 This function must also handle being called to perform
380 initialization, promotion/coercion of arguments, and
381 instantiation of default parameters.
383 Note that NAME may refer to an instance variable name. If
384 `operator()()' is defined for the type of that field, then we return
387 /* New overloading code. */
389 typedef struct z_candidate z_candidate;
391 typedef struct candidate_warning candidate_warning;
392 struct candidate_warning {
394 candidate_warning *next;
398 /* The FUNCTION_DECL that will be called if this candidate is
399 selected by overload resolution. */
401 /* The arguments to use when calling this function. */
403 /* The implicit conversion sequences for each of the arguments to
406 /* The number of implicit conversion sequences. */
408 /* If FN is a user-defined conversion, the standard conversion
409 sequence from the type returned by FN to the desired destination
411 conversion *second_conv;
413 /* If FN is a member function, the binfo indicating the path used to
414 qualify the name of FN at the call site. This path is used to
415 determine whether or not FN is accessible if it is selected by
416 overload resolution. The DECL_CONTEXT of FN will always be a
417 (possibly improper) base of this binfo. */
419 /* If FN is a non-static member function, the binfo indicating the
420 subobject to which the `this' pointer should be converted if FN
421 is selected by overload resolution. The type pointed to the by
422 the `this' pointer must correspond to the most derived class
423 indicated by the CONVERSION_PATH. */
424 tree conversion_path;
426 candidate_warning *warnings;
431 null_ptr_cst_p (tree t)
435 A null pointer constant is an integral constant expression
436 (_expr.const_) rvalue of integer type that evaluates to zero. */
438 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
444 /* Returns nonzero if PARMLIST consists of only default parms and/or
448 sufficient_parms_p (tree parmlist)
450 for (; parmlist && parmlist != void_list_node;
451 parmlist = TREE_CHAIN (parmlist))
452 if (!TREE_PURPOSE (parmlist))
457 /* Allocate N bytes of memory from the conversion obstack. The memory
458 is zeroed before being returned. */
461 conversion_obstack_alloc (size_t n)
464 if (!conversion_obstack_initialized)
466 gcc_obstack_init (&conversion_obstack);
467 conversion_obstack_initialized = true;
469 p = obstack_alloc (&conversion_obstack, n);
474 /* Dynamically allocate a conversion. */
477 alloc_conversion (conversion_kind kind)
480 c = conversion_obstack_alloc (sizeof (conversion));
485 #ifdef ENABLE_CHECKING
487 /* Make sure that all memory on the conversion obstack has been
491 validate_conversion_obstack (void)
493 if (conversion_obstack_initialized)
494 my_friendly_assert ((obstack_next_free (&conversion_obstack)
495 == obstack_base (&conversion_obstack)),
499 #endif /* ENABLE_CHECKING */
501 /* Dynamically allocate an array of N conversions. */
504 alloc_conversions (size_t n)
506 return conversion_obstack_alloc (n * sizeof (conversion *));
510 build_conv (conversion_kind code, tree type, conversion *from)
513 conversion_rank rank = CONVERSION_RANK (from);
515 /* We can't use buildl1 here because CODE could be USER_CONV, which
516 takes two arguments. In that case, the caller is responsible for
517 filling in the second argument. */
518 t = alloc_conversion (code);
541 t->user_conv_p = (code == ck_user || from->user_conv_p);
542 t->bad_p = from->bad_p;
546 /* Build a representation of the identity conversion from EXPR to
547 itself. The TYPE should match the the type of EXPR, if EXPR is
551 build_identity_conv (tree type, tree expr)
555 c = alloc_conversion (ck_identity);
562 /* Converting from EXPR to TYPE was ambiguous in the sense that there
563 were multiple user-defined conversions to accomplish the job.
564 Build a conversion that indicates that ambiguity. */
567 build_ambiguous_conv (tree type, tree expr)
571 c = alloc_conversion (ck_ambig);
579 strip_top_quals (tree t)
581 if (TREE_CODE (t) == ARRAY_TYPE)
583 return cp_build_qualified_type (t, 0);
586 /* Returns the standard conversion path (see [conv]) from type FROM to type
587 TO, if any. For proper handling of null pointer constants, you must
588 also pass the expression EXPR to convert from. */
591 standard_conversion (tree to, tree from, tree expr)
593 enum tree_code fcode, tcode;
595 bool fromref = false;
597 to = non_reference (to);
598 if (TREE_CODE (from) == REFERENCE_TYPE)
601 from = TREE_TYPE (from);
603 to = strip_top_quals (to);
604 from = strip_top_quals (from);
606 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
607 && expr && type_unknown_p (expr))
609 expr = instantiate_type (to, expr, tf_conv);
610 if (expr == error_mark_node)
612 from = TREE_TYPE (expr);
615 fcode = TREE_CODE (from);
616 tcode = TREE_CODE (to);
618 conv = build_identity_conv (from, expr);
619 if (fcode == FUNCTION_TYPE)
621 from = build_pointer_type (from);
622 fcode = TREE_CODE (from);
623 conv = build_conv (ck_lvalue, from, conv);
625 else if (fcode == ARRAY_TYPE)
627 from = build_pointer_type (TREE_TYPE (from));
628 fcode = TREE_CODE (from);
629 conv = build_conv (ck_lvalue, from, conv);
631 else if (fromref || (expr && lvalue_p (expr)))
632 conv = build_conv (ck_rvalue, from, conv);
634 /* Allow conversion between `__complex__' data types. */
635 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
637 /* The standard conversion sequence to convert FROM to TO is
638 the standard conversion sequence to perform componentwise
640 conversion *part_conv = standard_conversion
641 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
645 conv = build_conv (part_conv->kind, to, conv);
646 conv->rank = part_conv->rank;
654 if (same_type_p (from, to))
657 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
658 && expr && null_ptr_cst_p (expr))
659 conv = build_conv (ck_std, to, conv);
660 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE
661 && TREE_CODE (TREE_TYPE (to)) == VECTOR_TYPE
662 && TREE_CODE (TREE_TYPE (from)) == VECTOR_TYPE
663 && ((*targetm.vector_opaque_p) (TREE_TYPE (to))
664 || (*targetm.vector_opaque_p) (TREE_TYPE (from))))
665 conv = build_conv (ck_std, to, conv);
666 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
667 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
669 /* For backwards brain damage compatibility, allow interconversion of
670 pointers and integers with a pedwarn. */
671 conv = build_conv (ck_std, to, conv);
674 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
676 /* For backwards brain damage compatibility, allow interconversion of
677 enums and integers with a pedwarn. */
678 conv = build_conv (ck_std, to, conv);
681 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
682 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
687 if (tcode == POINTER_TYPE
688 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
691 else if (VOID_TYPE_P (TREE_TYPE (to))
692 && !TYPE_PTRMEM_P (from)
693 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
695 from = build_pointer_type
696 (cp_build_qualified_type (void_type_node,
697 cp_type_quals (TREE_TYPE (from))));
698 conv = build_conv (ck_ptr, from, conv);
700 else if (TYPE_PTRMEM_P (from))
702 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
703 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
705 if (DERIVED_FROM_P (fbase, tbase)
706 && (same_type_ignoring_top_level_qualifiers_p
707 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
708 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
710 from = build_ptrmem_type (tbase,
711 TYPE_PTRMEM_POINTED_TO_TYPE (from));
712 conv = build_conv (ck_pmem, from, conv);
715 else if (IS_AGGR_TYPE (TREE_TYPE (from))
716 && IS_AGGR_TYPE (TREE_TYPE (to))
719 An rvalue of type "pointer to cv D," where D is a
720 class type, can be converted to an rvalue of type
721 "pointer to cv B," where B is a base class (clause
722 _class.derived_) of D. If B is an inaccessible
723 (clause _class.access_) or ambiguous
724 (_class.member.lookup_) base class of D, a program
725 that necessitates this conversion is ill-formed. */
726 /* Therefore, we use DERIVED_FROM_P, and not
727 ACCESSIBLY_UNIQUELY_DERIVED_FROM_P, in this test. */
728 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
731 cp_build_qualified_type (TREE_TYPE (to),
732 cp_type_quals (TREE_TYPE (from)));
733 from = build_pointer_type (from);
734 conv = build_conv (ck_ptr, from, conv);
737 if (tcode == POINTER_TYPE)
739 to_pointee = TREE_TYPE (to);
740 from_pointee = TREE_TYPE (from);
744 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
745 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
748 if (same_type_p (from, to))
750 else if (comp_ptr_ttypes (to_pointee, from_pointee))
751 conv = build_conv (ck_qual, to, conv);
752 else if (expr && string_conv_p (to, expr, 0))
753 /* converting from string constant to char *. */
754 conv = build_conv (ck_qual, to, conv);
755 else if (ptr_reasonably_similar (to_pointee, from_pointee))
757 conv = build_conv (ck_ptr, to, conv);
765 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
767 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
768 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
769 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
770 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
772 if (!DERIVED_FROM_P (fbase, tbase)
773 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
774 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
775 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
776 || cp_type_quals (fbase) != cp_type_quals (tbase))
779 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
780 from = build_method_type_directly (from,
782 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
783 from = build_ptrmemfunc_type (build_pointer_type (from));
784 conv = build_conv (ck_pmem, from, conv);
786 else if (tcode == BOOLEAN_TYPE)
790 An rvalue of arithmetic, enumeration, pointer, or pointer to
791 member type can be converted to an rvalue of type bool. */
792 if (ARITHMETIC_TYPE_P (from)
793 || fcode == ENUMERAL_TYPE
794 || fcode == POINTER_TYPE
795 || TYPE_PTR_TO_MEMBER_P (from))
797 conv = build_conv (ck_std, to, conv);
798 if (fcode == POINTER_TYPE
799 || TYPE_PTRMEM_P (from)
800 || (TYPE_PTRMEMFUNC_P (from)
801 && conv->rank < cr_pbool))
802 conv->rank = cr_pbool;
808 /* We don't check for ENUMERAL_TYPE here because there are no standard
809 conversions to enum type. */
810 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
811 || tcode == REAL_TYPE)
813 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
815 conv = build_conv (ck_std, to, conv);
817 /* Give this a better rank if it's a promotion. */
818 if (same_type_p (to, type_promotes_to (from))
819 && conv->u.next->rank <= cr_promotion)
820 conv->rank = cr_promotion;
822 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
823 && ((*targetm.vector_opaque_p) (from)
824 || (*targetm.vector_opaque_p) (to)))
825 return build_conv (ck_std, to, conv);
826 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
827 && is_properly_derived_from (from, to))
829 if (conv->kind == ck_rvalue)
831 conv = build_conv (ck_base, to, conv);
832 /* The derived-to-base conversion indicates the initialization
833 of a parameter with base type from an object of a derived
834 type. A temporary object is created to hold the result of
836 conv->need_temporary_p = true;
844 /* Returns nonzero if T1 is reference-related to T2. */
847 reference_related_p (tree t1, tree t2)
849 t1 = TYPE_MAIN_VARIANT (t1);
850 t2 = TYPE_MAIN_VARIANT (t2);
854 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
855 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
857 return (same_type_p (t1, t2)
858 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
859 && DERIVED_FROM_P (t1, t2)));
862 /* Returns nonzero if T1 is reference-compatible with T2. */
865 reference_compatible_p (tree t1, tree t2)
869 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
870 reference-related to T2 and cv1 is the same cv-qualification as,
871 or greater cv-qualification than, cv2. */
872 return (reference_related_p (t1, t2)
873 && at_least_as_qualified_p (t1, t2));
876 /* Determine whether or not the EXPR (of class type S) can be
877 converted to T as in [over.match.ref]. */
880 convert_class_to_reference (tree t, tree s, tree expr)
886 struct z_candidate *candidates;
887 struct z_candidate *cand;
890 conversions = lookup_conversions (s);
896 Assuming that "cv1 T" is the underlying type of the reference
897 being initialized, and "cv S" is the type of the initializer
898 expression, with S a class type, the candidate functions are
901 --The conversion functions of S and its base classes are
902 considered. Those that are not hidden within S and yield type
903 "reference to cv2 T2", where "cv1 T" is reference-compatible
904 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
906 The argument list has one argument, which is the initializer
911 /* Conceptually, we should take the address of EXPR and put it in
912 the argument list. Unfortunately, however, that can result in
913 error messages, which we should not issue now because we are just
914 trying to find a conversion operator. Therefore, we use NULL,
915 cast to the appropriate type. */
916 arglist = build_int_2 (0, 0);
917 TREE_TYPE (arglist) = build_pointer_type (s);
918 arglist = build_tree_list (NULL_TREE, arglist);
920 reference_type = build_reference_type (t);
924 tree fns = TREE_VALUE (conversions);
926 for (; fns; fns = OVL_NEXT (fns))
928 tree f = OVL_CURRENT (fns);
929 tree t2 = TREE_TYPE (TREE_TYPE (f));
933 /* If this is a template function, try to get an exact
935 if (TREE_CODE (f) == TEMPLATE_DECL)
937 cand = add_template_candidate (&candidates,
943 TREE_PURPOSE (conversions),
949 /* Now, see if the conversion function really returns
950 an lvalue of the appropriate type. From the
951 point of view of unification, simply returning an
952 rvalue of the right type is good enough. */
954 t2 = TREE_TYPE (TREE_TYPE (f));
955 if (TREE_CODE (t2) != REFERENCE_TYPE
956 || !reference_compatible_p (t, TREE_TYPE (t2)))
958 candidates = candidates->next;
963 else if (TREE_CODE (t2) == REFERENCE_TYPE
964 && reference_compatible_p (t, TREE_TYPE (t2)))
965 cand = add_function_candidate (&candidates, f, s, arglist,
967 TREE_PURPOSE (conversions),
972 conversion *identity_conv;
973 /* Build a standard conversion sequence indicating the
974 binding from the reference type returned by the
975 function to the desired REFERENCE_TYPE. */
977 = build_identity_conv (TREE_TYPE (TREE_TYPE
978 (TREE_TYPE (cand->fn))),
981 = (direct_reference_binding
982 (reference_type, identity_conv));
983 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
986 conversions = TREE_CHAIN (conversions);
989 candidates = splice_viable (candidates, pedantic, &any_viable_p);
990 /* If none of the conversion functions worked out, let our caller
995 cand = tourney (candidates);
999 /* Now that we know that this is the function we're going to use fix
1000 the dummy first argument. */
1001 cand->args = tree_cons (NULL_TREE,
1003 TREE_CHAIN (cand->args));
1005 /* Build a user-defined conversion sequence representing the
1007 conv = build_conv (ck_user,
1008 TREE_TYPE (TREE_TYPE (cand->fn)),
1009 build_identity_conv (TREE_TYPE (expr), expr));
1012 /* Merge it with the standard conversion sequence from the
1013 conversion function's return type to the desired type. */
1014 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1016 if (cand->viable == -1)
1019 return cand->second_conv;
1022 /* A reference of the indicated TYPE is being bound directly to the
1023 expression represented by the implicit conversion sequence CONV.
1024 Return a conversion sequence for this binding. */
1027 direct_reference_binding (tree type, conversion *conv)
1031 my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
1032 my_friendly_assert (TREE_CODE (conv->type) != REFERENCE_TYPE, 20030306);
1034 t = TREE_TYPE (type);
1038 When a parameter of reference type binds directly
1039 (_dcl.init.ref_) to an argument expression, the implicit
1040 conversion sequence is the identity conversion, unless the
1041 argument expression has a type that is a derived class of the
1042 parameter type, in which case the implicit conversion sequence is
1043 a derived-to-base Conversion.
1045 If the parameter binds directly to the result of applying a
1046 conversion function to the argument expression, the implicit
1047 conversion sequence is a user-defined conversion sequence
1048 (_over.ics.user_), with the second standard conversion sequence
1049 either an identity conversion or, if the conversion function
1050 returns an entity of a type that is a derived class of the
1051 parameter type, a derived-to-base conversion. */
1052 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1054 /* Represent the derived-to-base conversion. */
1055 conv = build_conv (ck_base, t, conv);
1056 /* We will actually be binding to the base-class subobject in
1057 the derived class, so we mark this conversion appropriately.
1058 That way, convert_like knows not to generate a temporary. */
1059 conv->need_temporary_p = false;
1061 return build_conv (ck_ref_bind, type, conv);
1064 /* Returns the conversion path from type FROM to reference type TO for
1065 purposes of reference binding. For lvalue binding, either pass a
1066 reference type to FROM or an lvalue expression to EXPR. If the
1067 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1068 the conversion returned. */
1071 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1073 conversion *conv = NULL;
1074 tree to = TREE_TYPE (rto);
1078 cp_lvalue_kind lvalue_p = clk_none;
1080 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1082 expr = instantiate_type (to, expr, tf_none);
1083 if (expr == error_mark_node)
1085 from = TREE_TYPE (expr);
1088 if (TREE_CODE (from) == REFERENCE_TYPE)
1090 /* Anything with reference type is an lvalue. */
1091 lvalue_p = clk_ordinary;
1092 from = TREE_TYPE (from);
1095 lvalue_p = real_lvalue_p (expr);
1097 /* Figure out whether or not the types are reference-related and
1098 reference compatible. We have do do this after stripping
1099 references from FROM. */
1100 related_p = reference_related_p (to, from);
1101 compatible_p = reference_compatible_p (to, from);
1103 if (lvalue_p && compatible_p)
1107 If the initializer expression
1109 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1110 is reference-compatible with "cv2 T2,"
1112 the reference is bound directly to the initializer expression
1114 conv = build_identity_conv (from, expr);
1115 conv = direct_reference_binding (rto, conv);
1116 if ((lvalue_p & clk_bitfield) != 0
1117 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1118 /* For the purposes of overload resolution, we ignore the fact
1119 this expression is a bitfield or packed field. (In particular,
1120 [over.ics.ref] says specifically that a function with a
1121 non-const reference parameter is viable even if the
1122 argument is a bitfield.)
1124 However, when we actually call the function we must create
1125 a temporary to which to bind the reference. If the
1126 reference is volatile, or isn't const, then we cannot make
1127 a temporary, so we just issue an error when the conversion
1129 conv->need_temporary_p = true;
1133 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1137 If the initializer expression
1139 -- has a class type (i.e., T2 is a class type) can be
1140 implicitly converted to an lvalue of type "cv3 T3," where
1141 "cv1 T1" is reference-compatible with "cv3 T3". (this
1142 conversion is selected by enumerating the applicable
1143 conversion functions (_over.match.ref_) and choosing the
1144 best one through overload resolution. (_over.match_).
1146 the reference is bound to the lvalue result of the conversion
1147 in the second case. */
1148 conv = convert_class_to_reference (to, from, expr);
1153 /* From this point on, we conceptually need temporaries, even if we
1154 elide them. Only the cases above are "direct bindings". */
1155 if (flags & LOOKUP_NO_TEMP_BIND)
1160 When a parameter of reference type is not bound directly to an
1161 argument expression, the conversion sequence is the one required
1162 to convert the argument expression to the underlying type of the
1163 reference according to _over.best.ics_. Conceptually, this
1164 conversion sequence corresponds to copy-initializing a temporary
1165 of the underlying type with the argument expression. Any
1166 difference in top-level cv-qualification is subsumed by the
1167 initialization itself and does not constitute a conversion. */
1171 Otherwise, the reference shall be to a non-volatile const type. */
1172 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1177 If the initializer expression is an rvalue, with T2 a class type,
1178 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1179 is bound in one of the following ways:
1181 -- The reference is bound to the object represented by the rvalue
1182 or to a sub-object within that object.
1186 We use the first alternative. The implicit conversion sequence
1187 is supposed to be same as we would obtain by generating a
1188 temporary. Fortunately, if the types are reference compatible,
1189 then this is either an identity conversion or the derived-to-base
1190 conversion, just as for direct binding. */
1191 if (CLASS_TYPE_P (from) && compatible_p)
1193 conv = build_identity_conv (from, expr);
1194 conv = direct_reference_binding (rto, conv);
1195 conv->u.next->check_copy_constructor_p = true;
1201 Otherwise, a temporary of type "cv1 T1" is created and
1202 initialized from the initializer expression using the rules for a
1203 non-reference copy initialization. If T1 is reference-related to
1204 T2, cv1 must be the same cv-qualification as, or greater
1205 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1206 if (related_p && !at_least_as_qualified_p (to, from))
1209 conv = implicit_conversion (to, from, expr, flags);
1213 conv = build_conv (ck_ref_bind, rto, conv);
1214 /* This reference binding, unlike those above, requires the
1215 creation of a temporary. */
1216 conv->need_temporary_p = true;
1221 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1222 to type TO. The optional expression EXPR may affect the conversion.
1223 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1227 implicit_conversion (tree to, tree from, tree expr, int flags)
1231 if (from == error_mark_node || to == error_mark_node
1232 || expr == error_mark_node)
1235 if (TREE_CODE (to) == REFERENCE_TYPE)
1236 conv = reference_binding (to, from, expr, flags);
1238 conv = standard_conversion (to, from, expr);
1243 if (expr != NULL_TREE
1244 && (IS_AGGR_TYPE (from)
1245 || IS_AGGR_TYPE (to))
1246 && (flags & LOOKUP_NO_CONVERSION) == 0)
1248 struct z_candidate *cand;
1250 cand = build_user_type_conversion_1
1251 (to, expr, LOOKUP_ONLYCONVERTING);
1253 conv = cand->second_conv;
1255 /* We used to try to bind a reference to a temporary here, but that
1256 is now handled by the recursive call to this function at the end
1257 of reference_binding. */
1264 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1267 static struct z_candidate *
1268 add_candidate (struct z_candidate **candidates,
1270 size_t num_convs, conversion **convs,
1271 tree access_path, tree conversion_path,
1274 struct z_candidate *cand
1275 = conversion_obstack_alloc (sizeof (struct z_candidate));
1279 cand->convs = convs;
1280 cand->num_convs = num_convs;
1281 cand->access_path = access_path;
1282 cand->conversion_path = conversion_path;
1283 cand->viable = viable;
1284 cand->next = *candidates;
1290 /* Create an overload candidate for the function or method FN called with
1291 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1292 to implicit_conversion.
1294 CTYPE, if non-NULL, is the type we want to pretend this function
1295 comes from for purposes of overload resolution. */
1297 static struct z_candidate *
1298 add_function_candidate (struct z_candidate **candidates,
1299 tree fn, tree ctype, tree arglist,
1300 tree access_path, tree conversion_path,
1303 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1306 tree parmnode, argnode;
1310 /* Built-in functions that haven't been declared don't really
1312 if (DECL_ANTICIPATED (fn))
1315 /* The `this', `in_chrg' and VTT arguments to constructors are not
1316 considered in overload resolution. */
1317 if (DECL_CONSTRUCTOR_P (fn))
1319 parmlist = skip_artificial_parms_for (fn, parmlist);
1320 orig_arglist = arglist;
1321 arglist = skip_artificial_parms_for (fn, arglist);
1324 orig_arglist = arglist;
1326 len = list_length (arglist);
1327 convs = alloc_conversions (len);
1329 /* 13.3.2 - Viable functions [over.match.viable]
1330 First, to be a viable function, a candidate function shall have enough
1331 parameters to agree in number with the arguments in the list.
1333 We need to check this first; otherwise, checking the ICSes might cause
1334 us to produce an ill-formed template instantiation. */
1336 parmnode = parmlist;
1337 for (i = 0; i < len; ++i)
1339 if (parmnode == NULL_TREE || parmnode == void_list_node)
1341 parmnode = TREE_CHAIN (parmnode);
1344 if (i < len && parmnode)
1347 /* Make sure there are default args for the rest of the parms. */
1348 else if (!sufficient_parms_p (parmnode))
1354 /* Second, for F to be a viable function, there shall exist for each
1355 argument an implicit conversion sequence that converts that argument
1356 to the corresponding parameter of F. */
1358 parmnode = parmlist;
1361 for (i = 0; i < len; ++i)
1363 tree arg = TREE_VALUE (argnode);
1364 tree argtype = lvalue_type (arg);
1368 if (parmnode == void_list_node)
1371 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1372 && ! DECL_CONSTRUCTOR_P (fn));
1376 tree parmtype = TREE_VALUE (parmnode);
1378 /* The type of the implicit object parameter ('this') for
1379 overload resolution is not always the same as for the
1380 function itself; conversion functions are considered to
1381 be members of the class being converted, and functions
1382 introduced by a using-declaration are considered to be
1383 members of the class that uses them.
1385 Since build_over_call ignores the ICS for the `this'
1386 parameter, we can just change the parm type. */
1387 if (ctype && is_this)
1390 = build_qualified_type (ctype,
1391 TYPE_QUALS (TREE_TYPE (parmtype)));
1392 parmtype = build_pointer_type (parmtype);
1395 t = implicit_conversion (parmtype, argtype, arg, flags);
1399 t = build_identity_conv (argtype, arg);
1400 t->ellipsis_p = true;
1417 parmnode = TREE_CHAIN (parmnode);
1418 argnode = TREE_CHAIN (argnode);
1422 return add_candidate (candidates, fn, orig_arglist, len, convs,
1423 access_path, conversion_path, viable);
1426 /* Create an overload candidate for the conversion function FN which will
1427 be invoked for expression OBJ, producing a pointer-to-function which
1428 will in turn be called with the argument list ARGLIST, and add it to
1429 CANDIDATES. FLAGS is passed on to implicit_conversion.
1431 Actually, we don't really care about FN; we care about the type it
1432 converts to. There may be multiple conversion functions that will
1433 convert to that type, and we rely on build_user_type_conversion_1 to
1434 choose the best one; so when we create our candidate, we record the type
1435 instead of the function. */
1437 static struct z_candidate *
1438 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1439 tree arglist, tree access_path, tree conversion_path)
1441 tree totype = TREE_TYPE (TREE_TYPE (fn));
1442 int i, len, viable, flags;
1443 tree parmlist, parmnode, argnode;
1446 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1447 parmlist = TREE_TYPE (parmlist);
1448 parmlist = TYPE_ARG_TYPES (parmlist);
1450 len = list_length (arglist) + 1;
1451 convs = alloc_conversions (len);
1452 parmnode = parmlist;
1455 flags = LOOKUP_NORMAL;
1457 /* Don't bother looking up the same type twice. */
1458 if (*candidates && (*candidates)->fn == totype)
1461 for (i = 0; i < len; ++i)
1463 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1464 tree argtype = lvalue_type (arg);
1468 t = implicit_conversion (totype, argtype, arg, flags);
1469 else if (parmnode == void_list_node)
1472 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1475 t = build_identity_conv (argtype, arg);
1476 t->ellipsis_p = true;
1490 parmnode = TREE_CHAIN (parmnode);
1491 argnode = TREE_CHAIN (argnode);
1497 if (!sufficient_parms_p (parmnode))
1500 return add_candidate (candidates, totype, arglist, len, convs,
1501 access_path, conversion_path, viable);
1505 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1506 tree type1, tree type2, tree *args, tree *argtypes,
1518 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1519 convs = alloc_conversions (num_convs);
1521 for (i = 0; i < 2; ++i)
1526 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1530 /* We need something for printing the candidate. */
1531 t = build_identity_conv (types[i], NULL_TREE);
1538 /* For COND_EXPR we rearranged the arguments; undo that now. */
1541 convs[2] = convs[1];
1542 convs[1] = convs[0];
1543 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1550 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1552 /*access_path=*/NULL_TREE,
1553 /*conversion_path=*/NULL_TREE,
1558 is_complete (tree t)
1560 return COMPLETE_TYPE_P (complete_type (t));
1563 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1566 promoted_arithmetic_type_p (tree type)
1570 In this section, the term promoted integral type is used to refer
1571 to those integral types which are preserved by integral promotion
1572 (including e.g. int and long but excluding e.g. char).
1573 Similarly, the term promoted arithmetic type refers to promoted
1574 integral types plus floating types. */
1575 return ((INTEGRAL_TYPE_P (type)
1576 && same_type_p (type_promotes_to (type), type))
1577 || TREE_CODE (type) == REAL_TYPE);
1580 /* Create any builtin operator overload candidates for the operator in
1581 question given the converted operand types TYPE1 and TYPE2. The other
1582 args are passed through from add_builtin_candidates to
1583 build_builtin_candidate.
1585 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1586 If CODE is requires candidates operands of the same type of the kind
1587 of which TYPE1 and TYPE2 are, we add both candidates
1588 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1591 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1592 enum tree_code code2, tree fnname, tree type1,
1593 tree type2, tree *args, tree *argtypes, int flags)
1597 case POSTINCREMENT_EXPR:
1598 case POSTDECREMENT_EXPR:
1599 args[1] = integer_zero_node;
1600 type2 = integer_type_node;
1609 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1610 and VQ is either volatile or empty, there exist candidate operator
1611 functions of the form
1612 VQ T& operator++(VQ T&);
1613 T operator++(VQ T&, int);
1614 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1615 type other than bool, and VQ is either volatile or empty, there exist
1616 candidate operator functions of the form
1617 VQ T& operator--(VQ T&);
1618 T operator--(VQ T&, int);
1619 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1620 complete object type, and VQ is either volatile or empty, there exist
1621 candidate operator functions of the form
1622 T*VQ& operator++(T*VQ&);
1623 T*VQ& operator--(T*VQ&);
1624 T* operator++(T*VQ&, int);
1625 T* operator--(T*VQ&, int); */
1627 case POSTDECREMENT_EXPR:
1628 case PREDECREMENT_EXPR:
1629 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1631 case POSTINCREMENT_EXPR:
1632 case PREINCREMENT_EXPR:
1633 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1635 type1 = build_reference_type (type1);
1640 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1641 exist candidate operator functions of the form
1645 8 For every function type T, there exist candidate operator functions of
1647 T& operator*(T*); */
1650 if (TREE_CODE (type1) == POINTER_TYPE
1651 && (TYPE_PTROB_P (type1)
1652 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1656 /* 9 For every type T, there exist candidate operator functions of the form
1659 10For every promoted arithmetic type T, there exist candidate operator
1660 functions of the form
1664 case CONVERT_EXPR: /* unary + */
1665 if (TREE_CODE (type1) == POINTER_TYPE)
1668 if (ARITHMETIC_TYPE_P (type1))
1672 /* 11For every promoted integral type T, there exist candidate operator
1673 functions of the form
1677 if (INTEGRAL_TYPE_P (type1))
1681 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1682 is the same type as C2 or is a derived class of C2, T is a complete
1683 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1684 there exist candidate operator functions of the form
1685 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1686 where CV12 is the union of CV1 and CV2. */
1689 if (TREE_CODE (type1) == POINTER_TYPE
1690 && TYPE_PTR_TO_MEMBER_P (type2))
1692 tree c1 = TREE_TYPE (type1);
1693 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1695 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1696 && (TYPE_PTRMEMFUNC_P (type2)
1697 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1702 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1703 didate operator functions of the form
1708 bool operator<(L, R);
1709 bool operator>(L, R);
1710 bool operator<=(L, R);
1711 bool operator>=(L, R);
1712 bool operator==(L, R);
1713 bool operator!=(L, R);
1714 where LR is the result of the usual arithmetic conversions between
1717 14For every pair of types T and I, where T is a cv-qualified or cv-
1718 unqualified complete object type and I is a promoted integral type,
1719 there exist candidate operator functions of the form
1720 T* operator+(T*, I);
1721 T& operator[](T*, I);
1722 T* operator-(T*, I);
1723 T* operator+(I, T*);
1724 T& operator[](I, T*);
1726 15For every T, where T is a pointer to complete object type, there exist
1727 candidate operator functions of the form112)
1728 ptrdiff_t operator-(T, T);
1730 16For every pointer or enumeration type T, there exist candidate operator
1731 functions of the form
1732 bool operator<(T, T);
1733 bool operator>(T, T);
1734 bool operator<=(T, T);
1735 bool operator>=(T, T);
1736 bool operator==(T, T);
1737 bool operator!=(T, T);
1739 17For every pointer to member type T, there exist candidate operator
1740 functions of the form
1741 bool operator==(T, T);
1742 bool operator!=(T, T); */
1745 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1747 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1749 type2 = ptrdiff_type_node;
1753 case TRUNC_DIV_EXPR:
1754 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1760 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1761 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1763 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1768 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1780 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1782 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1784 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1786 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1791 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1799 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1802 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1804 type1 = ptrdiff_type_node;
1807 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1809 type2 = ptrdiff_type_node;
1814 /* 18For every pair of promoted integral types L and R, there exist candi-
1815 date operator functions of the form
1822 where LR is the result of the usual arithmetic conversions between
1825 case TRUNC_MOD_EXPR:
1831 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1835 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1836 type, VQ is either volatile or empty, and R is a promoted arithmetic
1837 type, there exist candidate operator functions of the form
1838 VQ L& operator=(VQ L&, R);
1839 VQ L& operator*=(VQ L&, R);
1840 VQ L& operator/=(VQ L&, R);
1841 VQ L& operator+=(VQ L&, R);
1842 VQ L& operator-=(VQ L&, R);
1844 20For every pair T, VQ), where T is any type and VQ is either volatile
1845 or empty, there exist candidate operator functions of the form
1846 T*VQ& operator=(T*VQ&, T*);
1848 21For every pair T, VQ), where T is a pointer to member type and VQ is
1849 either volatile or empty, there exist candidate operator functions of
1851 VQ T& operator=(VQ T&, T);
1853 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1854 unqualified complete object type, VQ is either volatile or empty, and
1855 I is a promoted integral type, there exist candidate operator func-
1857 T*VQ& operator+=(T*VQ&, I);
1858 T*VQ& operator-=(T*VQ&, I);
1860 23For every triple L, VQ, R), where L is an integral or enumeration
1861 type, VQ is either volatile or empty, and R is a promoted integral
1862 type, there exist candidate operator functions of the form
1864 VQ L& operator%=(VQ L&, R);
1865 VQ L& operator<<=(VQ L&, R);
1866 VQ L& operator>>=(VQ L&, R);
1867 VQ L& operator&=(VQ L&, R);
1868 VQ L& operator^=(VQ L&, R);
1869 VQ L& operator|=(VQ L&, R); */
1876 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1878 type2 = ptrdiff_type_node;
1882 case TRUNC_DIV_EXPR:
1883 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1887 case TRUNC_MOD_EXPR:
1893 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1898 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1900 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1901 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1902 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1903 || ((TYPE_PTRMEMFUNC_P (type1)
1904 || TREE_CODE (type1) == POINTER_TYPE)
1905 && null_ptr_cst_p (args[1])))
1915 type1 = build_reference_type (type1);
1921 For every pair of promoted arithmetic types L and R, there
1922 exist candidate operator functions of the form
1924 LR operator?(bool, L, R);
1926 where LR is the result of the usual arithmetic conversions
1927 between types L and R.
1929 For every type T, where T is a pointer or pointer-to-member
1930 type, there exist candidate operator functions of the form T
1931 operator?(bool, T, T); */
1933 if (promoted_arithmetic_type_p (type1)
1934 && promoted_arithmetic_type_p (type2))
1938 /* Otherwise, the types should be pointers. */
1939 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1940 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1943 /* We don't check that the two types are the same; the logic
1944 below will actually create two candidates; one in which both
1945 parameter types are TYPE1, and one in which both parameter
1953 /* If we're dealing with two pointer types or two enumeral types,
1954 we need candidates for both of them. */
1955 if (type2 && !same_type_p (type1, type2)
1956 && TREE_CODE (type1) == TREE_CODE (type2)
1957 && (TREE_CODE (type1) == REFERENCE_TYPE
1958 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1959 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1960 || TYPE_PTRMEMFUNC_P (type1)
1961 || IS_AGGR_TYPE (type1)
1962 || TREE_CODE (type1) == ENUMERAL_TYPE))
1964 build_builtin_candidate
1965 (candidates, fnname, type1, type1, args, argtypes, flags);
1966 build_builtin_candidate
1967 (candidates, fnname, type2, type2, args, argtypes, flags);
1971 build_builtin_candidate
1972 (candidates, fnname, type1, type2, args, argtypes, flags);
1976 type_decays_to (tree type)
1978 if (TREE_CODE (type) == ARRAY_TYPE)
1979 return build_pointer_type (TREE_TYPE (type));
1980 if (TREE_CODE (type) == FUNCTION_TYPE)
1981 return build_pointer_type (type);
1985 /* There are three conditions of builtin candidates:
1987 1) bool-taking candidates. These are the same regardless of the input.
1988 2) pointer-pair taking candidates. These are generated for each type
1989 one of the input types converts to.
1990 3) arithmetic candidates. According to the standard, we should generate
1991 all of these, but I'm trying not to...
1993 Here we generate a superset of the possible candidates for this particular
1994 case. That is a subset of the full set the standard defines, plus some
1995 other cases which the standard disallows. add_builtin_candidate will
1996 filter out the invalid set. */
1999 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2000 enum tree_code code2, tree fnname, tree *args,
2005 tree type, argtypes[3];
2006 /* TYPES[i] is the set of possible builtin-operator parameter types
2007 we will consider for the Ith argument. These are represented as
2008 a TREE_LIST; the TREE_VALUE of each node is the potential
2012 for (i = 0; i < 3; ++i)
2015 argtypes[i] = lvalue_type (args[i]);
2017 argtypes[i] = NULL_TREE;
2022 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2023 and VQ is either volatile or empty, there exist candidate operator
2024 functions of the form
2025 VQ T& operator++(VQ T&); */
2027 case POSTINCREMENT_EXPR:
2028 case PREINCREMENT_EXPR:
2029 case POSTDECREMENT_EXPR:
2030 case PREDECREMENT_EXPR:
2035 /* 24There also exist candidate operator functions of the form
2036 bool operator!(bool);
2037 bool operator&&(bool, bool);
2038 bool operator||(bool, bool); */
2040 case TRUTH_NOT_EXPR:
2041 build_builtin_candidate
2042 (candidates, fnname, boolean_type_node,
2043 NULL_TREE, args, argtypes, flags);
2046 case TRUTH_ORIF_EXPR:
2047 case TRUTH_ANDIF_EXPR:
2048 build_builtin_candidate
2049 (candidates, fnname, boolean_type_node,
2050 boolean_type_node, args, argtypes, flags);
2072 types[0] = types[1] = NULL_TREE;
2074 for (i = 0; i < 2; ++i)
2078 else if (IS_AGGR_TYPE (argtypes[i]))
2082 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2085 convs = lookup_conversions (argtypes[i]);
2087 if (code == COND_EXPR)
2089 if (real_lvalue_p (args[i]))
2090 types[i] = tree_cons
2091 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2093 types[i] = tree_cons
2094 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2100 for (; convs; convs = TREE_CHAIN (convs))
2102 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2105 && (TREE_CODE (type) != REFERENCE_TYPE
2106 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2109 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2110 types[i] = tree_cons (NULL_TREE, type, types[i]);
2112 type = non_reference (type);
2113 if (i != 0 || ! ref1)
2115 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2116 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2117 types[i] = tree_cons (NULL_TREE, type, types[i]);
2118 if (INTEGRAL_TYPE_P (type))
2119 type = type_promotes_to (type);
2122 if (! value_member (type, types[i]))
2123 types[i] = tree_cons (NULL_TREE, type, types[i]);
2128 if (code == COND_EXPR && real_lvalue_p (args[i]))
2129 types[i] = tree_cons
2130 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2131 type = non_reference (argtypes[i]);
2132 if (i != 0 || ! ref1)
2134 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2135 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2136 types[i] = tree_cons (NULL_TREE, type, types[i]);
2137 if (INTEGRAL_TYPE_P (type))
2138 type = type_promotes_to (type);
2140 types[i] = tree_cons (NULL_TREE, type, types[i]);
2144 /* Run through the possible parameter types of both arguments,
2145 creating candidates with those parameter types. */
2146 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2149 for (type = types[1]; type; type = TREE_CHAIN (type))
2150 add_builtin_candidate
2151 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2152 TREE_VALUE (type), args, argtypes, flags);
2154 add_builtin_candidate
2155 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2156 NULL_TREE, args, argtypes, flags);
2163 /* If TMPL can be successfully instantiated as indicated by
2164 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2166 TMPL is the template. EXPLICIT_TARGS are any explicit template
2167 arguments. ARGLIST is the arguments provided at the call-site.
2168 The RETURN_TYPE is the desired type for conversion operators. If
2169 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2170 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2171 add_conv_candidate. */
2173 static struct z_candidate*
2174 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2175 tree ctype, tree explicit_targs, tree arglist,
2176 tree return_type, tree access_path,
2177 tree conversion_path, int flags, tree obj,
2178 unification_kind_t strict)
2180 int ntparms = DECL_NTPARMS (tmpl);
2181 tree targs = make_tree_vec (ntparms);
2182 tree args_without_in_chrg = arglist;
2183 struct z_candidate *cand;
2187 /* We don't do deduction on the in-charge parameter, the VTT
2188 parameter or 'this'. */
2189 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2190 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2192 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2193 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2194 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
2195 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2197 i = fn_type_unification (tmpl, explicit_targs, targs,
2198 args_without_in_chrg,
2199 return_type, strict, -1);
2204 fn = instantiate_template (tmpl, targs, tf_none);
2205 if (fn == error_mark_node)
2210 A member function template is never instantiated to perform the
2211 copy of a class object to an object of its class type.
2213 It's a little unclear what this means; the standard explicitly
2214 does allow a template to be used to copy a class. For example,
2219 template <class T> A(const T&);
2222 void g () { A a (f ()); }
2224 the member template will be used to make the copy. The section
2225 quoted above appears in the paragraph that forbids constructors
2226 whose only parameter is (a possibly cv-qualified variant of) the
2227 class type, and a logical interpretation is that the intent was
2228 to forbid the instantiation of member templates which would then
2230 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2232 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2233 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2238 if (obj != NULL_TREE)
2239 /* Aha, this is a conversion function. */
2240 cand = add_conv_candidate (candidates, fn, obj, access_path,
2241 conversion_path, arglist);
2243 cand = add_function_candidate (candidates, fn, ctype,
2244 arglist, access_path,
2245 conversion_path, flags);
2246 if (DECL_TI_TEMPLATE (fn) != tmpl)
2247 /* This situation can occur if a member template of a template
2248 class is specialized. Then, instantiate_template might return
2249 an instantiation of the specialization, in which case the
2250 DECL_TI_TEMPLATE field will point at the original
2251 specialization. For example:
2253 template <class T> struct S { template <class U> void f(U);
2254 template <> void f(int) {}; };
2258 Here, TMPL will be template <class U> S<double>::f(U).
2259 And, instantiate template will give us the specialization
2260 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2261 for this will point at template <class T> template <> S<T>::f(int),
2262 so that we can find the definition. For the purposes of
2263 overload resolution, however, we want the original TMPL. */
2264 cand->template = tree_cons (tmpl, targs, NULL_TREE);
2266 cand->template = DECL_TEMPLATE_INFO (fn);
2272 static struct z_candidate *
2273 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2274 tree explicit_targs, tree arglist, tree return_type,
2275 tree access_path, tree conversion_path, int flags,
2276 unification_kind_t strict)
2279 add_template_candidate_real (candidates, tmpl, ctype,
2280 explicit_targs, arglist, return_type,
2281 access_path, conversion_path,
2282 flags, NULL_TREE, strict);
2286 static struct z_candidate *
2287 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2288 tree obj, tree arglist, tree return_type,
2289 tree access_path, tree conversion_path)
2292 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2293 arglist, return_type, access_path,
2294 conversion_path, 0, obj, DEDUCE_CONV);
2297 /* The CANDS are the set of candidates that were considered for
2298 overload resolution. Return the set of viable candidates. If none
2299 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2300 is true if a candidate should be considered viable only if it is
2303 static struct z_candidate*
2304 splice_viable (struct z_candidate *cands,
2308 struct z_candidate *viable;
2309 struct z_candidate **last_viable;
2310 struct z_candidate **cand;
2313 last_viable = &viable;
2314 *any_viable_p = false;
2319 struct z_candidate *c = *cand;
2320 if (strict_p ? c->viable == 1 : c->viable)
2325 last_viable = &c->next;
2326 *any_viable_p = true;
2332 return viable ? viable : cands;
2336 any_strictly_viable (struct z_candidate *cands)
2338 for (; cands; cands = cands->next)
2339 if (cands->viable == 1)
2345 build_this (tree obj)
2347 /* Fix this to work on non-lvalues. */
2348 return build_unary_op (ADDR_EXPR, obj, 0);
2351 /* Returns true iff functions are equivalent. Equivalent functions are
2352 not '==' only if one is a function-local extern function or if
2353 both are extern "C". */
2356 equal_functions (tree fn1, tree fn2)
2358 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2359 || DECL_EXTERN_C_FUNCTION_P (fn1))
2360 return decls_match (fn1, fn2);
2364 /* Print information about one overload candidate CANDIDATE. MSGSTR
2365 is the text to print before the candidate itself.
2367 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2368 to have been run through gettext by the caller. This wart makes
2369 life simpler in print_z_candidates and for the translators. */
2372 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2374 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2376 if (candidate->num_convs == 3)
2377 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2378 candidate->convs[0]->type,
2379 candidate->convs[1]->type,
2380 candidate->convs[2]->type);
2381 else if (candidate->num_convs == 2)
2382 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2383 candidate->convs[0]->type,
2384 candidate->convs[1]->type);
2386 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2387 candidate->convs[0]->type);
2389 else if (TYPE_P (candidate->fn))
2390 inform ("%s %T <conversion>", msgstr, candidate->fn);
2391 else if (candidate->viable == -1)
2392 inform ("%J%s %+#D <near match>", candidate->fn, msgstr, candidate->fn);
2394 inform ("%J%s %+#D", candidate->fn, msgstr, candidate->fn);
2398 print_z_candidates (struct z_candidate *candidates)
2401 struct z_candidate *cand1;
2402 struct z_candidate **cand2;
2404 /* There may be duplicates in the set of candidates. We put off
2405 checking this condition as long as possible, since we have no way
2406 to eliminate duplicates from a set of functions in less than n^2
2407 time. Now we are about to emit an error message, so it is more
2408 permissible to go slowly. */
2409 for (cand1 = candidates; cand1; cand1 = cand1->next)
2411 tree fn = cand1->fn;
2412 /* Skip builtin candidates and conversion functions. */
2413 if (TREE_CODE (fn) != FUNCTION_DECL)
2415 cand2 = &cand1->next;
2418 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2419 && equal_functions (fn, (*cand2)->fn))
2420 *cand2 = (*cand2)->next;
2422 cand2 = &(*cand2)->next;
2429 str = _("candidates are:");
2430 print_z_candidate (str, candidates);
2431 if (candidates->next)
2433 /* Indent successive candidates by the width of the translation
2434 of the above string. */
2435 size_t len = gcc_gettext_width (str) + 1;
2436 char *spaces = alloca (len);
2437 memset (spaces, ' ', len-1);
2438 spaces[len - 1] = '\0';
2440 candidates = candidates->next;
2443 print_z_candidate (spaces, candidates);
2444 candidates = candidates->next;
2450 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2451 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2452 the result of the conversion function to convert it to the final
2453 desired type. Merge the the two sequences into a single sequence,
2454 and return the merged sequence. */
2457 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2461 my_friendly_assert (user_seq->kind == ck_user, 20030306);
2463 /* Find the end of the second conversion sequence. */
2465 while ((*t)->kind != ck_identity)
2466 t = &((*t)->u.next);
2468 /* Replace the identity conversion with the user conversion
2472 /* The entire sequence is a user-conversion sequence. */
2473 std_seq->user_conv_p = true;
2478 /* Returns the best overload candidate to perform the requested
2479 conversion. This function is used for three the overloading situations
2480 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2481 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2482 per [dcl.init.ref], so we ignore temporary bindings. */
2484 static struct z_candidate *
2485 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2487 struct z_candidate *candidates, *cand;
2488 tree fromtype = TREE_TYPE (expr);
2489 tree ctors = NULL_TREE;
2490 tree conv_fns = NULL_TREE;
2491 conversion *conv = NULL;
2492 tree args = NULL_TREE;
2495 /* We represent conversion within a hierarchy using RVALUE_CONV and
2496 BASE_CONV, as specified by [over.best.ics]; these become plain
2497 constructor calls, as specified in [dcl.init]. */
2498 my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2499 || !DERIVED_FROM_P (totype, fromtype), 20011226);
2501 if (IS_AGGR_TYPE (totype))
2502 ctors = lookup_fnfields (TYPE_BINFO (totype),
2503 complete_ctor_identifier,
2506 if (IS_AGGR_TYPE (fromtype))
2507 conv_fns = lookup_conversions (fromtype);
2510 flags |= LOOKUP_NO_CONVERSION;
2516 ctors = BASELINK_FUNCTIONS (ctors);
2518 t = build_int_2 (0, 0);
2519 TREE_TYPE (t) = build_pointer_type (totype);
2520 args = build_tree_list (NULL_TREE, expr);
2521 /* We should never try to call the abstract or base constructor
2523 my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2524 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),
2526 args = tree_cons (NULL_TREE, t, args);
2528 for (; ctors; ctors = OVL_NEXT (ctors))
2530 tree ctor = OVL_CURRENT (ctors);
2531 if (DECL_NONCONVERTING_P (ctor))
2534 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2535 cand = add_template_candidate (&candidates, ctor, totype,
2536 NULL_TREE, args, NULL_TREE,
2537 TYPE_BINFO (totype),
2538 TYPE_BINFO (totype),
2542 cand = add_function_candidate (&candidates, ctor, totype,
2543 args, TYPE_BINFO (totype),
2544 TYPE_BINFO (totype),
2548 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2552 args = build_tree_list (NULL_TREE, build_this (expr));
2554 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2557 tree conversion_path = TREE_PURPOSE (conv_fns);
2558 int convflags = LOOKUP_NO_CONVERSION;
2560 /* If we are called to convert to a reference type, we are trying to
2561 find an lvalue binding, so don't even consider temporaries. If
2562 we don't find an lvalue binding, the caller will try again to
2563 look for a temporary binding. */
2564 if (TREE_CODE (totype) == REFERENCE_TYPE)
2565 convflags |= LOOKUP_NO_TEMP_BIND;
2567 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2569 tree fn = OVL_CURRENT (fns);
2571 /* [over.match.funcs] For conversion functions, the function
2572 is considered to be a member of the class of the implicit
2573 object argument for the purpose of defining the type of
2574 the implicit object parameter.
2576 So we pass fromtype as CTYPE to add_*_candidate. */
2578 if (TREE_CODE (fn) == TEMPLATE_DECL)
2579 cand = add_template_candidate (&candidates, fn, fromtype,
2582 TYPE_BINFO (fromtype),
2587 cand = add_function_candidate (&candidates, fn, fromtype,
2589 TYPE_BINFO (fromtype),
2596 = implicit_conversion (totype,
2597 TREE_TYPE (TREE_TYPE (cand->fn)),
2600 cand->second_conv = ics;
2604 else if (candidates->viable == 1 && ics->bad_p)
2610 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2614 cand = tourney (candidates);
2617 if (flags & LOOKUP_COMPLAIN)
2619 error ("conversion from `%T' to `%T' is ambiguous",
2621 print_z_candidates (candidates);
2624 cand = candidates; /* any one will do */
2625 cand->second_conv = build_ambiguous_conv (totype, expr);
2626 cand->second_conv->user_conv_p = true;
2627 if (!any_strictly_viable (candidates))
2628 cand->second_conv->bad_p = true;
2629 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2630 ambiguous conversion is no worse than another user-defined
2636 /* Build the user conversion sequence. */
2639 (DECL_CONSTRUCTOR_P (cand->fn)
2640 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2641 build_identity_conv (TREE_TYPE (expr), expr));
2644 /* Combine it with the second conversion sequence. */
2645 cand->second_conv = merge_conversion_sequences (conv,
2648 if (cand->viable == -1)
2649 cand->second_conv->bad_p = true;
2655 build_user_type_conversion (tree totype, tree expr, int flags)
2657 struct z_candidate *cand
2658 = build_user_type_conversion_1 (totype, expr, flags);
2662 if (cand->second_conv->kind == ck_ambig)
2663 return error_mark_node;
2664 return convert_from_reference (convert_like (cand->second_conv, expr));
2669 /* Do any initial processing on the arguments to a function call. */
2672 resolve_args (tree args)
2675 for (t = args; t; t = TREE_CHAIN (t))
2677 tree arg = TREE_VALUE (t);
2679 if (arg == error_mark_node)
2680 return error_mark_node;
2681 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2683 error ("invalid use of void expression");
2684 return error_mark_node;
2686 arg = convert_from_reference (arg);
2687 TREE_VALUE (t) = arg;
2692 /* Perform overload resolution on FN, which is called with the ARGS.
2694 Return the candidate function selected by overload resolution, or
2695 NULL if the event that overload resolution failed. In the case
2696 that overload resolution fails, *CANDIDATES will be the set of
2697 candidates considered, and ANY_VIABLE_P will be set to true or
2698 false to indicate whether or not any of the candidates were
2701 The ARGS should already have gone through RESOLVE_ARGS before this
2702 function is called. */
2704 static struct z_candidate *
2705 perform_overload_resolution (tree fn,
2707 struct z_candidate **candidates,
2710 struct z_candidate *cand;
2711 tree explicit_targs = NULL_TREE;
2712 int template_only = 0;
2715 *any_viable_p = true;
2717 /* Check FN and ARGS. */
2718 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
2719 || TREE_CODE (fn) == TEMPLATE_DECL
2720 || TREE_CODE (fn) == OVERLOAD
2721 || TREE_CODE (fn) == TEMPLATE_ID_EXPR,
2723 my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
2726 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2728 explicit_targs = TREE_OPERAND (fn, 1);
2729 fn = TREE_OPERAND (fn, 0);
2733 /* Add the various candidate functions. */
2734 add_candidates (fn, args, explicit_targs, template_only,
2735 /*conversion_path=*/NULL_TREE,
2736 /*access_path=*/NULL_TREE,
2740 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2744 cand = tourney (*candidates);
2748 /* Return an expression for a call to FN (a namespace-scope function,
2749 or a static member function) with the ARGS. */
2752 build_new_function_call (tree fn, tree args)
2754 struct z_candidate *candidates, *cand;
2759 args = resolve_args (args);
2760 if (args == error_mark_node)
2761 return error_mark_node;
2763 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2764 p = conversion_obstack_alloc (0);
2766 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2770 if (!any_viable_p && candidates && ! candidates->next)
2771 return build_function_call (candidates->fn, args);
2772 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2773 fn = TREE_OPERAND (fn, 0);
2775 error ("no matching function for call to `%D(%A)'",
2776 DECL_NAME (OVL_CURRENT (fn)), args);
2778 error ("call of overloaded `%D(%A)' is ambiguous",
2779 DECL_NAME (OVL_CURRENT (fn)), args);
2781 print_z_candidates (candidates);
2782 result = error_mark_node;
2785 result = build_over_call (cand, LOOKUP_NORMAL);
2787 /* Free all the conversions we allocated. */
2788 obstack_free (&conversion_obstack, p);
2793 /* Build a call to a global operator new. FNNAME is the name of the
2794 operator (either "operator new" or "operator new[]") and ARGS are
2795 the arguments provided. *SIZE points to the total number of bytes
2796 required by the allocation, and is updated if that is changed here.
2797 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2798 function determines that no cookie should be used, after all,
2799 *COOKIE_SIZE is set to NULL_TREE. */
2802 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2805 struct z_candidate *candidates;
2806 struct z_candidate *cand;
2809 args = tree_cons (NULL_TREE, *size, args);
2810 args = resolve_args (args);
2811 if (args == error_mark_node)
2814 fns = lookup_function_nonclass (fnname, args);
2816 /* Figure out what function is being called. */
2817 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2819 /* If no suitable function could be found, issue an error message
2824 error ("no matching function for call to `%D(%A)'",
2825 DECL_NAME (OVL_CURRENT (fns)), args);
2827 error ("call of overloaded `%D(%A)' is ambiguous",
2828 DECL_NAME (OVL_CURRENT (fns)), args);
2830 print_z_candidates (candidates);
2831 return error_mark_node;
2834 /* If a cookie is required, add some extra space. Whether
2835 or not a cookie is required cannot be determined until
2836 after we know which function was called. */
2839 bool use_cookie = true;
2840 if (!abi_version_at_least (2))
2842 tree placement = TREE_CHAIN (args);
2843 /* In G++ 3.2, the check was implemented incorrectly; it
2844 looked at the placement expression, rather than the
2845 type of the function. */
2846 if (placement && !TREE_CHAIN (placement)
2847 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2855 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2856 /* Skip the size_t parameter. */
2857 arg_types = TREE_CHAIN (arg_types);
2858 /* Check the remaining parameters (if any). */
2860 && TREE_CHAIN (arg_types) == void_list_node
2861 && same_type_p (TREE_VALUE (arg_types),
2865 /* If we need a cookie, adjust the number of bytes allocated. */
2868 /* Update the total size. */
2869 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2870 /* Update the argument list to reflect the adjusted size. */
2871 TREE_VALUE (args) = *size;
2874 *cookie_size = NULL_TREE;
2877 /* Build the CALL_EXPR. */
2878 return build_over_call (cand, LOOKUP_NORMAL);
2882 build_object_call (tree obj, tree args)
2884 struct z_candidate *candidates = 0, *cand;
2885 tree fns, convs, mem_args = NULL_TREE;
2886 tree type = TREE_TYPE (obj);
2888 tree result = NULL_TREE;
2891 if (TYPE_PTRMEMFUNC_P (type))
2893 /* It's no good looking for an overloaded operator() on a
2894 pointer-to-member-function. */
2895 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2896 return error_mark_node;
2899 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2900 if (fns == error_mark_node)
2901 return error_mark_node;
2903 args = resolve_args (args);
2905 if (args == error_mark_node)
2906 return error_mark_node;
2908 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2909 p = conversion_obstack_alloc (0);
2913 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2914 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2916 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2918 tree fn = OVL_CURRENT (fns);
2919 if (TREE_CODE (fn) == TEMPLATE_DECL)
2920 add_template_candidate (&candidates, fn, base, NULL_TREE,
2921 mem_args, NULL_TREE,
2924 LOOKUP_NORMAL, DEDUCE_CALL);
2926 add_function_candidate
2927 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2928 TYPE_BINFO (type), LOOKUP_NORMAL);
2932 convs = lookup_conversions (type);
2934 for (; convs; convs = TREE_CHAIN (convs))
2936 tree fns = TREE_VALUE (convs);
2937 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2939 if ((TREE_CODE (totype) == POINTER_TYPE
2940 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2941 || (TREE_CODE (totype) == REFERENCE_TYPE
2942 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2943 || (TREE_CODE (totype) == REFERENCE_TYPE
2944 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2945 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
2946 for (; fns; fns = OVL_NEXT (fns))
2948 tree fn = OVL_CURRENT (fns);
2949 if (TREE_CODE (fn) == TEMPLATE_DECL)
2950 add_template_conv_candidate
2951 (&candidates, fn, obj, args, totype,
2952 /*access_path=*/NULL_TREE,
2953 /*conversion_path=*/NULL_TREE);
2955 add_conv_candidate (&candidates, fn, obj, args,
2956 /*conversion_path=*/NULL_TREE,
2957 /*access_path=*/NULL_TREE);
2961 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2964 error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
2965 print_z_candidates (candidates);
2966 result = error_mark_node;
2970 cand = tourney (candidates);
2973 error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
2974 print_z_candidates (candidates);
2975 result = error_mark_node;
2977 /* Since cand->fn will be a type, not a function, for a conversion
2978 function, we must be careful not to unconditionally look at
2980 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
2981 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
2982 result = build_over_call (cand, LOOKUP_NORMAL);
2985 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
2986 result = build_function_call (obj, args);
2990 /* Free all the conversions we allocated. */
2991 obstack_free (&conversion_obstack, p);
2997 op_error (enum tree_code code, enum tree_code code2,
2998 tree arg1, tree arg2, tree arg3, const char *problem)
3002 if (code == MODIFY_EXPR)
3003 opname = assignment_operator_name_info[code2].name;
3005 opname = operator_name_info[code].name;
3010 error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
3011 problem, arg1, arg2, arg3);
3014 case POSTINCREMENT_EXPR:
3015 case POSTDECREMENT_EXPR:
3016 error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname);
3020 error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2);
3025 error ("%s for '%s' in '%s %E'", problem, opname, opname, arg1);
3030 error ("%s for 'operator%s' in '%E %s %E'",
3031 problem, opname, arg1, opname, arg2);
3033 error ("%s for 'operator%s' in '%s%E'",
3034 problem, opname, opname, arg1);
3039 /* Return the implicit conversion sequence that could be used to
3040 convert E1 to E2 in [expr.cond]. */
3043 conditional_conversion (tree e1, tree e2)
3045 tree t1 = non_reference (TREE_TYPE (e1));
3046 tree t2 = non_reference (TREE_TYPE (e2));
3052 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3053 implicitly converted (clause _conv_) to the type "reference to
3054 T2", subject to the constraint that in the conversion the
3055 reference must bind directly (_dcl.init.ref_) to E1. */
3056 if (real_lvalue_p (e2))
3058 conv = implicit_conversion (build_reference_type (t2),
3061 LOOKUP_NO_TEMP_BIND);
3068 If E1 and E2 have class type, and the underlying class types are
3069 the same or one is a base class of the other: E1 can be converted
3070 to match E2 if the class of T2 is the same type as, or a base
3071 class of, the class of T1, and the cv-qualification of T2 is the
3072 same cv-qualification as, or a greater cv-qualification than, the
3073 cv-qualification of T1. If the conversion is applied, E1 is
3074 changed to an rvalue of type T2 that still refers to the original
3075 source class object (or the appropriate subobject thereof).
3077 FIXME we can't express an rvalue that refers to the original object;
3078 we have to create a new one. */
3079 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3080 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3082 if (good_base && at_least_as_qualified_p (t2, t1))
3084 conv = build_identity_conv (t1, e1);
3085 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3086 TYPE_MAIN_VARIANT (t2)))
3088 conv = build_conv (ck_base, t2, conv);
3089 conv->need_temporary_p = true;
3092 conv = build_conv (ck_rvalue, t2, conv);
3101 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3102 converted to the type that expression E2 would have if E2 were
3103 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3104 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3107 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3108 arguments to the conditional expression. */
3111 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3115 tree result = NULL_TREE;
3116 tree result_type = NULL_TREE;
3117 bool lvalue_p = true;
3118 struct z_candidate *candidates = 0;
3119 struct z_candidate *cand;
3122 /* As a G++ extension, the second argument to the conditional can be
3123 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3124 c'.) If the second operand is omitted, make sure it is
3125 calculated only once. */
3129 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3131 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3132 if (real_lvalue_p (arg1))
3133 arg2 = arg1 = stabilize_reference (arg1);
3135 arg2 = arg1 = save_expr (arg1);
3140 The first expr ession is implicitly converted to bool (clause
3142 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3144 /* If something has already gone wrong, just pass that fact up the
3146 if (error_operand_p (arg1)
3147 || error_operand_p (arg2)
3148 || error_operand_p (arg3))
3149 return error_mark_node;
3153 If either the second or the third operand has type (possibly
3154 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3155 array-to-pointer (_conv.array_), and function-to-pointer
3156 (_conv.func_) standard conversions are performed on the second
3157 and third operands. */
3158 arg2_type = TREE_TYPE (arg2);
3159 arg3_type = TREE_TYPE (arg3);
3160 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3162 /* Do the conversions. We don't these for `void' type arguments
3163 since it can't have any effect and since decay_conversion
3164 does not handle that case gracefully. */
3165 if (!VOID_TYPE_P (arg2_type))
3166 arg2 = decay_conversion (arg2);
3167 if (!VOID_TYPE_P (arg3_type))
3168 arg3 = decay_conversion (arg3);
3169 arg2_type = TREE_TYPE (arg2);
3170 arg3_type = TREE_TYPE (arg3);
3174 One of the following shall hold:
3176 --The second or the third operand (but not both) is a
3177 throw-expression (_except.throw_); the result is of the
3178 type of the other and is an rvalue.
3180 --Both the second and the third operands have type void; the
3181 result is of type void and is an rvalue. */
3182 if (TREE_CODE (arg2) == THROW_EXPR
3183 && TREE_CODE (arg3) != THROW_EXPR)
3185 arg3 = force_rvalue (arg3);
3186 arg3_type = TREE_TYPE (arg3);
3187 result_type = arg3_type;
3189 else if (TREE_CODE (arg2) != THROW_EXPR
3190 && TREE_CODE (arg3) == THROW_EXPR)
3192 arg2 = force_rvalue (arg2);
3193 arg2_type = TREE_TYPE (arg2);
3194 result_type = arg2_type;
3196 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3197 result_type = void_type_node;
3200 error ("`%E' has type `void' and is not a throw-expression",
3201 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3202 return error_mark_node;
3206 goto valid_operands;
3210 Otherwise, if the second and third operand have different types,
3211 and either has (possibly cv-qualified) class type, an attempt is
3212 made to convert each of those operands to the type of the other. */
3213 else if (!same_type_p (arg2_type, arg3_type)
3214 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3219 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3220 p = conversion_obstack_alloc (0);
3222 conv2 = conditional_conversion (arg2, arg3);
3223 conv3 = conditional_conversion (arg3, arg2);
3227 If both can be converted, or one can be converted but the
3228 conversion is ambiguous, the program is ill-formed. If
3229 neither can be converted, the operands are left unchanged and
3230 further checking is performed as described below. If exactly
3231 one conversion is possible, that conversion is applied to the
3232 chosen operand and the converted operand is used in place of
3233 the original operand for the remainder of this section. */
3234 if ((conv2 && !conv2->bad_p
3235 && conv3 && !conv3->bad_p)
3236 || (conv2 && conv2->kind == ck_ambig)
3237 || (conv3 && conv3->kind == ck_ambig))
3239 error ("operands to ?: have different types");
3240 result = error_mark_node;
3242 else if (conv2 && !conv2->bad_p)
3244 arg2 = convert_like (conv2, arg2);
3245 arg2 = convert_from_reference (arg2);
3246 if (!same_type_p (TREE_TYPE (arg2), arg3_type)
3247 && CLASS_TYPE_P (arg3_type))
3248 /* The types need to match if we're converting to a class type.
3249 If not, we don't care about cv-qual mismatches, since
3250 non-class rvalues are not cv-qualified. */
3252 arg2_type = TREE_TYPE (arg2);
3254 else if (conv3 && !conv3->bad_p)
3256 arg3 = convert_like (conv3, arg3);
3257 arg3 = convert_from_reference (arg3);
3258 if (!same_type_p (TREE_TYPE (arg3), arg2_type)
3259 && CLASS_TYPE_P (arg2_type))
3261 arg3_type = TREE_TYPE (arg3);
3264 /* Free all the conversions we allocated. */
3265 obstack_free (&conversion_obstack, p);
3273 If the second and third operands are lvalues and have the same
3274 type, the result is of that type and is an lvalue. */
3275 if (real_lvalue_p (arg2)
3276 && real_lvalue_p (arg3)
3277 && same_type_p (arg2_type, arg3_type))
3279 result_type = arg2_type;
3280 goto valid_operands;
3285 Otherwise, the result is an rvalue. If the second and third
3286 operand do not have the same type, and either has (possibly
3287 cv-qualified) class type, overload resolution is used to
3288 determine the conversions (if any) to be applied to the operands
3289 (_over.match.oper_, _over.built_). */
3291 if (!same_type_p (arg2_type, arg3_type)
3292 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3298 /* Rearrange the arguments so that add_builtin_candidate only has
3299 to know about two args. In build_builtin_candidates, the
3300 arguments are unscrambled. */
3304 add_builtin_candidates (&candidates,
3307 ansi_opname (COND_EXPR),
3313 If the overload resolution fails, the program is
3315 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3318 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3319 print_z_candidates (candidates);
3320 return error_mark_node;
3322 cand = tourney (candidates);
3325 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3326 print_z_candidates (candidates);
3327 return error_mark_node;
3332 Otherwise, the conversions thus determined are applied, and
3333 the converted operands are used in place of the original
3334 operands for the remainder of this section. */
3335 conv = cand->convs[0];
3336 arg1 = convert_like (conv, arg1);
3337 conv = cand->convs[1];
3338 arg2 = convert_like (conv, arg2);
3339 conv = cand->convs[2];
3340 arg3 = convert_like (conv, arg3);
3345 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3346 and function-to-pointer (_conv.func_) standard conversions are
3347 performed on the second and third operands.
3349 We need to force the lvalue-to-rvalue conversion here for class types,
3350 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3351 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3354 We use ocp_convert rather than build_user_type_conversion because the
3355 latter returns NULL_TREE on failure, while the former gives an error. */
3357 arg2 = force_rvalue (arg2);
3358 arg2_type = TREE_TYPE (arg2);
3360 arg3 = force_rvalue (arg3);
3361 arg3_type = TREE_TYPE (arg3);
3363 if (arg2 == error_mark_node || arg3 == error_mark_node)
3364 return error_mark_node;
3368 After those conversions, one of the following shall hold:
3370 --The second and third operands have the same type; the result is of
3372 if (same_type_p (arg2_type, arg3_type))
3373 result_type = arg2_type;
3376 --The second and third operands have arithmetic or enumeration
3377 type; the usual arithmetic conversions are performed to bring
3378 them to a common type, and the result is of that type. */
3379 else if ((ARITHMETIC_TYPE_P (arg2_type)
3380 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3381 && (ARITHMETIC_TYPE_P (arg3_type)
3382 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3384 /* In this case, there is always a common type. */
3385 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3388 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3389 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3390 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3391 arg2_type, arg3_type);
3392 else if (extra_warnings
3393 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3394 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3395 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3396 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3397 warning ("enumeral and non-enumeral type in conditional expression");
3399 arg2 = perform_implicit_conversion (result_type, arg2);
3400 arg3 = perform_implicit_conversion (result_type, arg3);
3404 --The second and third operands have pointer type, or one has
3405 pointer type and the other is a null pointer constant; pointer
3406 conversions (_conv.ptr_) and qualification conversions
3407 (_conv.qual_) are performed to bring them to their composite
3408 pointer type (_expr.rel_). The result is of the composite
3411 --The second and third operands have pointer to member type, or
3412 one has pointer to member type and the other is a null pointer
3413 constant; pointer to member conversions (_conv.mem_) and
3414 qualification conversions (_conv.qual_) are performed to bring
3415 them to a common type, whose cv-qualification shall match the
3416 cv-qualification of either the second or the third operand.
3417 The result is of the common type. */
3418 else if ((null_ptr_cst_p (arg2)
3419 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3420 || (null_ptr_cst_p (arg3)
3421 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3422 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3423 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3424 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3426 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3427 arg3, "conditional expression");
3428 if (result_type == error_mark_node)
3429 return error_mark_node;
3430 arg2 = perform_implicit_conversion (result_type, arg2);
3431 arg3 = perform_implicit_conversion (result_type, arg3);
3436 error ("operands to ?: have different types");
3437 return error_mark_node;
3441 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3442 /* We can't use result_type below, as fold might have returned a
3445 /* Expand both sides into the same slot, hopefully the target of the
3446 ?: expression. We used to check for TARGET_EXPRs here, but now we
3447 sometimes wrap them in NOP_EXPRs so the test would fail. */
3448 if (!lvalue_p && IS_AGGR_TYPE (TREE_TYPE (result)))
3449 result = get_target_expr (result);
3451 /* If this expression is an rvalue, but might be mistaken for an
3452 lvalue, we must add a NON_LVALUE_EXPR. */
3453 if (!lvalue_p && real_lvalue_p (result))
3454 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3459 /* OPERAND is an operand to an expression. Perform necessary steps
3460 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3464 prep_operand (tree operand)
3468 operand = convert_from_reference (operand);
3469 if (CLASS_TYPE_P (TREE_TYPE (operand))
3470 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3471 /* Make sure the template type is instantiated now. */
3472 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3478 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3479 OVERLOAD) to the CANDIDATES, returning an updated list of
3480 CANDIDATES. The ARGS are the arguments provided to the call,
3481 without any implicit object parameter. The EXPLICIT_TARGS are
3482 explicit template arguments provided. TEMPLATE_ONLY is true if
3483 only template functions should be considered. CONVERSION_PATH,
3484 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3487 add_candidates (tree fns, tree args,
3488 tree explicit_targs, bool template_only,
3489 tree conversion_path, tree access_path,
3491 struct z_candidate **candidates)
3494 tree non_static_args;
3496 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3497 /* Delay creating the implicit this parameter until it is needed. */
3498 non_static_args = NULL_TREE;
3505 fn = OVL_CURRENT (fns);
3506 /* Figure out which set of arguments to use. */
3507 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3509 /* If this function is a non-static member, prepend the implicit
3510 object parameter. */
3511 if (!non_static_args)
3512 non_static_args = tree_cons (NULL_TREE,
3513 build_this (TREE_VALUE (args)),
3515 fn_args = non_static_args;
3518 /* Otherwise, just use the list of arguments provided. */
3521 if (TREE_CODE (fn) == TEMPLATE_DECL)
3522 add_template_candidate (candidates,
3532 else if (!template_only)
3533 add_function_candidate (candidates,
3540 fns = OVL_NEXT (fns);
3545 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3)
3547 struct z_candidate *candidates = 0, *cand;
3548 tree arglist, fnname;
3550 tree result = NULL_TREE;
3551 bool result_valid_p = false;
3552 enum tree_code code2 = NOP_EXPR;
3558 if (error_operand_p (arg1)
3559 || error_operand_p (arg2)
3560 || error_operand_p (arg3))
3561 return error_mark_node;
3563 if (code == MODIFY_EXPR)
3565 code2 = TREE_CODE (arg3);
3567 fnname = ansi_assopname (code2);
3570 fnname = ansi_opname (code);
3572 arg1 = prep_operand (arg1);
3578 case VEC_DELETE_EXPR:
3580 /* Use build_op_new_call and build_op_delete_call instead. */
3584 return build_object_call (arg1, arg2);
3590 arg2 = prep_operand (arg2);
3591 arg3 = prep_operand (arg3);
3593 if (code == COND_EXPR)
3595 if (arg2 == NULL_TREE
3596 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3597 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3598 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3599 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3602 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3603 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3606 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3607 arg2 = integer_zero_node;
3609 arglist = NULL_TREE;
3611 arglist = tree_cons (NULL_TREE, arg3, arglist);
3613 arglist = tree_cons (NULL_TREE, arg2, arglist);
3614 arglist = tree_cons (NULL_TREE, arg1, arglist);
3616 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3617 p = conversion_obstack_alloc (0);
3619 /* Add namespace-scope operators to the list of functions to
3621 add_candidates (lookup_function_nonclass (fnname, arglist),
3622 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3623 flags, &candidates);
3624 /* Add class-member operators to the candidate set. */
3625 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3629 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3630 if (fns == error_mark_node)
3632 result = error_mark_node;
3633 goto user_defined_result_ready;
3636 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3638 BASELINK_BINFO (fns),
3639 TYPE_BINFO (TREE_TYPE (arg1)),
3640 flags, &candidates);
3643 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3644 to know about two args; a builtin candidate will always have a first
3645 parameter of type bool. We'll handle that in
3646 build_builtin_candidate. */
3647 if (code == COND_EXPR)
3657 args[2] = NULL_TREE;
3660 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3666 /* For these, the built-in candidates set is empty
3667 [over.match.oper]/3. We don't want non-strict matches
3668 because exact matches are always possible with built-in
3669 operators. The built-in candidate set for COMPONENT_REF
3670 would be empty too, but since there are no such built-in
3671 operators, we accept non-strict matches for them. */
3676 strict_p = pedantic;
3680 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3685 case POSTINCREMENT_EXPR:
3686 case POSTDECREMENT_EXPR:
3687 /* Look for an `operator++ (int)'. If they didn't have
3688 one, then we fall back to the old way of doing things. */
3689 if (flags & LOOKUP_COMPLAIN)
3690 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3692 operator_name_info[code].name);
3693 if (code == POSTINCREMENT_EXPR)
3694 code = PREINCREMENT_EXPR;
3696 code = PREDECREMENT_EXPR;
3697 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
3700 /* The caller will deal with these. */
3705 result_valid_p = true;
3709 if (flags & LOOKUP_COMPLAIN)
3711 op_error (code, code2, arg1, arg2, arg3, "no match");
3712 print_z_candidates (candidates);
3714 result = error_mark_node;
3720 cand = tourney (candidates);
3723 if (flags & LOOKUP_COMPLAIN)
3725 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3726 print_z_candidates (candidates);
3728 result = error_mark_node;
3730 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3733 && fnname == ansi_assopname (NOP_EXPR)
3734 && DECL_ARTIFICIAL (cand->fn)
3736 && ! candidates->next->next)
3738 warning ("using synthesized `%#D' for copy assignment",
3740 cp_warning_at (" where cfront would use `%#D'",
3742 ? candidates->next->fn
3746 result = build_over_call (cand, LOOKUP_NORMAL);
3750 /* Check for comparison of different enum types. */
3759 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3760 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3761 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3762 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3764 warning ("comparison between `%#T' and `%#T'",
3765 TREE_TYPE (arg1), TREE_TYPE (arg2));
3772 /* We need to strip any leading REF_BIND so that bitfields
3773 don't cause errors. This should not remove any important
3774 conversions, because builtins don't apply to class
3775 objects directly. */
3776 conv = cand->convs[0];
3777 if (conv->kind == ck_ref_bind)
3778 conv = conv->u.next;
3779 arg1 = convert_like (conv, arg1);
3782 conv = cand->convs[1];
3783 if (conv->kind == ck_ref_bind)
3784 conv = conv->u.next;
3785 arg2 = convert_like (conv, arg2);
3789 conv = cand->convs[2];
3790 if (conv->kind == ck_ref_bind)
3791 conv = conv->u.next;
3792 arg3 = convert_like (conv, arg3);
3797 user_defined_result_ready:
3799 /* Free all the conversions we allocated. */
3800 obstack_free (&conversion_obstack, p);
3802 if (result || result_valid_p)
3809 return build_modify_expr (arg1, code2, arg2);
3812 return build_indirect_ref (arg1, "unary *");
3817 case TRUNC_DIV_EXPR:
3828 case TRUNC_MOD_EXPR:
3832 case TRUTH_ANDIF_EXPR:
3833 case TRUTH_ORIF_EXPR:
3834 return cp_build_binary_op (code, arg1, arg2);
3839 case TRUTH_NOT_EXPR:
3840 case PREINCREMENT_EXPR:
3841 case POSTINCREMENT_EXPR:
3842 case PREDECREMENT_EXPR:
3843 case POSTDECREMENT_EXPR:
3846 return build_unary_op (code, arg1, candidates != 0);
3849 return build_array_ref (arg1, arg2);
3852 return build_conditional_expr (arg1, arg2, arg3);
3855 return build_m_component_ref
3856 (build_indirect_ref (arg1, NULL), arg2);
3858 /* The caller will deal with these. */
3870 /* Build a call to operator delete. This has to be handled very specially,
3871 because the restrictions on what signatures match are different from all
3872 other call instances. For a normal delete, only a delete taking (void *)
3873 or (void *, size_t) is accepted. For a placement delete, only an exact
3874 match with the placement new is accepted.
3876 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3877 ADDR is the pointer to be deleted.
3878 SIZE is the size of the memory block to be deleted.
3879 GLOBAL_P is true if the delete-expression should not consider
3880 class-specific delete operators.
3881 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3884 build_op_delete_call (enum tree_code code, tree addr, tree size,
3885 bool global_p, tree placement)
3887 tree fn = NULL_TREE;
3888 tree fns, fnname, argtypes, args, type;
3891 if (addr == error_mark_node)
3892 return error_mark_node;
3894 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3896 fnname = ansi_opname (code);
3898 if (IS_AGGR_TYPE (type) && !global_p)
3901 If the result of the lookup is ambiguous or inaccessible, or if
3902 the lookup selects a placement deallocation function, the
3903 program is ill-formed.
3905 Therefore, we ask lookup_fnfields to complain about ambiguity. */
3907 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3908 if (fns == error_mark_node)
3909 return error_mark_node;
3914 if (fns == NULL_TREE)
3915 fns = lookup_name_nonclass (fnname);
3922 /* Find the allocation function that is being called. */
3923 call_expr = placement;
3924 /* Extract the function. */
3925 alloc_fn = get_callee_fndecl (call_expr);
3926 my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
3927 /* Then the second parm type. */
3928 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3929 /* Also the second argument. */
3930 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3934 /* First try it without the size argument. */
3935 argtypes = void_list_node;
3939 /* Strip const and volatile from addr. */
3940 addr = cp_convert (ptr_type_node, addr);
3942 /* We make two tries at finding a matching `operator delete'. On
3943 the first pass, we look for a one-operator (or placement)
3944 operator delete. If we're not doing placement delete, then on
3945 the second pass we look for a two-argument delete. */
3946 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
3948 /* Go through the `operator delete' functions looking for one
3949 with a matching type. */
3950 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
3956 /* The first argument must be "void *". */
3957 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3958 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3961 /* On the first pass, check the rest of the arguments. */
3964 while (argtypes && t)
3966 if (!same_type_p (TREE_VALUE (argtypes),
3969 argtypes = TREE_CHAIN (argtypes);
3972 if (!argtypes && !t)
3975 /* On the second pass, the second argument must be
3978 && same_type_p (TREE_VALUE (t), sizetype)
3979 && TREE_CHAIN (t) == void_list_node)
3983 /* If we found a match, we're done. */
3988 /* If we have a matching function, call it. */
3991 /* Make sure we have the actual function, and not an
3993 fn = OVL_CURRENT (fn);
3995 /* If the FN is a member function, make sure that it is
3997 if (DECL_CLASS_SCOPE_P (fn))
3998 perform_or_defer_access_check (TYPE_BINFO (type), fn);
4001 args = tree_cons (NULL_TREE, addr, args);
4003 args = tree_cons (NULL_TREE, addr,
4004 build_tree_list (NULL_TREE, size));
4008 /* The placement args might not be suitable for overload
4009 resolution at this point, so build the call directly. */
4011 return build_cxx_call (fn, args, args);
4014 return build_function_call (fn, args);
4017 /* If we are doing placement delete we do nothing if we don't find a
4018 matching op delete. */
4022 error ("no suitable `operator %s' for `%T'",
4023 operator_name_info[(int)code].name, type);
4024 return error_mark_node;
4027 /* If the current scope isn't allowed to access DECL along
4028 BASETYPE_PATH, give an error. The most derived class in
4029 BASETYPE_PATH is the one used to qualify DECL. */
4032 enforce_access (tree basetype_path, tree decl)
4034 my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624);
4036 if (!accessible_p (basetype_path, decl))
4038 if (TREE_PRIVATE (decl))
4039 cp_error_at ("`%+#D' is private", decl);
4040 else if (TREE_PROTECTED (decl))
4041 cp_error_at ("`%+#D' is protected", decl);
4043 cp_error_at ("`%+#D' is inaccessible", decl);
4044 error ("within this context");
4051 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4052 bitwise or of LOOKUP_* values. If any errors are warnings are
4053 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4054 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4058 build_temp (tree expr, tree type, int flags,
4059 void (**diagnostic_fn)(const char *, ...))
4063 savew = warningcount, savee = errorcount;
4064 expr = build_special_member_call (NULL_TREE,
4065 complete_ctor_identifier,
4066 build_tree_list (NULL_TREE, expr),
4069 if (warningcount > savew)
4070 *diagnostic_fn = warning;
4071 else if (errorcount > savee)
4072 *diagnostic_fn = error;
4074 *diagnostic_fn = NULL;
4079 /* Perform the conversions in CONVS on the expression EXPR. FN and
4080 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4081 indicates the `this' argument of a method. INNER is nonzero when
4082 being called to continue a conversion chain. It is negative when a
4083 reference binding will be applied, positive otherwise. If
4084 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4085 conversions will be emitted if appropriate. */
4088 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4089 int inner, bool issue_conversion_warnings)
4091 tree totype = convs->type;
4092 void (*diagnostic_fn)(const char *, ...);
4095 && convs->kind != ck_user
4096 && convs->kind != ck_ambig
4097 && convs->kind != ck_ref_bind)
4099 conversion *t = convs;
4100 for (; t; t = convs->u.next)
4102 if (t->kind == ck_user || !t->bad_p)
4104 expr = convert_like_real (t, expr, fn, argnum, 1,
4105 /*issue_conversion_warnings=*/false);
4108 else if (t->kind == ck_ambig)
4109 return convert_like_real (t, expr, fn, argnum, 1,
4110 /*issue_conversion_warnings=*/false);
4111 else if (t->kind == ck_identity)
4114 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
4116 pedwarn (" initializing argument %P of `%D'", argnum, fn);
4117 return cp_convert (totype, expr);
4120 if (issue_conversion_warnings)
4121 expr = dubious_conversion_warnings
4122 (totype, expr, "converting", fn, argnum);
4123 switch (convs->kind)
4127 struct z_candidate *cand = convs->cand;
4128 tree convfn = cand->fn;
4131 if (DECL_CONSTRUCTOR_P (convfn))
4133 tree t = build_int_2 (0, 0);
4134 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
4136 args = build_tree_list (NULL_TREE, expr);
4137 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
4138 || DECL_HAS_VTT_PARM_P (convfn))
4139 /* We should never try to call the abstract or base constructor
4142 args = tree_cons (NULL_TREE, t, args);
4145 args = build_this (expr);
4146 expr = build_over_call (cand, LOOKUP_NORMAL);
4148 /* If this is a constructor or a function returning an aggr type,
4149 we need to build up a TARGET_EXPR. */
4150 if (DECL_CONSTRUCTOR_P (convfn))
4151 expr = build_cplus_new (totype, expr);
4153 /* The result of the call is then used to direct-initialize the object
4154 that is the destination of the copy-initialization. [dcl.init]
4156 Note that this step is not reflected in the conversion sequence;
4157 it affects the semantics when we actually perform the
4158 conversion, but is not considered during overload resolution.
4160 If the target is a class, that means call a ctor. */
4161 if (IS_AGGR_TYPE (totype)
4162 && (inner >= 0 || !lvalue_p (expr)))
4166 /* Core issue 84, now a DR, says that we don't
4167 allow UDCs for these args (which deliberately
4168 breaks copy-init of an auto_ptr<Base> from an
4169 auto_ptr<Derived>). */
4170 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4177 (" initializing argument %P of `%D' from result of `%D'",
4178 argnum, fn, convfn);
4181 (" initializing temporary from result of `%D'", convfn);
4183 expr = build_cplus_new (totype, expr);
4188 if (type_unknown_p (expr))
4189 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4190 /* Convert a non-array constant variable to its underlying value, unless we
4191 are about to bind it to a reference, in which case we need to
4192 leave it as an lvalue. */
4194 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4195 expr = decl_constant_value (expr);
4196 if (convs->check_copy_constructor_p)
4197 /* Generate a temporary copy purely to generate the required
4199 build_temp (build_dummy_object (totype), totype,
4200 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4204 /* Call build_user_type_conversion again for the error. */
4205 return build_user_type_conversion
4206 (totype, convs->u.expr, LOOKUP_NORMAL);
4212 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4213 convs->kind == ck_ref_bind ? -1 : 1,
4214 /*issue_conversion_warnings=*/false);
4215 if (expr == error_mark_node)
4216 return error_mark_node;
4218 switch (convs->kind)
4221 if (! IS_AGGR_TYPE (totype))
4223 /* Else fall through. */
4225 if (convs->kind == ck_base && !convs->need_temporary_p)
4227 /* We are going to bind a reference directly to a base-class
4228 subobject of EXPR. */
4229 if (convs->check_copy_constructor_p)
4230 /* Generate a temporary copy purely to generate the required
4232 build_temp (build_dummy_object (TREE_TYPE (expr)),
4234 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4236 /* Build an expression for `*((base*) &expr)'. */
4237 expr = build_unary_op (ADDR_EXPR, expr, 0);
4238 expr = perform_implicit_conversion (build_pointer_type (totype),
4240 expr = build_indirect_ref (expr, "implicit conversion");
4244 /* Copy-initialization where the cv-unqualified version of the source
4245 type is the same class as, or a derived class of, the class of the
4246 destination [is treated as direct-initialization]. [dcl.init] */
4247 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4249 if (diagnostic_fn && fn)
4250 diagnostic_fn (" initializing argument %P of `%D'", argnum, fn);
4251 return build_cplus_new (totype, expr);
4255 tree ref_type = totype;
4257 /* If necessary, create a temporary. */
4258 if (convs->need_temporary_p || !lvalue_p (expr))
4260 tree type = convs->u.next->type;
4262 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4264 /* If the reference is volatile or non-const, we
4265 cannot create a temporary. */
4266 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4268 if (lvalue & clk_bitfield)
4269 error ("cannot bind bitfield `%E' to `%T'",
4271 else if (lvalue & clk_packed)
4272 error ("cannot bind packed field `%E' to `%T'",
4275 error ("cannot bind rvalue `%E' to `%T'", expr, ref_type);
4276 return error_mark_node;
4278 expr = build_target_expr_with_type (expr, type);
4281 /* Take the address of the thing to which we will bind the
4283 expr = build_unary_op (ADDR_EXPR, expr, 1);
4284 if (expr == error_mark_node)
4285 return error_mark_node;
4287 /* Convert it to a pointer to the type referred to by the
4288 reference. This will adjust the pointer if a derived to
4289 base conversion is being performed. */
4290 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4292 /* Convert the pointer to the desired reference type. */
4293 return build_nop (ref_type, expr);
4297 return decay_conversion (expr);
4300 /* Warn about deprecated conversion if appropriate. */
4301 string_conv_p (totype, expr, 1);
4307 return ocp_convert (totype, expr, CONV_IMPLICIT,
4308 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4311 /* Build a call to __builtin_trap which can be used as an expression of
4315 call_builtin_trap (tree type)
4317 tree fn = IDENTIFIER_GLOBAL_VALUE (get_identifier ("__builtin_trap"));
4319 my_friendly_assert (fn != NULL, 20030927);
4320 fn = build_call (fn, NULL_TREE);
4321 fn = build (COMPOUND_EXPR, type, fn, error_mark_node);
4322 fn = force_target_expr (type, fn);
4326 /* ARG is being passed to a varargs function. Perform any conversions
4327 required. Return the converted value. */
4330 convert_arg_to_ellipsis (tree arg)
4334 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4335 standard conversions are performed. */
4336 arg = decay_conversion (arg);
4339 If the argument has integral or enumeration type that is subject
4340 to the integral promotions (_conv.prom_), or a floating point
4341 type that is subject to the floating point promotion
4342 (_conv.fpprom_), the value of the argument is converted to the
4343 promoted type before the call. */
4344 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4345 && (TYPE_PRECISION (TREE_TYPE (arg))
4346 < TYPE_PRECISION (double_type_node)))
4347 arg = convert_to_real (double_type_node, arg);
4348 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4349 arg = perform_integral_promotions (arg);
4351 arg = require_complete_type (arg);
4353 if (arg != error_mark_node
4354 && !pod_type_p (TREE_TYPE (arg)))
4356 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4357 here and do a bitwise copy, but now cp_expr_size will abort if we
4359 If the call appears in the context of a sizeof expression,
4360 there is no need to emit a warning, since the expression won't be
4361 evaluated. We keep the builtin_trap just as a safety check. */
4362 if (!skip_evaluation)
4363 warning ("cannot pass objects of non-POD type `%#T' through `...'; "
4364 "call will abort at runtime", TREE_TYPE (arg));
4365 arg = call_builtin_trap (TREE_TYPE (arg));
4371 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4374 build_x_va_arg (tree expr, tree type)
4376 if (processing_template_decl)
4377 return build_min (VA_ARG_EXPR, type, expr);
4379 type = complete_type_or_else (type, NULL_TREE);
4381 if (expr == error_mark_node || !type)
4382 return error_mark_node;
4384 if (! pod_type_p (type))
4386 /* Undefined behavior [expr.call] 5.2.2/7. */
4387 warning ("cannot receive objects of non-POD type `%#T' through `...'; \
4388 call will abort at runtime",
4390 return call_builtin_trap (type);
4393 return build_va_arg (expr, type);
4396 /* TYPE has been given to va_arg. Apply the default conversions which
4397 would have happened when passed via ellipsis. Return the promoted
4398 type, or the passed type if there is no change. */
4401 cxx_type_promotes_to (tree type)
4405 /* Perform the array-to-pointer and function-to-pointer
4407 type = type_decays_to (type);
4409 promote = type_promotes_to (type);
4410 if (same_type_p (type, promote))
4416 /* ARG is a default argument expression being passed to a parameter of
4417 the indicated TYPE, which is a parameter to FN. Do any required
4418 conversions. Return the converted value. */
4421 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4423 /* If the ARG is an unparsed default argument expression, the
4424 conversion cannot be performed. */
4425 if (TREE_CODE (arg) == DEFAULT_ARG)
4427 error ("the default argument for parameter %d of `%D' has "
4428 "not yet been parsed",
4430 return error_mark_node;
4433 if (fn && DECL_TEMPLATE_INFO (fn))
4434 arg = tsubst_default_argument (fn, type, arg);
4436 arg = break_out_target_exprs (arg);
4438 if (TREE_CODE (arg) == CONSTRUCTOR)
4440 arg = digest_init (type, arg, 0);
4441 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4442 "default argument", fn, parmnum);
4446 /* This could get clobbered by the following call. */
4447 if (TREE_HAS_CONSTRUCTOR (arg))
4448 arg = copy_node (arg);
4450 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4451 "default argument", fn, parmnum);
4452 arg = convert_for_arg_passing (type, arg);
4458 /* Returns the type which will really be used for passing an argument of
4462 type_passed_as (tree type)
4464 /* Pass classes with copy ctors by invisible reference. */
4465 if (TREE_ADDRESSABLE (type))
4466 type = build_reference_type (type);
4467 else if (targetm.calls.promote_prototypes (type)
4468 && INTEGRAL_TYPE_P (type)
4469 && COMPLETE_TYPE_P (type)
4470 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4471 TYPE_SIZE (integer_type_node)))
4472 type = integer_type_node;
4477 /* Actually perform the appropriate conversion. */
4480 convert_for_arg_passing (tree type, tree val)
4482 if (val == error_mark_node)
4484 /* Pass classes with copy ctors by invisible reference. */
4485 else if (TREE_ADDRESSABLE (type))
4486 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4487 else if (targetm.calls.promote_prototypes (type)
4488 && INTEGRAL_TYPE_P (type)
4489 && COMPLETE_TYPE_P (type)
4490 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4491 TYPE_SIZE (integer_type_node)))
4492 val = perform_integral_promotions (val);
4496 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4497 which no conversions at all should be done. This is true for some
4498 builtins which don't act like normal functions. */
4501 magic_varargs_p (tree fn)
4503 if (DECL_BUILT_IN (fn))
4504 switch (DECL_FUNCTION_CODE (fn))
4506 case BUILT_IN_CLASSIFY_TYPE:
4507 case BUILT_IN_CONSTANT_P:
4508 case BUILT_IN_NEXT_ARG:
4509 case BUILT_IN_STDARG_START:
4510 case BUILT_IN_VA_START:
4519 /* Subroutine of the various build_*_call functions. Overload resolution
4520 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4521 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4522 bitmask of various LOOKUP_* flags which apply to the call itself. */
4525 build_over_call (struct z_candidate *cand, int flags)
4528 tree args = cand->args;
4529 conversion **convs = cand->convs;
4531 tree converted_args = NULL_TREE;
4532 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4537 /* In a template, there is no need to perform all of the work that
4538 is normally done. We are only interested in the type of the call
4539 expression, i.e., the return type of the function. Any semantic
4540 errors will be deferred until the template is instantiated. */
4541 if (processing_template_decl)
4545 return_type = TREE_TYPE (TREE_TYPE (fn));
4546 expr = build (CALL_EXPR, return_type, fn, args);
4547 if (!VOID_TYPE_P (return_type))
4548 require_complete_type (return_type);
4549 return convert_from_reference (expr);
4552 /* Give any warnings we noticed during overload resolution. */
4555 struct candidate_warning *w;
4556 for (w = cand->warnings; w; w = w->next)
4557 joust (cand, w->loser, 1);
4560 if (DECL_FUNCTION_MEMBER_P (fn))
4562 /* If FN is a template function, two cases must be considered.
4567 template <class T> void f();
4569 template <class T> struct B {
4573 struct C : A, B<int> {
4575 using B<int>::g; // #2
4578 In case #1 where `A::f' is a member template, DECL_ACCESS is
4579 recorded in the primary template but not in its specialization.
4580 We check access of FN using its primary template.
4582 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4583 because it is a member of class template B, DECL_ACCESS is
4584 recorded in the specialization `B<int>::g'. We cannot use its
4585 primary template because `B<T>::g' and `B<int>::g' may have
4586 different access. */
4587 if (DECL_TEMPLATE_INFO (fn)
4588 && is_member_template (DECL_TI_TEMPLATE (fn)))
4589 perform_or_defer_access_check (cand->access_path,
4590 DECL_TI_TEMPLATE (fn));
4592 perform_or_defer_access_check (cand->access_path, fn);
4595 if (args && TREE_CODE (args) != TREE_LIST)
4596 args = build_tree_list (NULL_TREE, args);
4599 /* The implicit parameters to a constructor are not considered by overload
4600 resolution, and must be of the proper type. */
4601 if (DECL_CONSTRUCTOR_P (fn))
4603 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4604 arg = TREE_CHAIN (arg);
4605 parm = TREE_CHAIN (parm);
4606 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4607 /* We should never try to call the abstract constructor. */
4609 if (DECL_HAS_VTT_PARM_P (fn))
4611 converted_args = tree_cons
4612 (NULL_TREE, TREE_VALUE (arg), converted_args);
4613 arg = TREE_CHAIN (arg);
4614 parm = TREE_CHAIN (parm);
4617 /* Bypass access control for 'this' parameter. */
4618 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4620 tree parmtype = TREE_VALUE (parm);
4621 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4625 if (convs[i]->bad_p)
4626 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4627 TREE_TYPE (argtype), fn);
4629 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4630 X is called for an object that is not of type X, or of a type
4631 derived from X, the behavior is undefined.
4633 So we can assume that anything passed as 'this' is non-null, and
4634 optimize accordingly. */
4635 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4636 /* Convert to the base in which the function was declared. */
4637 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4638 converted_arg = build_base_path (PLUS_EXPR,
4640 cand->conversion_path,
4642 /* Check that the base class is accessible. */
4643 if (!accessible_base_p (TREE_TYPE (argtype),
4644 BINFO_TYPE (cand->conversion_path)))
4645 error ("`%T' is not an accessible base of `%T'",
4646 BINFO_TYPE (cand->conversion_path),
4647 TREE_TYPE (argtype));
4648 /* If fn was found by a using declaration, the conversion path
4649 will be to the derived class, not the base declaring fn. We
4650 must convert from derived to base. */
4651 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4652 TREE_TYPE (parmtype), ba_ignore, NULL);
4653 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4656 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4657 parm = TREE_CHAIN (parm);
4658 arg = TREE_CHAIN (arg);
4664 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4666 tree type = TREE_VALUE (parm);
4669 val = convert_like_with_context
4670 (conv, TREE_VALUE (arg), fn, i - is_method);
4672 val = convert_for_arg_passing (type, val);
4673 converted_args = tree_cons (NULL_TREE, val, converted_args);
4676 /* Default arguments */
4677 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4679 = tree_cons (NULL_TREE,
4680 convert_default_arg (TREE_VALUE (parm),
4681 TREE_PURPOSE (parm),
4686 for (; arg; arg = TREE_CHAIN (arg))
4688 tree a = TREE_VALUE (arg);
4689 if (magic_varargs_p (fn))
4690 /* Do no conversions for magic varargs. */;
4692 a = convert_arg_to_ellipsis (a);
4693 converted_args = tree_cons (NULL_TREE, a, converted_args);
4696 converted_args = nreverse (converted_args);
4699 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4702 /* Avoid actually calling copy constructors and copy assignment operators,
4705 if (! flag_elide_constructors)
4706 /* Do things the hard way. */;
4707 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4710 arg = skip_artificial_parms_for (fn, converted_args);
4711 arg = TREE_VALUE (arg);
4713 /* Pull out the real argument, disregarding const-correctness. */
4715 while (TREE_CODE (targ) == NOP_EXPR
4716 || TREE_CODE (targ) == NON_LVALUE_EXPR
4717 || TREE_CODE (targ) == CONVERT_EXPR)
4718 targ = TREE_OPERAND (targ, 0);
4719 if (TREE_CODE (targ) == ADDR_EXPR)
4721 targ = TREE_OPERAND (targ, 0);
4722 if (!same_type_ignoring_top_level_qualifiers_p
4723 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4732 arg = build_indirect_ref (arg, 0);
4734 /* [class.copy]: the copy constructor is implicitly defined even if
4735 the implementation elided its use. */
4736 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4739 /* If we're creating a temp and we already have one, don't create a
4740 new one. If we're not creating a temp but we get one, use
4741 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4742 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4743 temp or an INIT_EXPR otherwise. */
4744 if (integer_zerop (TREE_VALUE (args)))
4746 if (TREE_CODE (arg) == TARGET_EXPR)
4748 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4749 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4751 else if (TREE_CODE (arg) == TARGET_EXPR
4752 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4755 tree to = stabilize_reference
4756 (build_indirect_ref (TREE_VALUE (args), 0));
4758 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4759 address = build_unary_op (ADDR_EXPR, val, 0);
4760 /* Avoid a warning about this expression, if the address is
4762 TREE_USED (address) = 1;
4766 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4768 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4770 tree to = stabilize_reference
4771 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4772 tree type = TREE_TYPE (to);
4773 tree as_base = CLASSTYPE_AS_BASE (type);
4775 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4776 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4777 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4780 /* We must only copy the non-tail padding parts. Use
4781 CLASSTYPE_AS_BASE for the bitwise copy. */
4782 tree to_ptr, arg_ptr, to_as_base, arg_as_base, base_ptr_type;
4785 to_ptr = save_expr (build_unary_op (ADDR_EXPR, to, 0));
4786 arg_ptr = build_unary_op (ADDR_EXPR, arg, 0);
4788 base_ptr_type = build_pointer_type (as_base);
4789 to_as_base = build_nop (base_ptr_type, to_ptr);
4790 to_as_base = build_indirect_ref (to_as_base, 0);
4791 arg_as_base = build_nop (base_ptr_type, arg_ptr);
4792 arg_as_base = build_indirect_ref (arg_as_base, 0);
4794 save_to = build_indirect_ref (to_ptr, 0);
4796 val = build (MODIFY_EXPR, as_base, to_as_base, arg_as_base);
4797 val = convert_to_void (val, NULL);
4798 val = build (COMPOUND_EXPR, type, val, save_to);
4799 TREE_NO_UNUSED_WARNING (val) = 1;
4807 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4809 tree t, *p = &TREE_VALUE (converted_args);
4810 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4813 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4815 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4816 if (TREE_SIDE_EFFECTS (*p))
4817 *p = save_expr (*p);
4818 t = build_pointer_type (TREE_TYPE (fn));
4819 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4820 fn = build_java_interface_fn_ref (fn, *p);
4822 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4825 else if (DECL_INLINE (fn))
4826 fn = inline_conversion (fn);
4828 fn = build_addr_func (fn);
4830 return build_cxx_call (fn, args, converted_args);
4833 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4834 gives the original form of the arguments. This function performs
4835 no overload resolution, conversion, or other high-level
4839 build_cxx_call(tree fn, tree args, tree converted_args)
4843 /* Recognize certain built-in functions so we can make tree-codes
4844 other than CALL_EXPR. We do this when it enables fold-const.c
4845 to do something useful. */
4846 if (TREE_CODE (fn) == ADDR_EXPR
4847 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4848 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4851 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4856 fn = build_call (fn, converted_args);
4858 /* If this call might throw an exception, note that fact. */
4859 fndecl = get_callee_fndecl (fn);
4860 if ((!fndecl || !TREE_NOTHROW (fndecl))
4861 && at_function_scope_p ()
4863 cp_function_chain->can_throw = 1;
4865 /* Some built-in function calls will be evaluated at compile-time in
4869 if (VOID_TYPE_P (TREE_TYPE (fn)))
4872 fn = require_complete_type (fn);
4873 if (fn == error_mark_node)
4874 return error_mark_node;
4876 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4877 fn = build_cplus_new (TREE_TYPE (fn), fn);
4878 return convert_from_reference (fn);
4881 static GTY(()) tree java_iface_lookup_fn;
4883 /* Make an expression which yields the address of the Java interface
4884 method FN. This is achieved by generating a call to libjava's
4885 _Jv_LookupInterfaceMethodIdx(). */
4888 build_java_interface_fn_ref (tree fn, tree instance)
4890 tree lookup_args, lookup_fn, method, idx;
4891 tree klass_ref, iface, iface_ref;
4894 if (!java_iface_lookup_fn)
4896 tree endlink = build_void_list_node ();
4897 tree t = tree_cons (NULL_TREE, ptr_type_node,
4898 tree_cons (NULL_TREE, ptr_type_node,
4899 tree_cons (NULL_TREE, java_int_type_node,
4901 java_iface_lookup_fn
4902 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4903 build_function_type (ptr_type_node, t),
4904 0, NOT_BUILT_IN, NULL, NULL_TREE);
4907 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4908 This is the first entry in the vtable. */
4909 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4912 /* Get the java.lang.Class pointer for the interface being called. */
4913 iface = DECL_CONTEXT (fn);
4914 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4915 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4916 || DECL_CONTEXT (iface_ref) != iface)
4918 error ("could not find class$ field in java interface type `%T'",
4920 return error_mark_node;
4922 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4924 /* Determine the itable index of FN. */
4926 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4928 if (!DECL_VIRTUAL_P (method))
4934 idx = build_int_2 (i, 0);
4936 lookup_args = tree_cons (NULL_TREE, klass_ref,
4937 tree_cons (NULL_TREE, iface_ref,
4938 build_tree_list (NULL_TREE, idx)));
4939 lookup_fn = build1 (ADDR_EXPR,
4940 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4941 java_iface_lookup_fn);
4942 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4945 /* Returns the value to use for the in-charge parameter when making a
4946 call to a function with the indicated NAME. */
4949 in_charge_arg_for_name (tree name)
4951 if (name == base_ctor_identifier
4952 || name == base_dtor_identifier)
4953 return integer_zero_node;
4954 else if (name == complete_ctor_identifier)
4955 return integer_one_node;
4956 else if (name == complete_dtor_identifier)
4957 return integer_two_node;
4958 else if (name == deleting_dtor_identifier)
4959 return integer_three_node;
4961 /* This function should only be called with one of the names listed
4967 /* Build a call to a constructor, destructor, or an assignment
4968 operator for INSTANCE, an expression with class type. NAME
4969 indicates the special member function to call; ARGS are the
4970 arguments. BINFO indicates the base of INSTANCE that is to be
4971 passed as the `this' parameter to the member function called.
4973 FLAGS are the LOOKUP_* flags to use when processing the call.
4975 If NAME indicates a complete object constructor, INSTANCE may be
4976 NULL_TREE. In this case, the caller will call build_cplus_new to
4977 store the newly constructed object into a VAR_DECL. */
4980 build_special_member_call (tree instance, tree name, tree args,
4981 tree binfo, int flags)
4984 /* The type of the subobject to be constructed or destroyed. */
4987 my_friendly_assert (name == complete_ctor_identifier
4988 || name == base_ctor_identifier
4989 || name == complete_dtor_identifier
4990 || name == base_dtor_identifier
4991 || name == deleting_dtor_identifier
4992 || name == ansi_assopname (NOP_EXPR),
4994 my_friendly_assert (binfo != NULL_TREE, 20020712);
4996 class_type = BINFO_TYPE (binfo);
4998 /* Handle the special case where INSTANCE is NULL_TREE. */
4999 if (name == complete_ctor_identifier && !instance)
5001 instance = build_int_2 (0, 0);
5002 TREE_TYPE (instance) = build_pointer_type (class_type);
5003 instance = build1 (INDIRECT_REF, class_type, instance);
5007 if (name == complete_dtor_identifier
5008 || name == base_dtor_identifier
5009 || name == deleting_dtor_identifier)
5010 my_friendly_assert (args == NULL_TREE, 20020712);
5012 /* Convert to the base class, if necessary. */
5013 if (!same_type_ignoring_top_level_qualifiers_p
5014 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5016 if (name != ansi_assopname (NOP_EXPR))
5017 /* For constructors and destructors, either the base is
5018 non-virtual, or it is virtual but we are doing the
5019 conversion from a constructor or destructor for the
5020 complete object. In either case, we can convert
5022 instance = convert_to_base_statically (instance, binfo);
5024 /* However, for assignment operators, we must convert
5025 dynamically if the base is virtual. */
5026 instance = build_base_path (PLUS_EXPR, instance,
5027 binfo, /*nonnull=*/1);
5031 my_friendly_assert (instance != NULL_TREE, 20020712);
5033 /* Resolve the name. */
5034 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
5035 return error_mark_node;
5037 fns = lookup_fnfields (binfo, name, 1);
5039 /* When making a call to a constructor or destructor for a subobject
5040 that uses virtual base classes, pass down a pointer to a VTT for
5042 if ((name == base_ctor_identifier
5043 || name == base_dtor_identifier)
5044 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
5049 /* If the current function is a complete object constructor
5050 or destructor, then we fetch the VTT directly.
5051 Otherwise, we look it up using the VTT we were given. */
5052 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5053 vtt = decay_conversion (vtt);
5054 vtt = build (COND_EXPR, TREE_TYPE (vtt),
5055 build (EQ_EXPR, boolean_type_node,
5056 current_in_charge_parm, integer_zero_node),
5059 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
5060 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5061 BINFO_SUBVTT_INDEX (binfo));
5063 args = tree_cons (NULL_TREE, sub_vtt, args);
5066 return build_new_method_call (instance, fns, args,
5067 TYPE_BINFO (BINFO_TYPE (binfo)),
5071 /* Return the NAME, as a C string. The NAME indicates a function that
5072 is a member of TYPE. *FREE_P is set to true if the caller must
5073 free the memory returned.
5075 Rather than go through all of this, we should simply set the names
5076 of constructors and destructors appropriately, and dispense with
5077 ctor_identifier, dtor_identifier, etc. */
5080 name_as_c_string (tree name, tree type, bool *free_p)
5084 /* Assume that we will not allocate memory. */
5086 /* Constructors and destructors are special. */
5087 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5090 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5091 /* For a destructor, add the '~'. */
5092 if (name == complete_dtor_identifier
5093 || name == base_dtor_identifier
5094 || name == deleting_dtor_identifier)
5096 pretty_name = concat ("~", pretty_name, NULL);
5097 /* Remember that we need to free the memory allocated. */
5101 else if (IDENTIFIER_TYPENAME_P (name))
5103 pretty_name = concat ("operator ",
5104 type_as_string (TREE_TYPE (name),
5105 TFF_PLAIN_IDENTIFIER),
5107 /* Remember that we need to free the memory allocated. */
5111 pretty_name = (char *) IDENTIFIER_POINTER (name);
5116 /* Build a call to "INSTANCE.FN (ARGS)". */
5119 build_new_method_call (tree instance, tree fns, tree args,
5120 tree conversion_path, int flags)
5122 struct z_candidate *candidates = 0, *cand;
5123 tree explicit_targs = NULL_TREE;
5124 tree basetype = NULL_TREE;
5127 tree mem_args = NULL_TREE, instance_ptr;
5133 int template_only = 0;
5140 my_friendly_assert (instance != NULL_TREE, 20020729);
5142 if (error_operand_p (instance)
5143 || error_operand_p (fns)
5144 || args == error_mark_node)
5145 return error_mark_node;
5147 orig_instance = instance;
5151 if (processing_template_decl)
5153 instance = build_non_dependent_expr (instance);
5154 if (!BASELINK_P (fns)
5155 && TREE_CODE (fns) != PSEUDO_DTOR_EXPR
5156 && TREE_TYPE (fns) != unknown_type_node)
5157 fns = build_non_dependent_expr (fns);
5158 args = build_non_dependent_args (orig_args);
5161 /* Process the argument list. */
5163 args = resolve_args (args);
5164 if (args == error_mark_node)
5165 return error_mark_node;
5167 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5168 instance = convert_from_reference (instance);
5169 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5170 instance_ptr = build_this (instance);
5172 if (!BASELINK_P (fns))
5174 error ("call to non-function `%D'", fns);
5175 return error_mark_node;
5178 if (!conversion_path)
5179 conversion_path = BASELINK_BINFO (fns);
5180 access_binfo = BASELINK_ACCESS_BINFO (fns);
5181 optype = BASELINK_OPTYPE (fns);
5182 fns = BASELINK_FUNCTIONS (fns);
5184 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5186 explicit_targs = TREE_OPERAND (fns, 1);
5187 fns = TREE_OPERAND (fns, 0);
5191 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
5192 || TREE_CODE (fns) == TEMPLATE_DECL
5193 || TREE_CODE (fns) == OVERLOAD,
5196 /* XXX this should be handled before we get here. */
5197 if (! IS_AGGR_TYPE (basetype))
5199 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5200 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5201 fns, instance, basetype);
5203 return error_mark_node;
5206 fn = get_first_fn (fns);
5207 name = DECL_NAME (fn);
5209 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5211 /* Callers should explicitly indicate whether they want to construct
5212 the complete object or just the part without virtual bases. */
5213 my_friendly_assert (name != ctor_identifier, 20000408);
5214 /* Similarly for destructors. */
5215 my_friendly_assert (name != dtor_identifier, 20000408);
5218 /* It's OK to call destructors on cv-qualified objects. Therefore,
5219 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5220 if (DECL_DESTRUCTOR_P (fn))
5222 tree type = build_pointer_type (basetype);
5223 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5224 instance_ptr = build_nop (type, instance_ptr);
5227 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5228 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5230 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5231 p = conversion_obstack_alloc (0);
5233 for (fn = fns; fn; fn = OVL_NEXT (fn))
5235 tree t = OVL_CURRENT (fn);
5238 /* We can end up here for copy-init of same or base class. */
5239 if ((flags & LOOKUP_ONLYCONVERTING)
5240 && DECL_NONCONVERTING_P (t))
5243 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5244 this_arglist = mem_args;
5246 this_arglist = args;
5248 if (TREE_CODE (t) == TEMPLATE_DECL)
5249 /* A member template. */
5250 add_template_candidate (&candidates, t,
5253 this_arglist, optype,
5258 else if (! template_only)
5259 add_function_candidate (&candidates, t,
5267 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5270 if (!COMPLETE_TYPE_P (basetype))
5271 cxx_incomplete_type_error (instance_ptr, basetype);
5277 pretty_name = name_as_c_string (name, basetype, &free_p);
5278 error ("no matching function for call to `%T::%s(%A)%#V'",
5279 basetype, pretty_name, user_args,
5280 TREE_TYPE (TREE_TYPE (instance_ptr)));
5284 print_z_candidates (candidates);
5285 call = error_mark_node;
5289 cand = tourney (candidates);
5295 pretty_name = name_as_c_string (name, basetype, &free_p);
5296 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
5298 print_z_candidates (candidates);
5301 call = error_mark_node;
5305 if (DECL_PURE_VIRTUAL_P (cand->fn)
5306 && instance == current_class_ref
5307 && (DECL_CONSTRUCTOR_P (current_function_decl)
5308 || DECL_DESTRUCTOR_P (current_function_decl))
5309 && ! (flags & LOOKUP_NONVIRTUAL)
5310 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
5311 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5312 "abstract virtual `%#D' called from constructor"
5313 : "abstract virtual `%#D' called from destructor"),
5315 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5316 && is_dummy_object (instance_ptr))
5318 error ("cannot call member function `%D' without object",
5320 call = error_mark_node;
5324 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5325 && resolves_to_fixed_type_p (instance, 0))
5326 flags |= LOOKUP_NONVIRTUAL;
5328 call = build_over_call (cand, flags);
5330 /* In an expression of the form `a->f()' where `f' turns
5331 out to be a static member function, `a' is
5332 none-the-less evaluated. */
5333 if (TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE
5334 && !is_dummy_object (instance_ptr)
5335 && TREE_SIDE_EFFECTS (instance))
5336 call = build (COMPOUND_EXPR, TREE_TYPE (call),
5342 if (processing_template_decl && call != error_mark_node)
5343 call = (build_min_non_dep
5345 build_min_nt (COMPONENT_REF, orig_instance, orig_fns),
5348 /* Free all the conversions we allocated. */
5349 obstack_free (&conversion_obstack, p);
5354 /* Returns true iff standard conversion sequence ICS1 is a proper
5355 subsequence of ICS2. */
5358 is_subseq (conversion *ics1, conversion *ics2)
5360 /* We can assume that a conversion of the same code
5361 between the same types indicates a subsequence since we only get
5362 here if the types we are converting from are the same. */
5364 while (ics1->kind == ck_rvalue
5365 || ics1->kind == ck_lvalue)
5366 ics1 = ics1->u.next;
5370 while (ics2->kind == ck_rvalue
5371 || ics2->kind == ck_lvalue)
5372 ics2 = ics2->u.next;
5374 if (ics2->kind == ck_user
5375 || ics2->kind == ck_ambig
5376 || ics2->kind == ck_identity)
5377 /* At this point, ICS1 cannot be a proper subsequence of
5378 ICS2. We can get a USER_CONV when we are comparing the
5379 second standard conversion sequence of two user conversion
5383 ics2 = ics2->u.next;
5385 if (ics2->kind == ics1->kind
5386 && same_type_p (ics2->type, ics1->type)
5387 && same_type_p (ics2->u.next->type,
5388 ics1->u.next->type))
5393 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5394 be any _TYPE nodes. */
5397 is_properly_derived_from (tree derived, tree base)
5399 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5400 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5403 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5404 considers every class derived from itself. */
5405 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5406 && DERIVED_FROM_P (base, derived));
5409 /* We build the ICS for an implicit object parameter as a pointer
5410 conversion sequence. However, such a sequence should be compared
5411 as if it were a reference conversion sequence. If ICS is the
5412 implicit conversion sequence for an implicit object parameter,
5413 modify it accordingly. */
5416 maybe_handle_implicit_object (conversion **ics)
5420 /* [over.match.funcs]
5422 For non-static member functions, the type of the
5423 implicit object parameter is "reference to cv X"
5424 where X is the class of which the function is a
5425 member and cv is the cv-qualification on the member
5426 function declaration. */
5427 conversion *t = *ics;
5428 tree reference_type;
5430 /* The `this' parameter is a pointer to a class type. Make the
5431 implicit conversion talk about a reference to that same class
5433 reference_type = TREE_TYPE (t->type);
5434 reference_type = build_reference_type (reference_type);
5436 if (t->kind == ck_qual)
5438 if (t->kind == ck_ptr)
5440 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5441 t = direct_reference_binding (reference_type, t);
5446 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5447 and return the type to which the reference refers. Otherwise,
5448 leave *ICS unchanged and return NULL_TREE. */
5451 maybe_handle_ref_bind (conversion **ics)
5453 if ((*ics)->kind == ck_ref_bind)
5455 conversion *old_ics = *ics;
5456 tree type = TREE_TYPE (old_ics->type);
5457 *ics = old_ics->u.next;
5458 (*ics)->user_conv_p = old_ics->user_conv_p;
5459 (*ics)->bad_p = old_ics->bad_p;
5466 /* Compare two implicit conversion sequences according to the rules set out in
5467 [over.ics.rank]. Return values:
5469 1: ics1 is better than ics2
5470 -1: ics2 is better than ics1
5471 0: ics1 and ics2 are indistinguishable */
5474 compare_ics (conversion *ics1, conversion *ics2)
5480 tree deref_from_type1 = NULL_TREE;
5481 tree deref_from_type2 = NULL_TREE;
5482 tree deref_to_type1 = NULL_TREE;
5483 tree deref_to_type2 = NULL_TREE;
5484 conversion_rank rank1, rank2;
5486 /* REF_BINDING is nonzero if the result of the conversion sequence
5487 is a reference type. In that case TARGET_TYPE is the
5488 type referred to by the reference. */
5492 /* Handle implicit object parameters. */
5493 maybe_handle_implicit_object (&ics1);
5494 maybe_handle_implicit_object (&ics2);
5496 /* Handle reference parameters. */
5497 target_type1 = maybe_handle_ref_bind (&ics1);
5498 target_type2 = maybe_handle_ref_bind (&ics2);
5502 When comparing the basic forms of implicit conversion sequences (as
5503 defined in _over.best.ics_)
5505 --a standard conversion sequence (_over.ics.scs_) is a better
5506 conversion sequence than a user-defined conversion sequence
5507 or an ellipsis conversion sequence, and
5509 --a user-defined conversion sequence (_over.ics.user_) is a
5510 better conversion sequence than an ellipsis conversion sequence
5511 (_over.ics.ellipsis_). */
5512 rank1 = CONVERSION_RANK (ics1);
5513 rank2 = CONVERSION_RANK (ics2);
5517 else if (rank1 < rank2)
5520 if (rank1 == cr_bad)
5522 /* XXX Isn't this an extension? */
5523 /* Both ICS are bad. We try to make a decision based on what
5524 would have happened if they'd been good. */
5525 if (ics1->user_conv_p > ics2->user_conv_p
5526 || ics1->rank > ics2->rank)
5528 else if (ics1->user_conv_p < ics2->user_conv_p
5529 || ics1->rank < ics2->rank)
5532 /* We couldn't make up our minds; try to figure it out below. */
5535 if (ics1->ellipsis_p)
5536 /* Both conversions are ellipsis conversions. */
5539 /* User-defined conversion sequence U1 is a better conversion sequence
5540 than another user-defined conversion sequence U2 if they contain the
5541 same user-defined conversion operator or constructor and if the sec-
5542 ond standard conversion sequence of U1 is better than the second
5543 standard conversion sequence of U2. */
5545 if (ics1->user_conv_p)
5550 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5551 if (t1->kind == ck_ambig)
5553 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5554 if (t2->kind == ck_ambig)
5557 if (t1->cand->fn != t2->cand->fn)
5560 /* We can just fall through here, after setting up
5561 FROM_TYPE1 and FROM_TYPE2. */
5562 from_type1 = t1->type;
5563 from_type2 = t2->type;
5570 /* We're dealing with two standard conversion sequences.
5574 Standard conversion sequence S1 is a better conversion
5575 sequence than standard conversion sequence S2 if
5577 --S1 is a proper subsequence of S2 (comparing the conversion
5578 sequences in the canonical form defined by _over.ics.scs_,
5579 excluding any Lvalue Transformation; the identity
5580 conversion sequence is considered to be a subsequence of
5581 any non-identity conversion sequence */
5584 while (t1->kind != ck_identity)
5586 from_type1 = t1->type;
5589 while (t2->kind != ck_identity)
5591 from_type2 = t2->type;
5594 if (same_type_p (from_type1, from_type2))
5596 if (is_subseq (ics1, ics2))
5598 if (is_subseq (ics2, ics1))
5601 /* Otherwise, one sequence cannot be a subsequence of the other; they
5602 don't start with the same type. This can happen when comparing the
5603 second standard conversion sequence in two user-defined conversion
5610 --the rank of S1 is better than the rank of S2 (by the rules
5613 Standard conversion sequences are ordered by their ranks: an Exact
5614 Match is a better conversion than a Promotion, which is a better
5615 conversion than a Conversion.
5617 Two conversion sequences with the same rank are indistinguishable
5618 unless one of the following rules applies:
5620 --A conversion that is not a conversion of a pointer, or pointer
5621 to member, to bool is better than another conversion that is such
5624 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5625 so that we do not have to check it explicitly. */
5626 if (ics1->rank < ics2->rank)
5628 else if (ics2->rank < ics1->rank)
5631 to_type1 = ics1->type;
5632 to_type2 = ics2->type;
5634 if (TYPE_PTR_P (from_type1)
5635 && TYPE_PTR_P (from_type2)
5636 && TYPE_PTR_P (to_type1)
5637 && TYPE_PTR_P (to_type2))
5639 deref_from_type1 = TREE_TYPE (from_type1);
5640 deref_from_type2 = TREE_TYPE (from_type2);
5641 deref_to_type1 = TREE_TYPE (to_type1);
5642 deref_to_type2 = TREE_TYPE (to_type2);
5644 /* The rules for pointers to members A::* are just like the rules
5645 for pointers A*, except opposite: if B is derived from A then
5646 A::* converts to B::*, not vice versa. For that reason, we
5647 switch the from_ and to_ variables here. */
5648 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5649 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5650 || (TYPE_PTRMEMFUNC_P (from_type1)
5651 && TYPE_PTRMEMFUNC_P (from_type2)
5652 && TYPE_PTRMEMFUNC_P (to_type1)
5653 && TYPE_PTRMEMFUNC_P (to_type2)))
5655 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5656 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5657 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5658 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5661 if (deref_from_type1 != NULL_TREE
5662 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5663 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5665 /* This was one of the pointer or pointer-like conversions.
5669 --If class B is derived directly or indirectly from class A,
5670 conversion of B* to A* is better than conversion of B* to
5671 void*, and conversion of A* to void* is better than
5672 conversion of B* to void*. */
5673 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5674 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5676 if (is_properly_derived_from (deref_from_type1,
5679 else if (is_properly_derived_from (deref_from_type2,
5683 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5684 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5686 if (same_type_p (deref_from_type1, deref_from_type2))
5688 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5690 if (is_properly_derived_from (deref_from_type1,
5694 /* We know that DEREF_TO_TYPE1 is `void' here. */
5695 else if (is_properly_derived_from (deref_from_type1,
5700 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5701 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5705 --If class B is derived directly or indirectly from class A
5706 and class C is derived directly or indirectly from B,
5708 --conversion of C* to B* is better than conversion of C* to
5711 --conversion of B* to A* is better than conversion of C* to
5713 if (same_type_p (deref_from_type1, deref_from_type2))
5715 if (is_properly_derived_from (deref_to_type1,
5718 else if (is_properly_derived_from (deref_to_type2,
5722 else if (same_type_p (deref_to_type1, deref_to_type2))
5724 if (is_properly_derived_from (deref_from_type2,
5727 else if (is_properly_derived_from (deref_from_type1,
5733 else if (CLASS_TYPE_P (non_reference (from_type1))
5734 && same_type_p (from_type1, from_type2))
5736 tree from = non_reference (from_type1);
5740 --binding of an expression of type C to a reference of type
5741 B& is better than binding an expression of type C to a
5742 reference of type A&
5744 --conversion of C to B is better than conversion of C to A, */
5745 if (is_properly_derived_from (from, to_type1)
5746 && is_properly_derived_from (from, to_type2))
5748 if (is_properly_derived_from (to_type1, to_type2))
5750 else if (is_properly_derived_from (to_type2, to_type1))
5754 else if (CLASS_TYPE_P (non_reference (to_type1))
5755 && same_type_p (to_type1, to_type2))
5757 tree to = non_reference (to_type1);
5761 --binding of an expression of type B to a reference of type
5762 A& is better than binding an expression of type C to a
5763 reference of type A&,
5765 --conversion of B to A is better than conversion of C to A */
5766 if (is_properly_derived_from (from_type1, to)
5767 && is_properly_derived_from (from_type2, to))
5769 if (is_properly_derived_from (from_type2, from_type1))
5771 else if (is_properly_derived_from (from_type1, from_type2))
5778 --S1 and S2 differ only in their qualification conversion and yield
5779 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5780 qualification signature of type T1 is a proper subset of the cv-
5781 qualification signature of type T2 */
5782 if (ics1->kind == ck_qual
5783 && ics2->kind == ck_qual
5784 && same_type_p (from_type1, from_type2))
5785 return comp_cv_qual_signature (to_type1, to_type2);
5789 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5790 types to which the references refer are the same type except for
5791 top-level cv-qualifiers, and the type to which the reference
5792 initialized by S2 refers is more cv-qualified than the type to
5793 which the reference initialized by S1 refers */
5795 if (target_type1 && target_type2
5796 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5797 return comp_cv_qualification (target_type2, target_type1);
5799 /* Neither conversion sequence is better than the other. */
5803 /* The source type for this standard conversion sequence. */
5806 source_type (conversion *t)
5808 for (;; t = t->u.next)
5810 if (t->kind == ck_user
5811 || t->kind == ck_ambig
5812 || t->kind == ck_identity)
5818 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5819 a pointer to LOSER and re-running joust to produce the warning if WINNER
5820 is actually used. */
5823 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5825 candidate_warning *cw;
5827 cw = conversion_obstack_alloc (sizeof (candidate_warning));
5829 cw->next = winner->warnings;
5830 winner->warnings = cw;
5833 /* Compare two candidates for overloading as described in
5834 [over.match.best]. Return values:
5836 1: cand1 is better than cand2
5837 -1: cand2 is better than cand1
5838 0: cand1 and cand2 are indistinguishable */
5841 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5844 int off1 = 0, off2 = 0;
5848 /* Candidates that involve bad conversions are always worse than those
5850 if (cand1->viable > cand2->viable)
5852 if (cand1->viable < cand2->viable)
5855 /* If we have two pseudo-candidates for conversions to the same type,
5856 or two candidates for the same function, arbitrarily pick one. */
5857 if (cand1->fn == cand2->fn
5858 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5861 /* a viable function F1
5862 is defined to be a better function than another viable function F2 if
5863 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5864 ICSi(F2), and then */
5866 /* for some argument j, ICSj(F1) is a better conversion sequence than
5869 /* For comparing static and non-static member functions, we ignore
5870 the implicit object parameter of the non-static function. The
5871 standard says to pretend that the static function has an object
5872 parm, but that won't work with operator overloading. */
5873 len = cand1->num_convs;
5874 if (len != cand2->num_convs)
5876 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5877 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5879 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5880 && DECL_STATIC_FUNCTION_P (cand2->fn))
5889 for (i = 0; i < len; ++i)
5891 conversion *t1 = cand1->convs[i + off1];
5892 conversion *t2 = cand2->convs[i + off2];
5893 int comp = compare_ics (t1, t2);
5898 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
5899 == cr_std + cr_promotion)
5900 && t1->kind == ck_std
5901 && t2->kind == ck_std
5902 && TREE_CODE (t1->type) == INTEGER_TYPE
5903 && TREE_CODE (t2->type) == INTEGER_TYPE
5904 && (TYPE_PRECISION (t1->type)
5905 == TYPE_PRECISION (t2->type))
5906 && (TREE_UNSIGNED (t1->u.next->type)
5907 || (TREE_CODE (t1->u.next->type)
5910 tree type = t1->u.next->type;
5912 struct z_candidate *w, *l;
5914 type1 = t1->type, type2 = t2->type,
5915 w = cand1, l = cand2;
5917 type1 = t2->type, type2 = t1->type,
5918 w = cand2, l = cand1;
5922 warning ("passing `%T' chooses `%T' over `%T'",
5923 type, type1, type2);
5924 warning (" in call to `%D'", w->fn);
5930 if (winner && comp != winner)
5939 /* warn about confusing overload resolution for user-defined conversions,
5940 either between a constructor and a conversion op, or between two
5942 if (winner && warn_conversion && cand1->second_conv
5943 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5944 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5946 struct z_candidate *w, *l;
5947 bool give_warning = false;
5950 w = cand1, l = cand2;
5952 w = cand2, l = cand1;
5954 /* We don't want to complain about `X::operator T1 ()'
5955 beating `X::operator T2 () const', when T2 is a no less
5956 cv-qualified version of T1. */
5957 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5958 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5960 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5961 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5963 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5968 if (!comp_ptr_ttypes (t, f))
5969 give_warning = true;
5972 give_warning = true;
5978 tree source = source_type (w->convs[0]);
5979 if (! DECL_CONSTRUCTOR_P (w->fn))
5980 source = TREE_TYPE (source);
5981 warning ("choosing `%D' over `%D'", w->fn, l->fn);
5982 warning (" for conversion from `%T' to `%T'",
5983 source, w->second_conv->type);
5984 warning (" because conversion sequence for the argument is better");
5994 F1 is a non-template function and F2 is a template function
5997 if (! cand1->template && cand2->template)
5999 else if (cand1->template && ! cand2->template)
6003 F1 and F2 are template functions and the function template for F1 is
6004 more specialized than the template for F2 according to the partial
6007 if (cand1->template && cand2->template)
6009 winner = more_specialized
6010 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
6012 /* Tell the deduction code how many real function arguments
6013 we saw, not counting the implicit 'this' argument. But,
6014 add_function_candidate() suppresses the "this" argument
6017 [temp.func.order]: The presence of unused ellipsis and default
6018 arguments has no effect on the partial ordering of function
6021 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
6022 - DECL_CONSTRUCTOR_P (cand1->fn)));
6028 the context is an initialization by user-defined conversion (see
6029 _dcl.init_ and _over.match.user_) and the standard conversion
6030 sequence from the return type of F1 to the destination type (i.e.,
6031 the type of the entity being initialized) is a better conversion
6032 sequence than the standard conversion sequence from the return type
6033 of F2 to the destination type. */
6035 if (cand1->second_conv)
6037 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6042 /* Check whether we can discard a builtin candidate, either because we
6043 have two identical ones or matching builtin and non-builtin candidates.
6045 (Pedantically in the latter case the builtin which matched the user
6046 function should not be added to the overload set, but we spot it here.
6049 ... the builtin candidates include ...
6050 - do not have the same parameter type list as any non-template
6051 non-member candidate. */
6053 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6054 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6056 for (i = 0; i < len; ++i)
6057 if (!same_type_p (cand1->convs[i]->type,
6058 cand2->convs[i]->type))
6060 if (i == cand1->num_convs)
6062 if (cand1->fn == cand2->fn)
6063 /* Two built-in candidates; arbitrarily pick one. */
6065 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6066 /* cand1 is built-in; prefer cand2. */
6069 /* cand2 is built-in; prefer cand1. */
6074 /* If the two functions are the same (this can happen with declarations
6075 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6076 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6077 && equal_functions (cand1->fn, cand2->fn))
6082 /* Extension: If the worst conversion for one candidate is worse than the
6083 worst conversion for the other, take the first. */
6086 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6087 struct z_candidate *w = 0, *l = 0;
6089 for (i = 0; i < len; ++i)
6091 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6092 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6093 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6094 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6097 winner = 1, w = cand1, l = cand2;
6099 winner = -1, w = cand2, l = cand1;
6105 ISO C++ says that these are ambiguous, even \
6106 though the worst conversion for the first is better than \
6107 the worst conversion for the second:");
6108 print_z_candidate (_("candidate 1:"), w);
6109 print_z_candidate (_("candidate 2:"), l);
6117 my_friendly_assert (!winner, 20010121);
6121 /* Given a list of candidates for overloading, find the best one, if any.
6122 This algorithm has a worst case of O(2n) (winner is last), and a best
6123 case of O(n/2) (totally ambiguous); much better than a sorting
6126 static struct z_candidate *
6127 tourney (struct z_candidate *candidates)
6129 struct z_candidate *champ = candidates, *challenger;
6131 int champ_compared_to_predecessor = 0;
6133 /* Walk through the list once, comparing each current champ to the next
6134 candidate, knocking out a candidate or two with each comparison. */
6136 for (challenger = champ->next; challenger; )
6138 fate = joust (champ, challenger, 0);
6140 challenger = challenger->next;
6145 champ = challenger->next;
6148 champ_compared_to_predecessor = 0;
6153 champ_compared_to_predecessor = 1;
6156 challenger = champ->next;
6160 /* Make sure the champ is better than all the candidates it hasn't yet
6161 been compared to. */
6163 for (challenger = candidates;
6165 && !(champ_compared_to_predecessor && challenger->next == champ);
6166 challenger = challenger->next)
6168 fate = joust (champ, challenger, 0);
6176 /* Returns nonzero if things of type FROM can be converted to TO. */
6179 can_convert (tree to, tree from)
6181 return can_convert_arg (to, from, NULL_TREE);
6184 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6187 can_convert_arg (tree to, tree from, tree arg)
6193 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6194 p = conversion_obstack_alloc (0);
6196 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6197 ok_p = (t && !t->bad_p);
6199 /* Free all the conversions we allocated. */
6200 obstack_free (&conversion_obstack, p);
6205 /* Like can_convert_arg, but allows dubious conversions as well. */
6208 can_convert_arg_bad (tree to, tree from, tree arg)
6213 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6214 p = conversion_obstack_alloc (0);
6215 /* Try to perform the conversion. */
6216 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6217 /* Free all the conversions we allocated. */
6218 obstack_free (&conversion_obstack, p);
6223 /* Convert EXPR to TYPE. Return the converted expression.
6225 Note that we allow bad conversions here because by the time we get to
6226 this point we are committed to doing the conversion. If we end up
6227 doing a bad conversion, convert_like will complain. */
6230 perform_implicit_conversion (tree type, tree expr)
6235 if (error_operand_p (expr))
6236 return error_mark_node;
6238 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6239 p = conversion_obstack_alloc (0);
6241 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6245 error ("could not convert `%E' to `%T'", expr, type);
6246 expr = error_mark_node;
6249 expr = convert_like (conv, expr);
6251 /* Free all the conversions we allocated. */
6252 obstack_free (&conversion_obstack, p);
6257 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6258 permitted. If the conversion is valid, the converted expression is
6259 returned. Otherwise, NULL_TREE is returned, except in the case
6260 that TYPE is a class type; in that case, an error is issued. */
6263 perform_direct_initialization_if_possible (tree type, tree expr)
6268 if (type == error_mark_node || error_operand_p (expr))
6269 return error_mark_node;
6272 If the destination type is a (possibly cv-qualified) class type:
6274 -- If the initialization is direct-initialization ...,
6275 constructors are considered. ... If no constructor applies, or
6276 the overload resolution is ambiguous, the initialization is
6278 if (CLASS_TYPE_P (type))
6280 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6281 build_tree_list (NULL_TREE, expr),
6284 return build_cplus_new (type, expr);
6287 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6288 p = conversion_obstack_alloc (0);
6290 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6292 if (!conv || conv->bad_p)
6295 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6296 /*issue_conversion_warnings=*/false);
6298 /* Free all the conversions we allocated. */
6299 obstack_free (&conversion_obstack, p);
6304 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6305 is being bound to a temporary. Create and return a new VAR_DECL
6306 with the indicated TYPE; this variable will store the value to
6307 which the reference is bound. */
6310 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6314 /* Create the variable. */
6315 var = build_decl (VAR_DECL, NULL_TREE, type);
6316 DECL_ARTIFICIAL (var) = 1;
6317 TREE_USED (var) = 1;
6319 /* Register the variable. */
6320 if (TREE_STATIC (decl))
6322 /* Namespace-scope or local static; give it a mangled name. */
6325 TREE_STATIC (var) = 1;
6326 name = mangle_ref_init_variable (decl);
6327 DECL_NAME (var) = name;
6328 SET_DECL_ASSEMBLER_NAME (var, name);
6329 var = pushdecl_top_level (var);
6333 /* Create a new cleanup level if necessary. */
6334 maybe_push_cleanup_level (type);
6335 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6336 DECL_CONTEXT (var) = current_function_decl;
6342 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6343 initializing a variable of that TYPE. If DECL is non-NULL, it is
6344 the VAR_DECL being initialized with the EXPR. (In that case, the
6345 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6346 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6347 return, if *CLEANUP is no longer NULL, it will be a CLEANUP_STMT
6348 that should be inserted after the returned expression is used to
6351 Return the converted expression. */
6354 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6359 if (type == error_mark_node || error_operand_p (expr))
6360 return error_mark_node;
6362 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6363 p = conversion_obstack_alloc (0);
6365 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6366 if (!conv || conv->bad_p)
6368 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6369 && !real_lvalue_p (expr))
6370 error ("invalid initialization of non-const reference of "
6371 "type '%T' from a temporary of type '%T'",
6372 type, TREE_TYPE (expr));
6374 error ("invalid initialization of reference of type "
6375 "'%T' from expression of type '%T'", type,
6377 return error_mark_node;
6380 /* If DECL is non-NULL, then this special rule applies:
6384 The temporary to which the reference is bound or the temporary
6385 that is the complete object to which the reference is bound
6386 persists for the lifetime of the reference.
6388 The temporaries created during the evaluation of the expression
6389 initializing the reference, except the temporary to which the
6390 reference is bound, are destroyed at the end of the
6391 full-expression in which they are created.
6393 In that case, we store the converted expression into a new
6394 VAR_DECL in a new scope.
6396 However, we want to be careful not to create temporaries when
6397 they are not required. For example, given:
6400 struct D : public B {};
6404 there is no need to copy the return value from "f"; we can just
6405 extend its lifetime. Similarly, given:
6408 struct T { operator S(); };
6412 we can extend the lifetime of the return value of the conversion
6414 my_friendly_assert (conv->kind == ck_ref_bind, 20030302);
6418 tree base_conv_type;
6420 /* Skip over the REF_BIND. */
6421 conv = conv->u.next;
6422 /* If the next conversion is a BASE_CONV, skip that too -- but
6423 remember that the conversion was required. */
6424 if (conv->kind == ck_base && conv->need_temporary_p)
6426 void (*diagnostic_fn) (const char *, ...);
6427 if (conv->check_copy_constructor_p)
6428 /* Generate a temporary copy purely to generate the required
6430 build_temp (build_dummy_object (TREE_TYPE (expr)),
6432 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6434 base_conv_type = conv->type;
6435 conv = conv->u.next;
6438 base_conv_type = NULL_TREE;
6439 /* Perform the remainder of the conversion. */
6440 expr = convert_like_real (conv, expr,
6441 /*fn=*/NULL_TREE, /*argnum=*/0,
6443 /*issue_conversion_warnings=*/true);
6444 if (!real_lvalue_p (expr))
6449 /* Create the temporary variable. */
6450 type = TREE_TYPE (expr);
6451 var = make_temporary_var_for_ref_to_temp (decl, type);
6452 layout_decl (var, 0);
6453 /* Create the INIT_EXPR that will initialize the temporary
6455 init = build (INIT_EXPR, type, var, expr);
6456 if (at_function_scope_p ())
6458 add_decl_stmt (var);
6459 *cleanup = cxx_maybe_build_cleanup (var);
6461 /* We must be careful to destroy the temporary only
6462 after its initialization has taken place. If the
6463 initialization throws an exception, then the
6464 destructor should not be run. We cannot simply
6465 transform INIT into something like:
6467 (INIT, ({ CLEANUP_STMT; }))
6469 because emit_local_var always treats the
6470 initializer as a full-expression. Thus, the
6471 destructor would run too early; it would run at the
6472 end of initializing the reference variable, rather
6473 than at the end of the block enclosing the
6476 The solution is to pass back a CLEANUP_STMT which
6477 the caller is responsible for attaching to the
6479 *cleanup = build_stmt (CLEANUP_STMT, var, *cleanup);
6483 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6484 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6485 static_aggregates = tree_cons (NULL_TREE, var,
6488 /* Use its address to initialize the reference variable. */
6489 expr = build_address (var);
6490 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6493 /* Take the address of EXPR. */
6494 expr = build_unary_op (ADDR_EXPR, expr, 0);
6495 /* If a BASE_CONV was required, perform it now. */
6497 expr = (perform_implicit_conversion
6498 (build_pointer_type (base_conv_type), expr));
6499 expr = build_nop (type, expr);
6502 /* Perform the conversion. */
6503 expr = convert_like (conv, expr);
6505 /* Free all the conversions we allocated. */
6506 obstack_free (&conversion_obstack, p);
6511 #include "gt-cp-call.h"