1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com) and
6 modified by Brendan Kehoe (brendan@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* High-level class interface. */
29 #include "coretypes.h"
38 #include "diagnostic.h"
42 #include "langhooks.h"
44 /* The various kinds of conversion. */
46 typedef enum conversion_kind
{
60 /* The rank of the conversion. Order of the enumerals matters; better
61 conversions should come earlier in the list. */
63 typedef enum conversion_rank
{
74 /* An implicit conversion sequence, in the sense of [over.best.ics].
75 The first conversion to be performed is at the end of the chain.
76 That conversion is always a cr_identity conversion. */
78 typedef struct conversion conversion
;
80 /* The kind of conversion represented by this step. */
82 /* The rank of this conversion. */
84 BOOL_BITFIELD user_conv_p
: 1;
85 BOOL_BITFIELD ellipsis_p
: 1;
86 BOOL_BITFIELD this_p
: 1;
87 BOOL_BITFIELD bad_p
: 1;
88 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
89 temporary should be created to hold the result of the
91 BOOL_BITFIELD need_temporary_p
: 1;
92 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
93 from a pointer-to-derived to pointer-to-base is being performed. */
94 BOOL_BITFIELD base_p
: 1;
95 /* If KIND is ck_ref_bind, true when either an lvalue reference is
96 being bound to an lvalue expression or an rvalue reference is
97 being bound to an rvalue expression. */
98 BOOL_BITFIELD rvaluedness_matches_p
: 1;
99 /* The type of the expression resulting from the conversion. */
102 /* The next conversion in the chain. Since the conversions are
103 arranged from outermost to innermost, the NEXT conversion will
104 actually be performed before this conversion. This variant is
105 used only when KIND is neither ck_identity nor ck_ambig. */
107 /* The expression at the beginning of the conversion chain. This
108 variant is used only if KIND is ck_identity or ck_ambig. */
111 /* The function candidate corresponding to this conversion
112 sequence. This field is only used if KIND is ck_user. */
113 struct z_candidate
*cand
;
116 #define CONVERSION_RANK(NODE) \
117 ((NODE)->bad_p ? cr_bad \
118 : (NODE)->ellipsis_p ? cr_ellipsis \
119 : (NODE)->user_conv_p ? cr_user \
122 static struct obstack conversion_obstack
;
123 static bool conversion_obstack_initialized
;
125 static struct z_candidate
* tourney (struct z_candidate
*);
126 static int equal_functions (tree
, tree
);
127 static int joust (struct z_candidate
*, struct z_candidate
*, bool);
128 static int compare_ics (conversion
*, conversion
*);
129 static tree
build_over_call (struct z_candidate
*, int);
130 static tree
build_java_interface_fn_ref (tree
, tree
);
131 #define convert_like(CONV, EXPR) \
132 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
133 /*issue_conversion_warnings=*/true, \
135 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
136 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
137 /*issue_conversion_warnings=*/true, \
139 static tree
convert_like_real (conversion
*, tree
, tree
, int, int, bool,
141 static void op_error (enum tree_code
, enum tree_code
, tree
, tree
,
143 static tree
build_object_call (tree
, tree
);
144 static tree
resolve_args (tree
);
145 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int);
146 static void print_z_candidate (const char *, struct z_candidate
*);
147 static void print_z_candidates (struct z_candidate
*);
148 static tree
build_this (tree
);
149 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
150 static bool any_strictly_viable (struct z_candidate
*);
151 static struct z_candidate
*add_template_candidate
152 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
,
153 tree
, tree
, int, unification_kind_t
);
154 static struct z_candidate
*add_template_candidate_real
155 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
,
156 tree
, tree
, int, tree
, unification_kind_t
);
157 static struct z_candidate
*add_template_conv_candidate
158 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
, tree
);
159 static void add_builtin_candidates
160 (struct z_candidate
**, enum tree_code
, enum tree_code
,
162 static void add_builtin_candidate
163 (struct z_candidate
**, enum tree_code
, enum tree_code
,
164 tree
, tree
, tree
, tree
*, tree
*, int);
165 static bool is_complete (tree
);
166 static void build_builtin_candidate
167 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
169 static struct z_candidate
*add_conv_candidate
170 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
);
171 static struct z_candidate
*add_function_candidate
172 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
, int);
173 static conversion
*implicit_conversion (tree
, tree
, tree
, bool, int);
174 static conversion
*standard_conversion (tree
, tree
, tree
, bool, int);
175 static conversion
*reference_binding (tree
, tree
, tree
, bool, int);
176 static conversion
*build_conv (conversion_kind
, tree
, conversion
*);
177 static bool is_subseq (conversion
*, conversion
*);
178 static conversion
*maybe_handle_ref_bind (conversion
**);
179 static void maybe_handle_implicit_object (conversion
**);
180 static struct z_candidate
*add_candidate
181 (struct z_candidate
**, tree
, tree
, size_t,
182 conversion
**, tree
, tree
, int);
183 static tree
source_type (conversion
*);
184 static void add_warning (struct z_candidate
*, struct z_candidate
*);
185 static bool reference_related_p (tree
, tree
);
186 static bool reference_compatible_p (tree
, tree
);
187 static conversion
*convert_class_to_reference (tree
, tree
, tree
);
188 static conversion
*direct_reference_binding (tree
, conversion
*);
189 static bool promoted_arithmetic_type_p (tree
);
190 static conversion
*conditional_conversion (tree
, tree
);
191 static char *name_as_c_string (tree
, tree
, bool *);
192 static tree
call_builtin_trap (void);
193 static tree
prep_operand (tree
);
194 static void add_candidates (tree
, tree
, tree
, bool, tree
, tree
,
195 int, struct z_candidate
**);
196 static conversion
*merge_conversion_sequences (conversion
*, conversion
*);
197 static bool magic_varargs_p (tree
);
198 typedef void (*diagnostic_fn_t
) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
199 static tree
build_temp (tree
, tree
, int, diagnostic_fn_t
*);
201 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
202 NAME can take many forms... */
205 check_dtor_name (tree basetype
, tree name
)
207 /* Just accept something we've already complained about. */
208 if (name
== error_mark_node
)
211 if (TREE_CODE (name
) == TYPE_DECL
)
212 name
= TREE_TYPE (name
);
213 else if (TYPE_P (name
))
215 else if (TREE_CODE (name
) == IDENTIFIER_NODE
)
217 if ((IS_AGGR_TYPE (basetype
) && name
== constructor_name (basetype
))
218 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
219 && name
== TYPE_IDENTIFIER (basetype
)))
222 name
= get_type_value (name
);
228 template <class T> struct S { ~S(); };
232 NAME will be a class template. */
233 gcc_assert (DECL_CLASS_TEMPLATE_P (name
));
239 return same_type_p (TYPE_MAIN_VARIANT (basetype
), TYPE_MAIN_VARIANT (name
));
242 /* We want the address of a function or method. We avoid creating a
243 pointer-to-member function. */
246 build_addr_func (tree function
)
248 tree type
= TREE_TYPE (function
);
250 /* We have to do these by hand to avoid real pointer to member
252 if (TREE_CODE (type
) == METHOD_TYPE
)
254 if (TREE_CODE (function
) == OFFSET_REF
)
256 tree object
= build_address (TREE_OPERAND (function
, 0));
257 return get_member_function_from_ptrfunc (&object
,
258 TREE_OPERAND (function
, 1));
260 function
= build_address (function
);
263 function
= decay_conversion (function
);
268 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
269 POINTER_TYPE to those. Note, pointer to member function types
270 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
271 two variants. build_call_a is the primitive taking an array of
272 arguments, while build_call_n is a wrapper that handles varargs. */
275 build_call_n (tree function
, int n
, ...)
278 return build_call_a (function
, 0, NULL
);
281 tree
*argarray
= (tree
*) alloca (n
* sizeof (tree
));
286 for (i
= 0; i
< n
; i
++)
287 argarray
[i
] = va_arg (ap
, tree
);
289 return build_call_a (function
, n
, argarray
);
294 build_call_a (tree function
, int n
, tree
*argarray
)
296 int is_constructor
= 0;
303 function
= build_addr_func (function
);
305 gcc_assert (TYPE_PTR_P (TREE_TYPE (function
)));
306 fntype
= TREE_TYPE (TREE_TYPE (function
));
307 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
308 || TREE_CODE (fntype
) == METHOD_TYPE
);
309 result_type
= TREE_TYPE (fntype
);
311 if (TREE_CODE (function
) == ADDR_EXPR
312 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
314 decl
= TREE_OPERAND (function
, 0);
315 if (!TREE_USED (decl
))
317 /* We invoke build_call directly for several library
318 functions. These may have been declared normally if
319 we're building libgcc, so we can't just check
321 gcc_assert (DECL_ARTIFICIAL (decl
)
322 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)),
330 /* We check both the decl and the type; a function may be known not to
331 throw without being declared throw(). */
332 nothrow
= ((decl
&& TREE_NOTHROW (decl
))
333 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function
))));
335 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
)
336 current_function_returns_abnormally
= 1;
338 if (decl
&& TREE_DEPRECATED (decl
))
339 warn_deprecated_use (decl
);
340 require_complete_eh_spec_types (fntype
, decl
);
342 if (decl
&& DECL_CONSTRUCTOR_P (decl
))
345 /* Don't pass empty class objects by value. This is useful
346 for tags in STL, which are used to control overload resolution.
347 We don't need to handle other cases of copying empty classes. */
348 if (! decl
|| ! DECL_BUILT_IN (decl
))
349 for (i
= 0; i
< n
; i
++)
350 if (is_empty_class (TREE_TYPE (argarray
[i
]))
351 && ! TREE_ADDRESSABLE (TREE_TYPE (argarray
[i
])))
353 tree t
= build0 (EMPTY_CLASS_EXPR
, TREE_TYPE (argarray
[i
]));
354 argarray
[i
] = build2 (COMPOUND_EXPR
, TREE_TYPE (t
),
358 function
= build_call_array (result_type
, function
, n
, argarray
);
359 TREE_HAS_CONSTRUCTOR (function
) = is_constructor
;
360 TREE_NOTHROW (function
) = nothrow
;
365 /* Build something of the form ptr->method (args)
366 or object.method (args). This can also build
367 calls to constructors, and find friends.
369 Member functions always take their class variable
372 INSTANCE is a class instance.
374 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
376 PARMS help to figure out what that NAME really refers to.
378 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
379 down to the real instance type to use for access checking. We need this
380 information to get protected accesses correct.
382 FLAGS is the logical disjunction of zero or more LOOKUP_
383 flags. See cp-tree.h for more info.
385 If this is all OK, calls build_function_call with the resolved
388 This function must also handle being called to perform
389 initialization, promotion/coercion of arguments, and
390 instantiation of default parameters.
392 Note that NAME may refer to an instance variable name. If
393 `operator()()' is defined for the type of that field, then we return
396 /* New overloading code. */
398 typedef struct z_candidate z_candidate
;
400 typedef struct candidate_warning candidate_warning
;
401 struct candidate_warning
{
403 candidate_warning
*next
;
407 /* The FUNCTION_DECL that will be called if this candidate is
408 selected by overload resolution. */
410 /* The arguments to use when calling this function. */
412 /* The implicit conversion sequences for each of the arguments to
415 /* The number of implicit conversion sequences. */
417 /* If FN is a user-defined conversion, the standard conversion
418 sequence from the type returned by FN to the desired destination
420 conversion
*second_conv
;
422 /* If FN is a member function, the binfo indicating the path used to
423 qualify the name of FN at the call site. This path is used to
424 determine whether or not FN is accessible if it is selected by
425 overload resolution. The DECL_CONTEXT of FN will always be a
426 (possibly improper) base of this binfo. */
428 /* If FN is a non-static member function, the binfo indicating the
429 subobject to which the `this' pointer should be converted if FN
430 is selected by overload resolution. The type pointed to the by
431 the `this' pointer must correspond to the most derived class
432 indicated by the CONVERSION_PATH. */
433 tree conversion_path
;
435 candidate_warning
*warnings
;
439 /* Returns true iff T is a null pointer constant in the sense of
443 null_ptr_cst_p (tree t
)
447 A null pointer constant is an integral constant expression
448 (_expr.const_) rvalue of integer type that evaluates to zero. */
449 t
= integral_constant_value (t
);
452 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t
)) && integer_zerop (t
))
455 if (!TREE_OVERFLOW (t
))
461 /* Returns nonzero if PARMLIST consists of only default parms and/or
465 sufficient_parms_p (const_tree parmlist
)
467 for (; parmlist
&& parmlist
!= void_list_node
;
468 parmlist
= TREE_CHAIN (parmlist
))
469 if (!TREE_PURPOSE (parmlist
))
474 /* Allocate N bytes of memory from the conversion obstack. The memory
475 is zeroed before being returned. */
478 conversion_obstack_alloc (size_t n
)
481 if (!conversion_obstack_initialized
)
483 gcc_obstack_init (&conversion_obstack
);
484 conversion_obstack_initialized
= true;
486 p
= obstack_alloc (&conversion_obstack
, n
);
491 /* Dynamically allocate a conversion. */
494 alloc_conversion (conversion_kind kind
)
497 c
= (conversion
*) conversion_obstack_alloc (sizeof (conversion
));
502 #ifdef ENABLE_CHECKING
504 /* Make sure that all memory on the conversion obstack has been
508 validate_conversion_obstack (void)
510 if (conversion_obstack_initialized
)
511 gcc_assert ((obstack_next_free (&conversion_obstack
)
512 == obstack_base (&conversion_obstack
)));
515 #endif /* ENABLE_CHECKING */
517 /* Dynamically allocate an array of N conversions. */
520 alloc_conversions (size_t n
)
522 return (conversion
**) conversion_obstack_alloc (n
* sizeof (conversion
*));
526 build_conv (conversion_kind code
, tree type
, conversion
*from
)
529 conversion_rank rank
= CONVERSION_RANK (from
);
531 /* We can't use buildl1 here because CODE could be USER_CONV, which
532 takes two arguments. In that case, the caller is responsible for
533 filling in the second argument. */
534 t
= alloc_conversion (code
);
557 t
->user_conv_p
= (code
== ck_user
|| from
->user_conv_p
);
558 t
->bad_p
= from
->bad_p
;
563 /* Build a representation of the identity conversion from EXPR to
564 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
567 build_identity_conv (tree type
, tree expr
)
571 c
= alloc_conversion (ck_identity
);
578 /* Converting from EXPR to TYPE was ambiguous in the sense that there
579 were multiple user-defined conversions to accomplish the job.
580 Build a conversion that indicates that ambiguity. */
583 build_ambiguous_conv (tree type
, tree expr
)
587 c
= alloc_conversion (ck_ambig
);
595 strip_top_quals (tree t
)
597 if (TREE_CODE (t
) == ARRAY_TYPE
)
599 return cp_build_qualified_type (t
, 0);
602 /* Returns the standard conversion path (see [conv]) from type FROM to type
603 TO, if any. For proper handling of null pointer constants, you must
604 also pass the expression EXPR to convert from. If C_CAST_P is true,
605 this conversion is coming from a C-style cast. */
608 standard_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
611 enum tree_code fcode
, tcode
;
613 bool fromref
= false;
615 to
= non_reference (to
);
616 if (TREE_CODE (from
) == REFERENCE_TYPE
)
619 from
= TREE_TYPE (from
);
621 to
= strip_top_quals (to
);
622 from
= strip_top_quals (from
);
624 if ((TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
625 && expr
&& type_unknown_p (expr
))
627 expr
= instantiate_type (to
, expr
, tf_conv
);
628 if (expr
== error_mark_node
)
630 from
= TREE_TYPE (expr
);
633 fcode
= TREE_CODE (from
);
634 tcode
= TREE_CODE (to
);
636 conv
= build_identity_conv (from
, expr
);
637 if (fcode
== FUNCTION_TYPE
|| fcode
== ARRAY_TYPE
)
639 from
= type_decays_to (from
);
640 fcode
= TREE_CODE (from
);
641 conv
= build_conv (ck_lvalue
, from
, conv
);
643 else if (fromref
|| (expr
&& lvalue_p (expr
)))
648 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
651 from
= strip_top_quals (bitfield_type
);
652 fcode
= TREE_CODE (from
);
655 conv
= build_conv (ck_rvalue
, from
, conv
);
658 /* Allow conversion between `__complex__' data types. */
659 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
661 /* The standard conversion sequence to convert FROM to TO is
662 the standard conversion sequence to perform componentwise
664 conversion
*part_conv
= standard_conversion
665 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
, c_cast_p
, flags
);
669 conv
= build_conv (part_conv
->kind
, to
, conv
);
670 conv
->rank
= part_conv
->rank
;
678 if (same_type_p (from
, to
))
681 if ((tcode
== POINTER_TYPE
|| TYPE_PTR_TO_MEMBER_P (to
))
682 && expr
&& null_ptr_cst_p (expr
))
683 conv
= build_conv (ck_std
, to
, conv
);
684 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
685 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
687 /* For backwards brain damage compatibility, allow interconversion of
688 pointers and integers with a pedwarn. */
689 conv
= build_conv (ck_std
, to
, conv
);
692 else if (tcode
== ENUMERAL_TYPE
&& fcode
== INTEGER_TYPE
)
694 /* For backwards brain damage compatibility, allow interconversion of
695 enums and integers with a pedwarn. */
696 conv
= build_conv (ck_std
, to
, conv
);
699 else if ((tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
700 || (TYPE_PTRMEM_P (to
) && TYPE_PTRMEM_P (from
)))
705 if (tcode
== POINTER_TYPE
706 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from
),
709 else if (VOID_TYPE_P (TREE_TYPE (to
))
710 && !TYPE_PTRMEM_P (from
)
711 && TREE_CODE (TREE_TYPE (from
)) != FUNCTION_TYPE
)
713 from
= build_pointer_type
714 (cp_build_qualified_type (void_type_node
,
715 cp_type_quals (TREE_TYPE (from
))));
716 conv
= build_conv (ck_ptr
, from
, conv
);
718 else if (TYPE_PTRMEM_P (from
))
720 tree fbase
= TYPE_PTRMEM_CLASS_TYPE (from
);
721 tree tbase
= TYPE_PTRMEM_CLASS_TYPE (to
);
723 if (DERIVED_FROM_P (fbase
, tbase
)
724 && (same_type_ignoring_top_level_qualifiers_p
725 (TYPE_PTRMEM_POINTED_TO_TYPE (from
),
726 TYPE_PTRMEM_POINTED_TO_TYPE (to
))))
728 from
= build_ptrmem_type (tbase
,
729 TYPE_PTRMEM_POINTED_TO_TYPE (from
));
730 conv
= build_conv (ck_pmem
, from
, conv
);
732 else if (!same_type_p (fbase
, tbase
))
735 else if (IS_AGGR_TYPE (TREE_TYPE (from
))
736 && IS_AGGR_TYPE (TREE_TYPE (to
))
739 An rvalue of type "pointer to cv D," where D is a
740 class type, can be converted to an rvalue of type
741 "pointer to cv B," where B is a base class (clause
742 _class.derived_) of D. If B is an inaccessible
743 (clause _class.access_) or ambiguous
744 (_class.member.lookup_) base class of D, a program
745 that necessitates this conversion is ill-formed.
746 Therefore, we use DERIVED_FROM_P, and do not check
747 access or uniqueness. */
748 && DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
))
749 /* If FROM is not yet complete, then we must be parsing
750 the body of a class. We know what's derived from
751 what, but we can't actually perform a
752 derived-to-base conversion. For example, in:
754 struct D : public B {
755 static const int i = sizeof((B*)(D*)0);
758 the D*-to-B* conversion is a reinterpret_cast, not a
760 && COMPLETE_TYPE_P (TREE_TYPE (from
)))
763 cp_build_qualified_type (TREE_TYPE (to
),
764 cp_type_quals (TREE_TYPE (from
)));
765 from
= build_pointer_type (from
);
766 conv
= build_conv (ck_ptr
, from
, conv
);
770 if (tcode
== POINTER_TYPE
)
772 to_pointee
= TREE_TYPE (to
);
773 from_pointee
= TREE_TYPE (from
);
777 to_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (to
);
778 from_pointee
= TYPE_PTRMEM_POINTED_TO_TYPE (from
);
781 if (same_type_p (from
, to
))
783 else if (c_cast_p
&& comp_ptr_ttypes_const (to
, from
))
784 /* In a C-style cast, we ignore CV-qualification because we
785 are allowed to perform a static_cast followed by a
787 conv
= build_conv (ck_qual
, to
, conv
);
788 else if (!c_cast_p
&& comp_ptr_ttypes (to_pointee
, from_pointee
))
789 conv
= build_conv (ck_qual
, to
, conv
);
790 else if (expr
&& string_conv_p (to
, expr
, 0))
791 /* converting from string constant to char *. */
792 conv
= build_conv (ck_qual
, to
, conv
);
793 else if (ptr_reasonably_similar (to_pointee
, from_pointee
))
795 conv
= build_conv (ck_ptr
, to
, conv
);
803 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
805 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
806 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
807 tree fbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn
)));
808 tree tbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn
)));
810 if (!DERIVED_FROM_P (fbase
, tbase
)
811 || !same_type_p (TREE_TYPE (fromfn
), TREE_TYPE (tofn
))
812 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)),
813 TREE_CHAIN (TYPE_ARG_TYPES (tofn
)))
814 || cp_type_quals (fbase
) != cp_type_quals (tbase
))
817 from
= cp_build_qualified_type (tbase
, cp_type_quals (fbase
));
818 from
= build_method_type_directly (from
,
820 TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)));
821 from
= build_ptrmemfunc_type (build_pointer_type (from
));
822 conv
= build_conv (ck_pmem
, from
, conv
);
825 else if (tcode
== BOOLEAN_TYPE
)
829 An rvalue of arithmetic, enumeration, pointer, or pointer to
830 member type can be converted to an rvalue of type bool. */
831 if (ARITHMETIC_TYPE_P (from
)
832 || fcode
== ENUMERAL_TYPE
833 || fcode
== POINTER_TYPE
834 || TYPE_PTR_TO_MEMBER_P (from
))
836 conv
= build_conv (ck_std
, to
, conv
);
837 if (fcode
== POINTER_TYPE
838 || TYPE_PTRMEM_P (from
)
839 || (TYPE_PTRMEMFUNC_P (from
)
840 && conv
->rank
< cr_pbool
))
841 conv
->rank
= cr_pbool
;
847 /* We don't check for ENUMERAL_TYPE here because there are no standard
848 conversions to enum type. */
849 else if (tcode
== INTEGER_TYPE
|| tcode
== BOOLEAN_TYPE
850 || tcode
== REAL_TYPE
)
852 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
))
854 conv
= build_conv (ck_std
, to
, conv
);
856 /* Give this a better rank if it's a promotion. */
857 if (same_type_p (to
, type_promotes_to (from
))
858 && conv
->u
.next
->rank
<= cr_promotion
)
859 conv
->rank
= cr_promotion
;
861 else if (fcode
== VECTOR_TYPE
&& tcode
== VECTOR_TYPE
862 && vector_types_convertible_p (from
, to
, false))
863 return build_conv (ck_std
, to
, conv
);
864 else if (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
865 && is_properly_derived_from (from
, to
))
867 if (conv
->kind
== ck_rvalue
)
869 conv
= build_conv (ck_base
, to
, conv
);
870 /* The derived-to-base conversion indicates the initialization
871 of a parameter with base type from an object of a derived
872 type. A temporary object is created to hold the result of
873 the conversion unless we're binding directly to a reference. */
874 conv
->need_temporary_p
= !(flags
& LOOKUP_NO_TEMP_BIND
);
882 /* Returns nonzero if T1 is reference-related to T2. */
885 reference_related_p (tree t1
, tree t2
)
887 t1
= TYPE_MAIN_VARIANT (t1
);
888 t2
= TYPE_MAIN_VARIANT (t2
);
892 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
893 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
895 return (same_type_p (t1
, t2
)
896 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
897 && DERIVED_FROM_P (t1
, t2
)));
900 /* Returns nonzero if T1 is reference-compatible with T2. */
903 reference_compatible_p (tree t1
, tree t2
)
907 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
908 reference-related to T2 and cv1 is the same cv-qualification as,
909 or greater cv-qualification than, cv2. */
910 return (reference_related_p (t1
, t2
)
911 && at_least_as_qualified_p (t1
, t2
));
914 /* Determine whether or not the EXPR (of class type S) can be
915 converted to T as in [over.match.ref]. */
918 convert_class_to_reference (tree reference_type
, tree s
, tree expr
)
924 struct z_candidate
*candidates
;
925 struct z_candidate
*cand
;
928 conversions
= lookup_conversions (s
);
934 Assuming that "cv1 T" is the underlying type of the reference
935 being initialized, and "cv S" is the type of the initializer
936 expression, with S a class type, the candidate functions are
939 --The conversion functions of S and its base classes are
940 considered. Those that are not hidden within S and yield type
941 "reference to cv2 T2", where "cv1 T" is reference-compatible
942 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
944 The argument list has one argument, which is the initializer
949 /* Conceptually, we should take the address of EXPR and put it in
950 the argument list. Unfortunately, however, that can result in
951 error messages, which we should not issue now because we are just
952 trying to find a conversion operator. Therefore, we use NULL,
953 cast to the appropriate type. */
954 arglist
= build_int_cst (build_pointer_type (s
), 0);
955 arglist
= build_tree_list (NULL_TREE
, arglist
);
957 t
= TREE_TYPE (reference_type
);
961 tree fns
= TREE_VALUE (conversions
);
963 for (; fns
; fns
= OVL_NEXT (fns
))
965 tree f
= OVL_CURRENT (fns
);
966 tree t2
= TREE_TYPE (TREE_TYPE (f
));
970 /* If this is a template function, try to get an exact
972 if (TREE_CODE (f
) == TEMPLATE_DECL
)
974 cand
= add_template_candidate (&candidates
,
980 TREE_PURPOSE (conversions
),
986 /* Now, see if the conversion function really returns
987 an lvalue of the appropriate type. From the
988 point of view of unification, simply returning an
989 rvalue of the right type is good enough. */
991 t2
= TREE_TYPE (TREE_TYPE (f
));
992 if (TREE_CODE (t2
) != REFERENCE_TYPE
993 || !reference_compatible_p (t
, TREE_TYPE (t2
)))
995 candidates
= candidates
->next
;
1000 else if (TREE_CODE (t2
) == REFERENCE_TYPE
1001 && reference_compatible_p (t
, TREE_TYPE (t2
)))
1002 cand
= add_function_candidate (&candidates
, f
, s
, arglist
,
1004 TREE_PURPOSE (conversions
),
1009 conversion
*identity_conv
;
1010 /* Build a standard conversion sequence indicating the
1011 binding from the reference type returned by the
1012 function to the desired REFERENCE_TYPE. */
1014 = build_identity_conv (TREE_TYPE (TREE_TYPE
1015 (TREE_TYPE (cand
->fn
))),
1018 = (direct_reference_binding
1019 (reference_type
, identity_conv
));
1020 cand
->second_conv
->rvaluedness_matches_p
1021 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand
->fn
)))
1022 == TYPE_REF_IS_RVALUE (reference_type
);
1023 cand
->second_conv
->bad_p
|= cand
->convs
[0]->bad_p
;
1026 conversions
= TREE_CHAIN (conversions
);
1029 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
1030 /* If none of the conversion functions worked out, let our caller
1035 cand
= tourney (candidates
);
1039 /* Now that we know that this is the function we're going to use fix
1040 the dummy first argument. */
1041 cand
->args
= tree_cons (NULL_TREE
,
1043 TREE_CHAIN (cand
->args
));
1045 /* Build a user-defined conversion sequence representing the
1047 conv
= build_conv (ck_user
,
1048 TREE_TYPE (TREE_TYPE (cand
->fn
)),
1049 build_identity_conv (TREE_TYPE (expr
), expr
));
1052 /* Merge it with the standard conversion sequence from the
1053 conversion function's return type to the desired type. */
1054 cand
->second_conv
= merge_conversion_sequences (conv
, cand
->second_conv
);
1056 if (cand
->viable
== -1)
1059 return cand
->second_conv
;
1062 /* A reference of the indicated TYPE is being bound directly to the
1063 expression represented by the implicit conversion sequence CONV.
1064 Return a conversion sequence for this binding. */
1067 direct_reference_binding (tree type
, conversion
*conv
)
1071 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
1072 gcc_assert (TREE_CODE (conv
->type
) != REFERENCE_TYPE
);
1074 t
= TREE_TYPE (type
);
1078 When a parameter of reference type binds directly
1079 (_dcl.init.ref_) to an argument expression, the implicit
1080 conversion sequence is the identity conversion, unless the
1081 argument expression has a type that is a derived class of the
1082 parameter type, in which case the implicit conversion sequence is
1083 a derived-to-base Conversion.
1085 If the parameter binds directly to the result of applying a
1086 conversion function to the argument expression, the implicit
1087 conversion sequence is a user-defined conversion sequence
1088 (_over.ics.user_), with the second standard conversion sequence
1089 either an identity conversion or, if the conversion function
1090 returns an entity of a type that is a derived class of the
1091 parameter type, a derived-to-base conversion. */
1092 if (!same_type_ignoring_top_level_qualifiers_p (t
, conv
->type
))
1094 /* Represent the derived-to-base conversion. */
1095 conv
= build_conv (ck_base
, t
, conv
);
1096 /* We will actually be binding to the base-class subobject in
1097 the derived class, so we mark this conversion appropriately.
1098 That way, convert_like knows not to generate a temporary. */
1099 conv
->need_temporary_p
= false;
1101 return build_conv (ck_ref_bind
, type
, conv
);
1104 /* Returns the conversion path from type FROM to reference type TO for
1105 purposes of reference binding. For lvalue binding, either pass a
1106 reference type to FROM or an lvalue expression to EXPR. If the
1107 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1108 the conversion returned. If C_CAST_P is true, this
1109 conversion is coming from a C-style cast. */
1112 reference_binding (tree rto
, tree rfrom
, tree expr
, bool c_cast_p
, int flags
)
1114 conversion
*conv
= NULL
;
1115 tree to
= TREE_TYPE (rto
);
1119 cp_lvalue_kind lvalue_p
= clk_none
;
1121 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1123 expr
= instantiate_type (to
, expr
, tf_none
);
1124 if (expr
== error_mark_node
)
1126 from
= TREE_TYPE (expr
);
1129 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1131 /* Anything with reference type is an lvalue. */
1132 lvalue_p
= clk_ordinary
;
1133 from
= TREE_TYPE (from
);
1136 lvalue_p
= real_lvalue_p (expr
);
1138 /* Figure out whether or not the types are reference-related and
1139 reference compatible. We have do do this after stripping
1140 references from FROM. */
1141 related_p
= reference_related_p (to
, from
);
1142 /* If this is a C cast, first convert to an appropriately qualified
1143 type, so that we can later do a const_cast to the desired type. */
1144 if (related_p
&& c_cast_p
1145 && !at_least_as_qualified_p (to
, from
))
1146 to
= build_qualified_type (to
, cp_type_quals (from
));
1147 compatible_p
= reference_compatible_p (to
, from
);
1149 /* Directly bind reference when target expression's type is compatible with
1150 the reference and expression is an lvalue. In DR391, the wording in
1151 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1152 const and rvalue references to rvalues of compatible class type. */
1155 || ((CP_TYPE_CONST_NON_VOLATILE_P(to
) || TYPE_REF_IS_RVALUE (rto
))
1156 && CLASS_TYPE_P (from
))))
1160 If the initializer expression
1162 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1163 is reference-compatible with "cv2 T2,"
1165 the reference is bound directly to the initializer expression
1169 If the initializer expression is an rvalue, with T2 a class type,
1170 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1171 is bound to the object represented by the rvalue or to a sub-object
1172 within that object. */
1174 conv
= build_identity_conv (from
, expr
);
1175 conv
= direct_reference_binding (rto
, conv
);
1177 if (flags
& LOOKUP_PREFER_RVALUE
)
1178 /* The top-level caller requested that we pretend that the lvalue
1179 be treated as an rvalue. */
1180 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1182 conv
->rvaluedness_matches_p
1183 = (TYPE_REF_IS_RVALUE (rto
) == !lvalue_p
);
1185 if ((lvalue_p
& clk_bitfield
) != 0
1186 || ((lvalue_p
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1187 /* For the purposes of overload resolution, we ignore the fact
1188 this expression is a bitfield or packed field. (In particular,
1189 [over.ics.ref] says specifically that a function with a
1190 non-const reference parameter is viable even if the
1191 argument is a bitfield.)
1193 However, when we actually call the function we must create
1194 a temporary to which to bind the reference. If the
1195 reference is volatile, or isn't const, then we cannot make
1196 a temporary, so we just issue an error when the conversion
1198 conv
->need_temporary_p
= true;
1202 /* [class.conv.fct] A conversion function is never used to convert a
1203 (possibly cv-qualified) object to the (possibly cv-qualified) same
1204 object type (or a reference to it), to a (possibly cv-qualified) base
1205 class of that type (or a reference to it).... */
1206 else if (CLASS_TYPE_P (from
) && !related_p
1207 && !(flags
& LOOKUP_NO_CONVERSION
))
1211 If the initializer expression
1213 -- has a class type (i.e., T2 is a class type) can be
1214 implicitly converted to an lvalue of type "cv3 T3," where
1215 "cv1 T1" is reference-compatible with "cv3 T3". (this
1216 conversion is selected by enumerating the applicable
1217 conversion functions (_over.match.ref_) and choosing the
1218 best one through overload resolution. (_over.match_).
1220 the reference is bound to the lvalue result of the conversion
1221 in the second case. */
1222 conv
= convert_class_to_reference (rto
, from
, expr
);
1227 /* From this point on, we conceptually need temporaries, even if we
1228 elide them. Only the cases above are "direct bindings". */
1229 if (flags
& LOOKUP_NO_TEMP_BIND
)
1234 When a parameter of reference type is not bound directly to an
1235 argument expression, the conversion sequence is the one required
1236 to convert the argument expression to the underlying type of the
1237 reference according to _over.best.ics_. Conceptually, this
1238 conversion sequence corresponds to copy-initializing a temporary
1239 of the underlying type with the argument expression. Any
1240 difference in top-level cv-qualification is subsumed by the
1241 initialization itself and does not constitute a conversion. */
1245 Otherwise, the reference shall be to a non-volatile const type.
1247 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1248 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1253 Otherwise, a temporary of type "cv1 T1" is created and
1254 initialized from the initializer expression using the rules for a
1255 non-reference copy initialization. If T1 is reference-related to
1256 T2, cv1 must be the same cv-qualification as, or greater
1257 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1258 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1261 /* We're generating a temporary now, but don't bind any more in the
1262 conversion (specifically, don't slice the temporary returned by a
1263 conversion operator). */
1264 flags
|= LOOKUP_NO_TEMP_BIND
;
1266 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1271 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1272 /* This reference binding, unlike those above, requires the
1273 creation of a temporary. */
1274 conv
->need_temporary_p
= true;
1275 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1280 /* Returns the implicit conversion sequence (see [over.ics]) from type
1281 FROM to type TO. The optional expression EXPR may affect the
1282 conversion. FLAGS are the usual overloading flags. Only
1283 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1284 conversion is coming from a C-style cast. */
1287 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1292 if (from
== error_mark_node
|| to
== error_mark_node
1293 || expr
== error_mark_node
)
1296 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1297 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
);
1299 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
);
1304 if (expr
!= NULL_TREE
1305 && (IS_AGGR_TYPE (from
)
1306 || IS_AGGR_TYPE (to
))
1307 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1309 struct z_candidate
*cand
;
1310 int convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
)
1311 |LOOKUP_ONLYCONVERTING
);
1313 cand
= build_user_type_conversion_1 (to
, expr
, convflags
);
1315 conv
= cand
->second_conv
;
1317 /* We used to try to bind a reference to a temporary here, but that
1318 is now handled after the recursive call to this function at the end
1319 of reference_binding. */
1326 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1329 static struct z_candidate
*
1330 add_candidate (struct z_candidate
**candidates
,
1332 size_t num_convs
, conversion
**convs
,
1333 tree access_path
, tree conversion_path
,
1336 struct z_candidate
*cand
= (struct z_candidate
*)
1337 conversion_obstack_alloc (sizeof (struct z_candidate
));
1341 cand
->convs
= convs
;
1342 cand
->num_convs
= num_convs
;
1343 cand
->access_path
= access_path
;
1344 cand
->conversion_path
= conversion_path
;
1345 cand
->viable
= viable
;
1346 cand
->next
= *candidates
;
1352 /* Create an overload candidate for the function or method FN called with
1353 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1354 to implicit_conversion.
1356 CTYPE, if non-NULL, is the type we want to pretend this function
1357 comes from for purposes of overload resolution. */
1359 static struct z_candidate
*
1360 add_function_candidate (struct z_candidate
**candidates
,
1361 tree fn
, tree ctype
, tree arglist
,
1362 tree access_path
, tree conversion_path
,
1365 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1368 tree parmnode
, argnode
;
1372 /* At this point we should not see any functions which haven't been
1373 explicitly declared, except for friend functions which will have
1374 been found using argument dependent lookup. */
1375 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
1377 /* The `this', `in_chrg' and VTT arguments to constructors are not
1378 considered in overload resolution. */
1379 if (DECL_CONSTRUCTOR_P (fn
))
1381 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1382 orig_arglist
= arglist
;
1383 arglist
= skip_artificial_parms_for (fn
, arglist
);
1386 orig_arglist
= arglist
;
1388 len
= list_length (arglist
);
1389 convs
= alloc_conversions (len
);
1391 /* 13.3.2 - Viable functions [over.match.viable]
1392 First, to be a viable function, a candidate function shall have enough
1393 parameters to agree in number with the arguments in the list.
1395 We need to check this first; otherwise, checking the ICSes might cause
1396 us to produce an ill-formed template instantiation. */
1398 parmnode
= parmlist
;
1399 for (i
= 0; i
< len
; ++i
)
1401 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1403 parmnode
= TREE_CHAIN (parmnode
);
1406 if (i
< len
&& parmnode
)
1409 /* Make sure there are default args for the rest of the parms. */
1410 else if (!sufficient_parms_p (parmnode
))
1416 /* Second, for F to be a viable function, there shall exist for each
1417 argument an implicit conversion sequence that converts that argument
1418 to the corresponding parameter of F. */
1420 parmnode
= parmlist
;
1423 for (i
= 0; i
< len
; ++i
)
1425 tree arg
= TREE_VALUE (argnode
);
1426 tree argtype
= lvalue_type (arg
);
1430 if (parmnode
== void_list_node
)
1433 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1434 && ! DECL_CONSTRUCTOR_P (fn
));
1438 tree parmtype
= TREE_VALUE (parmnode
);
1440 /* The type of the implicit object parameter ('this') for
1441 overload resolution is not always the same as for the
1442 function itself; conversion functions are considered to
1443 be members of the class being converted, and functions
1444 introduced by a using-declaration are considered to be
1445 members of the class that uses them.
1447 Since build_over_call ignores the ICS for the `this'
1448 parameter, we can just change the parm type. */
1449 if (ctype
&& is_this
)
1452 = build_qualified_type (ctype
,
1453 TYPE_QUALS (TREE_TYPE (parmtype
)));
1454 parmtype
= build_pointer_type (parmtype
);
1457 t
= implicit_conversion (parmtype
, argtype
, arg
,
1458 /*c_cast_p=*/false, flags
);
1462 t
= build_identity_conv (argtype
, arg
);
1463 t
->ellipsis_p
= true;
1480 parmnode
= TREE_CHAIN (parmnode
);
1481 argnode
= TREE_CHAIN (argnode
);
1485 return add_candidate (candidates
, fn
, orig_arglist
, len
, convs
,
1486 access_path
, conversion_path
, viable
);
1489 /* Create an overload candidate for the conversion function FN which will
1490 be invoked for expression OBJ, producing a pointer-to-function which
1491 will in turn be called with the argument list ARGLIST, and add it to
1492 CANDIDATES. FLAGS is passed on to implicit_conversion.
1494 Actually, we don't really care about FN; we care about the type it
1495 converts to. There may be multiple conversion functions that will
1496 convert to that type, and we rely on build_user_type_conversion_1 to
1497 choose the best one; so when we create our candidate, we record the type
1498 instead of the function. */
1500 static struct z_candidate
*
1501 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
1502 tree arglist
, tree access_path
, tree conversion_path
)
1504 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
1505 int i
, len
, viable
, flags
;
1506 tree parmlist
, parmnode
, argnode
;
1509 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
1510 parmlist
= TREE_TYPE (parmlist
);
1511 parmlist
= TYPE_ARG_TYPES (parmlist
);
1513 len
= list_length (arglist
) + 1;
1514 convs
= alloc_conversions (len
);
1515 parmnode
= parmlist
;
1518 flags
= LOOKUP_NORMAL
;
1520 /* Don't bother looking up the same type twice. */
1521 if (*candidates
&& (*candidates
)->fn
== totype
)
1524 for (i
= 0; i
< len
; ++i
)
1526 tree arg
= i
== 0 ? obj
: TREE_VALUE (argnode
);
1527 tree argtype
= lvalue_type (arg
);
1531 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
1533 else if (parmnode
== void_list_node
)
1536 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
1537 /*c_cast_p=*/false, flags
);
1540 t
= build_identity_conv (argtype
, arg
);
1541 t
->ellipsis_p
= true;
1555 parmnode
= TREE_CHAIN (parmnode
);
1556 argnode
= TREE_CHAIN (argnode
);
1562 if (!sufficient_parms_p (parmnode
))
1565 return add_candidate (candidates
, totype
, arglist
, len
, convs
,
1566 access_path
, conversion_path
, viable
);
1570 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
1571 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
1583 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
1584 convs
= alloc_conversions (num_convs
);
1586 for (i
= 0; i
< 2; ++i
)
1591 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
1592 /*c_cast_p=*/false, flags
);
1596 /* We need something for printing the candidate. */
1597 t
= build_identity_conv (types
[i
], NULL_TREE
);
1604 /* For COND_EXPR we rearranged the arguments; undo that now. */
1607 convs
[2] = convs
[1];
1608 convs
[1] = convs
[0];
1609 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
1610 /*c_cast_p=*/false, flags
);
1617 add_candidate (candidates
, fnname
, /*args=*/NULL_TREE
,
1619 /*access_path=*/NULL_TREE
,
1620 /*conversion_path=*/NULL_TREE
,
1625 is_complete (tree t
)
1627 return COMPLETE_TYPE_P (complete_type (t
));
1630 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1633 promoted_arithmetic_type_p (tree type
)
1637 In this section, the term promoted integral type is used to refer
1638 to those integral types which are preserved by integral promotion
1639 (including e.g. int and long but excluding e.g. char).
1640 Similarly, the term promoted arithmetic type refers to promoted
1641 integral types plus floating types. */
1642 return ((INTEGRAL_TYPE_P (type
)
1643 && same_type_p (type_promotes_to (type
), type
))
1644 || TREE_CODE (type
) == REAL_TYPE
);
1647 /* Create any builtin operator overload candidates for the operator in
1648 question given the converted operand types TYPE1 and TYPE2. The other
1649 args are passed through from add_builtin_candidates to
1650 build_builtin_candidate.
1652 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1653 If CODE is requires candidates operands of the same type of the kind
1654 of which TYPE1 and TYPE2 are, we add both candidates
1655 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1658 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
1659 enum tree_code code2
, tree fnname
, tree type1
,
1660 tree type2
, tree
*args
, tree
*argtypes
, int flags
)
1664 case POSTINCREMENT_EXPR
:
1665 case POSTDECREMENT_EXPR
:
1666 args
[1] = integer_zero_node
;
1667 type2
= integer_type_node
;
1676 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1677 and VQ is either volatile or empty, there exist candidate operator
1678 functions of the form
1679 VQ T& operator++(VQ T&);
1680 T operator++(VQ T&, int);
1681 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1682 type other than bool, and VQ is either volatile or empty, there exist
1683 candidate operator functions of the form
1684 VQ T& operator--(VQ T&);
1685 T operator--(VQ T&, int);
1686 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1687 complete object type, and VQ is either volatile or empty, there exist
1688 candidate operator functions of the form
1689 T*VQ& operator++(T*VQ&);
1690 T*VQ& operator--(T*VQ&);
1691 T* operator++(T*VQ&, int);
1692 T* operator--(T*VQ&, int); */
1694 case POSTDECREMENT_EXPR
:
1695 case PREDECREMENT_EXPR
:
1696 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
1698 case POSTINCREMENT_EXPR
:
1699 case PREINCREMENT_EXPR
:
1700 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
1702 type1
= build_reference_type (type1
);
1707 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1708 exist candidate operator functions of the form
1712 8 For every function type T, there exist candidate operator functions of
1714 T& operator*(T*); */
1717 if (TREE_CODE (type1
) == POINTER_TYPE
1718 && (TYPE_PTROB_P (type1
)
1719 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
1723 /* 9 For every type T, there exist candidate operator functions of the form
1726 10For every promoted arithmetic type T, there exist candidate operator
1727 functions of the form
1731 case UNARY_PLUS_EXPR
: /* unary + */
1732 if (TREE_CODE (type1
) == POINTER_TYPE
)
1735 if (ARITHMETIC_TYPE_P (type1
))
1739 /* 11For every promoted integral type T, there exist candidate operator
1740 functions of the form
1744 if (INTEGRAL_TYPE_P (type1
))
1748 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1749 is the same type as C2 or is a derived class of C2, T is a complete
1750 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1751 there exist candidate operator functions of the form
1752 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1753 where CV12 is the union of CV1 and CV2. */
1756 if (TREE_CODE (type1
) == POINTER_TYPE
1757 && TYPE_PTR_TO_MEMBER_P (type2
))
1759 tree c1
= TREE_TYPE (type1
);
1760 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
1762 if (IS_AGGR_TYPE (c1
) && DERIVED_FROM_P (c2
, c1
)
1763 && (TYPE_PTRMEMFUNC_P (type2
)
1764 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
1769 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1770 didate operator functions of the form
1775 bool operator<(L, R);
1776 bool operator>(L, R);
1777 bool operator<=(L, R);
1778 bool operator>=(L, R);
1779 bool operator==(L, R);
1780 bool operator!=(L, R);
1781 where LR is the result of the usual arithmetic conversions between
1784 14For every pair of types T and I, where T is a cv-qualified or cv-
1785 unqualified complete object type and I is a promoted integral type,
1786 there exist candidate operator functions of the form
1787 T* operator+(T*, I);
1788 T& operator[](T*, I);
1789 T* operator-(T*, I);
1790 T* operator+(I, T*);
1791 T& operator[](I, T*);
1793 15For every T, where T is a pointer to complete object type, there exist
1794 candidate operator functions of the form112)
1795 ptrdiff_t operator-(T, T);
1797 16For every pointer or enumeration type T, there exist candidate operator
1798 functions of the form
1799 bool operator<(T, T);
1800 bool operator>(T, T);
1801 bool operator<=(T, T);
1802 bool operator>=(T, T);
1803 bool operator==(T, T);
1804 bool operator!=(T, T);
1806 17For every pointer to member type T, there exist candidate operator
1807 functions of the form
1808 bool operator==(T, T);
1809 bool operator!=(T, T); */
1812 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
1814 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1816 type2
= ptrdiff_type_node
;
1820 case TRUNC_DIV_EXPR
:
1821 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1827 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
1828 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
)))
1830 if (TYPE_PTR_TO_MEMBER_P (type1
) && null_ptr_cst_p (args
[1]))
1835 if (TYPE_PTR_TO_MEMBER_P (type2
) && null_ptr_cst_p (args
[0]))
1847 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1849 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1851 if (TREE_CODE (type1
) == ENUMERAL_TYPE
1852 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
1854 if (TYPE_PTR_P (type1
)
1855 && null_ptr_cst_p (args
[1])
1856 && !uses_template_parms (type1
))
1861 if (null_ptr_cst_p (args
[0])
1862 && TYPE_PTR_P (type2
)
1863 && !uses_template_parms (type2
))
1871 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1874 if (INTEGRAL_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
1876 type1
= ptrdiff_type_node
;
1879 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1881 type2
= ptrdiff_type_node
;
1886 /* 18For every pair of promoted integral types L and R, there exist candi-
1887 date operator functions of the form
1894 where LR is the result of the usual arithmetic conversions between
1897 case TRUNC_MOD_EXPR
:
1903 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
1907 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1908 type, VQ is either volatile or empty, and R is a promoted arithmetic
1909 type, there exist candidate operator functions of the form
1910 VQ L& operator=(VQ L&, R);
1911 VQ L& operator*=(VQ L&, R);
1912 VQ L& operator/=(VQ L&, R);
1913 VQ L& operator+=(VQ L&, R);
1914 VQ L& operator-=(VQ L&, R);
1916 20For every pair T, VQ), where T is any type and VQ is either volatile
1917 or empty, there exist candidate operator functions of the form
1918 T*VQ& operator=(T*VQ&, T*);
1920 21For every pair T, VQ), where T is a pointer to member type and VQ is
1921 either volatile or empty, there exist candidate operator functions of
1923 VQ T& operator=(VQ T&, T);
1925 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1926 unqualified complete object type, VQ is either volatile or empty, and
1927 I is a promoted integral type, there exist candidate operator func-
1929 T*VQ& operator+=(T*VQ&, I);
1930 T*VQ& operator-=(T*VQ&, I);
1932 23For every triple L, VQ, R), where L is an integral or enumeration
1933 type, VQ is either volatile or empty, and R is a promoted integral
1934 type, there exist candidate operator functions of the form
1936 VQ L& operator%=(VQ L&, R);
1937 VQ L& operator<<=(VQ L&, R);
1938 VQ L& operator>>=(VQ L&, R);
1939 VQ L& operator&=(VQ L&, R);
1940 VQ L& operator^=(VQ L&, R);
1941 VQ L& operator|=(VQ L&, R); */
1948 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1950 type2
= ptrdiff_type_node
;
1954 case TRUNC_DIV_EXPR
:
1955 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1959 case TRUNC_MOD_EXPR
:
1965 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
1970 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1972 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
1973 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1974 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
1975 || ((TYPE_PTRMEMFUNC_P (type1
)
1976 || TREE_CODE (type1
) == POINTER_TYPE
)
1977 && null_ptr_cst_p (args
[1])))
1987 type1
= build_reference_type (type1
);
1993 For every pair of promoted arithmetic types L and R, there
1994 exist candidate operator functions of the form
1996 LR operator?(bool, L, R);
1998 where LR is the result of the usual arithmetic conversions
1999 between types L and R.
2001 For every type T, where T is a pointer or pointer-to-member
2002 type, there exist candidate operator functions of the form T
2003 operator?(bool, T, T); */
2005 if (promoted_arithmetic_type_p (type1
)
2006 && promoted_arithmetic_type_p (type2
))
2010 /* Otherwise, the types should be pointers. */
2011 if (!(TYPE_PTR_P (type1
) || TYPE_PTR_TO_MEMBER_P (type1
))
2012 || !(TYPE_PTR_P (type2
) || TYPE_PTR_TO_MEMBER_P (type2
)))
2015 /* We don't check that the two types are the same; the logic
2016 below will actually create two candidates; one in which both
2017 parameter types are TYPE1, and one in which both parameter
2025 /* If we're dealing with two pointer types or two enumeral types,
2026 we need candidates for both of them. */
2027 if (type2
&& !same_type_p (type1
, type2
)
2028 && TREE_CODE (type1
) == TREE_CODE (type2
)
2029 && (TREE_CODE (type1
) == REFERENCE_TYPE
2030 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2031 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
2032 || TYPE_PTRMEMFUNC_P (type1
)
2033 || IS_AGGR_TYPE (type1
)
2034 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2036 build_builtin_candidate
2037 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
);
2038 build_builtin_candidate
2039 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
);
2043 build_builtin_candidate
2044 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
);
2048 type_decays_to (tree type
)
2050 if (TREE_CODE (type
) == ARRAY_TYPE
)
2051 return build_pointer_type (TREE_TYPE (type
));
2052 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2053 return build_pointer_type (type
);
2057 /* There are three conditions of builtin candidates:
2059 1) bool-taking candidates. These are the same regardless of the input.
2060 2) pointer-pair taking candidates. These are generated for each type
2061 one of the input types converts to.
2062 3) arithmetic candidates. According to the standard, we should generate
2063 all of these, but I'm trying not to...
2065 Here we generate a superset of the possible candidates for this particular
2066 case. That is a subset of the full set the standard defines, plus some
2067 other cases which the standard disallows. add_builtin_candidate will
2068 filter out the invalid set. */
2071 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2072 enum tree_code code2
, tree fnname
, tree
*args
,
2077 tree type
, argtypes
[3];
2078 /* TYPES[i] is the set of possible builtin-operator parameter types
2079 we will consider for the Ith argument. These are represented as
2080 a TREE_LIST; the TREE_VALUE of each node is the potential
2084 for (i
= 0; i
< 3; ++i
)
2087 argtypes
[i
] = lvalue_type (args
[i
]);
2089 argtypes
[i
] = NULL_TREE
;
2094 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2095 and VQ is either volatile or empty, there exist candidate operator
2096 functions of the form
2097 VQ T& operator++(VQ T&); */
2099 case POSTINCREMENT_EXPR
:
2100 case PREINCREMENT_EXPR
:
2101 case POSTDECREMENT_EXPR
:
2102 case PREDECREMENT_EXPR
:
2107 /* 24There also exist candidate operator functions of the form
2108 bool operator!(bool);
2109 bool operator&&(bool, bool);
2110 bool operator||(bool, bool); */
2112 case TRUTH_NOT_EXPR
:
2113 build_builtin_candidate
2114 (candidates
, fnname
, boolean_type_node
,
2115 NULL_TREE
, args
, argtypes
, flags
);
2118 case TRUTH_ORIF_EXPR
:
2119 case TRUTH_ANDIF_EXPR
:
2120 build_builtin_candidate
2121 (candidates
, fnname
, boolean_type_node
,
2122 boolean_type_node
, args
, argtypes
, flags
);
2144 types
[0] = types
[1] = NULL_TREE
;
2146 for (i
= 0; i
< 2; ++i
)
2150 else if (IS_AGGR_TYPE (argtypes
[i
]))
2154 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2157 convs
= lookup_conversions (argtypes
[i
]);
2159 if (code
== COND_EXPR
)
2161 if (real_lvalue_p (args
[i
]))
2162 types
[i
] = tree_cons
2163 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
2165 types
[i
] = tree_cons
2166 (NULL_TREE
, TYPE_MAIN_VARIANT (argtypes
[i
]), types
[i
]);
2172 for (; convs
; convs
= TREE_CHAIN (convs
))
2174 type
= TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs
))));
2177 && (TREE_CODE (type
) != REFERENCE_TYPE
2178 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2181 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2182 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2184 type
= non_reference (type
);
2185 if (i
!= 0 || ! ref1
)
2187 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
2188 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2189 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2190 if (INTEGRAL_TYPE_P (type
))
2191 type
= type_promotes_to (type
);
2194 if (! value_member (type
, types
[i
]))
2195 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2200 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2201 types
[i
] = tree_cons
2202 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
2203 type
= non_reference (argtypes
[i
]);
2204 if (i
!= 0 || ! ref1
)
2206 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
2207 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2208 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2209 if (INTEGRAL_TYPE_P (type
))
2210 type
= type_promotes_to (type
);
2212 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2216 /* Run through the possible parameter types of both arguments,
2217 creating candidates with those parameter types. */
2218 for (; types
[0]; types
[0] = TREE_CHAIN (types
[0]))
2221 for (type
= types
[1]; type
; type
= TREE_CHAIN (type
))
2222 add_builtin_candidate
2223 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
2224 TREE_VALUE (type
), args
, argtypes
, flags
);
2226 add_builtin_candidate
2227 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
2228 NULL_TREE
, args
, argtypes
, flags
);
2233 /* If TMPL can be successfully instantiated as indicated by
2234 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2236 TMPL is the template. EXPLICIT_TARGS are any explicit template
2237 arguments. ARGLIST is the arguments provided at the call-site.
2238 The RETURN_TYPE is the desired type for conversion operators. If
2239 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2240 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2241 add_conv_candidate. */
2243 static struct z_candidate
*
2244 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
2245 tree ctype
, tree explicit_targs
, tree arglist
,
2246 tree return_type
, tree access_path
,
2247 tree conversion_path
, int flags
, tree obj
,
2248 unification_kind_t strict
)
2250 int ntparms
= DECL_NTPARMS (tmpl
);
2251 tree targs
= make_tree_vec (ntparms
);
2252 tree args_without_in_chrg
= arglist
;
2253 struct z_candidate
*cand
;
2257 /* We don't do deduction on the in-charge parameter, the VTT
2258 parameter or 'this'. */
2259 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
2260 args_without_in_chrg
= TREE_CHAIN (args_without_in_chrg
);
2262 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
2263 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
2264 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
2265 args_without_in_chrg
= TREE_CHAIN (args_without_in_chrg
);
2267 i
= fn_type_unification (tmpl
, explicit_targs
, targs
,
2268 args_without_in_chrg
,
2269 return_type
, strict
, flags
);
2274 fn
= instantiate_template (tmpl
, targs
, tf_none
);
2275 if (fn
== error_mark_node
)
2280 A member function template is never instantiated to perform the
2281 copy of a class object to an object of its class type.
2283 It's a little unclear what this means; the standard explicitly
2284 does allow a template to be used to copy a class. For example,
2289 template <class T> A(const T&);
2292 void g () { A a (f ()); }
2294 the member template will be used to make the copy. The section
2295 quoted above appears in the paragraph that forbids constructors
2296 whose only parameter is (a possibly cv-qualified variant of) the
2297 class type, and a logical interpretation is that the intent was
2298 to forbid the instantiation of member templates which would then
2300 if (DECL_CONSTRUCTOR_P (fn
) && list_length (arglist
) == 2)
2302 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
2303 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
2308 if (obj
!= NULL_TREE
)
2309 /* Aha, this is a conversion function. */
2310 cand
= add_conv_candidate (candidates
, fn
, obj
, access_path
,
2311 conversion_path
, arglist
);
2313 cand
= add_function_candidate (candidates
, fn
, ctype
,
2314 arglist
, access_path
,
2315 conversion_path
, flags
);
2316 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
2317 /* This situation can occur if a member template of a template
2318 class is specialized. Then, instantiate_template might return
2319 an instantiation of the specialization, in which case the
2320 DECL_TI_TEMPLATE field will point at the original
2321 specialization. For example:
2323 template <class T> struct S { template <class U> void f(U);
2324 template <> void f(int) {}; };
2328 Here, TMPL will be template <class U> S<double>::f(U).
2329 And, instantiate template will give us the specialization
2330 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2331 for this will point at template <class T> template <> S<T>::f(int),
2332 so that we can find the definition. For the purposes of
2333 overload resolution, however, we want the original TMPL. */
2334 cand
->template_decl
= tree_cons (tmpl
, targs
, NULL_TREE
);
2336 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
2342 static struct z_candidate
*
2343 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
2344 tree explicit_targs
, tree arglist
, tree return_type
,
2345 tree access_path
, tree conversion_path
, int flags
,
2346 unification_kind_t strict
)
2349 add_template_candidate_real (candidates
, tmpl
, ctype
,
2350 explicit_targs
, arglist
, return_type
,
2351 access_path
, conversion_path
,
2352 flags
, NULL_TREE
, strict
);
2356 static struct z_candidate
*
2357 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
2358 tree obj
, tree arglist
, tree return_type
,
2359 tree access_path
, tree conversion_path
)
2362 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
2363 arglist
, return_type
, access_path
,
2364 conversion_path
, 0, obj
, DEDUCE_CONV
);
2367 /* The CANDS are the set of candidates that were considered for
2368 overload resolution. Return the set of viable candidates. If none
2369 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2370 is true if a candidate should be considered viable only if it is
2373 static struct z_candidate
*
2374 splice_viable (struct z_candidate
*cands
,
2378 struct z_candidate
*viable
;
2379 struct z_candidate
**last_viable
;
2380 struct z_candidate
**cand
;
2383 last_viable
= &viable
;
2384 *any_viable_p
= false;
2389 struct z_candidate
*c
= *cand
;
2390 if (strict_p
? c
->viable
== 1 : c
->viable
)
2395 last_viable
= &c
->next
;
2396 *any_viable_p
= true;
2402 return viable
? viable
: cands
;
2406 any_strictly_viable (struct z_candidate
*cands
)
2408 for (; cands
; cands
= cands
->next
)
2409 if (cands
->viable
== 1)
2414 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2415 words, it is about to become the "this" pointer for a member
2416 function call. Take the address of the object. */
2419 build_this (tree obj
)
2421 /* In a template, we are only concerned about the type of the
2422 expression, so we can take a shortcut. */
2423 if (processing_template_decl
)
2424 return build_address (obj
);
2426 return build_unary_op (ADDR_EXPR
, obj
, 0);
2429 /* Returns true iff functions are equivalent. Equivalent functions are
2430 not '==' only if one is a function-local extern function or if
2431 both are extern "C". */
2434 equal_functions (tree fn1
, tree fn2
)
2436 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
2437 || DECL_EXTERN_C_FUNCTION_P (fn1
))
2438 return decls_match (fn1
, fn2
);
2442 /* Print information about one overload candidate CANDIDATE. MSGSTR
2443 is the text to print before the candidate itself.
2445 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2446 to have been run through gettext by the caller. This wart makes
2447 life simpler in print_z_candidates and for the translators. */
2450 print_z_candidate (const char *msgstr
, struct z_candidate
*candidate
)
2452 if (TREE_CODE (candidate
->fn
) == IDENTIFIER_NODE
)
2454 if (candidate
->num_convs
== 3)
2455 inform ("%s %D(%T, %T, %T) <built-in>", msgstr
, candidate
->fn
,
2456 candidate
->convs
[0]->type
,
2457 candidate
->convs
[1]->type
,
2458 candidate
->convs
[2]->type
);
2459 else if (candidate
->num_convs
== 2)
2460 inform ("%s %D(%T, %T) <built-in>", msgstr
, candidate
->fn
,
2461 candidate
->convs
[0]->type
,
2462 candidate
->convs
[1]->type
);
2464 inform ("%s %D(%T) <built-in>", msgstr
, candidate
->fn
,
2465 candidate
->convs
[0]->type
);
2467 else if (TYPE_P (candidate
->fn
))
2468 inform ("%s %T <conversion>", msgstr
, candidate
->fn
);
2469 else if (candidate
->viable
== -1)
2470 inform ("%s %+#D <near match>", msgstr
, candidate
->fn
);
2472 inform ("%s %+#D", msgstr
, candidate
->fn
);
2476 print_z_candidates (struct z_candidate
*candidates
)
2479 struct z_candidate
*cand1
;
2480 struct z_candidate
**cand2
;
2482 /* There may be duplicates in the set of candidates. We put off
2483 checking this condition as long as possible, since we have no way
2484 to eliminate duplicates from a set of functions in less than n^2
2485 time. Now we are about to emit an error message, so it is more
2486 permissible to go slowly. */
2487 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
2489 tree fn
= cand1
->fn
;
2490 /* Skip builtin candidates and conversion functions. */
2491 if (TREE_CODE (fn
) != FUNCTION_DECL
)
2493 cand2
= &cand1
->next
;
2496 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
2497 && equal_functions (fn
, (*cand2
)->fn
))
2498 *cand2
= (*cand2
)->next
;
2500 cand2
= &(*cand2
)->next
;
2507 str
= _("candidates are:");
2508 print_z_candidate (str
, candidates
);
2509 if (candidates
->next
)
2511 /* Indent successive candidates by the width of the translation
2512 of the above string. */
2513 size_t len
= gcc_gettext_width (str
) + 1;
2514 char *spaces
= (char *) alloca (len
);
2515 memset (spaces
, ' ', len
-1);
2516 spaces
[len
- 1] = '\0';
2518 candidates
= candidates
->next
;
2521 print_z_candidate (spaces
, candidates
);
2522 candidates
= candidates
->next
;
2528 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2529 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2530 the result of the conversion function to convert it to the final
2531 desired type. Merge the two sequences into a single sequence,
2532 and return the merged sequence. */
2535 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
2539 gcc_assert (user_seq
->kind
== ck_user
);
2541 /* Find the end of the second conversion sequence. */
2543 while ((*t
)->kind
!= ck_identity
)
2544 t
= &((*t
)->u
.next
);
2546 /* Replace the identity conversion with the user conversion
2550 /* The entire sequence is a user-conversion sequence. */
2551 std_seq
->user_conv_p
= true;
2556 /* Returns the best overload candidate to perform the requested
2557 conversion. This function is used for three the overloading situations
2558 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2559 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2560 per [dcl.init.ref], so we ignore temporary bindings. */
2562 static struct z_candidate
*
2563 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
)
2565 struct z_candidate
*candidates
, *cand
;
2566 tree fromtype
= TREE_TYPE (expr
);
2567 tree ctors
= NULL_TREE
;
2568 tree conv_fns
= NULL_TREE
;
2569 conversion
*conv
= NULL
;
2570 tree args
= NULL_TREE
;
2574 /* We represent conversion within a hierarchy using RVALUE_CONV and
2575 BASE_CONV, as specified by [over.best.ics]; these become plain
2576 constructor calls, as specified in [dcl.init]. */
2577 gcc_assert (!IS_AGGR_TYPE (fromtype
) || !IS_AGGR_TYPE (totype
)
2578 || !DERIVED_FROM_P (totype
, fromtype
));
2580 if (IS_AGGR_TYPE (totype
))
2581 ctors
= lookup_fnfields (totype
, complete_ctor_identifier
, 0);
2583 if (IS_AGGR_TYPE (fromtype
))
2585 tree to_nonref
= non_reference (totype
);
2586 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
2587 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
2588 && DERIVED_FROM_P (to_nonref
, fromtype
)))
2590 /* [class.conv.fct] A conversion function is never used to
2591 convert a (possibly cv-qualified) object to the (possibly
2592 cv-qualified) same object type (or a reference to it), to a
2593 (possibly cv-qualified) base class of that type (or a
2594 reference to it)... */
2597 conv_fns
= lookup_conversions (fromtype
);
2601 flags
|= LOOKUP_NO_CONVERSION
;
2603 /* It's OK to bind a temporary for converting constructor arguments, but
2604 not in converting the return value of a conversion operator. */
2605 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
);
2606 flags
&= ~LOOKUP_NO_TEMP_BIND
;
2612 ctors
= BASELINK_FUNCTIONS (ctors
);
2614 t
= build_int_cst (build_pointer_type (totype
), 0);
2615 args
= build_tree_list (NULL_TREE
, expr
);
2616 /* We should never try to call the abstract or base constructor
2618 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
2619 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
2620 args
= tree_cons (NULL_TREE
, t
, args
);
2622 for (; ctors
; ctors
= OVL_NEXT (ctors
))
2624 tree ctor
= OVL_CURRENT (ctors
);
2625 if (DECL_NONCONVERTING_P (ctor
))
2628 if (TREE_CODE (ctor
) == TEMPLATE_DECL
)
2629 cand
= add_template_candidate (&candidates
, ctor
, totype
,
2630 NULL_TREE
, args
, NULL_TREE
,
2631 TYPE_BINFO (totype
),
2632 TYPE_BINFO (totype
),
2636 cand
= add_function_candidate (&candidates
, ctor
, totype
,
2637 args
, TYPE_BINFO (totype
),
2638 TYPE_BINFO (totype
),
2642 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
2646 args
= build_tree_list (NULL_TREE
, build_this (expr
));
2648 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
2651 tree conversion_path
= TREE_PURPOSE (conv_fns
);
2653 /* If we are called to convert to a reference type, we are trying to
2654 find an lvalue binding, so don't even consider temporaries. If
2655 we don't find an lvalue binding, the caller will try again to
2656 look for a temporary binding. */
2657 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
2658 convflags
|= LOOKUP_NO_TEMP_BIND
;
2660 for (fns
= TREE_VALUE (conv_fns
); fns
; fns
= OVL_NEXT (fns
))
2662 tree fn
= OVL_CURRENT (fns
);
2664 /* [over.match.funcs] For conversion functions, the function
2665 is considered to be a member of the class of the implicit
2666 object argument for the purpose of defining the type of
2667 the implicit object parameter.
2669 So we pass fromtype as CTYPE to add_*_candidate. */
2671 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2672 cand
= add_template_candidate (&candidates
, fn
, fromtype
,
2675 TYPE_BINFO (fromtype
),
2680 cand
= add_function_candidate (&candidates
, fn
, fromtype
,
2682 TYPE_BINFO (fromtype
),
2689 = implicit_conversion (totype
,
2690 TREE_TYPE (TREE_TYPE (cand
->fn
)),
2692 /*c_cast_p=*/false, convflags
);
2694 cand
->second_conv
= ics
;
2698 else if (candidates
->viable
== 1 && ics
->bad_p
)
2704 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
2708 cand
= tourney (candidates
);
2711 if (flags
& LOOKUP_COMPLAIN
)
2713 error ("conversion from %qT to %qT is ambiguous",
2715 print_z_candidates (candidates
);
2718 cand
= candidates
; /* any one will do */
2719 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
2720 cand
->second_conv
->user_conv_p
= true;
2721 if (!any_strictly_viable (candidates
))
2722 cand
->second_conv
->bad_p
= true;
2723 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2724 ambiguous conversion is no worse than another user-defined
2730 /* Build the user conversion sequence. */
2733 (DECL_CONSTRUCTOR_P (cand
->fn
)
2734 ? totype
: non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)))),
2735 build_identity_conv (TREE_TYPE (expr
), expr
));
2738 /* Combine it with the second conversion sequence. */
2739 cand
->second_conv
= merge_conversion_sequences (conv
,
2742 if (cand
->viable
== -1)
2743 cand
->second_conv
->bad_p
= true;
2749 build_user_type_conversion (tree totype
, tree expr
, int flags
)
2751 struct z_candidate
*cand
2752 = build_user_type_conversion_1 (totype
, expr
, flags
);
2756 if (cand
->second_conv
->kind
== ck_ambig
)
2757 return error_mark_node
;
2758 expr
= convert_like (cand
->second_conv
, expr
);
2759 return convert_from_reference (expr
);
2764 /* Do any initial processing on the arguments to a function call. */
2767 resolve_args (tree args
)
2770 for (t
= args
; t
; t
= TREE_CHAIN (t
))
2772 tree arg
= TREE_VALUE (t
);
2774 if (error_operand_p (arg
))
2775 return error_mark_node
;
2776 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
2778 error ("invalid use of void expression");
2779 return error_mark_node
;
2781 else if (invalid_nonstatic_memfn_p (arg
))
2782 return error_mark_node
;
2787 /* Perform overload resolution on FN, which is called with the ARGS.
2789 Return the candidate function selected by overload resolution, or
2790 NULL if the event that overload resolution failed. In the case
2791 that overload resolution fails, *CANDIDATES will be the set of
2792 candidates considered, and ANY_VIABLE_P will be set to true or
2793 false to indicate whether or not any of the candidates were
2796 The ARGS should already have gone through RESOLVE_ARGS before this
2797 function is called. */
2799 static struct z_candidate
*
2800 perform_overload_resolution (tree fn
,
2802 struct z_candidate
**candidates
,
2805 struct z_candidate
*cand
;
2806 tree explicit_targs
= NULL_TREE
;
2807 int template_only
= 0;
2810 *any_viable_p
= true;
2812 /* Check FN and ARGS. */
2813 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
2814 || TREE_CODE (fn
) == TEMPLATE_DECL
2815 || TREE_CODE (fn
) == OVERLOAD
2816 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
2817 gcc_assert (!args
|| TREE_CODE (args
) == TREE_LIST
);
2819 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2821 explicit_targs
= TREE_OPERAND (fn
, 1);
2822 fn
= TREE_OPERAND (fn
, 0);
2826 /* Add the various candidate functions. */
2827 add_candidates (fn
, args
, explicit_targs
, template_only
,
2828 /*conversion_path=*/NULL_TREE
,
2829 /*access_path=*/NULL_TREE
,
2833 *candidates
= splice_viable (*candidates
, pedantic
, any_viable_p
);
2837 cand
= tourney (*candidates
);
2841 /* Return an expression for a call to FN (a namespace-scope function,
2842 or a static member function) with the ARGS. */
2845 build_new_function_call (tree fn
, tree args
, bool koenig_p
)
2847 struct z_candidate
*candidates
, *cand
;
2852 args
= resolve_args (args
);
2853 if (args
== error_mark_node
)
2854 return error_mark_node
;
2856 /* If this function was found without using argument dependent
2857 lookup, then we want to ignore any undeclared friend
2863 fn
= remove_hidden_names (fn
);
2866 error ("no matching function for call to %<%D(%A)%>",
2867 DECL_NAME (OVL_CURRENT (orig_fn
)), args
);
2868 return error_mark_node
;
2872 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2873 p
= conversion_obstack_alloc (0);
2875 cand
= perform_overload_resolution (fn
, args
, &candidates
, &any_viable_p
);
2879 if (!any_viable_p
&& candidates
&& ! candidates
->next
)
2880 return build_function_call (candidates
->fn
, args
);
2881 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2882 fn
= TREE_OPERAND (fn
, 0);
2884 error ("no matching function for call to %<%D(%A)%>",
2885 DECL_NAME (OVL_CURRENT (fn
)), args
);
2887 error ("call of overloaded %<%D(%A)%> is ambiguous",
2888 DECL_NAME (OVL_CURRENT (fn
)), args
);
2890 print_z_candidates (candidates
);
2891 result
= error_mark_node
;
2894 result
= build_over_call (cand
, LOOKUP_NORMAL
);
2896 /* Free all the conversions we allocated. */
2897 obstack_free (&conversion_obstack
, p
);
2902 /* Build a call to a global operator new. FNNAME is the name of the
2903 operator (either "operator new" or "operator new[]") and ARGS are
2904 the arguments provided. *SIZE points to the total number of bytes
2905 required by the allocation, and is updated if that is changed here.
2906 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2907 function determines that no cookie should be used, after all,
2908 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2909 set, upon return, to the allocation function called. */
2912 build_operator_new_call (tree fnname
, tree args
,
2913 tree
*size
, tree
*cookie_size
,
2917 struct z_candidate
*candidates
;
2918 struct z_candidate
*cand
;
2923 args
= tree_cons (NULL_TREE
, *size
, args
);
2924 args
= resolve_args (args
);
2925 if (args
== error_mark_node
)
2932 If this lookup fails to find the name, or if the allocated type
2933 is not a class type, the allocation function's name is looked
2934 up in the global scope.
2936 we disregard block-scope declarations of "operator new". */
2937 fns
= lookup_function_nonclass (fnname
, args
, /*block_p=*/false);
2939 /* Figure out what function is being called. */
2940 cand
= perform_overload_resolution (fns
, args
, &candidates
, &any_viable_p
);
2942 /* If no suitable function could be found, issue an error message
2947 error ("no matching function for call to %<%D(%A)%>",
2948 DECL_NAME (OVL_CURRENT (fns
)), args
);
2950 error ("call of overloaded %<%D(%A)%> is ambiguous",
2951 DECL_NAME (OVL_CURRENT (fns
)), args
);
2953 print_z_candidates (candidates
);
2954 return error_mark_node
;
2957 /* If a cookie is required, add some extra space. Whether
2958 or not a cookie is required cannot be determined until
2959 after we know which function was called. */
2962 bool use_cookie
= true;
2963 if (!abi_version_at_least (2))
2965 tree placement
= TREE_CHAIN (args
);
2966 /* In G++ 3.2, the check was implemented incorrectly; it
2967 looked at the placement expression, rather than the
2968 type of the function. */
2969 if (placement
&& !TREE_CHAIN (placement
)
2970 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2978 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
2979 /* Skip the size_t parameter. */
2980 arg_types
= TREE_CHAIN (arg_types
);
2981 /* Check the remaining parameters (if any). */
2983 && TREE_CHAIN (arg_types
) == void_list_node
2984 && same_type_p (TREE_VALUE (arg_types
),
2988 /* If we need a cookie, adjust the number of bytes allocated. */
2991 /* Update the total size. */
2992 *size
= size_binop (PLUS_EXPR
, *size
, *cookie_size
);
2993 /* Update the argument list to reflect the adjusted size. */
2994 TREE_VALUE (args
) = *size
;
2997 *cookie_size
= NULL_TREE
;
3000 /* Tell our caller which function we decided to call. */
3004 /* Build the CALL_EXPR. */
3005 return build_over_call (cand
, LOOKUP_NORMAL
);
3009 build_object_call (tree obj
, tree args
)
3011 struct z_candidate
*candidates
= 0, *cand
;
3012 tree fns
, convs
, mem_args
= NULL_TREE
;
3013 tree type
= TREE_TYPE (obj
);
3015 tree result
= NULL_TREE
;
3018 if (TYPE_PTRMEMFUNC_P (type
))
3020 /* It's no good looking for an overloaded operator() on a
3021 pointer-to-member-function. */
3022 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
3023 return error_mark_node
;
3026 if (TYPE_BINFO (type
))
3028 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
3029 if (fns
== error_mark_node
)
3030 return error_mark_node
;
3035 args
= resolve_args (args
);
3037 if (args
== error_mark_node
)
3038 return error_mark_node
;
3040 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3041 p
= conversion_obstack_alloc (0);
3045 tree base
= BINFO_TYPE (BASELINK_BINFO (fns
));
3046 mem_args
= tree_cons (NULL_TREE
, build_this (obj
), args
);
3048 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
3050 tree fn
= OVL_CURRENT (fns
);
3051 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
3052 add_template_candidate (&candidates
, fn
, base
, NULL_TREE
,
3053 mem_args
, NULL_TREE
,
3056 LOOKUP_NORMAL
, DEDUCE_CALL
);
3058 add_function_candidate
3059 (&candidates
, fn
, base
, mem_args
, TYPE_BINFO (type
),
3060 TYPE_BINFO (type
), LOOKUP_NORMAL
);
3064 convs
= lookup_conversions (type
);
3066 for (; convs
; convs
= TREE_CHAIN (convs
))
3068 tree fns
= TREE_VALUE (convs
);
3069 tree totype
= TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns
)));
3071 if ((TREE_CODE (totype
) == POINTER_TYPE
3072 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
3073 || (TREE_CODE (totype
) == REFERENCE_TYPE
3074 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
3075 || (TREE_CODE (totype
) == REFERENCE_TYPE
3076 && TREE_CODE (TREE_TYPE (totype
)) == POINTER_TYPE
3077 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype
))) == FUNCTION_TYPE
))
3078 for (; fns
; fns
= OVL_NEXT (fns
))
3080 tree fn
= OVL_CURRENT (fns
);
3081 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
3082 add_template_conv_candidate
3083 (&candidates
, fn
, obj
, args
, totype
,
3084 /*access_path=*/NULL_TREE
,
3085 /*conversion_path=*/NULL_TREE
);
3087 add_conv_candidate (&candidates
, fn
, obj
, args
,
3088 /*conversion_path=*/NULL_TREE
,
3089 /*access_path=*/NULL_TREE
);
3093 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
3096 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
), args
);
3097 print_z_candidates (candidates
);
3098 result
= error_mark_node
;
3102 cand
= tourney (candidates
);
3105 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj
), args
);
3106 print_z_candidates (candidates
);
3107 result
= error_mark_node
;
3109 /* Since cand->fn will be a type, not a function, for a conversion
3110 function, we must be careful not to unconditionally look at
3112 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
3113 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
3114 result
= build_over_call (cand
, LOOKUP_NORMAL
);
3117 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
, -1);
3118 obj
= convert_from_reference (obj
);
3119 result
= build_function_call (obj
, args
);
3123 /* Free all the conversions we allocated. */
3124 obstack_free (&conversion_obstack
, p
);
3130 op_error (enum tree_code code
, enum tree_code code2
,
3131 tree arg1
, tree arg2
, tree arg3
, const char *problem
)
3135 if (code
== MODIFY_EXPR
)
3136 opname
= assignment_operator_name_info
[code2
].name
;
3138 opname
= operator_name_info
[code
].name
;
3143 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3144 problem
, arg1
, arg2
, arg3
);
3147 case POSTINCREMENT_EXPR
:
3148 case POSTDECREMENT_EXPR
:
3149 error ("%s for %<operator%s%> in %<%E%s%>", problem
, opname
, arg1
, opname
);
3153 error ("%s for %<operator[]%> in %<%E[%E]%>", problem
, arg1
, arg2
);
3158 error ("%s for %qs in %<%s %E%>", problem
, opname
, opname
, arg1
);
3163 error ("%s for %<operator%s%> in %<%E %s %E%>",
3164 problem
, opname
, arg1
, opname
, arg2
);
3166 error ("%s for %<operator%s%> in %<%s%E%>",
3167 problem
, opname
, opname
, arg1
);
3172 /* Return the implicit conversion sequence that could be used to
3173 convert E1 to E2 in [expr.cond]. */
3176 conditional_conversion (tree e1
, tree e2
)
3178 tree t1
= non_reference (TREE_TYPE (e1
));
3179 tree t2
= non_reference (TREE_TYPE (e2
));
3185 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3186 implicitly converted (clause _conv_) to the type "reference to
3187 T2", subject to the constraint that in the conversion the
3188 reference must bind directly (_dcl.init.ref_) to E1. */
3189 if (real_lvalue_p (e2
))
3191 conv
= implicit_conversion (build_reference_type (t2
),
3195 LOOKUP_NO_TEMP_BIND
);
3202 If E1 and E2 have class type, and the underlying class types are
3203 the same or one is a base class of the other: E1 can be converted
3204 to match E2 if the class of T2 is the same type as, or a base
3205 class of, the class of T1, and the cv-qualification of T2 is the
3206 same cv-qualification as, or a greater cv-qualification than, the
3207 cv-qualification of T1. If the conversion is applied, E1 is
3208 changed to an rvalue of type T2 that still refers to the original
3209 source class object (or the appropriate subobject thereof). */
3210 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
3211 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
3213 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
3215 conv
= build_identity_conv (t1
, e1
);
3216 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
3217 TYPE_MAIN_VARIANT (t2
)))
3218 conv
= build_conv (ck_base
, t2
, conv
);
3220 conv
= build_conv (ck_rvalue
, t2
, conv
);
3229 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3230 converted to the type that expression E2 would have if E2 were
3231 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3232 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
3236 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3237 arguments to the conditional expression. */
3240 build_conditional_expr (tree arg1
, tree arg2
, tree arg3
)
3244 tree result
= NULL_TREE
;
3245 tree result_type
= NULL_TREE
;
3246 bool lvalue_p
= true;
3247 struct z_candidate
*candidates
= 0;
3248 struct z_candidate
*cand
;
3251 /* As a G++ extension, the second argument to the conditional can be
3252 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3253 c'.) If the second operand is omitted, make sure it is
3254 calculated only once. */
3258 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3260 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3261 if (real_lvalue_p (arg1
))
3262 arg2
= arg1
= stabilize_reference (arg1
);
3264 arg2
= arg1
= save_expr (arg1
);
3269 The first expr ession is implicitly converted to bool (clause
3271 arg1
= perform_implicit_conversion (boolean_type_node
, arg1
);
3273 /* If something has already gone wrong, just pass that fact up the
3275 if (error_operand_p (arg1
)
3276 || error_operand_p (arg2
)
3277 || error_operand_p (arg3
))
3278 return error_mark_node
;
3282 If either the second or the third operand has type (possibly
3283 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3284 array-to-pointer (_conv.array_), and function-to-pointer
3285 (_conv.func_) standard conversions are performed on the second
3286 and third operands. */
3287 arg2_type
= unlowered_expr_type (arg2
);
3288 arg3_type
= unlowered_expr_type (arg3
);
3289 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
3291 /* Do the conversions. We don't these for `void' type arguments
3292 since it can't have any effect and since decay_conversion
3293 does not handle that case gracefully. */
3294 if (!VOID_TYPE_P (arg2_type
))
3295 arg2
= decay_conversion (arg2
);
3296 if (!VOID_TYPE_P (arg3_type
))
3297 arg3
= decay_conversion (arg3
);
3298 arg2_type
= TREE_TYPE (arg2
);
3299 arg3_type
= TREE_TYPE (arg3
);
3303 One of the following shall hold:
3305 --The second or the third operand (but not both) is a
3306 throw-expression (_except.throw_); the result is of the
3307 type of the other and is an rvalue.
3309 --Both the second and the third operands have type void; the
3310 result is of type void and is an rvalue.
3312 We must avoid calling force_rvalue for expressions of type
3313 "void" because it will complain that their value is being
3315 if (TREE_CODE (arg2
) == THROW_EXPR
3316 && TREE_CODE (arg3
) != THROW_EXPR
)
3318 if (!VOID_TYPE_P (arg3_type
))
3319 arg3
= force_rvalue (arg3
);
3320 arg3_type
= TREE_TYPE (arg3
);
3321 result_type
= arg3_type
;
3323 else if (TREE_CODE (arg2
) != THROW_EXPR
3324 && TREE_CODE (arg3
) == THROW_EXPR
)
3326 if (!VOID_TYPE_P (arg2_type
))
3327 arg2
= force_rvalue (arg2
);
3328 arg2_type
= TREE_TYPE (arg2
);
3329 result_type
= arg2_type
;
3331 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
3332 result_type
= void_type_node
;
3335 if (VOID_TYPE_P (arg2_type
))
3336 error ("second operand to the conditional operator "
3337 "is of type %<void%>, "
3338 "but the third operand is neither a throw-expression "
3339 "nor of type %<void%>");
3341 error ("third operand to the conditional operator "
3342 "is of type %<void%>, "
3343 "but the second operand is neither a throw-expression "
3344 "nor of type %<void%>");
3345 return error_mark_node
;
3349 goto valid_operands
;
3353 Otherwise, if the second and third operand have different types,
3354 and either has (possibly cv-qualified) class type, an attempt is
3355 made to convert each of those operands to the type of the other. */
3356 else if (!same_type_p (arg2_type
, arg3_type
)
3357 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
3362 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3363 p
= conversion_obstack_alloc (0);
3365 conv2
= conditional_conversion (arg2
, arg3
);
3366 conv3
= conditional_conversion (arg3
, arg2
);
3370 If both can be converted, or one can be converted but the
3371 conversion is ambiguous, the program is ill-formed. If
3372 neither can be converted, the operands are left unchanged and
3373 further checking is performed as described below. If exactly
3374 one conversion is possible, that conversion is applied to the
3375 chosen operand and the converted operand is used in place of
3376 the original operand for the remainder of this section. */
3377 if ((conv2
&& !conv2
->bad_p
3378 && conv3
&& !conv3
->bad_p
)
3379 || (conv2
&& conv2
->kind
== ck_ambig
)
3380 || (conv3
&& conv3
->kind
== ck_ambig
))
3382 error ("operands to ?: have different types %qT and %qT",
3383 arg2_type
, arg3_type
);
3384 result
= error_mark_node
;
3386 else if (conv2
&& (!conv2
->bad_p
|| !conv3
))
3388 arg2
= convert_like (conv2
, arg2
);
3389 arg2
= convert_from_reference (arg2
);
3390 arg2_type
= TREE_TYPE (arg2
);
3391 /* Even if CONV2 is a valid conversion, the result of the
3392 conversion may be invalid. For example, if ARG3 has type
3393 "volatile X", and X does not have a copy constructor
3394 accepting a "volatile X&", then even if ARG2 can be
3395 converted to X, the conversion will fail. */
3396 if (error_operand_p (arg2
))
3397 result
= error_mark_node
;
3399 else if (conv3
&& (!conv3
->bad_p
|| !conv2
))
3401 arg3
= convert_like (conv3
, arg3
);
3402 arg3
= convert_from_reference (arg3
);
3403 arg3_type
= TREE_TYPE (arg3
);
3404 if (error_operand_p (arg3
))
3405 result
= error_mark_node
;
3408 /* Free all the conversions we allocated. */
3409 obstack_free (&conversion_obstack
, p
);
3414 /* If, after the conversion, both operands have class type,
3415 treat the cv-qualification of both operands as if it were the
3416 union of the cv-qualification of the operands.
3418 The standard is not clear about what to do in this
3419 circumstance. For example, if the first operand has type
3420 "const X" and the second operand has a user-defined
3421 conversion to "volatile X", what is the type of the second
3422 operand after this step? Making it be "const X" (matching
3423 the first operand) seems wrong, as that discards the
3424 qualification without actually performing a copy. Leaving it
3425 as "volatile X" seems wrong as that will result in the
3426 conditional expression failing altogether, even though,
3427 according to this step, the one operand could be converted to
3428 the type of the other. */
3429 if ((conv2
|| conv3
)
3430 && CLASS_TYPE_P (arg2_type
)
3431 && TYPE_QUALS (arg2_type
) != TYPE_QUALS (arg3_type
))
3432 arg2_type
= arg3_type
=
3433 cp_build_qualified_type (arg2_type
,
3434 TYPE_QUALS (arg2_type
)
3435 | TYPE_QUALS (arg3_type
));
3440 If the second and third operands are lvalues and have the same
3441 type, the result is of that type and is an lvalue. */
3442 if (real_lvalue_p (arg2
)
3443 && real_lvalue_p (arg3
)
3444 && same_type_p (arg2_type
, arg3_type
))
3446 result_type
= arg2_type
;
3447 goto valid_operands
;
3452 Otherwise, the result is an rvalue. If the second and third
3453 operand do not have the same type, and either has (possibly
3454 cv-qualified) class type, overload resolution is used to
3455 determine the conversions (if any) to be applied to the operands
3456 (_over.match.oper_, _over.built_). */
3458 if (!same_type_p (arg2_type
, arg3_type
)
3459 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
3465 /* Rearrange the arguments so that add_builtin_candidate only has
3466 to know about two args. In build_builtin_candidates, the
3467 arguments are unscrambled. */
3471 add_builtin_candidates (&candidates
,
3474 ansi_opname (COND_EXPR
),
3480 If the overload resolution fails, the program is
3482 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
3485 op_error (COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, "no match");
3486 print_z_candidates (candidates
);
3487 return error_mark_node
;
3489 cand
= tourney (candidates
);
3492 op_error (COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, "no match");
3493 print_z_candidates (candidates
);
3494 return error_mark_node
;
3499 Otherwise, the conversions thus determined are applied, and
3500 the converted operands are used in place of the original
3501 operands for the remainder of this section. */
3502 conv
= cand
->convs
[0];
3503 arg1
= convert_like (conv
, arg1
);
3504 conv
= cand
->convs
[1];
3505 arg2
= convert_like (conv
, arg2
);
3506 conv
= cand
->convs
[2];
3507 arg3
= convert_like (conv
, arg3
);
3512 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3513 and function-to-pointer (_conv.func_) standard conversions are
3514 performed on the second and third operands.
3516 We need to force the lvalue-to-rvalue conversion here for class types,
3517 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3518 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3521 arg2
= force_rvalue (arg2
);
3522 if (!CLASS_TYPE_P (arg2_type
))
3523 arg2_type
= TREE_TYPE (arg2
);
3525 arg3
= force_rvalue (arg3
);
3526 if (!CLASS_TYPE_P (arg2_type
))
3527 arg3_type
= TREE_TYPE (arg3
);
3529 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
3530 return error_mark_node
;
3534 After those conversions, one of the following shall hold:
3536 --The second and third operands have the same type; the result is of
3538 if (same_type_p (arg2_type
, arg3_type
))
3539 result_type
= arg2_type
;
3542 --The second and third operands have arithmetic or enumeration
3543 type; the usual arithmetic conversions are performed to bring
3544 them to a common type, and the result is of that type. */
3545 else if ((ARITHMETIC_TYPE_P (arg2_type
)
3546 || TREE_CODE (arg2_type
) == ENUMERAL_TYPE
)
3547 && (ARITHMETIC_TYPE_P (arg3_type
)
3548 || TREE_CODE (arg3_type
) == ENUMERAL_TYPE
))
3550 /* In this case, there is always a common type. */
3551 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
3554 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
3555 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
3556 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3557 arg2_type
, arg3_type
);
3558 else if (extra_warnings
3559 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
3560 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
3561 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
3562 && !same_type_p (arg2_type
, type_promotes_to (arg3_type
)))))
3563 warning (0, "enumeral and non-enumeral type in conditional expression");
3565 arg2
= perform_implicit_conversion (result_type
, arg2
);
3566 arg3
= perform_implicit_conversion (result_type
, arg3
);
3570 --The second and third operands have pointer type, or one has
3571 pointer type and the other is a null pointer constant; pointer
3572 conversions (_conv.ptr_) and qualification conversions
3573 (_conv.qual_) are performed to bring them to their composite
3574 pointer type (_expr.rel_). The result is of the composite
3577 --The second and third operands have pointer to member type, or
3578 one has pointer to member type and the other is a null pointer
3579 constant; pointer to member conversions (_conv.mem_) and
3580 qualification conversions (_conv.qual_) are performed to bring
3581 them to a common type, whose cv-qualification shall match the
3582 cv-qualification of either the second or the third operand.
3583 The result is of the common type. */
3584 else if ((null_ptr_cst_p (arg2
)
3585 && (TYPE_PTR_P (arg3_type
) || TYPE_PTR_TO_MEMBER_P (arg3_type
)))
3586 || (null_ptr_cst_p (arg3
)
3587 && (TYPE_PTR_P (arg2_type
) || TYPE_PTR_TO_MEMBER_P (arg2_type
)))
3588 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
3589 || (TYPE_PTRMEM_P (arg2_type
) && TYPE_PTRMEM_P (arg3_type
))
3590 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
3592 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
3593 arg3
, "conditional expression");
3594 if (result_type
== error_mark_node
)
3595 return error_mark_node
;
3596 arg2
= perform_implicit_conversion (result_type
, arg2
);
3597 arg3
= perform_implicit_conversion (result_type
, arg3
);
3602 error ("operands to ?: have different types %qT and %qT",
3603 arg2_type
, arg3_type
);
3604 return error_mark_node
;
3608 result
= fold_if_not_in_template (build3 (COND_EXPR
, result_type
, arg1
,
3610 /* We can't use result_type below, as fold might have returned a
3615 /* Expand both sides into the same slot, hopefully the target of
3616 the ?: expression. We used to check for TARGET_EXPRs here,
3617 but now we sometimes wrap them in NOP_EXPRs so the test would
3619 if (CLASS_TYPE_P (TREE_TYPE (result
)))
3620 result
= get_target_expr (result
);
3621 /* If this expression is an rvalue, but might be mistaken for an
3622 lvalue, we must add a NON_LVALUE_EXPR. */
3623 result
= rvalue (result
);
3629 /* OPERAND is an operand to an expression. Perform necessary steps
3630 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3634 prep_operand (tree operand
)
3638 if (CLASS_TYPE_P (TREE_TYPE (operand
))
3639 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
3640 /* Make sure the template type is instantiated now. */
3641 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
3647 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3648 OVERLOAD) to the CANDIDATES, returning an updated list of
3649 CANDIDATES. The ARGS are the arguments provided to the call,
3650 without any implicit object parameter. The EXPLICIT_TARGS are
3651 explicit template arguments provided. TEMPLATE_ONLY is true if
3652 only template functions should be considered. CONVERSION_PATH,
3653 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3656 add_candidates (tree fns
, tree args
,
3657 tree explicit_targs
, bool template_only
,
3658 tree conversion_path
, tree access_path
,
3660 struct z_candidate
**candidates
)
3663 tree non_static_args
;
3665 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
3666 /* Delay creating the implicit this parameter until it is needed. */
3667 non_static_args
= NULL_TREE
;
3674 fn
= OVL_CURRENT (fns
);
3675 /* Figure out which set of arguments to use. */
3676 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
3678 /* If this function is a non-static member, prepend the implicit
3679 object parameter. */
3680 if (!non_static_args
)
3681 non_static_args
= tree_cons (NULL_TREE
,
3682 build_this (TREE_VALUE (args
)),
3684 fn_args
= non_static_args
;
3687 /* Otherwise, just use the list of arguments provided. */
3690 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
3691 add_template_candidate (candidates
,
3701 else if (!template_only
)
3702 add_function_candidate (candidates
,
3709 fns
= OVL_NEXT (fns
);
3714 build_new_op (enum tree_code code
, int flags
, tree arg1
, tree arg2
, tree arg3
,
3717 struct z_candidate
*candidates
= 0, *cand
;
3718 tree arglist
, fnname
;
3720 tree result
= NULL_TREE
;
3721 bool result_valid_p
= false;
3722 enum tree_code code2
= NOP_EXPR
;
3727 bool expl_eq_arg1
= false;
3729 if (error_operand_p (arg1
)
3730 || error_operand_p (arg2
)
3731 || error_operand_p (arg3
))
3732 return error_mark_node
;
3734 if (code
== MODIFY_EXPR
)
3736 code2
= TREE_CODE (arg3
);
3738 fnname
= ansi_assopname (code2
);
3741 fnname
= ansi_opname (code
);
3743 arg1
= prep_operand (arg1
);
3749 case VEC_DELETE_EXPR
:
3751 /* Use build_op_new_call and build_op_delete_call instead. */
3755 return build_object_call (arg1
, arg2
);
3757 case TRUTH_ORIF_EXPR
:
3758 case TRUTH_ANDIF_EXPR
:
3759 case TRUTH_AND_EXPR
:
3761 if (COMPARISON_CLASS_P (arg1
))
3762 expl_eq_arg1
= true;
3767 arg2
= prep_operand (arg2
);
3768 arg3
= prep_operand (arg3
);
3770 if (code
== COND_EXPR
)
3772 if (arg2
== NULL_TREE
3773 || TREE_CODE (TREE_TYPE (arg2
)) == VOID_TYPE
3774 || TREE_CODE (TREE_TYPE (arg3
)) == VOID_TYPE
3775 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))
3776 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3
))))
3779 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1
))
3780 && (! arg2
|| ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))))
3783 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
3784 arg2
= integer_zero_node
;
3786 arglist
= NULL_TREE
;
3788 arglist
= tree_cons (NULL_TREE
, arg3
, arglist
);
3790 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3791 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3793 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3794 p
= conversion_obstack_alloc (0);
3796 /* Add namespace-scope operators to the list of functions to
3798 add_candidates (lookup_function_nonclass (fnname
, arglist
, /*block_p=*/true),
3799 arglist
, NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
3800 flags
, &candidates
);
3801 /* Add class-member operators to the candidate set. */
3802 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
3806 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
3807 if (fns
== error_mark_node
)
3809 result
= error_mark_node
;
3810 goto user_defined_result_ready
;
3813 add_candidates (BASELINK_FUNCTIONS (fns
), arglist
,
3815 BASELINK_BINFO (fns
),
3816 TYPE_BINFO (TREE_TYPE (arg1
)),
3817 flags
, &candidates
);
3820 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3821 to know about two args; a builtin candidate will always have a first
3822 parameter of type bool. We'll handle that in
3823 build_builtin_candidate. */
3824 if (code
== COND_EXPR
)
3834 args
[2] = NULL_TREE
;
3837 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
, flags
);
3843 /* For these, the built-in candidates set is empty
3844 [over.match.oper]/3. We don't want non-strict matches
3845 because exact matches are always possible with built-in
3846 operators. The built-in candidate set for COMPONENT_REF
3847 would be empty too, but since there are no such built-in
3848 operators, we accept non-strict matches for them. */
3853 strict_p
= pedantic
;
3857 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
3862 case POSTINCREMENT_EXPR
:
3863 case POSTDECREMENT_EXPR
:
3864 /* Look for an `operator++ (int)'. If they didn't have
3865 one, then we fall back to the old way of doing things. */
3866 if (flags
& LOOKUP_COMPLAIN
)
3867 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3868 "trying prefix operator instead",
3870 operator_name_info
[code
].name
);
3871 if (code
== POSTINCREMENT_EXPR
)
3872 code
= PREINCREMENT_EXPR
;
3874 code
= PREDECREMENT_EXPR
;
3875 result
= build_new_op (code
, flags
, arg1
, NULL_TREE
, NULL_TREE
,
3879 /* The caller will deal with these. */
3884 result_valid_p
= true;
3888 if (flags
& LOOKUP_COMPLAIN
)
3890 op_error (code
, code2
, arg1
, arg2
, arg3
, "no match");
3891 print_z_candidates (candidates
);
3893 result
= error_mark_node
;
3899 cand
= tourney (candidates
);
3902 if (flags
& LOOKUP_COMPLAIN
)
3904 op_error (code
, code2
, arg1
, arg2
, arg3
, "ambiguous overload");
3905 print_z_candidates (candidates
);
3907 result
= error_mark_node
;
3909 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
3912 *overloaded_p
= true;
3914 if (resolve_args (arglist
) == error_mark_node
)
3915 result
= error_mark_node
;
3917 result
= build_over_call (cand
, LOOKUP_NORMAL
);
3921 /* Give any warnings we noticed during overload resolution. */
3924 struct candidate_warning
*w
;
3925 for (w
= cand
->warnings
; w
; w
= w
->next
)
3926 joust (cand
, w
->loser
, 1);
3929 /* Check for comparison of different enum types. */
3938 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
3939 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
3940 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
3941 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
))))
3943 warning (0, "comparison between %q#T and %q#T",
3944 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
3951 /* We need to strip any leading REF_BIND so that bitfields
3952 don't cause errors. This should not remove any important
3953 conversions, because builtins don't apply to class
3954 objects directly. */
3955 conv
= cand
->convs
[0];
3956 if (conv
->kind
== ck_ref_bind
)
3957 conv
= conv
->u
.next
;
3958 arg1
= convert_like (conv
, arg1
);
3961 conv
= cand
->convs
[1];
3962 if (conv
->kind
== ck_ref_bind
)
3963 conv
= conv
->u
.next
;
3964 arg2
= convert_like (conv
, arg2
);
3968 conv
= cand
->convs
[2];
3969 if (conv
->kind
== ck_ref_bind
)
3970 conv
= conv
->u
.next
;
3971 arg3
= convert_like (conv
, arg3
);
3976 warn_logical_operator (code
, arg1
, arg2
);
3977 expl_eq_arg1
= true;
3982 user_defined_result_ready
:
3984 /* Free all the conversions we allocated. */
3985 obstack_free (&conversion_obstack
, p
);
3987 if (result
|| result_valid_p
)
3994 return build_modify_expr (arg1
, code2
, arg2
);
3997 return build_indirect_ref (arg1
, "unary *");
3999 case TRUTH_ANDIF_EXPR
:
4000 case TRUTH_ORIF_EXPR
:
4001 case TRUTH_AND_EXPR
:
4004 warn_logical_operator (code
, arg1
, arg2
);
4008 case TRUNC_DIV_EXPR
:
4019 case TRUNC_MOD_EXPR
:
4023 return cp_build_binary_op (code
, arg1
, arg2
);
4025 case UNARY_PLUS_EXPR
:
4028 case TRUTH_NOT_EXPR
:
4029 case PREINCREMENT_EXPR
:
4030 case POSTINCREMENT_EXPR
:
4031 case PREDECREMENT_EXPR
:
4032 case POSTDECREMENT_EXPR
:
4035 return build_unary_op (code
, arg1
, candidates
!= 0);
4038 return build_array_ref (arg1
, arg2
);
4041 return build_conditional_expr (arg1
, arg2
, arg3
);
4044 return build_m_component_ref (build_indirect_ref (arg1
, NULL
), arg2
);
4046 /* The caller will deal with these. */
4058 /* Build a call to operator delete. This has to be handled very specially,
4059 because the restrictions on what signatures match are different from all
4060 other call instances. For a normal delete, only a delete taking (void *)
4061 or (void *, size_t) is accepted. For a placement delete, only an exact
4062 match with the placement new is accepted.
4064 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4065 ADDR is the pointer to be deleted.
4066 SIZE is the size of the memory block to be deleted.
4067 GLOBAL_P is true if the delete-expression should not consider
4068 class-specific delete operators.
4069 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4071 If this call to "operator delete" is being generated as part to
4072 deallocate memory allocated via a new-expression (as per [expr.new]
4073 which requires that if the initialization throws an exception then
4074 we call a deallocation function), then ALLOC_FN is the allocation
4078 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
4079 bool global_p
, tree placement
,
4082 tree fn
= NULL_TREE
;
4083 tree fns
, fnname
, argtypes
, type
;
4086 if (addr
== error_mark_node
)
4087 return error_mark_node
;
4089 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
4091 fnname
= ansi_opname (code
);
4093 if (CLASS_TYPE_P (type
)
4094 && COMPLETE_TYPE_P (complete_type (type
))
4098 If the result of the lookup is ambiguous or inaccessible, or if
4099 the lookup selects a placement deallocation function, the
4100 program is ill-formed.
4102 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4104 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
4105 if (fns
== error_mark_node
)
4106 return error_mark_node
;
4111 if (fns
== NULL_TREE
)
4112 fns
= lookup_name_nonclass (fnname
);
4114 /* Strip const and volatile from addr. */
4115 addr
= cp_convert (ptr_type_node
, addr
);
4119 /* Get the parameter types for the allocation function that is
4121 gcc_assert (alloc_fn
!= NULL_TREE
);
4122 argtypes
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
4126 /* First try it without the size argument. */
4127 argtypes
= void_list_node
;
4130 /* We make two tries at finding a matching `operator delete'. On
4131 the first pass, we look for a one-operator (or placement)
4132 operator delete. If we're not doing placement delete, then on
4133 the second pass we look for a two-argument delete. */
4134 for (pass
= 0; pass
< (placement
? 1 : 2); ++pass
)
4136 /* Go through the `operator delete' functions looking for one
4137 with a matching type. */
4138 for (fn
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
4144 /* The first argument must be "void *". */
4145 t
= TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn
)));
4146 if (!same_type_p (TREE_VALUE (t
), ptr_type_node
))
4149 /* On the first pass, check the rest of the arguments. */
4155 if (!same_type_p (TREE_VALUE (a
), TREE_VALUE (t
)))
4163 /* On the second pass, look for a function with exactly two
4164 arguments: "void *" and "size_t". */
4166 /* For "operator delete(void *, ...)" there will be
4167 no second argument, but we will not get an exact
4170 && same_type_p (TREE_VALUE (t
), size_type_node
)
4171 && TREE_CHAIN (t
) == void_list_node
)
4175 /* If we found a match, we're done. */
4180 /* If we have a matching function, call it. */
4183 /* Make sure we have the actual function, and not an
4185 fn
= OVL_CURRENT (fn
);
4187 /* If the FN is a member function, make sure that it is
4189 if (DECL_CLASS_SCOPE_P (fn
))
4190 perform_or_defer_access_check (TYPE_BINFO (type
), fn
, fn
);
4194 /* The placement args might not be suitable for overload
4195 resolution at this point, so build the call directly. */
4196 int nargs
= call_expr_nargs (placement
);
4197 tree
*argarray
= (tree
*) alloca (nargs
* sizeof (tree
));
4200 for (i
= 1; i
< nargs
; i
++)
4201 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
4203 return build_cxx_call (fn
, nargs
, argarray
);
4209 args
= tree_cons (NULL_TREE
, addr
, NULL_TREE
);
4211 args
= tree_cons (NULL_TREE
, addr
,
4212 build_tree_list (NULL_TREE
, size
));
4213 return build_function_call (fn
, args
);
4219 If no unambiguous matching deallocation function can be found,
4220 propagating the exception does not cause the object's memory to
4225 warning (0, "no corresponding deallocation function for `%D'",
4230 error ("no suitable %<operator %s%> for %qT",
4231 operator_name_info
[(int)code
].name
, type
);
4232 return error_mark_node
;
4235 /* If the current scope isn't allowed to access DECL along
4236 BASETYPE_PATH, give an error. The most derived class in
4237 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4238 the declaration to use in the error diagnostic. */
4241 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
)
4243 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
4245 if (!accessible_p (basetype_path
, decl
, true))
4247 if (TREE_PRIVATE (decl
))
4248 error ("%q+#D is private", diag_decl
);
4249 else if (TREE_PROTECTED (decl
))
4250 error ("%q+#D is protected", diag_decl
);
4252 error ("%q+#D is inaccessible", diag_decl
);
4253 error ("within this context");
4260 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4261 bitwise or of LOOKUP_* values. If any errors are warnings are
4262 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4263 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4267 build_temp (tree expr
, tree type
, int flags
,
4268 diagnostic_fn_t
*diagnostic_fn
)
4272 savew
= warningcount
, savee
= errorcount
;
4273 expr
= build_special_member_call (NULL_TREE
,
4274 complete_ctor_identifier
,
4275 build_tree_list (NULL_TREE
, expr
),
4277 if (warningcount
> savew
)
4278 *diagnostic_fn
= warning0
;
4279 else if (errorcount
> savee
)
4280 *diagnostic_fn
= error
;
4282 *diagnostic_fn
= NULL
;
4286 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4287 EXPR is implicitly converted to type TOTYPE.
4288 FN and ARGNUM are used for diagnostics. */
4291 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
4293 tree t
= non_reference (totype
);
4295 /* Issue warnings about peculiar, but valid, uses of NULL. */
4296 if (expr
== null_node
&& TREE_CODE (t
) != BOOLEAN_TYPE
&& ARITHMETIC_TYPE_P (t
))
4299 warning (OPT_Wconversion
, "passing NULL to non-pointer argument %P of %qD",
4302 warning (OPT_Wconversion
, "converting to non-pointer type %qT from NULL", t
);
4305 /* Issue warnings if "false" is converted to a NULL pointer */
4306 else if (expr
== boolean_false_node
&& fn
&& POINTER_TYPE_P (t
))
4307 warning (OPT_Wconversion
,
4308 "converting %<false%> to pointer type for argument %P of %qD",
4312 /* Perform the conversions in CONVS on the expression EXPR. FN and
4313 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4314 indicates the `this' argument of a method. INNER is nonzero when
4315 being called to continue a conversion chain. It is negative when a
4316 reference binding will be applied, positive otherwise. If
4317 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4318 conversions will be emitted if appropriate. If C_CAST_P is true,
4319 this conversion is coming from a C-style cast; in that case,
4320 conversions to inaccessible bases are permitted. */
4323 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
4324 int inner
, bool issue_conversion_warnings
,
4327 tree totype
= convs
->type
;
4328 diagnostic_fn_t diagnostic_fn
;
4331 && convs
->kind
!= ck_user
4332 && convs
->kind
!= ck_ambig
4333 && convs
->kind
!= ck_ref_bind
)
4335 conversion
*t
= convs
;
4336 for (; t
; t
= convs
->u
.next
)
4338 if (t
->kind
== ck_user
|| !t
->bad_p
)
4340 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
4341 /*issue_conversion_warnings=*/false,
4342 /*c_cast_p=*/false);
4345 else if (t
->kind
== ck_ambig
)
4346 return convert_like_real (t
, expr
, fn
, argnum
, 1,
4347 /*issue_conversion_warnings=*/false,
4348 /*c_cast_p=*/false);
4349 else if (t
->kind
== ck_identity
)
4352 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr
), totype
);
4354 pedwarn (" initializing argument %P of %qD", argnum
, fn
);
4355 return cp_convert (totype
, expr
);
4358 if (issue_conversion_warnings
)
4359 conversion_null_warnings (totype
, expr
, fn
, argnum
);
4361 switch (convs
->kind
)
4365 struct z_candidate
*cand
= convs
->cand
;
4366 tree convfn
= cand
->fn
;
4368 expr
= build_over_call (cand
, LOOKUP_NORMAL
);
4370 /* If this is a constructor or a function returning an aggr type,
4371 we need to build up a TARGET_EXPR. */
4372 if (DECL_CONSTRUCTOR_P (convfn
))
4373 expr
= build_cplus_new (totype
, expr
);
4375 /* The result of the call is then used to direct-initialize the object
4376 that is the destination of the copy-initialization. [dcl.init]
4378 Note that this step is not reflected in the conversion sequence;
4379 it affects the semantics when we actually perform the
4380 conversion, but is not considered during overload resolution.
4382 If the target is a class, that means call a ctor. */
4383 if (IS_AGGR_TYPE (totype
)
4384 && (inner
>= 0 || !lvalue_p (expr
)))
4388 /* Core issue 84, now a DR, says that we don't
4389 allow UDCs for these args (which deliberately
4390 breaks copy-init of an auto_ptr<Base> from an
4391 auto_ptr<Derived>). */
4392 LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
,
4399 (" initializing argument %P of %qD from result of %qD",
4400 argnum
, fn
, convfn
);
4403 (" initializing temporary from result of %qD", convfn
);
4405 expr
= build_cplus_new (totype
, expr
);
4410 if (type_unknown_p (expr
))
4411 expr
= instantiate_type (totype
, expr
, tf_warning_or_error
);
4412 /* Convert a constant to its underlying value, unless we are
4413 about to bind it to a reference, in which case we need to
4414 leave it as an lvalue. */
4417 expr
= decl_constant_value (expr
);
4418 if (expr
== null_node
&& INTEGRAL_TYPE_P (totype
))
4419 /* If __null has been converted to an integer type, we do not
4420 want to warn about uses of EXPR as an integer, rather than
4422 expr
= build_int_cst (totype
, 0);
4426 /* Call build_user_type_conversion again for the error. */
4427 return build_user_type_conversion
4428 (totype
, convs
->u
.expr
, LOOKUP_NORMAL
);
4434 expr
= convert_like_real (convs
->u
.next
, expr
, fn
, argnum
,
4435 convs
->kind
== ck_ref_bind
? -1 : 1,
4436 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
4438 if (expr
== error_mark_node
)
4439 return error_mark_node
;
4441 switch (convs
->kind
)
4444 expr
= convert_bitfield_to_declared_type (expr
);
4445 if (! IS_AGGR_TYPE (totype
))
4447 /* Else fall through. */
4449 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
4451 /* We are going to bind a reference directly to a base-class
4452 subobject of EXPR. */
4453 /* Build an expression for `*((base*) &expr)'. */
4454 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
4455 expr
= convert_to_base (expr
, build_pointer_type (totype
),
4456 !c_cast_p
, /*nonnull=*/true);
4457 expr
= build_indirect_ref (expr
, "implicit conversion");
4461 /* Copy-initialization where the cv-unqualified version of the source
4462 type is the same class as, or a derived class of, the class of the
4463 destination [is treated as direct-initialization]. [dcl.init] */
4464 expr
= build_temp (expr
, totype
, LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
,
4466 if (diagnostic_fn
&& fn
)
4467 diagnostic_fn (" initializing argument %P of %qD", argnum
, fn
);
4468 return build_cplus_new (totype
, expr
);
4472 tree ref_type
= totype
;
4474 /* If necessary, create a temporary.
4476 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
4477 that need temporaries, even when their types are reference
4478 compatible with the type of reference being bound, so the
4479 upcoming call to build_unary_op (ADDR_EXPR, expr, ...)
4481 if (convs
->need_temporary_p
4482 || TREE_CODE (expr
) == CONSTRUCTOR
4483 || TREE_CODE (expr
) == VA_ARG_EXPR
)
4485 tree type
= convs
->u
.next
->type
;
4486 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
4488 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
))
4489 && !TYPE_REF_IS_RVALUE (ref_type
))
4491 /* If the reference is volatile or non-const, we
4492 cannot create a temporary. */
4493 if (lvalue
& clk_bitfield
)
4494 error ("cannot bind bitfield %qE to %qT",
4496 else if (lvalue
& clk_packed
)
4497 error ("cannot bind packed field %qE to %qT",
4500 error ("cannot bind rvalue %qE to %qT", expr
, ref_type
);
4501 return error_mark_node
;
4503 /* If the source is a packed field, and we must use a copy
4504 constructor, then building the target expr will require
4505 binding the field to the reference parameter to the
4506 copy constructor, and we'll end up with an infinite
4507 loop. If we can use a bitwise copy, then we'll be
4509 if ((lvalue
& clk_packed
)
4510 && CLASS_TYPE_P (type
)
4511 && !TYPE_HAS_TRIVIAL_INIT_REF (type
))
4513 error ("cannot bind packed field %qE to %qT",
4515 return error_mark_node
;
4517 expr
= build_target_expr_with_type (expr
, type
);
4520 /* Take the address of the thing to which we will bind the
4522 expr
= build_unary_op (ADDR_EXPR
, expr
, 1);
4523 if (expr
== error_mark_node
)
4524 return error_mark_node
;
4526 /* Convert it to a pointer to the type referred to by the
4527 reference. This will adjust the pointer if a derived to
4528 base conversion is being performed. */
4529 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
4531 /* Convert the pointer to the desired reference type. */
4532 return build_nop (ref_type
, expr
);
4536 return decay_conversion (expr
);
4539 /* Warn about deprecated conversion if appropriate. */
4540 string_conv_p (totype
, expr
, 1);
4545 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
4547 return build_nop (totype
, expr
);
4550 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
4557 if (issue_conversion_warnings
)
4558 expr
= convert_and_check (totype
, expr
);
4560 expr
= convert (totype
, expr
);
4565 /* Build a call to __builtin_trap. */
4568 call_builtin_trap (void)
4570 tree fn
= implicit_built_in_decls
[BUILT_IN_TRAP
];
4572 gcc_assert (fn
!= NULL
);
4573 fn
= build_call_n (fn
, 0);
4577 /* ARG is being passed to a varargs function. Perform any conversions
4578 required. Return the converted value. */
4581 convert_arg_to_ellipsis (tree arg
)
4585 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4586 standard conversions are performed. */
4587 arg
= decay_conversion (arg
);
4590 If the argument has integral or enumeration type that is subject
4591 to the integral promotions (_conv.prom_), or a floating point
4592 type that is subject to the floating point promotion
4593 (_conv.fpprom_), the value of the argument is converted to the
4594 promoted type before the call. */
4595 if (TREE_CODE (TREE_TYPE (arg
)) == REAL_TYPE
4596 && (TYPE_PRECISION (TREE_TYPE (arg
))
4597 < TYPE_PRECISION (double_type_node
)))
4598 arg
= convert_to_real (double_type_node
, arg
);
4599 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
4600 arg
= perform_integral_promotions (arg
);
4602 arg
= require_complete_type (arg
);
4604 if (arg
!= error_mark_node
4605 && !pod_type_p (TREE_TYPE (arg
)))
4607 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4608 here and do a bitwise copy, but now cp_expr_size will abort if we
4610 If the call appears in the context of a sizeof expression,
4611 there is no need to emit a warning, since the expression won't be
4612 evaluated. We keep the builtin_trap just as a safety check. */
4613 if (!skip_evaluation
)
4614 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4615 "call will abort at runtime", TREE_TYPE (arg
));
4616 arg
= call_builtin_trap ();
4617 arg
= build2 (COMPOUND_EXPR
, integer_type_node
, arg
,
4624 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4627 build_x_va_arg (tree expr
, tree type
)
4629 if (processing_template_decl
)
4630 return build_min (VA_ARG_EXPR
, type
, expr
);
4632 type
= complete_type_or_else (type
, NULL_TREE
);
4634 if (expr
== error_mark_node
|| !type
)
4635 return error_mark_node
;
4637 if (! pod_type_p (type
))
4639 /* Remove reference types so we don't ICE later on. */
4640 tree type1
= non_reference (type
);
4641 /* Undefined behavior [expr.call] 5.2.2/7. */
4642 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4643 "call will abort at runtime", type
);
4644 expr
= convert (build_pointer_type (type1
), null_node
);
4645 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
),
4646 call_builtin_trap (), expr
);
4647 expr
= build_indirect_ref (expr
, NULL
);
4651 return build_va_arg (expr
, type
);
4654 /* TYPE has been given to va_arg. Apply the default conversions which
4655 would have happened when passed via ellipsis. Return the promoted
4656 type, or the passed type if there is no change. */
4659 cxx_type_promotes_to (tree type
)
4663 /* Perform the array-to-pointer and function-to-pointer
4665 type
= type_decays_to (type
);
4667 promote
= type_promotes_to (type
);
4668 if (same_type_p (type
, promote
))
4674 /* ARG is a default argument expression being passed to a parameter of
4675 the indicated TYPE, which is a parameter to FN. Do any required
4676 conversions. Return the converted value. */
4678 static GTY(()) VEC(tree
,gc
) *default_arg_context
;
4681 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
)
4686 /* If the ARG is an unparsed default argument expression, the
4687 conversion cannot be performed. */
4688 if (TREE_CODE (arg
) == DEFAULT_ARG
)
4690 error ("the default argument for parameter %d of %qD has "
4691 "not yet been parsed",
4693 return error_mark_node
;
4696 /* Detect recursion. */
4697 for (i
= 0; VEC_iterate (tree
, default_arg_context
, i
, t
); ++i
)
4700 error ("recursive evaluation of default argument for %q#D", fn
);
4701 return error_mark_node
;
4703 VEC_safe_push (tree
, gc
, default_arg_context
, fn
);
4705 if (fn
&& DECL_TEMPLATE_INFO (fn
))
4706 arg
= tsubst_default_argument (fn
, type
, arg
);
4708 arg
= break_out_target_exprs (arg
);
4710 if (TREE_CODE (arg
) == CONSTRUCTOR
)
4712 arg
= digest_init (type
, arg
);
4713 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4714 "default argument", fn
, parmnum
);
4718 /* We must make a copy of ARG, in case subsequent processing
4719 alters any part of it. For example, during gimplification a
4720 cast of the form (T) &X::f (where "f" is a member function)
4721 will lead to replacing the PTRMEM_CST for &X::f with a
4722 VAR_DECL. We can avoid the copy for constants, since they
4723 are never modified in place. */
4724 if (!CONSTANT_CLASS_P (arg
))
4725 arg
= unshare_expr (arg
);
4726 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4727 "default argument", fn
, parmnum
);
4728 arg
= convert_for_arg_passing (type
, arg
);
4731 VEC_pop (tree
, default_arg_context
);
4736 /* Returns the type which will really be used for passing an argument of
4740 type_passed_as (tree type
)
4742 /* Pass classes with copy ctors by invisible reference. */
4743 if (TREE_ADDRESSABLE (type
))
4745 type
= build_reference_type (type
);
4746 /* There are no other pointers to this temporary. */
4747 type
= build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
4749 else if (targetm
.calls
.promote_prototypes (type
)
4750 && INTEGRAL_TYPE_P (type
)
4751 && COMPLETE_TYPE_P (type
)
4752 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type
),
4753 TYPE_SIZE (integer_type_node
)))
4754 type
= integer_type_node
;
4759 /* Actually perform the appropriate conversion. */
4762 convert_for_arg_passing (tree type
, tree val
)
4766 /* If VAL is a bitfield, then -- since it has already been converted
4767 to TYPE -- it cannot have a precision greater than TYPE.
4769 If it has a smaller precision, we must widen it here. For
4770 example, passing "int f:3;" to a function expecting an "int" will
4771 not result in any conversion before this point.
4773 If the precision is the same we must not risk widening. For
4774 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
4775 often have type "int", even though the C++ type for the field is
4776 "long long". If the value is being passed to a function
4777 expecting an "int", then no conversions will be required. But,
4778 if we call convert_bitfield_to_declared_type, the bitfield will
4779 be converted to "long long". */
4780 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
4782 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
4783 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
4785 if (val
== error_mark_node
)
4787 /* Pass classes with copy ctors by invisible reference. */
4788 else if (TREE_ADDRESSABLE (type
))
4789 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
4790 else if (targetm
.calls
.promote_prototypes (type
)
4791 && INTEGRAL_TYPE_P (type
)
4792 && COMPLETE_TYPE_P (type
)
4793 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type
),
4794 TYPE_SIZE (integer_type_node
)))
4795 val
= perform_integral_promotions (val
);
4796 if (warn_missing_format_attribute
)
4798 tree rhstype
= TREE_TYPE (val
);
4799 const enum tree_code coder
= TREE_CODE (rhstype
);
4800 const enum tree_code codel
= TREE_CODE (type
);
4801 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
4803 && check_missing_format_attribute (type
, rhstype
))
4804 warning (OPT_Wmissing_format_attribute
,
4805 "argument of function call might be a candidate for a format attribute");
4810 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4811 which no conversions at all should be done. This is true for some
4812 builtins which don't act like normal functions. */
4815 magic_varargs_p (tree fn
)
4817 if (DECL_BUILT_IN (fn
))
4818 switch (DECL_FUNCTION_CODE (fn
))
4820 case BUILT_IN_CLASSIFY_TYPE
:
4821 case BUILT_IN_CONSTANT_P
:
4822 case BUILT_IN_NEXT_ARG
:
4823 case BUILT_IN_STDARG_START
:
4824 case BUILT_IN_VA_START
:
4828 return lookup_attribute ("type generic",
4829 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
4835 /* Subroutine of the various build_*_call functions. Overload resolution
4836 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4837 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4838 bitmask of various LOOKUP_* flags which apply to the call itself. */
4841 build_over_call (struct z_candidate
*cand
, int flags
)
4844 tree args
= cand
->args
;
4845 conversion
**convs
= cand
->convs
;
4847 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
4856 /* In a template, there is no need to perform all of the work that
4857 is normally done. We are only interested in the type of the call
4858 expression, i.e., the return type of the function. Any semantic
4859 errors will be deferred until the template is instantiated. */
4860 if (processing_template_decl
)
4864 return_type
= TREE_TYPE (TREE_TYPE (fn
));
4865 expr
= build_call_list (return_type
, fn
, args
);
4866 if (TREE_THIS_VOLATILE (fn
) && cfun
)
4867 current_function_returns_abnormally
= 1;
4868 if (!VOID_TYPE_P (return_type
))
4869 require_complete_type (return_type
);
4870 return convert_from_reference (expr
);
4873 /* Give any warnings we noticed during overload resolution. */
4876 struct candidate_warning
*w
;
4877 for (w
= cand
->warnings
; w
; w
= w
->next
)
4878 joust (cand
, w
->loser
, 1);
4881 if (DECL_FUNCTION_MEMBER_P (fn
))
4883 /* If FN is a template function, two cases must be considered.
4888 template <class T> void f();
4890 template <class T> struct B {
4894 struct C : A, B<int> {
4896 using B<int>::g; // #2
4899 In case #1 where `A::f' is a member template, DECL_ACCESS is
4900 recorded in the primary template but not in its specialization.
4901 We check access of FN using its primary template.
4903 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4904 because it is a member of class template B, DECL_ACCESS is
4905 recorded in the specialization `B<int>::g'. We cannot use its
4906 primary template because `B<T>::g' and `B<int>::g' may have
4907 different access. */
4908 if (DECL_TEMPLATE_INFO (fn
)
4909 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
4910 perform_or_defer_access_check (cand
->access_path
,
4911 DECL_TI_TEMPLATE (fn
), fn
);
4913 perform_or_defer_access_check (cand
->access_path
, fn
, fn
);
4916 if (args
&& TREE_CODE (args
) != TREE_LIST
)
4917 args
= build_tree_list (NULL_TREE
, args
);
4920 /* Find maximum size of vector to hold converted arguments. */
4921 parmlen
= list_length (parm
);
4922 nargs
= list_length (args
);
4923 if (parmlen
> nargs
)
4925 argarray
= (tree
*) alloca (nargs
* sizeof (tree
));
4927 /* The implicit parameters to a constructor are not considered by overload
4928 resolution, and must be of the proper type. */
4929 if (DECL_CONSTRUCTOR_P (fn
))
4931 argarray
[j
++] = TREE_VALUE (arg
);
4932 arg
= TREE_CHAIN (arg
);
4933 parm
= TREE_CHAIN (parm
);
4934 /* We should never try to call the abstract constructor. */
4935 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
4937 if (DECL_HAS_VTT_PARM_P (fn
))
4939 argarray
[j
++] = TREE_VALUE (arg
);
4940 arg
= TREE_CHAIN (arg
);
4941 parm
= TREE_CHAIN (parm
);
4944 /* Bypass access control for 'this' parameter. */
4945 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4947 tree parmtype
= TREE_VALUE (parm
);
4948 tree argtype
= TREE_TYPE (TREE_VALUE (arg
));
4952 if (convs
[i
]->bad_p
)
4953 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4954 TREE_TYPE (argtype
), fn
);
4956 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4957 X is called for an object that is not of type X, or of a type
4958 derived from X, the behavior is undefined.
4960 So we can assume that anything passed as 'this' is non-null, and
4961 optimize accordingly. */
4962 gcc_assert (TREE_CODE (parmtype
) == POINTER_TYPE
);
4963 /* Convert to the base in which the function was declared. */
4964 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
4965 converted_arg
= build_base_path (PLUS_EXPR
,
4967 cand
->conversion_path
,
4969 /* Check that the base class is accessible. */
4970 if (!accessible_base_p (TREE_TYPE (argtype
),
4971 BINFO_TYPE (cand
->conversion_path
), true))
4972 error ("%qT is not an accessible base of %qT",
4973 BINFO_TYPE (cand
->conversion_path
),
4974 TREE_TYPE (argtype
));
4975 /* If fn was found by a using declaration, the conversion path
4976 will be to the derived class, not the base declaring fn. We
4977 must convert from derived to base. */
4978 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
4979 TREE_TYPE (parmtype
), ba_unique
, NULL
);
4980 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
4983 argarray
[j
++] = converted_arg
;
4984 parm
= TREE_CHAIN (parm
);
4985 arg
= TREE_CHAIN (arg
);
4991 parm
= TREE_CHAIN (parm
), arg
= TREE_CHAIN (arg
), ++i
)
4993 tree type
= TREE_VALUE (parm
);
4997 /* Don't make a copy here if build_call is going to. */
4998 if (conv
->kind
== ck_rvalue
4999 && COMPLETE_TYPE_P (complete_type (type
))
5000 && !TREE_ADDRESSABLE (type
))
5001 conv
= conv
->u
.next
;
5003 val
= convert_like_with_context
5004 (conv
, TREE_VALUE (arg
), fn
, i
- is_method
);
5006 val
= convert_for_arg_passing (type
, val
);
5007 argarray
[j
++] = val
;
5010 /* Default arguments */
5011 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
5012 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
5013 TREE_PURPOSE (parm
),
5016 for (; arg
; arg
= TREE_CHAIN (arg
))
5018 tree a
= TREE_VALUE (arg
);
5019 if (magic_varargs_p (fn
))
5020 /* Do no conversions for magic varargs. */;
5022 a
= convert_arg_to_ellipsis (a
);
5026 gcc_assert (j
<= nargs
);
5029 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn
)),
5030 nargs
, argarray
, TYPE_ARG_TYPES (TREE_TYPE (fn
)));
5032 /* Avoid actually calling copy constructors and copy assignment operators,
5035 if (! flag_elide_constructors
)
5036 /* Do things the hard way. */;
5037 else if (cand
->num_convs
== 1
5038 && (DECL_COPY_CONSTRUCTOR_P (fn
)
5039 || DECL_MOVE_CONSTRUCTOR_P (fn
)))
5042 arg
= argarray
[num_artificial_parms_for (fn
)];
5044 /* Pull out the real argument, disregarding const-correctness. */
5046 while (TREE_CODE (targ
) == NOP_EXPR
5047 || TREE_CODE (targ
) == NON_LVALUE_EXPR
5048 || TREE_CODE (targ
) == CONVERT_EXPR
)
5049 targ
= TREE_OPERAND (targ
, 0);
5050 if (TREE_CODE (targ
) == ADDR_EXPR
)
5052 targ
= TREE_OPERAND (targ
, 0);
5053 if (!same_type_ignoring_top_level_qualifiers_p
5054 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
5063 arg
= build_indirect_ref (arg
, 0);
5065 /* [class.copy]: the copy constructor is implicitly defined even if
5066 the implementation elided its use. */
5067 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn
)))
5070 /* If we're creating a temp and we already have one, don't create a
5071 new one. If we're not creating a temp but we get one, use
5072 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5073 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5074 temp or an INIT_EXPR otherwise. */
5075 if (integer_zerop (TREE_VALUE (args
)))
5077 if (TREE_CODE (arg
) == TARGET_EXPR
)
5079 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5080 return build_target_expr_with_type (arg
, DECL_CONTEXT (fn
));
5082 else if (TREE_CODE (arg
) == TARGET_EXPR
5083 || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
))
5084 && !move_fn_p (fn
)))
5086 tree to
= stabilize_reference
5087 (build_indirect_ref (TREE_VALUE (args
), 0));
5089 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
5093 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
5095 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn
)))
5097 tree to
= stabilize_reference
5098 (build_indirect_ref (argarray
[0], 0));
5099 tree type
= TREE_TYPE (to
);
5100 tree as_base
= CLASSTYPE_AS_BASE (type
);
5103 if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
5105 arg
= build_indirect_ref (arg
, 0);
5106 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
5110 /* We must only copy the non-tail padding parts.
5111 Use __builtin_memcpy for the bitwise copy. */
5113 tree arg0
, arg1
, arg2
, t
;
5115 arg2
= TYPE_SIZE_UNIT (as_base
);
5117 arg0
= build_unary_op (ADDR_EXPR
, to
, 0);
5118 t
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
5119 t
= build_call_n (t
, 3, arg0
, arg1
, arg2
);
5121 t
= convert (TREE_TYPE (arg0
), t
);
5122 val
= build_indirect_ref (t
, 0);
5130 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
5133 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
5136 gcc_assert (binfo
&& binfo
!= error_mark_node
);
5138 /* Warn about deprecated virtual functions now, since we're about
5139 to throw away the decl. */
5140 if (TREE_DEPRECATED (fn
))
5141 warn_deprecated_use (fn
);
5143 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1);
5144 if (TREE_SIDE_EFFECTS (argarray
[0]))
5145 argarray
[0] = save_expr (argarray
[0]);
5146 t
= build_pointer_type (TREE_TYPE (fn
));
5147 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
5148 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
5150 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
5153 else if (DECL_INLINE (fn
))
5154 fn
= inline_conversion (fn
);
5156 fn
= build_addr_func (fn
);
5158 return build_cxx_call (fn
, nargs
, argarray
);
5161 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5162 This function performs no overload resolution, conversion, or other
5163 high-level operations. */
5166 build_cxx_call (tree fn
, int nargs
, tree
*argarray
)
5170 fn
= build_call_a (fn
, nargs
, argarray
);
5172 /* If this call might throw an exception, note that fact. */
5173 fndecl
= get_callee_fndecl (fn
);
5174 if ((!fndecl
|| !TREE_NOTHROW (fndecl
))
5175 && at_function_scope_p ()
5177 cp_function_chain
->can_throw
= 1;
5179 /* Some built-in function calls will be evaluated at compile-time in
5181 fn
= fold_if_not_in_template (fn
);
5183 if (VOID_TYPE_P (TREE_TYPE (fn
)))
5186 fn
= require_complete_type (fn
);
5187 if (fn
== error_mark_node
)
5188 return error_mark_node
;
5190 if (IS_AGGR_TYPE (TREE_TYPE (fn
)))
5191 fn
= build_cplus_new (TREE_TYPE (fn
), fn
);
5192 return convert_from_reference (fn
);
5195 static GTY(()) tree java_iface_lookup_fn
;
5197 /* Make an expression which yields the address of the Java interface
5198 method FN. This is achieved by generating a call to libjava's
5199 _Jv_LookupInterfaceMethodIdx(). */
5202 build_java_interface_fn_ref (tree fn
, tree instance
)
5204 tree lookup_fn
, method
, idx
;
5205 tree klass_ref
, iface
, iface_ref
;
5208 if (!java_iface_lookup_fn
)
5210 tree endlink
= build_void_list_node ();
5211 tree t
= tree_cons (NULL_TREE
, ptr_type_node
,
5212 tree_cons (NULL_TREE
, ptr_type_node
,
5213 tree_cons (NULL_TREE
, java_int_type_node
,
5215 java_iface_lookup_fn
5216 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5217 build_function_type (ptr_type_node
, t
),
5218 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
5221 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5222 This is the first entry in the vtable. */
5223 klass_ref
= build_vtbl_ref (build_indirect_ref (instance
, 0),
5226 /* Get the java.lang.Class pointer for the interface being called. */
5227 iface
= DECL_CONTEXT (fn
);
5228 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
5229 if (!iface_ref
|| TREE_CODE (iface_ref
) != VAR_DECL
5230 || DECL_CONTEXT (iface_ref
) != iface
)
5232 error ("could not find class$ field in java interface type %qT",
5234 return error_mark_node
;
5236 iface_ref
= build_address (iface_ref
);
5237 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
5239 /* Determine the itable index of FN. */
5241 for (method
= TYPE_METHODS (iface
); method
; method
= TREE_CHAIN (method
))
5243 if (!DECL_VIRTUAL_P (method
))
5249 idx
= build_int_cst (NULL_TREE
, i
);
5251 lookup_fn
= build1 (ADDR_EXPR
,
5252 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
5253 java_iface_lookup_fn
);
5254 return build_call_nary (ptr_type_node
, lookup_fn
,
5255 3, klass_ref
, iface_ref
, idx
);
5258 /* Returns the value to use for the in-charge parameter when making a
5259 call to a function with the indicated NAME.
5261 FIXME:Can't we find a neater way to do this mapping? */
5264 in_charge_arg_for_name (tree name
)
5266 if (name
== base_ctor_identifier
5267 || name
== base_dtor_identifier
)
5268 return integer_zero_node
;
5269 else if (name
== complete_ctor_identifier
)
5270 return integer_one_node
;
5271 else if (name
== complete_dtor_identifier
)
5272 return integer_two_node
;
5273 else if (name
== deleting_dtor_identifier
)
5274 return integer_three_node
;
5276 /* This function should only be called with one of the names listed
5282 /* Build a call to a constructor, destructor, or an assignment
5283 operator for INSTANCE, an expression with class type. NAME
5284 indicates the special member function to call; ARGS are the
5285 arguments. BINFO indicates the base of INSTANCE that is to be
5286 passed as the `this' parameter to the member function called.
5288 FLAGS are the LOOKUP_* flags to use when processing the call.
5290 If NAME indicates a complete object constructor, INSTANCE may be
5291 NULL_TREE. In this case, the caller will call build_cplus_new to
5292 store the newly constructed object into a VAR_DECL. */
5295 build_special_member_call (tree instance
, tree name
, tree args
,
5296 tree binfo
, int flags
)
5299 /* The type of the subobject to be constructed or destroyed. */
5302 gcc_assert (name
== complete_ctor_identifier
5303 || name
== base_ctor_identifier
5304 || name
== complete_dtor_identifier
5305 || name
== base_dtor_identifier
5306 || name
== deleting_dtor_identifier
5307 || name
== ansi_assopname (NOP_EXPR
));
5310 /* Resolve the name. */
5311 if (!complete_type_or_else (binfo
, NULL_TREE
))
5312 return error_mark_node
;
5314 binfo
= TYPE_BINFO (binfo
);
5317 gcc_assert (binfo
!= NULL_TREE
);
5319 class_type
= BINFO_TYPE (binfo
);
5321 /* Handle the special case where INSTANCE is NULL_TREE. */
5322 if (name
== complete_ctor_identifier
&& !instance
)
5324 instance
= build_int_cst (build_pointer_type (class_type
), 0);
5325 instance
= build1 (INDIRECT_REF
, class_type
, instance
);
5329 if (name
== complete_dtor_identifier
5330 || name
== base_dtor_identifier
5331 || name
== deleting_dtor_identifier
)
5332 gcc_assert (args
== NULL_TREE
);
5334 /* Convert to the base class, if necessary. */
5335 if (!same_type_ignoring_top_level_qualifiers_p
5336 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
5338 if (name
!= ansi_assopname (NOP_EXPR
))
5339 /* For constructors and destructors, either the base is
5340 non-virtual, or it is virtual but we are doing the
5341 conversion from a constructor or destructor for the
5342 complete object. In either case, we can convert
5344 instance
= convert_to_base_statically (instance
, binfo
);
5346 /* However, for assignment operators, we must convert
5347 dynamically if the base is virtual. */
5348 instance
= build_base_path (PLUS_EXPR
, instance
,
5349 binfo
, /*nonnull=*/1);
5353 gcc_assert (instance
!= NULL_TREE
);
5355 fns
= lookup_fnfields (binfo
, name
, 1);
5357 /* When making a call to a constructor or destructor for a subobject
5358 that uses virtual base classes, pass down a pointer to a VTT for
5360 if ((name
== base_ctor_identifier
5361 || name
== base_dtor_identifier
)
5362 && CLASSTYPE_VBASECLASSES (class_type
))
5367 /* If the current function is a complete object constructor
5368 or destructor, then we fetch the VTT directly.
5369 Otherwise, we look it up using the VTT we were given. */
5370 vtt
= TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
5371 vtt
= decay_conversion (vtt
);
5372 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
5373 build2 (EQ_EXPR
, boolean_type_node
,
5374 current_in_charge_parm
, integer_zero_node
),
5377 gcc_assert (BINFO_SUBVTT_INDEX (binfo
));
5378 sub_vtt
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (vtt
), vtt
,
5379 BINFO_SUBVTT_INDEX (binfo
));
5381 args
= tree_cons (NULL_TREE
, sub_vtt
, args
);
5384 return build_new_method_call (instance
, fns
, args
,
5385 TYPE_BINFO (BINFO_TYPE (binfo
)),
5386 flags
, /*fn=*/NULL
);
5389 /* Return the NAME, as a C string. The NAME indicates a function that
5390 is a member of TYPE. *FREE_P is set to true if the caller must
5391 free the memory returned.
5393 Rather than go through all of this, we should simply set the names
5394 of constructors and destructors appropriately, and dispense with
5395 ctor_identifier, dtor_identifier, etc. */
5398 name_as_c_string (tree name
, tree type
, bool *free_p
)
5402 /* Assume that we will not allocate memory. */
5404 /* Constructors and destructors are special. */
5405 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
5408 = CONST_CAST (char *, IDENTIFIER_POINTER (constructor_name (type
)));
5409 /* For a destructor, add the '~'. */
5410 if (name
== complete_dtor_identifier
5411 || name
== base_dtor_identifier
5412 || name
== deleting_dtor_identifier
)
5414 pretty_name
= concat ("~", pretty_name
, NULL
);
5415 /* Remember that we need to free the memory allocated. */
5419 else if (IDENTIFIER_TYPENAME_P (name
))
5421 pretty_name
= concat ("operator ",
5422 type_as_string (TREE_TYPE (name
),
5423 TFF_PLAIN_IDENTIFIER
),
5425 /* Remember that we need to free the memory allocated. */
5429 pretty_name
= CONST_CAST (char *, IDENTIFIER_POINTER (name
));
5434 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5435 be set, upon return, to the function called. */
5438 build_new_method_call (tree instance
, tree fns
, tree args
,
5439 tree conversion_path
, int flags
,
5442 struct z_candidate
*candidates
= 0, *cand
;
5443 tree explicit_targs
= NULL_TREE
;
5444 tree basetype
= NULL_TREE
;
5447 tree mem_args
= NULL_TREE
, instance_ptr
;
5453 int template_only
= 0;
5460 gcc_assert (instance
!= NULL_TREE
);
5462 /* We don't know what function we're going to call, yet. */
5466 if (error_operand_p (instance
)
5467 || error_operand_p (fns
)
5468 || args
== error_mark_node
)
5469 return error_mark_node
;
5471 if (!BASELINK_P (fns
))
5473 error ("call to non-function %qD", fns
);
5474 return error_mark_node
;
5477 orig_instance
= instance
;
5481 /* Dismantle the baselink to collect all the information we need. */
5482 if (!conversion_path
)
5483 conversion_path
= BASELINK_BINFO (fns
);
5484 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
5485 optype
= BASELINK_OPTYPE (fns
);
5486 fns
= BASELINK_FUNCTIONS (fns
);
5487 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
5489 explicit_targs
= TREE_OPERAND (fns
, 1);
5490 fns
= TREE_OPERAND (fns
, 0);
5493 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
5494 || TREE_CODE (fns
) == TEMPLATE_DECL
5495 || TREE_CODE (fns
) == OVERLOAD
);
5496 fn
= get_first_fn (fns
);
5497 name
= DECL_NAME (fn
);
5499 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
5500 gcc_assert (CLASS_TYPE_P (basetype
));
5502 if (processing_template_decl
)
5504 instance
= build_non_dependent_expr (instance
);
5505 args
= build_non_dependent_args (orig_args
);
5508 /* The USER_ARGS are the arguments we will display to users if an
5509 error occurs. The USER_ARGS should not include any
5510 compiler-generated arguments. The "this" pointer hasn't been
5511 added yet. However, we must remove the VTT pointer if this is a
5512 call to a base-class constructor or destructor. */
5514 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
5516 /* Callers should explicitly indicate whether they want to construct
5517 the complete object or just the part without virtual bases. */
5518 gcc_assert (name
!= ctor_identifier
);
5519 /* Similarly for destructors. */
5520 gcc_assert (name
!= dtor_identifier
);
5521 /* Remove the VTT pointer, if present. */
5522 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
5523 && CLASSTYPE_VBASECLASSES (basetype
))
5524 user_args
= TREE_CHAIN (user_args
);
5527 /* Process the argument list. */
5528 args
= resolve_args (args
);
5529 if (args
== error_mark_node
)
5530 return error_mark_node
;
5532 instance_ptr
= build_this (instance
);
5534 /* It's OK to call destructors and constructors on cv-qualified objects.
5535 Therefore, convert the INSTANCE_PTR to the unqualified type, if
5537 if (DECL_DESTRUCTOR_P (fn
)
5538 || DECL_CONSTRUCTOR_P (fn
))
5540 tree type
= build_pointer_type (basetype
);
5541 if (!same_type_p (type
, TREE_TYPE (instance_ptr
)))
5542 instance_ptr
= build_nop (type
, instance_ptr
);
5544 if (DECL_DESTRUCTOR_P (fn
))
5545 name
= complete_dtor_identifier
;
5547 class_type
= (conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
);
5548 mem_args
= tree_cons (NULL_TREE
, instance_ptr
, args
);
5550 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5551 p
= conversion_obstack_alloc (0);
5553 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
5555 tree t
= OVL_CURRENT (fn
);
5558 /* We can end up here for copy-init of same or base class. */
5559 if ((flags
& LOOKUP_ONLYCONVERTING
)
5560 && DECL_NONCONVERTING_P (t
))
5563 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t
))
5564 this_arglist
= mem_args
;
5566 this_arglist
= args
;
5568 if (TREE_CODE (t
) == TEMPLATE_DECL
)
5569 /* A member template. */
5570 add_template_candidate (&candidates
, t
,
5573 this_arglist
, optype
,
5578 else if (! template_only
)
5579 add_function_candidate (&candidates
, t
,
5587 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
5590 if (!COMPLETE_TYPE_P (basetype
))
5591 cxx_incomplete_type_error (instance_ptr
, basetype
);
5597 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
5598 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5599 basetype
, pretty_name
, user_args
,
5600 TREE_TYPE (TREE_TYPE (instance_ptr
)));
5604 print_z_candidates (candidates
);
5605 call
= error_mark_node
;
5609 cand
= tourney (candidates
);
5615 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
5616 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name
,
5618 print_z_candidates (candidates
);
5621 call
= error_mark_node
;
5627 if (!(flags
& LOOKUP_NONVIRTUAL
)
5628 && DECL_PURE_VIRTUAL_P (fn
)
5629 && instance
== current_class_ref
5630 && (DECL_CONSTRUCTOR_P (current_function_decl
)
5631 || DECL_DESTRUCTOR_P (current_function_decl
)))
5632 /* This is not an error, it is runtime undefined
5634 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
) ?
5635 "abstract virtual %q#D called from constructor"
5636 : "abstract virtual %q#D called from destructor"),
5639 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
5640 && is_dummy_object (instance_ptr
))
5642 error ("cannot call member function %qD without object",
5644 call
= error_mark_node
;
5648 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
5649 && resolves_to_fixed_type_p (instance
, 0))
5650 flags
|= LOOKUP_NONVIRTUAL
;
5651 /* Now we know what function is being called. */
5654 /* Build the actual CALL_EXPR. */
5655 call
= build_over_call (cand
, flags
);
5656 /* In an expression of the form `a->f()' where `f' turns
5657 out to be a static member function, `a' is
5658 none-the-less evaluated. */
5659 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
5660 && !is_dummy_object (instance_ptr
)
5661 && TREE_SIDE_EFFECTS (instance_ptr
))
5662 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
5663 instance_ptr
, call
);
5664 else if (call
!= error_mark_node
5665 && DECL_DESTRUCTOR_P (cand
->fn
)
5666 && !VOID_TYPE_P (TREE_TYPE (call
)))
5667 /* An explicit call of the form "x->~X()" has type
5668 "void". However, on platforms where destructors
5669 return "this" (i.e., those where
5670 targetm.cxx.cdtor_returns_this is true), such calls
5671 will appear to have a return value of pointer type
5672 to the low-level call machinery. We do not want to
5673 change the low-level machinery, since we want to be
5674 able to optimize "delete f()" on such platforms as
5675 "operator delete(~X(f()))" (rather than generating
5676 "t = f(), ~X(t), operator delete (t)"). */
5677 call
= build_nop (void_type_node
, call
);
5682 if (processing_template_decl
&& call
!= error_mark_node
)
5683 call
= (build_min_non_dep_call_list
5685 build_min_nt (COMPONENT_REF
, orig_instance
, orig_fns
, NULL_TREE
),
5688 /* Free all the conversions we allocated. */
5689 obstack_free (&conversion_obstack
, p
);
5694 /* Returns true iff standard conversion sequence ICS1 is a proper
5695 subsequence of ICS2. */
5698 is_subseq (conversion
*ics1
, conversion
*ics2
)
5700 /* We can assume that a conversion of the same code
5701 between the same types indicates a subsequence since we only get
5702 here if the types we are converting from are the same. */
5704 while (ics1
->kind
== ck_rvalue
5705 || ics1
->kind
== ck_lvalue
)
5706 ics1
= ics1
->u
.next
;
5710 while (ics2
->kind
== ck_rvalue
5711 || ics2
->kind
== ck_lvalue
)
5712 ics2
= ics2
->u
.next
;
5714 if (ics2
->kind
== ck_user
5715 || ics2
->kind
== ck_ambig
5716 || ics2
->kind
== ck_identity
)
5717 /* At this point, ICS1 cannot be a proper subsequence of
5718 ICS2. We can get a USER_CONV when we are comparing the
5719 second standard conversion sequence of two user conversion
5723 ics2
= ics2
->u
.next
;
5725 if (ics2
->kind
== ics1
->kind
5726 && same_type_p (ics2
->type
, ics1
->type
)
5727 && same_type_p (ics2
->u
.next
->type
,
5728 ics1
->u
.next
->type
))
5733 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5734 be any _TYPE nodes. */
5737 is_properly_derived_from (tree derived
, tree base
)
5739 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived
))
5740 || !IS_AGGR_TYPE_CODE (TREE_CODE (base
)))
5743 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5744 considers every class derived from itself. */
5745 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
5746 && DERIVED_FROM_P (base
, derived
));
5749 /* We build the ICS for an implicit object parameter as a pointer
5750 conversion sequence. However, such a sequence should be compared
5751 as if it were a reference conversion sequence. If ICS is the
5752 implicit conversion sequence for an implicit object parameter,
5753 modify it accordingly. */
5756 maybe_handle_implicit_object (conversion
**ics
)
5760 /* [over.match.funcs]
5762 For non-static member functions, the type of the
5763 implicit object parameter is "reference to cv X"
5764 where X is the class of which the function is a
5765 member and cv is the cv-qualification on the member
5766 function declaration. */
5767 conversion
*t
= *ics
;
5768 tree reference_type
;
5770 /* The `this' parameter is a pointer to a class type. Make the
5771 implicit conversion talk about a reference to that same class
5773 reference_type
= TREE_TYPE (t
->type
);
5774 reference_type
= build_reference_type (reference_type
);
5776 if (t
->kind
== ck_qual
)
5778 if (t
->kind
== ck_ptr
)
5780 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
5781 t
= direct_reference_binding (reference_type
, t
);
5783 t
->rvaluedness_matches_p
= 0;
5788 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5789 and return the initial reference binding conversion. Otherwise,
5790 leave *ICS unchanged and return NULL. */
5793 maybe_handle_ref_bind (conversion
**ics
)
5795 if ((*ics
)->kind
== ck_ref_bind
)
5797 conversion
*old_ics
= *ics
;
5798 *ics
= old_ics
->u
.next
;
5799 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
5800 (*ics
)->bad_p
= old_ics
->bad_p
;
5807 /* Compare two implicit conversion sequences according to the rules set out in
5808 [over.ics.rank]. Return values:
5810 1: ics1 is better than ics2
5811 -1: ics2 is better than ics1
5812 0: ics1 and ics2 are indistinguishable */
5815 compare_ics (conversion
*ics1
, conversion
*ics2
)
5821 tree deref_from_type1
= NULL_TREE
;
5822 tree deref_from_type2
= NULL_TREE
;
5823 tree deref_to_type1
= NULL_TREE
;
5824 tree deref_to_type2
= NULL_TREE
;
5825 conversion_rank rank1
, rank2
;
5827 /* REF_BINDING is nonzero if the result of the conversion sequence
5828 is a reference type. In that case REF_CONV is the reference
5829 binding conversion. */
5830 conversion
*ref_conv1
;
5831 conversion
*ref_conv2
;
5833 /* Handle implicit object parameters. */
5834 maybe_handle_implicit_object (&ics1
);
5835 maybe_handle_implicit_object (&ics2
);
5837 /* Handle reference parameters. */
5838 ref_conv1
= maybe_handle_ref_bind (&ics1
);
5839 ref_conv2
= maybe_handle_ref_bind (&ics2
);
5843 When comparing the basic forms of implicit conversion sequences (as
5844 defined in _over.best.ics_)
5846 --a standard conversion sequence (_over.ics.scs_) is a better
5847 conversion sequence than a user-defined conversion sequence
5848 or an ellipsis conversion sequence, and
5850 --a user-defined conversion sequence (_over.ics.user_) is a
5851 better conversion sequence than an ellipsis conversion sequence
5852 (_over.ics.ellipsis_). */
5853 rank1
= CONVERSION_RANK (ics1
);
5854 rank2
= CONVERSION_RANK (ics2
);
5858 else if (rank1
< rank2
)
5861 if (rank1
== cr_bad
)
5863 /* XXX Isn't this an extension? */
5864 /* Both ICS are bad. We try to make a decision based on what
5865 would have happened if they'd been good. */
5866 if (ics1
->user_conv_p
> ics2
->user_conv_p
5867 || ics1
->rank
> ics2
->rank
)
5869 else if (ics1
->user_conv_p
< ics2
->user_conv_p
5870 || ics1
->rank
< ics2
->rank
)
5873 /* We couldn't make up our minds; try to figure it out below. */
5876 if (ics1
->ellipsis_p
)
5877 /* Both conversions are ellipsis conversions. */
5880 /* User-defined conversion sequence U1 is a better conversion sequence
5881 than another user-defined conversion sequence U2 if they contain the
5882 same user-defined conversion operator or constructor and if the sec-
5883 ond standard conversion sequence of U1 is better than the second
5884 standard conversion sequence of U2. */
5886 if (ics1
->user_conv_p
)
5891 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= t1
->u
.next
)
5892 if (t1
->kind
== ck_ambig
)
5894 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= t2
->u
.next
)
5895 if (t2
->kind
== ck_ambig
)
5898 if (t1
->cand
->fn
!= t2
->cand
->fn
)
5901 /* We can just fall through here, after setting up
5902 FROM_TYPE1 and FROM_TYPE2. */
5903 from_type1
= t1
->type
;
5904 from_type2
= t2
->type
;
5911 /* We're dealing with two standard conversion sequences.
5915 Standard conversion sequence S1 is a better conversion
5916 sequence than standard conversion sequence S2 if
5918 --S1 is a proper subsequence of S2 (comparing the conversion
5919 sequences in the canonical form defined by _over.ics.scs_,
5920 excluding any Lvalue Transformation; the identity
5921 conversion sequence is considered to be a subsequence of
5922 any non-identity conversion sequence */
5925 while (t1
->kind
!= ck_identity
)
5927 from_type1
= t1
->type
;
5930 while (t2
->kind
!= ck_identity
)
5932 from_type2
= t2
->type
;
5935 if (same_type_p (from_type1
, from_type2
))
5937 if (is_subseq (ics1
, ics2
))
5939 if (is_subseq (ics2
, ics1
))
5942 /* Otherwise, one sequence cannot be a subsequence of the other; they
5943 don't start with the same type. This can happen when comparing the
5944 second standard conversion sequence in two user-defined conversion
5951 --the rank of S1 is better than the rank of S2 (by the rules
5954 Standard conversion sequences are ordered by their ranks: an Exact
5955 Match is a better conversion than a Promotion, which is a better
5956 conversion than a Conversion.
5958 Two conversion sequences with the same rank are indistinguishable
5959 unless one of the following rules applies:
5961 --A conversion that is not a conversion of a pointer, or pointer
5962 to member, to bool is better than another conversion that is such
5965 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5966 so that we do not have to check it explicitly. */
5967 if (ics1
->rank
< ics2
->rank
)
5969 else if (ics2
->rank
< ics1
->rank
)
5972 to_type1
= ics1
->type
;
5973 to_type2
= ics2
->type
;
5975 if (TYPE_PTR_P (from_type1
)
5976 && TYPE_PTR_P (from_type2
)
5977 && TYPE_PTR_P (to_type1
)
5978 && TYPE_PTR_P (to_type2
))
5980 deref_from_type1
= TREE_TYPE (from_type1
);
5981 deref_from_type2
= TREE_TYPE (from_type2
);
5982 deref_to_type1
= TREE_TYPE (to_type1
);
5983 deref_to_type2
= TREE_TYPE (to_type2
);
5985 /* The rules for pointers to members A::* are just like the rules
5986 for pointers A*, except opposite: if B is derived from A then
5987 A::* converts to B::*, not vice versa. For that reason, we
5988 switch the from_ and to_ variables here. */
5989 else if ((TYPE_PTRMEM_P (from_type1
) && TYPE_PTRMEM_P (from_type2
)
5990 && TYPE_PTRMEM_P (to_type1
) && TYPE_PTRMEM_P (to_type2
))
5991 || (TYPE_PTRMEMFUNC_P (from_type1
)
5992 && TYPE_PTRMEMFUNC_P (from_type2
)
5993 && TYPE_PTRMEMFUNC_P (to_type1
)
5994 && TYPE_PTRMEMFUNC_P (to_type2
)))
5996 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
5997 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
5998 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
5999 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
6002 if (deref_from_type1
!= NULL_TREE
6003 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1
))
6004 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2
)))
6006 /* This was one of the pointer or pointer-like conversions.
6010 --If class B is derived directly or indirectly from class A,
6011 conversion of B* to A* is better than conversion of B* to
6012 void*, and conversion of A* to void* is better than
6013 conversion of B* to void*. */
6014 if (TREE_CODE (deref_to_type1
) == VOID_TYPE
6015 && TREE_CODE (deref_to_type2
) == VOID_TYPE
)
6017 if (is_properly_derived_from (deref_from_type1
,
6020 else if (is_properly_derived_from (deref_from_type2
,
6024 else if (TREE_CODE (deref_to_type1
) == VOID_TYPE
6025 || TREE_CODE (deref_to_type2
) == VOID_TYPE
)
6027 if (same_type_p (deref_from_type1
, deref_from_type2
))
6029 if (TREE_CODE (deref_to_type2
) == VOID_TYPE
)
6031 if (is_properly_derived_from (deref_from_type1
,
6035 /* We know that DEREF_TO_TYPE1 is `void' here. */
6036 else if (is_properly_derived_from (deref_from_type1
,
6041 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1
))
6042 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2
)))
6046 --If class B is derived directly or indirectly from class A
6047 and class C is derived directly or indirectly from B,
6049 --conversion of C* to B* is better than conversion of C* to
6052 --conversion of B* to A* is better than conversion of C* to
6054 if (same_type_p (deref_from_type1
, deref_from_type2
))
6056 if (is_properly_derived_from (deref_to_type1
,
6059 else if (is_properly_derived_from (deref_to_type2
,
6063 else if (same_type_p (deref_to_type1
, deref_to_type2
))
6065 if (is_properly_derived_from (deref_from_type2
,
6068 else if (is_properly_derived_from (deref_from_type1
,
6074 else if (CLASS_TYPE_P (non_reference (from_type1
))
6075 && same_type_p (from_type1
, from_type2
))
6077 tree from
= non_reference (from_type1
);
6081 --binding of an expression of type C to a reference of type
6082 B& is better than binding an expression of type C to a
6083 reference of type A&
6085 --conversion of C to B is better than conversion of C to A, */
6086 if (is_properly_derived_from (from
, to_type1
)
6087 && is_properly_derived_from (from
, to_type2
))
6089 if (is_properly_derived_from (to_type1
, to_type2
))
6091 else if (is_properly_derived_from (to_type2
, to_type1
))
6095 else if (CLASS_TYPE_P (non_reference (to_type1
))
6096 && same_type_p (to_type1
, to_type2
))
6098 tree to
= non_reference (to_type1
);
6102 --binding of an expression of type B to a reference of type
6103 A& is better than binding an expression of type C to a
6104 reference of type A&,
6106 --conversion of B to A is better than conversion of C to A */
6107 if (is_properly_derived_from (from_type1
, to
)
6108 && is_properly_derived_from (from_type2
, to
))
6110 if (is_properly_derived_from (from_type2
, from_type1
))
6112 else if (is_properly_derived_from (from_type1
, from_type2
))
6119 --S1 and S2 differ only in their qualification conversion and yield
6120 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6121 qualification signature of type T1 is a proper subset of the cv-
6122 qualification signature of type T2 */
6123 if (ics1
->kind
== ck_qual
6124 && ics2
->kind
== ck_qual
6125 && same_type_p (from_type1
, from_type2
))
6127 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
6134 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6135 to an implicit object parameter, and either S1 binds an lvalue reference
6136 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6137 reference to an rvalue and S2 binds an lvalue reference
6138 (C++0x draft standard, 13.3.3.2)
6140 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6141 types to which the references refer are the same type except for
6142 top-level cv-qualifiers, and the type to which the reference
6143 initialized by S2 refers is more cv-qualified than the type to
6144 which the reference initialized by S1 refers */
6146 if (ref_conv1
&& ref_conv2
)
6148 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
6149 && (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
6150 != TYPE_REF_IS_RVALUE (ref_conv2
->type
)))
6152 if (ref_conv1
->rvaluedness_matches_p
)
6154 if (ref_conv2
->rvaluedness_matches_p
)
6158 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
6159 return comp_cv_qualification (TREE_TYPE (ref_conv2
->type
),
6160 TREE_TYPE (ref_conv1
->type
));
6163 /* Neither conversion sequence is better than the other. */
6167 /* The source type for this standard conversion sequence. */
6170 source_type (conversion
*t
)
6172 for (;; t
= t
->u
.next
)
6174 if (t
->kind
== ck_user
6175 || t
->kind
== ck_ambig
6176 || t
->kind
== ck_identity
)
6182 /* Note a warning about preferring WINNER to LOSER. We do this by storing
6183 a pointer to LOSER and re-running joust to produce the warning if WINNER
6184 is actually used. */
6187 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
6189 candidate_warning
*cw
= (candidate_warning
*)
6190 conversion_obstack_alloc (sizeof (candidate_warning
));
6192 cw
->next
= winner
->warnings
;
6193 winner
->warnings
= cw
;
6196 /* Compare two candidates for overloading as described in
6197 [over.match.best]. Return values:
6199 1: cand1 is better than cand2
6200 -1: cand2 is better than cand1
6201 0: cand1 and cand2 are indistinguishable */
6204 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
)
6207 int off1
= 0, off2
= 0;
6211 /* Candidates that involve bad conversions are always worse than those
6213 if (cand1
->viable
> cand2
->viable
)
6215 if (cand1
->viable
< cand2
->viable
)
6218 /* If we have two pseudo-candidates for conversions to the same type,
6219 or two candidates for the same function, arbitrarily pick one. */
6220 if (cand1
->fn
== cand2
->fn
6221 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
6224 /* a viable function F1
6225 is defined to be a better function than another viable function F2 if
6226 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6227 ICSi(F2), and then */
6229 /* for some argument j, ICSj(F1) is a better conversion sequence than
6232 /* For comparing static and non-static member functions, we ignore
6233 the implicit object parameter of the non-static function. The
6234 standard says to pretend that the static function has an object
6235 parm, but that won't work with operator overloading. */
6236 len
= cand1
->num_convs
;
6237 if (len
!= cand2
->num_convs
)
6239 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
6240 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
6242 gcc_assert (static_1
!= static_2
);
6253 for (i
= 0; i
< len
; ++i
)
6255 conversion
*t1
= cand1
->convs
[i
+ off1
];
6256 conversion
*t2
= cand2
->convs
[i
+ off2
];
6257 int comp
= compare_ics (t1
, t2
);
6262 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
6263 == cr_std
+ cr_promotion
)
6264 && t1
->kind
== ck_std
6265 && t2
->kind
== ck_std
6266 && TREE_CODE (t1
->type
) == INTEGER_TYPE
6267 && TREE_CODE (t2
->type
) == INTEGER_TYPE
6268 && (TYPE_PRECISION (t1
->type
)
6269 == TYPE_PRECISION (t2
->type
))
6270 && (TYPE_UNSIGNED (t1
->u
.next
->type
)
6271 || (TREE_CODE (t1
->u
.next
->type
)
6274 tree type
= t1
->u
.next
->type
;
6276 struct z_candidate
*w
, *l
;
6278 type1
= t1
->type
, type2
= t2
->type
,
6279 w
= cand1
, l
= cand2
;
6281 type1
= t2
->type
, type2
= t1
->type
,
6282 w
= cand2
, l
= cand1
;
6286 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
6287 type
, type1
, type2
);
6288 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
6294 if (winner
&& comp
!= winner
)
6303 /* warn about confusing overload resolution for user-defined conversions,
6304 either between a constructor and a conversion op, or between two
6306 if (winner
&& warn_conversion
&& cand1
->second_conv
6307 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
6308 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
6310 struct z_candidate
*w
, *l
;
6311 bool give_warning
= false;
6314 w
= cand1
, l
= cand2
;
6316 w
= cand2
, l
= cand1
;
6318 /* We don't want to complain about `X::operator T1 ()'
6319 beating `X::operator T2 () const', when T2 is a no less
6320 cv-qualified version of T1. */
6321 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
6322 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
6324 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
6325 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
6327 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
6332 if (!comp_ptr_ttypes (t
, f
))
6333 give_warning
= true;
6336 give_warning
= true;
6342 tree source
= source_type (w
->convs
[0]);
6343 if (! DECL_CONSTRUCTOR_P (w
->fn
))
6344 source
= TREE_TYPE (source
);
6345 warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
);
6346 warning (OPT_Wconversion
, " for conversion from %qT to %qT",
6347 source
, w
->second_conv
->type
);
6348 inform (" because conversion sequence for the argument is better");
6358 F1 is a non-template function and F2 is a template function
6361 if (!cand1
->template_decl
&& cand2
->template_decl
)
6363 else if (cand1
->template_decl
&& !cand2
->template_decl
)
6367 F1 and F2 are template functions and the function template for F1 is
6368 more specialized than the template for F2 according to the partial
6371 if (cand1
->template_decl
&& cand2
->template_decl
)
6373 winner
= more_specialized_fn
6374 (TI_TEMPLATE (cand1
->template_decl
),
6375 TI_TEMPLATE (cand2
->template_decl
),
6376 /* [temp.func.order]: The presence of unused ellipsis and default
6377 arguments has no effect on the partial ordering of function
6378 templates. add_function_candidate() will not have
6379 counted the "this" argument for constructors. */
6380 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
6386 the context is an initialization by user-defined conversion (see
6387 _dcl.init_ and _over.match.user_) and the standard conversion
6388 sequence from the return type of F1 to the destination type (i.e.,
6389 the type of the entity being initialized) is a better conversion
6390 sequence than the standard conversion sequence from the return type
6391 of F2 to the destination type. */
6393 if (cand1
->second_conv
)
6395 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
6400 /* Check whether we can discard a builtin candidate, either because we
6401 have two identical ones or matching builtin and non-builtin candidates.
6403 (Pedantically in the latter case the builtin which matched the user
6404 function should not be added to the overload set, but we spot it here.
6407 ... the builtin candidates include ...
6408 - do not have the same parameter type list as any non-template
6409 non-member candidate. */
6411 if (TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
6412 || TREE_CODE (cand2
->fn
) == IDENTIFIER_NODE
)
6414 for (i
= 0; i
< len
; ++i
)
6415 if (!same_type_p (cand1
->convs
[i
]->type
,
6416 cand2
->convs
[i
]->type
))
6418 if (i
== cand1
->num_convs
)
6420 if (cand1
->fn
== cand2
->fn
)
6421 /* Two built-in candidates; arbitrarily pick one. */
6423 else if (TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
)
6424 /* cand1 is built-in; prefer cand2. */
6427 /* cand2 is built-in; prefer cand1. */
6432 /* If the two functions are the same (this can happen with declarations
6433 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6434 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
6435 && equal_functions (cand1
->fn
, cand2
->fn
))
6440 /* Extension: If the worst conversion for one candidate is worse than the
6441 worst conversion for the other, take the first. */
6444 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
6445 struct z_candidate
*w
= 0, *l
= 0;
6447 for (i
= 0; i
< len
; ++i
)
6449 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
6450 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
6451 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
6452 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
6455 winner
= 1, w
= cand1
, l
= cand2
;
6457 winner
= -1, w
= cand2
, l
= cand1
;
6463 ISO C++ says that these are ambiguous, even \
6464 though the worst conversion for the first is better than \
6465 the worst conversion for the second:");
6466 print_z_candidate (_("candidate 1:"), w
);
6467 print_z_candidate (_("candidate 2:"), l
);
6475 gcc_assert (!winner
);
6479 /* Given a list of candidates for overloading, find the best one, if any.
6480 This algorithm has a worst case of O(2n) (winner is last), and a best
6481 case of O(n/2) (totally ambiguous); much better than a sorting
6484 static struct z_candidate
*
6485 tourney (struct z_candidate
*candidates
)
6487 struct z_candidate
*champ
= candidates
, *challenger
;
6489 int champ_compared_to_predecessor
= 0;
6491 /* Walk through the list once, comparing each current champ to the next
6492 candidate, knocking out a candidate or two with each comparison. */
6494 for (challenger
= champ
->next
; challenger
; )
6496 fate
= joust (champ
, challenger
, 0);
6498 challenger
= challenger
->next
;
6503 champ
= challenger
->next
;
6506 champ_compared_to_predecessor
= 0;
6511 champ_compared_to_predecessor
= 1;
6514 challenger
= champ
->next
;
6518 /* Make sure the champ is better than all the candidates it hasn't yet
6519 been compared to. */
6521 for (challenger
= candidates
;
6523 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
6524 challenger
= challenger
->next
)
6526 fate
= joust (champ
, challenger
, 0);
6534 /* Returns nonzero if things of type FROM can be converted to TO. */
6537 can_convert (tree to
, tree from
)
6539 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_NORMAL
);
6542 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6545 can_convert_arg (tree to
, tree from
, tree arg
, int flags
)
6551 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6552 p
= conversion_obstack_alloc (0);
6554 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
6556 ok_p
= (t
&& !t
->bad_p
);
6558 /* Free all the conversions we allocated. */
6559 obstack_free (&conversion_obstack
, p
);
6564 /* Like can_convert_arg, but allows dubious conversions as well. */
6567 can_convert_arg_bad (tree to
, tree from
, tree arg
)
6572 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6573 p
= conversion_obstack_alloc (0);
6574 /* Try to perform the conversion. */
6575 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
6577 /* Free all the conversions we allocated. */
6578 obstack_free (&conversion_obstack
, p
);
6583 /* Convert EXPR to TYPE. Return the converted expression.
6585 Note that we allow bad conversions here because by the time we get to
6586 this point we are committed to doing the conversion. If we end up
6587 doing a bad conversion, convert_like will complain. */
6590 perform_implicit_conversion (tree type
, tree expr
)
6595 if (error_operand_p (expr
))
6596 return error_mark_node
;
6598 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6599 p
= conversion_obstack_alloc (0);
6601 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
6606 error ("could not convert %qE to %qT", expr
, type
);
6607 expr
= error_mark_node
;
6609 else if (processing_template_decl
)
6611 /* In a template, we are only concerned about determining the
6612 type of non-dependent expressions, so we do not have to
6613 perform the actual conversion. */
6614 if (TREE_TYPE (expr
) != type
)
6615 expr
= build_nop (type
, expr
);
6618 expr
= convert_like (conv
, expr
);
6620 /* Free all the conversions we allocated. */
6621 obstack_free (&conversion_obstack
, p
);
6626 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6627 permitted. If the conversion is valid, the converted expression is
6628 returned. Otherwise, NULL_TREE is returned, except in the case
6629 that TYPE is a class type; in that case, an error is issued. If
6630 C_CAST_P is true, then this direction initialization is taking
6631 place as part of a static_cast being attempted as part of a C-style
6635 perform_direct_initialization_if_possible (tree type
,
6642 if (type
== error_mark_node
|| error_operand_p (expr
))
6643 return error_mark_node
;
6646 If the destination type is a (possibly cv-qualified) class type:
6648 -- If the initialization is direct-initialization ...,
6649 constructors are considered. ... If no constructor applies, or
6650 the overload resolution is ambiguous, the initialization is
6652 if (CLASS_TYPE_P (type
))
6654 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6655 build_tree_list (NULL_TREE
, expr
),
6656 type
, LOOKUP_NORMAL
);
6657 return build_cplus_new (type
, expr
);
6660 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6661 p
= conversion_obstack_alloc (0);
6663 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
6666 if (!conv
|| conv
->bad_p
)
6669 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
6670 /*issue_conversion_warnings=*/false,
6673 /* Free all the conversions we allocated. */
6674 obstack_free (&conversion_obstack
, p
);
6679 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6680 is being bound to a temporary. Create and return a new VAR_DECL
6681 with the indicated TYPE; this variable will store the value to
6682 which the reference is bound. */
6685 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
6689 /* Create the variable. */
6690 var
= create_temporary_var (type
);
6692 /* Register the variable. */
6693 if (TREE_STATIC (decl
))
6695 /* Namespace-scope or local static; give it a mangled name. */
6698 TREE_STATIC (var
) = 1;
6699 name
= mangle_ref_init_variable (decl
);
6700 DECL_NAME (var
) = name
;
6701 SET_DECL_ASSEMBLER_NAME (var
, name
);
6702 var
= pushdecl_top_level (var
);
6705 /* Create a new cleanup level if necessary. */
6706 maybe_push_cleanup_level (type
);
6711 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6712 initializing a variable of that TYPE. If DECL is non-NULL, it is
6713 the VAR_DECL being initialized with the EXPR. (In that case, the
6714 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6715 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6716 return, if *CLEANUP is no longer NULL, it will be an expression
6717 that should be pushed as a cleanup after the returned expression
6718 is used to initialize DECL.
6720 Return the converted expression. */
6723 initialize_reference (tree type
, tree expr
, tree decl
, tree
*cleanup
)
6728 if (type
== error_mark_node
|| error_operand_p (expr
))
6729 return error_mark_node
;
6731 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6732 p
= conversion_obstack_alloc (0);
6734 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
6736 if (!conv
|| conv
->bad_p
)
6738 if (!(TYPE_QUALS (TREE_TYPE (type
)) & TYPE_QUAL_CONST
)
6739 && !real_lvalue_p (expr
))
6740 error ("invalid initialization of non-const reference of "
6741 "type %qT from a temporary of type %qT",
6742 type
, TREE_TYPE (expr
));
6744 error ("invalid initialization of reference of type "
6745 "%qT from expression of type %qT", type
,
6747 return error_mark_node
;
6750 /* If DECL is non-NULL, then this special rule applies:
6754 The temporary to which the reference is bound or the temporary
6755 that is the complete object to which the reference is bound
6756 persists for the lifetime of the reference.
6758 The temporaries created during the evaluation of the expression
6759 initializing the reference, except the temporary to which the
6760 reference is bound, are destroyed at the end of the
6761 full-expression in which they are created.
6763 In that case, we store the converted expression into a new
6764 VAR_DECL in a new scope.
6766 However, we want to be careful not to create temporaries when
6767 they are not required. For example, given:
6770 struct D : public B {};
6774 there is no need to copy the return value from "f"; we can just
6775 extend its lifetime. Similarly, given:
6778 struct T { operator S(); };
6782 we can extend the lifetime of the return value of the conversion
6784 gcc_assert (conv
->kind
== ck_ref_bind
);
6788 tree base_conv_type
;
6790 /* Skip over the REF_BIND. */
6791 conv
= conv
->u
.next
;
6792 /* If the next conversion is a BASE_CONV, skip that too -- but
6793 remember that the conversion was required. */
6794 if (conv
->kind
== ck_base
)
6796 base_conv_type
= conv
->type
;
6797 conv
= conv
->u
.next
;
6800 base_conv_type
= NULL_TREE
;
6801 /* Perform the remainder of the conversion. */
6802 expr
= convert_like_real (conv
, expr
,
6803 /*fn=*/NULL_TREE
, /*argnum=*/0,
6805 /*issue_conversion_warnings=*/true,
6806 /*c_cast_p=*/false);
6807 if (error_operand_p (expr
))
6808 expr
= error_mark_node
;
6811 if (!real_lvalue_p (expr
))
6816 /* Create the temporary variable. */
6817 type
= TREE_TYPE (expr
);
6818 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
6819 layout_decl (var
, 0);
6820 /* If the rvalue is the result of a function call it will be
6821 a TARGET_EXPR. If it is some other construct (such as a
6822 member access expression where the underlying object is
6823 itself the result of a function call), turn it into a
6824 TARGET_EXPR here. It is important that EXPR be a
6825 TARGET_EXPR below since otherwise the INIT_EXPR will
6826 attempt to make a bitwise copy of EXPR to initialize
6828 if (TREE_CODE (expr
) != TARGET_EXPR
)
6829 expr
= get_target_expr (expr
);
6830 /* Create the INIT_EXPR that will initialize the temporary
6832 init
= build2 (INIT_EXPR
, type
, var
, expr
);
6833 if (at_function_scope_p ())
6835 add_decl_expr (var
);
6837 if (TREE_STATIC (var
))
6838 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
6840 *cleanup
= cxx_maybe_build_cleanup (var
);
6842 /* We must be careful to destroy the temporary only
6843 after its initialization has taken place. If the
6844 initialization throws an exception, then the
6845 destructor should not be run. We cannot simply
6846 transform INIT into something like:
6848 (INIT, ({ CLEANUP_STMT; }))
6850 because emit_local_var always treats the
6851 initializer as a full-expression. Thus, the
6852 destructor would run too early; it would run at the
6853 end of initializing the reference variable, rather
6854 than at the end of the block enclosing the
6857 The solution is to pass back a cleanup expression
6858 which the caller is responsible for attaching to
6859 the statement tree. */
6863 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
6864 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6865 static_aggregates
= tree_cons (NULL_TREE
, var
,
6868 /* Use its address to initialize the reference variable. */
6869 expr
= build_address (var
);
6871 expr
= convert_to_base (expr
,
6872 build_pointer_type (base_conv_type
),
6873 /*check_access=*/true,
6875 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), init
, expr
);
6878 /* Take the address of EXPR. */
6879 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
6880 /* If a BASE_CONV was required, perform it now. */
6882 expr
= (perform_implicit_conversion
6883 (build_pointer_type (base_conv_type
), expr
));
6884 expr
= build_nop (type
, expr
);
6888 /* Perform the conversion. */
6889 expr
= convert_like (conv
, expr
);
6891 /* Free all the conversions we allocated. */
6892 obstack_free (&conversion_obstack
, p
);
6897 #include "gt-cp-call.h"