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, 2008
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
);
1120 cp_lvalue_kind lvalue_p
= clk_none
;
1122 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1124 expr
= instantiate_type (to
, expr
, tf_none
);
1125 if (expr
== error_mark_node
)
1127 from
= TREE_TYPE (expr
);
1130 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1132 /* Anything with reference type is an lvalue. */
1133 lvalue_p
= clk_ordinary
;
1134 from
= TREE_TYPE (from
);
1137 lvalue_p
= real_lvalue_p (expr
);
1140 if ((lvalue_p
& clk_bitfield
) != 0)
1141 tfrom
= unlowered_expr_type (expr
);
1143 /* Figure out whether or not the types are reference-related and
1144 reference compatible. We have do do this after stripping
1145 references from FROM. */
1146 related_p
= reference_related_p (to
, tfrom
);
1147 /* If this is a C cast, first convert to an appropriately qualified
1148 type, so that we can later do a const_cast to the desired type. */
1149 if (related_p
&& c_cast_p
1150 && !at_least_as_qualified_p (to
, tfrom
))
1151 to
= build_qualified_type (to
, cp_type_quals (tfrom
));
1152 compatible_p
= reference_compatible_p (to
, tfrom
);
1154 /* Directly bind reference when target expression's type is compatible with
1155 the reference and expression is an lvalue. In DR391, the wording in
1156 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1157 const and rvalue references to rvalues of compatible class type. */
1160 || ((CP_TYPE_CONST_NON_VOLATILE_P(to
) || TYPE_REF_IS_RVALUE (rto
))
1161 && CLASS_TYPE_P (from
))))
1165 If the initializer expression
1167 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1168 is reference-compatible with "cv2 T2,"
1170 the reference is bound directly to the initializer expression
1174 If the initializer expression is an rvalue, with T2 a class type,
1175 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1176 is bound to the object represented by the rvalue or to a sub-object
1177 within that object. */
1179 conv
= build_identity_conv (tfrom
, expr
);
1180 conv
= direct_reference_binding (rto
, conv
);
1182 if (flags
& LOOKUP_PREFER_RVALUE
)
1183 /* The top-level caller requested that we pretend that the lvalue
1184 be treated as an rvalue. */
1185 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1187 conv
->rvaluedness_matches_p
1188 = (TYPE_REF_IS_RVALUE (rto
) == !lvalue_p
);
1190 if ((lvalue_p
& clk_bitfield
) != 0
1191 || ((lvalue_p
& clk_packed
) != 0 && !TYPE_PACKED (to
)))
1192 /* For the purposes of overload resolution, we ignore the fact
1193 this expression is a bitfield or packed field. (In particular,
1194 [over.ics.ref] says specifically that a function with a
1195 non-const reference parameter is viable even if the
1196 argument is a bitfield.)
1198 However, when we actually call the function we must create
1199 a temporary to which to bind the reference. If the
1200 reference is volatile, or isn't const, then we cannot make
1201 a temporary, so we just issue an error when the conversion
1203 conv
->need_temporary_p
= true;
1207 /* [class.conv.fct] A conversion function is never used to convert a
1208 (possibly cv-qualified) object to the (possibly cv-qualified) same
1209 object type (or a reference to it), to a (possibly cv-qualified) base
1210 class of that type (or a reference to it).... */
1211 else if (CLASS_TYPE_P (from
) && !related_p
1212 && !(flags
& LOOKUP_NO_CONVERSION
))
1216 If the initializer expression
1218 -- has a class type (i.e., T2 is a class type) can be
1219 implicitly converted to an lvalue of type "cv3 T3," where
1220 "cv1 T1" is reference-compatible with "cv3 T3". (this
1221 conversion is selected by enumerating the applicable
1222 conversion functions (_over.match.ref_) and choosing the
1223 best one through overload resolution. (_over.match_).
1225 the reference is bound to the lvalue result of the conversion
1226 in the second case. */
1227 conv
= convert_class_to_reference (rto
, from
, expr
);
1232 /* From this point on, we conceptually need temporaries, even if we
1233 elide them. Only the cases above are "direct bindings". */
1234 if (flags
& LOOKUP_NO_TEMP_BIND
)
1239 When a parameter of reference type is not bound directly to an
1240 argument expression, the conversion sequence is the one required
1241 to convert the argument expression to the underlying type of the
1242 reference according to _over.best.ics_. Conceptually, this
1243 conversion sequence corresponds to copy-initializing a temporary
1244 of the underlying type with the argument expression. Any
1245 difference in top-level cv-qualification is subsumed by the
1246 initialization itself and does not constitute a conversion. */
1250 Otherwise, the reference shall be to a non-volatile const type.
1252 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1253 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
) && !TYPE_REF_IS_RVALUE (rto
))
1258 Otherwise, a temporary of type "cv1 T1" is created and
1259 initialized from the initializer expression using the rules for a
1260 non-reference copy initialization. If T1 is reference-related to
1261 T2, cv1 must be the same cv-qualification as, or greater
1262 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1263 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1266 /* We're generating a temporary now, but don't bind any more in the
1267 conversion (specifically, don't slice the temporary returned by a
1268 conversion operator). */
1269 flags
|= LOOKUP_NO_TEMP_BIND
;
1271 conv
= implicit_conversion (to
, from
, expr
, c_cast_p
,
1276 conv
= build_conv (ck_ref_bind
, rto
, conv
);
1277 /* This reference binding, unlike those above, requires the
1278 creation of a temporary. */
1279 conv
->need_temporary_p
= true;
1280 conv
->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (rto
);
1285 /* Returns the implicit conversion sequence (see [over.ics]) from type
1286 FROM to type TO. The optional expression EXPR may affect the
1287 conversion. FLAGS are the usual overloading flags. Only
1288 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1289 conversion is coming from a C-style cast. */
1292 implicit_conversion (tree to
, tree from
, tree expr
, bool c_cast_p
,
1297 if (from
== error_mark_node
|| to
== error_mark_node
1298 || expr
== error_mark_node
)
1301 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1302 conv
= reference_binding (to
, from
, expr
, c_cast_p
, flags
);
1304 conv
= standard_conversion (to
, from
, expr
, c_cast_p
, flags
);
1309 if (expr
!= NULL_TREE
1310 && (IS_AGGR_TYPE (from
)
1311 || IS_AGGR_TYPE (to
))
1312 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1314 struct z_candidate
*cand
;
1315 int convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
)
1316 |LOOKUP_ONLYCONVERTING
);
1318 cand
= build_user_type_conversion_1 (to
, expr
, convflags
);
1320 conv
= cand
->second_conv
;
1322 /* We used to try to bind a reference to a temporary here, but that
1323 is now handled after the recursive call to this function at the end
1324 of reference_binding. */
1331 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1334 static struct z_candidate
*
1335 add_candidate (struct z_candidate
**candidates
,
1337 size_t num_convs
, conversion
**convs
,
1338 tree access_path
, tree conversion_path
,
1341 struct z_candidate
*cand
= (struct z_candidate
*)
1342 conversion_obstack_alloc (sizeof (struct z_candidate
));
1346 cand
->convs
= convs
;
1347 cand
->num_convs
= num_convs
;
1348 cand
->access_path
= access_path
;
1349 cand
->conversion_path
= conversion_path
;
1350 cand
->viable
= viable
;
1351 cand
->next
= *candidates
;
1357 /* Create an overload candidate for the function or method FN called with
1358 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1359 to implicit_conversion.
1361 CTYPE, if non-NULL, is the type we want to pretend this function
1362 comes from for purposes of overload resolution. */
1364 static struct z_candidate
*
1365 add_function_candidate (struct z_candidate
**candidates
,
1366 tree fn
, tree ctype
, tree arglist
,
1367 tree access_path
, tree conversion_path
,
1370 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1373 tree parmnode
, argnode
;
1377 /* At this point we should not see any functions which haven't been
1378 explicitly declared, except for friend functions which will have
1379 been found using argument dependent lookup. */
1380 gcc_assert (!DECL_ANTICIPATED (fn
) || DECL_HIDDEN_FRIEND_P (fn
));
1382 /* The `this', `in_chrg' and VTT arguments to constructors are not
1383 considered in overload resolution. */
1384 if (DECL_CONSTRUCTOR_P (fn
))
1386 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1387 orig_arglist
= arglist
;
1388 arglist
= skip_artificial_parms_for (fn
, arglist
);
1391 orig_arglist
= arglist
;
1393 len
= list_length (arglist
);
1394 convs
= alloc_conversions (len
);
1396 /* 13.3.2 - Viable functions [over.match.viable]
1397 First, to be a viable function, a candidate function shall have enough
1398 parameters to agree in number with the arguments in the list.
1400 We need to check this first; otherwise, checking the ICSes might cause
1401 us to produce an ill-formed template instantiation. */
1403 parmnode
= parmlist
;
1404 for (i
= 0; i
< len
; ++i
)
1406 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1408 parmnode
= TREE_CHAIN (parmnode
);
1411 if (i
< len
&& parmnode
)
1414 /* Make sure there are default args for the rest of the parms. */
1415 else if (!sufficient_parms_p (parmnode
))
1421 /* Second, for F to be a viable function, there shall exist for each
1422 argument an implicit conversion sequence that converts that argument
1423 to the corresponding parameter of F. */
1425 parmnode
= parmlist
;
1428 for (i
= 0; i
< len
; ++i
)
1430 tree arg
= TREE_VALUE (argnode
);
1431 tree argtype
= lvalue_type (arg
);
1435 if (parmnode
== void_list_node
)
1438 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1439 && ! DECL_CONSTRUCTOR_P (fn
));
1443 tree parmtype
= TREE_VALUE (parmnode
);
1445 /* The type of the implicit object parameter ('this') for
1446 overload resolution is not always the same as for the
1447 function itself; conversion functions are considered to
1448 be members of the class being converted, and functions
1449 introduced by a using-declaration are considered to be
1450 members of the class that uses them.
1452 Since build_over_call ignores the ICS for the `this'
1453 parameter, we can just change the parm type. */
1454 if (ctype
&& is_this
)
1457 = build_qualified_type (ctype
,
1458 TYPE_QUALS (TREE_TYPE (parmtype
)));
1459 parmtype
= build_pointer_type (parmtype
);
1462 t
= implicit_conversion (parmtype
, argtype
, arg
,
1463 /*c_cast_p=*/false, flags
);
1467 t
= build_identity_conv (argtype
, arg
);
1468 t
->ellipsis_p
= true;
1485 parmnode
= TREE_CHAIN (parmnode
);
1486 argnode
= TREE_CHAIN (argnode
);
1490 return add_candidate (candidates
, fn
, orig_arglist
, len
, convs
,
1491 access_path
, conversion_path
, viable
);
1494 /* Create an overload candidate for the conversion function FN which will
1495 be invoked for expression OBJ, producing a pointer-to-function which
1496 will in turn be called with the argument list ARGLIST, and add it to
1497 CANDIDATES. FLAGS is passed on to implicit_conversion.
1499 Actually, we don't really care about FN; we care about the type it
1500 converts to. There may be multiple conversion functions that will
1501 convert to that type, and we rely on build_user_type_conversion_1 to
1502 choose the best one; so when we create our candidate, we record the type
1503 instead of the function. */
1505 static struct z_candidate
*
1506 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
1507 tree arglist
, tree access_path
, tree conversion_path
)
1509 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
1510 int i
, len
, viable
, flags
;
1511 tree parmlist
, parmnode
, argnode
;
1514 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
1515 parmlist
= TREE_TYPE (parmlist
);
1516 parmlist
= TYPE_ARG_TYPES (parmlist
);
1518 len
= list_length (arglist
) + 1;
1519 convs
= alloc_conversions (len
);
1520 parmnode
= parmlist
;
1523 flags
= LOOKUP_NORMAL
;
1525 /* Don't bother looking up the same type twice. */
1526 if (*candidates
&& (*candidates
)->fn
== totype
)
1529 for (i
= 0; i
< len
; ++i
)
1531 tree arg
= i
== 0 ? obj
: TREE_VALUE (argnode
);
1532 tree argtype
= lvalue_type (arg
);
1536 t
= implicit_conversion (totype
, argtype
, arg
, /*c_cast_p=*/false,
1538 else if (parmnode
== void_list_node
)
1541 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
,
1542 /*c_cast_p=*/false, flags
);
1545 t
= build_identity_conv (argtype
, arg
);
1546 t
->ellipsis_p
= true;
1560 parmnode
= TREE_CHAIN (parmnode
);
1561 argnode
= TREE_CHAIN (argnode
);
1567 if (!sufficient_parms_p (parmnode
))
1570 return add_candidate (candidates
, totype
, arglist
, len
, convs
,
1571 access_path
, conversion_path
, viable
);
1575 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
1576 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
1588 num_convs
= args
[2] ? 3 : (args
[1] ? 2 : 1);
1589 convs
= alloc_conversions (num_convs
);
1591 for (i
= 0; i
< 2; ++i
)
1596 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
],
1597 /*c_cast_p=*/false, flags
);
1601 /* We need something for printing the candidate. */
1602 t
= build_identity_conv (types
[i
], NULL_TREE
);
1609 /* For COND_EXPR we rearranged the arguments; undo that now. */
1612 convs
[2] = convs
[1];
1613 convs
[1] = convs
[0];
1614 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2],
1615 /*c_cast_p=*/false, flags
);
1622 add_candidate (candidates
, fnname
, /*args=*/NULL_TREE
,
1624 /*access_path=*/NULL_TREE
,
1625 /*conversion_path=*/NULL_TREE
,
1630 is_complete (tree t
)
1632 return COMPLETE_TYPE_P (complete_type (t
));
1635 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1638 promoted_arithmetic_type_p (tree type
)
1642 In this section, the term promoted integral type is used to refer
1643 to those integral types which are preserved by integral promotion
1644 (including e.g. int and long but excluding e.g. char).
1645 Similarly, the term promoted arithmetic type refers to promoted
1646 integral types plus floating types. */
1647 return ((INTEGRAL_TYPE_P (type
)
1648 && same_type_p (type_promotes_to (type
), type
))
1649 || TREE_CODE (type
) == REAL_TYPE
);
1652 /* Create any builtin operator overload candidates for the operator in
1653 question given the converted operand types TYPE1 and TYPE2. The other
1654 args are passed through from add_builtin_candidates to
1655 build_builtin_candidate.
1657 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1658 If CODE is requires candidates operands of the same type of the kind
1659 of which TYPE1 and TYPE2 are, we add both candidates
1660 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1663 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
1664 enum tree_code code2
, tree fnname
, tree type1
,
1665 tree type2
, tree
*args
, tree
*argtypes
, int flags
)
1669 case POSTINCREMENT_EXPR
:
1670 case POSTDECREMENT_EXPR
:
1671 args
[1] = integer_zero_node
;
1672 type2
= integer_type_node
;
1681 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1682 and VQ is either volatile or empty, there exist candidate operator
1683 functions of the form
1684 VQ T& operator++(VQ T&);
1685 T operator++(VQ T&, int);
1686 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1687 type other than bool, and VQ is either volatile or empty, there exist
1688 candidate operator functions of the form
1689 VQ T& operator--(VQ T&);
1690 T operator--(VQ T&, int);
1691 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1692 complete object type, and VQ is either volatile or empty, there exist
1693 candidate operator functions of the form
1694 T*VQ& operator++(T*VQ&);
1695 T*VQ& operator--(T*VQ&);
1696 T* operator++(T*VQ&, int);
1697 T* operator--(T*VQ&, int); */
1699 case POSTDECREMENT_EXPR
:
1700 case PREDECREMENT_EXPR
:
1701 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
1703 case POSTINCREMENT_EXPR
:
1704 case PREINCREMENT_EXPR
:
1705 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
1707 type1
= build_reference_type (type1
);
1712 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1713 exist candidate operator functions of the form
1717 8 For every function type T, there exist candidate operator functions of
1719 T& operator*(T*); */
1722 if (TREE_CODE (type1
) == POINTER_TYPE
1723 && (TYPE_PTROB_P (type1
)
1724 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
1728 /* 9 For every type T, there exist candidate operator functions of the form
1731 10For every promoted arithmetic type T, there exist candidate operator
1732 functions of the form
1736 case UNARY_PLUS_EXPR
: /* unary + */
1737 if (TREE_CODE (type1
) == POINTER_TYPE
)
1740 if (ARITHMETIC_TYPE_P (type1
))
1744 /* 11For every promoted integral type T, there exist candidate operator
1745 functions of the form
1749 if (INTEGRAL_TYPE_P (type1
))
1753 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1754 is the same type as C2 or is a derived class of C2, T is a complete
1755 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1756 there exist candidate operator functions of the form
1757 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1758 where CV12 is the union of CV1 and CV2. */
1761 if (TREE_CODE (type1
) == POINTER_TYPE
1762 && TYPE_PTR_TO_MEMBER_P (type2
))
1764 tree c1
= TREE_TYPE (type1
);
1765 tree c2
= TYPE_PTRMEM_CLASS_TYPE (type2
);
1767 if (IS_AGGR_TYPE (c1
) && DERIVED_FROM_P (c2
, c1
)
1768 && (TYPE_PTRMEMFUNC_P (type2
)
1769 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2
))))
1774 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1775 didate operator functions of the form
1780 bool operator<(L, R);
1781 bool operator>(L, R);
1782 bool operator<=(L, R);
1783 bool operator>=(L, R);
1784 bool operator==(L, R);
1785 bool operator!=(L, R);
1786 where LR is the result of the usual arithmetic conversions between
1789 14For every pair of types T and I, where T is a cv-qualified or cv-
1790 unqualified complete object type and I is a promoted integral type,
1791 there exist candidate operator functions of the form
1792 T* operator+(T*, I);
1793 T& operator[](T*, I);
1794 T* operator-(T*, I);
1795 T* operator+(I, T*);
1796 T& operator[](I, T*);
1798 15For every T, where T is a pointer to complete object type, there exist
1799 candidate operator functions of the form112)
1800 ptrdiff_t operator-(T, T);
1802 16For every pointer or enumeration type T, there exist candidate operator
1803 functions of the form
1804 bool operator<(T, T);
1805 bool operator>(T, T);
1806 bool operator<=(T, T);
1807 bool operator>=(T, T);
1808 bool operator==(T, T);
1809 bool operator!=(T, T);
1811 17For every pointer to member type T, there exist candidate operator
1812 functions of the form
1813 bool operator==(T, T);
1814 bool operator!=(T, T); */
1817 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
1819 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1821 type2
= ptrdiff_type_node
;
1825 case TRUNC_DIV_EXPR
:
1826 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1832 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
1833 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
)))
1835 if (TYPE_PTR_TO_MEMBER_P (type1
) && null_ptr_cst_p (args
[1]))
1840 if (TYPE_PTR_TO_MEMBER_P (type2
) && null_ptr_cst_p (args
[0]))
1852 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1854 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1856 if (TREE_CODE (type1
) == ENUMERAL_TYPE
1857 && TREE_CODE (type2
) == ENUMERAL_TYPE
)
1859 if (TYPE_PTR_P (type1
)
1860 && null_ptr_cst_p (args
[1])
1861 && !uses_template_parms (type1
))
1866 if (null_ptr_cst_p (args
[0])
1867 && TYPE_PTR_P (type2
)
1868 && !uses_template_parms (type2
))
1876 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1879 if (INTEGRAL_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
1881 type1
= ptrdiff_type_node
;
1884 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1886 type2
= ptrdiff_type_node
;
1891 /* 18For every pair of promoted integral types L and R, there exist candi-
1892 date operator functions of the form
1899 where LR is the result of the usual arithmetic conversions between
1902 case TRUNC_MOD_EXPR
:
1908 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
1912 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1913 type, VQ is either volatile or empty, and R is a promoted arithmetic
1914 type, there exist candidate operator functions of the form
1915 VQ L& operator=(VQ L&, R);
1916 VQ L& operator*=(VQ L&, R);
1917 VQ L& operator/=(VQ L&, R);
1918 VQ L& operator+=(VQ L&, R);
1919 VQ L& operator-=(VQ L&, R);
1921 20For every pair T, VQ), where T is any type and VQ is either volatile
1922 or empty, there exist candidate operator functions of the form
1923 T*VQ& operator=(T*VQ&, T*);
1925 21For every pair T, VQ), where T is a pointer to member type and VQ is
1926 either volatile or empty, there exist candidate operator functions of
1928 VQ T& operator=(VQ T&, T);
1930 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1931 unqualified complete object type, VQ is either volatile or empty, and
1932 I is a promoted integral type, there exist candidate operator func-
1934 T*VQ& operator+=(T*VQ&, I);
1935 T*VQ& operator-=(T*VQ&, I);
1937 23For every triple L, VQ, R), where L is an integral or enumeration
1938 type, VQ is either volatile or empty, and R is a promoted integral
1939 type, there exist candidate operator functions of the form
1941 VQ L& operator%=(VQ L&, R);
1942 VQ L& operator<<=(VQ L&, R);
1943 VQ L& operator>>=(VQ L&, R);
1944 VQ L& operator&=(VQ L&, R);
1945 VQ L& operator^=(VQ L&, R);
1946 VQ L& operator|=(VQ L&, R); */
1953 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1955 type2
= ptrdiff_type_node
;
1959 case TRUNC_DIV_EXPR
:
1960 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1964 case TRUNC_MOD_EXPR
:
1970 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
1975 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1977 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
1978 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1979 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
1980 || ((TYPE_PTRMEMFUNC_P (type1
)
1981 || TREE_CODE (type1
) == POINTER_TYPE
)
1982 && null_ptr_cst_p (args
[1])))
1992 type1
= build_reference_type (type1
);
1998 For every pair of promoted arithmetic types L and R, there
1999 exist candidate operator functions of the form
2001 LR operator?(bool, L, R);
2003 where LR is the result of the usual arithmetic conversions
2004 between types L and R.
2006 For every type T, where T is a pointer or pointer-to-member
2007 type, there exist candidate operator functions of the form T
2008 operator?(bool, T, T); */
2010 if (promoted_arithmetic_type_p (type1
)
2011 && promoted_arithmetic_type_p (type2
))
2015 /* Otherwise, the types should be pointers. */
2016 if (!(TYPE_PTR_P (type1
) || TYPE_PTR_TO_MEMBER_P (type1
))
2017 || !(TYPE_PTR_P (type2
) || TYPE_PTR_TO_MEMBER_P (type2
)))
2020 /* We don't check that the two types are the same; the logic
2021 below will actually create two candidates; one in which both
2022 parameter types are TYPE1, and one in which both parameter
2030 /* If we're dealing with two pointer types or two enumeral types,
2031 we need candidates for both of them. */
2032 if (type2
&& !same_type_p (type1
, type2
)
2033 && TREE_CODE (type1
) == TREE_CODE (type2
)
2034 && (TREE_CODE (type1
) == REFERENCE_TYPE
2035 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
2036 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
2037 || TYPE_PTRMEMFUNC_P (type1
)
2038 || IS_AGGR_TYPE (type1
)
2039 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
2041 build_builtin_candidate
2042 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
);
2043 build_builtin_candidate
2044 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
);
2048 build_builtin_candidate
2049 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
);
2053 type_decays_to (tree type
)
2055 if (TREE_CODE (type
) == ARRAY_TYPE
)
2056 return build_pointer_type (TREE_TYPE (type
));
2057 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2058 return build_pointer_type (type
);
2062 /* There are three conditions of builtin candidates:
2064 1) bool-taking candidates. These are the same regardless of the input.
2065 2) pointer-pair taking candidates. These are generated for each type
2066 one of the input types converts to.
2067 3) arithmetic candidates. According to the standard, we should generate
2068 all of these, but I'm trying not to...
2070 Here we generate a superset of the possible candidates for this particular
2071 case. That is a subset of the full set the standard defines, plus some
2072 other cases which the standard disallows. add_builtin_candidate will
2073 filter out the invalid set. */
2076 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
2077 enum tree_code code2
, tree fnname
, tree
*args
,
2082 tree type
, argtypes
[3];
2083 /* TYPES[i] is the set of possible builtin-operator parameter types
2084 we will consider for the Ith argument. These are represented as
2085 a TREE_LIST; the TREE_VALUE of each node is the potential
2089 for (i
= 0; i
< 3; ++i
)
2092 argtypes
[i
] = unlowered_expr_type (args
[i
]);
2094 argtypes
[i
] = NULL_TREE
;
2099 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2100 and VQ is either volatile or empty, there exist candidate operator
2101 functions of the form
2102 VQ T& operator++(VQ T&); */
2104 case POSTINCREMENT_EXPR
:
2105 case PREINCREMENT_EXPR
:
2106 case POSTDECREMENT_EXPR
:
2107 case PREDECREMENT_EXPR
:
2112 /* 24There also exist candidate operator functions of the form
2113 bool operator!(bool);
2114 bool operator&&(bool, bool);
2115 bool operator||(bool, bool); */
2117 case TRUTH_NOT_EXPR
:
2118 build_builtin_candidate
2119 (candidates
, fnname
, boolean_type_node
,
2120 NULL_TREE
, args
, argtypes
, flags
);
2123 case TRUTH_ORIF_EXPR
:
2124 case TRUTH_ANDIF_EXPR
:
2125 build_builtin_candidate
2126 (candidates
, fnname
, boolean_type_node
,
2127 boolean_type_node
, args
, argtypes
, flags
);
2149 types
[0] = types
[1] = NULL_TREE
;
2151 for (i
= 0; i
< 2; ++i
)
2155 else if (IS_AGGR_TYPE (argtypes
[i
]))
2159 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2162 convs
= lookup_conversions (argtypes
[i
]);
2164 if (code
== COND_EXPR
)
2166 if (real_lvalue_p (args
[i
]))
2167 types
[i
] = tree_cons
2168 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
2170 types
[i
] = tree_cons
2171 (NULL_TREE
, TYPE_MAIN_VARIANT (argtypes
[i
]), types
[i
]);
2177 for (; convs
; convs
= TREE_CHAIN (convs
))
2179 type
= TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs
))));
2182 && (TREE_CODE (type
) != REFERENCE_TYPE
2183 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2186 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2187 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2189 type
= non_reference (type
);
2190 if (i
!= 0 || ! ref1
)
2192 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
2193 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2194 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2195 if (INTEGRAL_TYPE_P (type
))
2196 type
= type_promotes_to (type
);
2199 if (! value_member (type
, types
[i
]))
2200 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2205 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2206 types
[i
] = tree_cons
2207 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
2208 type
= non_reference (argtypes
[i
]);
2209 if (i
!= 0 || ! ref1
)
2211 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
2212 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2213 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2214 if (INTEGRAL_TYPE_P (type
))
2215 type
= type_promotes_to (type
);
2217 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2221 /* Run through the possible parameter types of both arguments,
2222 creating candidates with those parameter types. */
2223 for (; types
[0]; types
[0] = TREE_CHAIN (types
[0]))
2226 for (type
= types
[1]; type
; type
= TREE_CHAIN (type
))
2227 add_builtin_candidate
2228 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
2229 TREE_VALUE (type
), args
, argtypes
, flags
);
2231 add_builtin_candidate
2232 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
2233 NULL_TREE
, args
, argtypes
, flags
);
2238 /* If TMPL can be successfully instantiated as indicated by
2239 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2241 TMPL is the template. EXPLICIT_TARGS are any explicit template
2242 arguments. ARGLIST is the arguments provided at the call-site.
2243 The RETURN_TYPE is the desired type for conversion operators. If
2244 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2245 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2246 add_conv_candidate. */
2248 static struct z_candidate
*
2249 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
2250 tree ctype
, tree explicit_targs
, tree arglist
,
2251 tree return_type
, tree access_path
,
2252 tree conversion_path
, int flags
, tree obj
,
2253 unification_kind_t strict
)
2255 int ntparms
= DECL_NTPARMS (tmpl
);
2256 tree targs
= make_tree_vec (ntparms
);
2257 tree args_without_in_chrg
= arglist
;
2258 struct z_candidate
*cand
;
2262 /* We don't do deduction on the in-charge parameter, the VTT
2263 parameter or 'this'. */
2264 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
2265 args_without_in_chrg
= TREE_CHAIN (args_without_in_chrg
);
2267 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
2268 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
2269 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl
)))
2270 args_without_in_chrg
= TREE_CHAIN (args_without_in_chrg
);
2272 i
= fn_type_unification (tmpl
, explicit_targs
, targs
,
2273 args_without_in_chrg
,
2274 return_type
, strict
, flags
);
2279 fn
= instantiate_template (tmpl
, targs
, tf_none
);
2280 if (fn
== error_mark_node
)
2285 A member function template is never instantiated to perform the
2286 copy of a class object to an object of its class type.
2288 It's a little unclear what this means; the standard explicitly
2289 does allow a template to be used to copy a class. For example,
2294 template <class T> A(const T&);
2297 void g () { A a (f ()); }
2299 the member template will be used to make the copy. The section
2300 quoted above appears in the paragraph that forbids constructors
2301 whose only parameter is (a possibly cv-qualified variant of) the
2302 class type, and a logical interpretation is that the intent was
2303 to forbid the instantiation of member templates which would then
2305 if (DECL_CONSTRUCTOR_P (fn
) && list_length (arglist
) == 2)
2307 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
2308 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
2313 if (obj
!= NULL_TREE
)
2314 /* Aha, this is a conversion function. */
2315 cand
= add_conv_candidate (candidates
, fn
, obj
, access_path
,
2316 conversion_path
, arglist
);
2318 cand
= add_function_candidate (candidates
, fn
, ctype
,
2319 arglist
, access_path
,
2320 conversion_path
, flags
);
2321 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
2322 /* This situation can occur if a member template of a template
2323 class is specialized. Then, instantiate_template might return
2324 an instantiation of the specialization, in which case the
2325 DECL_TI_TEMPLATE field will point at the original
2326 specialization. For example:
2328 template <class T> struct S { template <class U> void f(U);
2329 template <> void f(int) {}; };
2333 Here, TMPL will be template <class U> S<double>::f(U).
2334 And, instantiate template will give us the specialization
2335 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2336 for this will point at template <class T> template <> S<T>::f(int),
2337 so that we can find the definition. For the purposes of
2338 overload resolution, however, we want the original TMPL. */
2339 cand
->template_decl
= tree_cons (tmpl
, targs
, NULL_TREE
);
2341 cand
->template_decl
= DECL_TEMPLATE_INFO (fn
);
2347 static struct z_candidate
*
2348 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
2349 tree explicit_targs
, tree arglist
, tree return_type
,
2350 tree access_path
, tree conversion_path
, int flags
,
2351 unification_kind_t strict
)
2354 add_template_candidate_real (candidates
, tmpl
, ctype
,
2355 explicit_targs
, arglist
, return_type
,
2356 access_path
, conversion_path
,
2357 flags
, NULL_TREE
, strict
);
2361 static struct z_candidate
*
2362 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
2363 tree obj
, tree arglist
, tree return_type
,
2364 tree access_path
, tree conversion_path
)
2367 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
2368 arglist
, return_type
, access_path
,
2369 conversion_path
, 0, obj
, DEDUCE_CONV
);
2372 /* The CANDS are the set of candidates that were considered for
2373 overload resolution. Return the set of viable candidates. If none
2374 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2375 is true if a candidate should be considered viable only if it is
2378 static struct z_candidate
*
2379 splice_viable (struct z_candidate
*cands
,
2383 struct z_candidate
*viable
;
2384 struct z_candidate
**last_viable
;
2385 struct z_candidate
**cand
;
2388 last_viable
= &viable
;
2389 *any_viable_p
= false;
2394 struct z_candidate
*c
= *cand
;
2395 if (strict_p
? c
->viable
== 1 : c
->viable
)
2400 last_viable
= &c
->next
;
2401 *any_viable_p
= true;
2407 return viable
? viable
: cands
;
2411 any_strictly_viable (struct z_candidate
*cands
)
2413 for (; cands
; cands
= cands
->next
)
2414 if (cands
->viable
== 1)
2419 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2420 words, it is about to become the "this" pointer for a member
2421 function call. Take the address of the object. */
2424 build_this (tree obj
)
2426 /* In a template, we are only concerned about the type of the
2427 expression, so we can take a shortcut. */
2428 if (processing_template_decl
)
2429 return build_address (obj
);
2431 return build_unary_op (ADDR_EXPR
, obj
, 0);
2434 /* Returns true iff functions are equivalent. Equivalent functions are
2435 not '==' only if one is a function-local extern function or if
2436 both are extern "C". */
2439 equal_functions (tree fn1
, tree fn2
)
2441 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
2442 || DECL_EXTERN_C_FUNCTION_P (fn1
))
2443 return decls_match (fn1
, fn2
);
2447 /* Print information about one overload candidate CANDIDATE. MSGSTR
2448 is the text to print before the candidate itself.
2450 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2451 to have been run through gettext by the caller. This wart makes
2452 life simpler in print_z_candidates and for the translators. */
2455 print_z_candidate (const char *msgstr
, struct z_candidate
*candidate
)
2457 if (TREE_CODE (candidate
->fn
) == IDENTIFIER_NODE
)
2459 if (candidate
->num_convs
== 3)
2460 inform ("%s %D(%T, %T, %T) <built-in>", msgstr
, candidate
->fn
,
2461 candidate
->convs
[0]->type
,
2462 candidate
->convs
[1]->type
,
2463 candidate
->convs
[2]->type
);
2464 else if (candidate
->num_convs
== 2)
2465 inform ("%s %D(%T, %T) <built-in>", msgstr
, candidate
->fn
,
2466 candidate
->convs
[0]->type
,
2467 candidate
->convs
[1]->type
);
2469 inform ("%s %D(%T) <built-in>", msgstr
, candidate
->fn
,
2470 candidate
->convs
[0]->type
);
2472 else if (TYPE_P (candidate
->fn
))
2473 inform ("%s %T <conversion>", msgstr
, candidate
->fn
);
2474 else if (candidate
->viable
== -1)
2475 inform ("%s %+#D <near match>", msgstr
, candidate
->fn
);
2477 inform ("%s %+#D", msgstr
, candidate
->fn
);
2481 print_z_candidates (struct z_candidate
*candidates
)
2484 struct z_candidate
*cand1
;
2485 struct z_candidate
**cand2
;
2487 /* There may be duplicates in the set of candidates. We put off
2488 checking this condition as long as possible, since we have no way
2489 to eliminate duplicates from a set of functions in less than n^2
2490 time. Now we are about to emit an error message, so it is more
2491 permissible to go slowly. */
2492 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
2494 tree fn
= cand1
->fn
;
2495 /* Skip builtin candidates and conversion functions. */
2496 if (TREE_CODE (fn
) != FUNCTION_DECL
)
2498 cand2
= &cand1
->next
;
2501 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
2502 && equal_functions (fn
, (*cand2
)->fn
))
2503 *cand2
= (*cand2
)->next
;
2505 cand2
= &(*cand2
)->next
;
2512 str
= _("candidates are:");
2513 print_z_candidate (str
, candidates
);
2514 if (candidates
->next
)
2516 /* Indent successive candidates by the width of the translation
2517 of the above string. */
2518 size_t len
= gcc_gettext_width (str
) + 1;
2519 char *spaces
= (char *) alloca (len
);
2520 memset (spaces
, ' ', len
-1);
2521 spaces
[len
- 1] = '\0';
2523 candidates
= candidates
->next
;
2526 print_z_candidate (spaces
, candidates
);
2527 candidates
= candidates
->next
;
2533 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2534 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2535 the result of the conversion function to convert it to the final
2536 desired type. Merge the two sequences into a single sequence,
2537 and return the merged sequence. */
2540 merge_conversion_sequences (conversion
*user_seq
, conversion
*std_seq
)
2544 gcc_assert (user_seq
->kind
== ck_user
);
2546 /* Find the end of the second conversion sequence. */
2548 while ((*t
)->kind
!= ck_identity
)
2549 t
= &((*t
)->u
.next
);
2551 /* Replace the identity conversion with the user conversion
2555 /* The entire sequence is a user-conversion sequence. */
2556 std_seq
->user_conv_p
= true;
2561 /* Returns the best overload candidate to perform the requested
2562 conversion. This function is used for three the overloading situations
2563 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2564 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2565 per [dcl.init.ref], so we ignore temporary bindings. */
2567 static struct z_candidate
*
2568 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
)
2570 struct z_candidate
*candidates
, *cand
;
2571 tree fromtype
= TREE_TYPE (expr
);
2572 tree ctors
= NULL_TREE
;
2573 tree conv_fns
= NULL_TREE
;
2574 conversion
*conv
= NULL
;
2575 tree args
= NULL_TREE
;
2579 /* We represent conversion within a hierarchy using RVALUE_CONV and
2580 BASE_CONV, as specified by [over.best.ics]; these become plain
2581 constructor calls, as specified in [dcl.init]. */
2582 gcc_assert (!IS_AGGR_TYPE (fromtype
) || !IS_AGGR_TYPE (totype
)
2583 || !DERIVED_FROM_P (totype
, fromtype
));
2585 if (IS_AGGR_TYPE (totype
))
2586 ctors
= lookup_fnfields (totype
, complete_ctor_identifier
, 0);
2588 if (IS_AGGR_TYPE (fromtype
))
2590 tree to_nonref
= non_reference (totype
);
2591 if (same_type_ignoring_top_level_qualifiers_p (to_nonref
, fromtype
) ||
2592 (CLASS_TYPE_P (to_nonref
) && CLASS_TYPE_P (fromtype
)
2593 && DERIVED_FROM_P (to_nonref
, fromtype
)))
2595 /* [class.conv.fct] A conversion function is never used to
2596 convert a (possibly cv-qualified) object to the (possibly
2597 cv-qualified) same object type (or a reference to it), to a
2598 (possibly cv-qualified) base class of that type (or a
2599 reference to it)... */
2602 conv_fns
= lookup_conversions (fromtype
);
2606 flags
|= LOOKUP_NO_CONVERSION
;
2608 /* It's OK to bind a temporary for converting constructor arguments, but
2609 not in converting the return value of a conversion operator. */
2610 convflags
= ((flags
& LOOKUP_NO_TEMP_BIND
) | LOOKUP_NO_CONVERSION
);
2611 flags
&= ~LOOKUP_NO_TEMP_BIND
;
2617 ctors
= BASELINK_FUNCTIONS (ctors
);
2619 t
= build_int_cst (build_pointer_type (totype
), 0);
2620 args
= build_tree_list (NULL_TREE
, expr
);
2621 /* We should never try to call the abstract or base constructor
2623 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
2624 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)));
2625 args
= tree_cons (NULL_TREE
, t
, args
);
2627 for (; ctors
; ctors
= OVL_NEXT (ctors
))
2629 tree ctor
= OVL_CURRENT (ctors
);
2630 if (DECL_NONCONVERTING_P (ctor
))
2633 if (TREE_CODE (ctor
) == TEMPLATE_DECL
)
2634 cand
= add_template_candidate (&candidates
, ctor
, totype
,
2635 NULL_TREE
, args
, NULL_TREE
,
2636 TYPE_BINFO (totype
),
2637 TYPE_BINFO (totype
),
2641 cand
= add_function_candidate (&candidates
, ctor
, totype
,
2642 args
, TYPE_BINFO (totype
),
2643 TYPE_BINFO (totype
),
2647 cand
->second_conv
= build_identity_conv (totype
, NULL_TREE
);
2651 args
= build_tree_list (NULL_TREE
, build_this (expr
));
2653 for (; conv_fns
; conv_fns
= TREE_CHAIN (conv_fns
))
2656 tree conversion_path
= TREE_PURPOSE (conv_fns
);
2658 /* If we are called to convert to a reference type, we are trying to
2659 find an lvalue binding, so don't even consider temporaries. If
2660 we don't find an lvalue binding, the caller will try again to
2661 look for a temporary binding. */
2662 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
2663 convflags
|= LOOKUP_NO_TEMP_BIND
;
2665 for (fns
= TREE_VALUE (conv_fns
); fns
; fns
= OVL_NEXT (fns
))
2667 tree fn
= OVL_CURRENT (fns
);
2669 /* [over.match.funcs] For conversion functions, the function
2670 is considered to be a member of the class of the implicit
2671 object argument for the purpose of defining the type of
2672 the implicit object parameter.
2674 So we pass fromtype as CTYPE to add_*_candidate. */
2676 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2677 cand
= add_template_candidate (&candidates
, fn
, fromtype
,
2680 TYPE_BINFO (fromtype
),
2685 cand
= add_function_candidate (&candidates
, fn
, fromtype
,
2687 TYPE_BINFO (fromtype
),
2694 = implicit_conversion (totype
,
2695 TREE_TYPE (TREE_TYPE (cand
->fn
)),
2697 /*c_cast_p=*/false, convflags
);
2699 cand
->second_conv
= ics
;
2703 else if (candidates
->viable
== 1 && ics
->bad_p
)
2709 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
2713 cand
= tourney (candidates
);
2716 if (flags
& LOOKUP_COMPLAIN
)
2718 error ("conversion from %qT to %qT is ambiguous",
2720 print_z_candidates (candidates
);
2723 cand
= candidates
; /* any one will do */
2724 cand
->second_conv
= build_ambiguous_conv (totype
, expr
);
2725 cand
->second_conv
->user_conv_p
= true;
2726 if (!any_strictly_viable (candidates
))
2727 cand
->second_conv
->bad_p
= true;
2728 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2729 ambiguous conversion is no worse than another user-defined
2735 /* Build the user conversion sequence. */
2738 (DECL_CONSTRUCTOR_P (cand
->fn
)
2739 ? totype
: non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)))),
2740 build_identity_conv (TREE_TYPE (expr
), expr
));
2743 /* Combine it with the second conversion sequence. */
2744 cand
->second_conv
= merge_conversion_sequences (conv
,
2747 if (cand
->viable
== -1)
2748 cand
->second_conv
->bad_p
= true;
2754 build_user_type_conversion (tree totype
, tree expr
, int flags
)
2756 struct z_candidate
*cand
2757 = build_user_type_conversion_1 (totype
, expr
, flags
);
2761 if (cand
->second_conv
->kind
== ck_ambig
)
2762 return error_mark_node
;
2763 expr
= convert_like (cand
->second_conv
, expr
);
2764 return convert_from_reference (expr
);
2769 /* Do any initial processing on the arguments to a function call. */
2772 resolve_args (tree args
)
2775 for (t
= args
; t
; t
= TREE_CHAIN (t
))
2777 tree arg
= TREE_VALUE (t
);
2779 if (error_operand_p (arg
))
2780 return error_mark_node
;
2781 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
2783 error ("invalid use of void expression");
2784 return error_mark_node
;
2786 else if (invalid_nonstatic_memfn_p (arg
))
2787 return error_mark_node
;
2792 /* Perform overload resolution on FN, which is called with the ARGS.
2794 Return the candidate function selected by overload resolution, or
2795 NULL if the event that overload resolution failed. In the case
2796 that overload resolution fails, *CANDIDATES will be the set of
2797 candidates considered, and ANY_VIABLE_P will be set to true or
2798 false to indicate whether or not any of the candidates were
2801 The ARGS should already have gone through RESOLVE_ARGS before this
2802 function is called. */
2804 static struct z_candidate
*
2805 perform_overload_resolution (tree fn
,
2807 struct z_candidate
**candidates
,
2810 struct z_candidate
*cand
;
2811 tree explicit_targs
= NULL_TREE
;
2812 int template_only
= 0;
2815 *any_viable_p
= true;
2817 /* Check FN and ARGS. */
2818 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
2819 || TREE_CODE (fn
) == TEMPLATE_DECL
2820 || TREE_CODE (fn
) == OVERLOAD
2821 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
);
2822 gcc_assert (!args
|| TREE_CODE (args
) == TREE_LIST
);
2824 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2826 explicit_targs
= TREE_OPERAND (fn
, 1);
2827 fn
= TREE_OPERAND (fn
, 0);
2831 /* Add the various candidate functions. */
2832 add_candidates (fn
, args
, explicit_targs
, template_only
,
2833 /*conversion_path=*/NULL_TREE
,
2834 /*access_path=*/NULL_TREE
,
2838 *candidates
= splice_viable (*candidates
, pedantic
, any_viable_p
);
2842 cand
= tourney (*candidates
);
2846 /* Return an expression for a call to FN (a namespace-scope function,
2847 or a static member function) with the ARGS. */
2850 build_new_function_call (tree fn
, tree args
, bool koenig_p
)
2852 struct z_candidate
*candidates
, *cand
;
2857 args
= resolve_args (args
);
2858 if (args
== error_mark_node
)
2859 return error_mark_node
;
2861 /* If this function was found without using argument dependent
2862 lookup, then we want to ignore any undeclared friend
2868 fn
= remove_hidden_names (fn
);
2871 error ("no matching function for call to %<%D(%A)%>",
2872 DECL_NAME (OVL_CURRENT (orig_fn
)), args
);
2873 return error_mark_node
;
2877 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2878 p
= conversion_obstack_alloc (0);
2880 cand
= perform_overload_resolution (fn
, args
, &candidates
, &any_viable_p
);
2884 if (!any_viable_p
&& candidates
&& ! candidates
->next
)
2885 return build_function_call (candidates
->fn
, args
);
2886 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2887 fn
= TREE_OPERAND (fn
, 0);
2889 error ("no matching function for call to %<%D(%A)%>",
2890 DECL_NAME (OVL_CURRENT (fn
)), args
);
2892 error ("call of overloaded %<%D(%A)%> is ambiguous",
2893 DECL_NAME (OVL_CURRENT (fn
)), args
);
2895 print_z_candidates (candidates
);
2896 result
= error_mark_node
;
2899 result
= build_over_call (cand
, LOOKUP_NORMAL
);
2901 /* Free all the conversions we allocated. */
2902 obstack_free (&conversion_obstack
, p
);
2907 /* Build a call to a global operator new. FNNAME is the name of the
2908 operator (either "operator new" or "operator new[]") and ARGS are
2909 the arguments provided. *SIZE points to the total number of bytes
2910 required by the allocation, and is updated if that is changed here.
2911 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2912 function determines that no cookie should be used, after all,
2913 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2914 set, upon return, to the allocation function called. */
2917 build_operator_new_call (tree fnname
, tree args
,
2918 tree
*size
, tree
*cookie_size
,
2922 struct z_candidate
*candidates
;
2923 struct z_candidate
*cand
;
2928 args
= tree_cons (NULL_TREE
, *size
, args
);
2929 args
= resolve_args (args
);
2930 if (args
== error_mark_node
)
2937 If this lookup fails to find the name, or if the allocated type
2938 is not a class type, the allocation function's name is looked
2939 up in the global scope.
2941 we disregard block-scope declarations of "operator new". */
2942 fns
= lookup_function_nonclass (fnname
, args
, /*block_p=*/false);
2944 /* Figure out what function is being called. */
2945 cand
= perform_overload_resolution (fns
, args
, &candidates
, &any_viable_p
);
2947 /* If no suitable function could be found, issue an error message
2952 error ("no matching function for call to %<%D(%A)%>",
2953 DECL_NAME (OVL_CURRENT (fns
)), args
);
2955 error ("call of overloaded %<%D(%A)%> is ambiguous",
2956 DECL_NAME (OVL_CURRENT (fns
)), args
);
2958 print_z_candidates (candidates
);
2959 return error_mark_node
;
2962 /* If a cookie is required, add some extra space. Whether
2963 or not a cookie is required cannot be determined until
2964 after we know which function was called. */
2967 bool use_cookie
= true;
2968 if (!abi_version_at_least (2))
2970 tree placement
= TREE_CHAIN (args
);
2971 /* In G++ 3.2, the check was implemented incorrectly; it
2972 looked at the placement expression, rather than the
2973 type of the function. */
2974 if (placement
&& !TREE_CHAIN (placement
)
2975 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2983 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
2984 /* Skip the size_t parameter. */
2985 arg_types
= TREE_CHAIN (arg_types
);
2986 /* Check the remaining parameters (if any). */
2988 && TREE_CHAIN (arg_types
) == void_list_node
2989 && same_type_p (TREE_VALUE (arg_types
),
2993 /* If we need a cookie, adjust the number of bytes allocated. */
2996 /* Update the total size. */
2997 *size
= size_binop (PLUS_EXPR
, *size
, *cookie_size
);
2998 /* Update the argument list to reflect the adjusted size. */
2999 TREE_VALUE (args
) = *size
;
3002 *cookie_size
= NULL_TREE
;
3005 /* Tell our caller which function we decided to call. */
3009 /* Build the CALL_EXPR. */
3010 return build_over_call (cand
, LOOKUP_NORMAL
);
3014 build_object_call (tree obj
, tree args
)
3016 struct z_candidate
*candidates
= 0, *cand
;
3017 tree fns
, convs
, mem_args
= NULL_TREE
;
3018 tree type
= TREE_TYPE (obj
);
3020 tree result
= NULL_TREE
;
3023 if (TYPE_PTRMEMFUNC_P (type
))
3025 /* It's no good looking for an overloaded operator() on a
3026 pointer-to-member-function. */
3027 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
3028 return error_mark_node
;
3031 if (TYPE_BINFO (type
))
3033 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
3034 if (fns
== error_mark_node
)
3035 return error_mark_node
;
3040 args
= resolve_args (args
);
3042 if (args
== error_mark_node
)
3043 return error_mark_node
;
3045 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3046 p
= conversion_obstack_alloc (0);
3050 tree base
= BINFO_TYPE (BASELINK_BINFO (fns
));
3051 mem_args
= tree_cons (NULL_TREE
, build_this (obj
), args
);
3053 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
3055 tree fn
= OVL_CURRENT (fns
);
3056 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
3057 add_template_candidate (&candidates
, fn
, base
, NULL_TREE
,
3058 mem_args
, NULL_TREE
,
3061 LOOKUP_NORMAL
, DEDUCE_CALL
);
3063 add_function_candidate
3064 (&candidates
, fn
, base
, mem_args
, TYPE_BINFO (type
),
3065 TYPE_BINFO (type
), LOOKUP_NORMAL
);
3069 convs
= lookup_conversions (type
);
3071 for (; convs
; convs
= TREE_CHAIN (convs
))
3073 tree fns
= TREE_VALUE (convs
);
3074 tree totype
= TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns
)));
3076 if ((TREE_CODE (totype
) == POINTER_TYPE
3077 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
3078 || (TREE_CODE (totype
) == REFERENCE_TYPE
3079 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
3080 || (TREE_CODE (totype
) == REFERENCE_TYPE
3081 && TREE_CODE (TREE_TYPE (totype
)) == POINTER_TYPE
3082 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype
))) == FUNCTION_TYPE
))
3083 for (; fns
; fns
= OVL_NEXT (fns
))
3085 tree fn
= OVL_CURRENT (fns
);
3086 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
3087 add_template_conv_candidate
3088 (&candidates
, fn
, obj
, args
, totype
,
3089 /*access_path=*/NULL_TREE
,
3090 /*conversion_path=*/NULL_TREE
);
3092 add_conv_candidate (&candidates
, fn
, obj
, args
,
3093 /*conversion_path=*/NULL_TREE
,
3094 /*access_path=*/NULL_TREE
);
3098 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
3101 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj
), args
);
3102 print_z_candidates (candidates
);
3103 result
= error_mark_node
;
3107 cand
= tourney (candidates
);
3110 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj
), args
);
3111 print_z_candidates (candidates
);
3112 result
= error_mark_node
;
3114 /* Since cand->fn will be a type, not a function, for a conversion
3115 function, we must be careful not to unconditionally look at
3117 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
3118 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
3119 result
= build_over_call (cand
, LOOKUP_NORMAL
);
3122 obj
= convert_like_with_context (cand
->convs
[0], obj
, cand
->fn
, -1);
3123 obj
= convert_from_reference (obj
);
3124 result
= build_function_call (obj
, args
);
3128 /* Free all the conversions we allocated. */
3129 obstack_free (&conversion_obstack
, p
);
3135 op_error (enum tree_code code
, enum tree_code code2
,
3136 tree arg1
, tree arg2
, tree arg3
, const char *problem
)
3140 if (code
== MODIFY_EXPR
)
3141 opname
= assignment_operator_name_info
[code2
].name
;
3143 opname
= operator_name_info
[code
].name
;
3148 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3149 problem
, arg1
, arg2
, arg3
);
3152 case POSTINCREMENT_EXPR
:
3153 case POSTDECREMENT_EXPR
:
3154 error ("%s for %<operator%s%> in %<%E%s%>", problem
, opname
, arg1
, opname
);
3158 error ("%s for %<operator[]%> in %<%E[%E]%>", problem
, arg1
, arg2
);
3163 error ("%s for %qs in %<%s %E%>", problem
, opname
, opname
, arg1
);
3168 error ("%s for %<operator%s%> in %<%E %s %E%>",
3169 problem
, opname
, arg1
, opname
, arg2
);
3171 error ("%s for %<operator%s%> in %<%s%E%>",
3172 problem
, opname
, opname
, arg1
);
3177 /* Return the implicit conversion sequence that could be used to
3178 convert E1 to E2 in [expr.cond]. */
3181 conditional_conversion (tree e1
, tree e2
)
3183 tree t1
= non_reference (TREE_TYPE (e1
));
3184 tree t2
= non_reference (TREE_TYPE (e2
));
3190 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3191 implicitly converted (clause _conv_) to the type "reference to
3192 T2", subject to the constraint that in the conversion the
3193 reference must bind directly (_dcl.init.ref_) to E1. */
3194 if (real_lvalue_p (e2
))
3196 conv
= implicit_conversion (build_reference_type (t2
),
3200 LOOKUP_NO_TEMP_BIND
);
3207 If E1 and E2 have class type, and the underlying class types are
3208 the same or one is a base class of the other: E1 can be converted
3209 to match E2 if the class of T2 is the same type as, or a base
3210 class of, the class of T1, and the cv-qualification of T2 is the
3211 same cv-qualification as, or a greater cv-qualification than, the
3212 cv-qualification of T1. If the conversion is applied, E1 is
3213 changed to an rvalue of type T2 that still refers to the original
3214 source class object (or the appropriate subobject thereof). */
3215 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
3216 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
3218 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
3220 conv
= build_identity_conv (t1
, e1
);
3221 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
3222 TYPE_MAIN_VARIANT (t2
)))
3223 conv
= build_conv (ck_base
, t2
, conv
);
3225 conv
= build_conv (ck_rvalue
, t2
, conv
);
3234 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3235 converted to the type that expression E2 would have if E2 were
3236 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3237 return implicit_conversion (t2
, t1
, e1
, /*c_cast_p=*/false,
3241 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3242 arguments to the conditional expression. */
3245 build_conditional_expr (tree arg1
, tree arg2
, tree arg3
)
3249 tree result
= NULL_TREE
;
3250 tree result_type
= NULL_TREE
;
3251 bool lvalue_p
= true;
3252 struct z_candidate
*candidates
= 0;
3253 struct z_candidate
*cand
;
3256 /* As a G++ extension, the second argument to the conditional can be
3257 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3258 c'.) If the second operand is omitted, make sure it is
3259 calculated only once. */
3263 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3265 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3266 if (real_lvalue_p (arg1
))
3267 arg2
= arg1
= stabilize_reference (arg1
);
3269 arg2
= arg1
= save_expr (arg1
);
3274 The first expr ession is implicitly converted to bool (clause
3276 arg1
= perform_implicit_conversion (boolean_type_node
, arg1
);
3278 /* If something has already gone wrong, just pass that fact up the
3280 if (error_operand_p (arg1
)
3281 || error_operand_p (arg2
)
3282 || error_operand_p (arg3
))
3283 return error_mark_node
;
3287 If either the second or the third operand has type (possibly
3288 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3289 array-to-pointer (_conv.array_), and function-to-pointer
3290 (_conv.func_) standard conversions are performed on the second
3291 and third operands. */
3292 arg2_type
= unlowered_expr_type (arg2
);
3293 arg3_type
= unlowered_expr_type (arg3
);
3294 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
3296 /* Do the conversions. We don't these for `void' type arguments
3297 since it can't have any effect and since decay_conversion
3298 does not handle that case gracefully. */
3299 if (!VOID_TYPE_P (arg2_type
))
3300 arg2
= decay_conversion (arg2
);
3301 if (!VOID_TYPE_P (arg3_type
))
3302 arg3
= decay_conversion (arg3
);
3303 arg2_type
= TREE_TYPE (arg2
);
3304 arg3_type
= TREE_TYPE (arg3
);
3308 One of the following shall hold:
3310 --The second or the third operand (but not both) is a
3311 throw-expression (_except.throw_); the result is of the
3312 type of the other and is an rvalue.
3314 --Both the second and the third operands have type void; the
3315 result is of type void and is an rvalue.
3317 We must avoid calling force_rvalue for expressions of type
3318 "void" because it will complain that their value is being
3320 if (TREE_CODE (arg2
) == THROW_EXPR
3321 && TREE_CODE (arg3
) != THROW_EXPR
)
3323 if (!VOID_TYPE_P (arg3_type
))
3324 arg3
= force_rvalue (arg3
);
3325 arg3_type
= TREE_TYPE (arg3
);
3326 result_type
= arg3_type
;
3328 else if (TREE_CODE (arg2
) != THROW_EXPR
3329 && TREE_CODE (arg3
) == THROW_EXPR
)
3331 if (!VOID_TYPE_P (arg2_type
))
3332 arg2
= force_rvalue (arg2
);
3333 arg2_type
= TREE_TYPE (arg2
);
3334 result_type
= arg2_type
;
3336 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
3337 result_type
= void_type_node
;
3340 if (VOID_TYPE_P (arg2_type
))
3341 error ("second operand to the conditional operator "
3342 "is of type %<void%>, "
3343 "but the third operand is neither a throw-expression "
3344 "nor of type %<void%>");
3346 error ("third operand to the conditional operator "
3347 "is of type %<void%>, "
3348 "but the second operand is neither a throw-expression "
3349 "nor of type %<void%>");
3350 return error_mark_node
;
3354 goto valid_operands
;
3358 Otherwise, if the second and third operand have different types,
3359 and either has (possibly cv-qualified) class type, an attempt is
3360 made to convert each of those operands to the type of the other. */
3361 else if (!same_type_p (arg2_type
, arg3_type
)
3362 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
3367 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3368 p
= conversion_obstack_alloc (0);
3370 conv2
= conditional_conversion (arg2
, arg3
);
3371 conv3
= conditional_conversion (arg3
, arg2
);
3375 If both can be converted, or one can be converted but the
3376 conversion is ambiguous, the program is ill-formed. If
3377 neither can be converted, the operands are left unchanged and
3378 further checking is performed as described below. If exactly
3379 one conversion is possible, that conversion is applied to the
3380 chosen operand and the converted operand is used in place of
3381 the original operand for the remainder of this section. */
3382 if ((conv2
&& !conv2
->bad_p
3383 && conv3
&& !conv3
->bad_p
)
3384 || (conv2
&& conv2
->kind
== ck_ambig
)
3385 || (conv3
&& conv3
->kind
== ck_ambig
))
3387 error ("operands to ?: have different types %qT and %qT",
3388 arg2_type
, arg3_type
);
3389 result
= error_mark_node
;
3391 else if (conv2
&& (!conv2
->bad_p
|| !conv3
))
3393 arg2
= convert_like (conv2
, arg2
);
3394 arg2
= convert_from_reference (arg2
);
3395 arg2_type
= TREE_TYPE (arg2
);
3396 /* Even if CONV2 is a valid conversion, the result of the
3397 conversion may be invalid. For example, if ARG3 has type
3398 "volatile X", and X does not have a copy constructor
3399 accepting a "volatile X&", then even if ARG2 can be
3400 converted to X, the conversion will fail. */
3401 if (error_operand_p (arg2
))
3402 result
= error_mark_node
;
3404 else if (conv3
&& (!conv3
->bad_p
|| !conv2
))
3406 arg3
= convert_like (conv3
, arg3
);
3407 arg3
= convert_from_reference (arg3
);
3408 arg3_type
= TREE_TYPE (arg3
);
3409 if (error_operand_p (arg3
))
3410 result
= error_mark_node
;
3413 /* Free all the conversions we allocated. */
3414 obstack_free (&conversion_obstack
, p
);
3419 /* If, after the conversion, both operands have class type,
3420 treat the cv-qualification of both operands as if it were the
3421 union of the cv-qualification of the operands.
3423 The standard is not clear about what to do in this
3424 circumstance. For example, if the first operand has type
3425 "const X" and the second operand has a user-defined
3426 conversion to "volatile X", what is the type of the second
3427 operand after this step? Making it be "const X" (matching
3428 the first operand) seems wrong, as that discards the
3429 qualification without actually performing a copy. Leaving it
3430 as "volatile X" seems wrong as that will result in the
3431 conditional expression failing altogether, even though,
3432 according to this step, the one operand could be converted to
3433 the type of the other. */
3434 if ((conv2
|| conv3
)
3435 && CLASS_TYPE_P (arg2_type
)
3436 && TYPE_QUALS (arg2_type
) != TYPE_QUALS (arg3_type
))
3437 arg2_type
= arg3_type
=
3438 cp_build_qualified_type (arg2_type
,
3439 TYPE_QUALS (arg2_type
)
3440 | TYPE_QUALS (arg3_type
));
3445 If the second and third operands are lvalues and have the same
3446 type, the result is of that type and is an lvalue. */
3447 if (real_lvalue_p (arg2
)
3448 && real_lvalue_p (arg3
)
3449 && same_type_p (arg2_type
, arg3_type
))
3451 result_type
= arg2_type
;
3452 goto valid_operands
;
3457 Otherwise, the result is an rvalue. If the second and third
3458 operand do not have the same type, and either has (possibly
3459 cv-qualified) class type, overload resolution is used to
3460 determine the conversions (if any) to be applied to the operands
3461 (_over.match.oper_, _over.built_). */
3463 if (!same_type_p (arg2_type
, arg3_type
)
3464 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
3470 /* Rearrange the arguments so that add_builtin_candidate only has
3471 to know about two args. In build_builtin_candidates, the
3472 arguments are unscrambled. */
3476 add_builtin_candidates (&candidates
,
3479 ansi_opname (COND_EXPR
),
3485 If the overload resolution fails, the program is
3487 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
3490 op_error (COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, "no match");
3491 print_z_candidates (candidates
);
3492 return error_mark_node
;
3494 cand
= tourney (candidates
);
3497 op_error (COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, "no match");
3498 print_z_candidates (candidates
);
3499 return error_mark_node
;
3504 Otherwise, the conversions thus determined are applied, and
3505 the converted operands are used in place of the original
3506 operands for the remainder of this section. */
3507 conv
= cand
->convs
[0];
3508 arg1
= convert_like (conv
, arg1
);
3509 conv
= cand
->convs
[1];
3510 arg2
= convert_like (conv
, arg2
);
3511 conv
= cand
->convs
[2];
3512 arg3
= convert_like (conv
, arg3
);
3517 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3518 and function-to-pointer (_conv.func_) standard conversions are
3519 performed on the second and third operands.
3521 We need to force the lvalue-to-rvalue conversion here for class types,
3522 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3523 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3526 arg2
= force_rvalue (arg2
);
3527 if (!CLASS_TYPE_P (arg2_type
))
3528 arg2_type
= TREE_TYPE (arg2
);
3530 arg3
= force_rvalue (arg3
);
3531 if (!CLASS_TYPE_P (arg2_type
))
3532 arg3_type
= TREE_TYPE (arg3
);
3534 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
3535 return error_mark_node
;
3539 After those conversions, one of the following shall hold:
3541 --The second and third operands have the same type; the result is of
3543 if (same_type_p (arg2_type
, arg3_type
))
3544 result_type
= arg2_type
;
3547 --The second and third operands have arithmetic or enumeration
3548 type; the usual arithmetic conversions are performed to bring
3549 them to a common type, and the result is of that type. */
3550 else if ((ARITHMETIC_TYPE_P (arg2_type
)
3551 || TREE_CODE (arg2_type
) == ENUMERAL_TYPE
)
3552 && (ARITHMETIC_TYPE_P (arg3_type
)
3553 || TREE_CODE (arg3_type
) == ENUMERAL_TYPE
))
3555 /* In this case, there is always a common type. */
3556 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
3559 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
3560 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
3561 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3562 arg2_type
, arg3_type
);
3563 else if (extra_warnings
3564 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
3565 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
3566 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
3567 && !same_type_p (arg2_type
, type_promotes_to (arg3_type
)))))
3568 warning (0, "enumeral and non-enumeral type in conditional expression");
3570 arg2
= perform_implicit_conversion (result_type
, arg2
);
3571 arg3
= perform_implicit_conversion (result_type
, arg3
);
3575 --The second and third operands have pointer type, or one has
3576 pointer type and the other is a null pointer constant; pointer
3577 conversions (_conv.ptr_) and qualification conversions
3578 (_conv.qual_) are performed to bring them to their composite
3579 pointer type (_expr.rel_). The result is of the composite
3582 --The second and third operands have pointer to member type, or
3583 one has pointer to member type and the other is a null pointer
3584 constant; pointer to member conversions (_conv.mem_) and
3585 qualification conversions (_conv.qual_) are performed to bring
3586 them to a common type, whose cv-qualification shall match the
3587 cv-qualification of either the second or the third operand.
3588 The result is of the common type. */
3589 else if ((null_ptr_cst_p (arg2
)
3590 && (TYPE_PTR_P (arg3_type
) || TYPE_PTR_TO_MEMBER_P (arg3_type
)))
3591 || (null_ptr_cst_p (arg3
)
3592 && (TYPE_PTR_P (arg2_type
) || TYPE_PTR_TO_MEMBER_P (arg2_type
)))
3593 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
3594 || (TYPE_PTRMEM_P (arg2_type
) && TYPE_PTRMEM_P (arg3_type
))
3595 || (TYPE_PTRMEMFUNC_P (arg2_type
) && TYPE_PTRMEMFUNC_P (arg3_type
)))
3597 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
3598 arg3
, "conditional expression");
3599 if (result_type
== error_mark_node
)
3600 return error_mark_node
;
3601 arg2
= perform_implicit_conversion (result_type
, arg2
);
3602 arg3
= perform_implicit_conversion (result_type
, arg3
);
3607 error ("operands to ?: have different types %qT and %qT",
3608 arg2_type
, arg3_type
);
3609 return error_mark_node
;
3613 result
= fold_if_not_in_template (build3 (COND_EXPR
, result_type
, arg1
,
3615 /* We can't use result_type below, as fold might have returned a
3620 /* Expand both sides into the same slot, hopefully the target of
3621 the ?: expression. We used to check for TARGET_EXPRs here,
3622 but now we sometimes wrap them in NOP_EXPRs so the test would
3624 if (CLASS_TYPE_P (TREE_TYPE (result
)))
3625 result
= get_target_expr (result
);
3626 /* If this expression is an rvalue, but might be mistaken for an
3627 lvalue, we must add a NON_LVALUE_EXPR. */
3628 result
= rvalue (result
);
3634 /* OPERAND is an operand to an expression. Perform necessary steps
3635 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3639 prep_operand (tree operand
)
3643 if (CLASS_TYPE_P (TREE_TYPE (operand
))
3644 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
3645 /* Make sure the template type is instantiated now. */
3646 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
3652 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3653 OVERLOAD) to the CANDIDATES, returning an updated list of
3654 CANDIDATES. The ARGS are the arguments provided to the call,
3655 without any implicit object parameter. The EXPLICIT_TARGS are
3656 explicit template arguments provided. TEMPLATE_ONLY is true if
3657 only template functions should be considered. CONVERSION_PATH,
3658 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3661 add_candidates (tree fns
, tree args
,
3662 tree explicit_targs
, bool template_only
,
3663 tree conversion_path
, tree access_path
,
3665 struct z_candidate
**candidates
)
3668 tree non_static_args
;
3670 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
3671 /* Delay creating the implicit this parameter until it is needed. */
3672 non_static_args
= NULL_TREE
;
3679 fn
= OVL_CURRENT (fns
);
3680 /* Figure out which set of arguments to use. */
3681 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
3683 /* If this function is a non-static member, prepend the implicit
3684 object parameter. */
3685 if (!non_static_args
)
3686 non_static_args
= tree_cons (NULL_TREE
,
3687 build_this (TREE_VALUE (args
)),
3689 fn_args
= non_static_args
;
3692 /* Otherwise, just use the list of arguments provided. */
3695 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
3696 add_template_candidate (candidates
,
3706 else if (!template_only
)
3707 add_function_candidate (candidates
,
3714 fns
= OVL_NEXT (fns
);
3719 build_new_op (enum tree_code code
, int flags
, tree arg1
, tree arg2
, tree arg3
,
3722 struct z_candidate
*candidates
= 0, *cand
;
3723 tree arglist
, fnname
;
3725 tree result
= NULL_TREE
;
3726 bool result_valid_p
= false;
3727 enum tree_code code2
= NOP_EXPR
;
3732 bool expl_eq_arg1
= false;
3734 if (error_operand_p (arg1
)
3735 || error_operand_p (arg2
)
3736 || error_operand_p (arg3
))
3737 return error_mark_node
;
3739 if (code
== MODIFY_EXPR
)
3741 code2
= TREE_CODE (arg3
);
3743 fnname
= ansi_assopname (code2
);
3746 fnname
= ansi_opname (code
);
3748 arg1
= prep_operand (arg1
);
3754 case VEC_DELETE_EXPR
:
3756 /* Use build_op_new_call and build_op_delete_call instead. */
3760 return build_object_call (arg1
, arg2
);
3762 case TRUTH_ORIF_EXPR
:
3763 case TRUTH_ANDIF_EXPR
:
3764 case TRUTH_AND_EXPR
:
3766 if (COMPARISON_CLASS_P (arg1
))
3767 expl_eq_arg1
= true;
3772 arg2
= prep_operand (arg2
);
3773 arg3
= prep_operand (arg3
);
3775 if (code
== COND_EXPR
)
3777 if (arg2
== NULL_TREE
3778 || TREE_CODE (TREE_TYPE (arg2
)) == VOID_TYPE
3779 || TREE_CODE (TREE_TYPE (arg3
)) == VOID_TYPE
3780 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))
3781 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3
))))
3784 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1
))
3785 && (! arg2
|| ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))))
3788 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
3789 arg2
= integer_zero_node
;
3791 arglist
= NULL_TREE
;
3793 arglist
= tree_cons (NULL_TREE
, arg3
, arglist
);
3795 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3796 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3798 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3799 p
= conversion_obstack_alloc (0);
3801 /* Add namespace-scope operators to the list of functions to
3803 add_candidates (lookup_function_nonclass (fnname
, arglist
, /*block_p=*/true),
3804 arglist
, NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
3805 flags
, &candidates
);
3806 /* Add class-member operators to the candidate set. */
3807 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
3811 fns
= lookup_fnfields (TREE_TYPE (arg1
), fnname
, 1);
3812 if (fns
== error_mark_node
)
3814 result
= error_mark_node
;
3815 goto user_defined_result_ready
;
3818 add_candidates (BASELINK_FUNCTIONS (fns
), arglist
,
3820 BASELINK_BINFO (fns
),
3821 TYPE_BINFO (TREE_TYPE (arg1
)),
3822 flags
, &candidates
);
3825 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3826 to know about two args; a builtin candidate will always have a first
3827 parameter of type bool. We'll handle that in
3828 build_builtin_candidate. */
3829 if (code
== COND_EXPR
)
3839 args
[2] = NULL_TREE
;
3842 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
, flags
);
3848 /* For these, the built-in candidates set is empty
3849 [over.match.oper]/3. We don't want non-strict matches
3850 because exact matches are always possible with built-in
3851 operators. The built-in candidate set for COMPONENT_REF
3852 would be empty too, but since there are no such built-in
3853 operators, we accept non-strict matches for them. */
3858 strict_p
= pedantic
;
3862 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
3867 case POSTINCREMENT_EXPR
:
3868 case POSTDECREMENT_EXPR
:
3869 /* Look for an `operator++ (int)'. If they didn't have
3870 one, then we fall back to the old way of doing things. */
3871 if (flags
& LOOKUP_COMPLAIN
)
3872 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3873 "trying prefix operator instead",
3875 operator_name_info
[code
].name
);
3876 if (code
== POSTINCREMENT_EXPR
)
3877 code
= PREINCREMENT_EXPR
;
3879 code
= PREDECREMENT_EXPR
;
3880 result
= build_new_op (code
, flags
, arg1
, NULL_TREE
, NULL_TREE
,
3884 /* The caller will deal with these. */
3889 result_valid_p
= true;
3893 if (flags
& LOOKUP_COMPLAIN
)
3895 op_error (code
, code2
, arg1
, arg2
, arg3
, "no match");
3896 print_z_candidates (candidates
);
3898 result
= error_mark_node
;
3904 cand
= tourney (candidates
);
3907 if (flags
& LOOKUP_COMPLAIN
)
3909 op_error (code
, code2
, arg1
, arg2
, arg3
, "ambiguous overload");
3910 print_z_candidates (candidates
);
3912 result
= error_mark_node
;
3914 else if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
3917 *overloaded_p
= true;
3919 if (resolve_args (arglist
) == error_mark_node
)
3920 result
= error_mark_node
;
3922 result
= build_over_call (cand
, LOOKUP_NORMAL
);
3926 /* Give any warnings we noticed during overload resolution. */
3929 struct candidate_warning
*w
;
3930 for (w
= cand
->warnings
; w
; w
= w
->next
)
3931 joust (cand
, w
->loser
, 1);
3934 /* Check for comparison of different enum types. */
3943 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
3944 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
3945 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
3946 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
))))
3948 warning (0, "comparison between %q#T and %q#T",
3949 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
3956 /* We need to strip any leading REF_BIND so that bitfields
3957 don't cause errors. This should not remove any important
3958 conversions, because builtins don't apply to class
3959 objects directly. */
3960 conv
= cand
->convs
[0];
3961 if (conv
->kind
== ck_ref_bind
)
3962 conv
= conv
->u
.next
;
3963 arg1
= convert_like (conv
, arg1
);
3966 conv
= cand
->convs
[1];
3967 if (conv
->kind
== ck_ref_bind
)
3968 conv
= conv
->u
.next
;
3969 arg2
= convert_like (conv
, arg2
);
3973 conv
= cand
->convs
[2];
3974 if (conv
->kind
== ck_ref_bind
)
3975 conv
= conv
->u
.next
;
3976 arg3
= convert_like (conv
, arg3
);
3981 warn_logical_operator (code
, arg1
, arg2
);
3982 expl_eq_arg1
= true;
3987 user_defined_result_ready
:
3989 /* Free all the conversions we allocated. */
3990 obstack_free (&conversion_obstack
, p
);
3992 if (result
|| result_valid_p
)
3999 return build_modify_expr (arg1
, code2
, arg2
);
4002 return build_indirect_ref (arg1
, "unary *");
4004 case TRUTH_ANDIF_EXPR
:
4005 case TRUTH_ORIF_EXPR
:
4006 case TRUTH_AND_EXPR
:
4009 warn_logical_operator (code
, arg1
, arg2
);
4013 case TRUNC_DIV_EXPR
:
4024 case TRUNC_MOD_EXPR
:
4028 return cp_build_binary_op (code
, arg1
, arg2
);
4030 case UNARY_PLUS_EXPR
:
4033 case TRUTH_NOT_EXPR
:
4034 case PREINCREMENT_EXPR
:
4035 case POSTINCREMENT_EXPR
:
4036 case PREDECREMENT_EXPR
:
4037 case POSTDECREMENT_EXPR
:
4040 return build_unary_op (code
, arg1
, candidates
!= 0);
4043 return build_array_ref (arg1
, arg2
);
4046 return build_conditional_expr (arg1
, arg2
, arg3
);
4049 return build_m_component_ref (build_indirect_ref (arg1
, NULL
), arg2
);
4051 /* The caller will deal with these. */
4063 /* Build a call to operator delete. This has to be handled very specially,
4064 because the restrictions on what signatures match are different from all
4065 other call instances. For a normal delete, only a delete taking (void *)
4066 or (void *, size_t) is accepted. For a placement delete, only an exact
4067 match with the placement new is accepted.
4069 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4070 ADDR is the pointer to be deleted.
4071 SIZE is the size of the memory block to be deleted.
4072 GLOBAL_P is true if the delete-expression should not consider
4073 class-specific delete operators.
4074 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4076 If this call to "operator delete" is being generated as part to
4077 deallocate memory allocated via a new-expression (as per [expr.new]
4078 which requires that if the initialization throws an exception then
4079 we call a deallocation function), then ALLOC_FN is the allocation
4083 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
4084 bool global_p
, tree placement
,
4087 tree fn
= NULL_TREE
;
4088 tree fns
, fnname
, argtypes
, type
;
4091 if (addr
== error_mark_node
)
4092 return error_mark_node
;
4094 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
4096 fnname
= ansi_opname (code
);
4098 if (CLASS_TYPE_P (type
)
4099 && COMPLETE_TYPE_P (complete_type (type
))
4103 If the result of the lookup is ambiguous or inaccessible, or if
4104 the lookup selects a placement deallocation function, the
4105 program is ill-formed.
4107 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4109 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
4110 if (fns
== error_mark_node
)
4111 return error_mark_node
;
4116 if (fns
== NULL_TREE
)
4117 fns
= lookup_name_nonclass (fnname
);
4119 /* Strip const and volatile from addr. */
4120 addr
= cp_convert (ptr_type_node
, addr
);
4124 /* Get the parameter types for the allocation function that is
4126 gcc_assert (alloc_fn
!= NULL_TREE
);
4127 argtypes
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
4131 /* First try it without the size argument. */
4132 argtypes
= void_list_node
;
4135 /* We make two tries at finding a matching `operator delete'. On
4136 the first pass, we look for a one-operator (or placement)
4137 operator delete. If we're not doing placement delete, then on
4138 the second pass we look for a two-argument delete. */
4139 for (pass
= 0; pass
< (placement
? 1 : 2); ++pass
)
4141 /* Go through the `operator delete' functions looking for one
4142 with a matching type. */
4143 for (fn
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
4149 /* The first argument must be "void *". */
4150 t
= TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn
)));
4151 if (!same_type_p (TREE_VALUE (t
), ptr_type_node
))
4154 /* On the first pass, check the rest of the arguments. */
4160 if (!same_type_p (TREE_VALUE (a
), TREE_VALUE (t
)))
4168 /* On the second pass, look for a function with exactly two
4169 arguments: "void *" and "size_t". */
4171 /* For "operator delete(void *, ...)" there will be
4172 no second argument, but we will not get an exact
4175 && same_type_p (TREE_VALUE (t
), size_type_node
)
4176 && TREE_CHAIN (t
) == void_list_node
)
4180 /* If we found a match, we're done. */
4185 /* If we have a matching function, call it. */
4188 /* Make sure we have the actual function, and not an
4190 fn
= OVL_CURRENT (fn
);
4192 /* If the FN is a member function, make sure that it is
4194 if (DECL_CLASS_SCOPE_P (fn
))
4195 perform_or_defer_access_check (TYPE_BINFO (type
), fn
, fn
);
4199 /* The placement args might not be suitable for overload
4200 resolution at this point, so build the call directly. */
4201 int nargs
= call_expr_nargs (placement
);
4202 tree
*argarray
= (tree
*) alloca (nargs
* sizeof (tree
));
4205 for (i
= 1; i
< nargs
; i
++)
4206 argarray
[i
] = CALL_EXPR_ARG (placement
, i
);
4208 return build_cxx_call (fn
, nargs
, argarray
);
4214 args
= tree_cons (NULL_TREE
, addr
, NULL_TREE
);
4216 args
= tree_cons (NULL_TREE
, addr
,
4217 build_tree_list (NULL_TREE
, size
));
4218 return build_function_call (fn
, args
);
4224 If no unambiguous matching deallocation function can be found,
4225 propagating the exception does not cause the object's memory to
4230 warning (0, "no corresponding deallocation function for `%D'",
4235 error ("no suitable %<operator %s%> for %qT",
4236 operator_name_info
[(int)code
].name
, type
);
4237 return error_mark_node
;
4240 /* If the current scope isn't allowed to access DECL along
4241 BASETYPE_PATH, give an error. The most derived class in
4242 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4243 the declaration to use in the error diagnostic. */
4246 enforce_access (tree basetype_path
, tree decl
, tree diag_decl
)
4248 gcc_assert (TREE_CODE (basetype_path
) == TREE_BINFO
);
4250 if (!accessible_p (basetype_path
, decl
, true))
4252 if (TREE_PRIVATE (decl
))
4253 error ("%q+#D is private", diag_decl
);
4254 else if (TREE_PROTECTED (decl
))
4255 error ("%q+#D is protected", diag_decl
);
4257 error ("%q+#D is inaccessible", diag_decl
);
4258 error ("within this context");
4265 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4266 bitwise or of LOOKUP_* values. If any errors are warnings are
4267 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4268 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4272 build_temp (tree expr
, tree type
, int flags
,
4273 diagnostic_fn_t
*diagnostic_fn
)
4277 savew
= warningcount
, savee
= errorcount
;
4278 expr
= build_special_member_call (NULL_TREE
,
4279 complete_ctor_identifier
,
4280 build_tree_list (NULL_TREE
, expr
),
4282 if (warningcount
> savew
)
4283 *diagnostic_fn
= warning0
;
4284 else if (errorcount
> savee
)
4285 *diagnostic_fn
= error
;
4287 *diagnostic_fn
= NULL
;
4291 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4292 EXPR is implicitly converted to type TOTYPE.
4293 FN and ARGNUM are used for diagnostics. */
4296 conversion_null_warnings (tree totype
, tree expr
, tree fn
, int argnum
)
4298 tree t
= non_reference (totype
);
4300 /* Issue warnings about peculiar, but valid, uses of NULL. */
4301 if (expr
== null_node
&& TREE_CODE (t
) != BOOLEAN_TYPE
&& ARITHMETIC_TYPE_P (t
))
4304 warning (OPT_Wconversion
, "passing NULL to non-pointer argument %P of %qD",
4307 warning (OPT_Wconversion
, "converting to non-pointer type %qT from NULL", t
);
4310 /* Issue warnings if "false" is converted to a NULL pointer */
4311 else if (expr
== boolean_false_node
&& fn
&& POINTER_TYPE_P (t
))
4312 warning (OPT_Wconversion
,
4313 "converting %<false%> to pointer type for argument %P of %qD",
4317 /* Perform the conversions in CONVS on the expression EXPR. FN and
4318 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4319 indicates the `this' argument of a method. INNER is nonzero when
4320 being called to continue a conversion chain. It is negative when a
4321 reference binding will be applied, positive otherwise. If
4322 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4323 conversions will be emitted if appropriate. If C_CAST_P is true,
4324 this conversion is coming from a C-style cast; in that case,
4325 conversions to inaccessible bases are permitted. */
4328 convert_like_real (conversion
*convs
, tree expr
, tree fn
, int argnum
,
4329 int inner
, bool issue_conversion_warnings
,
4332 tree totype
= convs
->type
;
4333 diagnostic_fn_t diagnostic_fn
;
4336 && convs
->kind
!= ck_user
4337 && convs
->kind
!= ck_ambig
4338 && convs
->kind
!= ck_ref_bind
)
4340 conversion
*t
= convs
;
4341 for (; t
; t
= convs
->u
.next
)
4343 if (t
->kind
== ck_user
|| !t
->bad_p
)
4345 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
4346 /*issue_conversion_warnings=*/false,
4347 /*c_cast_p=*/false);
4350 else if (t
->kind
== ck_ambig
)
4351 return convert_like_real (t
, expr
, fn
, argnum
, 1,
4352 /*issue_conversion_warnings=*/false,
4353 /*c_cast_p=*/false);
4354 else if (t
->kind
== ck_identity
)
4357 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr
), totype
);
4359 pedwarn (" initializing argument %P of %qD", argnum
, fn
);
4360 return cp_convert (totype
, expr
);
4363 if (issue_conversion_warnings
)
4364 conversion_null_warnings (totype
, expr
, fn
, argnum
);
4366 switch (convs
->kind
)
4370 struct z_candidate
*cand
= convs
->cand
;
4371 tree convfn
= cand
->fn
;
4373 expr
= build_over_call (cand
, LOOKUP_NORMAL
);
4375 /* If this is a constructor or a function returning an aggr type,
4376 we need to build up a TARGET_EXPR. */
4377 if (DECL_CONSTRUCTOR_P (convfn
))
4378 expr
= build_cplus_new (totype
, expr
);
4380 /* The result of the call is then used to direct-initialize the object
4381 that is the destination of the copy-initialization. [dcl.init]
4383 Note that this step is not reflected in the conversion sequence;
4384 it affects the semantics when we actually perform the
4385 conversion, but is not considered during overload resolution.
4387 If the target is a class, that means call a ctor. */
4388 if (IS_AGGR_TYPE (totype
)
4389 && (inner
>= 0 || !lvalue_p (expr
)))
4393 /* Core issue 84, now a DR, says that we don't
4394 allow UDCs for these args (which deliberately
4395 breaks copy-init of an auto_ptr<Base> from an
4396 auto_ptr<Derived>). */
4397 LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
,
4404 (" initializing argument %P of %qD from result of %qD",
4405 argnum
, fn
, convfn
);
4408 (" initializing temporary from result of %qD", convfn
);
4410 expr
= build_cplus_new (totype
, expr
);
4415 if (type_unknown_p (expr
))
4416 expr
= instantiate_type (totype
, expr
, tf_warning_or_error
);
4417 /* Convert a constant to its underlying value, unless we are
4418 about to bind it to a reference, in which case we need to
4419 leave it as an lvalue. */
4422 expr
= decl_constant_value (expr
);
4423 if (expr
== null_node
&& INTEGRAL_TYPE_P (totype
))
4424 /* If __null has been converted to an integer type, we do not
4425 want to warn about uses of EXPR as an integer, rather than
4427 expr
= build_int_cst (totype
, 0);
4431 /* Call build_user_type_conversion again for the error. */
4432 return build_user_type_conversion
4433 (totype
, convs
->u
.expr
, LOOKUP_NORMAL
);
4439 expr
= convert_like_real (convs
->u
.next
, expr
, fn
, argnum
,
4440 convs
->kind
== ck_ref_bind
? -1 : 1,
4441 convs
->kind
== ck_ref_bind
? issue_conversion_warnings
: false,
4443 if (expr
== error_mark_node
)
4444 return error_mark_node
;
4446 switch (convs
->kind
)
4449 expr
= convert_bitfield_to_declared_type (expr
);
4450 if (! IS_AGGR_TYPE (totype
))
4452 /* Else fall through. */
4454 if (convs
->kind
== ck_base
&& !convs
->need_temporary_p
)
4456 /* We are going to bind a reference directly to a base-class
4457 subobject of EXPR. */
4458 /* Build an expression for `*((base*) &expr)'. */
4459 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
4460 expr
= convert_to_base (expr
, build_pointer_type (totype
),
4461 !c_cast_p
, /*nonnull=*/true);
4462 expr
= build_indirect_ref (expr
, "implicit conversion");
4466 /* Copy-initialization where the cv-unqualified version of the source
4467 type is the same class as, or a derived class of, the class of the
4468 destination [is treated as direct-initialization]. [dcl.init] */
4469 expr
= build_temp (expr
, totype
, LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
,
4471 if (diagnostic_fn
&& fn
)
4472 diagnostic_fn (" initializing argument %P of %qD", argnum
, fn
);
4473 return build_cplus_new (totype
, expr
);
4477 tree ref_type
= totype
;
4479 /* If necessary, create a temporary.
4481 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
4482 that need temporaries, even when their types are reference
4483 compatible with the type of reference being bound, so the
4484 upcoming call to build_unary_op (ADDR_EXPR, expr, ...)
4486 if (convs
->need_temporary_p
4487 || TREE_CODE (expr
) == CONSTRUCTOR
4488 || TREE_CODE (expr
) == VA_ARG_EXPR
)
4490 tree type
= convs
->u
.next
->type
;
4491 cp_lvalue_kind lvalue
= real_lvalue_p (expr
);
4493 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type
))
4494 && !TYPE_REF_IS_RVALUE (ref_type
))
4496 /* If the reference is volatile or non-const, we
4497 cannot create a temporary. */
4498 if (lvalue
& clk_bitfield
)
4499 error ("cannot bind bitfield %qE to %qT",
4501 else if (lvalue
& clk_packed
)
4502 error ("cannot bind packed field %qE to %qT",
4505 error ("cannot bind rvalue %qE to %qT", expr
, ref_type
);
4506 return error_mark_node
;
4508 /* If the source is a packed field, and we must use a copy
4509 constructor, then building the target expr will require
4510 binding the field to the reference parameter to the
4511 copy constructor, and we'll end up with an infinite
4512 loop. If we can use a bitwise copy, then we'll be
4514 if ((lvalue
& clk_packed
)
4515 && CLASS_TYPE_P (type
)
4516 && !TYPE_HAS_TRIVIAL_INIT_REF (type
))
4518 error ("cannot bind packed field %qE to %qT",
4520 return error_mark_node
;
4522 expr
= build_target_expr_with_type (expr
, type
);
4525 /* Take the address of the thing to which we will bind the
4527 expr
= build_unary_op (ADDR_EXPR
, expr
, 1);
4528 if (expr
== error_mark_node
)
4529 return error_mark_node
;
4531 /* Convert it to a pointer to the type referred to by the
4532 reference. This will adjust the pointer if a derived to
4533 base conversion is being performed. */
4534 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
4536 /* Convert the pointer to the desired reference type. */
4537 return build_nop (ref_type
, expr
);
4541 return decay_conversion (expr
);
4544 /* Warn about deprecated conversion if appropriate. */
4545 string_conv_p (totype
, expr
, 1);
4550 expr
= convert_to_base (expr
, totype
, !c_cast_p
,
4552 return build_nop (totype
, expr
);
4555 return convert_ptrmem (totype
, expr
, /*allow_inverse_p=*/false,
4562 if (issue_conversion_warnings
)
4563 expr
= convert_and_check (totype
, expr
);
4565 expr
= convert (totype
, expr
);
4570 /* Build a call to __builtin_trap. */
4573 call_builtin_trap (void)
4575 tree fn
= implicit_built_in_decls
[BUILT_IN_TRAP
];
4577 gcc_assert (fn
!= NULL
);
4578 fn
= build_call_n (fn
, 0);
4582 /* ARG is being passed to a varargs function. Perform any conversions
4583 required. Return the converted value. */
4586 convert_arg_to_ellipsis (tree arg
)
4590 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4591 standard conversions are performed. */
4592 arg
= decay_conversion (arg
);
4595 If the argument has integral or enumeration type that is subject
4596 to the integral promotions (_conv.prom_), or a floating point
4597 type that is subject to the floating point promotion
4598 (_conv.fpprom_), the value of the argument is converted to the
4599 promoted type before the call. */
4600 if (TREE_CODE (TREE_TYPE (arg
)) == REAL_TYPE
4601 && (TYPE_PRECISION (TREE_TYPE (arg
))
4602 < TYPE_PRECISION (double_type_node
)))
4603 arg
= convert_to_real (double_type_node
, arg
);
4604 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
4605 arg
= perform_integral_promotions (arg
);
4607 arg
= require_complete_type (arg
);
4609 if (arg
!= error_mark_node
4610 && !pod_type_p (TREE_TYPE (arg
)))
4612 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4613 here and do a bitwise copy, but now cp_expr_size will abort if we
4615 If the call appears in the context of a sizeof expression,
4616 there is no need to emit a warning, since the expression won't be
4617 evaluated. We keep the builtin_trap just as a safety check. */
4618 if (!skip_evaluation
)
4619 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4620 "call will abort at runtime", TREE_TYPE (arg
));
4621 arg
= call_builtin_trap ();
4622 arg
= build2 (COMPOUND_EXPR
, integer_type_node
, arg
,
4629 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4632 build_x_va_arg (tree expr
, tree type
)
4634 if (processing_template_decl
)
4635 return build_min (VA_ARG_EXPR
, type
, expr
);
4637 type
= complete_type_or_else (type
, NULL_TREE
);
4639 if (expr
== error_mark_node
|| !type
)
4640 return error_mark_node
;
4642 if (! pod_type_p (type
))
4644 /* Remove reference types so we don't ICE later on. */
4645 tree type1
= non_reference (type
);
4646 /* Undefined behavior [expr.call] 5.2.2/7. */
4647 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4648 "call will abort at runtime", type
);
4649 expr
= convert (build_pointer_type (type1
), null_node
);
4650 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
),
4651 call_builtin_trap (), expr
);
4652 expr
= build_indirect_ref (expr
, NULL
);
4656 return build_va_arg (expr
, type
);
4659 /* TYPE has been given to va_arg. Apply the default conversions which
4660 would have happened when passed via ellipsis. Return the promoted
4661 type, or the passed type if there is no change. */
4664 cxx_type_promotes_to (tree type
)
4668 /* Perform the array-to-pointer and function-to-pointer
4670 type
= type_decays_to (type
);
4672 promote
= type_promotes_to (type
);
4673 if (same_type_p (type
, promote
))
4679 /* ARG is a default argument expression being passed to a parameter of
4680 the indicated TYPE, which is a parameter to FN. Do any required
4681 conversions. Return the converted value. */
4683 static GTY(()) VEC(tree
,gc
) *default_arg_context
;
4686 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
)
4691 /* If the ARG is an unparsed default argument expression, the
4692 conversion cannot be performed. */
4693 if (TREE_CODE (arg
) == DEFAULT_ARG
)
4695 error ("the default argument for parameter %d of %qD has "
4696 "not yet been parsed",
4698 return error_mark_node
;
4701 /* Detect recursion. */
4702 for (i
= 0; VEC_iterate (tree
, default_arg_context
, i
, t
); ++i
)
4705 error ("recursive evaluation of default argument for %q#D", fn
);
4706 return error_mark_node
;
4708 VEC_safe_push (tree
, gc
, default_arg_context
, fn
);
4710 if (fn
&& DECL_TEMPLATE_INFO (fn
))
4711 arg
= tsubst_default_argument (fn
, type
, arg
);
4713 arg
= break_out_target_exprs (arg
);
4715 if (TREE_CODE (arg
) == CONSTRUCTOR
)
4717 arg
= digest_init (type
, arg
);
4718 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4719 "default argument", fn
, parmnum
);
4723 /* We must make a copy of ARG, in case subsequent processing
4724 alters any part of it. For example, during gimplification a
4725 cast of the form (T) &X::f (where "f" is a member function)
4726 will lead to replacing the PTRMEM_CST for &X::f with a
4727 VAR_DECL. We can avoid the copy for constants, since they
4728 are never modified in place. */
4729 if (!CONSTANT_CLASS_P (arg
))
4730 arg
= unshare_expr (arg
);
4731 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4732 "default argument", fn
, parmnum
);
4733 arg
= convert_for_arg_passing (type
, arg
);
4736 VEC_pop (tree
, default_arg_context
);
4741 /* Returns the type which will really be used for passing an argument of
4745 type_passed_as (tree type
)
4747 /* Pass classes with copy ctors by invisible reference. */
4748 if (TREE_ADDRESSABLE (type
))
4750 type
= build_reference_type (type
);
4751 /* There are no other pointers to this temporary. */
4752 type
= build_qualified_type (type
, TYPE_QUAL_RESTRICT
);
4754 else if (targetm
.calls
.promote_prototypes (type
)
4755 && INTEGRAL_TYPE_P (type
)
4756 && COMPLETE_TYPE_P (type
)
4757 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type
),
4758 TYPE_SIZE (integer_type_node
)))
4759 type
= integer_type_node
;
4764 /* Actually perform the appropriate conversion. */
4767 convert_for_arg_passing (tree type
, tree val
)
4771 /* If VAL is a bitfield, then -- since it has already been converted
4772 to TYPE -- it cannot have a precision greater than TYPE.
4774 If it has a smaller precision, we must widen it here. For
4775 example, passing "int f:3;" to a function expecting an "int" will
4776 not result in any conversion before this point.
4778 If the precision is the same we must not risk widening. For
4779 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
4780 often have type "int", even though the C++ type for the field is
4781 "long long". If the value is being passed to a function
4782 expecting an "int", then no conversions will be required. But,
4783 if we call convert_bitfield_to_declared_type, the bitfield will
4784 be converted to "long long". */
4785 bitfield_type
= is_bitfield_expr_with_lowered_type (val
);
4787 && TYPE_PRECISION (TREE_TYPE (val
)) < TYPE_PRECISION (type
))
4788 val
= convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type
), val
);
4790 if (val
== error_mark_node
)
4792 /* Pass classes with copy ctors by invisible reference. */
4793 else if (TREE_ADDRESSABLE (type
))
4794 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
4795 else if (targetm
.calls
.promote_prototypes (type
)
4796 && INTEGRAL_TYPE_P (type
)
4797 && COMPLETE_TYPE_P (type
)
4798 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type
),
4799 TYPE_SIZE (integer_type_node
)))
4800 val
= perform_integral_promotions (val
);
4801 if (warn_missing_format_attribute
)
4803 tree rhstype
= TREE_TYPE (val
);
4804 const enum tree_code coder
= TREE_CODE (rhstype
);
4805 const enum tree_code codel
= TREE_CODE (type
);
4806 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
4808 && check_missing_format_attribute (type
, rhstype
))
4809 warning (OPT_Wmissing_format_attribute
,
4810 "argument of function call might be a candidate for a format attribute");
4815 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4816 which no conversions at all should be done. This is true for some
4817 builtins which don't act like normal functions. */
4820 magic_varargs_p (tree fn
)
4822 if (DECL_BUILT_IN (fn
))
4823 switch (DECL_FUNCTION_CODE (fn
))
4825 case BUILT_IN_CLASSIFY_TYPE
:
4826 case BUILT_IN_CONSTANT_P
:
4827 case BUILT_IN_NEXT_ARG
:
4828 case BUILT_IN_STDARG_START
:
4829 case BUILT_IN_VA_START
:
4833 return lookup_attribute ("type generic",
4834 TYPE_ATTRIBUTES (TREE_TYPE (fn
))) != 0;
4840 /* Subroutine of the various build_*_call functions. Overload resolution
4841 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4842 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4843 bitmask of various LOOKUP_* flags which apply to the call itself. */
4846 build_over_call (struct z_candidate
*cand
, int flags
)
4849 tree args
= cand
->args
;
4850 conversion
**convs
= cand
->convs
;
4852 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
4861 /* In a template, there is no need to perform all of the work that
4862 is normally done. We are only interested in the type of the call
4863 expression, i.e., the return type of the function. Any semantic
4864 errors will be deferred until the template is instantiated. */
4865 if (processing_template_decl
)
4869 return_type
= TREE_TYPE (TREE_TYPE (fn
));
4870 expr
= build_call_list (return_type
, fn
, args
);
4871 if (TREE_THIS_VOLATILE (fn
) && cfun
)
4872 current_function_returns_abnormally
= 1;
4873 if (!VOID_TYPE_P (return_type
))
4874 require_complete_type (return_type
);
4875 return convert_from_reference (expr
);
4878 /* Give any warnings we noticed during overload resolution. */
4881 struct candidate_warning
*w
;
4882 for (w
= cand
->warnings
; w
; w
= w
->next
)
4883 joust (cand
, w
->loser
, 1);
4886 if (DECL_FUNCTION_MEMBER_P (fn
))
4888 /* If FN is a template function, two cases must be considered.
4893 template <class T> void f();
4895 template <class T> struct B {
4899 struct C : A, B<int> {
4901 using B<int>::g; // #2
4904 In case #1 where `A::f' is a member template, DECL_ACCESS is
4905 recorded in the primary template but not in its specialization.
4906 We check access of FN using its primary template.
4908 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4909 because it is a member of class template B, DECL_ACCESS is
4910 recorded in the specialization `B<int>::g'. We cannot use its
4911 primary template because `B<T>::g' and `B<int>::g' may have
4912 different access. */
4913 if (DECL_TEMPLATE_INFO (fn
)
4914 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn
)))
4915 perform_or_defer_access_check (cand
->access_path
,
4916 DECL_TI_TEMPLATE (fn
), fn
);
4918 perform_or_defer_access_check (cand
->access_path
, fn
, fn
);
4921 if (args
&& TREE_CODE (args
) != TREE_LIST
)
4922 args
= build_tree_list (NULL_TREE
, args
);
4925 /* Find maximum size of vector to hold converted arguments. */
4926 parmlen
= list_length (parm
);
4927 nargs
= list_length (args
);
4928 if (parmlen
> nargs
)
4930 argarray
= (tree
*) alloca (nargs
* sizeof (tree
));
4932 /* The implicit parameters to a constructor are not considered by overload
4933 resolution, and must be of the proper type. */
4934 if (DECL_CONSTRUCTOR_P (fn
))
4936 argarray
[j
++] = TREE_VALUE (arg
);
4937 arg
= TREE_CHAIN (arg
);
4938 parm
= TREE_CHAIN (parm
);
4939 /* We should never try to call the abstract constructor. */
4940 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn
));
4942 if (DECL_HAS_VTT_PARM_P (fn
))
4944 argarray
[j
++] = TREE_VALUE (arg
);
4945 arg
= TREE_CHAIN (arg
);
4946 parm
= TREE_CHAIN (parm
);
4949 /* Bypass access control for 'this' parameter. */
4950 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4952 tree parmtype
= TREE_VALUE (parm
);
4953 tree argtype
= TREE_TYPE (TREE_VALUE (arg
));
4957 if (convs
[i
]->bad_p
)
4958 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4959 TREE_TYPE (argtype
), fn
);
4961 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4962 X is called for an object that is not of type X, or of a type
4963 derived from X, the behavior is undefined.
4965 So we can assume that anything passed as 'this' is non-null, and
4966 optimize accordingly. */
4967 gcc_assert (TREE_CODE (parmtype
) == POINTER_TYPE
);
4968 /* Convert to the base in which the function was declared. */
4969 gcc_assert (cand
->conversion_path
!= NULL_TREE
);
4970 converted_arg
= build_base_path (PLUS_EXPR
,
4972 cand
->conversion_path
,
4974 /* Check that the base class is accessible. */
4975 if (!accessible_base_p (TREE_TYPE (argtype
),
4976 BINFO_TYPE (cand
->conversion_path
), true))
4977 error ("%qT is not an accessible base of %qT",
4978 BINFO_TYPE (cand
->conversion_path
),
4979 TREE_TYPE (argtype
));
4980 /* If fn was found by a using declaration, the conversion path
4981 will be to the derived class, not the base declaring fn. We
4982 must convert from derived to base. */
4983 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
4984 TREE_TYPE (parmtype
), ba_unique
, NULL
);
4985 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
4988 argarray
[j
++] = converted_arg
;
4989 parm
= TREE_CHAIN (parm
);
4990 arg
= TREE_CHAIN (arg
);
4996 parm
= TREE_CHAIN (parm
), arg
= TREE_CHAIN (arg
), ++i
)
4998 tree type
= TREE_VALUE (parm
);
5002 /* Don't make a copy here if build_call is going to. */
5003 if (conv
->kind
== ck_rvalue
5004 && COMPLETE_TYPE_P (complete_type (type
))
5005 && !TREE_ADDRESSABLE (type
))
5006 conv
= conv
->u
.next
;
5008 val
= convert_like_with_context
5009 (conv
, TREE_VALUE (arg
), fn
, i
- is_method
);
5011 val
= convert_for_arg_passing (type
, val
);
5012 argarray
[j
++] = val
;
5015 /* Default arguments */
5016 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
5017 argarray
[j
++] = convert_default_arg (TREE_VALUE (parm
),
5018 TREE_PURPOSE (parm
),
5021 for (; arg
; arg
= TREE_CHAIN (arg
))
5023 tree a
= TREE_VALUE (arg
);
5024 if (magic_varargs_p (fn
))
5025 /* Do no conversions for magic varargs. */;
5027 a
= convert_arg_to_ellipsis (a
);
5031 gcc_assert (j
<= nargs
);
5034 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn
)),
5035 nargs
, argarray
, TYPE_ARG_TYPES (TREE_TYPE (fn
)));
5037 /* Avoid actually calling copy constructors and copy assignment operators,
5040 if (! flag_elide_constructors
)
5041 /* Do things the hard way. */;
5042 else if (cand
->num_convs
== 1
5043 && (DECL_COPY_CONSTRUCTOR_P (fn
)
5044 || DECL_MOVE_CONSTRUCTOR_P (fn
)))
5047 arg
= argarray
[num_artificial_parms_for (fn
)];
5049 /* Pull out the real argument, disregarding const-correctness. */
5051 while (TREE_CODE (targ
) == NOP_EXPR
5052 || TREE_CODE (targ
) == NON_LVALUE_EXPR
5053 || TREE_CODE (targ
) == CONVERT_EXPR
)
5054 targ
= TREE_OPERAND (targ
, 0);
5055 if (TREE_CODE (targ
) == ADDR_EXPR
)
5057 targ
= TREE_OPERAND (targ
, 0);
5058 if (!same_type_ignoring_top_level_qualifiers_p
5059 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
5068 arg
= build_indirect_ref (arg
, 0);
5070 /* [class.copy]: the copy constructor is implicitly defined even if
5071 the implementation elided its use. */
5072 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn
)))
5075 /* If we're creating a temp and we already have one, don't create a
5076 new one. If we're not creating a temp but we get one, use
5077 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5078 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5079 temp or an INIT_EXPR otherwise. */
5080 if (integer_zerop (TREE_VALUE (args
)))
5082 if (TREE_CODE (arg
) == TARGET_EXPR
)
5084 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5085 return build_target_expr_with_type (arg
, DECL_CONTEXT (fn
));
5087 else if (TREE_CODE (arg
) == TARGET_EXPR
5088 || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
))
5089 && !move_fn_p (fn
)))
5091 tree to
= stabilize_reference
5092 (build_indirect_ref (TREE_VALUE (args
), 0));
5094 val
= build2 (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
5098 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
5100 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn
)))
5102 tree to
= stabilize_reference
5103 (build_indirect_ref (argarray
[0], 0));
5104 tree type
= TREE_TYPE (to
);
5105 tree as_base
= CLASSTYPE_AS_BASE (type
);
5108 if (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (as_base
)))
5110 arg
= build_indirect_ref (arg
, 0);
5111 val
= build2 (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
5115 /* We must only copy the non-tail padding parts.
5116 Use __builtin_memcpy for the bitwise copy. */
5118 tree arg0
, arg1
, arg2
, t
;
5120 arg2
= TYPE_SIZE_UNIT (as_base
);
5122 arg0
= build_unary_op (ADDR_EXPR
, to
, 0);
5123 t
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
5124 t
= build_call_n (t
, 3, arg0
, arg1
, arg2
);
5126 t
= convert (TREE_TYPE (arg0
), t
);
5127 val
= build_indirect_ref (t
, 0);
5135 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
5138 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (argarray
[0])),
5141 gcc_assert (binfo
&& binfo
!= error_mark_node
);
5143 /* Warn about deprecated virtual functions now, since we're about
5144 to throw away the decl. */
5145 if (TREE_DEPRECATED (fn
))
5146 warn_deprecated_use (fn
);
5148 argarray
[0] = build_base_path (PLUS_EXPR
, argarray
[0], binfo
, 1);
5149 if (TREE_SIDE_EFFECTS (argarray
[0]))
5150 argarray
[0] = save_expr (argarray
[0]);
5151 t
= build_pointer_type (TREE_TYPE (fn
));
5152 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
5153 fn
= build_java_interface_fn_ref (fn
, argarray
[0]);
5155 fn
= build_vfn_ref (argarray
[0], DECL_VINDEX (fn
));
5158 else if (DECL_INLINE (fn
))
5159 fn
= inline_conversion (fn
);
5161 fn
= build_addr_func (fn
);
5163 return build_cxx_call (fn
, nargs
, argarray
);
5166 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5167 This function performs no overload resolution, conversion, or other
5168 high-level operations. */
5171 build_cxx_call (tree fn
, int nargs
, tree
*argarray
)
5175 fn
= build_call_a (fn
, nargs
, argarray
);
5177 /* If this call might throw an exception, note that fact. */
5178 fndecl
= get_callee_fndecl (fn
);
5179 if ((!fndecl
|| !TREE_NOTHROW (fndecl
))
5180 && at_function_scope_p ()
5182 cp_function_chain
->can_throw
= 1;
5184 /* Some built-in function calls will be evaluated at compile-time in
5186 fn
= fold_if_not_in_template (fn
);
5188 if (VOID_TYPE_P (TREE_TYPE (fn
)))
5191 fn
= require_complete_type (fn
);
5192 if (fn
== error_mark_node
)
5193 return error_mark_node
;
5195 if (IS_AGGR_TYPE (TREE_TYPE (fn
)))
5196 fn
= build_cplus_new (TREE_TYPE (fn
), fn
);
5197 return convert_from_reference (fn
);
5200 static GTY(()) tree java_iface_lookup_fn
;
5202 /* Make an expression which yields the address of the Java interface
5203 method FN. This is achieved by generating a call to libjava's
5204 _Jv_LookupInterfaceMethodIdx(). */
5207 build_java_interface_fn_ref (tree fn
, tree instance
)
5209 tree lookup_fn
, method
, idx
;
5210 tree klass_ref
, iface
, iface_ref
;
5213 if (!java_iface_lookup_fn
)
5215 tree endlink
= build_void_list_node ();
5216 tree t
= tree_cons (NULL_TREE
, ptr_type_node
,
5217 tree_cons (NULL_TREE
, ptr_type_node
,
5218 tree_cons (NULL_TREE
, java_int_type_node
,
5220 java_iface_lookup_fn
5221 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5222 build_function_type (ptr_type_node
, t
),
5223 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
5226 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5227 This is the first entry in the vtable. */
5228 klass_ref
= build_vtbl_ref (build_indirect_ref (instance
, 0),
5231 /* Get the java.lang.Class pointer for the interface being called. */
5232 iface
= DECL_CONTEXT (fn
);
5233 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
5234 if (!iface_ref
|| TREE_CODE (iface_ref
) != VAR_DECL
5235 || DECL_CONTEXT (iface_ref
) != iface
)
5237 error ("could not find class$ field in java interface type %qT",
5239 return error_mark_node
;
5241 iface_ref
= build_address (iface_ref
);
5242 iface_ref
= convert (build_pointer_type (iface
), iface_ref
);
5244 /* Determine the itable index of FN. */
5246 for (method
= TYPE_METHODS (iface
); method
; method
= TREE_CHAIN (method
))
5248 if (!DECL_VIRTUAL_P (method
))
5254 idx
= build_int_cst (NULL_TREE
, i
);
5256 lookup_fn
= build1 (ADDR_EXPR
,
5257 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
5258 java_iface_lookup_fn
);
5259 return build_call_nary (ptr_type_node
, lookup_fn
,
5260 3, klass_ref
, iface_ref
, idx
);
5263 /* Returns the value to use for the in-charge parameter when making a
5264 call to a function with the indicated NAME.
5266 FIXME:Can't we find a neater way to do this mapping? */
5269 in_charge_arg_for_name (tree name
)
5271 if (name
== base_ctor_identifier
5272 || name
== base_dtor_identifier
)
5273 return integer_zero_node
;
5274 else if (name
== complete_ctor_identifier
)
5275 return integer_one_node
;
5276 else if (name
== complete_dtor_identifier
)
5277 return integer_two_node
;
5278 else if (name
== deleting_dtor_identifier
)
5279 return integer_three_node
;
5281 /* This function should only be called with one of the names listed
5287 /* Build a call to a constructor, destructor, or an assignment
5288 operator for INSTANCE, an expression with class type. NAME
5289 indicates the special member function to call; ARGS are the
5290 arguments. BINFO indicates the base of INSTANCE that is to be
5291 passed as the `this' parameter to the member function called.
5293 FLAGS are the LOOKUP_* flags to use when processing the call.
5295 If NAME indicates a complete object constructor, INSTANCE may be
5296 NULL_TREE. In this case, the caller will call build_cplus_new to
5297 store the newly constructed object into a VAR_DECL. */
5300 build_special_member_call (tree instance
, tree name
, tree args
,
5301 tree binfo
, int flags
)
5304 /* The type of the subobject to be constructed or destroyed. */
5307 gcc_assert (name
== complete_ctor_identifier
5308 || name
== base_ctor_identifier
5309 || name
== complete_dtor_identifier
5310 || name
== base_dtor_identifier
5311 || name
== deleting_dtor_identifier
5312 || name
== ansi_assopname (NOP_EXPR
));
5315 /* Resolve the name. */
5316 if (!complete_type_or_else (binfo
, NULL_TREE
))
5317 return error_mark_node
;
5319 binfo
= TYPE_BINFO (binfo
);
5322 gcc_assert (binfo
!= NULL_TREE
);
5324 class_type
= BINFO_TYPE (binfo
);
5326 /* Handle the special case where INSTANCE is NULL_TREE. */
5327 if (name
== complete_ctor_identifier
&& !instance
)
5329 instance
= build_int_cst (build_pointer_type (class_type
), 0);
5330 instance
= build1 (INDIRECT_REF
, class_type
, instance
);
5334 if (name
== complete_dtor_identifier
5335 || name
== base_dtor_identifier
5336 || name
== deleting_dtor_identifier
)
5337 gcc_assert (args
== NULL_TREE
);
5339 /* Convert to the base class, if necessary. */
5340 if (!same_type_ignoring_top_level_qualifiers_p
5341 (TREE_TYPE (instance
), BINFO_TYPE (binfo
)))
5343 if (name
!= ansi_assopname (NOP_EXPR
))
5344 /* For constructors and destructors, either the base is
5345 non-virtual, or it is virtual but we are doing the
5346 conversion from a constructor or destructor for the
5347 complete object. In either case, we can convert
5349 instance
= convert_to_base_statically (instance
, binfo
);
5351 /* However, for assignment operators, we must convert
5352 dynamically if the base is virtual. */
5353 instance
= build_base_path (PLUS_EXPR
, instance
,
5354 binfo
, /*nonnull=*/1);
5358 gcc_assert (instance
!= NULL_TREE
);
5360 fns
= lookup_fnfields (binfo
, name
, 1);
5362 /* When making a call to a constructor or destructor for a subobject
5363 that uses virtual base classes, pass down a pointer to a VTT for
5365 if ((name
== base_ctor_identifier
5366 || name
== base_dtor_identifier
)
5367 && CLASSTYPE_VBASECLASSES (class_type
))
5372 /* If the current function is a complete object constructor
5373 or destructor, then we fetch the VTT directly.
5374 Otherwise, we look it up using the VTT we were given. */
5375 vtt
= TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
5376 vtt
= decay_conversion (vtt
);
5377 vtt
= build3 (COND_EXPR
, TREE_TYPE (vtt
),
5378 build2 (EQ_EXPR
, boolean_type_node
,
5379 current_in_charge_parm
, integer_zero_node
),
5382 gcc_assert (BINFO_SUBVTT_INDEX (binfo
));
5383 sub_vtt
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (vtt
), vtt
,
5384 BINFO_SUBVTT_INDEX (binfo
));
5386 args
= tree_cons (NULL_TREE
, sub_vtt
, args
);
5389 return build_new_method_call (instance
, fns
, args
,
5390 TYPE_BINFO (BINFO_TYPE (binfo
)),
5391 flags
, /*fn=*/NULL
);
5394 /* Return the NAME, as a C string. The NAME indicates a function that
5395 is a member of TYPE. *FREE_P is set to true if the caller must
5396 free the memory returned.
5398 Rather than go through all of this, we should simply set the names
5399 of constructors and destructors appropriately, and dispense with
5400 ctor_identifier, dtor_identifier, etc. */
5403 name_as_c_string (tree name
, tree type
, bool *free_p
)
5407 /* Assume that we will not allocate memory. */
5409 /* Constructors and destructors are special. */
5410 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
5413 = CONST_CAST (char *, IDENTIFIER_POINTER (constructor_name (type
)));
5414 /* For a destructor, add the '~'. */
5415 if (name
== complete_dtor_identifier
5416 || name
== base_dtor_identifier
5417 || name
== deleting_dtor_identifier
)
5419 pretty_name
= concat ("~", pretty_name
, NULL
);
5420 /* Remember that we need to free the memory allocated. */
5424 else if (IDENTIFIER_TYPENAME_P (name
))
5426 pretty_name
= concat ("operator ",
5427 type_as_string (TREE_TYPE (name
),
5428 TFF_PLAIN_IDENTIFIER
),
5430 /* Remember that we need to free the memory allocated. */
5434 pretty_name
= CONST_CAST (char *, IDENTIFIER_POINTER (name
));
5439 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5440 be set, upon return, to the function called. */
5443 build_new_method_call (tree instance
, tree fns
, tree args
,
5444 tree conversion_path
, int flags
,
5447 struct z_candidate
*candidates
= 0, *cand
;
5448 tree explicit_targs
= NULL_TREE
;
5449 tree basetype
= NULL_TREE
;
5452 tree mem_args
= NULL_TREE
, instance_ptr
;
5458 int template_only
= 0;
5465 gcc_assert (instance
!= NULL_TREE
);
5467 /* We don't know what function we're going to call, yet. */
5471 if (error_operand_p (instance
)
5472 || error_operand_p (fns
)
5473 || args
== error_mark_node
)
5474 return error_mark_node
;
5476 if (!BASELINK_P (fns
))
5478 error ("call to non-function %qD", fns
);
5479 return error_mark_node
;
5482 orig_instance
= instance
;
5486 /* Dismantle the baselink to collect all the information we need. */
5487 if (!conversion_path
)
5488 conversion_path
= BASELINK_BINFO (fns
);
5489 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
5490 optype
= BASELINK_OPTYPE (fns
);
5491 fns
= BASELINK_FUNCTIONS (fns
);
5492 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
5494 explicit_targs
= TREE_OPERAND (fns
, 1);
5495 fns
= TREE_OPERAND (fns
, 0);
5498 gcc_assert (TREE_CODE (fns
) == FUNCTION_DECL
5499 || TREE_CODE (fns
) == TEMPLATE_DECL
5500 || TREE_CODE (fns
) == OVERLOAD
);
5501 fn
= get_first_fn (fns
);
5502 name
= DECL_NAME (fn
);
5504 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
5505 gcc_assert (CLASS_TYPE_P (basetype
));
5507 if (processing_template_decl
)
5509 instance
= build_non_dependent_expr (instance
);
5510 args
= build_non_dependent_args (orig_args
);
5513 /* The USER_ARGS are the arguments we will display to users if an
5514 error occurs. The USER_ARGS should not include any
5515 compiler-generated arguments. The "this" pointer hasn't been
5516 added yet. However, we must remove the VTT pointer if this is a
5517 call to a base-class constructor or destructor. */
5519 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
5521 /* Callers should explicitly indicate whether they want to construct
5522 the complete object or just the part without virtual bases. */
5523 gcc_assert (name
!= ctor_identifier
);
5524 /* Similarly for destructors. */
5525 gcc_assert (name
!= dtor_identifier
);
5526 /* Remove the VTT pointer, if present. */
5527 if ((name
== base_ctor_identifier
|| name
== base_dtor_identifier
)
5528 && CLASSTYPE_VBASECLASSES (basetype
))
5529 user_args
= TREE_CHAIN (user_args
);
5532 /* Process the argument list. */
5533 args
= resolve_args (args
);
5534 if (args
== error_mark_node
)
5535 return error_mark_node
;
5537 instance_ptr
= build_this (instance
);
5539 /* It's OK to call destructors and constructors on cv-qualified objects.
5540 Therefore, convert the INSTANCE_PTR to the unqualified type, if
5542 if (DECL_DESTRUCTOR_P (fn
)
5543 || DECL_CONSTRUCTOR_P (fn
))
5545 tree type
= build_pointer_type (basetype
);
5546 if (!same_type_p (type
, TREE_TYPE (instance_ptr
)))
5547 instance_ptr
= build_nop (type
, instance_ptr
);
5549 if (DECL_DESTRUCTOR_P (fn
))
5550 name
= complete_dtor_identifier
;
5552 class_type
= (conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
);
5553 mem_args
= tree_cons (NULL_TREE
, instance_ptr
, args
);
5555 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5556 p
= conversion_obstack_alloc (0);
5558 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
5560 tree t
= OVL_CURRENT (fn
);
5563 /* We can end up here for copy-init of same or base class. */
5564 if ((flags
& LOOKUP_ONLYCONVERTING
)
5565 && DECL_NONCONVERTING_P (t
))
5568 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t
))
5569 this_arglist
= mem_args
;
5571 this_arglist
= args
;
5573 if (TREE_CODE (t
) == TEMPLATE_DECL
)
5574 /* A member template. */
5575 add_template_candidate (&candidates
, t
,
5578 this_arglist
, optype
,
5583 else if (! template_only
)
5584 add_function_candidate (&candidates
, t
,
5592 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
5595 if (!COMPLETE_TYPE_P (basetype
))
5596 cxx_incomplete_type_error (instance_ptr
, basetype
);
5602 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
5603 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5604 basetype
, pretty_name
, user_args
,
5605 TREE_TYPE (TREE_TYPE (instance_ptr
)));
5609 print_z_candidates (candidates
);
5610 call
= error_mark_node
;
5614 cand
= tourney (candidates
);
5620 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
5621 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name
,
5623 print_z_candidates (candidates
);
5626 call
= error_mark_node
;
5632 if (!(flags
& LOOKUP_NONVIRTUAL
)
5633 && DECL_PURE_VIRTUAL_P (fn
)
5634 && instance
== current_class_ref
5635 && (DECL_CONSTRUCTOR_P (current_function_decl
)
5636 || DECL_DESTRUCTOR_P (current_function_decl
)))
5637 /* This is not an error, it is runtime undefined
5639 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl
) ?
5640 "abstract virtual %q#D called from constructor"
5641 : "abstract virtual %q#D called from destructor"),
5644 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
5645 && is_dummy_object (instance_ptr
))
5647 error ("cannot call member function %qD without object",
5649 call
= error_mark_node
;
5653 if (DECL_VINDEX (fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
5654 && resolves_to_fixed_type_p (instance
, 0))
5655 flags
|= LOOKUP_NONVIRTUAL
;
5656 /* Now we know what function is being called. */
5659 /* Build the actual CALL_EXPR. */
5660 call
= build_over_call (cand
, flags
);
5661 /* In an expression of the form `a->f()' where `f' turns
5662 out to be a static member function, `a' is
5663 none-the-less evaluated. */
5664 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
5665 && !is_dummy_object (instance_ptr
)
5666 && TREE_SIDE_EFFECTS (instance_ptr
))
5667 call
= build2 (COMPOUND_EXPR
, TREE_TYPE (call
),
5668 instance_ptr
, call
);
5669 else if (call
!= error_mark_node
5670 && DECL_DESTRUCTOR_P (cand
->fn
)
5671 && !VOID_TYPE_P (TREE_TYPE (call
)))
5672 /* An explicit call of the form "x->~X()" has type
5673 "void". However, on platforms where destructors
5674 return "this" (i.e., those where
5675 targetm.cxx.cdtor_returns_this is true), such calls
5676 will appear to have a return value of pointer type
5677 to the low-level call machinery. We do not want to
5678 change the low-level machinery, since we want to be
5679 able to optimize "delete f()" on such platforms as
5680 "operator delete(~X(f()))" (rather than generating
5681 "t = f(), ~X(t), operator delete (t)"). */
5682 call
= build_nop (void_type_node
, call
);
5687 if (processing_template_decl
&& call
!= error_mark_node
)
5688 call
= (build_min_non_dep_call_list
5690 build_min_nt (COMPONENT_REF
, orig_instance
, orig_fns
, NULL_TREE
),
5693 /* Free all the conversions we allocated. */
5694 obstack_free (&conversion_obstack
, p
);
5699 /* Returns true iff standard conversion sequence ICS1 is a proper
5700 subsequence of ICS2. */
5703 is_subseq (conversion
*ics1
, conversion
*ics2
)
5705 /* We can assume that a conversion of the same code
5706 between the same types indicates a subsequence since we only get
5707 here if the types we are converting from are the same. */
5709 while (ics1
->kind
== ck_rvalue
5710 || ics1
->kind
== ck_lvalue
)
5711 ics1
= ics1
->u
.next
;
5715 while (ics2
->kind
== ck_rvalue
5716 || ics2
->kind
== ck_lvalue
)
5717 ics2
= ics2
->u
.next
;
5719 if (ics2
->kind
== ck_user
5720 || ics2
->kind
== ck_ambig
5721 || ics2
->kind
== ck_identity
)
5722 /* At this point, ICS1 cannot be a proper subsequence of
5723 ICS2. We can get a USER_CONV when we are comparing the
5724 second standard conversion sequence of two user conversion
5728 ics2
= ics2
->u
.next
;
5730 if (ics2
->kind
== ics1
->kind
5731 && same_type_p (ics2
->type
, ics1
->type
)
5732 && same_type_p (ics2
->u
.next
->type
,
5733 ics1
->u
.next
->type
))
5738 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5739 be any _TYPE nodes. */
5742 is_properly_derived_from (tree derived
, tree base
)
5744 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived
))
5745 || !IS_AGGR_TYPE_CODE (TREE_CODE (base
)))
5748 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5749 considers every class derived from itself. */
5750 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
5751 && DERIVED_FROM_P (base
, derived
));
5754 /* We build the ICS for an implicit object parameter as a pointer
5755 conversion sequence. However, such a sequence should be compared
5756 as if it were a reference conversion sequence. If ICS is the
5757 implicit conversion sequence for an implicit object parameter,
5758 modify it accordingly. */
5761 maybe_handle_implicit_object (conversion
**ics
)
5765 /* [over.match.funcs]
5767 For non-static member functions, the type of the
5768 implicit object parameter is "reference to cv X"
5769 where X is the class of which the function is a
5770 member and cv is the cv-qualification on the member
5771 function declaration. */
5772 conversion
*t
= *ics
;
5773 tree reference_type
;
5775 /* The `this' parameter is a pointer to a class type. Make the
5776 implicit conversion talk about a reference to that same class
5778 reference_type
= TREE_TYPE (t
->type
);
5779 reference_type
= build_reference_type (reference_type
);
5781 if (t
->kind
== ck_qual
)
5783 if (t
->kind
== ck_ptr
)
5785 t
= build_identity_conv (TREE_TYPE (t
->type
), NULL_TREE
);
5786 t
= direct_reference_binding (reference_type
, t
);
5788 t
->rvaluedness_matches_p
= 0;
5793 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5794 and return the initial reference binding conversion. Otherwise,
5795 leave *ICS unchanged and return NULL. */
5798 maybe_handle_ref_bind (conversion
**ics
)
5800 if ((*ics
)->kind
== ck_ref_bind
)
5802 conversion
*old_ics
= *ics
;
5803 *ics
= old_ics
->u
.next
;
5804 (*ics
)->user_conv_p
= old_ics
->user_conv_p
;
5805 (*ics
)->bad_p
= old_ics
->bad_p
;
5812 /* Compare two implicit conversion sequences according to the rules set out in
5813 [over.ics.rank]. Return values:
5815 1: ics1 is better than ics2
5816 -1: ics2 is better than ics1
5817 0: ics1 and ics2 are indistinguishable */
5820 compare_ics (conversion
*ics1
, conversion
*ics2
)
5826 tree deref_from_type1
= NULL_TREE
;
5827 tree deref_from_type2
= NULL_TREE
;
5828 tree deref_to_type1
= NULL_TREE
;
5829 tree deref_to_type2
= NULL_TREE
;
5830 conversion_rank rank1
, rank2
;
5832 /* REF_BINDING is nonzero if the result of the conversion sequence
5833 is a reference type. In that case REF_CONV is the reference
5834 binding conversion. */
5835 conversion
*ref_conv1
;
5836 conversion
*ref_conv2
;
5838 /* Handle implicit object parameters. */
5839 maybe_handle_implicit_object (&ics1
);
5840 maybe_handle_implicit_object (&ics2
);
5842 /* Handle reference parameters. */
5843 ref_conv1
= maybe_handle_ref_bind (&ics1
);
5844 ref_conv2
= maybe_handle_ref_bind (&ics2
);
5848 When comparing the basic forms of implicit conversion sequences (as
5849 defined in _over.best.ics_)
5851 --a standard conversion sequence (_over.ics.scs_) is a better
5852 conversion sequence than a user-defined conversion sequence
5853 or an ellipsis conversion sequence, and
5855 --a user-defined conversion sequence (_over.ics.user_) is a
5856 better conversion sequence than an ellipsis conversion sequence
5857 (_over.ics.ellipsis_). */
5858 rank1
= CONVERSION_RANK (ics1
);
5859 rank2
= CONVERSION_RANK (ics2
);
5863 else if (rank1
< rank2
)
5866 if (rank1
== cr_bad
)
5868 /* XXX Isn't this an extension? */
5869 /* Both ICS are bad. We try to make a decision based on what
5870 would have happened if they'd been good. */
5871 if (ics1
->user_conv_p
> ics2
->user_conv_p
5872 || ics1
->rank
> ics2
->rank
)
5874 else if (ics1
->user_conv_p
< ics2
->user_conv_p
5875 || ics1
->rank
< ics2
->rank
)
5878 /* We couldn't make up our minds; try to figure it out below. */
5881 if (ics1
->ellipsis_p
)
5882 /* Both conversions are ellipsis conversions. */
5885 /* User-defined conversion sequence U1 is a better conversion sequence
5886 than another user-defined conversion sequence U2 if they contain the
5887 same user-defined conversion operator or constructor and if the sec-
5888 ond standard conversion sequence of U1 is better than the second
5889 standard conversion sequence of U2. */
5891 if (ics1
->user_conv_p
)
5896 for (t1
= ics1
; t1
->kind
!= ck_user
; t1
= t1
->u
.next
)
5897 if (t1
->kind
== ck_ambig
)
5899 for (t2
= ics2
; t2
->kind
!= ck_user
; t2
= t2
->u
.next
)
5900 if (t2
->kind
== ck_ambig
)
5903 if (t1
->cand
->fn
!= t2
->cand
->fn
)
5906 /* We can just fall through here, after setting up
5907 FROM_TYPE1 and FROM_TYPE2. */
5908 from_type1
= t1
->type
;
5909 from_type2
= t2
->type
;
5916 /* We're dealing with two standard conversion sequences.
5920 Standard conversion sequence S1 is a better conversion
5921 sequence than standard conversion sequence S2 if
5923 --S1 is a proper subsequence of S2 (comparing the conversion
5924 sequences in the canonical form defined by _over.ics.scs_,
5925 excluding any Lvalue Transformation; the identity
5926 conversion sequence is considered to be a subsequence of
5927 any non-identity conversion sequence */
5930 while (t1
->kind
!= ck_identity
)
5932 from_type1
= t1
->type
;
5935 while (t2
->kind
!= ck_identity
)
5937 from_type2
= t2
->type
;
5940 if (same_type_p (from_type1
, from_type2
))
5942 if (is_subseq (ics1
, ics2
))
5944 if (is_subseq (ics2
, ics1
))
5947 /* Otherwise, one sequence cannot be a subsequence of the other; they
5948 don't start with the same type. This can happen when comparing the
5949 second standard conversion sequence in two user-defined conversion
5956 --the rank of S1 is better than the rank of S2 (by the rules
5959 Standard conversion sequences are ordered by their ranks: an Exact
5960 Match is a better conversion than a Promotion, which is a better
5961 conversion than a Conversion.
5963 Two conversion sequences with the same rank are indistinguishable
5964 unless one of the following rules applies:
5966 --A conversion that is not a conversion of a pointer, or pointer
5967 to member, to bool is better than another conversion that is such
5970 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5971 so that we do not have to check it explicitly. */
5972 if (ics1
->rank
< ics2
->rank
)
5974 else if (ics2
->rank
< ics1
->rank
)
5977 to_type1
= ics1
->type
;
5978 to_type2
= ics2
->type
;
5980 if (TYPE_PTR_P (from_type1
)
5981 && TYPE_PTR_P (from_type2
)
5982 && TYPE_PTR_P (to_type1
)
5983 && TYPE_PTR_P (to_type2
))
5985 deref_from_type1
= TREE_TYPE (from_type1
);
5986 deref_from_type2
= TREE_TYPE (from_type2
);
5987 deref_to_type1
= TREE_TYPE (to_type1
);
5988 deref_to_type2
= TREE_TYPE (to_type2
);
5990 /* The rules for pointers to members A::* are just like the rules
5991 for pointers A*, except opposite: if B is derived from A then
5992 A::* converts to B::*, not vice versa. For that reason, we
5993 switch the from_ and to_ variables here. */
5994 else if ((TYPE_PTRMEM_P (from_type1
) && TYPE_PTRMEM_P (from_type2
)
5995 && TYPE_PTRMEM_P (to_type1
) && TYPE_PTRMEM_P (to_type2
))
5996 || (TYPE_PTRMEMFUNC_P (from_type1
)
5997 && TYPE_PTRMEMFUNC_P (from_type2
)
5998 && TYPE_PTRMEMFUNC_P (to_type1
)
5999 && TYPE_PTRMEMFUNC_P (to_type2
)))
6001 deref_to_type1
= TYPE_PTRMEM_CLASS_TYPE (from_type1
);
6002 deref_to_type2
= TYPE_PTRMEM_CLASS_TYPE (from_type2
);
6003 deref_from_type1
= TYPE_PTRMEM_CLASS_TYPE (to_type1
);
6004 deref_from_type2
= TYPE_PTRMEM_CLASS_TYPE (to_type2
);
6007 if (deref_from_type1
!= NULL_TREE
6008 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1
))
6009 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2
)))
6011 /* This was one of the pointer or pointer-like conversions.
6015 --If class B is derived directly or indirectly from class A,
6016 conversion of B* to A* is better than conversion of B* to
6017 void*, and conversion of A* to void* is better than
6018 conversion of B* to void*. */
6019 if (TREE_CODE (deref_to_type1
) == VOID_TYPE
6020 && TREE_CODE (deref_to_type2
) == VOID_TYPE
)
6022 if (is_properly_derived_from (deref_from_type1
,
6025 else if (is_properly_derived_from (deref_from_type2
,
6029 else if (TREE_CODE (deref_to_type1
) == VOID_TYPE
6030 || TREE_CODE (deref_to_type2
) == VOID_TYPE
)
6032 if (same_type_p (deref_from_type1
, deref_from_type2
))
6034 if (TREE_CODE (deref_to_type2
) == VOID_TYPE
)
6036 if (is_properly_derived_from (deref_from_type1
,
6040 /* We know that DEREF_TO_TYPE1 is `void' here. */
6041 else if (is_properly_derived_from (deref_from_type1
,
6046 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1
))
6047 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2
)))
6051 --If class B is derived directly or indirectly from class A
6052 and class C is derived directly or indirectly from B,
6054 --conversion of C* to B* is better than conversion of C* to
6057 --conversion of B* to A* is better than conversion of C* to
6059 if (same_type_p (deref_from_type1
, deref_from_type2
))
6061 if (is_properly_derived_from (deref_to_type1
,
6064 else if (is_properly_derived_from (deref_to_type2
,
6068 else if (same_type_p (deref_to_type1
, deref_to_type2
))
6070 if (is_properly_derived_from (deref_from_type2
,
6073 else if (is_properly_derived_from (deref_from_type1
,
6079 else if (CLASS_TYPE_P (non_reference (from_type1
))
6080 && same_type_p (from_type1
, from_type2
))
6082 tree from
= non_reference (from_type1
);
6086 --binding of an expression of type C to a reference of type
6087 B& is better than binding an expression of type C to a
6088 reference of type A&
6090 --conversion of C to B is better than conversion of C to A, */
6091 if (is_properly_derived_from (from
, to_type1
)
6092 && is_properly_derived_from (from
, to_type2
))
6094 if (is_properly_derived_from (to_type1
, to_type2
))
6096 else if (is_properly_derived_from (to_type2
, to_type1
))
6100 else if (CLASS_TYPE_P (non_reference (to_type1
))
6101 && same_type_p (to_type1
, to_type2
))
6103 tree to
= non_reference (to_type1
);
6107 --binding of an expression of type B to a reference of type
6108 A& is better than binding an expression of type C to a
6109 reference of type A&,
6111 --conversion of B to A is better than conversion of C to A */
6112 if (is_properly_derived_from (from_type1
, to
)
6113 && is_properly_derived_from (from_type2
, to
))
6115 if (is_properly_derived_from (from_type2
, from_type1
))
6117 else if (is_properly_derived_from (from_type1
, from_type2
))
6124 --S1 and S2 differ only in their qualification conversion and yield
6125 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6126 qualification signature of type T1 is a proper subset of the cv-
6127 qualification signature of type T2 */
6128 if (ics1
->kind
== ck_qual
6129 && ics2
->kind
== ck_qual
6130 && same_type_p (from_type1
, from_type2
))
6132 int result
= comp_cv_qual_signature (to_type1
, to_type2
);
6139 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6140 to an implicit object parameter, and either S1 binds an lvalue reference
6141 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6142 reference to an rvalue and S2 binds an lvalue reference
6143 (C++0x draft standard, 13.3.3.2)
6145 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6146 types to which the references refer are the same type except for
6147 top-level cv-qualifiers, and the type to which the reference
6148 initialized by S2 refers is more cv-qualified than the type to
6149 which the reference initialized by S1 refers */
6151 if (ref_conv1
&& ref_conv2
)
6153 if (!ref_conv1
->this_p
&& !ref_conv2
->this_p
6154 && (TYPE_REF_IS_RVALUE (ref_conv1
->type
)
6155 != TYPE_REF_IS_RVALUE (ref_conv2
->type
)))
6157 if (ref_conv1
->rvaluedness_matches_p
)
6159 if (ref_conv2
->rvaluedness_matches_p
)
6163 if (same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
6164 return comp_cv_qualification (TREE_TYPE (ref_conv2
->type
),
6165 TREE_TYPE (ref_conv1
->type
));
6168 /* Neither conversion sequence is better than the other. */
6172 /* The source type for this standard conversion sequence. */
6175 source_type (conversion
*t
)
6177 for (;; t
= t
->u
.next
)
6179 if (t
->kind
== ck_user
6180 || t
->kind
== ck_ambig
6181 || t
->kind
== ck_identity
)
6187 /* Note a warning about preferring WINNER to LOSER. We do this by storing
6188 a pointer to LOSER and re-running joust to produce the warning if WINNER
6189 is actually used. */
6192 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
6194 candidate_warning
*cw
= (candidate_warning
*)
6195 conversion_obstack_alloc (sizeof (candidate_warning
));
6197 cw
->next
= winner
->warnings
;
6198 winner
->warnings
= cw
;
6201 /* Compare two candidates for overloading as described in
6202 [over.match.best]. Return values:
6204 1: cand1 is better than cand2
6205 -1: cand2 is better than cand1
6206 0: cand1 and cand2 are indistinguishable */
6209 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
)
6212 int off1
= 0, off2
= 0;
6216 /* Candidates that involve bad conversions are always worse than those
6218 if (cand1
->viable
> cand2
->viable
)
6220 if (cand1
->viable
< cand2
->viable
)
6223 /* If we have two pseudo-candidates for conversions to the same type,
6224 or two candidates for the same function, arbitrarily pick one. */
6225 if (cand1
->fn
== cand2
->fn
6226 && (IS_TYPE_OR_DECL_P (cand1
->fn
)))
6229 /* a viable function F1
6230 is defined to be a better function than another viable function F2 if
6231 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6232 ICSi(F2), and then */
6234 /* for some argument j, ICSj(F1) is a better conversion sequence than
6237 /* For comparing static and non-static member functions, we ignore
6238 the implicit object parameter of the non-static function. The
6239 standard says to pretend that the static function has an object
6240 parm, but that won't work with operator overloading. */
6241 len
= cand1
->num_convs
;
6242 if (len
!= cand2
->num_convs
)
6244 int static_1
= DECL_STATIC_FUNCTION_P (cand1
->fn
);
6245 int static_2
= DECL_STATIC_FUNCTION_P (cand2
->fn
);
6247 gcc_assert (static_1
!= static_2
);
6258 for (i
= 0; i
< len
; ++i
)
6260 conversion
*t1
= cand1
->convs
[i
+ off1
];
6261 conversion
*t2
= cand2
->convs
[i
+ off2
];
6262 int comp
= compare_ics (t1
, t2
);
6267 && (CONVERSION_RANK (t1
) + CONVERSION_RANK (t2
)
6268 == cr_std
+ cr_promotion
)
6269 && t1
->kind
== ck_std
6270 && t2
->kind
== ck_std
6271 && TREE_CODE (t1
->type
) == INTEGER_TYPE
6272 && TREE_CODE (t2
->type
) == INTEGER_TYPE
6273 && (TYPE_PRECISION (t1
->type
)
6274 == TYPE_PRECISION (t2
->type
))
6275 && (TYPE_UNSIGNED (t1
->u
.next
->type
)
6276 || (TREE_CODE (t1
->u
.next
->type
)
6279 tree type
= t1
->u
.next
->type
;
6281 struct z_candidate
*w
, *l
;
6283 type1
= t1
->type
, type2
= t2
->type
,
6284 w
= cand1
, l
= cand2
;
6286 type1
= t2
->type
, type2
= t1
->type
,
6287 w
= cand2
, l
= cand1
;
6291 warning (OPT_Wsign_promo
, "passing %qT chooses %qT over %qT",
6292 type
, type1
, type2
);
6293 warning (OPT_Wsign_promo
, " in call to %qD", w
->fn
);
6299 if (winner
&& comp
!= winner
)
6308 /* warn about confusing overload resolution for user-defined conversions,
6309 either between a constructor and a conversion op, or between two
6311 if (winner
&& warn_conversion
&& cand1
->second_conv
6312 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
6313 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
6315 struct z_candidate
*w
, *l
;
6316 bool give_warning
= false;
6319 w
= cand1
, l
= cand2
;
6321 w
= cand2
, l
= cand1
;
6323 /* We don't want to complain about `X::operator T1 ()'
6324 beating `X::operator T2 () const', when T2 is a no less
6325 cv-qualified version of T1. */
6326 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
6327 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
6329 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
6330 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
6332 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
6337 if (!comp_ptr_ttypes (t
, f
))
6338 give_warning
= true;
6341 give_warning
= true;
6347 tree source
= source_type (w
->convs
[0]);
6348 if (! DECL_CONSTRUCTOR_P (w
->fn
))
6349 source
= TREE_TYPE (source
);
6350 warning (OPT_Wconversion
, "choosing %qD over %qD", w
->fn
, l
->fn
);
6351 warning (OPT_Wconversion
, " for conversion from %qT to %qT",
6352 source
, w
->second_conv
->type
);
6353 inform (" because conversion sequence for the argument is better");
6363 F1 is a non-template function and F2 is a template function
6366 if (!cand1
->template_decl
&& cand2
->template_decl
)
6368 else if (cand1
->template_decl
&& !cand2
->template_decl
)
6372 F1 and F2 are template functions and the function template for F1 is
6373 more specialized than the template for F2 according to the partial
6376 if (cand1
->template_decl
&& cand2
->template_decl
)
6378 winner
= more_specialized_fn
6379 (TI_TEMPLATE (cand1
->template_decl
),
6380 TI_TEMPLATE (cand2
->template_decl
),
6381 /* [temp.func.order]: The presence of unused ellipsis and default
6382 arguments has no effect on the partial ordering of function
6383 templates. add_function_candidate() will not have
6384 counted the "this" argument for constructors. */
6385 cand1
->num_convs
+ DECL_CONSTRUCTOR_P (cand1
->fn
));
6391 the context is an initialization by user-defined conversion (see
6392 _dcl.init_ and _over.match.user_) and the standard conversion
6393 sequence from the return type of F1 to the destination type (i.e.,
6394 the type of the entity being initialized) is a better conversion
6395 sequence than the standard conversion sequence from the return type
6396 of F2 to the destination type. */
6398 if (cand1
->second_conv
)
6400 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
6405 /* Check whether we can discard a builtin candidate, either because we
6406 have two identical ones or matching builtin and non-builtin candidates.
6408 (Pedantically in the latter case the builtin which matched the user
6409 function should not be added to the overload set, but we spot it here.
6412 ... the builtin candidates include ...
6413 - do not have the same parameter type list as any non-template
6414 non-member candidate. */
6416 if (TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
6417 || TREE_CODE (cand2
->fn
) == IDENTIFIER_NODE
)
6419 for (i
= 0; i
< len
; ++i
)
6420 if (!same_type_p (cand1
->convs
[i
]->type
,
6421 cand2
->convs
[i
]->type
))
6423 if (i
== cand1
->num_convs
)
6425 if (cand1
->fn
== cand2
->fn
)
6426 /* Two built-in candidates; arbitrarily pick one. */
6428 else if (TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
)
6429 /* cand1 is built-in; prefer cand2. */
6432 /* cand2 is built-in; prefer cand1. */
6437 /* If the two functions are the same (this can happen with declarations
6438 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6439 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
6440 && equal_functions (cand1
->fn
, cand2
->fn
))
6445 /* Extension: If the worst conversion for one candidate is worse than the
6446 worst conversion for the other, take the first. */
6449 conversion_rank rank1
= cr_identity
, rank2
= cr_identity
;
6450 struct z_candidate
*w
= 0, *l
= 0;
6452 for (i
= 0; i
< len
; ++i
)
6454 if (CONVERSION_RANK (cand1
->convs
[i
+off1
]) > rank1
)
6455 rank1
= CONVERSION_RANK (cand1
->convs
[i
+off1
]);
6456 if (CONVERSION_RANK (cand2
->convs
[i
+ off2
]) > rank2
)
6457 rank2
= CONVERSION_RANK (cand2
->convs
[i
+ off2
]);
6460 winner
= 1, w
= cand1
, l
= cand2
;
6462 winner
= -1, w
= cand2
, l
= cand1
;
6468 ISO C++ says that these are ambiguous, even \
6469 though the worst conversion for the first is better than \
6470 the worst conversion for the second:");
6471 print_z_candidate (_("candidate 1:"), w
);
6472 print_z_candidate (_("candidate 2:"), l
);
6480 gcc_assert (!winner
);
6484 /* Given a list of candidates for overloading, find the best one, if any.
6485 This algorithm has a worst case of O(2n) (winner is last), and a best
6486 case of O(n/2) (totally ambiguous); much better than a sorting
6489 static struct z_candidate
*
6490 tourney (struct z_candidate
*candidates
)
6492 struct z_candidate
*champ
= candidates
, *challenger
;
6494 int champ_compared_to_predecessor
= 0;
6496 /* Walk through the list once, comparing each current champ to the next
6497 candidate, knocking out a candidate or two with each comparison. */
6499 for (challenger
= champ
->next
; challenger
; )
6501 fate
= joust (champ
, challenger
, 0);
6503 challenger
= challenger
->next
;
6508 champ
= challenger
->next
;
6511 champ_compared_to_predecessor
= 0;
6516 champ_compared_to_predecessor
= 1;
6519 challenger
= champ
->next
;
6523 /* Make sure the champ is better than all the candidates it hasn't yet
6524 been compared to. */
6526 for (challenger
= candidates
;
6528 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
6529 challenger
= challenger
->next
)
6531 fate
= joust (champ
, challenger
, 0);
6539 /* Returns nonzero if things of type FROM can be converted to TO. */
6542 can_convert (tree to
, tree from
)
6544 return can_convert_arg (to
, from
, NULL_TREE
, LOOKUP_NORMAL
);
6547 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6550 can_convert_arg (tree to
, tree from
, tree arg
, int flags
)
6556 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6557 p
= conversion_obstack_alloc (0);
6559 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
6561 ok_p
= (t
&& !t
->bad_p
);
6563 /* Free all the conversions we allocated. */
6564 obstack_free (&conversion_obstack
, p
);
6569 /* Like can_convert_arg, but allows dubious conversions as well. */
6572 can_convert_arg_bad (tree to
, tree from
, tree arg
)
6577 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6578 p
= conversion_obstack_alloc (0);
6579 /* Try to perform the conversion. */
6580 t
= implicit_conversion (to
, from
, arg
, /*c_cast_p=*/false,
6582 /* Free all the conversions we allocated. */
6583 obstack_free (&conversion_obstack
, p
);
6588 /* Convert EXPR to TYPE. Return the converted expression.
6590 Note that we allow bad conversions here because by the time we get to
6591 this point we are committed to doing the conversion. If we end up
6592 doing a bad conversion, convert_like will complain. */
6595 perform_implicit_conversion (tree type
, tree expr
)
6600 if (error_operand_p (expr
))
6601 return error_mark_node
;
6603 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6604 p
= conversion_obstack_alloc (0);
6606 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
6611 error ("could not convert %qE to %qT", expr
, type
);
6612 expr
= error_mark_node
;
6614 else if (processing_template_decl
)
6616 /* In a template, we are only concerned about determining the
6617 type of non-dependent expressions, so we do not have to
6618 perform the actual conversion. */
6619 if (TREE_TYPE (expr
) != type
)
6620 expr
= build_nop (type
, expr
);
6623 expr
= convert_like (conv
, expr
);
6625 /* Free all the conversions we allocated. */
6626 obstack_free (&conversion_obstack
, p
);
6631 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6632 permitted. If the conversion is valid, the converted expression is
6633 returned. Otherwise, NULL_TREE is returned, except in the case
6634 that TYPE is a class type; in that case, an error is issued. If
6635 C_CAST_P is true, then this direction initialization is taking
6636 place as part of a static_cast being attempted as part of a C-style
6640 perform_direct_initialization_if_possible (tree type
,
6647 if (type
== error_mark_node
|| error_operand_p (expr
))
6648 return error_mark_node
;
6651 If the destination type is a (possibly cv-qualified) class type:
6653 -- If the initialization is direct-initialization ...,
6654 constructors are considered. ... If no constructor applies, or
6655 the overload resolution is ambiguous, the initialization is
6657 if (CLASS_TYPE_P (type
))
6659 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6660 build_tree_list (NULL_TREE
, expr
),
6661 type
, LOOKUP_NORMAL
);
6662 return build_cplus_new (type
, expr
);
6665 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6666 p
= conversion_obstack_alloc (0);
6668 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
6671 if (!conv
|| conv
->bad_p
)
6674 expr
= convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
6675 /*issue_conversion_warnings=*/false,
6678 /* Free all the conversions we allocated. */
6679 obstack_free (&conversion_obstack
, p
);
6684 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6685 is being bound to a temporary. Create and return a new VAR_DECL
6686 with the indicated TYPE; this variable will store the value to
6687 which the reference is bound. */
6690 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
6694 /* Create the variable. */
6695 var
= create_temporary_var (type
);
6697 /* Register the variable. */
6698 if (TREE_STATIC (decl
))
6700 /* Namespace-scope or local static; give it a mangled name. */
6703 TREE_STATIC (var
) = 1;
6704 name
= mangle_ref_init_variable (decl
);
6705 DECL_NAME (var
) = name
;
6706 SET_DECL_ASSEMBLER_NAME (var
, name
);
6707 var
= pushdecl_top_level (var
);
6710 /* Create a new cleanup level if necessary. */
6711 maybe_push_cleanup_level (type
);
6716 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6717 initializing a variable of that TYPE. If DECL is non-NULL, it is
6718 the VAR_DECL being initialized with the EXPR. (In that case, the
6719 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6720 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6721 return, if *CLEANUP is no longer NULL, it will be an expression
6722 that should be pushed as a cleanup after the returned expression
6723 is used to initialize DECL.
6725 Return the converted expression. */
6728 initialize_reference (tree type
, tree expr
, tree decl
, tree
*cleanup
)
6733 if (type
== error_mark_node
|| error_operand_p (expr
))
6734 return error_mark_node
;
6736 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6737 p
= conversion_obstack_alloc (0);
6739 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, /*c_cast_p=*/false,
6741 if (!conv
|| conv
->bad_p
)
6743 if (!(TYPE_QUALS (TREE_TYPE (type
)) & TYPE_QUAL_CONST
)
6744 && !real_lvalue_p (expr
))
6745 error ("invalid initialization of non-const reference of "
6746 "type %qT from a temporary of type %qT",
6747 type
, TREE_TYPE (expr
));
6749 error ("invalid initialization of reference of type "
6750 "%qT from expression of type %qT", type
,
6752 return error_mark_node
;
6755 /* If DECL is non-NULL, then this special rule applies:
6759 The temporary to which the reference is bound or the temporary
6760 that is the complete object to which the reference is bound
6761 persists for the lifetime of the reference.
6763 The temporaries created during the evaluation of the expression
6764 initializing the reference, except the temporary to which the
6765 reference is bound, are destroyed at the end of the
6766 full-expression in which they are created.
6768 In that case, we store the converted expression into a new
6769 VAR_DECL in a new scope.
6771 However, we want to be careful not to create temporaries when
6772 they are not required. For example, given:
6775 struct D : public B {};
6779 there is no need to copy the return value from "f"; we can just
6780 extend its lifetime. Similarly, given:
6783 struct T { operator S(); };
6787 we can extend the lifetime of the return value of the conversion
6789 gcc_assert (conv
->kind
== ck_ref_bind
);
6793 tree base_conv_type
;
6795 /* Skip over the REF_BIND. */
6796 conv
= conv
->u
.next
;
6797 /* If the next conversion is a BASE_CONV, skip that too -- but
6798 remember that the conversion was required. */
6799 if (conv
->kind
== ck_base
)
6801 base_conv_type
= conv
->type
;
6802 conv
= conv
->u
.next
;
6805 base_conv_type
= NULL_TREE
;
6806 /* Perform the remainder of the conversion. */
6807 expr
= convert_like_real (conv
, expr
,
6808 /*fn=*/NULL_TREE
, /*argnum=*/0,
6810 /*issue_conversion_warnings=*/true,
6811 /*c_cast_p=*/false);
6812 if (error_operand_p (expr
))
6813 expr
= error_mark_node
;
6816 if (!real_lvalue_p (expr
))
6821 /* Create the temporary variable. */
6822 type
= TREE_TYPE (expr
);
6823 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
6824 layout_decl (var
, 0);
6825 /* If the rvalue is the result of a function call it will be
6826 a TARGET_EXPR. If it is some other construct (such as a
6827 member access expression where the underlying object is
6828 itself the result of a function call), turn it into a
6829 TARGET_EXPR here. It is important that EXPR be a
6830 TARGET_EXPR below since otherwise the INIT_EXPR will
6831 attempt to make a bitwise copy of EXPR to initialize
6833 if (TREE_CODE (expr
) != TARGET_EXPR
)
6834 expr
= get_target_expr (expr
);
6835 /* Create the INIT_EXPR that will initialize the temporary
6837 init
= build2 (INIT_EXPR
, type
, var
, expr
);
6838 if (at_function_scope_p ())
6840 add_decl_expr (var
);
6842 if (TREE_STATIC (var
))
6843 init
= add_stmt_to_compound (init
, register_dtor_fn (var
));
6845 *cleanup
= cxx_maybe_build_cleanup (var
);
6847 /* We must be careful to destroy the temporary only
6848 after its initialization has taken place. If the
6849 initialization throws an exception, then the
6850 destructor should not be run. We cannot simply
6851 transform INIT into something like:
6853 (INIT, ({ CLEANUP_STMT; }))
6855 because emit_local_var always treats the
6856 initializer as a full-expression. Thus, the
6857 destructor would run too early; it would run at the
6858 end of initializing the reference variable, rather
6859 than at the end of the block enclosing the
6862 The solution is to pass back a cleanup expression
6863 which the caller is responsible for attaching to
6864 the statement tree. */
6868 rest_of_decl_compilation (var
, /*toplev=*/1, at_eof
);
6869 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6870 static_aggregates
= tree_cons (NULL_TREE
, var
,
6873 /* Use its address to initialize the reference variable. */
6874 expr
= build_address (var
);
6876 expr
= convert_to_base (expr
,
6877 build_pointer_type (base_conv_type
),
6878 /*check_access=*/true,
6880 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), init
, expr
);
6883 /* Take the address of EXPR. */
6884 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
6885 /* If a BASE_CONV was required, perform it now. */
6887 expr
= (perform_implicit_conversion
6888 (build_pointer_type (base_conv_type
), expr
));
6889 expr
= build_nop (type
, expr
);
6893 /* Perform the conversion. */
6894 expr
= convert_like (conv
, expr
);
6896 /* Free all the conversions we allocated. */
6897 obstack_free (&conversion_obstack
, p
);
6902 #include "gt-cp-call.h"