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)))
751 cp_build_qualified_type (TREE_TYPE (to),
752 cp_type_quals (TREE_TYPE (from)));
753 from = build_pointer_type (from);
754 conv = build_conv (ck_ptr, from, conv);
758 if (tcode == POINTER_TYPE)
760 to_pointee = TREE_TYPE (to);
761 from_pointee = TREE_TYPE (from);
765 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
766 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
769 if (same_type_p (from, to))
771 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
772 /* In a C-style cast, we ignore CV-qualification because we
773 are allowed to perform a static_cast followed by a
775 conv = build_conv (ck_qual, to, conv);
776 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
777 conv = build_conv (ck_qual, to, conv);
778 else if (expr && string_conv_p (to, expr, 0))
779 /* converting from string constant to char *. */
780 conv = build_conv (ck_qual, to, conv);
781 else if (ptr_reasonably_similar (to_pointee, from_pointee))
783 conv = build_conv (ck_ptr, to, conv);
791 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
793 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
794 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
795 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
796 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
798 if (!DERIVED_FROM_P (fbase, tbase)
799 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
800 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
801 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
802 || cp_type_quals (fbase) != cp_type_quals (tbase))
805 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
806 from = build_method_type_directly (from,
808 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
809 from = build_ptrmemfunc_type (build_pointer_type (from));
810 conv = build_conv (ck_pmem, from, conv);
813 else if (tcode == BOOLEAN_TYPE)
817 An rvalue of arithmetic, enumeration, pointer, or pointer to
818 member type can be converted to an rvalue of type bool. */
819 if (ARITHMETIC_TYPE_P (from)
820 || fcode == ENUMERAL_TYPE
821 || fcode == POINTER_TYPE
822 || TYPE_PTR_TO_MEMBER_P (from))
824 conv = build_conv (ck_std, to, conv);
825 if (fcode == POINTER_TYPE
826 || TYPE_PTRMEM_P (from)
827 || (TYPE_PTRMEMFUNC_P (from)
828 && conv->rank < cr_pbool))
829 conv->rank = cr_pbool;
835 /* We don't check for ENUMERAL_TYPE here because there are no standard
836 conversions to enum type. */
837 /* As an extension, allow conversion to complex type. */
838 else if (ARITHMETIC_TYPE_P (to))
840 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
842 conv = build_conv (ck_std, to, conv);
844 /* Give this a better rank if it's a promotion. */
845 if (same_type_p (to, type_promotes_to (from))
846 && conv->u.next->rank <= cr_promotion)
847 conv->rank = cr_promotion;
849 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
850 && vector_types_convertible_p (from, to, false))
851 return build_conv (ck_std, to, conv);
852 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
853 && is_properly_derived_from (from, to))
855 if (conv->kind == ck_rvalue)
857 conv = build_conv (ck_base, to, conv);
858 /* The derived-to-base conversion indicates the initialization
859 of a parameter with base type from an object of a derived
860 type. A temporary object is created to hold the result of
861 the conversion unless we're binding directly to a reference. */
862 conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
870 /* Returns nonzero if T1 is reference-related to T2. */
873 reference_related_p (tree t1, tree t2)
875 t1 = TYPE_MAIN_VARIANT (t1);
876 t2 = TYPE_MAIN_VARIANT (t2);
880 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
881 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
883 return (same_type_p (t1, t2)
884 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
885 && DERIVED_FROM_P (t1, t2)));
888 /* Returns nonzero if T1 is reference-compatible with T2. */
891 reference_compatible_p (tree t1, tree t2)
895 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
896 reference-related to T2 and cv1 is the same cv-qualification as,
897 or greater cv-qualification than, cv2. */
898 return (reference_related_p (t1, t2)
899 && at_least_as_qualified_p (t1, t2));
902 /* Determine whether or not the EXPR (of class type S) can be
903 converted to T as in [over.match.ref]. */
906 convert_class_to_reference (tree reference_type, tree s, tree expr)
912 struct z_candidate *candidates;
913 struct z_candidate *cand;
916 conversions = lookup_conversions (s);
922 Assuming that "cv1 T" is the underlying type of the reference
923 being initialized, and "cv S" is the type of the initializer
924 expression, with S a class type, the candidate functions are
927 --The conversion functions of S and its base classes are
928 considered. Those that are not hidden within S and yield type
929 "reference to cv2 T2", where "cv1 T" is reference-compatible
930 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
932 The argument list has one argument, which is the initializer
937 /* Conceptually, we should take the address of EXPR and put it in
938 the argument list. Unfortunately, however, that can result in
939 error messages, which we should not issue now because we are just
940 trying to find a conversion operator. Therefore, we use NULL,
941 cast to the appropriate type. */
942 arglist = build_int_cst (build_pointer_type (s), 0);
943 arglist = build_tree_list (NULL_TREE, arglist);
945 t = TREE_TYPE (reference_type);
949 tree fns = TREE_VALUE (conversions);
951 for (; fns; fns = OVL_NEXT (fns))
953 tree f = OVL_CURRENT (fns);
954 tree t2 = TREE_TYPE (TREE_TYPE (f));
958 /* If this is a template function, try to get an exact
960 if (TREE_CODE (f) == TEMPLATE_DECL)
962 cand = add_template_candidate (&candidates,
968 TREE_PURPOSE (conversions),
974 /* Now, see if the conversion function really returns
975 an lvalue of the appropriate type. From the
976 point of view of unification, simply returning an
977 rvalue of the right type is good enough. */
979 t2 = TREE_TYPE (TREE_TYPE (f));
980 if (TREE_CODE (t2) != REFERENCE_TYPE
981 || !reference_compatible_p (t, TREE_TYPE (t2)))
983 candidates = candidates->next;
988 else if (TREE_CODE (t2) == REFERENCE_TYPE
989 && reference_compatible_p (t, TREE_TYPE (t2)))
990 cand = add_function_candidate (&candidates, f, s, arglist,
992 TREE_PURPOSE (conversions),
997 conversion *identity_conv;
998 /* Build a standard conversion sequence indicating the
999 binding from the reference type returned by the
1000 function to the desired REFERENCE_TYPE. */
1002 = build_identity_conv (TREE_TYPE (TREE_TYPE
1003 (TREE_TYPE (cand->fn))),
1006 = (direct_reference_binding
1007 (reference_type, identity_conv));
1008 cand->second_conv->rvaluedness_matches_p
1009 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1010 == TYPE_REF_IS_RVALUE (reference_type);
1011 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1014 conversions = TREE_CHAIN (conversions);
1017 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1018 /* If none of the conversion functions worked out, let our caller
1023 cand = tourney (candidates);
1027 /* Now that we know that this is the function we're going to use fix
1028 the dummy first argument. */
1029 cand->args = tree_cons (NULL_TREE,
1031 TREE_CHAIN (cand->args));
1033 /* Build a user-defined conversion sequence representing the
1035 conv = build_conv (ck_user,
1036 TREE_TYPE (TREE_TYPE (cand->fn)),
1037 build_identity_conv (TREE_TYPE (expr), expr));
1040 /* Merge it with the standard conversion sequence from the
1041 conversion function's return type to the desired type. */
1042 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1044 if (cand->viable == -1)
1047 return cand->second_conv;
1050 /* A reference of the indicated TYPE is being bound directly to the
1051 expression represented by the implicit conversion sequence CONV.
1052 Return a conversion sequence for this binding. */
1055 direct_reference_binding (tree type, conversion *conv)
1059 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1060 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1062 t = TREE_TYPE (type);
1066 When a parameter of reference type binds directly
1067 (_dcl.init.ref_) to an argument expression, the implicit
1068 conversion sequence is the identity conversion, unless the
1069 argument expression has a type that is a derived class of the
1070 parameter type, in which case the implicit conversion sequence is
1071 a derived-to-base Conversion.
1073 If the parameter binds directly to the result of applying a
1074 conversion function to the argument expression, the implicit
1075 conversion sequence is a user-defined conversion sequence
1076 (_over.ics.user_), with the second standard conversion sequence
1077 either an identity conversion or, if the conversion function
1078 returns an entity of a type that is a derived class of the
1079 parameter type, a derived-to-base conversion. */
1080 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1082 /* Represent the derived-to-base conversion. */
1083 conv = build_conv (ck_base, t, conv);
1084 /* We will actually be binding to the base-class subobject in
1085 the derived class, so we mark this conversion appropriately.
1086 That way, convert_like knows not to generate a temporary. */
1087 conv->need_temporary_p = false;
1089 return build_conv (ck_ref_bind, type, conv);
1092 /* Returns the conversion path from type FROM to reference type TO for
1093 purposes of reference binding. For lvalue binding, either pass a
1094 reference type to FROM or an lvalue expression to EXPR. If the
1095 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1096 the conversion returned. If C_CAST_P is true, this
1097 conversion is coming from a C-style cast. */
1100 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1102 conversion *conv = NULL;
1103 tree to = TREE_TYPE (rto);
1108 cp_lvalue_kind lvalue_p = clk_none;
1110 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1112 expr = instantiate_type (to, expr, tf_none);
1113 if (expr == error_mark_node)
1115 from = TREE_TYPE (expr);
1118 if (TREE_CODE (from) == REFERENCE_TYPE)
1120 /* Anything with reference type is an lvalue. */
1121 lvalue_p = clk_ordinary;
1122 from = TREE_TYPE (from);
1125 lvalue_p = real_lvalue_p (expr);
1128 if ((lvalue_p & clk_bitfield) != 0)
1129 tfrom = unlowered_expr_type (expr);
1131 /* Figure out whether or not the types are reference-related and
1132 reference compatible. We have do do this after stripping
1133 references from FROM. */
1134 related_p = reference_related_p (to, tfrom);
1135 /* If this is a C cast, first convert to an appropriately qualified
1136 type, so that we can later do a const_cast to the desired type. */
1137 if (related_p && c_cast_p
1138 && !at_least_as_qualified_p (to, tfrom))
1139 to = build_qualified_type (to, cp_type_quals (tfrom));
1140 compatible_p = reference_compatible_p (to, tfrom);
1142 /* Directly bind reference when target expression's type is compatible with
1143 the reference and expression is an lvalue. In DR391, the wording in
1144 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1145 const and rvalue references to rvalues of compatible class type. */
1148 || ((CP_TYPE_CONST_NON_VOLATILE_P(to) || TYPE_REF_IS_RVALUE (rto))
1149 && CLASS_TYPE_P (from))))
1153 If the initializer expression
1155 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1156 is reference-compatible with "cv2 T2,"
1158 the reference is bound directly to the initializer expression
1162 If the initializer expression is an rvalue, with T2 a class type,
1163 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1164 is bound to the object represented by the rvalue or to a sub-object
1165 within that object. */
1167 conv = build_identity_conv (tfrom, expr);
1168 conv = direct_reference_binding (rto, conv);
1170 if (flags & LOOKUP_PREFER_RVALUE)
1171 /* The top-level caller requested that we pretend that the lvalue
1172 be treated as an rvalue. */
1173 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1175 conv->rvaluedness_matches_p
1176 = (TYPE_REF_IS_RVALUE (rto) == !lvalue_p);
1178 if ((lvalue_p & clk_bitfield) != 0
1179 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1180 /* For the purposes of overload resolution, we ignore the fact
1181 this expression is a bitfield or packed field. (In particular,
1182 [over.ics.ref] says specifically that a function with a
1183 non-const reference parameter is viable even if the
1184 argument is a bitfield.)
1186 However, when we actually call the function we must create
1187 a temporary to which to bind the reference. If the
1188 reference is volatile, or isn't const, then we cannot make
1189 a temporary, so we just issue an error when the conversion
1191 conv->need_temporary_p = true;
1195 /* [class.conv.fct] A conversion function is never used to convert a
1196 (possibly cv-qualified) object to the (possibly cv-qualified) same
1197 object type (or a reference to it), to a (possibly cv-qualified) base
1198 class of that type (or a reference to it).... */
1199 else if (CLASS_TYPE_P (from) && !related_p
1200 && !(flags & LOOKUP_NO_CONVERSION))
1204 If the initializer expression
1206 -- has a class type (i.e., T2 is a class type) can be
1207 implicitly converted to an lvalue of type "cv3 T3," where
1208 "cv1 T1" is reference-compatible with "cv3 T3". (this
1209 conversion is selected by enumerating the applicable
1210 conversion functions (_over.match.ref_) and choosing the
1211 best one through overload resolution. (_over.match_).
1213 the reference is bound to the lvalue result of the conversion
1214 in the second case. */
1215 conv = convert_class_to_reference (rto, from, expr);
1220 /* From this point on, we conceptually need temporaries, even if we
1221 elide them. Only the cases above are "direct bindings". */
1222 if (flags & LOOKUP_NO_TEMP_BIND)
1227 When a parameter of reference type is not bound directly to an
1228 argument expression, the conversion sequence is the one required
1229 to convert the argument expression to the underlying type of the
1230 reference according to _over.best.ics_. Conceptually, this
1231 conversion sequence corresponds to copy-initializing a temporary
1232 of the underlying type with the argument expression. Any
1233 difference in top-level cv-qualification is subsumed by the
1234 initialization itself and does not constitute a conversion. */
1238 Otherwise, the reference shall be to a non-volatile const type.
1240 Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1241 if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1246 Otherwise, a temporary of type "cv1 T1" is created and
1247 initialized from the initializer expression using the rules for a
1248 non-reference copy initialization. If T1 is reference-related to
1249 T2, cv1 must be the same cv-qualification as, or greater
1250 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1251 if (related_p && !at_least_as_qualified_p (to, from))
1254 /* We're generating a temporary now, but don't bind any more in the
1255 conversion (specifically, don't slice the temporary returned by a
1256 conversion operator). */
1257 flags |= LOOKUP_NO_TEMP_BIND;
1259 conv = implicit_conversion (to, from, expr, c_cast_p,
1264 conv = build_conv (ck_ref_bind, rto, conv);
1265 /* This reference binding, unlike those above, requires the
1266 creation of a temporary. */
1267 conv->need_temporary_p = true;
1268 conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1273 /* Returns the implicit conversion sequence (see [over.ics]) from type
1274 FROM to type TO. The optional expression EXPR may affect the
1275 conversion. FLAGS are the usual overloading flags. Only
1276 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1277 conversion is coming from a C-style cast. */
1280 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1285 if (from == error_mark_node || to == error_mark_node
1286 || expr == error_mark_node)
1289 if (TREE_CODE (to) == REFERENCE_TYPE)
1290 conv = reference_binding (to, from, expr, c_cast_p, flags);
1292 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1297 if (expr != NULL_TREE
1298 && (IS_AGGR_TYPE (from)
1299 || IS_AGGR_TYPE (to))
1300 && (flags & LOOKUP_NO_CONVERSION) == 0)
1302 struct z_candidate *cand;
1303 int convflags = ((flags & LOOKUP_NO_TEMP_BIND)
1304 |LOOKUP_ONLYCONVERTING);
1306 cand = build_user_type_conversion_1 (to, expr, convflags);
1308 conv = cand->second_conv;
1310 /* We used to try to bind a reference to a temporary here, but that
1311 is now handled after the recursive call to this function at the end
1312 of reference_binding. */
1319 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1322 static struct z_candidate *
1323 add_candidate (struct z_candidate **candidates,
1325 size_t num_convs, conversion **convs,
1326 tree access_path, tree conversion_path,
1329 struct z_candidate *cand = (struct z_candidate *)
1330 conversion_obstack_alloc (sizeof (struct z_candidate));
1334 cand->convs = convs;
1335 cand->num_convs = num_convs;
1336 cand->access_path = access_path;
1337 cand->conversion_path = conversion_path;
1338 cand->viable = viable;
1339 cand->next = *candidates;
1345 /* Create an overload candidate for the function or method FN called with
1346 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1347 to implicit_conversion.
1349 CTYPE, if non-NULL, is the type we want to pretend this function
1350 comes from for purposes of overload resolution. */
1352 static struct z_candidate *
1353 add_function_candidate (struct z_candidate **candidates,
1354 tree fn, tree ctype, tree arglist,
1355 tree access_path, tree conversion_path,
1358 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1361 tree parmnode, argnode;
1365 /* At this point we should not see any functions which haven't been
1366 explicitly declared, except for friend functions which will have
1367 been found using argument dependent lookup. */
1368 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1370 /* The `this', `in_chrg' and VTT arguments to constructors are not
1371 considered in overload resolution. */
1372 if (DECL_CONSTRUCTOR_P (fn))
1374 parmlist = skip_artificial_parms_for (fn, parmlist);
1375 orig_arglist = arglist;
1376 arglist = skip_artificial_parms_for (fn, arglist);
1379 orig_arglist = arglist;
1381 len = list_length (arglist);
1382 convs = alloc_conversions (len);
1384 /* 13.3.2 - Viable functions [over.match.viable]
1385 First, to be a viable function, a candidate function shall have enough
1386 parameters to agree in number with the arguments in the list.
1388 We need to check this first; otherwise, checking the ICSes might cause
1389 us to produce an ill-formed template instantiation. */
1391 parmnode = parmlist;
1392 for (i = 0; i < len; ++i)
1394 if (parmnode == NULL_TREE || parmnode == void_list_node)
1396 parmnode = TREE_CHAIN (parmnode);
1399 if (i < len && parmnode)
1402 /* Make sure there are default args for the rest of the parms. */
1403 else if (!sufficient_parms_p (parmnode))
1409 /* Second, for F to be a viable function, there shall exist for each
1410 argument an implicit conversion sequence that converts that argument
1411 to the corresponding parameter of F. */
1413 parmnode = parmlist;
1416 for (i = 0; i < len; ++i)
1418 tree arg = TREE_VALUE (argnode);
1419 tree argtype = lvalue_type (arg);
1423 if (parmnode == void_list_node)
1426 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1427 && ! DECL_CONSTRUCTOR_P (fn));
1431 tree parmtype = TREE_VALUE (parmnode);
1433 /* The type of the implicit object parameter ('this') for
1434 overload resolution is not always the same as for the
1435 function itself; conversion functions are considered to
1436 be members of the class being converted, and functions
1437 introduced by a using-declaration are considered to be
1438 members of the class that uses them.
1440 Since build_over_call ignores the ICS for the `this'
1441 parameter, we can just change the parm type. */
1442 if (ctype && is_this)
1445 = build_qualified_type (ctype,
1446 TYPE_QUALS (TREE_TYPE (parmtype)));
1447 parmtype = build_pointer_type (parmtype);
1450 t = implicit_conversion (parmtype, argtype, arg,
1451 /*c_cast_p=*/false, flags);
1455 t = build_identity_conv (argtype, arg);
1456 t->ellipsis_p = true;
1473 parmnode = TREE_CHAIN (parmnode);
1474 argnode = TREE_CHAIN (argnode);
1478 return add_candidate (candidates, fn, orig_arglist, len, convs,
1479 access_path, conversion_path, viable);
1482 /* Create an overload candidate for the conversion function FN which will
1483 be invoked for expression OBJ, producing a pointer-to-function which
1484 will in turn be called with the argument list ARGLIST, and add it to
1485 CANDIDATES. FLAGS is passed on to implicit_conversion.
1487 Actually, we don't really care about FN; we care about the type it
1488 converts to. There may be multiple conversion functions that will
1489 convert to that type, and we rely on build_user_type_conversion_1 to
1490 choose the best one; so when we create our candidate, we record the type
1491 instead of the function. */
1493 static struct z_candidate *
1494 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1495 tree arglist, tree access_path, tree conversion_path)
1497 tree totype = TREE_TYPE (TREE_TYPE (fn));
1498 int i, len, viable, flags;
1499 tree parmlist, parmnode, argnode;
1502 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1503 parmlist = TREE_TYPE (parmlist);
1504 parmlist = TYPE_ARG_TYPES (parmlist);
1506 len = list_length (arglist) + 1;
1507 convs = alloc_conversions (len);
1508 parmnode = parmlist;
1511 flags = LOOKUP_NORMAL;
1513 /* Don't bother looking up the same type twice. */
1514 if (*candidates && (*candidates)->fn == totype)
1517 for (i = 0; i < len; ++i)
1519 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1520 tree argtype = lvalue_type (arg);
1524 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1526 else if (parmnode == void_list_node)
1529 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1530 /*c_cast_p=*/false, flags);
1533 t = build_identity_conv (argtype, arg);
1534 t->ellipsis_p = true;
1548 parmnode = TREE_CHAIN (parmnode);
1549 argnode = TREE_CHAIN (argnode);
1555 if (!sufficient_parms_p (parmnode))
1558 return add_candidate (candidates, totype, arglist, len, convs,
1559 access_path, conversion_path, viable);
1563 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1564 tree type1, tree type2, tree *args, tree *argtypes,
1576 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1577 convs = alloc_conversions (num_convs);
1579 for (i = 0; i < 2; ++i)
1584 t = implicit_conversion (types[i], argtypes[i], args[i],
1585 /*c_cast_p=*/false, flags);
1589 /* We need something for printing the candidate. */
1590 t = build_identity_conv (types[i], NULL_TREE);
1597 /* For COND_EXPR we rearranged the arguments; undo that now. */
1600 convs[2] = convs[1];
1601 convs[1] = convs[0];
1602 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1603 /*c_cast_p=*/false, flags);
1610 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1612 /*access_path=*/NULL_TREE,
1613 /*conversion_path=*/NULL_TREE,
1618 is_complete (tree t)
1620 return COMPLETE_TYPE_P (complete_type (t));
1623 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1626 promoted_arithmetic_type_p (tree type)
1630 In this section, the term promoted integral type is used to refer
1631 to those integral types which are preserved by integral promotion
1632 (including e.g. int and long but excluding e.g. char).
1633 Similarly, the term promoted arithmetic type refers to promoted
1634 integral types plus floating types. */
1635 return ((INTEGRAL_TYPE_P (type)
1636 && same_type_p (type_promotes_to (type), type))
1637 || TREE_CODE (type) == REAL_TYPE);
1640 /* Create any builtin operator overload candidates for the operator in
1641 question given the converted operand types TYPE1 and TYPE2. The other
1642 args are passed through from add_builtin_candidates to
1643 build_builtin_candidate.
1645 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1646 If CODE is requires candidates operands of the same type of the kind
1647 of which TYPE1 and TYPE2 are, we add both candidates
1648 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1651 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1652 enum tree_code code2, tree fnname, tree type1,
1653 tree type2, tree *args, tree *argtypes, int flags)
1657 case POSTINCREMENT_EXPR:
1658 case POSTDECREMENT_EXPR:
1659 args[1] = integer_zero_node;
1660 type2 = integer_type_node;
1669 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1670 and VQ is either volatile or empty, there exist candidate operator
1671 functions of the form
1672 VQ T& operator++(VQ T&);
1673 T operator++(VQ T&, int);
1674 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1675 type other than bool, and VQ is either volatile or empty, there exist
1676 candidate operator functions of the form
1677 VQ T& operator--(VQ T&);
1678 T operator--(VQ T&, int);
1679 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1680 complete object type, and VQ is either volatile or empty, there exist
1681 candidate operator functions of the form
1682 T*VQ& operator++(T*VQ&);
1683 T*VQ& operator--(T*VQ&);
1684 T* operator++(T*VQ&, int);
1685 T* operator--(T*VQ&, int); */
1687 case POSTDECREMENT_EXPR:
1688 case PREDECREMENT_EXPR:
1689 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1691 case POSTINCREMENT_EXPR:
1692 case PREINCREMENT_EXPR:
1693 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1695 type1 = build_reference_type (type1);
1700 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1701 exist candidate operator functions of the form
1705 8 For every function type T, there exist candidate operator functions of
1707 T& operator*(T*); */
1710 if (TREE_CODE (type1) == POINTER_TYPE
1711 && (TYPE_PTROB_P (type1)
1712 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1716 /* 9 For every type T, there exist candidate operator functions of the form
1719 10For every promoted arithmetic type T, there exist candidate operator
1720 functions of the form
1724 case UNARY_PLUS_EXPR: /* unary + */
1725 if (TREE_CODE (type1) == POINTER_TYPE)
1728 if (ARITHMETIC_TYPE_P (type1))
1732 /* 11For every promoted integral type T, there exist candidate operator
1733 functions of the form
1737 if (INTEGRAL_TYPE_P (type1))
1741 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1742 is the same type as C2 or is a derived class of C2, T is a complete
1743 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1744 there exist candidate operator functions of the form
1745 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1746 where CV12 is the union of CV1 and CV2. */
1749 if (TREE_CODE (type1) == POINTER_TYPE
1750 && TYPE_PTR_TO_MEMBER_P (type2))
1752 tree c1 = TREE_TYPE (type1);
1753 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1755 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1756 && (TYPE_PTRMEMFUNC_P (type2)
1757 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1762 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1763 didate operator functions of the form
1768 bool operator<(L, R);
1769 bool operator>(L, R);
1770 bool operator<=(L, R);
1771 bool operator>=(L, R);
1772 bool operator==(L, R);
1773 bool operator!=(L, R);
1774 where LR is the result of the usual arithmetic conversions between
1777 14For every pair of types T and I, where T is a cv-qualified or cv-
1778 unqualified complete object type and I is a promoted integral type,
1779 there exist candidate operator functions of the form
1780 T* operator+(T*, I);
1781 T& operator[](T*, I);
1782 T* operator-(T*, I);
1783 T* operator+(I, T*);
1784 T& operator[](I, T*);
1786 15For every T, where T is a pointer to complete object type, there exist
1787 candidate operator functions of the form112)
1788 ptrdiff_t operator-(T, T);
1790 16For every pointer or enumeration type T, there exist candidate operator
1791 functions of the form
1792 bool operator<(T, T);
1793 bool operator>(T, T);
1794 bool operator<=(T, T);
1795 bool operator>=(T, T);
1796 bool operator==(T, T);
1797 bool operator!=(T, T);
1799 17For every pointer to member type T, there exist candidate operator
1800 functions of the form
1801 bool operator==(T, T);
1802 bool operator!=(T, T); */
1805 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1807 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1809 type2 = ptrdiff_type_node;
1813 case TRUNC_DIV_EXPR:
1814 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1820 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1821 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1823 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1828 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1840 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1842 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1844 if (TREE_CODE (type1) == ENUMERAL_TYPE
1845 && TREE_CODE (type2) == ENUMERAL_TYPE)
1847 if (TYPE_PTR_P (type1)
1848 && null_ptr_cst_p (args[1])
1849 && !uses_template_parms (type1))
1854 if (null_ptr_cst_p (args[0])
1855 && TYPE_PTR_P (type2)
1856 && !uses_template_parms (type2))
1864 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1867 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1869 type1 = ptrdiff_type_node;
1872 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1874 type2 = ptrdiff_type_node;
1879 /* 18For every pair of promoted integral types L and R, there exist candi-
1880 date operator functions of the form
1887 where LR is the result of the usual arithmetic conversions between
1890 case TRUNC_MOD_EXPR:
1896 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1900 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1901 type, VQ is either volatile or empty, and R is a promoted arithmetic
1902 type, there exist candidate operator functions of the form
1903 VQ L& operator=(VQ L&, R);
1904 VQ L& operator*=(VQ L&, R);
1905 VQ L& operator/=(VQ L&, R);
1906 VQ L& operator+=(VQ L&, R);
1907 VQ L& operator-=(VQ L&, R);
1909 20For every pair T, VQ), where T is any type and VQ is either volatile
1910 or empty, there exist candidate operator functions of the form
1911 T*VQ& operator=(T*VQ&, T*);
1913 21For every pair T, VQ), where T is a pointer to member type and VQ is
1914 either volatile or empty, there exist candidate operator functions of
1916 VQ T& operator=(VQ T&, T);
1918 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1919 unqualified complete object type, VQ is either volatile or empty, and
1920 I is a promoted integral type, there exist candidate operator func-
1922 T*VQ& operator+=(T*VQ&, I);
1923 T*VQ& operator-=(T*VQ&, I);
1925 23For every triple L, VQ, R), where L is an integral or enumeration
1926 type, VQ is either volatile or empty, and R is a promoted integral
1927 type, there exist candidate operator functions of the form
1929 VQ L& operator%=(VQ L&, R);
1930 VQ L& operator<<=(VQ L&, R);
1931 VQ L& operator>>=(VQ L&, R);
1932 VQ L& operator&=(VQ L&, R);
1933 VQ L& operator^=(VQ L&, R);
1934 VQ L& operator|=(VQ L&, R); */
1941 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1943 type2 = ptrdiff_type_node;
1947 case TRUNC_DIV_EXPR:
1948 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1952 case TRUNC_MOD_EXPR:
1958 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1963 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1965 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1966 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1967 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1968 || ((TYPE_PTRMEMFUNC_P (type1)
1969 || TREE_CODE (type1) == POINTER_TYPE)
1970 && null_ptr_cst_p (args[1])))
1980 type1 = build_reference_type (type1);
1986 For every pair of promoted arithmetic types L and R, there
1987 exist candidate operator functions of the form
1989 LR operator?(bool, L, R);
1991 where LR is the result of the usual arithmetic conversions
1992 between types L and R.
1994 For every type T, where T is a pointer or pointer-to-member
1995 type, there exist candidate operator functions of the form T
1996 operator?(bool, T, T); */
1998 if (promoted_arithmetic_type_p (type1)
1999 && promoted_arithmetic_type_p (type2))
2003 /* Otherwise, the types should be pointers. */
2004 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2005 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2008 /* We don't check that the two types are the same; the logic
2009 below will actually create two candidates; one in which both
2010 parameter types are TYPE1, and one in which both parameter
2018 /* If we're dealing with two pointer types or two enumeral types,
2019 we need candidates for both of them. */
2020 if (type2 && !same_type_p (type1, type2)
2021 && TREE_CODE (type1) == TREE_CODE (type2)
2022 && (TREE_CODE (type1) == REFERENCE_TYPE
2023 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2024 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2025 || TYPE_PTRMEMFUNC_P (type1)
2026 || IS_AGGR_TYPE (type1)
2027 || TREE_CODE (type1) == ENUMERAL_TYPE))
2029 build_builtin_candidate
2030 (candidates, fnname, type1, type1, args, argtypes, flags);
2031 build_builtin_candidate
2032 (candidates, fnname, type2, type2, args, argtypes, flags);
2036 build_builtin_candidate
2037 (candidates, fnname, type1, type2, args, argtypes, flags);
2041 type_decays_to (tree type)
2043 if (TREE_CODE (type) == ARRAY_TYPE)
2044 return build_pointer_type (TREE_TYPE (type));
2045 if (TREE_CODE (type) == FUNCTION_TYPE)
2046 return build_pointer_type (type);
2050 /* There are three conditions of builtin candidates:
2052 1) bool-taking candidates. These are the same regardless of the input.
2053 2) pointer-pair taking candidates. These are generated for each type
2054 one of the input types converts to.
2055 3) arithmetic candidates. According to the standard, we should generate
2056 all of these, but I'm trying not to...
2058 Here we generate a superset of the possible candidates for this particular
2059 case. That is a subset of the full set the standard defines, plus some
2060 other cases which the standard disallows. add_builtin_candidate will
2061 filter out the invalid set. */
2064 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2065 enum tree_code code2, tree fnname, tree *args,
2070 tree type, argtypes[3];
2071 /* TYPES[i] is the set of possible builtin-operator parameter types
2072 we will consider for the Ith argument. These are represented as
2073 a TREE_LIST; the TREE_VALUE of each node is the potential
2077 for (i = 0; i < 3; ++i)
2080 argtypes[i] = unlowered_expr_type (args[i]);
2082 argtypes[i] = NULL_TREE;
2087 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2088 and VQ is either volatile or empty, there exist candidate operator
2089 functions of the form
2090 VQ T& operator++(VQ T&); */
2092 case POSTINCREMENT_EXPR:
2093 case PREINCREMENT_EXPR:
2094 case POSTDECREMENT_EXPR:
2095 case PREDECREMENT_EXPR:
2100 /* 24There also exist candidate operator functions of the form
2101 bool operator!(bool);
2102 bool operator&&(bool, bool);
2103 bool operator||(bool, bool); */
2105 case TRUTH_NOT_EXPR:
2106 build_builtin_candidate
2107 (candidates, fnname, boolean_type_node,
2108 NULL_TREE, args, argtypes, flags);
2111 case TRUTH_ORIF_EXPR:
2112 case TRUTH_ANDIF_EXPR:
2113 build_builtin_candidate
2114 (candidates, fnname, boolean_type_node,
2115 boolean_type_node, args, argtypes, flags);
2137 types[0] = types[1] = NULL_TREE;
2139 for (i = 0; i < 2; ++i)
2143 else if (IS_AGGR_TYPE (argtypes[i]))
2147 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2150 convs = lookup_conversions (argtypes[i]);
2152 if (code == COND_EXPR)
2154 if (real_lvalue_p (args[i]))
2155 types[i] = tree_cons
2156 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2158 types[i] = tree_cons
2159 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2165 for (; convs; convs = TREE_CHAIN (convs))
2167 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2170 && (TREE_CODE (type) != REFERENCE_TYPE
2171 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2174 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2175 types[i] = tree_cons (NULL_TREE, type, types[i]);
2177 type = non_reference (type);
2178 if (i != 0 || ! ref1)
2180 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2181 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2182 types[i] = tree_cons (NULL_TREE, type, types[i]);
2183 if (INTEGRAL_TYPE_P (type))
2184 type = type_promotes_to (type);
2187 if (! value_member (type, types[i]))
2188 types[i] = tree_cons (NULL_TREE, type, types[i]);
2193 if (code == COND_EXPR && real_lvalue_p (args[i]))
2194 types[i] = tree_cons
2195 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2196 type = non_reference (argtypes[i]);
2197 if (i != 0 || ! ref1)
2199 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2200 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2201 types[i] = tree_cons (NULL_TREE, type, types[i]);
2202 if (INTEGRAL_TYPE_P (type))
2203 type = type_promotes_to (type);
2205 types[i] = tree_cons (NULL_TREE, type, types[i]);
2209 /* Run through the possible parameter types of both arguments,
2210 creating candidates with those parameter types. */
2211 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2214 for (type = types[1]; type; type = TREE_CHAIN (type))
2215 add_builtin_candidate
2216 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2217 TREE_VALUE (type), args, argtypes, flags);
2219 add_builtin_candidate
2220 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2221 NULL_TREE, args, argtypes, flags);
2226 /* If TMPL can be successfully instantiated as indicated by
2227 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2229 TMPL is the template. EXPLICIT_TARGS are any explicit template
2230 arguments. ARGLIST is the arguments provided at the call-site.
2231 The RETURN_TYPE is the desired type for conversion operators. If
2232 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2233 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2234 add_conv_candidate. */
2236 static struct z_candidate*
2237 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2238 tree ctype, tree explicit_targs, tree arglist,
2239 tree return_type, tree access_path,
2240 tree conversion_path, int flags, tree obj,
2241 unification_kind_t strict)
2243 int ntparms = DECL_NTPARMS (tmpl);
2244 tree targs = make_tree_vec (ntparms);
2245 tree args_without_in_chrg = arglist;
2246 struct z_candidate *cand;
2250 /* We don't do deduction on the in-charge parameter, the VTT
2251 parameter or 'this'. */
2252 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2253 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2255 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2256 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2257 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2258 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2260 i = fn_type_unification (tmpl, explicit_targs, targs,
2261 args_without_in_chrg,
2262 return_type, strict, flags);
2267 fn = instantiate_template (tmpl, targs, tf_none);
2268 if (fn == error_mark_node)
2273 A member function template is never instantiated to perform the
2274 copy of a class object to an object of its class type.
2276 It's a little unclear what this means; the standard explicitly
2277 does allow a template to be used to copy a class. For example,
2282 template <class T> A(const T&);
2285 void g () { A a (f ()); }
2287 the member template will be used to make the copy. The section
2288 quoted above appears in the paragraph that forbids constructors
2289 whose only parameter is (a possibly cv-qualified variant of) the
2290 class type, and a logical interpretation is that the intent was
2291 to forbid the instantiation of member templates which would then
2293 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2295 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2296 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2301 if (obj != NULL_TREE)
2302 /* Aha, this is a conversion function. */
2303 cand = add_conv_candidate (candidates, fn, obj, access_path,
2304 conversion_path, arglist);
2306 cand = add_function_candidate (candidates, fn, ctype,
2307 arglist, access_path,
2308 conversion_path, flags);
2309 if (DECL_TI_TEMPLATE (fn) != tmpl)
2310 /* This situation can occur if a member template of a template
2311 class is specialized. Then, instantiate_template might return
2312 an instantiation of the specialization, in which case the
2313 DECL_TI_TEMPLATE field will point at the original
2314 specialization. For example:
2316 template <class T> struct S { template <class U> void f(U);
2317 template <> void f(int) {}; };
2321 Here, TMPL will be template <class U> S<double>::f(U).
2322 And, instantiate template will give us the specialization
2323 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2324 for this will point at template <class T> template <> S<T>::f(int),
2325 so that we can find the definition. For the purposes of
2326 overload resolution, however, we want the original TMPL. */
2327 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2329 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2335 static struct z_candidate *
2336 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2337 tree explicit_targs, tree arglist, tree return_type,
2338 tree access_path, tree conversion_path, int flags,
2339 unification_kind_t strict)
2342 add_template_candidate_real (candidates, tmpl, ctype,
2343 explicit_targs, arglist, return_type,
2344 access_path, conversion_path,
2345 flags, NULL_TREE, strict);
2349 static struct z_candidate *
2350 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2351 tree obj, tree arglist, tree return_type,
2352 tree access_path, tree conversion_path)
2355 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2356 arglist, return_type, access_path,
2357 conversion_path, 0, obj, DEDUCE_CONV);
2360 /* The CANDS are the set of candidates that were considered for
2361 overload resolution. Return the set of viable candidates. If none
2362 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2363 is true if a candidate should be considered viable only if it is
2366 static struct z_candidate*
2367 splice_viable (struct z_candidate *cands,
2371 struct z_candidate *viable;
2372 struct z_candidate **last_viable;
2373 struct z_candidate **cand;
2376 last_viable = &viable;
2377 *any_viable_p = false;
2382 struct z_candidate *c = *cand;
2383 if (strict_p ? c->viable == 1 : c->viable)
2388 last_viable = &c->next;
2389 *any_viable_p = true;
2395 return viable ? viable : cands;
2399 any_strictly_viable (struct z_candidate *cands)
2401 for (; cands; cands = cands->next)
2402 if (cands->viable == 1)
2407 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2408 words, it is about to become the "this" pointer for a member
2409 function call. Take the address of the object. */
2412 build_this (tree obj)
2414 /* In a template, we are only concerned about the type of the
2415 expression, so we can take a shortcut. */
2416 if (processing_template_decl)
2417 return build_address (obj);
2419 return build_unary_op (ADDR_EXPR, obj, 0);
2422 /* Returns true iff functions are equivalent. Equivalent functions are
2423 not '==' only if one is a function-local extern function or if
2424 both are extern "C". */
2427 equal_functions (tree fn1, tree fn2)
2429 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2430 || DECL_EXTERN_C_FUNCTION_P (fn1))
2431 return decls_match (fn1, fn2);
2435 /* Print information about one overload candidate CANDIDATE. MSGSTR
2436 is the text to print before the candidate itself.
2438 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2439 to have been run through gettext by the caller. This wart makes
2440 life simpler in print_z_candidates and for the translators. */
2443 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2445 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2447 if (candidate->num_convs == 3)
2448 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2449 candidate->convs[0]->type,
2450 candidate->convs[1]->type,
2451 candidate->convs[2]->type);
2452 else if (candidate->num_convs == 2)
2453 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2454 candidate->convs[0]->type,
2455 candidate->convs[1]->type);
2457 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2458 candidate->convs[0]->type);
2460 else if (TYPE_P (candidate->fn))
2461 inform ("%s %T <conversion>", msgstr, candidate->fn);
2462 else if (candidate->viable == -1)
2463 inform ("%s %+#D <near match>", msgstr, candidate->fn);
2465 inform ("%s %+#D", msgstr, candidate->fn);
2469 print_z_candidates (struct z_candidate *candidates)
2472 struct z_candidate *cand1;
2473 struct z_candidate **cand2;
2475 /* There may be duplicates in the set of candidates. We put off
2476 checking this condition as long as possible, since we have no way
2477 to eliminate duplicates from a set of functions in less than n^2
2478 time. Now we are about to emit an error message, so it is more
2479 permissible to go slowly. */
2480 for (cand1 = candidates; cand1; cand1 = cand1->next)
2482 tree fn = cand1->fn;
2483 /* Skip builtin candidates and conversion functions. */
2484 if (TREE_CODE (fn) != FUNCTION_DECL)
2486 cand2 = &cand1->next;
2489 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2490 && equal_functions (fn, (*cand2)->fn))
2491 *cand2 = (*cand2)->next;
2493 cand2 = &(*cand2)->next;
2500 str = _("candidates are:");
2501 print_z_candidate (str, candidates);
2502 if (candidates->next)
2504 /* Indent successive candidates by the width of the translation
2505 of the above string. */
2506 size_t len = gcc_gettext_width (str) + 1;
2507 char *spaces = (char *) alloca (len);
2508 memset (spaces, ' ', len-1);
2509 spaces[len - 1] = '\0';
2511 candidates = candidates->next;
2514 print_z_candidate (spaces, candidates);
2515 candidates = candidates->next;
2521 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2522 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2523 the result of the conversion function to convert it to the final
2524 desired type. Merge the two sequences into a single sequence,
2525 and return the merged sequence. */
2528 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2532 gcc_assert (user_seq->kind == ck_user);
2534 /* Find the end of the second conversion sequence. */
2536 while ((*t)->kind != ck_identity)
2537 t = &((*t)->u.next);
2539 /* Replace the identity conversion with the user conversion
2543 /* The entire sequence is a user-conversion sequence. */
2544 std_seq->user_conv_p = true;
2549 /* Returns the best overload candidate to perform the requested
2550 conversion. This function is used for three the overloading situations
2551 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2552 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2553 per [dcl.init.ref], so we ignore temporary bindings. */
2555 static struct z_candidate *
2556 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2558 struct z_candidate *candidates, *cand;
2559 tree fromtype = TREE_TYPE (expr);
2560 tree ctors = NULL_TREE;
2561 tree conv_fns = NULL_TREE;
2562 conversion *conv = NULL;
2563 tree args = NULL_TREE;
2567 /* We represent conversion within a hierarchy using RVALUE_CONV and
2568 BASE_CONV, as specified by [over.best.ics]; these become plain
2569 constructor calls, as specified in [dcl.init]. */
2570 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2571 || !DERIVED_FROM_P (totype, fromtype));
2573 if (IS_AGGR_TYPE (totype))
2574 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2576 if (IS_AGGR_TYPE (fromtype))
2578 tree to_nonref = non_reference (totype);
2579 if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
2580 (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
2581 && DERIVED_FROM_P (to_nonref, fromtype)))
2583 /* [class.conv.fct] A conversion function is never used to
2584 convert a (possibly cv-qualified) object to the (possibly
2585 cv-qualified) same object type (or a reference to it), to a
2586 (possibly cv-qualified) base class of that type (or a
2587 reference to it)... */
2590 conv_fns = lookup_conversions (fromtype);
2594 flags |= LOOKUP_NO_CONVERSION;
2596 /* It's OK to bind a temporary for converting constructor arguments, but
2597 not in converting the return value of a conversion operator. */
2598 convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
2599 flags &= ~LOOKUP_NO_TEMP_BIND;
2605 ctors = BASELINK_FUNCTIONS (ctors);
2607 t = build_int_cst (build_pointer_type (totype), 0);
2608 args = build_tree_list (NULL_TREE, expr);
2609 /* We should never try to call the abstract or base constructor
2611 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2612 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2613 args = tree_cons (NULL_TREE, t, args);
2615 for (; ctors; ctors = OVL_NEXT (ctors))
2617 tree ctor = OVL_CURRENT (ctors);
2618 if (DECL_NONCONVERTING_P (ctor))
2621 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2622 cand = add_template_candidate (&candidates, ctor, totype,
2623 NULL_TREE, args, NULL_TREE,
2624 TYPE_BINFO (totype),
2625 TYPE_BINFO (totype),
2629 cand = add_function_candidate (&candidates, ctor, totype,
2630 args, TYPE_BINFO (totype),
2631 TYPE_BINFO (totype),
2635 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2639 args = build_tree_list (NULL_TREE, build_this (expr));
2641 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2644 tree conversion_path = TREE_PURPOSE (conv_fns);
2646 /* If we are called to convert to a reference type, we are trying to
2647 find an lvalue binding, so don't even consider temporaries. If
2648 we don't find an lvalue binding, the caller will try again to
2649 look for a temporary binding. */
2650 if (TREE_CODE (totype) == REFERENCE_TYPE)
2651 convflags |= LOOKUP_NO_TEMP_BIND;
2653 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2655 tree fn = OVL_CURRENT (fns);
2657 /* [over.match.funcs] For conversion functions, the function
2658 is considered to be a member of the class of the implicit
2659 object argument for the purpose of defining the type of
2660 the implicit object parameter.
2662 So we pass fromtype as CTYPE to add_*_candidate. */
2664 if (TREE_CODE (fn) == TEMPLATE_DECL)
2665 cand = add_template_candidate (&candidates, fn, fromtype,
2668 TYPE_BINFO (fromtype),
2673 cand = add_function_candidate (&candidates, fn, fromtype,
2675 TYPE_BINFO (fromtype),
2682 = implicit_conversion (totype,
2683 TREE_TYPE (TREE_TYPE (cand->fn)),
2685 /*c_cast_p=*/false, convflags);
2687 cand->second_conv = ics;
2691 else if (candidates->viable == 1 && ics->bad_p)
2697 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2701 cand = tourney (candidates);
2704 if (flags & LOOKUP_COMPLAIN)
2706 error ("conversion from %qT to %qT is ambiguous",
2708 print_z_candidates (candidates);
2711 cand = candidates; /* any one will do */
2712 cand->second_conv = build_ambiguous_conv (totype, expr);
2713 cand->second_conv->user_conv_p = true;
2714 if (!any_strictly_viable (candidates))
2715 cand->second_conv->bad_p = true;
2716 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2717 ambiguous conversion is no worse than another user-defined
2723 /* Build the user conversion sequence. */
2726 (DECL_CONSTRUCTOR_P (cand->fn)
2727 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2728 build_identity_conv (TREE_TYPE (expr), expr));
2731 /* Combine it with the second conversion sequence. */
2732 cand->second_conv = merge_conversion_sequences (conv,
2735 if (cand->viable == -1)
2736 cand->second_conv->bad_p = true;
2742 build_user_type_conversion (tree totype, tree expr, int flags)
2744 struct z_candidate *cand
2745 = build_user_type_conversion_1 (totype, expr, flags);
2749 if (cand->second_conv->kind == ck_ambig)
2750 return error_mark_node;
2751 expr = convert_like (cand->second_conv, expr);
2752 return convert_from_reference (expr);
2757 /* Do any initial processing on the arguments to a function call. */
2760 resolve_args (tree args)
2763 for (t = args; t; t = TREE_CHAIN (t))
2765 tree arg = TREE_VALUE (t);
2767 if (error_operand_p (arg))
2768 return error_mark_node;
2769 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2771 error ("invalid use of void expression");
2772 return error_mark_node;
2774 else if (invalid_nonstatic_memfn_p (arg))
2775 return error_mark_node;
2780 /* Perform overload resolution on FN, which is called with the ARGS.
2782 Return the candidate function selected by overload resolution, or
2783 NULL if the event that overload resolution failed. In the case
2784 that overload resolution fails, *CANDIDATES will be the set of
2785 candidates considered, and ANY_VIABLE_P will be set to true or
2786 false to indicate whether or not any of the candidates were
2789 The ARGS should already have gone through RESOLVE_ARGS before this
2790 function is called. */
2792 static struct z_candidate *
2793 perform_overload_resolution (tree fn,
2795 struct z_candidate **candidates,
2798 struct z_candidate *cand;
2799 tree explicit_targs = NULL_TREE;
2800 int template_only = 0;
2803 *any_viable_p = true;
2805 /* Check FN and ARGS. */
2806 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2807 || TREE_CODE (fn) == TEMPLATE_DECL
2808 || TREE_CODE (fn) == OVERLOAD
2809 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2810 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2812 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2814 explicit_targs = TREE_OPERAND (fn, 1);
2815 fn = TREE_OPERAND (fn, 0);
2819 /* Add the various candidate functions. */
2820 add_candidates (fn, args, explicit_targs, template_only,
2821 /*conversion_path=*/NULL_TREE,
2822 /*access_path=*/NULL_TREE,
2826 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2830 cand = tourney (*candidates);
2834 /* Return an expression for a call to FN (a namespace-scope function,
2835 or a static member function) with the ARGS. */
2838 build_new_function_call (tree fn, tree args, bool koenig_p)
2840 struct z_candidate *candidates, *cand;
2845 args = resolve_args (args);
2846 if (args == error_mark_node)
2847 return error_mark_node;
2849 /* If this function was found without using argument dependent
2850 lookup, then we want to ignore any undeclared friend
2856 fn = remove_hidden_names (fn);
2859 error ("no matching function for call to %<%D(%A)%>",
2860 DECL_NAME (OVL_CURRENT (orig_fn)), args);
2861 return error_mark_node;
2865 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2866 p = conversion_obstack_alloc (0);
2868 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2872 if (!any_viable_p && candidates && ! candidates->next)
2873 return build_function_call (candidates->fn, args);
2874 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2875 fn = TREE_OPERAND (fn, 0);
2877 error ("no matching function for call to %<%D(%A)%>",
2878 DECL_NAME (OVL_CURRENT (fn)), args);
2880 error ("call of overloaded %<%D(%A)%> is ambiguous",
2881 DECL_NAME (OVL_CURRENT (fn)), args);
2883 print_z_candidates (candidates);
2884 result = error_mark_node;
2887 result = build_over_call (cand, LOOKUP_NORMAL);
2889 /* Free all the conversions we allocated. */
2890 obstack_free (&conversion_obstack, p);
2895 /* Build a call to a global operator new. FNNAME is the name of the
2896 operator (either "operator new" or "operator new[]") and ARGS are
2897 the arguments provided. *SIZE points to the total number of bytes
2898 required by the allocation, and is updated if that is changed here.
2899 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2900 function determines that no cookie should be used, after all,
2901 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2902 set, upon return, to the allocation function called. */
2905 build_operator_new_call (tree fnname, tree args,
2906 tree *size, tree *cookie_size,
2910 struct z_candidate *candidates;
2911 struct z_candidate *cand;
2916 args = tree_cons (NULL_TREE, *size, args);
2917 args = resolve_args (args);
2918 if (args == error_mark_node)
2925 If this lookup fails to find the name, or if the allocated type
2926 is not a class type, the allocation function's name is looked
2927 up in the global scope.
2929 we disregard block-scope declarations of "operator new". */
2930 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2932 /* Figure out what function is being called. */
2933 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2935 /* If no suitable function could be found, issue an error message
2940 error ("no matching function for call to %<%D(%A)%>",
2941 DECL_NAME (OVL_CURRENT (fns)), args);
2943 error ("call of overloaded %<%D(%A)%> is ambiguous",
2944 DECL_NAME (OVL_CURRENT (fns)), args);
2946 print_z_candidates (candidates);
2947 return error_mark_node;
2950 /* If a cookie is required, add some extra space. Whether
2951 or not a cookie is required cannot be determined until
2952 after we know which function was called. */
2955 bool use_cookie = true;
2956 if (!abi_version_at_least (2))
2958 tree placement = TREE_CHAIN (args);
2959 /* In G++ 3.2, the check was implemented incorrectly; it
2960 looked at the placement expression, rather than the
2961 type of the function. */
2962 if (placement && !TREE_CHAIN (placement)
2963 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2971 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2972 /* Skip the size_t parameter. */
2973 arg_types = TREE_CHAIN (arg_types);
2974 /* Check the remaining parameters (if any). */
2976 && TREE_CHAIN (arg_types) == void_list_node
2977 && same_type_p (TREE_VALUE (arg_types),
2981 /* If we need a cookie, adjust the number of bytes allocated. */
2984 /* Update the total size. */
2985 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2986 /* Update the argument list to reflect the adjusted size. */
2987 TREE_VALUE (args) = *size;
2990 *cookie_size = NULL_TREE;
2993 /* Tell our caller which function we decided to call. */
2997 /* Build the CALL_EXPR. */
2998 return build_over_call (cand, LOOKUP_NORMAL);
3002 build_object_call (tree obj, tree args)
3004 struct z_candidate *candidates = 0, *cand;
3005 tree fns, convs, mem_args = NULL_TREE;
3006 tree type = TREE_TYPE (obj);
3008 tree result = NULL_TREE;
3011 if (TYPE_PTRMEMFUNC_P (type))
3013 /* It's no good looking for an overloaded operator() on a
3014 pointer-to-member-function. */
3015 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3016 return error_mark_node;
3019 if (TYPE_BINFO (type))
3021 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3022 if (fns == error_mark_node)
3023 return error_mark_node;
3028 args = resolve_args (args);
3030 if (args == error_mark_node)
3031 return error_mark_node;
3033 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3034 p = conversion_obstack_alloc (0);
3038 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
3039 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
3041 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
3043 tree fn = OVL_CURRENT (fns);
3044 if (TREE_CODE (fn) == TEMPLATE_DECL)
3045 add_template_candidate (&candidates, fn, base, NULL_TREE,
3046 mem_args, NULL_TREE,
3049 LOOKUP_NORMAL, DEDUCE_CALL);
3051 add_function_candidate
3052 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3053 TYPE_BINFO (type), LOOKUP_NORMAL);
3057 convs = lookup_conversions (type);
3059 for (; convs; convs = TREE_CHAIN (convs))
3061 tree fns = TREE_VALUE (convs);
3062 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3064 if ((TREE_CODE (totype) == POINTER_TYPE
3065 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3066 || (TREE_CODE (totype) == REFERENCE_TYPE
3067 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3068 || (TREE_CODE (totype) == REFERENCE_TYPE
3069 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3070 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3071 for (; fns; fns = OVL_NEXT (fns))
3073 tree fn = OVL_CURRENT (fns);
3074 if (TREE_CODE (fn) == TEMPLATE_DECL)
3075 add_template_conv_candidate
3076 (&candidates, fn, obj, args, totype,
3077 /*access_path=*/NULL_TREE,
3078 /*conversion_path=*/NULL_TREE);
3080 add_conv_candidate (&candidates, fn, obj, args,
3081 /*conversion_path=*/NULL_TREE,
3082 /*access_path=*/NULL_TREE);
3086 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3089 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3090 print_z_candidates (candidates);
3091 result = error_mark_node;
3095 cand = tourney (candidates);
3098 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
3099 print_z_candidates (candidates);
3100 result = error_mark_node;
3102 /* Since cand->fn will be a type, not a function, for a conversion
3103 function, we must be careful not to unconditionally look at
3105 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3106 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3107 result = build_over_call (cand, LOOKUP_NORMAL);
3110 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
3111 obj = convert_from_reference (obj);
3112 result = build_function_call (obj, args);
3116 /* Free all the conversions we allocated. */
3117 obstack_free (&conversion_obstack, p);
3123 op_error (enum tree_code code, enum tree_code code2,
3124 tree arg1, tree arg2, tree arg3, const char *problem)
3128 if (code == MODIFY_EXPR)
3129 opname = assignment_operator_name_info[code2].name;
3131 opname = operator_name_info[code].name;
3136 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3137 problem, arg1, arg2, arg3);
3140 case POSTINCREMENT_EXPR:
3141 case POSTDECREMENT_EXPR:
3142 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3146 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3151 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3156 error ("%s for %<operator%s%> in %<%E %s %E%>",
3157 problem, opname, arg1, opname, arg2);
3159 error ("%s for %<operator%s%> in %<%s%E%>",
3160 problem, opname, opname, arg1);
3165 /* Return the implicit conversion sequence that could be used to
3166 convert E1 to E2 in [expr.cond]. */
3169 conditional_conversion (tree e1, tree e2)
3171 tree t1 = non_reference (TREE_TYPE (e1));
3172 tree t2 = non_reference (TREE_TYPE (e2));
3178 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3179 implicitly converted (clause _conv_) to the type "reference to
3180 T2", subject to the constraint that in the conversion the
3181 reference must bind directly (_dcl.init.ref_) to E1. */
3182 if (real_lvalue_p (e2))
3184 conv = implicit_conversion (build_reference_type (t2),
3188 LOOKUP_NO_TEMP_BIND);
3195 If E1 and E2 have class type, and the underlying class types are
3196 the same or one is a base class of the other: E1 can be converted
3197 to match E2 if the class of T2 is the same type as, or a base
3198 class of, the class of T1, and the cv-qualification of T2 is the
3199 same cv-qualification as, or a greater cv-qualification than, the
3200 cv-qualification of T1. If the conversion is applied, E1 is
3201 changed to an rvalue of type T2 that still refers to the original
3202 source class object (or the appropriate subobject thereof). */
3203 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3204 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3206 if (good_base && at_least_as_qualified_p (t2, t1))
3208 conv = build_identity_conv (t1, e1);
3209 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3210 TYPE_MAIN_VARIANT (t2)))
3211 conv = build_conv (ck_base, t2, conv);
3213 conv = build_conv (ck_rvalue, t2, conv);
3222 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3223 converted to the type that expression E2 would have if E2 were
3224 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3225 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3229 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3230 arguments to the conditional expression. */
3233 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3237 tree result = NULL_TREE;
3238 tree result_type = NULL_TREE;
3239 bool lvalue_p = true;
3240 struct z_candidate *candidates = 0;
3241 struct z_candidate *cand;
3244 /* As a G++ extension, the second argument to the conditional can be
3245 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3246 c'.) If the second operand is omitted, make sure it is
3247 calculated only once. */
3251 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3253 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3254 if (real_lvalue_p (arg1))
3255 arg2 = arg1 = stabilize_reference (arg1);
3257 arg2 = arg1 = save_expr (arg1);
3262 The first expr ession is implicitly converted to bool (clause
3264 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3266 /* If something has already gone wrong, just pass that fact up the
3268 if (error_operand_p (arg1)
3269 || error_operand_p (arg2)
3270 || error_operand_p (arg3))
3271 return error_mark_node;
3275 If either the second or the third operand has type (possibly
3276 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3277 array-to-pointer (_conv.array_), and function-to-pointer
3278 (_conv.func_) standard conversions are performed on the second
3279 and third operands. */
3280 arg2_type = unlowered_expr_type (arg2);
3281 arg3_type = unlowered_expr_type (arg3);
3282 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3284 /* Do the conversions. We don't these for `void' type arguments
3285 since it can't have any effect and since decay_conversion
3286 does not handle that case gracefully. */
3287 if (!VOID_TYPE_P (arg2_type))
3288 arg2 = decay_conversion (arg2);
3289 if (!VOID_TYPE_P (arg3_type))
3290 arg3 = decay_conversion (arg3);
3291 arg2_type = TREE_TYPE (arg2);
3292 arg3_type = TREE_TYPE (arg3);
3296 One of the following shall hold:
3298 --The second or the third operand (but not both) is a
3299 throw-expression (_except.throw_); the result is of the
3300 type of the other and is an rvalue.
3302 --Both the second and the third operands have type void; the
3303 result is of type void and is an rvalue.
3305 We must avoid calling force_rvalue for expressions of type
3306 "void" because it will complain that their value is being
3308 if (TREE_CODE (arg2) == THROW_EXPR
3309 && TREE_CODE (arg3) != THROW_EXPR)
3311 if (!VOID_TYPE_P (arg3_type))
3312 arg3 = force_rvalue (arg3);
3313 arg3_type = TREE_TYPE (arg3);
3314 result_type = arg3_type;
3316 else if (TREE_CODE (arg2) != THROW_EXPR
3317 && TREE_CODE (arg3) == THROW_EXPR)
3319 if (!VOID_TYPE_P (arg2_type))
3320 arg2 = force_rvalue (arg2);
3321 arg2_type = TREE_TYPE (arg2);
3322 result_type = arg2_type;
3324 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3325 result_type = void_type_node;
3328 if (VOID_TYPE_P (arg2_type))
3329 error ("second operand to the conditional operator "
3330 "is of type %<void%>, "
3331 "but the third operand is neither a throw-expression "
3332 "nor of type %<void%>");
3334 error ("third operand to the conditional operator "
3335 "is of type %<void%>, "
3336 "but the second operand is neither a throw-expression "
3337 "nor of type %<void%>");
3338 return error_mark_node;
3342 goto valid_operands;
3346 Otherwise, if the second and third operand have different types,
3347 and either has (possibly cv-qualified) class type, an attempt is
3348 made to convert each of those operands to the type of the other. */
3349 else if (!same_type_p (arg2_type, arg3_type)
3350 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3355 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3356 p = conversion_obstack_alloc (0);
3358 conv2 = conditional_conversion (arg2, arg3);
3359 conv3 = conditional_conversion (arg3, arg2);
3363 If both can be converted, or one can be converted but the
3364 conversion is ambiguous, the program is ill-formed. If
3365 neither can be converted, the operands are left unchanged and
3366 further checking is performed as described below. If exactly
3367 one conversion is possible, that conversion is applied to the
3368 chosen operand and the converted operand is used in place of
3369 the original operand for the remainder of this section. */
3370 if ((conv2 && !conv2->bad_p
3371 && conv3 && !conv3->bad_p)
3372 || (conv2 && conv2->kind == ck_ambig)
3373 || (conv3 && conv3->kind == ck_ambig))
3375 error ("operands to ?: have different types %qT and %qT",
3376 arg2_type, arg3_type);
3377 result = error_mark_node;
3379 else if (conv2 && (!conv2->bad_p || !conv3))
3381 arg2 = convert_like (conv2, arg2);
3382 arg2 = convert_from_reference (arg2);
3383 arg2_type = TREE_TYPE (arg2);
3384 /* Even if CONV2 is a valid conversion, the result of the
3385 conversion may be invalid. For example, if ARG3 has type
3386 "volatile X", and X does not have a copy constructor
3387 accepting a "volatile X&", then even if ARG2 can be
3388 converted to X, the conversion will fail. */
3389 if (error_operand_p (arg2))
3390 result = error_mark_node;
3392 else if (conv3 && (!conv3->bad_p || !conv2))
3394 arg3 = convert_like (conv3, arg3);
3395 arg3 = convert_from_reference (arg3);
3396 arg3_type = TREE_TYPE (arg3);
3397 if (error_operand_p (arg3))
3398 result = error_mark_node;
3401 /* Free all the conversions we allocated. */
3402 obstack_free (&conversion_obstack, p);
3407 /* If, after the conversion, both operands have class type,
3408 treat the cv-qualification of both operands as if it were the
3409 union of the cv-qualification of the operands.
3411 The standard is not clear about what to do in this
3412 circumstance. For example, if the first operand has type
3413 "const X" and the second operand has a user-defined
3414 conversion to "volatile X", what is the type of the second
3415 operand after this step? Making it be "const X" (matching
3416 the first operand) seems wrong, as that discards the
3417 qualification without actually performing a copy. Leaving it
3418 as "volatile X" seems wrong as that will result in the
3419 conditional expression failing altogether, even though,
3420 according to this step, the one operand could be converted to
3421 the type of the other. */
3422 if ((conv2 || conv3)
3423 && CLASS_TYPE_P (arg2_type)
3424 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3425 arg2_type = arg3_type =
3426 cp_build_qualified_type (arg2_type,
3427 TYPE_QUALS (arg2_type)
3428 | TYPE_QUALS (arg3_type));
3433 If the second and third operands are lvalues and have the same
3434 type, the result is of that type and is an lvalue. */
3435 if (real_lvalue_p (arg2)
3436 && real_lvalue_p (arg3)
3437 && same_type_p (arg2_type, arg3_type))
3439 result_type = arg2_type;
3440 goto valid_operands;
3445 Otherwise, the result is an rvalue. If the second and third
3446 operand do not have the same type, and either has (possibly
3447 cv-qualified) class type, overload resolution is used to
3448 determine the conversions (if any) to be applied to the operands
3449 (_over.match.oper_, _over.built_). */
3451 if (!same_type_p (arg2_type, arg3_type)
3452 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3458 /* Rearrange the arguments so that add_builtin_candidate only has
3459 to know about two args. In build_builtin_candidates, the
3460 arguments are unscrambled. */
3464 add_builtin_candidates (&candidates,
3467 ansi_opname (COND_EXPR),
3473 If the overload resolution fails, the program is
3475 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3478 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3479 print_z_candidates (candidates);
3480 return error_mark_node;
3482 cand = tourney (candidates);
3485 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3486 print_z_candidates (candidates);
3487 return error_mark_node;
3492 Otherwise, the conversions thus determined are applied, and
3493 the converted operands are used in place of the original
3494 operands for the remainder of this section. */
3495 conv = cand->convs[0];
3496 arg1 = convert_like (conv, arg1);
3497 conv = cand->convs[1];
3498 arg2 = convert_like (conv, arg2);
3499 conv = cand->convs[2];
3500 arg3 = convert_like (conv, arg3);
3505 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3506 and function-to-pointer (_conv.func_) standard conversions are
3507 performed on the second and third operands.
3509 We need to force the lvalue-to-rvalue conversion here for class types,
3510 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3511 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3514 arg2 = force_rvalue (arg2);
3515 if (!CLASS_TYPE_P (arg2_type))
3516 arg2_type = TREE_TYPE (arg2);
3518 arg3 = force_rvalue (arg3);
3519 if (!CLASS_TYPE_P (arg2_type))
3520 arg3_type = TREE_TYPE (arg3);
3522 if (arg2 == error_mark_node || arg3 == error_mark_node)
3523 return error_mark_node;
3527 After those conversions, one of the following shall hold:
3529 --The second and third operands have the same type; the result is of
3531 if (same_type_p (arg2_type, arg3_type))
3532 result_type = arg2_type;
3535 --The second and third operands have arithmetic or enumeration
3536 type; the usual arithmetic conversions are performed to bring
3537 them to a common type, and the result is of that type. */
3538 else if ((ARITHMETIC_TYPE_P (arg2_type)
3539 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3540 && (ARITHMETIC_TYPE_P (arg3_type)
3541 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3543 /* In this case, there is always a common type. */
3544 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3547 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3548 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3549 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3550 arg2_type, arg3_type);
3551 else if (extra_warnings
3552 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3553 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3554 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3555 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3556 warning (0, "enumeral and non-enumeral type in conditional expression");
3558 arg2 = perform_implicit_conversion (result_type, arg2);
3559 arg3 = perform_implicit_conversion (result_type, arg3);
3563 --The second and third operands have pointer type, or one has
3564 pointer type and the other is a null pointer constant; pointer
3565 conversions (_conv.ptr_) and qualification conversions
3566 (_conv.qual_) are performed to bring them to their composite
3567 pointer type (_expr.rel_). The result is of the composite
3570 --The second and third operands have pointer to member type, or
3571 one has pointer to member type and the other is a null pointer
3572 constant; pointer to member conversions (_conv.mem_) and
3573 qualification conversions (_conv.qual_) are performed to bring
3574 them to a common type, whose cv-qualification shall match the
3575 cv-qualification of either the second or the third operand.
3576 The result is of the common type. */
3577 else if ((null_ptr_cst_p (arg2)
3578 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3579 || (null_ptr_cst_p (arg3)
3580 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3581 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3582 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3583 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3585 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3586 arg3, "conditional expression");
3587 if (result_type == error_mark_node)
3588 return error_mark_node;
3589 arg2 = perform_implicit_conversion (result_type, arg2);
3590 arg3 = perform_implicit_conversion (result_type, arg3);
3595 error ("operands to ?: have different types %qT and %qT",
3596 arg2_type, arg3_type);
3597 return error_mark_node;
3601 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3603 /* We can't use result_type below, as fold might have returned a
3608 /* Expand both sides into the same slot, hopefully the target of
3609 the ?: expression. We used to check for TARGET_EXPRs here,
3610 but now we sometimes wrap them in NOP_EXPRs so the test would
3612 if (CLASS_TYPE_P (TREE_TYPE (result)))
3613 result = get_target_expr (result);
3614 /* If this expression is an rvalue, but might be mistaken for an
3615 lvalue, we must add a NON_LVALUE_EXPR. */
3616 result = rvalue (result);
3622 /* OPERAND is an operand to an expression. Perform necessary steps
3623 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3627 prep_operand (tree operand)
3631 if (CLASS_TYPE_P (TREE_TYPE (operand))
3632 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3633 /* Make sure the template type is instantiated now. */
3634 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3640 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3641 OVERLOAD) to the CANDIDATES, returning an updated list of
3642 CANDIDATES. The ARGS are the arguments provided to the call,
3643 without any implicit object parameter. The EXPLICIT_TARGS are
3644 explicit template arguments provided. TEMPLATE_ONLY is true if
3645 only template functions should be considered. CONVERSION_PATH,
3646 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3649 add_candidates (tree fns, tree args,
3650 tree explicit_targs, bool template_only,
3651 tree conversion_path, tree access_path,
3653 struct z_candidate **candidates)
3656 tree non_static_args;
3658 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3659 /* Delay creating the implicit this parameter until it is needed. */
3660 non_static_args = NULL_TREE;
3667 fn = OVL_CURRENT (fns);
3668 /* Figure out which set of arguments to use. */
3669 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3671 /* If this function is a non-static member, prepend the implicit
3672 object parameter. */
3673 if (!non_static_args)
3674 non_static_args = tree_cons (NULL_TREE,
3675 build_this (TREE_VALUE (args)),
3677 fn_args = non_static_args;
3680 /* Otherwise, just use the list of arguments provided. */
3683 if (TREE_CODE (fn) == TEMPLATE_DECL)
3684 add_template_candidate (candidates,
3694 else if (!template_only)
3695 add_function_candidate (candidates,
3702 fns = OVL_NEXT (fns);
3707 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3710 struct z_candidate *candidates = 0, *cand;
3711 tree arglist, fnname;
3713 tree result = NULL_TREE;
3714 bool result_valid_p = false;
3715 enum tree_code code2 = NOP_EXPR;
3720 bool expl_eq_arg1 = false;
3722 if (error_operand_p (arg1)
3723 || error_operand_p (arg2)
3724 || error_operand_p (arg3))
3725 return error_mark_node;
3727 if (code == MODIFY_EXPR)
3729 code2 = TREE_CODE (arg3);
3731 fnname = ansi_assopname (code2);
3734 fnname = ansi_opname (code);
3736 arg1 = prep_operand (arg1);
3742 case VEC_DELETE_EXPR:
3744 /* Use build_op_new_call and build_op_delete_call instead. */
3748 return build_object_call (arg1, arg2);
3750 case TRUTH_ORIF_EXPR:
3751 case TRUTH_ANDIF_EXPR:
3752 case TRUTH_AND_EXPR:
3754 if (COMPARISON_CLASS_P (arg1))
3755 expl_eq_arg1 = true;
3760 arg2 = prep_operand (arg2);
3761 arg3 = prep_operand (arg3);
3763 if (code == COND_EXPR)
3765 if (arg2 == NULL_TREE
3766 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3767 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3768 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3769 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3772 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3773 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3776 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3777 arg2 = integer_zero_node;
3779 arglist = NULL_TREE;
3781 arglist = tree_cons (NULL_TREE, arg3, arglist);
3783 arglist = tree_cons (NULL_TREE, arg2, arglist);
3784 arglist = tree_cons (NULL_TREE, arg1, arglist);
3786 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3787 p = conversion_obstack_alloc (0);
3789 /* Add namespace-scope operators to the list of functions to
3791 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3792 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3793 flags, &candidates);
3794 /* Add class-member operators to the candidate set. */
3795 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3799 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3800 if (fns == error_mark_node)
3802 result = error_mark_node;
3803 goto user_defined_result_ready;
3806 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3808 BASELINK_BINFO (fns),
3809 TYPE_BINFO (TREE_TYPE (arg1)),
3810 flags, &candidates);
3813 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3814 to know about two args; a builtin candidate will always have a first
3815 parameter of type bool. We'll handle that in
3816 build_builtin_candidate. */
3817 if (code == COND_EXPR)
3827 args[2] = NULL_TREE;
3830 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3836 /* For these, the built-in candidates set is empty
3837 [over.match.oper]/3. We don't want non-strict matches
3838 because exact matches are always possible with built-in
3839 operators. The built-in candidate set for COMPONENT_REF
3840 would be empty too, but since there are no such built-in
3841 operators, we accept non-strict matches for them. */
3846 strict_p = pedantic;
3850 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3855 case POSTINCREMENT_EXPR:
3856 case POSTDECREMENT_EXPR:
3857 /* Look for an `operator++ (int)'. If they didn't have
3858 one, then we fall back to the old way of doing things. */
3859 if (flags & LOOKUP_COMPLAIN)
3860 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3861 "trying prefix operator instead",
3863 operator_name_info[code].name);
3864 if (code == POSTINCREMENT_EXPR)
3865 code = PREINCREMENT_EXPR;
3867 code = PREDECREMENT_EXPR;
3868 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3872 /* The caller will deal with these. */
3877 result_valid_p = true;
3881 if (flags & LOOKUP_COMPLAIN)
3883 op_error (code, code2, arg1, arg2, arg3, "no match");
3884 print_z_candidates (candidates);
3886 result = error_mark_node;
3892 cand = tourney (candidates);
3895 if (flags & LOOKUP_COMPLAIN)
3897 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3898 print_z_candidates (candidates);
3900 result = error_mark_node;
3902 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3905 *overloaded_p = true;
3907 if (resolve_args (arglist) == error_mark_node)
3908 result = error_mark_node;
3910 result = build_over_call (cand, LOOKUP_NORMAL);
3914 /* Give any warnings we noticed during overload resolution. */
3917 struct candidate_warning *w;
3918 for (w = cand->warnings; w; w = w->next)
3919 joust (cand, w->loser, 1);
3922 /* Check for comparison of different enum types. */
3931 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3932 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3933 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3934 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3936 warning (0, "comparison between %q#T and %q#T",
3937 TREE_TYPE (arg1), TREE_TYPE (arg2));
3944 /* We need to strip any leading REF_BIND so that bitfields
3945 don't cause errors. This should not remove any important
3946 conversions, because builtins don't apply to class
3947 objects directly. */
3948 conv = cand->convs[0];
3949 if (conv->kind == ck_ref_bind)
3950 conv = conv->u.next;
3951 arg1 = convert_like (conv, arg1);
3954 conv = cand->convs[1];
3955 if (conv->kind == ck_ref_bind)
3956 conv = conv->u.next;
3957 arg2 = convert_like (conv, arg2);
3961 conv = cand->convs[2];
3962 if (conv->kind == ck_ref_bind)
3963 conv = conv->u.next;
3964 arg3 = convert_like (conv, arg3);
3969 warn_logical_operator (code, arg1, arg2);
3970 expl_eq_arg1 = true;
3975 user_defined_result_ready:
3977 /* Free all the conversions we allocated. */
3978 obstack_free (&conversion_obstack, p);
3980 if (result || result_valid_p)
3987 return build_modify_expr (arg1, code2, arg2);
3990 return build_indirect_ref (arg1, "unary *");
3992 case TRUTH_ANDIF_EXPR:
3993 case TRUTH_ORIF_EXPR:
3994 case TRUTH_AND_EXPR:
3997 warn_logical_operator (code, arg1, arg2);
4001 case TRUNC_DIV_EXPR:
4012 case TRUNC_MOD_EXPR:
4016 return cp_build_binary_op (code, arg1, arg2);
4018 case UNARY_PLUS_EXPR:
4021 case TRUTH_NOT_EXPR:
4022 case PREINCREMENT_EXPR:
4023 case POSTINCREMENT_EXPR:
4024 case PREDECREMENT_EXPR:
4025 case POSTDECREMENT_EXPR:
4028 return build_unary_op (code, arg1, candidates != 0);
4031 return build_array_ref (arg1, arg2);
4034 return build_conditional_expr (arg1, arg2, arg3);
4037 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
4039 /* The caller will deal with these. */
4051 /* Build a call to operator delete. This has to be handled very specially,
4052 because the restrictions on what signatures match are different from all
4053 other call instances. For a normal delete, only a delete taking (void *)
4054 or (void *, size_t) is accepted. For a placement delete, only an exact
4055 match with the placement new is accepted.
4057 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4058 ADDR is the pointer to be deleted.
4059 SIZE is the size of the memory block to be deleted.
4060 GLOBAL_P is true if the delete-expression should not consider
4061 class-specific delete operators.
4062 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4064 If this call to "operator delete" is being generated as part to
4065 deallocate memory allocated via a new-expression (as per [expr.new]
4066 which requires that if the initialization throws an exception then
4067 we call a deallocation function), then ALLOC_FN is the allocation
4071 build_op_delete_call (enum tree_code code, tree addr, tree size,
4072 bool global_p, tree placement,
4075 tree fn = NULL_TREE;
4076 tree fns, fnname, argtypes, type;
4079 if (addr == error_mark_node)
4080 return error_mark_node;
4082 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4084 fnname = ansi_opname (code);
4086 if (CLASS_TYPE_P (type)
4087 && COMPLETE_TYPE_P (complete_type (type))
4091 If the result of the lookup is ambiguous or inaccessible, or if
4092 the lookup selects a placement deallocation function, the
4093 program is ill-formed.
4095 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4097 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4098 if (fns == error_mark_node)
4099 return error_mark_node;
4104 if (fns == NULL_TREE)
4105 fns = lookup_name_nonclass (fnname);
4107 /* Strip const and volatile from addr. */
4108 addr = cp_convert (ptr_type_node, addr);
4112 /* Get the parameter types for the allocation function that is
4114 gcc_assert (alloc_fn != NULL_TREE);
4115 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4119 /* First try it without the size argument. */
4120 argtypes = void_list_node;
4123 /* We make two tries at finding a matching `operator delete'. On
4124 the first pass, we look for a one-operator (or placement)
4125 operator delete. If we're not doing placement delete, then on
4126 the second pass we look for a two-argument delete. */
4127 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4129 /* Go through the `operator delete' functions looking for one
4130 with a matching type. */
4131 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4137 /* The first argument must be "void *". */
4138 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4139 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4142 /* On the first pass, check the rest of the arguments. */
4148 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4156 /* On the second pass, look for a function with exactly two
4157 arguments: "void *" and "size_t". */
4159 /* For "operator delete(void *, ...)" there will be
4160 no second argument, but we will not get an exact
4163 && same_type_p (TREE_VALUE (t), size_type_node)
4164 && TREE_CHAIN (t) == void_list_node)
4168 /* If we found a match, we're done. */
4173 /* If we have a matching function, call it. */
4176 /* Make sure we have the actual function, and not an
4178 fn = OVL_CURRENT (fn);
4180 /* If the FN is a member function, make sure that it is
4182 if (DECL_CLASS_SCOPE_P (fn))
4183 perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4187 /* The placement args might not be suitable for overload
4188 resolution at this point, so build the call directly. */
4189 int nargs = call_expr_nargs (placement);
4190 tree *argarray = (tree *) alloca (nargs * sizeof (tree));
4193 for (i = 1; i < nargs; i++)
4194 argarray[i] = CALL_EXPR_ARG (placement, i);
4196 return build_cxx_call (fn, nargs, argarray);
4202 args = tree_cons (NULL_TREE, addr, NULL_TREE);
4204 args = tree_cons (NULL_TREE, addr,
4205 build_tree_list (NULL_TREE, size));
4206 return build_function_call (fn, args);
4212 If no unambiguous matching deallocation function can be found,
4213 propagating the exception does not cause the object's memory to
4218 warning (0, "no corresponding deallocation function for `%D'",
4223 error ("no suitable %<operator %s%> for %qT",
4224 operator_name_info[(int)code].name, type);
4225 return error_mark_node;
4228 /* If the current scope isn't allowed to access DECL along
4229 BASETYPE_PATH, give an error. The most derived class in
4230 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4231 the declaration to use in the error diagnostic. */
4234 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4236 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4238 if (!accessible_p (basetype_path, decl, true))
4240 if (TREE_PRIVATE (decl))
4241 error ("%q+#D is private", diag_decl);
4242 else if (TREE_PROTECTED (decl))
4243 error ("%q+#D is protected", diag_decl);
4245 error ("%q+#D is inaccessible", diag_decl);
4246 error ("within this context");
4253 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4254 bitwise or of LOOKUP_* values. If any errors are warnings are
4255 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4256 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4260 build_temp (tree expr, tree type, int flags,
4261 diagnostic_fn_t *diagnostic_fn)
4265 savew = warningcount, savee = errorcount;
4266 expr = build_special_member_call (NULL_TREE,
4267 complete_ctor_identifier,
4268 build_tree_list (NULL_TREE, expr),
4270 if (warningcount > savew)
4271 *diagnostic_fn = warning0;
4272 else if (errorcount > savee)
4273 *diagnostic_fn = error;
4275 *diagnostic_fn = NULL;
4279 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4280 EXPR is implicitly converted to type TOTYPE.
4281 FN and ARGNUM are used for diagnostics. */
4284 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
4286 tree t = non_reference (totype);
4288 /* Issue warnings about peculiar, but valid, uses of NULL. */
4289 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4292 warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4295 warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4298 /* Issue warnings if "false" is converted to a NULL pointer */
4299 else if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4300 warning (OPT_Wconversion,
4301 "converting %<false%> to pointer type for argument %P of %qD",
4305 /* Perform the conversions in CONVS on the expression EXPR. FN and
4306 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4307 indicates the `this' argument of a method. INNER is nonzero when
4308 being called to continue a conversion chain. It is negative when a
4309 reference binding will be applied, positive otherwise. If
4310 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4311 conversions will be emitted if appropriate. If C_CAST_P is true,
4312 this conversion is coming from a C-style cast; in that case,
4313 conversions to inaccessible bases are permitted. */
4316 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4317 int inner, bool issue_conversion_warnings,
4320 tree totype = convs->type;
4321 diagnostic_fn_t diagnostic_fn;
4325 && convs->kind != ck_user
4326 && convs->kind != ck_ambig
4327 && convs->kind != ck_ref_bind)
4329 conversion *t = convs;
4330 for (; t; t = convs->u.next)
4332 if (t->kind == ck_user || !t->bad_p)
4334 expr = convert_like_real (t, expr, fn, argnum, 1,
4335 /*issue_conversion_warnings=*/false,
4336 /*c_cast_p=*/false);
4339 else if (t->kind == ck_ambig)
4340 return convert_like_real (t, expr, fn, argnum, 1,
4341 /*issue_conversion_warnings=*/false,
4342 /*c_cast_p=*/false);
4343 else if (t->kind == ck_identity)
4346 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4348 pedwarn (" initializing argument %P of %qD", argnum, fn);
4349 return cp_convert (totype, expr);
4352 if (issue_conversion_warnings)
4353 conversion_null_warnings (totype, expr, fn, argnum);
4355 switch (convs->kind)
4359 struct z_candidate *cand = convs->cand;
4360 tree convfn = cand->fn;
4363 /* Set user_conv_p on the argument conversions, so rvalue/base
4364 handling knows not to allow any more UDCs. */
4365 for (i = 0; i < cand->num_convs; ++i)
4366 cand->convs[i]->user_conv_p = true;
4368 expr = build_over_call (cand, LOOKUP_NORMAL);
4370 /* If this is a constructor or a function returning an aggr type,
4371 we need to build up a TARGET_EXPR. */
4372 if (DECL_CONSTRUCTOR_P (convfn))
4373 expr = build_cplus_new (totype, expr);
4375 /* The result of the call is then used to direct-initialize the object
4376 that is the destination of the copy-initialization. [dcl.init]
4378 Note that this step is not reflected in the conversion sequence;
4379 it affects the semantics when we actually perform the
4380 conversion, but is not considered during overload resolution.
4382 If the target is a class, that means call a ctor. */
4383 if (IS_AGGR_TYPE (totype)
4384 && (inner >= 0 || !lvalue_p (expr)))
4388 /* Core issue 84, now a DR, says that we don't
4389 allow UDCs for these args (which deliberately
4390 breaks copy-init of an auto_ptr<Base> from an
4391 auto_ptr<Derived>). */
4392 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4399 (" initializing argument %P of %qD from result of %qD",
4400 argnum, fn, convfn);
4403 (" initializing temporary from result of %qD", convfn);
4405 expr = build_cplus_new (totype, expr);
4410 if (type_unknown_p (expr))
4411 expr = instantiate_type (totype, expr, tf_warning_or_error);
4412 /* Convert a constant to its underlying value, unless we are
4413 about to bind it to a reference, in which case we need to
4414 leave it as an lvalue. */
4417 expr = decl_constant_value (expr);
4418 if (expr == null_node && INTEGRAL_TYPE_P (totype))
4419 /* If __null has been converted to an integer type, we do not
4420 want to warn about uses of EXPR as an integer, rather than
4422 expr = build_int_cst (totype, 0);
4426 /* Call build_user_type_conversion again for the error. */
4427 return build_user_type_conversion
4428 (totype, convs->u.expr, LOOKUP_NORMAL);
4434 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4435 convs->kind == ck_ref_bind ? -1 : 1,
4436 convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
4438 if (expr == error_mark_node)
4439 return error_mark_node;
4441 switch (convs->kind)
4444 expr = convert_bitfield_to_declared_type (expr);
4445 if (! IS_AGGR_TYPE (totype))
4447 /* Else fall through. */
4449 if (convs->kind == ck_base && !convs->need_temporary_p)
4451 /* We are going to bind a reference directly to a base-class
4452 subobject of EXPR. */
4453 /* Build an expression for `*((base*) &expr)'. */
4454 expr = build_unary_op (ADDR_EXPR, expr, 0);
4455 expr = convert_to_base (expr, build_pointer_type (totype),
4456 !c_cast_p, /*nonnull=*/true);
4457 expr = build_indirect_ref (expr, "implicit conversion");
4461 /* Copy-initialization where the cv-unqualified version of the source
4462 type is the same class as, or a derived class of, the class of the
4463 destination [is treated as direct-initialization]. [dcl.init] */
4464 flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
4465 if (convs->user_conv_p)
4466 /* This conversion is being done in the context of a user-defined
4467 conversion, so don't allow any more. */
4468 flags |= LOOKUP_NO_CONVERSION;
4469 expr = build_temp (expr, totype, flags, &diagnostic_fn);
4470 if (diagnostic_fn && fn)
4471 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4472 return build_cplus_new (totype, expr);
4476 tree ref_type = totype;
4478 /* If necessary, create a temporary.
4480 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
4481 that need temporaries, even when their types are reference
4482 compatible with the type of reference being bound, so the
4483 upcoming call to build_unary_op (ADDR_EXPR, expr, ...)
4485 if (convs->need_temporary_p
4486 || TREE_CODE (expr) == CONSTRUCTOR
4487 || TREE_CODE (expr) == VA_ARG_EXPR)
4489 tree type = convs->u.next->type;
4490 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4492 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
4493 && !TYPE_REF_IS_RVALUE (ref_type))
4495 /* If the reference is volatile or non-const, we
4496 cannot create a temporary. */
4497 if (lvalue & clk_bitfield)
4498 error ("cannot bind bitfield %qE to %qT",
4500 else if (lvalue & clk_packed)
4501 error ("cannot bind packed field %qE to %qT",
4504 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4505 return error_mark_node;
4507 /* If the source is a packed field, and we must use a copy
4508 constructor, then building the target expr will require
4509 binding the field to the reference parameter to the
4510 copy constructor, and we'll end up with an infinite
4511 loop. If we can use a bitwise copy, then we'll be
4513 if ((lvalue & clk_packed)
4514 && CLASS_TYPE_P (type)
4515 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4517 error ("cannot bind packed field %qE to %qT",
4519 return error_mark_node;
4521 if (lvalue & clk_bitfield)
4522 expr = convert_bitfield_to_declared_type (expr);
4523 expr = build_target_expr_with_type (expr, type);
4526 /* Take the address of the thing to which we will bind the
4528 expr = build_unary_op (ADDR_EXPR, expr, 1);
4529 if (expr == error_mark_node)
4530 return error_mark_node;
4532 /* Convert it to a pointer to the type referred to by the
4533 reference. This will adjust the pointer if a derived to
4534 base conversion is being performed. */
4535 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4537 /* Convert the pointer to the desired reference type. */
4538 return build_nop (ref_type, expr);
4542 return decay_conversion (expr);
4545 /* Warn about deprecated conversion if appropriate. */
4546 string_conv_p (totype, expr, 1);
4551 expr = convert_to_base (expr, totype, !c_cast_p,
4553 return build_nop (totype, expr);
4556 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4563 if (issue_conversion_warnings)
4564 expr = convert_and_check (totype, expr);
4566 expr = convert (totype, expr);
4571 /* Build a call to __builtin_trap. */
4574 call_builtin_trap (void)
4576 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4578 gcc_assert (fn != NULL);
4579 fn = build_call_n (fn, 0);
4583 /* ARG is being passed to a varargs function. Perform any conversions
4584 required. Return the converted value. */
4587 convert_arg_to_ellipsis (tree arg)
4591 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4592 standard conversions are performed. */
4593 arg = decay_conversion (arg);
4596 If the argument has integral or enumeration type that is subject
4597 to the integral promotions (_conv.prom_), or a floating point
4598 type that is subject to the floating point promotion
4599 (_conv.fpprom_), the value of the argument is converted to the
4600 promoted type before the call. */
4601 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4602 && (TYPE_PRECISION (TREE_TYPE (arg))
4603 < TYPE_PRECISION (double_type_node)))
4604 arg = convert_to_real (double_type_node, arg);
4605 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4606 arg = perform_integral_promotions (arg);
4608 arg = require_complete_type (arg);
4610 if (arg != error_mark_node
4611 && !pod_type_p (TREE_TYPE (arg)))
4613 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4614 here and do a bitwise copy, but now cp_expr_size will abort if we
4616 If the call appears in the context of a sizeof expression,
4617 there is no need to emit a warning, since the expression won't be
4618 evaluated. We keep the builtin_trap just as a safety check. */
4619 if (!skip_evaluation)
4620 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4621 "call will abort at runtime", TREE_TYPE (arg));
4622 arg = call_builtin_trap ();
4623 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4630 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4633 build_x_va_arg (tree expr, tree type)
4635 if (processing_template_decl)
4636 return build_min (VA_ARG_EXPR, type, expr);
4638 type = complete_type_or_else (type, NULL_TREE);
4640 if (expr == error_mark_node || !type)
4641 return error_mark_node;
4643 if (! pod_type_p (type))
4645 /* Remove reference types so we don't ICE later on. */
4646 tree type1 = non_reference (type);
4647 /* Undefined behavior [expr.call] 5.2.2/7. */
4648 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4649 "call will abort at runtime", type);
4650 expr = convert (build_pointer_type (type1), null_node);
4651 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4652 call_builtin_trap (), expr);
4653 expr = build_indirect_ref (expr, NULL);
4657 return build_va_arg (expr, type);
4660 /* TYPE has been given to va_arg. Apply the default conversions which
4661 would have happened when passed via ellipsis. Return the promoted
4662 type, or the passed type if there is no change. */
4665 cxx_type_promotes_to (tree type)
4669 /* Perform the array-to-pointer and function-to-pointer
4671 type = type_decays_to (type);
4673 promote = type_promotes_to (type);
4674 if (same_type_p (type, promote))
4680 /* ARG is a default argument expression being passed to a parameter of
4681 the indicated TYPE, which is a parameter to FN. Do any required
4682 conversions. Return the converted value. */
4684 static GTY(()) VEC(tree,gc) *default_arg_context;
4687 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4692 /* If the ARG is an unparsed default argument expression, the
4693 conversion cannot be performed. */
4694 if (TREE_CODE (arg) == DEFAULT_ARG)
4696 error ("the default argument for parameter %d of %qD has "
4697 "not yet been parsed",
4699 return error_mark_node;
4702 /* Detect recursion. */
4703 for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
4706 error ("recursive evaluation of default argument for %q#D", fn);
4707 return error_mark_node;
4709 VEC_safe_push (tree, gc, default_arg_context, fn);
4711 if (fn && DECL_TEMPLATE_INFO (fn))
4712 arg = tsubst_default_argument (fn, type, arg);
4714 arg = break_out_target_exprs (arg);
4716 if (TREE_CODE (arg) == CONSTRUCTOR)
4718 arg = digest_init (type, arg);
4719 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4720 "default argument", fn, parmnum);
4724 /* We must make a copy of ARG, in case subsequent processing
4725 alters any part of it. For example, during gimplification a
4726 cast of the form (T) &X::f (where "f" is a member function)
4727 will lead to replacing the PTRMEM_CST for &X::f with a
4728 VAR_DECL. We can avoid the copy for constants, since they
4729 are never modified in place. */
4730 if (!CONSTANT_CLASS_P (arg))
4731 arg = unshare_expr (arg);
4732 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4733 "default argument", fn, parmnum);
4734 arg = convert_for_arg_passing (type, arg);
4737 VEC_pop (tree, default_arg_context);
4742 /* Returns the type which will really be used for passing an argument of
4746 type_passed_as (tree type)
4748 /* Pass classes with copy ctors by invisible reference. */
4749 if (TREE_ADDRESSABLE (type))
4751 type = build_reference_type (type);
4752 /* There are no other pointers to this temporary. */
4753 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4755 else if (targetm.calls.promote_prototypes (type)
4756 && INTEGRAL_TYPE_P (type)
4757 && COMPLETE_TYPE_P (type)
4758 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4759 TYPE_SIZE (integer_type_node)))
4760 type = integer_type_node;
4765 /* Actually perform the appropriate conversion. */
4768 convert_for_arg_passing (tree type, tree val)
4772 /* If VAL is a bitfield, then -- since it has already been converted
4773 to TYPE -- it cannot have a precision greater than TYPE.
4775 If it has a smaller precision, we must widen it here. For
4776 example, passing "int f:3;" to a function expecting an "int" will
4777 not result in any conversion before this point.
4779 If the precision is the same we must not risk widening. For
4780 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
4781 often have type "int", even though the C++ type for the field is
4782 "long long". If the value is being passed to a function
4783 expecting an "int", then no conversions will be required. But,
4784 if we call convert_bitfield_to_declared_type, the bitfield will
4785 be converted to "long long". */
4786 bitfield_type = is_bitfield_expr_with_lowered_type (val);
4788 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
4789 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
4791 if (val == error_mark_node)
4793 /* Pass classes with copy ctors by invisible reference. */
4794 else if (TREE_ADDRESSABLE (type))
4795 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4796 else if (targetm.calls.promote_prototypes (type)
4797 && INTEGRAL_TYPE_P (type)
4798 && COMPLETE_TYPE_P (type)
4799 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4800 TYPE_SIZE (integer_type_node)))
4801 val = perform_integral_promotions (val);
4802 if (warn_missing_format_attribute)
4804 tree rhstype = TREE_TYPE (val);
4805 const enum tree_code coder = TREE_CODE (rhstype);
4806 const enum tree_code codel = TREE_CODE (type);
4807 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4809 && check_missing_format_attribute (type, rhstype))
4810 warning (OPT_Wmissing_format_attribute,
4811 "argument of function call might be a candidate for a format attribute");
4816 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4817 which no conversions at all should be done. This is true for some
4818 builtins which don't act like normal functions. */
4821 magic_varargs_p (tree fn)
4823 if (DECL_BUILT_IN (fn))
4824 switch (DECL_FUNCTION_CODE (fn))
4826 case BUILT_IN_CLASSIFY_TYPE:
4827 case BUILT_IN_CONSTANT_P:
4828 case BUILT_IN_NEXT_ARG:
4829 case BUILT_IN_STDARG_START:
4830 case BUILT_IN_VA_START:
4834 return lookup_attribute ("type generic",
4835 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
4841 /* Subroutine of the various build_*_call functions. Overload resolution
4842 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4843 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4844 bitmask of various LOOKUP_* flags which apply to the call itself. */
4847 build_over_call (struct z_candidate *cand, int flags)
4850 tree args = cand->args;
4851 conversion **convs = cand->convs;
4853 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4862 /* In a template, there is no need to perform all of the work that
4863 is normally done. We are only interested in the type of the call
4864 expression, i.e., the return type of the function. Any semantic
4865 errors will be deferred until the template is instantiated. */
4866 if (processing_template_decl)
4870 return_type = TREE_TYPE (TREE_TYPE (fn));
4871 expr = build_call_list (return_type, fn, args);
4872 if (TREE_THIS_VOLATILE (fn) && cfun)
4873 current_function_returns_abnormally = 1;
4874 if (!VOID_TYPE_P (return_type))
4875 require_complete_type (return_type);
4876 return convert_from_reference (expr);
4879 /* Give any warnings we noticed during overload resolution. */
4882 struct candidate_warning *w;
4883 for (w = cand->warnings; w; w = w->next)
4884 joust (cand, w->loser, 1);
4887 if (DECL_FUNCTION_MEMBER_P (fn))
4889 /* If FN is a template function, two cases must be considered.
4894 template <class T> void f();
4896 template <class T> struct B {
4900 struct C : A, B<int> {
4902 using B<int>::g; // #2
4905 In case #1 where `A::f' is a member template, DECL_ACCESS is
4906 recorded in the primary template but not in its specialization.
4907 We check access of FN using its primary template.
4909 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4910 because it is a member of class template B, DECL_ACCESS is
4911 recorded in the specialization `B<int>::g'. We cannot use its
4912 primary template because `B<T>::g' and `B<int>::g' may have
4913 different access. */
4914 if (DECL_TEMPLATE_INFO (fn)
4915 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4916 perform_or_defer_access_check (cand->access_path,
4917 DECL_TI_TEMPLATE (fn), fn);
4919 perform_or_defer_access_check (cand->access_path, fn, fn);
4922 if (args && TREE_CODE (args) != TREE_LIST)
4923 args = build_tree_list (NULL_TREE, args);
4926 /* Find maximum size of vector to hold converted arguments. */
4927 parmlen = list_length (parm);
4928 nargs = list_length (args);
4929 if (parmlen > nargs)
4931 argarray = (tree *) alloca (nargs * sizeof (tree));
4933 /* The implicit parameters to a constructor are not considered by overload
4934 resolution, and must be of the proper type. */
4935 if (DECL_CONSTRUCTOR_P (fn))
4937 argarray[j++] = TREE_VALUE (arg);
4938 arg = TREE_CHAIN (arg);
4939 parm = TREE_CHAIN (parm);
4940 /* We should never try to call the abstract constructor. */
4941 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4943 if (DECL_HAS_VTT_PARM_P (fn))
4945 argarray[j++] = TREE_VALUE (arg);
4946 arg = TREE_CHAIN (arg);
4947 parm = TREE_CHAIN (parm);
4950 /* Bypass access control for 'this' parameter. */
4951 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4953 tree parmtype = TREE_VALUE (parm);
4954 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4958 if (convs[i]->bad_p)
4959 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4960 TREE_TYPE (argtype), fn);
4962 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4963 X is called for an object that is not of type X, or of a type
4964 derived from X, the behavior is undefined.
4966 So we can assume that anything passed as 'this' is non-null, and
4967 optimize accordingly. */
4968 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4969 /* Convert to the base in which the function was declared. */
4970 gcc_assert (cand->conversion_path != NULL_TREE);
4971 converted_arg = build_base_path (PLUS_EXPR,
4973 cand->conversion_path,
4975 /* Check that the base class is accessible. */
4976 if (!accessible_base_p (TREE_TYPE (argtype),
4977 BINFO_TYPE (cand->conversion_path), true))
4978 error ("%qT is not an accessible base of %qT",
4979 BINFO_TYPE (cand->conversion_path),
4980 TREE_TYPE (argtype));
4981 /* If fn was found by a using declaration, the conversion path
4982 will be to the derived class, not the base declaring fn. We
4983 must convert from derived to base. */
4984 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4985 TREE_TYPE (parmtype), ba_unique, NULL);
4986 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4989 argarray[j++] = converted_arg;
4990 parm = TREE_CHAIN (parm);
4991 arg = TREE_CHAIN (arg);
4997 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4999 tree type = TREE_VALUE (parm);
5003 /* Don't make a copy here if build_call is going to. */
5004 if (conv->kind == ck_rvalue
5005 && COMPLETE_TYPE_P (complete_type (type))
5006 && !TREE_ADDRESSABLE (type))
5007 conv = conv->u.next;
5009 val = convert_like_with_context
5010 (conv, TREE_VALUE (arg), fn, i - is_method);
5012 val = convert_for_arg_passing (type, val);
5013 argarray[j++] = val;
5016 /* Default arguments */
5017 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5018 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5019 TREE_PURPOSE (parm),
5022 for (; arg; arg = TREE_CHAIN (arg))
5024 tree a = TREE_VALUE (arg);
5025 if (magic_varargs_p (fn))
5026 /* Do no conversions for magic varargs. */;
5028 a = convert_arg_to_ellipsis (a);
5032 gcc_assert (j <= nargs);
5035 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5036 nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5038 /* Avoid actually calling copy constructors and copy assignment operators,
5041 if (! flag_elide_constructors)
5042 /* Do things the hard way. */;
5043 else if (cand->num_convs == 1
5044 && (DECL_COPY_CONSTRUCTOR_P (fn)
5045 || DECL_MOVE_CONSTRUCTOR_P (fn)))
5048 arg = argarray[num_artificial_parms_for (fn)];
5050 /* Pull out the real argument, disregarding const-correctness. */
5052 while (TREE_CODE (targ) == NOP_EXPR
5053 || TREE_CODE (targ) == NON_LVALUE_EXPR
5054 || TREE_CODE (targ) == CONVERT_EXPR)
5055 targ = TREE_OPERAND (targ, 0);
5056 if (TREE_CODE (targ) == ADDR_EXPR)
5058 targ = TREE_OPERAND (targ, 0);
5059 if (!same_type_ignoring_top_level_qualifiers_p
5060 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5069 arg = build_indirect_ref (arg, 0);
5071 /* [class.copy]: the copy constructor is implicitly defined even if
5072 the implementation elided its use. */
5073 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
5076 /* If we're creating a temp and we already have one, don't create a
5077 new one. If we're not creating a temp but we get one, use
5078 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5079 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5080 temp or an INIT_EXPR otherwise. */
5081 if (integer_zerop (TREE_VALUE (args)))
5083 if (TREE_CODE (arg) == TARGET_EXPR)
5085 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5086 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5088 else if (TREE_CODE (arg) == TARGET_EXPR
5089 || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5090 && !move_fn_p (fn)))
5092 tree to = stabilize_reference
5093 (build_indirect_ref (TREE_VALUE (args), 0));
5095 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5099 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5101 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5103 tree to = stabilize_reference
5104 (build_indirect_ref (argarray[0], 0));
5105 tree type = TREE_TYPE (to);
5106 tree as_base = CLASSTYPE_AS_BASE (type);
5109 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5111 arg = build_indirect_ref (arg, 0);
5112 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5116 /* We must only copy the non-tail padding parts.
5117 Use __builtin_memcpy for the bitwise copy. */
5119 tree arg0, arg1, arg2, t;
5121 arg2 = TYPE_SIZE_UNIT (as_base);
5123 arg0 = build_unary_op (ADDR_EXPR, to, 0);
5124 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5125 t = build_call_n (t, 3, arg0, arg1, arg2);
5127 t = convert (TREE_TYPE (arg0), t);
5128 val = build_indirect_ref (t, 0);
5136 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5139 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5142 gcc_assert (binfo && binfo != error_mark_node);
5144 /* Warn about deprecated virtual functions now, since we're about
5145 to throw away the decl. */
5146 if (TREE_DEPRECATED (fn))
5147 warn_deprecated_use (fn);
5149 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5150 if (TREE_SIDE_EFFECTS (argarray[0]))
5151 argarray[0] = save_expr (argarray[0]);
5152 t = build_pointer_type (TREE_TYPE (fn));
5153 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5154 fn = build_java_interface_fn_ref (fn, argarray[0]);
5156 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5159 else if (DECL_INLINE (fn))
5160 fn = inline_conversion (fn);
5162 fn = build_addr_func (fn);
5164 return build_cxx_call (fn, nargs, argarray);
5167 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5168 This function performs no overload resolution, conversion, or other
5169 high-level operations. */
5172 build_cxx_call (tree fn, int nargs, tree *argarray)
5176 fn = build_call_a (fn, nargs, argarray);
5178 /* If this call might throw an exception, note that fact. */
5179 fndecl = get_callee_fndecl (fn);
5180 if ((!fndecl || !TREE_NOTHROW (fndecl))
5181 && at_function_scope_p ()
5183 cp_function_chain->can_throw = 1;
5185 /* Some built-in function calls will be evaluated at compile-time in
5187 fn = fold_if_not_in_template (fn);
5189 if (VOID_TYPE_P (TREE_TYPE (fn)))
5192 fn = require_complete_type (fn);
5193 if (fn == error_mark_node)
5194 return error_mark_node;
5196 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5197 fn = build_cplus_new (TREE_TYPE (fn), fn);
5198 return convert_from_reference (fn);
5201 static GTY(()) tree java_iface_lookup_fn;
5203 /* Make an expression which yields the address of the Java interface
5204 method FN. This is achieved by generating a call to libjava's
5205 _Jv_LookupInterfaceMethodIdx(). */
5208 build_java_interface_fn_ref (tree fn, tree instance)
5210 tree lookup_fn, method, idx;
5211 tree klass_ref, iface, iface_ref;
5214 if (!java_iface_lookup_fn)
5216 tree endlink = build_void_list_node ();
5217 tree t = tree_cons (NULL_TREE, ptr_type_node,
5218 tree_cons (NULL_TREE, ptr_type_node,
5219 tree_cons (NULL_TREE, java_int_type_node,
5221 java_iface_lookup_fn
5222 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5223 build_function_type (ptr_type_node, t),
5224 0, NOT_BUILT_IN, NULL, NULL_TREE);
5227 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5228 This is the first entry in the vtable. */
5229 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5232 /* Get the java.lang.Class pointer for the interface being called. */
5233 iface = DECL_CONTEXT (fn);
5234 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5235 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5236 || DECL_CONTEXT (iface_ref) != iface)
5238 error ("could not find class$ field in java interface type %qT",
5240 return error_mark_node;
5242 iface_ref = build_address (iface_ref);
5243 iface_ref = convert (build_pointer_type (iface), iface_ref);
5245 /* Determine the itable index of FN. */
5247 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5249 if (!DECL_VIRTUAL_P (method))
5255 idx = build_int_cst (NULL_TREE, i);
5257 lookup_fn = build1 (ADDR_EXPR,
5258 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5259 java_iface_lookup_fn);
5260 return build_call_nary (ptr_type_node, lookup_fn,
5261 3, klass_ref, iface_ref, idx);
5264 /* Returns the value to use for the in-charge parameter when making a
5265 call to a function with the indicated NAME.
5267 FIXME:Can't we find a neater way to do this mapping? */
5270 in_charge_arg_for_name (tree name)
5272 if (name == base_ctor_identifier
5273 || name == base_dtor_identifier)
5274 return integer_zero_node;
5275 else if (name == complete_ctor_identifier)
5276 return integer_one_node;
5277 else if (name == complete_dtor_identifier)
5278 return integer_two_node;
5279 else if (name == deleting_dtor_identifier)
5280 return integer_three_node;
5282 /* This function should only be called with one of the names listed
5288 /* Build a call to a constructor, destructor, or an assignment
5289 operator for INSTANCE, an expression with class type. NAME
5290 indicates the special member function to call; ARGS are the
5291 arguments. BINFO indicates the base of INSTANCE that is to be
5292 passed as the `this' parameter to the member function called.
5294 FLAGS are the LOOKUP_* flags to use when processing the call.
5296 If NAME indicates a complete object constructor, INSTANCE may be
5297 NULL_TREE. In this case, the caller will call build_cplus_new to
5298 store the newly constructed object into a VAR_DECL. */
5301 build_special_member_call (tree instance, tree name, tree args,
5302 tree binfo, int flags)
5305 /* The type of the subobject to be constructed or destroyed. */
5308 gcc_assert (name == complete_ctor_identifier
5309 || name == base_ctor_identifier
5310 || name == complete_dtor_identifier
5311 || name == base_dtor_identifier
5312 || name == deleting_dtor_identifier
5313 || name == ansi_assopname (NOP_EXPR));
5316 /* Resolve the name. */
5317 if (!complete_type_or_else (binfo, NULL_TREE))
5318 return error_mark_node;
5320 binfo = TYPE_BINFO (binfo);
5323 gcc_assert (binfo != NULL_TREE);
5325 class_type = BINFO_TYPE (binfo);
5327 /* Handle the special case where INSTANCE is NULL_TREE. */
5328 if (name == complete_ctor_identifier && !instance)
5330 instance = build_int_cst (build_pointer_type (class_type), 0);
5331 instance = build1 (INDIRECT_REF, class_type, instance);
5335 if (name == complete_dtor_identifier
5336 || name == base_dtor_identifier
5337 || name == deleting_dtor_identifier)
5338 gcc_assert (args == NULL_TREE);
5340 /* Convert to the base class, if necessary. */
5341 if (!same_type_ignoring_top_level_qualifiers_p
5342 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5344 if (name != ansi_assopname (NOP_EXPR))
5345 /* For constructors and destructors, either the base is
5346 non-virtual, or it is virtual but we are doing the
5347 conversion from a constructor or destructor for the
5348 complete object. In either case, we can convert
5350 instance = convert_to_base_statically (instance, binfo);
5352 /* However, for assignment operators, we must convert
5353 dynamically if the base is virtual. */
5354 instance = build_base_path (PLUS_EXPR, instance,
5355 binfo, /*nonnull=*/1);
5359 gcc_assert (instance != NULL_TREE);
5361 fns = lookup_fnfields (binfo, name, 1);
5363 /* When making a call to a constructor or destructor for a subobject
5364 that uses virtual base classes, pass down a pointer to a VTT for
5366 if ((name == base_ctor_identifier
5367 || name == base_dtor_identifier)
5368 && CLASSTYPE_VBASECLASSES (class_type))
5373 /* If the current function is a complete object constructor
5374 or destructor, then we fetch the VTT directly.
5375 Otherwise, we look it up using the VTT we were given. */
5376 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5377 vtt = decay_conversion (vtt);
5378 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5379 build2 (EQ_EXPR, boolean_type_node,
5380 current_in_charge_parm, integer_zero_node),
5383 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5384 sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
5385 BINFO_SUBVTT_INDEX (binfo));
5387 args = tree_cons (NULL_TREE, sub_vtt, args);
5390 return build_new_method_call (instance, fns, args,
5391 TYPE_BINFO (BINFO_TYPE (binfo)),
5392 flags, /*fn=*/NULL);
5395 /* Return the NAME, as a C string. The NAME indicates a function that
5396 is a member of TYPE. *FREE_P is set to true if the caller must
5397 free the memory returned.
5399 Rather than go through all of this, we should simply set the names
5400 of constructors and destructors appropriately, and dispense with
5401 ctor_identifier, dtor_identifier, etc. */
5404 name_as_c_string (tree name, tree type, bool *free_p)
5408 /* Assume that we will not allocate memory. */
5410 /* Constructors and destructors are special. */
5411 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5414 = CONST_CAST (char *, IDENTIFIER_POINTER (constructor_name (type)));
5415 /* For a destructor, add the '~'. */
5416 if (name == complete_dtor_identifier
5417 || name == base_dtor_identifier
5418 || name == deleting_dtor_identifier)
5420 pretty_name = concat ("~", pretty_name, NULL);
5421 /* Remember that we need to free the memory allocated. */
5425 else if (IDENTIFIER_TYPENAME_P (name))
5427 pretty_name = concat ("operator ",
5428 type_as_string (TREE_TYPE (name),
5429 TFF_PLAIN_IDENTIFIER),
5431 /* Remember that we need to free the memory allocated. */
5435 pretty_name = CONST_CAST (char *, IDENTIFIER_POINTER (name));
5440 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5441 be set, upon return, to the function called. */
5444 build_new_method_call (tree instance, tree fns, tree args,
5445 tree conversion_path, int flags,
5448 struct z_candidate *candidates = 0, *cand;
5449 tree explicit_targs = NULL_TREE;
5450 tree basetype = NULL_TREE;
5453 tree mem_args = NULL_TREE, instance_ptr;
5459 int template_only = 0;
5466 gcc_assert (instance != NULL_TREE);
5468 /* We don't know what function we're going to call, yet. */
5472 if (error_operand_p (instance)
5473 || error_operand_p (fns)
5474 || args == error_mark_node)
5475 return error_mark_node;
5477 if (!BASELINK_P (fns))
5479 error ("call to non-function %qD", fns);
5480 return error_mark_node;
5483 orig_instance = instance;
5487 /* Dismantle the baselink to collect all the information we need. */
5488 if (!conversion_path)
5489 conversion_path = BASELINK_BINFO (fns);
5490 access_binfo = BASELINK_ACCESS_BINFO (fns);
5491 optype = BASELINK_OPTYPE (fns);
5492 fns = BASELINK_FUNCTIONS (fns);
5493 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5495 explicit_targs = TREE_OPERAND (fns, 1);
5496 fns = TREE_OPERAND (fns, 0);
5499 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5500 || TREE_CODE (fns) == TEMPLATE_DECL
5501 || TREE_CODE (fns) == OVERLOAD);
5502 fn = get_first_fn (fns);
5503 name = DECL_NAME (fn);
5505 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5506 gcc_assert (CLASS_TYPE_P (basetype));
5508 if (processing_template_decl)
5510 instance = build_non_dependent_expr (instance);
5511 args = build_non_dependent_args (orig_args);
5514 /* The USER_ARGS are the arguments we will display to users if an
5515 error occurs. The USER_ARGS should not include any
5516 compiler-generated arguments. The "this" pointer hasn't been
5517 added yet. However, we must remove the VTT pointer if this is a
5518 call to a base-class constructor or destructor. */
5520 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5522 /* Callers should explicitly indicate whether they want to construct
5523 the complete object or just the part without virtual bases. */
5524 gcc_assert (name != ctor_identifier);
5525 /* Similarly for destructors. */
5526 gcc_assert (name != dtor_identifier);
5527 /* Remove the VTT pointer, if present. */
5528 if ((name == base_ctor_identifier || name == base_dtor_identifier)
5529 && CLASSTYPE_VBASECLASSES (basetype))
5530 user_args = TREE_CHAIN (user_args);
5533 /* Process the argument list. */
5534 args = resolve_args (args);
5535 if (args == error_mark_node)
5536 return error_mark_node;
5538 instance_ptr = build_this (instance);
5540 /* It's OK to call destructors and constructors on cv-qualified objects.
5541 Therefore, convert the INSTANCE_PTR to the unqualified type, if
5543 if (DECL_DESTRUCTOR_P (fn)
5544 || DECL_CONSTRUCTOR_P (fn))
5546 tree type = build_pointer_type (basetype);
5547 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5548 instance_ptr = build_nop (type, instance_ptr);
5550 if (DECL_DESTRUCTOR_P (fn))
5551 name = complete_dtor_identifier;
5553 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5554 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5556 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5557 p = conversion_obstack_alloc (0);
5559 for (fn = fns; fn; fn = OVL_NEXT (fn))
5561 tree t = OVL_CURRENT (fn);
5564 /* We can end up here for copy-init of same or base class. */
5565 if ((flags & LOOKUP_ONLYCONVERTING)
5566 && DECL_NONCONVERTING_P (t))
5569 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5570 this_arglist = mem_args;
5572 this_arglist = args;
5574 if (TREE_CODE (t) == TEMPLATE_DECL)
5575 /* A member template. */
5576 add_template_candidate (&candidates, t,
5579 this_arglist, optype,
5584 else if (! template_only)
5585 add_function_candidate (&candidates, t,
5593 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5596 if (!COMPLETE_TYPE_P (basetype))
5597 cxx_incomplete_type_error (instance_ptr, basetype);
5603 pretty_name = name_as_c_string (name, basetype, &free_p);
5604 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5605 basetype, pretty_name, user_args,
5606 TREE_TYPE (TREE_TYPE (instance_ptr)));
5610 print_z_candidates (candidates);
5611 call = error_mark_node;
5615 cand = tourney (candidates);
5621 pretty_name = name_as_c_string (name, basetype, &free_p);
5622 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5624 print_z_candidates (candidates);
5627 call = error_mark_node;
5633 if (!(flags & LOOKUP_NONVIRTUAL)
5634 && DECL_PURE_VIRTUAL_P (fn)
5635 && instance == current_class_ref
5636 && (DECL_CONSTRUCTOR_P (current_function_decl)
5637 || DECL_DESTRUCTOR_P (current_function_decl)))
5638 /* This is not an error, it is runtime undefined
5640 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5641 "abstract virtual %q#D called from constructor"
5642 : "abstract virtual %q#D called from destructor"),
5645 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5646 && is_dummy_object (instance_ptr))
5648 error ("cannot call member function %qD without object",
5650 call = error_mark_node;
5654 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5655 && resolves_to_fixed_type_p (instance, 0))
5656 flags |= LOOKUP_NONVIRTUAL;
5657 /* Now we know what function is being called. */
5660 /* Build the actual CALL_EXPR. */
5661 call = build_over_call (cand, flags);
5662 /* In an expression of the form `a->f()' where `f' turns
5663 out to be a static member function, `a' is
5664 none-the-less evaluated. */
5665 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
5666 && !is_dummy_object (instance_ptr)
5667 && TREE_SIDE_EFFECTS (instance_ptr))
5668 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5669 instance_ptr, call);
5670 else if (call != error_mark_node
5671 && DECL_DESTRUCTOR_P (cand->fn)
5672 && !VOID_TYPE_P (TREE_TYPE (call)))
5673 /* An explicit call of the form "x->~X()" has type
5674 "void". However, on platforms where destructors
5675 return "this" (i.e., those where
5676 targetm.cxx.cdtor_returns_this is true), such calls
5677 will appear to have a return value of pointer type
5678 to the low-level call machinery. We do not want to
5679 change the low-level machinery, since we want to be
5680 able to optimize "delete f()" on such platforms as
5681 "operator delete(~X(f()))" (rather than generating
5682 "t = f(), ~X(t), operator delete (t)"). */
5683 call = build_nop (void_type_node, call);
5688 if (processing_template_decl && call != error_mark_node)
5689 call = (build_min_non_dep_call_list
5691 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5694 /* Free all the conversions we allocated. */
5695 obstack_free (&conversion_obstack, p);
5700 /* Returns true iff standard conversion sequence ICS1 is a proper
5701 subsequence of ICS2. */
5704 is_subseq (conversion *ics1, conversion *ics2)
5706 /* We can assume that a conversion of the same code
5707 between the same types indicates a subsequence since we only get
5708 here if the types we are converting from are the same. */
5710 while (ics1->kind == ck_rvalue
5711 || ics1->kind == ck_lvalue)
5712 ics1 = ics1->u.next;
5716 while (ics2->kind == ck_rvalue
5717 || ics2->kind == ck_lvalue)
5718 ics2 = ics2->u.next;
5720 if (ics2->kind == ck_user
5721 || ics2->kind == ck_ambig
5722 || ics2->kind == ck_identity)
5723 /* At this point, ICS1 cannot be a proper subsequence of
5724 ICS2. We can get a USER_CONV when we are comparing the
5725 second standard conversion sequence of two user conversion
5729 ics2 = ics2->u.next;
5731 if (ics2->kind == ics1->kind
5732 && same_type_p (ics2->type, ics1->type)
5733 && same_type_p (ics2->u.next->type,
5734 ics1->u.next->type))
5739 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5740 be any _TYPE nodes. */
5743 is_properly_derived_from (tree derived, tree base)
5745 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5746 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5749 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5750 considers every class derived from itself. */
5751 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5752 && DERIVED_FROM_P (base, derived));
5755 /* We build the ICS for an implicit object parameter as a pointer
5756 conversion sequence. However, such a sequence should be compared
5757 as if it were a reference conversion sequence. If ICS is the
5758 implicit conversion sequence for an implicit object parameter,
5759 modify it accordingly. */
5762 maybe_handle_implicit_object (conversion **ics)
5766 /* [over.match.funcs]
5768 For non-static member functions, the type of the
5769 implicit object parameter is "reference to cv X"
5770 where X is the class of which the function is a
5771 member and cv is the cv-qualification on the member
5772 function declaration. */
5773 conversion *t = *ics;
5774 tree reference_type;
5776 /* The `this' parameter is a pointer to a class type. Make the
5777 implicit conversion talk about a reference to that same class
5779 reference_type = TREE_TYPE (t->type);
5780 reference_type = build_reference_type (reference_type);
5782 if (t->kind == ck_qual)
5784 if (t->kind == ck_ptr)
5786 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5787 t = direct_reference_binding (reference_type, t);
5789 t->rvaluedness_matches_p = 0;
5794 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5795 and return the initial reference binding conversion. Otherwise,
5796 leave *ICS unchanged and return NULL. */
5799 maybe_handle_ref_bind (conversion **ics)
5801 if ((*ics)->kind == ck_ref_bind)
5803 conversion *old_ics = *ics;
5804 *ics = old_ics->u.next;
5805 (*ics)->user_conv_p = old_ics->user_conv_p;
5806 (*ics)->bad_p = old_ics->bad_p;
5813 /* Compare two implicit conversion sequences according to the rules set out in
5814 [over.ics.rank]. Return values:
5816 1: ics1 is better than ics2
5817 -1: ics2 is better than ics1
5818 0: ics1 and ics2 are indistinguishable */
5821 compare_ics (conversion *ics1, conversion *ics2)
5827 tree deref_from_type1 = NULL_TREE;
5828 tree deref_from_type2 = NULL_TREE;
5829 tree deref_to_type1 = NULL_TREE;
5830 tree deref_to_type2 = NULL_TREE;
5831 conversion_rank rank1, rank2;
5833 /* REF_BINDING is nonzero if the result of the conversion sequence
5834 is a reference type. In that case REF_CONV is the reference
5835 binding conversion. */
5836 conversion *ref_conv1;
5837 conversion *ref_conv2;
5839 /* Handle implicit object parameters. */
5840 maybe_handle_implicit_object (&ics1);
5841 maybe_handle_implicit_object (&ics2);
5843 /* Handle reference parameters. */
5844 ref_conv1 = maybe_handle_ref_bind (&ics1);
5845 ref_conv2 = maybe_handle_ref_bind (&ics2);
5849 When comparing the basic forms of implicit conversion sequences (as
5850 defined in _over.best.ics_)
5852 --a standard conversion sequence (_over.ics.scs_) is a better
5853 conversion sequence than a user-defined conversion sequence
5854 or an ellipsis conversion sequence, and
5856 --a user-defined conversion sequence (_over.ics.user_) is a
5857 better conversion sequence than an ellipsis conversion sequence
5858 (_over.ics.ellipsis_). */
5859 rank1 = CONVERSION_RANK (ics1);
5860 rank2 = CONVERSION_RANK (ics2);
5864 else if (rank1 < rank2)
5867 if (rank1 == cr_bad)
5869 /* XXX Isn't this an extension? */
5870 /* Both ICS are bad. We try to make a decision based on what
5871 would have happened if they'd been good. */
5872 if (ics1->user_conv_p > ics2->user_conv_p
5873 || ics1->rank > ics2->rank)
5875 else if (ics1->user_conv_p < ics2->user_conv_p
5876 || ics1->rank < ics2->rank)
5879 /* We couldn't make up our minds; try to figure it out below. */
5882 if (ics1->ellipsis_p)
5883 /* Both conversions are ellipsis conversions. */
5886 /* User-defined conversion sequence U1 is a better conversion sequence
5887 than another user-defined conversion sequence U2 if they contain the
5888 same user-defined conversion operator or constructor and if the sec-
5889 ond standard conversion sequence of U1 is better than the second
5890 standard conversion sequence of U2. */
5892 if (ics1->user_conv_p)
5897 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5898 if (t1->kind == ck_ambig)
5900 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5901 if (t2->kind == ck_ambig)
5904 if (t1->cand->fn != t2->cand->fn)
5907 /* We can just fall through here, after setting up
5908 FROM_TYPE1 and FROM_TYPE2. */
5909 from_type1 = t1->type;
5910 from_type2 = t2->type;
5917 /* We're dealing with two standard conversion sequences.
5921 Standard conversion sequence S1 is a better conversion
5922 sequence than standard conversion sequence S2 if
5924 --S1 is a proper subsequence of S2 (comparing the conversion
5925 sequences in the canonical form defined by _over.ics.scs_,
5926 excluding any Lvalue Transformation; the identity
5927 conversion sequence is considered to be a subsequence of
5928 any non-identity conversion sequence */
5931 while (t1->kind != ck_identity)
5933 from_type1 = t1->type;
5936 while (t2->kind != ck_identity)
5938 from_type2 = t2->type;
5941 /* One sequence can only be a subsequence of the other if they start with
5942 the same type. They can start with different types when comparing the
5943 second standard conversion sequence in two user-defined conversion
5945 if (same_type_p (from_type1, from_type2))
5947 if (is_subseq (ics1, ics2))
5949 if (is_subseq (ics2, ics1))
5957 --the rank of S1 is better than the rank of S2 (by the rules
5960 Standard conversion sequences are ordered by their ranks: an Exact
5961 Match is a better conversion than a Promotion, which is a better
5962 conversion than a Conversion.
5964 Two conversion sequences with the same rank are indistinguishable
5965 unless one of the following rules applies:
5967 --A conversion that is not a conversion of a pointer, or pointer
5968 to member, to bool is better than another conversion that is such
5971 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5972 so that we do not have to check it explicitly. */
5973 if (ics1->rank < ics2->rank)
5975 else if (ics2->rank < ics1->rank)
5978 to_type1 = ics1->type;
5979 to_type2 = ics2->type;
5981 /* A conversion from scalar arithmetic type to complex is worse than a
5982 conversion between scalar arithmetic types. */
5983 if (same_type_p (from_type1, from_type2)
5984 && ARITHMETIC_TYPE_P (from_type1)
5985 && ARITHMETIC_TYPE_P (to_type1)
5986 && ARITHMETIC_TYPE_P (to_type2)
5987 && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
5988 != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
5990 if (TREE_CODE (to_type1) == COMPLEX_TYPE)
5996 if (TYPE_PTR_P (from_type1)
5997 && TYPE_PTR_P (from_type2)
5998 && TYPE_PTR_P (to_type1)
5999 && TYPE_PTR_P (to_type2))
6001 deref_from_type1 = TREE_TYPE (from_type1);
6002 deref_from_type2 = TREE_TYPE (from_type2);
6003 deref_to_type1 = TREE_TYPE (to_type1);
6004 deref_to_type2 = TREE_TYPE (to_type2);
6006 /* The rules for pointers to members A::* are just like the rules
6007 for pointers A*, except opposite: if B is derived from A then
6008 A::* converts to B::*, not vice versa. For that reason, we
6009 switch the from_ and to_ variables here. */
6010 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6011 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6012 || (TYPE_PTRMEMFUNC_P (from_type1)
6013 && TYPE_PTRMEMFUNC_P (from_type2)
6014 && TYPE_PTRMEMFUNC_P (to_type1)
6015 && TYPE_PTRMEMFUNC_P (to_type2)))
6017 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6018 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6019 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6020 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6023 if (deref_from_type1 != NULL_TREE
6024 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
6025 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
6027 /* This was one of the pointer or pointer-like conversions.
6031 --If class B is derived directly or indirectly from class A,
6032 conversion of B* to A* is better than conversion of B* to
6033 void*, and conversion of A* to void* is better than
6034 conversion of B* to void*. */
6035 if (TREE_CODE (deref_to_type1) == VOID_TYPE
6036 && TREE_CODE (deref_to_type2) == VOID_TYPE)
6038 if (is_properly_derived_from (deref_from_type1,
6041 else if (is_properly_derived_from (deref_from_type2,
6045 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6046 || TREE_CODE (deref_to_type2) == VOID_TYPE)
6048 if (same_type_p (deref_from_type1, deref_from_type2))
6050 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6052 if (is_properly_derived_from (deref_from_type1,
6056 /* We know that DEREF_TO_TYPE1 is `void' here. */
6057 else if (is_properly_derived_from (deref_from_type1,
6062 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
6063 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
6067 --If class B is derived directly or indirectly from class A
6068 and class C is derived directly or indirectly from B,
6070 --conversion of C* to B* is better than conversion of C* to
6073 --conversion of B* to A* is better than conversion of C* to
6075 if (same_type_p (deref_from_type1, deref_from_type2))
6077 if (is_properly_derived_from (deref_to_type1,
6080 else if (is_properly_derived_from (deref_to_type2,
6084 else if (same_type_p (deref_to_type1, deref_to_type2))
6086 if (is_properly_derived_from (deref_from_type2,
6089 else if (is_properly_derived_from (deref_from_type1,
6095 else if (CLASS_TYPE_P (non_reference (from_type1))
6096 && same_type_p (from_type1, from_type2))
6098 tree from = non_reference (from_type1);
6102 --binding of an expression of type C to a reference of type
6103 B& is better than binding an expression of type C to a
6104 reference of type A&
6106 --conversion of C to B is better than conversion of C to A, */
6107 if (is_properly_derived_from (from, to_type1)
6108 && is_properly_derived_from (from, to_type2))
6110 if (is_properly_derived_from (to_type1, to_type2))
6112 else if (is_properly_derived_from (to_type2, to_type1))
6116 else if (CLASS_TYPE_P (non_reference (to_type1))
6117 && same_type_p (to_type1, to_type2))
6119 tree to = non_reference (to_type1);
6123 --binding of an expression of type B to a reference of type
6124 A& is better than binding an expression of type C to a
6125 reference of type A&,
6127 --conversion of B to A is better than conversion of C to A */
6128 if (is_properly_derived_from (from_type1, to)
6129 && is_properly_derived_from (from_type2, to))
6131 if (is_properly_derived_from (from_type2, from_type1))
6133 else if (is_properly_derived_from (from_type1, from_type2))
6140 --S1 and S2 differ only in their qualification conversion and yield
6141 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6142 qualification signature of type T1 is a proper subset of the cv-
6143 qualification signature of type T2 */
6144 if (ics1->kind == ck_qual
6145 && ics2->kind == ck_qual
6146 && same_type_p (from_type1, from_type2))
6148 int result = comp_cv_qual_signature (to_type1, to_type2);
6155 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6156 to an implicit object parameter, and either S1 binds an lvalue reference
6157 to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6158 reference to an rvalue and S2 binds an lvalue reference
6159 (C++0x draft standard, 13.3.3.2)
6161 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6162 types to which the references refer are the same type except for
6163 top-level cv-qualifiers, and the type to which the reference
6164 initialized by S2 refers is more cv-qualified than the type to
6165 which the reference initialized by S1 refers */
6167 if (ref_conv1 && ref_conv2)
6169 if (!ref_conv1->this_p && !ref_conv2->this_p
6170 && (TYPE_REF_IS_RVALUE (ref_conv1->type)
6171 != TYPE_REF_IS_RVALUE (ref_conv2->type)))
6173 if (ref_conv1->rvaluedness_matches_p)
6175 if (ref_conv2->rvaluedness_matches_p)
6179 if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
6180 return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
6181 TREE_TYPE (ref_conv1->type));
6184 /* Neither conversion sequence is better than the other. */
6188 /* The source type for this standard conversion sequence. */
6191 source_type (conversion *t)
6193 for (;; t = t->u.next)
6195 if (t->kind == ck_user
6196 || t->kind == ck_ambig
6197 || t->kind == ck_identity)
6203 /* Note a warning about preferring WINNER to LOSER. We do this by storing
6204 a pointer to LOSER and re-running joust to produce the warning if WINNER
6205 is actually used. */
6208 add_warning (struct z_candidate *winner, struct z_candidate *loser)
6210 candidate_warning *cw = (candidate_warning *)
6211 conversion_obstack_alloc (sizeof (candidate_warning));
6213 cw->next = winner->warnings;
6214 winner->warnings = cw;
6217 /* Compare two candidates for overloading as described in
6218 [over.match.best]. Return values:
6220 1: cand1 is better than cand2
6221 -1: cand2 is better than cand1
6222 0: cand1 and cand2 are indistinguishable */
6225 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6228 int off1 = 0, off2 = 0;
6232 /* Candidates that involve bad conversions are always worse than those
6234 if (cand1->viable > cand2->viable)
6236 if (cand1->viable < cand2->viable)
6239 /* If we have two pseudo-candidates for conversions to the same type,
6240 or two candidates for the same function, arbitrarily pick one. */
6241 if (cand1->fn == cand2->fn
6242 && (IS_TYPE_OR_DECL_P (cand1->fn)))
6245 /* a viable function F1
6246 is defined to be a better function than another viable function F2 if
6247 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6248 ICSi(F2), and then */
6250 /* for some argument j, ICSj(F1) is a better conversion sequence than
6253 /* For comparing static and non-static member functions, we ignore
6254 the implicit object parameter of the non-static function. The
6255 standard says to pretend that the static function has an object
6256 parm, but that won't work with operator overloading. */
6257 len = cand1->num_convs;
6258 if (len != cand2->num_convs)
6260 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6261 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6263 gcc_assert (static_1 != static_2);
6274 for (i = 0; i < len; ++i)
6276 conversion *t1 = cand1->convs[i + off1];
6277 conversion *t2 = cand2->convs[i + off2];
6278 int comp = compare_ics (t1, t2);
6283 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6284 == cr_std + cr_promotion)
6285 && t1->kind == ck_std
6286 && t2->kind == ck_std
6287 && TREE_CODE (t1->type) == INTEGER_TYPE
6288 && TREE_CODE (t2->type) == INTEGER_TYPE
6289 && (TYPE_PRECISION (t1->type)
6290 == TYPE_PRECISION (t2->type))
6291 && (TYPE_UNSIGNED (t1->u.next->type)
6292 || (TREE_CODE (t1->u.next->type)
6295 tree type = t1->u.next->type;
6297 struct z_candidate *w, *l;
6299 type1 = t1->type, type2 = t2->type,
6300 w = cand1, l = cand2;
6302 type1 = t2->type, type2 = t1->type,
6303 w = cand2, l = cand1;
6307 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6308 type, type1, type2);
6309 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
6315 if (winner && comp != winner)
6324 /* warn about confusing overload resolution for user-defined conversions,
6325 either between a constructor and a conversion op, or between two
6327 if (winner && warn_conversion && cand1->second_conv
6328 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6329 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6331 struct z_candidate *w, *l;
6332 bool give_warning = false;
6335 w = cand1, l = cand2;
6337 w = cand2, l = cand1;
6339 /* We don't want to complain about `X::operator T1 ()'
6340 beating `X::operator T2 () const', when T2 is a no less
6341 cv-qualified version of T1. */
6342 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6343 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6345 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6346 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6348 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6353 if (!comp_ptr_ttypes (t, f))
6354 give_warning = true;
6357 give_warning = true;
6363 tree source = source_type (w->convs[0]);
6364 if (! DECL_CONSTRUCTOR_P (w->fn))
6365 source = TREE_TYPE (source);
6366 warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn);
6367 warning (OPT_Wconversion, " for conversion from %qT to %qT",
6368 source, w->second_conv->type);
6369 inform (" because conversion sequence for the argument is better");
6379 F1 is a non-template function and F2 is a template function
6382 if (!cand1->template_decl && cand2->template_decl)
6384 else if (cand1->template_decl && !cand2->template_decl)
6388 F1 and F2 are template functions and the function template for F1 is
6389 more specialized than the template for F2 according to the partial
6392 if (cand1->template_decl && cand2->template_decl)
6394 winner = more_specialized_fn
6395 (TI_TEMPLATE (cand1->template_decl),
6396 TI_TEMPLATE (cand2->template_decl),
6397 /* [temp.func.order]: The presence of unused ellipsis and default
6398 arguments has no effect on the partial ordering of function
6399 templates. add_function_candidate() will not have
6400 counted the "this" argument for constructors. */
6401 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6407 the context is an initialization by user-defined conversion (see
6408 _dcl.init_ and _over.match.user_) and the standard conversion
6409 sequence from the return type of F1 to the destination type (i.e.,
6410 the type of the entity being initialized) is a better conversion
6411 sequence than the standard conversion sequence from the return type
6412 of F2 to the destination type. */
6414 if (cand1->second_conv)
6416 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6421 /* Check whether we can discard a builtin candidate, either because we
6422 have two identical ones or matching builtin and non-builtin candidates.
6424 (Pedantically in the latter case the builtin which matched the user
6425 function should not be added to the overload set, but we spot it here.
6428 ... the builtin candidates include ...
6429 - do not have the same parameter type list as any non-template
6430 non-member candidate. */
6432 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6433 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6435 for (i = 0; i < len; ++i)
6436 if (!same_type_p (cand1->convs[i]->type,
6437 cand2->convs[i]->type))
6439 if (i == cand1->num_convs)
6441 if (cand1->fn == cand2->fn)
6442 /* Two built-in candidates; arbitrarily pick one. */
6444 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6445 /* cand1 is built-in; prefer cand2. */
6448 /* cand2 is built-in; prefer cand1. */
6453 /* If the two functions are the same (this can happen with declarations
6454 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6455 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6456 && equal_functions (cand1->fn, cand2->fn))
6461 /* Extension: If the worst conversion for one candidate is worse than the
6462 worst conversion for the other, take the first. */
6465 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6466 struct z_candidate *w = 0, *l = 0;
6468 for (i = 0; i < len; ++i)
6470 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6471 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6472 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6473 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6476 winner = 1, w = cand1, l = cand2;
6478 winner = -1, w = cand2, l = cand1;
6484 ISO C++ says that these are ambiguous, even \
6485 though the worst conversion for the first is better than \
6486 the worst conversion for the second:");
6487 print_z_candidate (_("candidate 1:"), w);
6488 print_z_candidate (_("candidate 2:"), l);
6496 gcc_assert (!winner);
6500 /* Given a list of candidates for overloading, find the best one, if any.
6501 This algorithm has a worst case of O(2n) (winner is last), and a best
6502 case of O(n/2) (totally ambiguous); much better than a sorting
6505 static struct z_candidate *
6506 tourney (struct z_candidate *candidates)
6508 struct z_candidate *champ = candidates, *challenger;
6510 int champ_compared_to_predecessor = 0;
6512 /* Walk through the list once, comparing each current champ to the next
6513 candidate, knocking out a candidate or two with each comparison. */
6515 for (challenger = champ->next; challenger; )
6517 fate = joust (champ, challenger, 0);
6519 challenger = challenger->next;
6524 champ = challenger->next;
6527 champ_compared_to_predecessor = 0;
6532 champ_compared_to_predecessor = 1;
6535 challenger = champ->next;
6539 /* Make sure the champ is better than all the candidates it hasn't yet
6540 been compared to. */
6542 for (challenger = candidates;
6544 && !(champ_compared_to_predecessor && challenger->next == champ);
6545 challenger = challenger->next)
6547 fate = joust (champ, challenger, 0);
6555 /* Returns nonzero if things of type FROM can be converted to TO. */
6558 can_convert (tree to, tree from)
6560 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6563 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6566 can_convert_arg (tree to, tree from, tree arg, int flags)
6572 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6573 p = conversion_obstack_alloc (0);
6575 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6577 ok_p = (t && !t->bad_p);
6579 /* Free all the conversions we allocated. */
6580 obstack_free (&conversion_obstack, p);
6585 /* Like can_convert_arg, but allows dubious conversions as well. */
6588 can_convert_arg_bad (tree to, tree from, tree arg)
6593 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6594 p = conversion_obstack_alloc (0);
6595 /* Try to perform the conversion. */
6596 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6598 /* Free all the conversions we allocated. */
6599 obstack_free (&conversion_obstack, p);
6604 /* Convert EXPR to TYPE. Return the converted expression.
6606 Note that we allow bad conversions here because by the time we get to
6607 this point we are committed to doing the conversion. If we end up
6608 doing a bad conversion, convert_like will complain. */
6611 perform_implicit_conversion (tree type, tree expr)
6616 if (error_operand_p (expr))
6617 return error_mark_node;
6619 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6620 p = conversion_obstack_alloc (0);
6622 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6627 error ("could not convert %qE to %qT", expr, type);
6628 expr = error_mark_node;
6630 else if (processing_template_decl)
6632 /* In a template, we are only concerned about determining the
6633 type of non-dependent expressions, so we do not have to
6634 perform the actual conversion. */
6635 if (TREE_TYPE (expr) != type)
6636 expr = build_nop (type, expr);
6639 expr = convert_like (conv, expr);
6641 /* Free all the conversions we allocated. */
6642 obstack_free (&conversion_obstack, p);
6647 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6648 permitted. If the conversion is valid, the converted expression is
6649 returned. Otherwise, NULL_TREE is returned, except in the case
6650 that TYPE is a class type; in that case, an error is issued. If
6651 C_CAST_P is true, then this direction initialization is taking
6652 place as part of a static_cast being attempted as part of a C-style
6656 perform_direct_initialization_if_possible (tree type,
6663 if (type == error_mark_node || error_operand_p (expr))
6664 return error_mark_node;
6667 If the destination type is a (possibly cv-qualified) class type:
6669 -- If the initialization is direct-initialization ...,
6670 constructors are considered. ... If no constructor applies, or
6671 the overload resolution is ambiguous, the initialization is
6673 if (CLASS_TYPE_P (type))
6675 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6676 build_tree_list (NULL_TREE, expr),
6677 type, LOOKUP_NORMAL);
6678 return build_cplus_new (type, expr);
6681 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6682 p = conversion_obstack_alloc (0);
6684 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6687 if (!conv || conv->bad_p)
6690 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6691 /*issue_conversion_warnings=*/false,
6694 /* Free all the conversions we allocated. */
6695 obstack_free (&conversion_obstack, p);
6700 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6701 is being bound to a temporary. Create and return a new VAR_DECL
6702 with the indicated TYPE; this variable will store the value to
6703 which the reference is bound. */
6706 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6710 /* Create the variable. */
6711 var = create_temporary_var (type);
6713 /* Register the variable. */
6714 if (TREE_STATIC (decl))
6716 /* Namespace-scope or local static; give it a mangled name. */
6719 TREE_STATIC (var) = 1;
6720 name = mangle_ref_init_variable (decl);
6721 DECL_NAME (var) = name;
6722 SET_DECL_ASSEMBLER_NAME (var, name);
6723 var = pushdecl_top_level (var);
6726 /* Create a new cleanup level if necessary. */
6727 maybe_push_cleanup_level (type);
6732 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6733 initializing a variable of that TYPE. If DECL is non-NULL, it is
6734 the VAR_DECL being initialized with the EXPR. (In that case, the
6735 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6736 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6737 return, if *CLEANUP is no longer NULL, it will be an expression
6738 that should be pushed as a cleanup after the returned expression
6739 is used to initialize DECL.
6741 Return the converted expression. */
6744 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6749 if (type == error_mark_node || error_operand_p (expr))
6750 return error_mark_node;
6752 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6753 p = conversion_obstack_alloc (0);
6755 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
6757 if (!conv || conv->bad_p)
6759 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6760 && !real_lvalue_p (expr))
6761 error ("invalid initialization of non-const reference of "
6762 "type %qT from a temporary of type %qT",
6763 type, TREE_TYPE (expr));
6765 error ("invalid initialization of reference of type "
6766 "%qT from expression of type %qT", type,
6768 return error_mark_node;
6771 /* If DECL is non-NULL, then this special rule applies:
6775 The temporary to which the reference is bound or the temporary
6776 that is the complete object to which the reference is bound
6777 persists for the lifetime of the reference.
6779 The temporaries created during the evaluation of the expression
6780 initializing the reference, except the temporary to which the
6781 reference is bound, are destroyed at the end of the
6782 full-expression in which they are created.
6784 In that case, we store the converted expression into a new
6785 VAR_DECL in a new scope.
6787 However, we want to be careful not to create temporaries when
6788 they are not required. For example, given:
6791 struct D : public B {};
6795 there is no need to copy the return value from "f"; we can just
6796 extend its lifetime. Similarly, given:
6799 struct T { operator S(); };
6803 we can extend the lifetime of the return value of the conversion
6805 gcc_assert (conv->kind == ck_ref_bind);
6809 tree base_conv_type;
6811 /* Skip over the REF_BIND. */
6812 conv = conv->u.next;
6813 /* If the next conversion is a BASE_CONV, skip that too -- but
6814 remember that the conversion was required. */
6815 if (conv->kind == ck_base)
6817 base_conv_type = conv->type;
6818 conv = conv->u.next;
6821 base_conv_type = NULL_TREE;
6822 /* Perform the remainder of the conversion. */
6823 expr = convert_like_real (conv, expr,
6824 /*fn=*/NULL_TREE, /*argnum=*/0,
6826 /*issue_conversion_warnings=*/true,
6827 /*c_cast_p=*/false);
6828 if (error_operand_p (expr))
6829 expr = error_mark_node;
6832 if (!real_lvalue_p (expr))
6837 /* Create the temporary variable. */
6838 type = TREE_TYPE (expr);
6839 var = make_temporary_var_for_ref_to_temp (decl, type);
6840 layout_decl (var, 0);
6841 /* If the rvalue is the result of a function call it will be
6842 a TARGET_EXPR. If it is some other construct (such as a
6843 member access expression where the underlying object is
6844 itself the result of a function call), turn it into a
6845 TARGET_EXPR here. It is important that EXPR be a
6846 TARGET_EXPR below since otherwise the INIT_EXPR will
6847 attempt to make a bitwise copy of EXPR to initialize
6849 if (TREE_CODE (expr) != TARGET_EXPR)
6850 expr = get_target_expr (expr);
6851 /* Create the INIT_EXPR that will initialize the temporary
6853 init = build2 (INIT_EXPR, type, var, expr);
6854 if (at_function_scope_p ())
6856 add_decl_expr (var);
6858 if (TREE_STATIC (var))
6859 init = add_stmt_to_compound (init, register_dtor_fn (var));
6861 *cleanup = cxx_maybe_build_cleanup (var);
6863 /* We must be careful to destroy the temporary only
6864 after its initialization has taken place. If the
6865 initialization throws an exception, then the
6866 destructor should not be run. We cannot simply
6867 transform INIT into something like:
6869 (INIT, ({ CLEANUP_STMT; }))
6871 because emit_local_var always treats the
6872 initializer as a full-expression. Thus, the
6873 destructor would run too early; it would run at the
6874 end of initializing the reference variable, rather
6875 than at the end of the block enclosing the
6878 The solution is to pass back a cleanup expression
6879 which the caller is responsible for attaching to
6880 the statement tree. */
6884 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6885 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6886 static_aggregates = tree_cons (NULL_TREE, var,
6889 /* Use its address to initialize the reference variable. */
6890 expr = build_address (var);
6892 expr = convert_to_base (expr,
6893 build_pointer_type (base_conv_type),
6894 /*check_access=*/true,
6896 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6899 /* Take the address of EXPR. */
6900 expr = build_unary_op (ADDR_EXPR, expr, 0);
6901 /* If a BASE_CONV was required, perform it now. */
6903 expr = (perform_implicit_conversion
6904 (build_pointer_type (base_conv_type), expr));
6905 expr = build_nop (type, expr);
6909 /* Perform the conversion. */
6910 expr = convert_like (conv, expr);
6912 /* Free all the conversions we allocated. */
6913 obstack_free (&conversion_obstack, p);
6918 #include "gt-cp-call.h"