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). */
3076 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3077 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3079 if (good_base && at_least_as_qualified_p (t2, t1))
3081 conv = build_identity_conv (t1, e1);
3082 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3083 TYPE_MAIN_VARIANT (t2)))
3084 conv = build_conv (ck_base, t2, conv);
3086 conv = build_conv (ck_rvalue, t2, conv);
3095 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3096 converted to the type that expression E2 would have if E2 were
3097 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3098 return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3101 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3102 arguments to the conditional expression. */
3105 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3109 tree result = NULL_TREE;
3110 tree result_type = NULL_TREE;
3111 bool lvalue_p = true;
3112 struct z_candidate *candidates = 0;
3113 struct z_candidate *cand;
3116 /* As a G++ extension, the second argument to the conditional can be
3117 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3118 c'.) If the second operand is omitted, make sure it is
3119 calculated only once. */
3123 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3125 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3126 if (real_lvalue_p (arg1))
3127 arg2 = arg1 = stabilize_reference (arg1);
3129 arg2 = arg1 = save_expr (arg1);
3134 The first expr ession is implicitly converted to bool (clause
3136 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3138 /* If something has already gone wrong, just pass that fact up the
3140 if (error_operand_p (arg1)
3141 || error_operand_p (arg2)
3142 || error_operand_p (arg3))
3143 return error_mark_node;
3147 If either the second or the third operand has type (possibly
3148 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3149 array-to-pointer (_conv.array_), and function-to-pointer
3150 (_conv.func_) standard conversions are performed on the second
3151 and third operands. */
3152 arg2_type = TREE_TYPE (arg2);
3153 arg3_type = TREE_TYPE (arg3);
3154 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3156 /* Do the conversions. We don't these for `void' type arguments
3157 since it can't have any effect and since decay_conversion
3158 does not handle that case gracefully. */
3159 if (!VOID_TYPE_P (arg2_type))
3160 arg2 = decay_conversion (arg2);
3161 if (!VOID_TYPE_P (arg3_type))
3162 arg3 = decay_conversion (arg3);
3163 arg2_type = TREE_TYPE (arg2);
3164 arg3_type = TREE_TYPE (arg3);
3168 One of the following shall hold:
3170 --The second or the third operand (but not both) is a
3171 throw-expression (_except.throw_); the result is of the
3172 type of the other and is an rvalue.
3174 --Both the second and the third operands have type void; the
3175 result is of type void and is an rvalue.
3177 We must avoid calling force_rvalue for expressions of type
3178 "void" because it will complain that their value is being
3180 if (TREE_CODE (arg2) == THROW_EXPR
3181 && TREE_CODE (arg3) != THROW_EXPR)
3183 if (!VOID_TYPE_P (arg3_type))
3184 arg3 = force_rvalue (arg3);
3185 arg3_type = TREE_TYPE (arg3);
3186 result_type = arg3_type;
3188 else if (TREE_CODE (arg2) != THROW_EXPR
3189 && TREE_CODE (arg3) == THROW_EXPR)
3191 if (!VOID_TYPE_P (arg2_type))
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 arg2_type = TREE_TYPE (arg2);
3248 else if (conv3 && !conv3->bad_p)
3250 arg3 = convert_like (conv3, arg3);
3251 arg3 = convert_from_reference (arg3);
3252 arg3_type = TREE_TYPE (arg3);
3255 /* Free all the conversions we allocated. */
3256 obstack_free (&conversion_obstack, p);
3261 /* If, after the conversion, both operands have class type,
3262 treat the cv-qualification of both operands as if it were the
3263 union of the cv-qualification of the operands.
3265 The standard is not clear about what to do in this
3266 circumstance. For example, if the first operand has type
3267 "const X" and the second operand has a user-defined
3268 conversion to "volatile X", what is the type of the second
3269 operand after this step? Making it be "const X" (matching
3270 the first operand) seems wrong, as that discards the
3271 qualification without actually performing a copy. Leaving it
3272 as "volatile X" seems wrong as that will result in the
3273 conditional expression failing altogether, even though,
3274 according to this step, the one operand could be converted to
3275 the type of the other. */
3276 if ((conv2 || conv3)
3277 && CLASS_TYPE_P (arg2_type)
3278 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3279 arg2_type = arg3_type =
3280 cp_build_qualified_type (arg2_type,
3281 TYPE_QUALS (arg2_type)
3282 | TYPE_QUALS (arg3_type));
3287 If the second and third operands are lvalues and have the same
3288 type, the result is of that type and is an lvalue. */
3289 if (real_lvalue_p (arg2)
3290 && real_lvalue_p (arg3)
3291 && same_type_p (arg2_type, arg3_type))
3293 result_type = arg2_type;
3294 goto valid_operands;
3299 Otherwise, the result is an rvalue. If the second and third
3300 operand do not have the same type, and either has (possibly
3301 cv-qualified) class type, overload resolution is used to
3302 determine the conversions (if any) to be applied to the operands
3303 (_over.match.oper_, _over.built_). */
3305 if (!same_type_p (arg2_type, arg3_type)
3306 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3312 /* Rearrange the arguments so that add_builtin_candidate only has
3313 to know about two args. In build_builtin_candidates, the
3314 arguments are unscrambled. */
3318 add_builtin_candidates (&candidates,
3321 ansi_opname (COND_EXPR),
3327 If the overload resolution fails, the program is
3329 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3332 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3333 print_z_candidates (candidates);
3334 return error_mark_node;
3336 cand = tourney (candidates);
3339 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3340 print_z_candidates (candidates);
3341 return error_mark_node;
3346 Otherwise, the conversions thus determined are applied, and
3347 the converted operands are used in place of the original
3348 operands for the remainder of this section. */
3349 conv = cand->convs[0];
3350 arg1 = convert_like (conv, arg1);
3351 conv = cand->convs[1];
3352 arg2 = convert_like (conv, arg2);
3353 conv = cand->convs[2];
3354 arg3 = convert_like (conv, arg3);
3359 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3360 and function-to-pointer (_conv.func_) standard conversions are
3361 performed on the second and third operands.
3363 We need to force the lvalue-to-rvalue conversion here for class types,
3364 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3365 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3368 arg2 = force_rvalue (arg2);
3369 if (!CLASS_TYPE_P (arg2_type))
3370 arg2_type = TREE_TYPE (arg2);
3372 arg3 = force_rvalue (arg3);
3373 if (!CLASS_TYPE_P (arg2_type))
3374 arg3_type = TREE_TYPE (arg3);
3376 if (arg2 == error_mark_node || arg3 == error_mark_node)
3377 return error_mark_node;
3381 After those conversions, one of the following shall hold:
3383 --The second and third operands have the same type; the result is of
3385 if (same_type_p (arg2_type, arg3_type))
3386 result_type = arg2_type;
3389 --The second and third operands have arithmetic or enumeration
3390 type; the usual arithmetic conversions are performed to bring
3391 them to a common type, and the result is of that type. */
3392 else if ((ARITHMETIC_TYPE_P (arg2_type)
3393 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3394 && (ARITHMETIC_TYPE_P (arg3_type)
3395 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3397 /* In this case, there is always a common type. */
3398 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3401 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3402 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3403 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3404 arg2_type, arg3_type);
3405 else if (extra_warnings
3406 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3407 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3408 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3409 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3410 warning ("enumeral and non-enumeral type in conditional expression");
3412 arg2 = perform_implicit_conversion (result_type, arg2);
3413 arg3 = perform_implicit_conversion (result_type, arg3);
3417 --The second and third operands have pointer type, or one has
3418 pointer type and the other is a null pointer constant; pointer
3419 conversions (_conv.ptr_) and qualification conversions
3420 (_conv.qual_) are performed to bring them to their composite
3421 pointer type (_expr.rel_). The result is of the composite
3424 --The second and third operands have pointer to member type, or
3425 one has pointer to member type and the other is a null pointer
3426 constant; pointer to member conversions (_conv.mem_) and
3427 qualification conversions (_conv.qual_) are performed to bring
3428 them to a common type, whose cv-qualification shall match the
3429 cv-qualification of either the second or the third operand.
3430 The result is of the common type. */
3431 else if ((null_ptr_cst_p (arg2)
3432 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3433 || (null_ptr_cst_p (arg3)
3434 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3435 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3436 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3437 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3439 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3440 arg3, "conditional expression");
3441 if (result_type == error_mark_node)
3442 return error_mark_node;
3443 arg2 = perform_implicit_conversion (result_type, arg2);
3444 arg3 = perform_implicit_conversion (result_type, arg3);
3449 error ("operands to ?: have different types");
3450 return error_mark_node;
3454 result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3455 /* We can't use result_type below, as fold might have returned a
3458 /* Expand both sides into the same slot, hopefully the target of the
3459 ?: expression. We used to check for TARGET_EXPRs here, but now we
3460 sometimes wrap them in NOP_EXPRs so the test would fail. */
3461 if (!lvalue_p && CLASS_TYPE_P (TREE_TYPE (result)))
3462 result = get_target_expr (result);
3464 /* If this expression is an rvalue, but might be mistaken for an
3465 lvalue, we must add a NON_LVALUE_EXPR. */
3466 if (!lvalue_p && real_lvalue_p (result))
3467 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3472 /* OPERAND is an operand to an expression. Perform necessary steps
3473 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3477 prep_operand (tree operand)
3481 operand = convert_from_reference (operand);
3482 if (CLASS_TYPE_P (TREE_TYPE (operand))
3483 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3484 /* Make sure the template type is instantiated now. */
3485 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3491 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3492 OVERLOAD) to the CANDIDATES, returning an updated list of
3493 CANDIDATES. The ARGS are the arguments provided to the call,
3494 without any implicit object parameter. The EXPLICIT_TARGS are
3495 explicit template arguments provided. TEMPLATE_ONLY is true if
3496 only template functions should be considered. CONVERSION_PATH,
3497 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3500 add_candidates (tree fns, tree args,
3501 tree explicit_targs, bool template_only,
3502 tree conversion_path, tree access_path,
3504 struct z_candidate **candidates)
3507 tree non_static_args;
3509 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3510 /* Delay creating the implicit this parameter until it is needed. */
3511 non_static_args = NULL_TREE;
3518 fn = OVL_CURRENT (fns);
3519 /* Figure out which set of arguments to use. */
3520 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3522 /* If this function is a non-static member, prepend the implicit
3523 object parameter. */
3524 if (!non_static_args)
3525 non_static_args = tree_cons (NULL_TREE,
3526 build_this (TREE_VALUE (args)),
3528 fn_args = non_static_args;
3531 /* Otherwise, just use the list of arguments provided. */
3534 if (TREE_CODE (fn) == TEMPLATE_DECL)
3535 add_template_candidate (candidates,
3545 else if (!template_only)
3546 add_function_candidate (candidates,
3553 fns = OVL_NEXT (fns);
3558 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3561 struct z_candidate *candidates = 0, *cand;
3562 tree arglist, fnname;
3564 tree result = NULL_TREE;
3565 bool result_valid_p = false;
3566 enum tree_code code2 = NOP_EXPR;
3572 if (error_operand_p (arg1)
3573 || error_operand_p (arg2)
3574 || error_operand_p (arg3))
3575 return error_mark_node;
3577 if (code == MODIFY_EXPR)
3579 code2 = TREE_CODE (arg3);
3581 fnname = ansi_assopname (code2);
3584 fnname = ansi_opname (code);
3586 arg1 = prep_operand (arg1);
3592 case VEC_DELETE_EXPR:
3594 /* Use build_op_new_call and build_op_delete_call instead. */
3598 return build_object_call (arg1, arg2);
3604 arg2 = prep_operand (arg2);
3605 arg3 = prep_operand (arg3);
3607 if (code == COND_EXPR)
3609 if (arg2 == NULL_TREE
3610 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3611 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3612 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3613 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3616 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3617 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3620 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3621 arg2 = integer_zero_node;
3623 arglist = NULL_TREE;
3625 arglist = tree_cons (NULL_TREE, arg3, arglist);
3627 arglist = tree_cons (NULL_TREE, arg2, arglist);
3628 arglist = tree_cons (NULL_TREE, arg1, arglist);
3630 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3631 p = conversion_obstack_alloc (0);
3633 /* Add namespace-scope operators to the list of functions to
3635 add_candidates (lookup_function_nonclass (fnname, arglist),
3636 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3637 flags, &candidates);
3638 /* Add class-member operators to the candidate set. */
3639 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3643 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3644 if (fns == error_mark_node)
3646 result = error_mark_node;
3647 goto user_defined_result_ready;
3650 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3652 BASELINK_BINFO (fns),
3653 TYPE_BINFO (TREE_TYPE (arg1)),
3654 flags, &candidates);
3657 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3658 to know about two args; a builtin candidate will always have a first
3659 parameter of type bool. We'll handle that in
3660 build_builtin_candidate. */
3661 if (code == COND_EXPR)
3671 args[2] = NULL_TREE;
3674 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3680 /* For these, the built-in candidates set is empty
3681 [over.match.oper]/3. We don't want non-strict matches
3682 because exact matches are always possible with built-in
3683 operators. The built-in candidate set for COMPONENT_REF
3684 would be empty too, but since there are no such built-in
3685 operators, we accept non-strict matches for them. */
3690 strict_p = pedantic;
3694 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3699 case POSTINCREMENT_EXPR:
3700 case POSTDECREMENT_EXPR:
3701 /* Look for an `operator++ (int)'. If they didn't have
3702 one, then we fall back to the old way of doing things. */
3703 if (flags & LOOKUP_COMPLAIN)
3704 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3706 operator_name_info[code].name);
3707 if (code == POSTINCREMENT_EXPR)
3708 code = PREINCREMENT_EXPR;
3710 code = PREDECREMENT_EXPR;
3711 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3715 /* The caller will deal with these. */
3720 result_valid_p = true;
3724 if (flags & LOOKUP_COMPLAIN)
3726 op_error (code, code2, arg1, arg2, arg3, "no match");
3727 print_z_candidates (candidates);
3729 result = error_mark_node;
3735 cand = tourney (candidates);
3738 if (flags & LOOKUP_COMPLAIN)
3740 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3741 print_z_candidates (candidates);
3743 result = error_mark_node;
3745 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3748 *overloaded_p = true;
3751 && fnname == ansi_assopname (NOP_EXPR)
3752 && DECL_ARTIFICIAL (cand->fn)
3754 && ! candidates->next->next)
3756 warning ("using synthesized `%#D' for copy assignment",
3758 cp_warning_at (" where cfront would use `%#D'",
3760 ? candidates->next->fn
3764 result = build_over_call (cand, LOOKUP_NORMAL);
3768 /* Check for comparison of different enum types. */
3777 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3778 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3779 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3780 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3782 warning ("comparison between `%#T' and `%#T'",
3783 TREE_TYPE (arg1), TREE_TYPE (arg2));
3790 /* We need to strip any leading REF_BIND so that bitfields
3791 don't cause errors. This should not remove any important
3792 conversions, because builtins don't apply to class
3793 objects directly. */
3794 conv = cand->convs[0];
3795 if (conv->kind == ck_ref_bind)
3796 conv = conv->u.next;
3797 arg1 = convert_like (conv, arg1);
3800 conv = cand->convs[1];
3801 if (conv->kind == ck_ref_bind)
3802 conv = conv->u.next;
3803 arg2 = convert_like (conv, arg2);
3807 conv = cand->convs[2];
3808 if (conv->kind == ck_ref_bind)
3809 conv = conv->u.next;
3810 arg3 = convert_like (conv, arg3);
3815 user_defined_result_ready:
3817 /* Free all the conversions we allocated. */
3818 obstack_free (&conversion_obstack, p);
3820 if (result || result_valid_p)
3827 return build_modify_expr (arg1, code2, arg2);
3830 return build_indirect_ref (arg1, "unary *");
3835 case TRUNC_DIV_EXPR:
3846 case TRUNC_MOD_EXPR:
3850 case TRUTH_ANDIF_EXPR:
3851 case TRUTH_ORIF_EXPR:
3852 return cp_build_binary_op (code, arg1, arg2);
3857 case TRUTH_NOT_EXPR:
3858 case PREINCREMENT_EXPR:
3859 case POSTINCREMENT_EXPR:
3860 case PREDECREMENT_EXPR:
3861 case POSTDECREMENT_EXPR:
3864 return build_unary_op (code, arg1, candidates != 0);
3867 return build_array_ref (arg1, arg2);
3870 return build_conditional_expr (arg1, arg2, arg3);
3873 return build_m_component_ref
3874 (build_indirect_ref (arg1, NULL), arg2);
3876 /* The caller will deal with these. */
3888 /* Build a call to operator delete. This has to be handled very specially,
3889 because the restrictions on what signatures match are different from all
3890 other call instances. For a normal delete, only a delete taking (void *)
3891 or (void *, size_t) is accepted. For a placement delete, only an exact
3892 match with the placement new is accepted.
3894 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3895 ADDR is the pointer to be deleted.
3896 SIZE is the size of the memory block to be deleted.
3897 GLOBAL_P is true if the delete-expression should not consider
3898 class-specific delete operators.
3899 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3902 build_op_delete_call (enum tree_code code, tree addr, tree size,
3903 bool global_p, tree placement)
3905 tree fn = NULL_TREE;
3906 tree fns, fnname, argtypes, args, type;
3909 if (addr == error_mark_node)
3910 return error_mark_node;
3912 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3914 fnname = ansi_opname (code);
3916 if (IS_AGGR_TYPE (type) && !global_p)
3919 If the result of the lookup is ambiguous or inaccessible, or if
3920 the lookup selects a placement deallocation function, the
3921 program is ill-formed.
3923 Therefore, we ask lookup_fnfields to complain about ambiguity. */
3925 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3926 if (fns == error_mark_node)
3927 return error_mark_node;
3932 if (fns == NULL_TREE)
3933 fns = lookup_name_nonclass (fnname);
3940 /* Find the allocation function that is being called. */
3941 call_expr = placement;
3942 /* Extract the function. */
3943 alloc_fn = get_callee_fndecl (call_expr);
3944 my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
3945 /* Then the second parm type. */
3946 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3947 /* Also the second argument. */
3948 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3952 /* First try it without the size argument. */
3953 argtypes = void_list_node;
3957 /* Strip const and volatile from addr. */
3958 addr = cp_convert (ptr_type_node, addr);
3960 /* We make two tries at finding a matching `operator delete'. On
3961 the first pass, we look for a one-operator (or placement)
3962 operator delete. If we're not doing placement delete, then on
3963 the second pass we look for a two-argument delete. */
3964 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
3966 /* Go through the `operator delete' functions looking for one
3967 with a matching type. */
3968 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
3974 /* The first argument must be "void *". */
3975 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3976 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3979 /* On the first pass, check the rest of the arguments. */
3985 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
3993 /* On the second pass, the second argument must be
3996 && same_type_p (TREE_VALUE (t), sizetype)
3997 && TREE_CHAIN (t) == void_list_node)
4001 /* If we found a match, we're done. */
4006 /* If we have a matching function, call it. */
4009 /* Make sure we have the actual function, and not an
4011 fn = OVL_CURRENT (fn);
4013 /* If the FN is a member function, make sure that it is
4015 if (DECL_CLASS_SCOPE_P (fn))
4016 perform_or_defer_access_check (TYPE_BINFO (type), fn);
4019 args = tree_cons (NULL_TREE, addr, args);
4021 args = tree_cons (NULL_TREE, addr,
4022 build_tree_list (NULL_TREE, size));
4026 /* The placement args might not be suitable for overload
4027 resolution at this point, so build the call directly. */
4029 return build_cxx_call (fn, args, args);
4032 return build_function_call (fn, args);
4035 /* If we are doing placement delete we do nothing if we don't find a
4036 matching op delete. */
4040 error ("no suitable `operator %s' for `%T'",
4041 operator_name_info[(int)code].name, type);
4042 return error_mark_node;
4045 /* If the current scope isn't allowed to access DECL along
4046 BASETYPE_PATH, give an error. The most derived class in
4047 BASETYPE_PATH is the one used to qualify DECL. */
4050 enforce_access (tree basetype_path, tree decl)
4052 my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624);
4054 if (!accessible_p (basetype_path, decl))
4056 if (TREE_PRIVATE (decl))
4057 cp_error_at ("`%+#D' is private", decl);
4058 else if (TREE_PROTECTED (decl))
4059 cp_error_at ("`%+#D' is protected", decl);
4061 cp_error_at ("`%+#D' is inaccessible", decl);
4062 error ("within this context");
4069 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4070 bitwise or of LOOKUP_* values. If any errors are warnings are
4071 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4072 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4076 build_temp (tree expr, tree type, int flags,
4077 void (**diagnostic_fn)(const char *, ...))
4081 savew = warningcount, savee = errorcount;
4082 expr = build_special_member_call (NULL_TREE,
4083 complete_ctor_identifier,
4084 build_tree_list (NULL_TREE, expr),
4087 if (warningcount > savew)
4088 *diagnostic_fn = warning;
4089 else if (errorcount > savee)
4090 *diagnostic_fn = error;
4092 *diagnostic_fn = NULL;
4097 /* Perform the conversions in CONVS on the expression EXPR. FN and
4098 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4099 indicates the `this' argument of a method. INNER is nonzero when
4100 being called to continue a conversion chain. It is negative when a
4101 reference binding will be applied, positive otherwise. If
4102 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4103 conversions will be emitted if appropriate. */
4106 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4107 int inner, bool issue_conversion_warnings)
4109 tree totype = convs->type;
4110 void (*diagnostic_fn)(const char *, ...);
4113 && convs->kind != ck_user
4114 && convs->kind != ck_ambig
4115 && convs->kind != ck_ref_bind)
4117 conversion *t = convs;
4118 for (; t; t = convs->u.next)
4120 if (t->kind == ck_user || !t->bad_p)
4122 expr = convert_like_real (t, expr, fn, argnum, 1,
4123 /*issue_conversion_warnings=*/false);
4126 else if (t->kind == ck_ambig)
4127 return convert_like_real (t, expr, fn, argnum, 1,
4128 /*issue_conversion_warnings=*/false);
4129 else if (t->kind == ck_identity)
4132 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
4134 pedwarn (" initializing argument %P of `%D'", argnum, fn);
4135 return cp_convert (totype, expr);
4138 if (issue_conversion_warnings)
4139 expr = dubious_conversion_warnings
4140 (totype, expr, "converting", fn, argnum);
4141 switch (convs->kind)
4145 struct z_candidate *cand = convs->cand;
4146 tree convfn = cand->fn;
4149 if (DECL_CONSTRUCTOR_P (convfn))
4151 tree t = build_int_2 (0, 0);
4152 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (convfn));
4154 args = build_tree_list (NULL_TREE, expr);
4155 if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
4156 || DECL_HAS_VTT_PARM_P (convfn))
4157 /* We should never try to call the abstract or base constructor
4160 args = tree_cons (NULL_TREE, t, args);
4163 args = build_this (expr);
4164 expr = build_over_call (cand, LOOKUP_NORMAL);
4166 /* If this is a constructor or a function returning an aggr type,
4167 we need to build up a TARGET_EXPR. */
4168 if (DECL_CONSTRUCTOR_P (convfn))
4169 expr = build_cplus_new (totype, expr);
4171 /* The result of the call is then used to direct-initialize the object
4172 that is the destination of the copy-initialization. [dcl.init]
4174 Note that this step is not reflected in the conversion sequence;
4175 it affects the semantics when we actually perform the
4176 conversion, but is not considered during overload resolution.
4178 If the target is a class, that means call a ctor. */
4179 if (IS_AGGR_TYPE (totype)
4180 && (inner >= 0 || !lvalue_p (expr)))
4184 /* Core issue 84, now a DR, says that we don't
4185 allow UDCs for these args (which deliberately
4186 breaks copy-init of an auto_ptr<Base> from an
4187 auto_ptr<Derived>). */
4188 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4195 (" initializing argument %P of `%D' from result of `%D'",
4196 argnum, fn, convfn);
4199 (" initializing temporary from result of `%D'", convfn);
4201 expr = build_cplus_new (totype, expr);
4206 if (type_unknown_p (expr))
4207 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4208 /* Convert a non-array constant variable to its underlying value, unless we
4209 are about to bind it to a reference, in which case we need to
4210 leave it as an lvalue. */
4212 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
4213 expr = decl_constant_value (expr);
4214 if (convs->check_copy_constructor_p)
4215 /* Generate a temporary copy purely to generate the required
4219 (build_qualified_type (totype, TYPE_QUAL_CONST)),
4220 totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING, &diagnostic_fn);
4223 /* Call build_user_type_conversion again for the error. */
4224 return build_user_type_conversion
4225 (totype, convs->u.expr, LOOKUP_NORMAL);
4231 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4232 convs->kind == ck_ref_bind ? -1 : 1,
4233 /*issue_conversion_warnings=*/false);
4234 if (expr == error_mark_node)
4235 return error_mark_node;
4237 switch (convs->kind)
4240 if (! IS_AGGR_TYPE (totype))
4242 /* Else fall through. */
4244 if (convs->kind == ck_base && !convs->need_temporary_p)
4246 /* We are going to bind a reference directly to a base-class
4247 subobject of EXPR. */
4248 if (convs->check_copy_constructor_p)
4249 /* Generate a temporary copy purely to generate the required
4251 build_temp (build_dummy_object (TREE_TYPE (expr)),
4253 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4255 /* Build an expression for `*((base*) &expr)'. */
4256 expr = build_unary_op (ADDR_EXPR, expr, 0);
4257 expr = perform_implicit_conversion (build_pointer_type (totype),
4259 expr = build_indirect_ref (expr, "implicit conversion");
4263 /* Copy-initialization where the cv-unqualified version of the source
4264 type is the same class as, or a derived class of, the class of the
4265 destination [is treated as direct-initialization]. [dcl.init] */
4266 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4268 if (diagnostic_fn && fn)
4269 diagnostic_fn (" initializing argument %P of `%D'", argnum, fn);
4270 return build_cplus_new (totype, expr);
4274 tree ref_type = totype;
4276 /* If necessary, create a temporary. */
4277 if (convs->need_temporary_p || !lvalue_p (expr))
4279 tree type = convs->u.next->type;
4281 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4283 /* If the reference is volatile or non-const, we
4284 cannot create a temporary. */
4285 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4287 if (lvalue & clk_bitfield)
4288 error ("cannot bind bitfield `%E' to `%T'",
4290 else if (lvalue & clk_packed)
4291 error ("cannot bind packed field `%E' to `%T'",
4294 error ("cannot bind rvalue `%E' to `%T'", expr, ref_type);
4295 return error_mark_node;
4297 expr = build_target_expr_with_type (expr, type);
4300 /* Take the address of the thing to which we will bind the
4302 expr = build_unary_op (ADDR_EXPR, expr, 1);
4303 if (expr == error_mark_node)
4304 return error_mark_node;
4306 /* Convert it to a pointer to the type referred to by the
4307 reference. This will adjust the pointer if a derived to
4308 base conversion is being performed. */
4309 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4311 /* Convert the pointer to the desired reference type. */
4312 return build_nop (ref_type, expr);
4316 return decay_conversion (expr);
4319 /* Warn about deprecated conversion if appropriate. */
4320 string_conv_p (totype, expr, 1);
4326 return ocp_convert (totype, expr, CONV_IMPLICIT,
4327 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4330 /* Build a call to __builtin_trap which can be used as an expression of
4334 call_builtin_trap (tree type)
4336 tree fn = IDENTIFIER_GLOBAL_VALUE (get_identifier ("__builtin_trap"));
4338 my_friendly_assert (fn != NULL, 20030927);
4339 fn = build_call (fn, NULL_TREE);
4340 fn = build (COMPOUND_EXPR, type, fn, error_mark_node);
4341 fn = force_target_expr (type, fn);
4345 /* ARG is being passed to a varargs function. Perform any conversions
4346 required. Return the converted value. */
4349 convert_arg_to_ellipsis (tree arg)
4353 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4354 standard conversions are performed. */
4355 arg = decay_conversion (arg);
4358 If the argument has integral or enumeration type that is subject
4359 to the integral promotions (_conv.prom_), or a floating point
4360 type that is subject to the floating point promotion
4361 (_conv.fpprom_), the value of the argument is converted to the
4362 promoted type before the call. */
4363 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4364 && (TYPE_PRECISION (TREE_TYPE (arg))
4365 < TYPE_PRECISION (double_type_node)))
4366 arg = convert_to_real (double_type_node, arg);
4367 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4368 arg = perform_integral_promotions (arg);
4370 arg = require_complete_type (arg);
4372 if (arg != error_mark_node
4373 && !pod_type_p (TREE_TYPE (arg)))
4375 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4376 here and do a bitwise copy, but now cp_expr_size will abort if we
4378 If the call appears in the context of a sizeof expression,
4379 there is no need to emit a warning, since the expression won't be
4380 evaluated. We keep the builtin_trap just as a safety check. */
4381 if (!skip_evaluation)
4382 warning ("cannot pass objects of non-POD type `%#T' through `...'; "
4383 "call will abort at runtime", TREE_TYPE (arg));
4384 arg = call_builtin_trap (TREE_TYPE (arg));
4390 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4393 build_x_va_arg (tree expr, tree type)
4395 if (processing_template_decl)
4396 return build_min (VA_ARG_EXPR, type, expr);
4398 type = complete_type_or_else (type, NULL_TREE);
4400 if (expr == error_mark_node || !type)
4401 return error_mark_node;
4403 if (! pod_type_p (type))
4405 /* Undefined behavior [expr.call] 5.2.2/7. */
4406 warning ("cannot receive objects of non-POD type `%#T' through `...'; \
4407 call will abort at runtime",
4409 return call_builtin_trap (type);
4412 return build_va_arg (expr, type);
4415 /* TYPE has been given to va_arg. Apply the default conversions which
4416 would have happened when passed via ellipsis. Return the promoted
4417 type, or the passed type if there is no change. */
4420 cxx_type_promotes_to (tree type)
4424 /* Perform the array-to-pointer and function-to-pointer
4426 type = type_decays_to (type);
4428 promote = type_promotes_to (type);
4429 if (same_type_p (type, promote))
4435 /* ARG is a default argument expression being passed to a parameter of
4436 the indicated TYPE, which is a parameter to FN. Do any required
4437 conversions. Return the converted value. */
4440 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4442 /* If the ARG is an unparsed default argument expression, the
4443 conversion cannot be performed. */
4444 if (TREE_CODE (arg) == DEFAULT_ARG)
4446 error ("the default argument for parameter %d of `%D' has "
4447 "not yet been parsed",
4449 return error_mark_node;
4452 if (fn && DECL_TEMPLATE_INFO (fn))
4453 arg = tsubst_default_argument (fn, type, arg);
4455 arg = break_out_target_exprs (arg);
4457 if (TREE_CODE (arg) == CONSTRUCTOR)
4459 arg = digest_init (type, arg, 0);
4460 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4461 "default argument", fn, parmnum);
4465 /* This could get clobbered by the following call. */
4466 if (TREE_HAS_CONSTRUCTOR (arg))
4467 arg = copy_node (arg);
4469 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4470 "default argument", fn, parmnum);
4471 arg = convert_for_arg_passing (type, arg);
4477 /* Returns the type which will really be used for passing an argument of
4481 type_passed_as (tree type)
4483 /* Pass classes with copy ctors by invisible reference. */
4484 if (TREE_ADDRESSABLE (type))
4485 type = build_reference_type (type);
4486 else if (targetm.calls.promote_prototypes (type)
4487 && INTEGRAL_TYPE_P (type)
4488 && COMPLETE_TYPE_P (type)
4489 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4490 TYPE_SIZE (integer_type_node)))
4491 type = integer_type_node;
4496 /* Actually perform the appropriate conversion. */
4499 convert_for_arg_passing (tree type, tree val)
4501 if (val == error_mark_node)
4503 /* Pass classes with copy ctors by invisible reference. */
4504 else if (TREE_ADDRESSABLE (type))
4505 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4506 else if (targetm.calls.promote_prototypes (type)
4507 && INTEGRAL_TYPE_P (type)
4508 && COMPLETE_TYPE_P (type)
4509 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4510 TYPE_SIZE (integer_type_node)))
4511 val = perform_integral_promotions (val);
4515 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4516 which no conversions at all should be done. This is true for some
4517 builtins which don't act like normal functions. */
4520 magic_varargs_p (tree fn)
4522 if (DECL_BUILT_IN (fn))
4523 switch (DECL_FUNCTION_CODE (fn))
4525 case BUILT_IN_CLASSIFY_TYPE:
4526 case BUILT_IN_CONSTANT_P:
4527 case BUILT_IN_NEXT_ARG:
4528 case BUILT_IN_STDARG_START:
4529 case BUILT_IN_VA_START:
4538 /* Subroutine of the various build_*_call functions. Overload resolution
4539 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4540 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4541 bitmask of various LOOKUP_* flags which apply to the call itself. */
4544 build_over_call (struct z_candidate *cand, int flags)
4547 tree args = cand->args;
4548 conversion **convs = cand->convs;
4550 tree converted_args = NULL_TREE;
4551 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4556 /* In a template, there is no need to perform all of the work that
4557 is normally done. We are only interested in the type of the call
4558 expression, i.e., the return type of the function. Any semantic
4559 errors will be deferred until the template is instantiated. */
4560 if (processing_template_decl)
4564 return_type = TREE_TYPE (TREE_TYPE (fn));
4565 expr = build (CALL_EXPR, return_type, fn, args);
4566 if (!VOID_TYPE_P (return_type))
4567 require_complete_type (return_type);
4568 return convert_from_reference (expr);
4571 /* Give any warnings we noticed during overload resolution. */
4574 struct candidate_warning *w;
4575 for (w = cand->warnings; w; w = w->next)
4576 joust (cand, w->loser, 1);
4579 if (DECL_FUNCTION_MEMBER_P (fn))
4581 /* If FN is a template function, two cases must be considered.
4586 template <class T> void f();
4588 template <class T> struct B {
4592 struct C : A, B<int> {
4594 using B<int>::g; // #2
4597 In case #1 where `A::f' is a member template, DECL_ACCESS is
4598 recorded in the primary template but not in its specialization.
4599 We check access of FN using its primary template.
4601 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4602 because it is a member of class template B, DECL_ACCESS is
4603 recorded in the specialization `B<int>::g'. We cannot use its
4604 primary template because `B<T>::g' and `B<int>::g' may have
4605 different access. */
4606 if (DECL_TEMPLATE_INFO (fn)
4607 && is_member_template (DECL_TI_TEMPLATE (fn)))
4608 perform_or_defer_access_check (cand->access_path,
4609 DECL_TI_TEMPLATE (fn));
4611 perform_or_defer_access_check (cand->access_path, fn);
4614 if (args && TREE_CODE (args) != TREE_LIST)
4615 args = build_tree_list (NULL_TREE, args);
4618 /* The implicit parameters to a constructor are not considered by overload
4619 resolution, and must be of the proper type. */
4620 if (DECL_CONSTRUCTOR_P (fn))
4622 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4623 arg = TREE_CHAIN (arg);
4624 parm = TREE_CHAIN (parm);
4625 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
4626 /* We should never try to call the abstract constructor. */
4628 if (DECL_HAS_VTT_PARM_P (fn))
4630 converted_args = tree_cons
4631 (NULL_TREE, TREE_VALUE (arg), converted_args);
4632 arg = TREE_CHAIN (arg);
4633 parm = TREE_CHAIN (parm);
4636 /* Bypass access control for 'this' parameter. */
4637 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4639 tree parmtype = TREE_VALUE (parm);
4640 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4644 if (convs[i]->bad_p)
4645 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4646 TREE_TYPE (argtype), fn);
4648 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4649 X is called for an object that is not of type X, or of a type
4650 derived from X, the behavior is undefined.
4652 So we can assume that anything passed as 'this' is non-null, and
4653 optimize accordingly. */
4654 my_friendly_assert (TREE_CODE (parmtype) == POINTER_TYPE, 19990811);
4655 /* Convert to the base in which the function was declared. */
4656 my_friendly_assert (cand->conversion_path != NULL_TREE, 20020730);
4657 converted_arg = build_base_path (PLUS_EXPR,
4659 cand->conversion_path,
4661 /* Check that the base class is accessible. */
4662 if (!accessible_base_p (TREE_TYPE (argtype),
4663 BINFO_TYPE (cand->conversion_path)))
4664 error ("`%T' is not an accessible base of `%T'",
4665 BINFO_TYPE (cand->conversion_path),
4666 TREE_TYPE (argtype));
4667 /* If fn was found by a using declaration, the conversion path
4668 will be to the derived class, not the base declaring fn. We
4669 must convert from derived to base. */
4670 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4671 TREE_TYPE (parmtype), ba_ignore, NULL);
4672 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4675 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4676 parm = TREE_CHAIN (parm);
4677 arg = TREE_CHAIN (arg);
4683 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4685 tree type = TREE_VALUE (parm);
4688 val = convert_like_with_context
4689 (conv, TREE_VALUE (arg), fn, i - is_method);
4691 val = convert_for_arg_passing (type, val);
4692 converted_args = tree_cons (NULL_TREE, val, converted_args);
4695 /* Default arguments */
4696 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4698 = tree_cons (NULL_TREE,
4699 convert_default_arg (TREE_VALUE (parm),
4700 TREE_PURPOSE (parm),
4705 for (; arg; arg = TREE_CHAIN (arg))
4707 tree a = TREE_VALUE (arg);
4708 if (magic_varargs_p (fn))
4709 /* Do no conversions for magic varargs. */;
4711 a = convert_arg_to_ellipsis (a);
4712 converted_args = tree_cons (NULL_TREE, a, converted_args);
4715 converted_args = nreverse (converted_args);
4718 check_function_format (NULL, TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4721 /* Avoid actually calling copy constructors and copy assignment operators,
4724 if (! flag_elide_constructors)
4725 /* Do things the hard way. */;
4726 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4729 arg = skip_artificial_parms_for (fn, converted_args);
4730 arg = TREE_VALUE (arg);
4732 /* Pull out the real argument, disregarding const-correctness. */
4734 while (TREE_CODE (targ) == NOP_EXPR
4735 || TREE_CODE (targ) == NON_LVALUE_EXPR
4736 || TREE_CODE (targ) == CONVERT_EXPR)
4737 targ = TREE_OPERAND (targ, 0);
4738 if (TREE_CODE (targ) == ADDR_EXPR)
4740 targ = TREE_OPERAND (targ, 0);
4741 if (!same_type_ignoring_top_level_qualifiers_p
4742 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4751 arg = build_indirect_ref (arg, 0);
4753 /* [class.copy]: the copy constructor is implicitly defined even if
4754 the implementation elided its use. */
4755 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4758 /* If we're creating a temp and we already have one, don't create a
4759 new one. If we're not creating a temp but we get one, use
4760 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4761 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4762 temp or an INIT_EXPR otherwise. */
4763 if (integer_zerop (TREE_VALUE (args)))
4765 if (TREE_CODE (arg) == TARGET_EXPR)
4767 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4768 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4770 else if (TREE_CODE (arg) == TARGET_EXPR
4771 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4774 tree to = stabilize_reference
4775 (build_indirect_ref (TREE_VALUE (args), 0));
4777 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4778 address = build_unary_op (ADDR_EXPR, val, 0);
4779 /* Avoid a warning about this expression, if the address is
4781 TREE_USED (address) = 1;
4785 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4787 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4789 tree to = stabilize_reference
4790 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4791 tree type = TREE_TYPE (to);
4792 tree as_base = CLASSTYPE_AS_BASE (type);
4794 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
4795 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4796 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4799 /* We must only copy the non-tail padding parts. Use
4800 CLASSTYPE_AS_BASE for the bitwise copy. */
4801 tree to_ptr, arg_ptr, to_as_base, arg_as_base, base_ptr_type;
4804 to_ptr = save_expr (build_unary_op (ADDR_EXPR, to, 0));
4805 arg_ptr = build_unary_op (ADDR_EXPR, arg, 0);
4807 base_ptr_type = build_pointer_type (as_base);
4808 to_as_base = build_nop (base_ptr_type, to_ptr);
4809 to_as_base = build_indirect_ref (to_as_base, 0);
4810 arg_as_base = build_nop (base_ptr_type, arg_ptr);
4811 arg_as_base = build_indirect_ref (arg_as_base, 0);
4813 save_to = build_indirect_ref (to_ptr, 0);
4815 val = build (MODIFY_EXPR, as_base, to_as_base, arg_as_base);
4816 val = convert_to_void (val, NULL);
4817 val = build (COMPOUND_EXPR, type, val, save_to);
4818 TREE_NO_UNUSED_WARNING (val) = 1;
4826 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4828 tree t, *p = &TREE_VALUE (converted_args);
4829 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4832 my_friendly_assert (binfo && binfo != error_mark_node, 20010730);
4834 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4835 if (TREE_SIDE_EFFECTS (*p))
4836 *p = save_expr (*p);
4837 t = build_pointer_type (TREE_TYPE (fn));
4838 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4839 fn = build_java_interface_fn_ref (fn, *p);
4841 fn = build_vfn_ref (build_indirect_ref (*p, 0), DECL_VINDEX (fn));
4844 else if (DECL_INLINE (fn))
4845 fn = inline_conversion (fn);
4847 fn = build_addr_func (fn);
4849 return build_cxx_call (fn, args, converted_args);
4852 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4853 gives the original form of the arguments. This function performs
4854 no overload resolution, conversion, or other high-level
4858 build_cxx_call(tree fn, tree args, tree converted_args)
4862 /* Recognize certain built-in functions so we can make tree-codes
4863 other than CALL_EXPR. We do this when it enables fold-const.c
4864 to do something useful. */
4865 if (TREE_CODE (fn) == ADDR_EXPR
4866 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
4867 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
4870 exp = expand_tree_builtin (TREE_OPERAND (fn, 0), args, converted_args);
4875 fn = build_call (fn, converted_args);
4877 /* If this call might throw an exception, note that fact. */
4878 fndecl = get_callee_fndecl (fn);
4879 if ((!fndecl || !TREE_NOTHROW (fndecl))
4880 && at_function_scope_p ()
4882 cp_function_chain->can_throw = 1;
4884 /* Some built-in function calls will be evaluated at compile-time in
4888 if (VOID_TYPE_P (TREE_TYPE (fn)))
4891 fn = require_complete_type (fn);
4892 if (fn == error_mark_node)
4893 return error_mark_node;
4895 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
4896 fn = build_cplus_new (TREE_TYPE (fn), fn);
4897 return convert_from_reference (fn);
4900 static GTY(()) tree java_iface_lookup_fn;
4902 /* Make an expression which yields the address of the Java interface
4903 method FN. This is achieved by generating a call to libjava's
4904 _Jv_LookupInterfaceMethodIdx(). */
4907 build_java_interface_fn_ref (tree fn, tree instance)
4909 tree lookup_args, lookup_fn, method, idx;
4910 tree klass_ref, iface, iface_ref;
4913 if (!java_iface_lookup_fn)
4915 tree endlink = build_void_list_node ();
4916 tree t = tree_cons (NULL_TREE, ptr_type_node,
4917 tree_cons (NULL_TREE, ptr_type_node,
4918 tree_cons (NULL_TREE, java_int_type_node,
4920 java_iface_lookup_fn
4921 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4922 build_function_type (ptr_type_node, t),
4923 0, NOT_BUILT_IN, NULL, NULL_TREE);
4926 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4927 This is the first entry in the vtable. */
4928 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
4931 /* Get the java.lang.Class pointer for the interface being called. */
4932 iface = DECL_CONTEXT (fn);
4933 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
4934 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
4935 || DECL_CONTEXT (iface_ref) != iface)
4937 error ("could not find class$ field in java interface type `%T'",
4939 return error_mark_node;
4941 iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
4943 /* Determine the itable index of FN. */
4945 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
4947 if (!DECL_VIRTUAL_P (method))
4953 idx = build_int_2 (i, 0);
4955 lookup_args = tree_cons (NULL_TREE, klass_ref,
4956 tree_cons (NULL_TREE, iface_ref,
4957 build_tree_list (NULL_TREE, idx)));
4958 lookup_fn = build1 (ADDR_EXPR,
4959 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
4960 java_iface_lookup_fn);
4961 return build (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
4964 /* Returns the value to use for the in-charge parameter when making a
4965 call to a function with the indicated NAME. */
4968 in_charge_arg_for_name (tree name)
4970 if (name == base_ctor_identifier
4971 || name == base_dtor_identifier)
4972 return integer_zero_node;
4973 else if (name == complete_ctor_identifier)
4974 return integer_one_node;
4975 else if (name == complete_dtor_identifier)
4976 return integer_two_node;
4977 else if (name == deleting_dtor_identifier)
4978 return integer_three_node;
4980 /* This function should only be called with one of the names listed
4986 /* Build a call to a constructor, destructor, or an assignment
4987 operator for INSTANCE, an expression with class type. NAME
4988 indicates the special member function to call; ARGS are the
4989 arguments. BINFO indicates the base of INSTANCE that is to be
4990 passed as the `this' parameter to the member function called.
4992 FLAGS are the LOOKUP_* flags to use when processing the call.
4994 If NAME indicates a complete object constructor, INSTANCE may be
4995 NULL_TREE. In this case, the caller will call build_cplus_new to
4996 store the newly constructed object into a VAR_DECL. */
4999 build_special_member_call (tree instance, tree name, tree args,
5000 tree binfo, int flags)
5003 /* The type of the subobject to be constructed or destroyed. */
5006 my_friendly_assert (name == complete_ctor_identifier
5007 || name == base_ctor_identifier
5008 || name == complete_dtor_identifier
5009 || name == base_dtor_identifier
5010 || name == deleting_dtor_identifier
5011 || name == ansi_assopname (NOP_EXPR),
5013 my_friendly_assert (binfo != NULL_TREE, 20020712);
5015 class_type = BINFO_TYPE (binfo);
5017 /* Handle the special case where INSTANCE is NULL_TREE. */
5018 if (name == complete_ctor_identifier && !instance)
5020 instance = build_int_2 (0, 0);
5021 TREE_TYPE (instance) = build_pointer_type (class_type);
5022 instance = build1 (INDIRECT_REF, class_type, instance);
5026 if (name == complete_dtor_identifier
5027 || name == base_dtor_identifier
5028 || name == deleting_dtor_identifier)
5029 my_friendly_assert (args == NULL_TREE, 20020712);
5031 /* Convert to the base class, if necessary. */
5032 if (!same_type_ignoring_top_level_qualifiers_p
5033 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5035 if (name != ansi_assopname (NOP_EXPR))
5036 /* For constructors and destructors, either the base is
5037 non-virtual, or it is virtual but we are doing the
5038 conversion from a constructor or destructor for the
5039 complete object. In either case, we can convert
5041 instance = convert_to_base_statically (instance, binfo);
5043 /* However, for assignment operators, we must convert
5044 dynamically if the base is virtual. */
5045 instance = build_base_path (PLUS_EXPR, instance,
5046 binfo, /*nonnull=*/1);
5050 my_friendly_assert (instance != NULL_TREE, 20020712);
5052 /* Resolve the name. */
5053 if (!complete_type_or_else (BINFO_TYPE (binfo), NULL_TREE))
5054 return error_mark_node;
5056 fns = lookup_fnfields (binfo, name, 1);
5058 /* When making a call to a constructor or destructor for a subobject
5059 that uses virtual base classes, pass down a pointer to a VTT for
5061 if ((name == base_ctor_identifier
5062 || name == base_dtor_identifier)
5063 && TYPE_USES_VIRTUAL_BASECLASSES (class_type))
5068 /* If the current function is a complete object constructor
5069 or destructor, then we fetch the VTT directly.
5070 Otherwise, we look it up using the VTT we were given. */
5071 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5072 vtt = decay_conversion (vtt);
5073 vtt = build (COND_EXPR, TREE_TYPE (vtt),
5074 build (EQ_EXPR, boolean_type_node,
5075 current_in_charge_parm, integer_zero_node),
5078 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo), 20010110);
5079 sub_vtt = build (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5080 BINFO_SUBVTT_INDEX (binfo));
5082 args = tree_cons (NULL_TREE, sub_vtt, args);
5085 return build_new_method_call (instance, fns, args,
5086 TYPE_BINFO (BINFO_TYPE (binfo)),
5090 /* Return the NAME, as a C string. The NAME indicates a function that
5091 is a member of TYPE. *FREE_P is set to true if the caller must
5092 free the memory returned.
5094 Rather than go through all of this, we should simply set the names
5095 of constructors and destructors appropriately, and dispense with
5096 ctor_identifier, dtor_identifier, etc. */
5099 name_as_c_string (tree name, tree type, bool *free_p)
5103 /* Assume that we will not allocate memory. */
5105 /* Constructors and destructors are special. */
5106 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5109 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5110 /* For a destructor, add the '~'. */
5111 if (name == complete_dtor_identifier
5112 || name == base_dtor_identifier
5113 || name == deleting_dtor_identifier)
5115 pretty_name = concat ("~", pretty_name, NULL);
5116 /* Remember that we need to free the memory allocated. */
5120 else if (IDENTIFIER_TYPENAME_P (name))
5122 pretty_name = concat ("operator ",
5123 type_as_string (TREE_TYPE (name),
5124 TFF_PLAIN_IDENTIFIER),
5126 /* Remember that we need to free the memory allocated. */
5130 pretty_name = (char *) IDENTIFIER_POINTER (name);
5135 /* Build a call to "INSTANCE.FN (ARGS)". */
5138 build_new_method_call (tree instance, tree fns, tree args,
5139 tree conversion_path, int flags)
5141 struct z_candidate *candidates = 0, *cand;
5142 tree explicit_targs = NULL_TREE;
5143 tree basetype = NULL_TREE;
5146 tree mem_args = NULL_TREE, instance_ptr;
5152 int template_only = 0;
5159 my_friendly_assert (instance != NULL_TREE, 20020729);
5161 if (error_operand_p (instance)
5162 || error_operand_p (fns)
5163 || args == error_mark_node)
5164 return error_mark_node;
5166 orig_instance = instance;
5170 if (processing_template_decl)
5172 instance = build_non_dependent_expr (instance);
5173 if (!BASELINK_P (fns)
5174 && TREE_CODE (fns) != PSEUDO_DTOR_EXPR
5175 && TREE_TYPE (fns) != unknown_type_node)
5176 fns = build_non_dependent_expr (fns);
5177 args = build_non_dependent_args (orig_args);
5180 /* Process the argument list. */
5182 args = resolve_args (args);
5183 if (args == error_mark_node)
5184 return error_mark_node;
5186 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5187 instance = convert_from_reference (instance);
5188 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5189 instance_ptr = build_this (instance);
5191 if (!BASELINK_P (fns))
5193 error ("call to non-function `%D'", fns);
5194 return error_mark_node;
5197 if (!conversion_path)
5198 conversion_path = BASELINK_BINFO (fns);
5199 access_binfo = BASELINK_ACCESS_BINFO (fns);
5200 optype = BASELINK_OPTYPE (fns);
5201 fns = BASELINK_FUNCTIONS (fns);
5203 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5205 explicit_targs = TREE_OPERAND (fns, 1);
5206 fns = TREE_OPERAND (fns, 0);
5210 my_friendly_assert (TREE_CODE (fns) == FUNCTION_DECL
5211 || TREE_CODE (fns) == TEMPLATE_DECL
5212 || TREE_CODE (fns) == OVERLOAD,
5215 /* XXX this should be handled before we get here. */
5216 if (! IS_AGGR_TYPE (basetype))
5218 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5219 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5220 fns, instance, basetype);
5222 return error_mark_node;
5225 fn = get_first_fn (fns);
5226 name = DECL_NAME (fn);
5228 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5230 /* Callers should explicitly indicate whether they want to construct
5231 the complete object or just the part without virtual bases. */
5232 my_friendly_assert (name != ctor_identifier, 20000408);
5233 /* Similarly for destructors. */
5234 my_friendly_assert (name != dtor_identifier, 20000408);
5237 /* It's OK to call destructors on cv-qualified objects. Therefore,
5238 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5239 if (DECL_DESTRUCTOR_P (fn))
5241 tree type = build_pointer_type (basetype);
5242 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5243 instance_ptr = build_nop (type, instance_ptr);
5246 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5247 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5249 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5250 p = conversion_obstack_alloc (0);
5252 for (fn = fns; fn; fn = OVL_NEXT (fn))
5254 tree t = OVL_CURRENT (fn);
5257 /* We can end up here for copy-init of same or base class. */
5258 if ((flags & LOOKUP_ONLYCONVERTING)
5259 && DECL_NONCONVERTING_P (t))
5262 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5263 this_arglist = mem_args;
5265 this_arglist = args;
5267 if (TREE_CODE (t) == TEMPLATE_DECL)
5268 /* A member template. */
5269 add_template_candidate (&candidates, t,
5272 this_arglist, optype,
5277 else if (! template_only)
5278 add_function_candidate (&candidates, t,
5286 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5289 if (!COMPLETE_TYPE_P (basetype))
5290 cxx_incomplete_type_error (instance_ptr, basetype);
5296 pretty_name = name_as_c_string (name, basetype, &free_p);
5297 error ("no matching function for call to `%T::%s(%A)%#V'",
5298 basetype, pretty_name, user_args,
5299 TREE_TYPE (TREE_TYPE (instance_ptr)));
5303 print_z_candidates (candidates);
5304 call = error_mark_node;
5308 cand = tourney (candidates);
5314 pretty_name = name_as_c_string (name, basetype, &free_p);
5315 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name,
5317 print_z_candidates (candidates);
5320 call = error_mark_node;
5324 if (DECL_PURE_VIRTUAL_P (cand->fn)
5325 && instance == current_class_ref
5326 && (DECL_CONSTRUCTOR_P (current_function_decl)
5327 || DECL_DESTRUCTOR_P (current_function_decl))
5328 && ! (flags & LOOKUP_NONVIRTUAL)
5329 && value_member (cand->fn, CLASSTYPE_PURE_VIRTUALS (basetype)))
5330 error ((DECL_CONSTRUCTOR_P (current_function_decl) ?
5331 "abstract virtual `%#D' called from constructor"
5332 : "abstract virtual `%#D' called from destructor"),
5334 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5335 && is_dummy_object (instance_ptr))
5337 error ("cannot call member function `%D' without object",
5339 call = error_mark_node;
5343 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5344 && resolves_to_fixed_type_p (instance, 0))
5345 flags |= LOOKUP_NONVIRTUAL;
5347 call = build_over_call (cand, flags);
5349 /* In an expression of the form `a->f()' where `f' turns
5350 out to be a static member function, `a' is
5351 none-the-less evaluated. */
5352 if (TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE
5353 && !is_dummy_object (instance_ptr)
5354 && TREE_SIDE_EFFECTS (instance))
5355 call = build (COMPOUND_EXPR, TREE_TYPE (call),
5361 if (processing_template_decl && call != error_mark_node)
5362 call = (build_min_non_dep
5364 build_min_nt (COMPONENT_REF, orig_instance, orig_fns),
5367 /* Free all the conversions we allocated. */
5368 obstack_free (&conversion_obstack, p);
5373 /* Returns true iff standard conversion sequence ICS1 is a proper
5374 subsequence of ICS2. */
5377 is_subseq (conversion *ics1, conversion *ics2)
5379 /* We can assume that a conversion of the same code
5380 between the same types indicates a subsequence since we only get
5381 here if the types we are converting from are the same. */
5383 while (ics1->kind == ck_rvalue
5384 || ics1->kind == ck_lvalue)
5385 ics1 = ics1->u.next;
5389 while (ics2->kind == ck_rvalue
5390 || ics2->kind == ck_lvalue)
5391 ics2 = ics2->u.next;
5393 if (ics2->kind == ck_user
5394 || ics2->kind == ck_ambig
5395 || ics2->kind == ck_identity)
5396 /* At this point, ICS1 cannot be a proper subsequence of
5397 ICS2. We can get a USER_CONV when we are comparing the
5398 second standard conversion sequence of two user conversion
5402 ics2 = ics2->u.next;
5404 if (ics2->kind == ics1->kind
5405 && same_type_p (ics2->type, ics1->type)
5406 && same_type_p (ics2->u.next->type,
5407 ics1->u.next->type))
5412 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5413 be any _TYPE nodes. */
5416 is_properly_derived_from (tree derived, tree base)
5418 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5419 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5422 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5423 considers every class derived from itself. */
5424 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5425 && DERIVED_FROM_P (base, derived));
5428 /* We build the ICS for an implicit object parameter as a pointer
5429 conversion sequence. However, such a sequence should be compared
5430 as if it were a reference conversion sequence. If ICS is the
5431 implicit conversion sequence for an implicit object parameter,
5432 modify it accordingly. */
5435 maybe_handle_implicit_object (conversion **ics)
5439 /* [over.match.funcs]
5441 For non-static member functions, the type of the
5442 implicit object parameter is "reference to cv X"
5443 where X is the class of which the function is a
5444 member and cv is the cv-qualification on the member
5445 function declaration. */
5446 conversion *t = *ics;
5447 tree reference_type;
5449 /* The `this' parameter is a pointer to a class type. Make the
5450 implicit conversion talk about a reference to that same class
5452 reference_type = TREE_TYPE (t->type);
5453 reference_type = build_reference_type (reference_type);
5455 if (t->kind == ck_qual)
5457 if (t->kind == ck_ptr)
5459 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5460 t = direct_reference_binding (reference_type, t);
5465 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5466 and return the type to which the reference refers. Otherwise,
5467 leave *ICS unchanged and return NULL_TREE. */
5470 maybe_handle_ref_bind (conversion **ics)
5472 if ((*ics)->kind == ck_ref_bind)
5474 conversion *old_ics = *ics;
5475 tree type = TREE_TYPE (old_ics->type);
5476 *ics = old_ics->u.next;
5477 (*ics)->user_conv_p = old_ics->user_conv_p;
5478 (*ics)->bad_p = old_ics->bad_p;
5485 /* Compare two implicit conversion sequences according to the rules set out in
5486 [over.ics.rank]. Return values:
5488 1: ics1 is better than ics2
5489 -1: ics2 is better than ics1
5490 0: ics1 and ics2 are indistinguishable */
5493 compare_ics (conversion *ics1, conversion *ics2)
5499 tree deref_from_type1 = NULL_TREE;
5500 tree deref_from_type2 = NULL_TREE;
5501 tree deref_to_type1 = NULL_TREE;
5502 tree deref_to_type2 = NULL_TREE;
5503 conversion_rank rank1, rank2;
5505 /* REF_BINDING is nonzero if the result of the conversion sequence
5506 is a reference type. In that case TARGET_TYPE is the
5507 type referred to by the reference. */
5511 /* Handle implicit object parameters. */
5512 maybe_handle_implicit_object (&ics1);
5513 maybe_handle_implicit_object (&ics2);
5515 /* Handle reference parameters. */
5516 target_type1 = maybe_handle_ref_bind (&ics1);
5517 target_type2 = maybe_handle_ref_bind (&ics2);
5521 When comparing the basic forms of implicit conversion sequences (as
5522 defined in _over.best.ics_)
5524 --a standard conversion sequence (_over.ics.scs_) is a better
5525 conversion sequence than a user-defined conversion sequence
5526 or an ellipsis conversion sequence, and
5528 --a user-defined conversion sequence (_over.ics.user_) is a
5529 better conversion sequence than an ellipsis conversion sequence
5530 (_over.ics.ellipsis_). */
5531 rank1 = CONVERSION_RANK (ics1);
5532 rank2 = CONVERSION_RANK (ics2);
5536 else if (rank1 < rank2)
5539 if (rank1 == cr_bad)
5541 /* XXX Isn't this an extension? */
5542 /* Both ICS are bad. We try to make a decision based on what
5543 would have happened if they'd been good. */
5544 if (ics1->user_conv_p > ics2->user_conv_p
5545 || ics1->rank > ics2->rank)
5547 else if (ics1->user_conv_p < ics2->user_conv_p
5548 || ics1->rank < ics2->rank)
5551 /* We couldn't make up our minds; try to figure it out below. */
5554 if (ics1->ellipsis_p)
5555 /* Both conversions are ellipsis conversions. */
5558 /* User-defined conversion sequence U1 is a better conversion sequence
5559 than another user-defined conversion sequence U2 if they contain the
5560 same user-defined conversion operator or constructor and if the sec-
5561 ond standard conversion sequence of U1 is better than the second
5562 standard conversion sequence of U2. */
5564 if (ics1->user_conv_p)
5569 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5570 if (t1->kind == ck_ambig)
5572 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5573 if (t2->kind == ck_ambig)
5576 if (t1->cand->fn != t2->cand->fn)
5579 /* We can just fall through here, after setting up
5580 FROM_TYPE1 and FROM_TYPE2. */
5581 from_type1 = t1->type;
5582 from_type2 = t2->type;
5589 /* We're dealing with two standard conversion sequences.
5593 Standard conversion sequence S1 is a better conversion
5594 sequence than standard conversion sequence S2 if
5596 --S1 is a proper subsequence of S2 (comparing the conversion
5597 sequences in the canonical form defined by _over.ics.scs_,
5598 excluding any Lvalue Transformation; the identity
5599 conversion sequence is considered to be a subsequence of
5600 any non-identity conversion sequence */
5603 while (t1->kind != ck_identity)
5605 from_type1 = t1->type;
5608 while (t2->kind != ck_identity)
5610 from_type2 = t2->type;
5613 if (same_type_p (from_type1, from_type2))
5615 if (is_subseq (ics1, ics2))
5617 if (is_subseq (ics2, ics1))
5620 /* Otherwise, one sequence cannot be a subsequence of the other; they
5621 don't start with the same type. This can happen when comparing the
5622 second standard conversion sequence in two user-defined conversion
5629 --the rank of S1 is better than the rank of S2 (by the rules
5632 Standard conversion sequences are ordered by their ranks: an Exact
5633 Match is a better conversion than a Promotion, which is a better
5634 conversion than a Conversion.
5636 Two conversion sequences with the same rank are indistinguishable
5637 unless one of the following rules applies:
5639 --A conversion that is not a conversion of a pointer, or pointer
5640 to member, to bool is better than another conversion that is such
5643 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5644 so that we do not have to check it explicitly. */
5645 if (ics1->rank < ics2->rank)
5647 else if (ics2->rank < ics1->rank)
5650 to_type1 = ics1->type;
5651 to_type2 = ics2->type;
5653 if (TYPE_PTR_P (from_type1)
5654 && TYPE_PTR_P (from_type2)
5655 && TYPE_PTR_P (to_type1)
5656 && TYPE_PTR_P (to_type2))
5658 deref_from_type1 = TREE_TYPE (from_type1);
5659 deref_from_type2 = TREE_TYPE (from_type2);
5660 deref_to_type1 = TREE_TYPE (to_type1);
5661 deref_to_type2 = TREE_TYPE (to_type2);
5663 /* The rules for pointers to members A::* are just like the rules
5664 for pointers A*, except opposite: if B is derived from A then
5665 A::* converts to B::*, not vice versa. For that reason, we
5666 switch the from_ and to_ variables here. */
5667 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5668 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5669 || (TYPE_PTRMEMFUNC_P (from_type1)
5670 && TYPE_PTRMEMFUNC_P (from_type2)
5671 && TYPE_PTRMEMFUNC_P (to_type1)
5672 && TYPE_PTRMEMFUNC_P (to_type2)))
5674 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5675 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5676 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5677 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5680 if (deref_from_type1 != NULL_TREE
5681 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5682 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5684 /* This was one of the pointer or pointer-like conversions.
5688 --If class B is derived directly or indirectly from class A,
5689 conversion of B* to A* is better than conversion of B* to
5690 void*, and conversion of A* to void* is better than
5691 conversion of B* to void*. */
5692 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5693 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5695 if (is_properly_derived_from (deref_from_type1,
5698 else if (is_properly_derived_from (deref_from_type2,
5702 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5703 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5705 if (same_type_p (deref_from_type1, deref_from_type2))
5707 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5709 if (is_properly_derived_from (deref_from_type1,
5713 /* We know that DEREF_TO_TYPE1 is `void' here. */
5714 else if (is_properly_derived_from (deref_from_type1,
5719 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5720 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5724 --If class B is derived directly or indirectly from class A
5725 and class C is derived directly or indirectly from B,
5727 --conversion of C* to B* is better than conversion of C* to
5730 --conversion of B* to A* is better than conversion of C* to
5732 if (same_type_p (deref_from_type1, deref_from_type2))
5734 if (is_properly_derived_from (deref_to_type1,
5737 else if (is_properly_derived_from (deref_to_type2,
5741 else if (same_type_p (deref_to_type1, deref_to_type2))
5743 if (is_properly_derived_from (deref_from_type2,
5746 else if (is_properly_derived_from (deref_from_type1,
5752 else if (CLASS_TYPE_P (non_reference (from_type1))
5753 && same_type_p (from_type1, from_type2))
5755 tree from = non_reference (from_type1);
5759 --binding of an expression of type C to a reference of type
5760 B& is better than binding an expression of type C to a
5761 reference of type A&
5763 --conversion of C to B is better than conversion of C to A, */
5764 if (is_properly_derived_from (from, to_type1)
5765 && is_properly_derived_from (from, to_type2))
5767 if (is_properly_derived_from (to_type1, to_type2))
5769 else if (is_properly_derived_from (to_type2, to_type1))
5773 else if (CLASS_TYPE_P (non_reference (to_type1))
5774 && same_type_p (to_type1, to_type2))
5776 tree to = non_reference (to_type1);
5780 --binding of an expression of type B to a reference of type
5781 A& is better than binding an expression of type C to a
5782 reference of type A&,
5784 --conversion of B to A is better than conversion of C to A */
5785 if (is_properly_derived_from (from_type1, to)
5786 && is_properly_derived_from (from_type2, to))
5788 if (is_properly_derived_from (from_type2, from_type1))
5790 else if (is_properly_derived_from (from_type1, from_type2))
5797 --S1 and S2 differ only in their qualification conversion and yield
5798 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5799 qualification signature of type T1 is a proper subset of the cv-
5800 qualification signature of type T2 */
5801 if (ics1->kind == ck_qual
5802 && ics2->kind == ck_qual
5803 && same_type_p (from_type1, from_type2))
5804 return comp_cv_qual_signature (to_type1, to_type2);
5808 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5809 types to which the references refer are the same type except for
5810 top-level cv-qualifiers, and the type to which the reference
5811 initialized by S2 refers is more cv-qualified than the type to
5812 which the reference initialized by S1 refers */
5814 if (target_type1 && target_type2
5815 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5816 return comp_cv_qualification (target_type2, target_type1);
5818 /* Neither conversion sequence is better than the other. */
5822 /* The source type for this standard conversion sequence. */
5825 source_type (conversion *t)
5827 for (;; t = t->u.next)
5829 if (t->kind == ck_user
5830 || t->kind == ck_ambig
5831 || t->kind == ck_identity)
5837 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5838 a pointer to LOSER and re-running joust to produce the warning if WINNER
5839 is actually used. */
5842 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5844 candidate_warning *cw;
5846 cw = conversion_obstack_alloc (sizeof (candidate_warning));
5848 cw->next = winner->warnings;
5849 winner->warnings = cw;
5852 /* Compare two candidates for overloading as described in
5853 [over.match.best]. Return values:
5855 1: cand1 is better than cand2
5856 -1: cand2 is better than cand1
5857 0: cand1 and cand2 are indistinguishable */
5860 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5863 int off1 = 0, off2 = 0;
5867 /* Candidates that involve bad conversions are always worse than those
5869 if (cand1->viable > cand2->viable)
5871 if (cand1->viable < cand2->viable)
5874 /* If we have two pseudo-candidates for conversions to the same type,
5875 or two candidates for the same function, arbitrarily pick one. */
5876 if (cand1->fn == cand2->fn
5877 && (TYPE_P (cand1->fn) || DECL_P (cand1->fn)))
5880 /* a viable function F1
5881 is defined to be a better function than another viable function F2 if
5882 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5883 ICSi(F2), and then */
5885 /* for some argument j, ICSj(F1) is a better conversion sequence than
5888 /* For comparing static and non-static member functions, we ignore
5889 the implicit object parameter of the non-static function. The
5890 standard says to pretend that the static function has an object
5891 parm, but that won't work with operator overloading. */
5892 len = cand1->num_convs;
5893 if (len != cand2->num_convs)
5895 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5896 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5898 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5899 && DECL_STATIC_FUNCTION_P (cand2->fn))
5908 for (i = 0; i < len; ++i)
5910 conversion *t1 = cand1->convs[i + off1];
5911 conversion *t2 = cand2->convs[i + off2];
5912 int comp = compare_ics (t1, t2);
5917 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
5918 == cr_std + cr_promotion)
5919 && t1->kind == ck_std
5920 && t2->kind == ck_std
5921 && TREE_CODE (t1->type) == INTEGER_TYPE
5922 && TREE_CODE (t2->type) == INTEGER_TYPE
5923 && (TYPE_PRECISION (t1->type)
5924 == TYPE_PRECISION (t2->type))
5925 && (TREE_UNSIGNED (t1->u.next->type)
5926 || (TREE_CODE (t1->u.next->type)
5929 tree type = t1->u.next->type;
5931 struct z_candidate *w, *l;
5933 type1 = t1->type, type2 = t2->type,
5934 w = cand1, l = cand2;
5936 type1 = t2->type, type2 = t1->type,
5937 w = cand2, l = cand1;
5941 warning ("passing `%T' chooses `%T' over `%T'",
5942 type, type1, type2);
5943 warning (" in call to `%D'", w->fn);
5949 if (winner && comp != winner)
5958 /* warn about confusing overload resolution for user-defined conversions,
5959 either between a constructor and a conversion op, or between two
5961 if (winner && warn_conversion && cand1->second_conv
5962 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
5963 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
5965 struct z_candidate *w, *l;
5966 bool give_warning = false;
5969 w = cand1, l = cand2;
5971 w = cand2, l = cand1;
5973 /* We don't want to complain about `X::operator T1 ()'
5974 beating `X::operator T2 () const', when T2 is a no less
5975 cv-qualified version of T1. */
5976 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
5977 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
5979 tree t = TREE_TYPE (TREE_TYPE (l->fn));
5980 tree f = TREE_TYPE (TREE_TYPE (w->fn));
5982 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
5987 if (!comp_ptr_ttypes (t, f))
5988 give_warning = true;
5991 give_warning = true;
5997 tree source = source_type (w->convs[0]);
5998 if (! DECL_CONSTRUCTOR_P (w->fn))
5999 source = TREE_TYPE (source);
6000 warning ("choosing `%D' over `%D'", w->fn, l->fn);
6001 warning (" for conversion from `%T' to `%T'",
6002 source, w->second_conv->type);
6003 warning (" because conversion sequence for the argument is better");
6013 F1 is a non-template function and F2 is a template function
6016 if (! cand1->template && cand2->template)
6018 else if (cand1->template && ! cand2->template)
6022 F1 and F2 are template functions and the function template for F1 is
6023 more specialized than the template for F2 according to the partial
6026 if (cand1->template && cand2->template)
6028 winner = more_specialized
6029 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template),
6031 /* Tell the deduction code how many real function arguments
6032 we saw, not counting the implicit 'this' argument. But,
6033 add_function_candidate() suppresses the "this" argument
6036 [temp.func.order]: The presence of unused ellipsis and default
6037 arguments has no effect on the partial ordering of function
6040 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1->fn)
6041 - DECL_CONSTRUCTOR_P (cand1->fn)));
6047 the context is an initialization by user-defined conversion (see
6048 _dcl.init_ and _over.match.user_) and the standard conversion
6049 sequence from the return type of F1 to the destination type (i.e.,
6050 the type of the entity being initialized) is a better conversion
6051 sequence than the standard conversion sequence from the return type
6052 of F2 to the destination type. */
6054 if (cand1->second_conv)
6056 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6061 /* Check whether we can discard a builtin candidate, either because we
6062 have two identical ones or matching builtin and non-builtin candidates.
6064 (Pedantically in the latter case the builtin which matched the user
6065 function should not be added to the overload set, but we spot it here.
6068 ... the builtin candidates include ...
6069 - do not have the same parameter type list as any non-template
6070 non-member candidate. */
6072 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6073 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6075 for (i = 0; i < len; ++i)
6076 if (!same_type_p (cand1->convs[i]->type,
6077 cand2->convs[i]->type))
6079 if (i == cand1->num_convs)
6081 if (cand1->fn == cand2->fn)
6082 /* Two built-in candidates; arbitrarily pick one. */
6084 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6085 /* cand1 is built-in; prefer cand2. */
6088 /* cand2 is built-in; prefer cand1. */
6093 /* If the two functions are the same (this can happen with declarations
6094 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6095 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6096 && equal_functions (cand1->fn, cand2->fn))
6101 /* Extension: If the worst conversion for one candidate is worse than the
6102 worst conversion for the other, take the first. */
6105 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6106 struct z_candidate *w = 0, *l = 0;
6108 for (i = 0; i < len; ++i)
6110 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6111 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6112 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6113 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6116 winner = 1, w = cand1, l = cand2;
6118 winner = -1, w = cand2, l = cand1;
6124 ISO C++ says that these are ambiguous, even \
6125 though the worst conversion for the first is better than \
6126 the worst conversion for the second:");
6127 print_z_candidate (_("candidate 1:"), w);
6128 print_z_candidate (_("candidate 2:"), l);
6136 my_friendly_assert (!winner, 20010121);
6140 /* Given a list of candidates for overloading, find the best one, if any.
6141 This algorithm has a worst case of O(2n) (winner is last), and a best
6142 case of O(n/2) (totally ambiguous); much better than a sorting
6145 static struct z_candidate *
6146 tourney (struct z_candidate *candidates)
6148 struct z_candidate *champ = candidates, *challenger;
6150 int champ_compared_to_predecessor = 0;
6152 /* Walk through the list once, comparing each current champ to the next
6153 candidate, knocking out a candidate or two with each comparison. */
6155 for (challenger = champ->next; challenger; )
6157 fate = joust (champ, challenger, 0);
6159 challenger = challenger->next;
6164 champ = challenger->next;
6167 champ_compared_to_predecessor = 0;
6172 champ_compared_to_predecessor = 1;
6175 challenger = champ->next;
6179 /* Make sure the champ is better than all the candidates it hasn't yet
6180 been compared to. */
6182 for (challenger = candidates;
6184 && !(champ_compared_to_predecessor && challenger->next == champ);
6185 challenger = challenger->next)
6187 fate = joust (champ, challenger, 0);
6195 /* Returns nonzero if things of type FROM can be converted to TO. */
6198 can_convert (tree to, tree from)
6200 return can_convert_arg (to, from, NULL_TREE);
6203 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6206 can_convert_arg (tree to, tree from, tree arg)
6212 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6213 p = conversion_obstack_alloc (0);
6215 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6216 ok_p = (t && !t->bad_p);
6218 /* Free all the conversions we allocated. */
6219 obstack_free (&conversion_obstack, p);
6224 /* Like can_convert_arg, but allows dubious conversions as well. */
6227 can_convert_arg_bad (tree to, tree from, tree arg)
6232 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6233 p = conversion_obstack_alloc (0);
6234 /* Try to perform the conversion. */
6235 t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
6236 /* Free all the conversions we allocated. */
6237 obstack_free (&conversion_obstack, p);
6242 /* Convert EXPR to TYPE. Return the converted expression.
6244 Note that we allow bad conversions here because by the time we get to
6245 this point we are committed to doing the conversion. If we end up
6246 doing a bad conversion, convert_like will complain. */
6249 perform_implicit_conversion (tree type, tree expr)
6254 if (error_operand_p (expr))
6255 return error_mark_node;
6257 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6258 p = conversion_obstack_alloc (0);
6260 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6264 error ("could not convert `%E' to `%T'", expr, type);
6265 expr = error_mark_node;
6268 expr = convert_like (conv, expr);
6270 /* Free all the conversions we allocated. */
6271 obstack_free (&conversion_obstack, p);
6276 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6277 permitted. If the conversion is valid, the converted expression is
6278 returned. Otherwise, NULL_TREE is returned, except in the case
6279 that TYPE is a class type; in that case, an error is issued. */
6282 perform_direct_initialization_if_possible (tree type, tree expr)
6287 if (type == error_mark_node || error_operand_p (expr))
6288 return error_mark_node;
6291 If the destination type is a (possibly cv-qualified) class type:
6293 -- If the initialization is direct-initialization ...,
6294 constructors are considered. ... If no constructor applies, or
6295 the overload resolution is ambiguous, the initialization is
6297 if (CLASS_TYPE_P (type))
6299 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6300 build_tree_list (NULL_TREE, expr),
6303 return build_cplus_new (type, expr);
6306 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6307 p = conversion_obstack_alloc (0);
6309 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6311 if (!conv || conv->bad_p)
6314 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6315 /*issue_conversion_warnings=*/false);
6317 /* Free all the conversions we allocated. */
6318 obstack_free (&conversion_obstack, p);
6323 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6324 is being bound to a temporary. Create and return a new VAR_DECL
6325 with the indicated TYPE; this variable will store the value to
6326 which the reference is bound. */
6329 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6333 /* Create the variable. */
6334 var = build_decl (VAR_DECL, NULL_TREE, type);
6335 DECL_ARTIFICIAL (var) = 1;
6336 TREE_USED (var) = 1;
6338 /* Register the variable. */
6339 if (TREE_STATIC (decl))
6341 /* Namespace-scope or local static; give it a mangled name. */
6344 TREE_STATIC (var) = 1;
6345 name = mangle_ref_init_variable (decl);
6346 DECL_NAME (var) = name;
6347 SET_DECL_ASSEMBLER_NAME (var, name);
6348 var = pushdecl_top_level (var);
6352 /* Create a new cleanup level if necessary. */
6353 maybe_push_cleanup_level (type);
6354 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
6355 DECL_CONTEXT (var) = current_function_decl;
6361 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6362 initializing a variable of that TYPE. If DECL is non-NULL, it is
6363 the VAR_DECL being initialized with the EXPR. (In that case, the
6364 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6365 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6366 return, if *CLEANUP is no longer NULL, it will be a CLEANUP_STMT
6367 that should be inserted after the returned expression is used to
6370 Return the converted expression. */
6373 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6378 if (type == error_mark_node || error_operand_p (expr))
6379 return error_mark_node;
6381 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6382 p = conversion_obstack_alloc (0);
6384 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6385 if (!conv || conv->bad_p)
6387 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6388 && !real_lvalue_p (expr))
6389 error ("invalid initialization of non-const reference of "
6390 "type '%T' from a temporary of type '%T'",
6391 type, TREE_TYPE (expr));
6393 error ("invalid initialization of reference of type "
6394 "'%T' from expression of type '%T'", type,
6396 return error_mark_node;
6399 /* If DECL is non-NULL, then this special rule applies:
6403 The temporary to which the reference is bound or the temporary
6404 that is the complete object to which the reference is bound
6405 persists for the lifetime of the reference.
6407 The temporaries created during the evaluation of the expression
6408 initializing the reference, except the temporary to which the
6409 reference is bound, are destroyed at the end of the
6410 full-expression in which they are created.
6412 In that case, we store the converted expression into a new
6413 VAR_DECL in a new scope.
6415 However, we want to be careful not to create temporaries when
6416 they are not required. For example, given:
6419 struct D : public B {};
6423 there is no need to copy the return value from "f"; we can just
6424 extend its lifetime. Similarly, given:
6427 struct T { operator S(); };
6431 we can extend the lifetime of the return value of the conversion
6433 my_friendly_assert (conv->kind == ck_ref_bind, 20030302);
6437 tree base_conv_type;
6439 /* Skip over the REF_BIND. */
6440 conv = conv->u.next;
6441 /* If the next conversion is a BASE_CONV, skip that too -- but
6442 remember that the conversion was required. */
6443 if (conv->kind == ck_base && conv->need_temporary_p)
6445 void (*diagnostic_fn) (const char *, ...);
6446 if (conv->check_copy_constructor_p)
6447 /* Generate a temporary copy purely to generate the required
6449 build_temp (build_dummy_object (TREE_TYPE (expr)),
6451 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6453 base_conv_type = conv->type;
6454 conv = conv->u.next;
6457 base_conv_type = NULL_TREE;
6458 /* Perform the remainder of the conversion. */
6459 expr = convert_like_real (conv, expr,
6460 /*fn=*/NULL_TREE, /*argnum=*/0,
6462 /*issue_conversion_warnings=*/true);
6463 if (!real_lvalue_p (expr))
6468 /* Create the temporary variable. */
6469 type = TREE_TYPE (expr);
6470 var = make_temporary_var_for_ref_to_temp (decl, type);
6471 layout_decl (var, 0);
6472 /* If the rvalue is the result of a function call it will be
6473 a TARGET_EXPR. If it is some other construct (such as a
6474 member access expression where the underlying object is
6475 itself the result of a function call), turn it into a
6476 TARGET_EXPR here. It is important that EXPR be a
6477 TARGET_EXPR below since otherwise the INIT_EXPR will
6478 attempt to make a bitwise copy of EXPR to initialize
6480 if (TREE_CODE (expr) != TARGET_EXPR)
6481 expr = get_target_expr (expr);
6482 /* Create the INIT_EXPR that will initialize the temporary
6484 init = build (INIT_EXPR, type, var, expr);
6485 if (at_function_scope_p ())
6487 add_decl_stmt (var);
6488 *cleanup = cxx_maybe_build_cleanup (var);
6490 /* We must be careful to destroy the temporary only
6491 after its initialization has taken place. If the
6492 initialization throws an exception, then the
6493 destructor should not be run. We cannot simply
6494 transform INIT into something like:
6496 (INIT, ({ CLEANUP_STMT; }))
6498 because emit_local_var always treats the
6499 initializer as a full-expression. Thus, the
6500 destructor would run too early; it would run at the
6501 end of initializing the reference variable, rather
6502 than at the end of the block enclosing the
6505 The solution is to pass back a CLEANUP_STMT which
6506 the caller is responsible for attaching to the
6508 *cleanup = build_stmt (CLEANUP_STMT, var, *cleanup);
6512 rest_of_decl_compilation (var, NULL, /*toplev=*/1, at_eof);
6513 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6514 static_aggregates = tree_cons (NULL_TREE, var,
6517 /* Use its address to initialize the reference variable. */
6518 expr = build_address (var);
6519 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6522 /* Take the address of EXPR. */
6523 expr = build_unary_op (ADDR_EXPR, expr, 0);
6524 /* If a BASE_CONV was required, perform it now. */
6526 expr = (perform_implicit_conversion
6527 (build_pointer_type (base_conv_type), expr));
6528 expr = build_nop (type, expr);
6531 /* Perform the conversion. */
6532 expr = convert_like (conv, expr);
6534 /* Free all the conversions we allocated. */
6535 obstack_free (&conversion_obstack, p);
6540 #include "gt-cp-call.h"