1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com) and
6 modified by Brendan Kehoe (brendan@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, 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 COPYING. If not, write to
22 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
26 /* High-level class interface. */
30 #include "coretypes.h"
39 #include "diagnostic.h"
43 #include "langhooks.h"
45 /* The various kinds of conversion. */
47 typedef enum conversion_kind {
61 /* The rank of the conversion. Order of the enumerals matters; better
62 conversions should come earlier in the list. */
64 typedef enum conversion_rank {
75 /* An implicit conversion sequence, in the sense of [over.best.ics].
76 The first conversion to be performed is at the end of the chain.
77 That conversion is always a cr_identity conversion. */
79 typedef struct conversion conversion;
81 /* The kind of conversion represented by this step. */
83 /* The rank of this conversion. */
85 BOOL_BITFIELD user_conv_p : 1;
86 BOOL_BITFIELD ellipsis_p : 1;
87 BOOL_BITFIELD this_p : 1;
88 BOOL_BITFIELD bad_p : 1;
89 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
90 temporary should be created to hold the result of the
92 BOOL_BITFIELD need_temporary_p : 1;
93 /* If KIND is ck_identity or ck_base_conv, true to indicate that the
94 copy constructor must be accessible, even though it is not being
96 BOOL_BITFIELD check_copy_constructor_p : 1;
97 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
98 from a pointer-to-derived to pointer-to-base is being performed. */
99 BOOL_BITFIELD base_p : 1;
100 /* The type of the expression resulting from the conversion. */
103 /* The next conversion in the chain. Since the conversions are
104 arranged from outermost to innermost, the NEXT conversion will
105 actually be performed before this conversion. This variant is
106 used only when KIND is neither ck_identity nor ck_ambig. */
108 /* The expression at the beginning of the conversion chain. This
109 variant is used only if KIND is ck_identity or ck_ambig. */
112 /* The function candidate corresponding to this conversion
113 sequence. This field is only used if KIND is ck_user. */
114 struct z_candidate *cand;
117 #define CONVERSION_RANK(NODE) \
118 ((NODE)->bad_p ? cr_bad \
119 : (NODE)->ellipsis_p ? cr_ellipsis \
120 : (NODE)->user_conv_p ? cr_user \
123 static struct obstack conversion_obstack;
124 static bool conversion_obstack_initialized;
126 static struct z_candidate * tourney (struct z_candidate *);
127 static int equal_functions (tree, tree);
128 static int joust (struct z_candidate *, struct z_candidate *, bool);
129 static int compare_ics (conversion *, conversion *);
130 static tree build_over_call (struct z_candidate *, int);
131 static tree build_java_interface_fn_ref (tree, tree);
132 #define convert_like(CONV, EXPR) \
133 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
134 /*issue_conversion_warnings=*/true, \
136 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
137 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
138 /*issue_conversion_warnings=*/true, \
140 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
142 static void op_error (enum tree_code, enum tree_code, tree, tree,
144 static tree build_object_call (tree, tree);
145 static tree resolve_args (tree);
146 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
147 static void print_z_candidate (const char *, struct z_candidate *);
148 static void print_z_candidates (struct z_candidate *);
149 static tree build_this (tree);
150 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
151 static bool any_strictly_viable (struct z_candidate *);
152 static struct z_candidate *add_template_candidate
153 (struct z_candidate **, tree, tree, tree, tree, tree,
154 tree, tree, int, unification_kind_t);
155 static struct z_candidate *add_template_candidate_real
156 (struct z_candidate **, tree, tree, tree, tree, tree,
157 tree, tree, int, tree, unification_kind_t);
158 static struct z_candidate *add_template_conv_candidate
159 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
160 static void add_builtin_candidates
161 (struct z_candidate **, enum tree_code, enum tree_code,
163 static void add_builtin_candidate
164 (struct z_candidate **, enum tree_code, enum tree_code,
165 tree, tree, tree, tree *, tree *, int);
166 static bool is_complete (tree);
167 static void build_builtin_candidate
168 (struct z_candidate **, tree, tree, tree, tree *, tree *,
170 static struct z_candidate *add_conv_candidate
171 (struct z_candidate **, tree, tree, tree, tree, tree);
172 static struct z_candidate *add_function_candidate
173 (struct z_candidate **, tree, tree, tree, tree, tree, int);
174 static conversion *implicit_conversion (tree, tree, tree, bool, int);
175 static conversion *standard_conversion (tree, tree, tree, bool, int);
176 static conversion *reference_binding (tree, tree, tree, int);
177 static conversion *build_conv (conversion_kind, tree, conversion *);
178 static bool is_subseq (conversion *, conversion *);
179 static tree maybe_handle_ref_bind (conversion **);
180 static void maybe_handle_implicit_object (conversion **);
181 static struct z_candidate *add_candidate
182 (struct z_candidate **, tree, tree, size_t,
183 conversion **, tree, tree, int);
184 static tree source_type (conversion *);
185 static void add_warning (struct z_candidate *, struct z_candidate *);
186 static bool reference_related_p (tree, tree);
187 static bool reference_compatible_p (tree, tree);
188 static conversion *convert_class_to_reference (tree, tree, tree);
189 static conversion *direct_reference_binding (tree, conversion *);
190 static bool promoted_arithmetic_type_p (tree);
191 static conversion *conditional_conversion (tree, tree);
192 static char *name_as_c_string (tree, tree, bool *);
193 static tree call_builtin_trap (void);
194 static tree prep_operand (tree);
195 static void add_candidates (tree, tree, tree, bool, tree, tree,
196 int, struct z_candidate **);
197 static conversion *merge_conversion_sequences (conversion *, conversion *);
198 static bool magic_varargs_p (tree);
199 typedef void (*diagnostic_fn_t) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
200 static tree build_temp (tree, tree, int, diagnostic_fn_t *);
201 static void check_constructor_callable (tree, tree);
203 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
204 NAME can take many forms... */
207 check_dtor_name (tree basetype, tree name)
209 /* Just accept something we've already complained about. */
210 if (name == error_mark_node)
213 if (TREE_CODE (name) == TYPE_DECL)
214 name = TREE_TYPE (name);
215 else if (TYPE_P (name))
217 else if (TREE_CODE (name) == IDENTIFIER_NODE)
219 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
220 || (TREE_CODE (basetype) == ENUMERAL_TYPE
221 && name == TYPE_IDENTIFIER (basetype)))
224 name = get_type_value (name);
230 template <class T> struct S { ~S(); };
234 NAME will be a class template. */
235 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
241 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
244 /* We want the address of a function or method. We avoid creating a
245 pointer-to-member function. */
248 build_addr_func (tree function)
250 tree type = TREE_TYPE (function);
252 /* We have to do these by hand to avoid real pointer to member
254 if (TREE_CODE (type) == METHOD_TYPE)
256 if (TREE_CODE (function) == OFFSET_REF)
258 tree object = build_address (TREE_OPERAND (function, 0));
259 return get_member_function_from_ptrfunc (&object,
260 TREE_OPERAND (function, 1));
262 function = build_address (function);
265 function = decay_conversion (function);
270 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
271 POINTER_TYPE to those. Note, pointer to member function types
272 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
273 two variants. build_call_a is the primitive taking an array of
274 arguments, while build_call_n is a wrapper that handles varargs. */
277 build_call_n (tree function, int n, ...)
280 return build_call_a (function, 0, NULL);
283 tree *argarray = (tree *) alloca (n * sizeof (tree));
288 for (i = 0; i < n; i++)
289 argarray[i] = va_arg (ap, tree);
291 return build_call_a (function, n, argarray);
296 build_call_a (tree function, int n, tree *argarray)
298 int is_constructor = 0;
305 function = build_addr_func (function);
307 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
308 fntype = TREE_TYPE (TREE_TYPE (function));
309 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
310 || TREE_CODE (fntype) == METHOD_TYPE);
311 result_type = TREE_TYPE (fntype);
313 if (TREE_CODE (function) == ADDR_EXPR
314 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
316 decl = TREE_OPERAND (function, 0);
317 if (!TREE_USED (decl))
319 /* We invoke build_call directly for several library
320 functions. These may have been declared normally if
321 we're building libgcc, so we can't just check
323 gcc_assert (DECL_ARTIFICIAL (decl)
324 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
332 /* We check both the decl and the type; a function may be known not to
333 throw without being declared throw(). */
334 nothrow = ((decl && TREE_NOTHROW (decl))
335 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
337 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
338 current_function_returns_abnormally = 1;
340 if (decl && TREE_DEPRECATED (decl))
341 warn_deprecated_use (decl);
342 require_complete_eh_spec_types (fntype, decl);
344 if (decl && DECL_CONSTRUCTOR_P (decl))
347 /* Don't pass empty class objects by value. This is useful
348 for tags in STL, which are used to control overload resolution.
349 We don't need to handle other cases of copying empty classes. */
350 if (! decl || ! DECL_BUILT_IN (decl))
351 for (i = 0; i < n; i++)
352 if (is_empty_class (TREE_TYPE (argarray[i]))
353 && ! TREE_ADDRESSABLE (TREE_TYPE (argarray[i])))
355 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (argarray[i]));
356 argarray[i] = build2 (COMPOUND_EXPR, TREE_TYPE (t),
360 function = build_call_array (result_type, function, n, argarray);
361 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
362 TREE_NOTHROW (function) = nothrow;
367 /* Build something of the form ptr->method (args)
368 or object.method (args). This can also build
369 calls to constructors, and find friends.
371 Member functions always take their class variable
374 INSTANCE is a class instance.
376 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
378 PARMS help to figure out what that NAME really refers to.
380 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
381 down to the real instance type to use for access checking. We need this
382 information to get protected accesses correct.
384 FLAGS is the logical disjunction of zero or more LOOKUP_
385 flags. See cp-tree.h for more info.
387 If this is all OK, calls build_function_call with the resolved
390 This function must also handle being called to perform
391 initialization, promotion/coercion of arguments, and
392 instantiation of default parameters.
394 Note that NAME may refer to an instance variable name. If
395 `operator()()' is defined for the type of that field, then we return
398 /* New overloading code. */
400 typedef struct z_candidate z_candidate;
402 typedef struct candidate_warning candidate_warning;
403 struct candidate_warning {
405 candidate_warning *next;
409 /* The FUNCTION_DECL that will be called if this candidate is
410 selected by overload resolution. */
412 /* The arguments to use when calling this function. */
414 /* The implicit conversion sequences for each of the arguments to
417 /* The number of implicit conversion sequences. */
419 /* If FN is a user-defined conversion, the standard conversion
420 sequence from the type returned by FN to the desired destination
422 conversion *second_conv;
424 /* If FN is a member function, the binfo indicating the path used to
425 qualify the name of FN at the call site. This path is used to
426 determine whether or not FN is accessible if it is selected by
427 overload resolution. The DECL_CONTEXT of FN will always be a
428 (possibly improper) base of this binfo. */
430 /* If FN is a non-static member function, the binfo indicating the
431 subobject to which the `this' pointer should be converted if FN
432 is selected by overload resolution. The type pointed to the by
433 the `this' pointer must correspond to the most derived class
434 indicated by the CONVERSION_PATH. */
435 tree conversion_path;
437 candidate_warning *warnings;
441 /* Returns true iff T is a null pointer constant in the sense of
445 null_ptr_cst_p (tree t)
449 A null pointer constant is an integral constant expression
450 (_expr.const_) rvalue of integer type that evaluates to zero. */
451 t = integral_constant_value (t);
454 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
457 if (!TREE_OVERFLOW (t))
463 /* Returns nonzero if PARMLIST consists of only default parms and/or
467 sufficient_parms_p (tree parmlist)
469 for (; parmlist && parmlist != void_list_node;
470 parmlist = TREE_CHAIN (parmlist))
471 if (!TREE_PURPOSE (parmlist))
476 /* Allocate N bytes of memory from the conversion obstack. The memory
477 is zeroed before being returned. */
480 conversion_obstack_alloc (size_t n)
483 if (!conversion_obstack_initialized)
485 gcc_obstack_init (&conversion_obstack);
486 conversion_obstack_initialized = true;
488 p = obstack_alloc (&conversion_obstack, n);
493 /* Dynamically allocate a conversion. */
496 alloc_conversion (conversion_kind kind)
499 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
504 #ifdef ENABLE_CHECKING
506 /* Make sure that all memory on the conversion obstack has been
510 validate_conversion_obstack (void)
512 if (conversion_obstack_initialized)
513 gcc_assert ((obstack_next_free (&conversion_obstack)
514 == obstack_base (&conversion_obstack)));
517 #endif /* ENABLE_CHECKING */
519 /* Dynamically allocate an array of N conversions. */
522 alloc_conversions (size_t n)
524 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
528 build_conv (conversion_kind code, tree type, conversion *from)
531 conversion_rank rank = CONVERSION_RANK (from);
533 /* We can't use buildl1 here because CODE could be USER_CONV, which
534 takes two arguments. In that case, the caller is responsible for
535 filling in the second argument. */
536 t = alloc_conversion (code);
559 t->user_conv_p = (code == ck_user || from->user_conv_p);
560 t->bad_p = from->bad_p;
565 /* Build a representation of the identity conversion from EXPR to
566 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
569 build_identity_conv (tree type, tree expr)
573 c = alloc_conversion (ck_identity);
580 /* Converting from EXPR to TYPE was ambiguous in the sense that there
581 were multiple user-defined conversions to accomplish the job.
582 Build a conversion that indicates that ambiguity. */
585 build_ambiguous_conv (tree type, tree expr)
589 c = alloc_conversion (ck_ambig);
597 strip_top_quals (tree t)
599 if (TREE_CODE (t) == ARRAY_TYPE)
601 return cp_build_qualified_type (t, 0);
604 /* Returns the standard conversion path (see [conv]) from type FROM to type
605 TO, if any. For proper handling of null pointer constants, you must
606 also pass the expression EXPR to convert from. If C_CAST_P is true,
607 this conversion is coming from a C-style cast. */
610 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
613 enum tree_code fcode, tcode;
615 bool fromref = false;
617 to = non_reference (to);
618 if (TREE_CODE (from) == REFERENCE_TYPE)
621 from = TREE_TYPE (from);
623 to = strip_top_quals (to);
624 from = strip_top_quals (from);
626 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
627 && expr && type_unknown_p (expr))
629 expr = instantiate_type (to, expr, tf_conv);
630 if (expr == error_mark_node)
632 from = TREE_TYPE (expr);
635 fcode = TREE_CODE (from);
636 tcode = TREE_CODE (to);
638 conv = build_identity_conv (from, expr);
639 if (fcode == FUNCTION_TYPE)
641 from = build_pointer_type (from);
642 fcode = TREE_CODE (from);
643 conv = build_conv (ck_lvalue, from, conv);
645 else if (fcode == ARRAY_TYPE)
647 from = build_pointer_type (TREE_TYPE (from));
648 fcode = TREE_CODE (from);
649 conv = build_conv (ck_lvalue, from, conv);
651 else if (fromref || (expr && lvalue_p (expr)))
656 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
658 from = strip_top_quals (bitfield_type);
660 conv = build_conv (ck_rvalue, from, conv);
663 /* Allow conversion between `__complex__' data types. */
664 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
666 /* The standard conversion sequence to convert FROM to TO is
667 the standard conversion sequence to perform componentwise
669 conversion *part_conv = standard_conversion
670 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
674 conv = build_conv (part_conv->kind, to, conv);
675 conv->rank = part_conv->rank;
683 if (same_type_p (from, to))
686 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
687 && expr && null_ptr_cst_p (expr))
688 conv = build_conv (ck_std, to, conv);
689 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
690 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
692 /* For backwards brain damage compatibility, allow interconversion of
693 pointers and integers with a pedwarn. */
694 conv = build_conv (ck_std, to, conv);
697 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
699 /* For backwards brain damage compatibility, allow interconversion of
700 enums and integers with a pedwarn. */
701 conv = build_conv (ck_std, to, conv);
704 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
705 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
710 if (tcode == POINTER_TYPE
711 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
714 else if (VOID_TYPE_P (TREE_TYPE (to))
715 && !TYPE_PTRMEM_P (from)
716 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
718 from = build_pointer_type
719 (cp_build_qualified_type (void_type_node,
720 cp_type_quals (TREE_TYPE (from))));
721 conv = build_conv (ck_ptr, from, conv);
723 else if (TYPE_PTRMEM_P (from))
725 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
726 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
728 if (DERIVED_FROM_P (fbase, tbase)
729 && (same_type_ignoring_top_level_qualifiers_p
730 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
731 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
733 from = build_ptrmem_type (tbase,
734 TYPE_PTRMEM_POINTED_TO_TYPE (from));
735 conv = build_conv (ck_pmem, from, conv);
737 else if (!same_type_p (fbase, tbase))
740 else if (IS_AGGR_TYPE (TREE_TYPE (from))
741 && IS_AGGR_TYPE (TREE_TYPE (to))
744 An rvalue of type "pointer to cv D," where D is a
745 class type, can be converted to an rvalue of type
746 "pointer to cv B," where B is a base class (clause
747 _class.derived_) of D. If B is an inaccessible
748 (clause _class.access_) or ambiguous
749 (_class.member.lookup_) base class of D, a program
750 that necessitates this conversion is ill-formed.
751 Therefore, we use DERIVED_FROM_P, and do not check
752 access or uniqueness. */
753 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from))
754 /* If FROM is not yet complete, then we must be parsing
755 the body of a class. We know what's derived from
756 what, but we can't actually perform a
757 derived-to-base conversion. For example, in:
759 struct D : public B {
760 static const int i = sizeof((B*)(D*)0);
763 the D*-to-B* conversion is a reinterpret_cast, not a
765 && COMPLETE_TYPE_P (TREE_TYPE (from)))
768 cp_build_qualified_type (TREE_TYPE (to),
769 cp_type_quals (TREE_TYPE (from)));
770 from = build_pointer_type (from);
771 conv = build_conv (ck_ptr, from, conv);
775 if (tcode == POINTER_TYPE)
777 to_pointee = TREE_TYPE (to);
778 from_pointee = TREE_TYPE (from);
782 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
783 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
786 if (same_type_p (from, to))
788 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
789 /* In a C-style cast, we ignore CV-qualification because we
790 are allowed to perform a static_cast followed by a
792 conv = build_conv (ck_qual, to, conv);
793 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
794 conv = build_conv (ck_qual, to, conv);
795 else if (expr && string_conv_p (to, expr, 0))
796 /* converting from string constant to char *. */
797 conv = build_conv (ck_qual, to, conv);
798 else if (ptr_reasonably_similar (to_pointee, from_pointee))
800 conv = build_conv (ck_ptr, to, conv);
808 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
810 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
811 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
812 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
813 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
815 if (!DERIVED_FROM_P (fbase, tbase)
816 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
817 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
818 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
819 || cp_type_quals (fbase) != cp_type_quals (tbase))
822 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
823 from = build_method_type_directly (from,
825 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
826 from = build_ptrmemfunc_type (build_pointer_type (from));
827 conv = build_conv (ck_pmem, from, conv);
830 else if (tcode == BOOLEAN_TYPE)
834 An rvalue of arithmetic, enumeration, pointer, or pointer to
835 member type can be converted to an rvalue of type bool. */
836 if (ARITHMETIC_TYPE_P (from)
837 || fcode == ENUMERAL_TYPE
838 || fcode == POINTER_TYPE
839 || TYPE_PTR_TO_MEMBER_P (from))
841 conv = build_conv (ck_std, to, conv);
842 if (fcode == POINTER_TYPE
843 || TYPE_PTRMEM_P (from)
844 || (TYPE_PTRMEMFUNC_P (from)
845 && conv->rank < cr_pbool))
846 conv->rank = cr_pbool;
852 /* We don't check for ENUMERAL_TYPE here because there are no standard
853 conversions to enum type. */
854 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
855 || tcode == REAL_TYPE)
857 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
859 conv = build_conv (ck_std, to, conv);
861 /* Give this a better rank if it's a promotion. */
862 if (same_type_p (to, type_promotes_to (from))
863 && conv->u.next->rank <= cr_promotion)
864 conv->rank = cr_promotion;
866 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
867 && vector_types_convertible_p (from, to, false))
868 return build_conv (ck_std, to, conv);
869 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
870 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
871 && is_properly_derived_from (from, to))
873 if (conv->kind == ck_rvalue)
875 conv = build_conv (ck_base, to, conv);
876 /* The derived-to-base conversion indicates the initialization
877 of a parameter with base type from an object of a derived
878 type. A temporary object is created to hold the result of
880 conv->need_temporary_p = true;
888 /* Returns nonzero if T1 is reference-related to T2. */
891 reference_related_p (tree t1, tree t2)
893 t1 = TYPE_MAIN_VARIANT (t1);
894 t2 = TYPE_MAIN_VARIANT (t2);
898 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
899 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
901 return (same_type_p (t1, t2)
902 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
903 && DERIVED_FROM_P (t1, t2)));
906 /* Returns nonzero if T1 is reference-compatible with T2. */
909 reference_compatible_p (tree t1, tree t2)
913 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
914 reference-related to T2 and cv1 is the same cv-qualification as,
915 or greater cv-qualification than, cv2. */
916 return (reference_related_p (t1, t2)
917 && at_least_as_qualified_p (t1, t2));
920 /* Determine whether or not the EXPR (of class type S) can be
921 converted to T as in [over.match.ref]. */
924 convert_class_to_reference (tree t, tree s, tree expr)
930 struct z_candidate *candidates;
931 struct z_candidate *cand;
934 conversions = lookup_conversions (s);
940 Assuming that "cv1 T" is the underlying type of the reference
941 being initialized, and "cv S" is the type of the initializer
942 expression, with S a class type, the candidate functions are
945 --The conversion functions of S and its base classes are
946 considered. Those that are not hidden within S and yield type
947 "reference to cv2 T2", where "cv1 T" is reference-compatible
948 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
950 The argument list has one argument, which is the initializer
955 /* Conceptually, we should take the address of EXPR and put it in
956 the argument list. Unfortunately, however, that can result in
957 error messages, which we should not issue now because we are just
958 trying to find a conversion operator. Therefore, we use NULL,
959 cast to the appropriate type. */
960 arglist = build_int_cst (build_pointer_type (s), 0);
961 arglist = build_tree_list (NULL_TREE, arglist);
963 reference_type = build_reference_type (t);
967 tree fns = TREE_VALUE (conversions);
969 for (; fns; fns = OVL_NEXT (fns))
971 tree f = OVL_CURRENT (fns);
972 tree t2 = TREE_TYPE (TREE_TYPE (f));
976 /* If this is a template function, try to get an exact
978 if (TREE_CODE (f) == TEMPLATE_DECL)
980 cand = add_template_candidate (&candidates,
986 TREE_PURPOSE (conversions),
992 /* Now, see if the conversion function really returns
993 an lvalue of the appropriate type. From the
994 point of view of unification, simply returning an
995 rvalue of the right type is good enough. */
997 t2 = TREE_TYPE (TREE_TYPE (f));
998 if (TREE_CODE (t2) != REFERENCE_TYPE
999 || !reference_compatible_p (t, TREE_TYPE (t2)))
1001 candidates = candidates->next;
1006 else if (TREE_CODE (t2) == REFERENCE_TYPE
1007 && reference_compatible_p (t, TREE_TYPE (t2)))
1008 cand = add_function_candidate (&candidates, f, s, arglist,
1010 TREE_PURPOSE (conversions),
1015 conversion *identity_conv;
1016 /* Build a standard conversion sequence indicating the
1017 binding from the reference type returned by the
1018 function to the desired REFERENCE_TYPE. */
1020 = build_identity_conv (TREE_TYPE (TREE_TYPE
1021 (TREE_TYPE (cand->fn))),
1024 = (direct_reference_binding
1025 (reference_type, identity_conv));
1026 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1029 conversions = TREE_CHAIN (conversions);
1032 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1033 /* If none of the conversion functions worked out, let our caller
1038 cand = tourney (candidates);
1042 /* Now that we know that this is the function we're going to use fix
1043 the dummy first argument. */
1044 cand->args = tree_cons (NULL_TREE,
1046 TREE_CHAIN (cand->args));
1048 /* Build a user-defined conversion sequence representing the
1050 conv = build_conv (ck_user,
1051 TREE_TYPE (TREE_TYPE (cand->fn)),
1052 build_identity_conv (TREE_TYPE (expr), expr));
1055 /* Merge it with the standard conversion sequence from the
1056 conversion function's return type to the desired type. */
1057 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1059 if (cand->viable == -1)
1062 return cand->second_conv;
1065 /* A reference of the indicated TYPE is being bound directly to the
1066 expression represented by the implicit conversion sequence CONV.
1067 Return a conversion sequence for this binding. */
1070 direct_reference_binding (tree type, conversion *conv)
1074 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1075 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1077 t = TREE_TYPE (type);
1081 When a parameter of reference type binds directly
1082 (_dcl.init.ref_) to an argument expression, the implicit
1083 conversion sequence is the identity conversion, unless the
1084 argument expression has a type that is a derived class of the
1085 parameter type, in which case the implicit conversion sequence is
1086 a derived-to-base Conversion.
1088 If the parameter binds directly to the result of applying a
1089 conversion function to the argument expression, the implicit
1090 conversion sequence is a user-defined conversion sequence
1091 (_over.ics.user_), with the second standard conversion sequence
1092 either an identity conversion or, if the conversion function
1093 returns an entity of a type that is a derived class of the
1094 parameter type, a derived-to-base conversion. */
1095 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1097 /* Represent the derived-to-base conversion. */
1098 conv = build_conv (ck_base, t, conv);
1099 /* We will actually be binding to the base-class subobject in
1100 the derived class, so we mark this conversion appropriately.
1101 That way, convert_like knows not to generate a temporary. */
1102 conv->need_temporary_p = false;
1104 return build_conv (ck_ref_bind, type, conv);
1107 /* Returns the conversion path from type FROM to reference type TO for
1108 purposes of reference binding. For lvalue binding, either pass a
1109 reference type to FROM or an lvalue expression to EXPR. If the
1110 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1111 the conversion returned. */
1114 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1116 conversion *conv = NULL;
1117 tree to = TREE_TYPE (rto);
1121 cp_lvalue_kind lvalue_p = clk_none;
1123 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1125 expr = instantiate_type (to, expr, tf_none);
1126 if (expr == error_mark_node)
1128 from = TREE_TYPE (expr);
1131 if (TREE_CODE (from) == REFERENCE_TYPE)
1133 /* Anything with reference type is an lvalue. */
1134 lvalue_p = clk_ordinary;
1135 from = TREE_TYPE (from);
1138 lvalue_p = real_lvalue_p (expr);
1140 /* Figure out whether or not the types are reference-related and
1141 reference compatible. We have do do this after stripping
1142 references from FROM. */
1143 related_p = reference_related_p (to, from);
1144 compatible_p = reference_compatible_p (to, from);
1146 if (lvalue_p && compatible_p)
1150 If the initializer expression
1152 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1153 is reference-compatible with "cv2 T2,"
1155 the reference is bound directly to the initializer expression
1157 conv = build_identity_conv (from, expr);
1158 conv = direct_reference_binding (rto, conv);
1159 if ((lvalue_p & clk_bitfield) != 0
1160 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1161 /* For the purposes of overload resolution, we ignore the fact
1162 this expression is a bitfield or packed field. (In particular,
1163 [over.ics.ref] says specifically that a function with a
1164 non-const reference parameter is viable even if the
1165 argument is a bitfield.)
1167 However, when we actually call the function we must create
1168 a temporary to which to bind the reference. If the
1169 reference is volatile, or isn't const, then we cannot make
1170 a temporary, so we just issue an error when the conversion
1172 conv->need_temporary_p = true;
1176 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1180 If the initializer expression
1182 -- has a class type (i.e., T2 is a class type) can be
1183 implicitly converted to an lvalue of type "cv3 T3," where
1184 "cv1 T1" is reference-compatible with "cv3 T3". (this
1185 conversion is selected by enumerating the applicable
1186 conversion functions (_over.match.ref_) and choosing the
1187 best one through overload resolution. (_over.match_).
1189 the reference is bound to the lvalue result of the conversion
1190 in the second case. */
1191 conv = convert_class_to_reference (to, from, expr);
1196 /* From this point on, we conceptually need temporaries, even if we
1197 elide them. Only the cases above are "direct bindings". */
1198 if (flags & LOOKUP_NO_TEMP_BIND)
1203 When a parameter of reference type is not bound directly to an
1204 argument expression, the conversion sequence is the one required
1205 to convert the argument expression to the underlying type of the
1206 reference according to _over.best.ics_. Conceptually, this
1207 conversion sequence corresponds to copy-initializing a temporary
1208 of the underlying type with the argument expression. Any
1209 difference in top-level cv-qualification is subsumed by the
1210 initialization itself and does not constitute a conversion. */
1214 Otherwise, the reference shall be to a non-volatile const type. */
1215 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1220 If the initializer expression is an rvalue, with T2 a class type,
1221 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1222 is bound in one of the following ways:
1224 -- The reference is bound to the object represented by the rvalue
1225 or to a sub-object within that object.
1229 We use the first alternative. The implicit conversion sequence
1230 is supposed to be same as we would obtain by generating a
1231 temporary. Fortunately, if the types are reference compatible,
1232 then this is either an identity conversion or the derived-to-base
1233 conversion, just as for direct binding. */
1234 if (CLASS_TYPE_P (from) && compatible_p)
1236 conv = build_identity_conv (from, expr);
1237 conv = direct_reference_binding (rto, conv);
1238 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1239 conv->u.next->check_copy_constructor_p = true;
1245 Otherwise, a temporary of type "cv1 T1" is created and
1246 initialized from the initializer expression using the rules for a
1247 non-reference copy initialization. If T1 is reference-related to
1248 T2, cv1 must be the same cv-qualification as, or greater
1249 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1250 if (related_p && !at_least_as_qualified_p (to, from))
1253 conv = implicit_conversion (to, from, expr, /*c_cast_p=*/false,
1258 conv = build_conv (ck_ref_bind, rto, conv);
1259 /* This reference binding, unlike those above, requires the
1260 creation of a temporary. */
1261 conv->need_temporary_p = true;
1266 /* Returns the implicit conversion sequence (see [over.ics]) from type
1267 FROM to type TO. The optional expression EXPR may affect the
1268 conversion. FLAGS are the usual overloading flags. Only
1269 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1270 conversion is coming from a C-style cast. */
1273 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1278 if (from == error_mark_node || to == error_mark_node
1279 || expr == error_mark_node)
1282 if (TREE_CODE (to) == REFERENCE_TYPE)
1283 conv = reference_binding (to, from, expr, flags);
1285 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1290 if (expr != NULL_TREE
1291 && (IS_AGGR_TYPE (from)
1292 || IS_AGGR_TYPE (to))
1293 && (flags & LOOKUP_NO_CONVERSION) == 0)
1295 struct z_candidate *cand;
1297 cand = build_user_type_conversion_1
1298 (to, expr, LOOKUP_ONLYCONVERTING);
1300 conv = cand->second_conv;
1302 /* We used to try to bind a reference to a temporary here, but that
1303 is now handled by the recursive call to this function at the end
1304 of reference_binding. */
1311 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1314 static struct z_candidate *
1315 add_candidate (struct z_candidate **candidates,
1317 size_t num_convs, conversion **convs,
1318 tree access_path, tree conversion_path,
1321 struct z_candidate *cand = (struct z_candidate *)
1322 conversion_obstack_alloc (sizeof (struct z_candidate));
1326 cand->convs = convs;
1327 cand->num_convs = num_convs;
1328 cand->access_path = access_path;
1329 cand->conversion_path = conversion_path;
1330 cand->viable = viable;
1331 cand->next = *candidates;
1337 /* Create an overload candidate for the function or method FN called with
1338 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1339 to implicit_conversion.
1341 CTYPE, if non-NULL, is the type we want to pretend this function
1342 comes from for purposes of overload resolution. */
1344 static struct z_candidate *
1345 add_function_candidate (struct z_candidate **candidates,
1346 tree fn, tree ctype, tree arglist,
1347 tree access_path, tree conversion_path,
1350 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1353 tree parmnode, argnode;
1357 /* At this point we should not see any functions which haven't been
1358 explicitly declared, except for friend functions which will have
1359 been found using argument dependent lookup. */
1360 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1362 /* The `this', `in_chrg' and VTT arguments to constructors are not
1363 considered in overload resolution. */
1364 if (DECL_CONSTRUCTOR_P (fn))
1366 parmlist = skip_artificial_parms_for (fn, parmlist);
1367 orig_arglist = arglist;
1368 arglist = skip_artificial_parms_for (fn, arglist);
1371 orig_arglist = arglist;
1373 len = list_length (arglist);
1374 convs = alloc_conversions (len);
1376 /* 13.3.2 - Viable functions [over.match.viable]
1377 First, to be a viable function, a candidate function shall have enough
1378 parameters to agree in number with the arguments in the list.
1380 We need to check this first; otherwise, checking the ICSes might cause
1381 us to produce an ill-formed template instantiation. */
1383 parmnode = parmlist;
1384 for (i = 0; i < len; ++i)
1386 if (parmnode == NULL_TREE || parmnode == void_list_node)
1388 parmnode = TREE_CHAIN (parmnode);
1391 if (i < len && parmnode)
1394 /* Make sure there are default args for the rest of the parms. */
1395 else if (!sufficient_parms_p (parmnode))
1401 /* Second, for F to be a viable function, there shall exist for each
1402 argument an implicit conversion sequence that converts that argument
1403 to the corresponding parameter of F. */
1405 parmnode = parmlist;
1408 for (i = 0; i < len; ++i)
1410 tree arg = TREE_VALUE (argnode);
1411 tree argtype = lvalue_type (arg);
1415 if (parmnode == void_list_node)
1418 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1419 && ! DECL_CONSTRUCTOR_P (fn));
1423 tree parmtype = TREE_VALUE (parmnode);
1425 /* The type of the implicit object parameter ('this') for
1426 overload resolution is not always the same as for the
1427 function itself; conversion functions are considered to
1428 be members of the class being converted, and functions
1429 introduced by a using-declaration are considered to be
1430 members of the class that uses them.
1432 Since build_over_call ignores the ICS for the `this'
1433 parameter, we can just change the parm type. */
1434 if (ctype && is_this)
1437 = build_qualified_type (ctype,
1438 TYPE_QUALS (TREE_TYPE (parmtype)));
1439 parmtype = build_pointer_type (parmtype);
1442 t = implicit_conversion (parmtype, argtype, arg,
1443 /*c_cast_p=*/false, flags);
1447 t = build_identity_conv (argtype, arg);
1448 t->ellipsis_p = true;
1465 parmnode = TREE_CHAIN (parmnode);
1466 argnode = TREE_CHAIN (argnode);
1470 return add_candidate (candidates, fn, orig_arglist, len, convs,
1471 access_path, conversion_path, viable);
1474 /* Create an overload candidate for the conversion function FN which will
1475 be invoked for expression OBJ, producing a pointer-to-function which
1476 will in turn be called with the argument list ARGLIST, and add it to
1477 CANDIDATES. FLAGS is passed on to implicit_conversion.
1479 Actually, we don't really care about FN; we care about the type it
1480 converts to. There may be multiple conversion functions that will
1481 convert to that type, and we rely on build_user_type_conversion_1 to
1482 choose the best one; so when we create our candidate, we record the type
1483 instead of the function. */
1485 static struct z_candidate *
1486 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1487 tree arglist, tree access_path, tree conversion_path)
1489 tree totype = TREE_TYPE (TREE_TYPE (fn));
1490 int i, len, viable, flags;
1491 tree parmlist, parmnode, argnode;
1494 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1495 parmlist = TREE_TYPE (parmlist);
1496 parmlist = TYPE_ARG_TYPES (parmlist);
1498 len = list_length (arglist) + 1;
1499 convs = alloc_conversions (len);
1500 parmnode = parmlist;
1503 flags = LOOKUP_NORMAL;
1505 /* Don't bother looking up the same type twice. */
1506 if (*candidates && (*candidates)->fn == totype)
1509 for (i = 0; i < len; ++i)
1511 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1512 tree argtype = lvalue_type (arg);
1516 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1518 else if (parmnode == void_list_node)
1521 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1522 /*c_cast_p=*/false, flags);
1525 t = build_identity_conv (argtype, arg);
1526 t->ellipsis_p = true;
1540 parmnode = TREE_CHAIN (parmnode);
1541 argnode = TREE_CHAIN (argnode);
1547 if (!sufficient_parms_p (parmnode))
1550 return add_candidate (candidates, totype, arglist, len, convs,
1551 access_path, conversion_path, viable);
1555 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1556 tree type1, tree type2, tree *args, tree *argtypes,
1568 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1569 convs = alloc_conversions (num_convs);
1571 for (i = 0; i < 2; ++i)
1576 t = implicit_conversion (types[i], argtypes[i], args[i],
1577 /*c_cast_p=*/false, flags);
1581 /* We need something for printing the candidate. */
1582 t = build_identity_conv (types[i], NULL_TREE);
1589 /* For COND_EXPR we rearranged the arguments; undo that now. */
1592 convs[2] = convs[1];
1593 convs[1] = convs[0];
1594 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1595 /*c_cast_p=*/false, flags);
1602 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1604 /*access_path=*/NULL_TREE,
1605 /*conversion_path=*/NULL_TREE,
1610 is_complete (tree t)
1612 return COMPLETE_TYPE_P (complete_type (t));
1615 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1618 promoted_arithmetic_type_p (tree type)
1622 In this section, the term promoted integral type is used to refer
1623 to those integral types which are preserved by integral promotion
1624 (including e.g. int and long but excluding e.g. char).
1625 Similarly, the term promoted arithmetic type refers to promoted
1626 integral types plus floating types. */
1627 return ((INTEGRAL_TYPE_P (type)
1628 && same_type_p (type_promotes_to (type), type))
1629 || TREE_CODE (type) == REAL_TYPE);
1632 /* Create any builtin operator overload candidates for the operator in
1633 question given the converted operand types TYPE1 and TYPE2. The other
1634 args are passed through from add_builtin_candidates to
1635 build_builtin_candidate.
1637 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1638 If CODE is requires candidates operands of the same type of the kind
1639 of which TYPE1 and TYPE2 are, we add both candidates
1640 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1643 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1644 enum tree_code code2, tree fnname, tree type1,
1645 tree type2, tree *args, tree *argtypes, int flags)
1649 case POSTINCREMENT_EXPR:
1650 case POSTDECREMENT_EXPR:
1651 args[1] = integer_zero_node;
1652 type2 = integer_type_node;
1661 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1662 and VQ is either volatile or empty, there exist candidate operator
1663 functions of the form
1664 VQ T& operator++(VQ T&);
1665 T operator++(VQ T&, int);
1666 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1667 type other than bool, and VQ is either volatile or empty, there exist
1668 candidate operator functions of the form
1669 VQ T& operator--(VQ T&);
1670 T operator--(VQ T&, int);
1671 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1672 complete object type, and VQ is either volatile or empty, there exist
1673 candidate operator functions of the form
1674 T*VQ& operator++(T*VQ&);
1675 T*VQ& operator--(T*VQ&);
1676 T* operator++(T*VQ&, int);
1677 T* operator--(T*VQ&, int); */
1679 case POSTDECREMENT_EXPR:
1680 case PREDECREMENT_EXPR:
1681 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1683 case POSTINCREMENT_EXPR:
1684 case PREINCREMENT_EXPR:
1685 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1687 type1 = build_reference_type (type1);
1692 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1693 exist candidate operator functions of the form
1697 8 For every function type T, there exist candidate operator functions of
1699 T& operator*(T*); */
1702 if (TREE_CODE (type1) == POINTER_TYPE
1703 && (TYPE_PTROB_P (type1)
1704 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1708 /* 9 For every type T, there exist candidate operator functions of the form
1711 10For every promoted arithmetic type T, there exist candidate operator
1712 functions of the form
1716 case UNARY_PLUS_EXPR: /* unary + */
1717 if (TREE_CODE (type1) == POINTER_TYPE)
1720 if (ARITHMETIC_TYPE_P (type1))
1724 /* 11For every promoted integral type T, there exist candidate operator
1725 functions of the form
1729 if (INTEGRAL_TYPE_P (type1))
1733 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1734 is the same type as C2 or is a derived class of C2, T is a complete
1735 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1736 there exist candidate operator functions of the form
1737 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1738 where CV12 is the union of CV1 and CV2. */
1741 if (TREE_CODE (type1) == POINTER_TYPE
1742 && TYPE_PTR_TO_MEMBER_P (type2))
1744 tree c1 = TREE_TYPE (type1);
1745 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1747 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1748 && (TYPE_PTRMEMFUNC_P (type2)
1749 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1754 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1755 didate operator functions of the form
1760 bool operator<(L, R);
1761 bool operator>(L, R);
1762 bool operator<=(L, R);
1763 bool operator>=(L, R);
1764 bool operator==(L, R);
1765 bool operator!=(L, R);
1766 where LR is the result of the usual arithmetic conversions between
1769 14For every pair of types T and I, where T is a cv-qualified or cv-
1770 unqualified complete object type and I is a promoted integral type,
1771 there exist candidate operator functions of the form
1772 T* operator+(T*, I);
1773 T& operator[](T*, I);
1774 T* operator-(T*, I);
1775 T* operator+(I, T*);
1776 T& operator[](I, T*);
1778 15For every T, where T is a pointer to complete object type, there exist
1779 candidate operator functions of the form112)
1780 ptrdiff_t operator-(T, T);
1782 16For every pointer or enumeration type T, there exist candidate operator
1783 functions of the form
1784 bool operator<(T, T);
1785 bool operator>(T, T);
1786 bool operator<=(T, T);
1787 bool operator>=(T, T);
1788 bool operator==(T, T);
1789 bool operator!=(T, T);
1791 17For every pointer to member type T, there exist candidate operator
1792 functions of the form
1793 bool operator==(T, T);
1794 bool operator!=(T, T); */
1797 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1799 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1801 type2 = ptrdiff_type_node;
1805 case TRUNC_DIV_EXPR:
1806 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1812 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1813 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1815 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1820 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1832 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1834 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1836 if (TREE_CODE (type1) == ENUMERAL_TYPE
1837 && TREE_CODE (type2) == ENUMERAL_TYPE)
1839 if (TYPE_PTR_P (type1)
1840 && null_ptr_cst_p (args[1])
1841 && !uses_template_parms (type1))
1846 if (null_ptr_cst_p (args[0])
1847 && TYPE_PTR_P (type2)
1848 && !uses_template_parms (type2))
1856 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1859 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1861 type1 = ptrdiff_type_node;
1864 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1866 type2 = ptrdiff_type_node;
1871 /* 18For every pair of promoted integral types L and R, there exist candi-
1872 date operator functions of the form
1879 where LR is the result of the usual arithmetic conversions between
1882 case TRUNC_MOD_EXPR:
1888 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1892 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1893 type, VQ is either volatile or empty, and R is a promoted arithmetic
1894 type, there exist candidate operator functions of the form
1895 VQ L& operator=(VQ L&, R);
1896 VQ L& operator*=(VQ L&, R);
1897 VQ L& operator/=(VQ L&, R);
1898 VQ L& operator+=(VQ L&, R);
1899 VQ L& operator-=(VQ L&, R);
1901 20For every pair T, VQ), where T is any type and VQ is either volatile
1902 or empty, there exist candidate operator functions of the form
1903 T*VQ& operator=(T*VQ&, T*);
1905 21For every pair T, VQ), where T is a pointer to member type and VQ is
1906 either volatile or empty, there exist candidate operator functions of
1908 VQ T& operator=(VQ T&, T);
1910 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1911 unqualified complete object type, VQ is either volatile or empty, and
1912 I is a promoted integral type, there exist candidate operator func-
1914 T*VQ& operator+=(T*VQ&, I);
1915 T*VQ& operator-=(T*VQ&, I);
1917 23For every triple L, VQ, R), where L is an integral or enumeration
1918 type, VQ is either volatile or empty, and R is a promoted integral
1919 type, there exist candidate operator functions of the form
1921 VQ L& operator%=(VQ L&, R);
1922 VQ L& operator<<=(VQ L&, R);
1923 VQ L& operator>>=(VQ L&, R);
1924 VQ L& operator&=(VQ L&, R);
1925 VQ L& operator^=(VQ L&, R);
1926 VQ L& operator|=(VQ L&, R); */
1933 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1935 type2 = ptrdiff_type_node;
1939 case TRUNC_DIV_EXPR:
1940 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1944 case TRUNC_MOD_EXPR:
1950 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1955 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1957 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1958 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1959 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1960 || ((TYPE_PTRMEMFUNC_P (type1)
1961 || TREE_CODE (type1) == POINTER_TYPE)
1962 && null_ptr_cst_p (args[1])))
1972 type1 = build_reference_type (type1);
1978 For every pair of promoted arithmetic types L and R, there
1979 exist candidate operator functions of the form
1981 LR operator?(bool, L, R);
1983 where LR is the result of the usual arithmetic conversions
1984 between types L and R.
1986 For every type T, where T is a pointer or pointer-to-member
1987 type, there exist candidate operator functions of the form T
1988 operator?(bool, T, T); */
1990 if (promoted_arithmetic_type_p (type1)
1991 && promoted_arithmetic_type_p (type2))
1995 /* Otherwise, the types should be pointers. */
1996 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1997 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2000 /* We don't check that the two types are the same; the logic
2001 below will actually create two candidates; one in which both
2002 parameter types are TYPE1, and one in which both parameter
2010 /* If we're dealing with two pointer types or two enumeral types,
2011 we need candidates for both of them. */
2012 if (type2 && !same_type_p (type1, type2)
2013 && TREE_CODE (type1) == TREE_CODE (type2)
2014 && (TREE_CODE (type1) == REFERENCE_TYPE
2015 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2016 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2017 || TYPE_PTRMEMFUNC_P (type1)
2018 || IS_AGGR_TYPE (type1)
2019 || TREE_CODE (type1) == ENUMERAL_TYPE))
2021 build_builtin_candidate
2022 (candidates, fnname, type1, type1, args, argtypes, flags);
2023 build_builtin_candidate
2024 (candidates, fnname, type2, type2, args, argtypes, flags);
2028 build_builtin_candidate
2029 (candidates, fnname, type1, type2, args, argtypes, flags);
2033 type_decays_to (tree type)
2035 if (TREE_CODE (type) == ARRAY_TYPE)
2036 return build_pointer_type (TREE_TYPE (type));
2037 if (TREE_CODE (type) == FUNCTION_TYPE)
2038 return build_pointer_type (type);
2042 /* There are three conditions of builtin candidates:
2044 1) bool-taking candidates. These are the same regardless of the input.
2045 2) pointer-pair taking candidates. These are generated for each type
2046 one of the input types converts to.
2047 3) arithmetic candidates. According to the standard, we should generate
2048 all of these, but I'm trying not to...
2050 Here we generate a superset of the possible candidates for this particular
2051 case. That is a subset of the full set the standard defines, plus some
2052 other cases which the standard disallows. add_builtin_candidate will
2053 filter out the invalid set. */
2056 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2057 enum tree_code code2, tree fnname, tree *args,
2062 tree type, argtypes[3];
2063 /* TYPES[i] is the set of possible builtin-operator parameter types
2064 we will consider for the Ith argument. These are represented as
2065 a TREE_LIST; the TREE_VALUE of each node is the potential
2069 for (i = 0; i < 3; ++i)
2072 argtypes[i] = lvalue_type (args[i]);
2074 argtypes[i] = NULL_TREE;
2079 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2080 and VQ is either volatile or empty, there exist candidate operator
2081 functions of the form
2082 VQ T& operator++(VQ T&); */
2084 case POSTINCREMENT_EXPR:
2085 case PREINCREMENT_EXPR:
2086 case POSTDECREMENT_EXPR:
2087 case PREDECREMENT_EXPR:
2092 /* 24There also exist candidate operator functions of the form
2093 bool operator!(bool);
2094 bool operator&&(bool, bool);
2095 bool operator||(bool, bool); */
2097 case TRUTH_NOT_EXPR:
2098 build_builtin_candidate
2099 (candidates, fnname, boolean_type_node,
2100 NULL_TREE, args, argtypes, flags);
2103 case TRUTH_ORIF_EXPR:
2104 case TRUTH_ANDIF_EXPR:
2105 build_builtin_candidate
2106 (candidates, fnname, boolean_type_node,
2107 boolean_type_node, args, argtypes, flags);
2129 types[0] = types[1] = NULL_TREE;
2131 for (i = 0; i < 2; ++i)
2135 else if (IS_AGGR_TYPE (argtypes[i]))
2139 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2142 convs = lookup_conversions (argtypes[i]);
2144 if (code == COND_EXPR)
2146 if (real_lvalue_p (args[i]))
2147 types[i] = tree_cons
2148 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2150 types[i] = tree_cons
2151 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2157 for (; convs; convs = TREE_CHAIN (convs))
2159 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2162 && (TREE_CODE (type) != REFERENCE_TYPE
2163 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2166 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2167 types[i] = tree_cons (NULL_TREE, type, types[i]);
2169 type = non_reference (type);
2170 if (i != 0 || ! ref1)
2172 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2173 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2174 types[i] = tree_cons (NULL_TREE, type, types[i]);
2175 if (INTEGRAL_TYPE_P (type))
2176 type = type_promotes_to (type);
2179 if (! value_member (type, types[i]))
2180 types[i] = tree_cons (NULL_TREE, type, types[i]);
2185 if (code == COND_EXPR && real_lvalue_p (args[i]))
2186 types[i] = tree_cons
2187 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2188 type = non_reference (argtypes[i]);
2189 if (i != 0 || ! ref1)
2191 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2192 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2193 types[i] = tree_cons (NULL_TREE, type, types[i]);
2194 if (INTEGRAL_TYPE_P (type))
2195 type = type_promotes_to (type);
2197 types[i] = tree_cons (NULL_TREE, type, types[i]);
2201 /* Run through the possible parameter types of both arguments,
2202 creating candidates with those parameter types. */
2203 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2206 for (type = types[1]; type; type = TREE_CHAIN (type))
2207 add_builtin_candidate
2208 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2209 TREE_VALUE (type), args, argtypes, flags);
2211 add_builtin_candidate
2212 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2213 NULL_TREE, args, argtypes, flags);
2218 /* If TMPL can be successfully instantiated as indicated by
2219 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2221 TMPL is the template. EXPLICIT_TARGS are any explicit template
2222 arguments. ARGLIST is the arguments provided at the call-site.
2223 The RETURN_TYPE is the desired type for conversion operators. If
2224 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2225 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2226 add_conv_candidate. */
2228 static struct z_candidate*
2229 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2230 tree ctype, tree explicit_targs, tree arglist,
2231 tree return_type, tree access_path,
2232 tree conversion_path, int flags, tree obj,
2233 unification_kind_t strict)
2235 int ntparms = DECL_NTPARMS (tmpl);
2236 tree targs = make_tree_vec (ntparms);
2237 tree args_without_in_chrg = arglist;
2238 struct z_candidate *cand;
2242 /* We don't do deduction on the in-charge parameter, the VTT
2243 parameter or 'this'. */
2244 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2245 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2247 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2248 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2249 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2250 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2252 i = fn_type_unification (tmpl, explicit_targs, targs,
2253 args_without_in_chrg,
2254 return_type, strict, flags);
2259 fn = instantiate_template (tmpl, targs, tf_none);
2260 if (fn == error_mark_node)
2265 A member function template is never instantiated to perform the
2266 copy of a class object to an object of its class type.
2268 It's a little unclear what this means; the standard explicitly
2269 does allow a template to be used to copy a class. For example,
2274 template <class T> A(const T&);
2277 void g () { A a (f ()); }
2279 the member template will be used to make the copy. The section
2280 quoted above appears in the paragraph that forbids constructors
2281 whose only parameter is (a possibly cv-qualified variant of) the
2282 class type, and a logical interpretation is that the intent was
2283 to forbid the instantiation of member templates which would then
2285 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2287 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2288 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2293 if (obj != NULL_TREE)
2294 /* Aha, this is a conversion function. */
2295 cand = add_conv_candidate (candidates, fn, obj, access_path,
2296 conversion_path, arglist);
2298 cand = add_function_candidate (candidates, fn, ctype,
2299 arglist, access_path,
2300 conversion_path, flags);
2301 if (DECL_TI_TEMPLATE (fn) != tmpl)
2302 /* This situation can occur if a member template of a template
2303 class is specialized. Then, instantiate_template might return
2304 an instantiation of the specialization, in which case the
2305 DECL_TI_TEMPLATE field will point at the original
2306 specialization. For example:
2308 template <class T> struct S { template <class U> void f(U);
2309 template <> void f(int) {}; };
2313 Here, TMPL will be template <class U> S<double>::f(U).
2314 And, instantiate template will give us the specialization
2315 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2316 for this will point at template <class T> template <> S<T>::f(int),
2317 so that we can find the definition. For the purposes of
2318 overload resolution, however, we want the original TMPL. */
2319 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2321 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2327 static struct z_candidate *
2328 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2329 tree explicit_targs, tree arglist, tree return_type,
2330 tree access_path, tree conversion_path, int flags,
2331 unification_kind_t strict)
2334 add_template_candidate_real (candidates, tmpl, ctype,
2335 explicit_targs, arglist, return_type,
2336 access_path, conversion_path,
2337 flags, NULL_TREE, strict);
2341 static struct z_candidate *
2342 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2343 tree obj, tree arglist, tree return_type,
2344 tree access_path, tree conversion_path)
2347 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2348 arglist, return_type, access_path,
2349 conversion_path, 0, obj, DEDUCE_CONV);
2352 /* The CANDS are the set of candidates that were considered for
2353 overload resolution. Return the set of viable candidates. If none
2354 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2355 is true if a candidate should be considered viable only if it is
2358 static struct z_candidate*
2359 splice_viable (struct z_candidate *cands,
2363 struct z_candidate *viable;
2364 struct z_candidate **last_viable;
2365 struct z_candidate **cand;
2368 last_viable = &viable;
2369 *any_viable_p = false;
2374 struct z_candidate *c = *cand;
2375 if (strict_p ? c->viable == 1 : c->viable)
2380 last_viable = &c->next;
2381 *any_viable_p = true;
2387 return viable ? viable : cands;
2391 any_strictly_viable (struct z_candidate *cands)
2393 for (; cands; cands = cands->next)
2394 if (cands->viable == 1)
2399 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2400 words, it is about to become the "this" pointer for a member
2401 function call. Take the address of the object. */
2404 build_this (tree obj)
2406 /* In a template, we are only concerned about the type of the
2407 expression, so we can take a shortcut. */
2408 if (processing_template_decl)
2409 return build_address (obj);
2411 return build_unary_op (ADDR_EXPR, obj, 0);
2414 /* Returns true iff functions are equivalent. Equivalent functions are
2415 not '==' only if one is a function-local extern function or if
2416 both are extern "C". */
2419 equal_functions (tree fn1, tree fn2)
2421 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2422 || DECL_EXTERN_C_FUNCTION_P (fn1))
2423 return decls_match (fn1, fn2);
2427 /* Print information about one overload candidate CANDIDATE. MSGSTR
2428 is the text to print before the candidate itself.
2430 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2431 to have been run through gettext by the caller. This wart makes
2432 life simpler in print_z_candidates and for the translators. */
2435 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2437 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2439 if (candidate->num_convs == 3)
2440 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2441 candidate->convs[0]->type,
2442 candidate->convs[1]->type,
2443 candidate->convs[2]->type);
2444 else if (candidate->num_convs == 2)
2445 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2446 candidate->convs[0]->type,
2447 candidate->convs[1]->type);
2449 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2450 candidate->convs[0]->type);
2452 else if (TYPE_P (candidate->fn))
2453 inform ("%s %T <conversion>", msgstr, candidate->fn);
2454 else if (candidate->viable == -1)
2455 inform ("%s %+#D <near match>", msgstr, candidate->fn);
2457 inform ("%s %+#D", msgstr, candidate->fn);
2461 print_z_candidates (struct z_candidate *candidates)
2464 struct z_candidate *cand1;
2465 struct z_candidate **cand2;
2467 /* There may be duplicates in the set of candidates. We put off
2468 checking this condition as long as possible, since we have no way
2469 to eliminate duplicates from a set of functions in less than n^2
2470 time. Now we are about to emit an error message, so it is more
2471 permissible to go slowly. */
2472 for (cand1 = candidates; cand1; cand1 = cand1->next)
2474 tree fn = cand1->fn;
2475 /* Skip builtin candidates and conversion functions. */
2476 if (TREE_CODE (fn) != FUNCTION_DECL)
2478 cand2 = &cand1->next;
2481 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2482 && equal_functions (fn, (*cand2)->fn))
2483 *cand2 = (*cand2)->next;
2485 cand2 = &(*cand2)->next;
2492 str = _("candidates are:");
2493 print_z_candidate (str, candidates);
2494 if (candidates->next)
2496 /* Indent successive candidates by the width of the translation
2497 of the above string. */
2498 size_t len = gcc_gettext_width (str) + 1;
2499 char *spaces = (char *) alloca (len);
2500 memset (spaces, ' ', len-1);
2501 spaces[len - 1] = '\0';
2503 candidates = candidates->next;
2506 print_z_candidate (spaces, candidates);
2507 candidates = candidates->next;
2513 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2514 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2515 the result of the conversion function to convert it to the final
2516 desired type. Merge the two sequences into a single sequence,
2517 and return the merged sequence. */
2520 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2524 gcc_assert (user_seq->kind == ck_user);
2526 /* Find the end of the second conversion sequence. */
2528 while ((*t)->kind != ck_identity)
2529 t = &((*t)->u.next);
2531 /* Replace the identity conversion with the user conversion
2535 /* The entire sequence is a user-conversion sequence. */
2536 std_seq->user_conv_p = true;
2541 /* Returns the best overload candidate to perform the requested
2542 conversion. This function is used for three the overloading situations
2543 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2544 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2545 per [dcl.init.ref], so we ignore temporary bindings. */
2547 static struct z_candidate *
2548 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2550 struct z_candidate *candidates, *cand;
2551 tree fromtype = TREE_TYPE (expr);
2552 tree ctors = NULL_TREE;
2553 tree conv_fns = NULL_TREE;
2554 conversion *conv = NULL;
2555 tree args = NULL_TREE;
2558 /* We represent conversion within a hierarchy using RVALUE_CONV and
2559 BASE_CONV, as specified by [over.best.ics]; these become plain
2560 constructor calls, as specified in [dcl.init]. */
2561 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2562 || !DERIVED_FROM_P (totype, fromtype));
2564 if (IS_AGGR_TYPE (totype))
2565 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2567 if (IS_AGGR_TYPE (fromtype))
2568 conv_fns = lookup_conversions (fromtype);
2571 flags |= LOOKUP_NO_CONVERSION;
2577 ctors = BASELINK_FUNCTIONS (ctors);
2579 t = build_int_cst (build_pointer_type (totype), 0);
2580 args = build_tree_list (NULL_TREE, expr);
2581 /* We should never try to call the abstract or base constructor
2583 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2584 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2585 args = tree_cons (NULL_TREE, t, args);
2587 for (; ctors; ctors = OVL_NEXT (ctors))
2589 tree ctor = OVL_CURRENT (ctors);
2590 if (DECL_NONCONVERTING_P (ctor))
2593 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2594 cand = add_template_candidate (&candidates, ctor, totype,
2595 NULL_TREE, args, NULL_TREE,
2596 TYPE_BINFO (totype),
2597 TYPE_BINFO (totype),
2601 cand = add_function_candidate (&candidates, ctor, totype,
2602 args, TYPE_BINFO (totype),
2603 TYPE_BINFO (totype),
2607 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2611 args = build_tree_list (NULL_TREE, build_this (expr));
2613 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2616 tree conversion_path = TREE_PURPOSE (conv_fns);
2617 int convflags = LOOKUP_NO_CONVERSION;
2619 /* If we are called to convert to a reference type, we are trying to
2620 find an lvalue binding, so don't even consider temporaries. If
2621 we don't find an lvalue binding, the caller will try again to
2622 look for a temporary binding. */
2623 if (TREE_CODE (totype) == REFERENCE_TYPE)
2624 convflags |= LOOKUP_NO_TEMP_BIND;
2626 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2628 tree fn = OVL_CURRENT (fns);
2630 /* [over.match.funcs] For conversion functions, the function
2631 is considered to be a member of the class of the implicit
2632 object argument for the purpose of defining the type of
2633 the implicit object parameter.
2635 So we pass fromtype as CTYPE to add_*_candidate. */
2637 if (TREE_CODE (fn) == TEMPLATE_DECL)
2638 cand = add_template_candidate (&candidates, fn, fromtype,
2641 TYPE_BINFO (fromtype),
2646 cand = add_function_candidate (&candidates, fn, fromtype,
2648 TYPE_BINFO (fromtype),
2655 = implicit_conversion (totype,
2656 TREE_TYPE (TREE_TYPE (cand->fn)),
2658 /*c_cast_p=*/false, convflags);
2660 cand->second_conv = ics;
2664 else if (candidates->viable == 1 && ics->bad_p)
2670 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2674 cand = tourney (candidates);
2677 if (flags & LOOKUP_COMPLAIN)
2679 error ("conversion from %qT to %qT is ambiguous",
2681 print_z_candidates (candidates);
2684 cand = candidates; /* any one will do */
2685 cand->second_conv = build_ambiguous_conv (totype, expr);
2686 cand->second_conv->user_conv_p = true;
2687 if (!any_strictly_viable (candidates))
2688 cand->second_conv->bad_p = true;
2689 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2690 ambiguous conversion is no worse than another user-defined
2696 /* Build the user conversion sequence. */
2699 (DECL_CONSTRUCTOR_P (cand->fn)
2700 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2701 build_identity_conv (TREE_TYPE (expr), expr));
2704 /* Combine it with the second conversion sequence. */
2705 cand->second_conv = merge_conversion_sequences (conv,
2708 if (cand->viable == -1)
2709 cand->second_conv->bad_p = true;
2715 build_user_type_conversion (tree totype, tree expr, int flags)
2717 struct z_candidate *cand
2718 = build_user_type_conversion_1 (totype, expr, flags);
2722 if (cand->second_conv->kind == ck_ambig)
2723 return error_mark_node;
2724 expr = convert_like (cand->second_conv, expr);
2725 return convert_from_reference (expr);
2730 /* Do any initial processing on the arguments to a function call. */
2733 resolve_args (tree args)
2736 for (t = args; t; t = TREE_CHAIN (t))
2738 tree arg = TREE_VALUE (t);
2740 if (error_operand_p (arg))
2741 return error_mark_node;
2742 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2744 error ("invalid use of void expression");
2745 return error_mark_node;
2747 else if (invalid_nonstatic_memfn_p (arg))
2748 return error_mark_node;
2753 /* Perform overload resolution on FN, which is called with the ARGS.
2755 Return the candidate function selected by overload resolution, or
2756 NULL if the event that overload resolution failed. In the case
2757 that overload resolution fails, *CANDIDATES will be the set of
2758 candidates considered, and ANY_VIABLE_P will be set to true or
2759 false to indicate whether or not any of the candidates were
2762 The ARGS should already have gone through RESOLVE_ARGS before this
2763 function is called. */
2765 static struct z_candidate *
2766 perform_overload_resolution (tree fn,
2768 struct z_candidate **candidates,
2771 struct z_candidate *cand;
2772 tree explicit_targs = NULL_TREE;
2773 int template_only = 0;
2776 *any_viable_p = true;
2778 /* Check FN and ARGS. */
2779 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2780 || TREE_CODE (fn) == TEMPLATE_DECL
2781 || TREE_CODE (fn) == OVERLOAD
2782 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2783 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2785 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2787 explicit_targs = TREE_OPERAND (fn, 1);
2788 fn = TREE_OPERAND (fn, 0);
2792 /* Add the various candidate functions. */
2793 add_candidates (fn, args, explicit_targs, template_only,
2794 /*conversion_path=*/NULL_TREE,
2795 /*access_path=*/NULL_TREE,
2799 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2803 cand = tourney (*candidates);
2807 /* Return an expression for a call to FN (a namespace-scope function,
2808 or a static member function) with the ARGS. */
2811 build_new_function_call (tree fn, tree args, bool koenig_p)
2813 struct z_candidate *candidates, *cand;
2818 args = resolve_args (args);
2819 if (args == error_mark_node)
2820 return error_mark_node;
2822 /* If this function was found without using argument dependent
2823 lookup, then we want to ignore any undeclared friend
2829 fn = remove_hidden_names (fn);
2832 error ("no matching function for call to %<%D(%A)%>",
2833 DECL_NAME (OVL_CURRENT (orig_fn)), args);
2834 return error_mark_node;
2838 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2839 p = conversion_obstack_alloc (0);
2841 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2845 if (!any_viable_p && candidates && ! candidates->next)
2846 return build_function_call (candidates->fn, args);
2847 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2848 fn = TREE_OPERAND (fn, 0);
2850 error ("no matching function for call to %<%D(%A)%>",
2851 DECL_NAME (OVL_CURRENT (fn)), args);
2853 error ("call of overloaded %<%D(%A)%> is ambiguous",
2854 DECL_NAME (OVL_CURRENT (fn)), args);
2856 print_z_candidates (candidates);
2857 result = error_mark_node;
2860 result = build_over_call (cand, LOOKUP_NORMAL);
2862 /* Free all the conversions we allocated. */
2863 obstack_free (&conversion_obstack, p);
2868 /* Build a call to a global operator new. FNNAME is the name of the
2869 operator (either "operator new" or "operator new[]") and ARGS are
2870 the arguments provided. *SIZE points to the total number of bytes
2871 required by the allocation, and is updated if that is changed here.
2872 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2873 function determines that no cookie should be used, after all,
2874 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2875 set, upon return, to the allocation function called. */
2878 build_operator_new_call (tree fnname, tree args,
2879 tree *size, tree *cookie_size,
2883 struct z_candidate *candidates;
2884 struct z_candidate *cand;
2889 args = tree_cons (NULL_TREE, *size, args);
2890 args = resolve_args (args);
2891 if (args == error_mark_node)
2898 If this lookup fails to find the name, or if the allocated type
2899 is not a class type, the allocation function's name is looked
2900 up in the global scope.
2902 we disregard block-scope declarations of "operator new". */
2903 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2905 /* Figure out what function is being called. */
2906 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2908 /* If no suitable function could be found, issue an error message
2913 error ("no matching function for call to %<%D(%A)%>",
2914 DECL_NAME (OVL_CURRENT (fns)), args);
2916 error ("call of overloaded %<%D(%A)%> is ambiguous",
2917 DECL_NAME (OVL_CURRENT (fns)), args);
2919 print_z_candidates (candidates);
2920 return error_mark_node;
2923 /* If a cookie is required, add some extra space. Whether
2924 or not a cookie is required cannot be determined until
2925 after we know which function was called. */
2928 bool use_cookie = true;
2929 if (!abi_version_at_least (2))
2931 tree placement = TREE_CHAIN (args);
2932 /* In G++ 3.2, the check was implemented incorrectly; it
2933 looked at the placement expression, rather than the
2934 type of the function. */
2935 if (placement && !TREE_CHAIN (placement)
2936 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2944 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2945 /* Skip the size_t parameter. */
2946 arg_types = TREE_CHAIN (arg_types);
2947 /* Check the remaining parameters (if any). */
2949 && TREE_CHAIN (arg_types) == void_list_node
2950 && same_type_p (TREE_VALUE (arg_types),
2954 /* If we need a cookie, adjust the number of bytes allocated. */
2957 /* Update the total size. */
2958 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2959 /* Update the argument list to reflect the adjusted size. */
2960 TREE_VALUE (args) = *size;
2963 *cookie_size = NULL_TREE;
2966 /* Tell our caller which function we decided to call. */
2970 /* Build the CALL_EXPR. */
2971 return build_over_call (cand, LOOKUP_NORMAL);
2975 build_object_call (tree obj, tree args)
2977 struct z_candidate *candidates = 0, *cand;
2978 tree fns, convs, mem_args = NULL_TREE;
2979 tree type = TREE_TYPE (obj);
2981 tree result = NULL_TREE;
2984 if (TYPE_PTRMEMFUNC_P (type))
2986 /* It's no good looking for an overloaded operator() on a
2987 pointer-to-member-function. */
2988 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2989 return error_mark_node;
2992 if (TYPE_BINFO (type))
2994 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2995 if (fns == error_mark_node)
2996 return error_mark_node;
3001 args = resolve_args (args);
3003 if (args == error_mark_node)
3004 return error_mark_node;
3006 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3007 p = conversion_obstack_alloc (0);
3011 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
3012 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
3014 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
3016 tree fn = OVL_CURRENT (fns);
3017 if (TREE_CODE (fn) == TEMPLATE_DECL)
3018 add_template_candidate (&candidates, fn, base, NULL_TREE,
3019 mem_args, NULL_TREE,
3022 LOOKUP_NORMAL, DEDUCE_CALL);
3024 add_function_candidate
3025 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3026 TYPE_BINFO (type), LOOKUP_NORMAL);
3030 convs = lookup_conversions (type);
3032 for (; convs; convs = TREE_CHAIN (convs))
3034 tree fns = TREE_VALUE (convs);
3035 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3037 if ((TREE_CODE (totype) == POINTER_TYPE
3038 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3039 || (TREE_CODE (totype) == REFERENCE_TYPE
3040 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3041 || (TREE_CODE (totype) == REFERENCE_TYPE
3042 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3043 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3044 for (; fns; fns = OVL_NEXT (fns))
3046 tree fn = OVL_CURRENT (fns);
3047 if (TREE_CODE (fn) == TEMPLATE_DECL)
3048 add_template_conv_candidate
3049 (&candidates, fn, obj, args, totype,
3050 /*access_path=*/NULL_TREE,
3051 /*conversion_path=*/NULL_TREE);
3053 add_conv_candidate (&candidates, fn, obj, args,
3054 /*conversion_path=*/NULL_TREE,
3055 /*access_path=*/NULL_TREE);
3059 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3062 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3063 print_z_candidates (candidates);
3064 result = error_mark_node;
3068 cand = tourney (candidates);
3071 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
3072 print_z_candidates (candidates);
3073 result = error_mark_node;
3075 /* Since cand->fn will be a type, not a function, for a conversion
3076 function, we must be careful not to unconditionally look at
3078 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3079 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3080 result = build_over_call (cand, LOOKUP_NORMAL);
3083 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
3084 obj = convert_from_reference (obj);
3085 result = build_function_call (obj, args);
3089 /* Free all the conversions we allocated. */
3090 obstack_free (&conversion_obstack, p);
3096 op_error (enum tree_code code, enum tree_code code2,
3097 tree arg1, tree arg2, tree arg3, const char *problem)
3101 if (code == MODIFY_EXPR)
3102 opname = assignment_operator_name_info[code2].name;
3104 opname = operator_name_info[code].name;
3109 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3110 problem, arg1, arg2, arg3);
3113 case POSTINCREMENT_EXPR:
3114 case POSTDECREMENT_EXPR:
3115 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3119 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3124 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3129 error ("%s for %<operator%s%> in %<%E %s %E%>",
3130 problem, opname, arg1, opname, arg2);
3132 error ("%s for %<operator%s%> in %<%s%E%>",
3133 problem, opname, opname, arg1);
3138 /* Return the implicit conversion sequence that could be used to
3139 convert E1 to E2 in [expr.cond]. */
3142 conditional_conversion (tree e1, tree e2)
3144 tree t1 = non_reference (TREE_TYPE (e1));
3145 tree t2 = non_reference (TREE_TYPE (e2));
3151 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3152 implicitly converted (clause _conv_) to the type "reference to
3153 T2", subject to the constraint that in the conversion the
3154 reference must bind directly (_dcl.init.ref_) to E1. */
3155 if (real_lvalue_p (e2))
3157 conv = implicit_conversion (build_reference_type (t2),
3161 LOOKUP_NO_TEMP_BIND);
3168 If E1 and E2 have class type, and the underlying class types are
3169 the same or one is a base class of the other: E1 can be converted
3170 to match E2 if the class of T2 is the same type as, or a base
3171 class of, the class of T1, and the cv-qualification of T2 is the
3172 same cv-qualification as, or a greater cv-qualification than, the
3173 cv-qualification of T1. If the conversion is applied, E1 is
3174 changed to an rvalue of type T2 that still refers to the original
3175 source class object (or the appropriate subobject thereof). */
3176 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3177 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3179 if (good_base && at_least_as_qualified_p (t2, t1))
3181 conv = build_identity_conv (t1, e1);
3182 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3183 TYPE_MAIN_VARIANT (t2)))
3184 conv = build_conv (ck_base, t2, conv);
3186 conv = build_conv (ck_rvalue, t2, conv);
3195 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3196 converted to the type that expression E2 would have if E2 were
3197 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3198 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3202 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3203 arguments to the conditional expression. */
3206 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3210 tree result = NULL_TREE;
3211 tree result_type = NULL_TREE;
3212 bool lvalue_p = true;
3213 struct z_candidate *candidates = 0;
3214 struct z_candidate *cand;
3217 /* As a G++ extension, the second argument to the conditional can be
3218 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3219 c'.) If the second operand is omitted, make sure it is
3220 calculated only once. */
3224 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3226 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3227 if (real_lvalue_p (arg1))
3228 arg2 = arg1 = stabilize_reference (arg1);
3230 arg2 = arg1 = save_expr (arg1);
3235 The first expr ession is implicitly converted to bool (clause
3237 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3239 /* If something has already gone wrong, just pass that fact up the
3241 if (error_operand_p (arg1)
3242 || error_operand_p (arg2)
3243 || error_operand_p (arg3))
3244 return error_mark_node;
3248 If either the second or the third operand has type (possibly
3249 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3250 array-to-pointer (_conv.array_), and function-to-pointer
3251 (_conv.func_) standard conversions are performed on the second
3252 and third operands. */
3253 arg2_type = unlowered_expr_type (arg2);
3254 arg3_type = unlowered_expr_type (arg3);
3255 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3257 /* Do the conversions. We don't these for `void' type arguments
3258 since it can't have any effect and since decay_conversion
3259 does not handle that case gracefully. */
3260 if (!VOID_TYPE_P (arg2_type))
3261 arg2 = decay_conversion (arg2);
3262 if (!VOID_TYPE_P (arg3_type))
3263 arg3 = decay_conversion (arg3);
3264 arg2_type = TREE_TYPE (arg2);
3265 arg3_type = TREE_TYPE (arg3);
3269 One of the following shall hold:
3271 --The second or the third operand (but not both) is a
3272 throw-expression (_except.throw_); the result is of the
3273 type of the other and is an rvalue.
3275 --Both the second and the third operands have type void; the
3276 result is of type void and is an rvalue.
3278 We must avoid calling force_rvalue for expressions of type
3279 "void" because it will complain that their value is being
3281 if (TREE_CODE (arg2) == THROW_EXPR
3282 && TREE_CODE (arg3) != THROW_EXPR)
3284 if (!VOID_TYPE_P (arg3_type))
3285 arg3 = force_rvalue (arg3);
3286 arg3_type = TREE_TYPE (arg3);
3287 result_type = arg3_type;
3289 else if (TREE_CODE (arg2) != THROW_EXPR
3290 && TREE_CODE (arg3) == THROW_EXPR)
3292 if (!VOID_TYPE_P (arg2_type))
3293 arg2 = force_rvalue (arg2);
3294 arg2_type = TREE_TYPE (arg2);
3295 result_type = arg2_type;
3297 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3298 result_type = void_type_node;
3301 if (VOID_TYPE_P (arg2_type))
3302 error ("second operand to the conditional operator "
3303 "is of type %<void%>, "
3304 "but the third operand is neither a throw-expression "
3305 "nor of type %<void%>");
3307 error ("third operand to the conditional operator "
3308 "is of type %<void%>, "
3309 "but the second operand is neither a throw-expression "
3310 "nor of type %<void%>");
3311 return error_mark_node;
3315 goto valid_operands;
3319 Otherwise, if the second and third operand have different types,
3320 and either has (possibly cv-qualified) class type, an attempt is
3321 made to convert each of those operands to the type of the other. */
3322 else if (!same_type_p (arg2_type, arg3_type)
3323 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3328 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3329 p = conversion_obstack_alloc (0);
3331 conv2 = conditional_conversion (arg2, arg3);
3332 conv3 = conditional_conversion (arg3, arg2);
3336 If both can be converted, or one can be converted but the
3337 conversion is ambiguous, the program is ill-formed. If
3338 neither can be converted, the operands are left unchanged and
3339 further checking is performed as described below. If exactly
3340 one conversion is possible, that conversion is applied to the
3341 chosen operand and the converted operand is used in place of
3342 the original operand for the remainder of this section. */
3343 if ((conv2 && !conv2->bad_p
3344 && conv3 && !conv3->bad_p)
3345 || (conv2 && conv2->kind == ck_ambig)
3346 || (conv3 && conv3->kind == ck_ambig))
3348 error ("operands to ?: have different types %qT and %qT",
3349 arg2_type, arg3_type);
3350 result = error_mark_node;
3352 else if (conv2 && (!conv2->bad_p || !conv3))
3354 arg2 = convert_like (conv2, arg2);
3355 arg2 = convert_from_reference (arg2);
3356 arg2_type = TREE_TYPE (arg2);
3357 /* Even if CONV2 is a valid conversion, the result of the
3358 conversion may be invalid. For example, if ARG3 has type
3359 "volatile X", and X does not have a copy constructor
3360 accepting a "volatile X&", then even if ARG2 can be
3361 converted to X, the conversion will fail. */
3362 if (error_operand_p (arg2))
3363 result = error_mark_node;
3365 else if (conv3 && (!conv3->bad_p || !conv2))
3367 arg3 = convert_like (conv3, arg3);
3368 arg3 = convert_from_reference (arg3);
3369 arg3_type = TREE_TYPE (arg3);
3370 if (error_operand_p (arg3))
3371 result = error_mark_node;
3374 /* Free all the conversions we allocated. */
3375 obstack_free (&conversion_obstack, p);
3380 /* If, after the conversion, both operands have class type,
3381 treat the cv-qualification of both operands as if it were the
3382 union of the cv-qualification of the operands.
3384 The standard is not clear about what to do in this
3385 circumstance. For example, if the first operand has type
3386 "const X" and the second operand has a user-defined
3387 conversion to "volatile X", what is the type of the second
3388 operand after this step? Making it be "const X" (matching
3389 the first operand) seems wrong, as that discards the
3390 qualification without actually performing a copy. Leaving it
3391 as "volatile X" seems wrong as that will result in the
3392 conditional expression failing altogether, even though,
3393 according to this step, the one operand could be converted to
3394 the type of the other. */
3395 if ((conv2 || conv3)
3396 && CLASS_TYPE_P (arg2_type)
3397 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3398 arg2_type = arg3_type =
3399 cp_build_qualified_type (arg2_type,
3400 TYPE_QUALS (arg2_type)
3401 | TYPE_QUALS (arg3_type));
3406 If the second and third operands are lvalues and have the same
3407 type, the result is of that type and is an lvalue. */
3408 if (real_lvalue_p (arg2)
3409 && real_lvalue_p (arg3)
3410 && same_type_p (arg2_type, arg3_type))
3412 result_type = arg2_type;
3413 goto valid_operands;
3418 Otherwise, the result is an rvalue. If the second and third
3419 operand do not have the same type, and either has (possibly
3420 cv-qualified) class type, overload resolution is used to
3421 determine the conversions (if any) to be applied to the operands
3422 (_over.match.oper_, _over.built_). */
3424 if (!same_type_p (arg2_type, arg3_type)
3425 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3431 /* Rearrange the arguments so that add_builtin_candidate only has
3432 to know about two args. In build_builtin_candidates, the
3433 arguments are unscrambled. */
3437 add_builtin_candidates (&candidates,
3440 ansi_opname (COND_EXPR),
3446 If the overload resolution fails, the program is
3448 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3451 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3452 print_z_candidates (candidates);
3453 return error_mark_node;
3455 cand = tourney (candidates);
3458 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3459 print_z_candidates (candidates);
3460 return error_mark_node;
3465 Otherwise, the conversions thus determined are applied, and
3466 the converted operands are used in place of the original
3467 operands for the remainder of this section. */
3468 conv = cand->convs[0];
3469 arg1 = convert_like (conv, arg1);
3470 conv = cand->convs[1];
3471 arg2 = convert_like (conv, arg2);
3472 conv = cand->convs[2];
3473 arg3 = convert_like (conv, arg3);
3478 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3479 and function-to-pointer (_conv.func_) standard conversions are
3480 performed on the second and third operands.
3482 We need to force the lvalue-to-rvalue conversion here for class types,
3483 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3484 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3487 arg2 = force_rvalue (arg2);
3488 if (!CLASS_TYPE_P (arg2_type))
3489 arg2_type = TREE_TYPE (arg2);
3491 arg3 = force_rvalue (arg3);
3492 if (!CLASS_TYPE_P (arg2_type))
3493 arg3_type = TREE_TYPE (arg3);
3495 if (arg2 == error_mark_node || arg3 == error_mark_node)
3496 return error_mark_node;
3500 After those conversions, one of the following shall hold:
3502 --The second and third operands have the same type; the result is of
3504 if (same_type_p (arg2_type, arg3_type))
3505 result_type = arg2_type;
3508 --The second and third operands have arithmetic or enumeration
3509 type; the usual arithmetic conversions are performed to bring
3510 them to a common type, and the result is of that type. */
3511 else if ((ARITHMETIC_TYPE_P (arg2_type)
3512 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3513 && (ARITHMETIC_TYPE_P (arg3_type)
3514 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3516 /* In this case, there is always a common type. */
3517 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3520 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3521 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3522 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3523 arg2_type, arg3_type);
3524 else if (extra_warnings
3525 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3526 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3527 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3528 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3529 warning (0, "enumeral and non-enumeral type in conditional expression");
3531 arg2 = perform_implicit_conversion (result_type, arg2);
3532 arg3 = perform_implicit_conversion (result_type, arg3);
3536 --The second and third operands have pointer type, or one has
3537 pointer type and the other is a null pointer constant; pointer
3538 conversions (_conv.ptr_) and qualification conversions
3539 (_conv.qual_) are performed to bring them to their composite
3540 pointer type (_expr.rel_). The result is of the composite
3543 --The second and third operands have pointer to member type, or
3544 one has pointer to member type and the other is a null pointer
3545 constant; pointer to member conversions (_conv.mem_) and
3546 qualification conversions (_conv.qual_) are performed to bring
3547 them to a common type, whose cv-qualification shall match the
3548 cv-qualification of either the second or the third operand.
3549 The result is of the common type. */
3550 else if ((null_ptr_cst_p (arg2)
3551 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3552 || (null_ptr_cst_p (arg3)
3553 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3554 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3555 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3556 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3558 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3559 arg3, "conditional expression");
3560 if (result_type == error_mark_node)
3561 return error_mark_node;
3562 arg2 = perform_implicit_conversion (result_type, arg2);
3563 arg3 = perform_implicit_conversion (result_type, arg3);
3568 error ("operands to ?: have different types %qT and %qT",
3569 arg2_type, arg3_type);
3570 return error_mark_node;
3574 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3576 /* We can't use result_type below, as fold might have returned a
3581 /* Expand both sides into the same slot, hopefully the target of
3582 the ?: expression. We used to check for TARGET_EXPRs here,
3583 but now we sometimes wrap them in NOP_EXPRs so the test would
3585 if (CLASS_TYPE_P (TREE_TYPE (result)))
3586 result = get_target_expr (result);
3587 /* If this expression is an rvalue, but might be mistaken for an
3588 lvalue, we must add a NON_LVALUE_EXPR. */
3589 result = rvalue (result);
3595 /* OPERAND is an operand to an expression. Perform necessary steps
3596 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3600 prep_operand (tree operand)
3604 if (CLASS_TYPE_P (TREE_TYPE (operand))
3605 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3606 /* Make sure the template type is instantiated now. */
3607 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3613 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3614 OVERLOAD) to the CANDIDATES, returning an updated list of
3615 CANDIDATES. The ARGS are the arguments provided to the call,
3616 without any implicit object parameter. The EXPLICIT_TARGS are
3617 explicit template arguments provided. TEMPLATE_ONLY is true if
3618 only template functions should be considered. CONVERSION_PATH,
3619 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3622 add_candidates (tree fns, tree args,
3623 tree explicit_targs, bool template_only,
3624 tree conversion_path, tree access_path,
3626 struct z_candidate **candidates)
3629 tree non_static_args;
3631 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3632 /* Delay creating the implicit this parameter until it is needed. */
3633 non_static_args = NULL_TREE;
3640 fn = OVL_CURRENT (fns);
3641 /* Figure out which set of arguments to use. */
3642 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3644 /* If this function is a non-static member, prepend the implicit
3645 object parameter. */
3646 if (!non_static_args)
3647 non_static_args = tree_cons (NULL_TREE,
3648 build_this (TREE_VALUE (args)),
3650 fn_args = non_static_args;
3653 /* Otherwise, just use the list of arguments provided. */
3656 if (TREE_CODE (fn) == TEMPLATE_DECL)
3657 add_template_candidate (candidates,
3667 else if (!template_only)
3668 add_function_candidate (candidates,
3675 fns = OVL_NEXT (fns);
3680 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3683 struct z_candidate *candidates = 0, *cand;
3684 tree arglist, fnname;
3686 tree result = NULL_TREE;
3687 bool result_valid_p = false;
3688 enum tree_code code2 = NOP_EXPR;
3693 bool expl_eq_arg1 = false;
3695 if (error_operand_p (arg1)
3696 || error_operand_p (arg2)
3697 || error_operand_p (arg3))
3698 return error_mark_node;
3700 if (code == MODIFY_EXPR)
3702 code2 = TREE_CODE (arg3);
3704 fnname = ansi_assopname (code2);
3707 fnname = ansi_opname (code);
3709 arg1 = prep_operand (arg1);
3715 case VEC_DELETE_EXPR:
3717 /* Use build_op_new_call and build_op_delete_call instead. */
3721 return build_object_call (arg1, arg2);
3723 case TRUTH_ORIF_EXPR:
3724 case TRUTH_ANDIF_EXPR:
3725 case TRUTH_AND_EXPR:
3727 if (COMPARISON_CLASS_P (arg1))
3728 expl_eq_arg1 = true;
3733 arg2 = prep_operand (arg2);
3734 arg3 = prep_operand (arg3);
3736 if (code == COND_EXPR)
3738 if (arg2 == NULL_TREE
3739 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3740 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3741 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3742 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3745 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3746 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3749 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3750 arg2 = integer_zero_node;
3752 arglist = NULL_TREE;
3754 arglist = tree_cons (NULL_TREE, arg3, arglist);
3756 arglist = tree_cons (NULL_TREE, arg2, arglist);
3757 arglist = tree_cons (NULL_TREE, arg1, arglist);
3759 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3760 p = conversion_obstack_alloc (0);
3762 /* Add namespace-scope operators to the list of functions to
3764 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3765 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3766 flags, &candidates);
3767 /* Add class-member operators to the candidate set. */
3768 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3772 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3773 if (fns == error_mark_node)
3775 result = error_mark_node;
3776 goto user_defined_result_ready;
3779 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3781 BASELINK_BINFO (fns),
3782 TYPE_BINFO (TREE_TYPE (arg1)),
3783 flags, &candidates);
3786 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3787 to know about two args; a builtin candidate will always have a first
3788 parameter of type bool. We'll handle that in
3789 build_builtin_candidate. */
3790 if (code == COND_EXPR)
3800 args[2] = NULL_TREE;
3803 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3809 /* For these, the built-in candidates set is empty
3810 [over.match.oper]/3. We don't want non-strict matches
3811 because exact matches are always possible with built-in
3812 operators. The built-in candidate set for COMPONENT_REF
3813 would be empty too, but since there are no such built-in
3814 operators, we accept non-strict matches for them. */
3819 strict_p = pedantic;
3823 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3828 case POSTINCREMENT_EXPR:
3829 case POSTDECREMENT_EXPR:
3830 /* Look for an `operator++ (int)'. If they didn't have
3831 one, then we fall back to the old way of doing things. */
3832 if (flags & LOOKUP_COMPLAIN)
3833 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3834 "trying prefix operator instead",
3836 operator_name_info[code].name);
3837 if (code == POSTINCREMENT_EXPR)
3838 code = PREINCREMENT_EXPR;
3840 code = PREDECREMENT_EXPR;
3841 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3845 /* The caller will deal with these. */
3850 result_valid_p = true;
3854 if (flags & LOOKUP_COMPLAIN)
3856 op_error (code, code2, arg1, arg2, arg3, "no match");
3857 print_z_candidates (candidates);
3859 result = error_mark_node;
3865 cand = tourney (candidates);
3868 if (flags & LOOKUP_COMPLAIN)
3870 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3871 print_z_candidates (candidates);
3873 result = error_mark_node;
3875 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3878 *overloaded_p = true;
3880 result = build_over_call (cand, LOOKUP_NORMAL);
3884 /* Give any warnings we noticed during overload resolution. */
3887 struct candidate_warning *w;
3888 for (w = cand->warnings; w; w = w->next)
3889 joust (cand, w->loser, 1);
3892 /* Check for comparison of different enum types. */
3901 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3902 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3903 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3904 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3906 warning (0, "comparison between %q#T and %q#T",
3907 TREE_TYPE (arg1), TREE_TYPE (arg2));
3914 /* We need to strip any leading REF_BIND so that bitfields
3915 don't cause errors. This should not remove any important
3916 conversions, because builtins don't apply to class
3917 objects directly. */
3918 conv = cand->convs[0];
3919 if (conv->kind == ck_ref_bind)
3920 conv = conv->u.next;
3921 arg1 = convert_like (conv, arg1);
3924 conv = cand->convs[1];
3925 if (conv->kind == ck_ref_bind)
3926 conv = conv->u.next;
3927 arg2 = convert_like (conv, arg2);
3931 conv = cand->convs[2];
3932 if (conv->kind == ck_ref_bind)
3933 conv = conv->u.next;
3934 arg3 = convert_like (conv, arg3);
3939 warn_logical_operator (code, arg1, arg2);
3940 expl_eq_arg1 = true;
3945 user_defined_result_ready:
3947 /* Free all the conversions we allocated. */
3948 obstack_free (&conversion_obstack, p);
3950 if (result || result_valid_p)
3957 return build_modify_expr (arg1, code2, arg2);
3960 return build_indirect_ref (arg1, "unary *");
3962 case TRUTH_ANDIF_EXPR:
3963 case TRUTH_ORIF_EXPR:
3964 case TRUTH_AND_EXPR:
3967 warn_logical_operator (code, arg1, arg2);
3971 case TRUNC_DIV_EXPR:
3982 case TRUNC_MOD_EXPR:
3986 return cp_build_binary_op (code, arg1, arg2);
3988 case UNARY_PLUS_EXPR:
3991 case TRUTH_NOT_EXPR:
3992 case PREINCREMENT_EXPR:
3993 case POSTINCREMENT_EXPR:
3994 case PREDECREMENT_EXPR:
3995 case POSTDECREMENT_EXPR:
3998 return build_unary_op (code, arg1, candidates != 0);
4001 return build_array_ref (arg1, arg2);
4004 return build_conditional_expr (arg1, arg2, arg3);
4007 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
4009 /* The caller will deal with these. */
4021 /* Build a call to operator delete. This has to be handled very specially,
4022 because the restrictions on what signatures match are different from all
4023 other call instances. For a normal delete, only a delete taking (void *)
4024 or (void *, size_t) is accepted. For a placement delete, only an exact
4025 match with the placement new is accepted.
4027 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4028 ADDR is the pointer to be deleted.
4029 SIZE is the size of the memory block to be deleted.
4030 GLOBAL_P is true if the delete-expression should not consider
4031 class-specific delete operators.
4032 PLACEMENT is the corresponding placement new call, or NULL_TREE.
4033 If PLACEMENT is non-NULL, then ALLOC_FN is the allocation function
4034 called to perform the placement new. */
4037 build_op_delete_call (enum tree_code code, tree addr, tree size,
4038 bool global_p, tree placement,
4041 tree fn = NULL_TREE;
4042 tree fns, fnname, argtypes, type;
4045 if (addr == error_mark_node)
4046 return error_mark_node;
4048 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4050 fnname = ansi_opname (code);
4052 if (CLASS_TYPE_P (type)
4053 && COMPLETE_TYPE_P (complete_type (type))
4057 If the result of the lookup is ambiguous or inaccessible, or if
4058 the lookup selects a placement deallocation function, the
4059 program is ill-formed.
4061 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4063 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4064 if (fns == error_mark_node)
4065 return error_mark_node;
4070 if (fns == NULL_TREE)
4071 fns = lookup_name_nonclass (fnname);
4073 /* Strip const and volatile from addr. */
4074 addr = cp_convert (ptr_type_node, addr);
4078 /* Get the parameter types for the allocation function that is
4080 gcc_assert (alloc_fn != NULL_TREE);
4081 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4085 /* First try it without the size argument. */
4086 argtypes = void_list_node;
4089 /* We make two tries at finding a matching `operator delete'. On
4090 the first pass, we look for a one-operator (or placement)
4091 operator delete. If we're not doing placement delete, then on
4092 the second pass we look for a two-argument delete. */
4093 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4095 /* Go through the `operator delete' functions looking for one
4096 with a matching type. */
4097 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4103 /* The first argument must be "void *". */
4104 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4105 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4108 /* On the first pass, check the rest of the arguments. */
4114 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4122 /* On the second pass, the second argument must be
4125 && same_type_p (TREE_VALUE (t), size_type_node)
4126 && TREE_CHAIN (t) == void_list_node)
4130 /* If we found a match, we're done. */
4135 /* If we have a matching function, call it. */
4138 /* Make sure we have the actual function, and not an
4140 fn = OVL_CURRENT (fn);
4142 /* If the FN is a member function, make sure that it is
4144 if (DECL_CLASS_SCOPE_P (fn))
4145 perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4149 /* The placement args might not be suitable for overload
4150 resolution at this point, so build the call directly. */
4151 int nargs = call_expr_nargs (placement);
4152 tree *argarray = (tree *) alloca (nargs * sizeof (tree));
4155 for (i = 1; i < nargs; i++)
4156 argarray[i] = CALL_EXPR_ARG (placement, i);
4158 return build_cxx_call (fn, nargs, argarray);
4164 args = tree_cons (NULL_TREE, addr, NULL_TREE);
4166 args = tree_cons (NULL_TREE, addr,
4167 build_tree_list (NULL_TREE, size));
4168 return build_function_call (fn, args);
4172 /* If we are doing placement delete we do nothing if we don't find a
4173 matching op delete. */
4177 error ("no suitable %<operator %s%> for %qT",
4178 operator_name_info[(int)code].name, type);
4179 return error_mark_node;
4182 /* If the current scope isn't allowed to access DECL along
4183 BASETYPE_PATH, give an error. The most derived class in
4184 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4185 the declaration to use in the error diagnostic. */
4188 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4190 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4192 if (!accessible_p (basetype_path, decl, true))
4194 if (TREE_PRIVATE (decl))
4195 error ("%q+#D is private", diag_decl);
4196 else if (TREE_PROTECTED (decl))
4197 error ("%q+#D is protected", diag_decl);
4199 error ("%q+#D is inaccessible", diag_decl);
4200 error ("within this context");
4207 /* Check that a callable constructor to initialize a temporary of
4208 TYPE from an EXPR exists. */
4211 check_constructor_callable (tree type, tree expr)
4213 build_special_member_call (NULL_TREE,
4214 complete_ctor_identifier,
4215 build_tree_list (NULL_TREE, expr),
4217 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4218 | LOOKUP_NO_CONVERSION
4219 | LOOKUP_CONSTRUCTOR_CALLABLE);
4222 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4223 bitwise or of LOOKUP_* values. If any errors are warnings are
4224 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4225 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4229 build_temp (tree expr, tree type, int flags,
4230 diagnostic_fn_t *diagnostic_fn)
4234 savew = warningcount, savee = errorcount;
4235 expr = build_special_member_call (NULL_TREE,
4236 complete_ctor_identifier,
4237 build_tree_list (NULL_TREE, expr),
4239 if (warningcount > savew)
4240 *diagnostic_fn = warning0;
4241 else if (errorcount > savee)
4242 *diagnostic_fn = error;
4244 *diagnostic_fn = NULL;
4248 /* Perform warnings about conversion of EXPR to type TOTYPE.
4249 FN and ARGNUM are used for diagnostics. */
4252 convert_conversion_warnings (tree totype, tree expr, tree fn, int argnum)
4254 tree t = non_reference (totype);
4256 /* Issue warnings about peculiar, but valid, uses of NULL. */
4257 if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4260 warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4263 warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4266 /* Warn about assigning a floating-point type to an integer type. */
4267 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4268 && TREE_CODE (t) == INTEGER_TYPE)
4271 warning (OPT_Wconversion, "passing %qT for argument %P to %qD",
4272 TREE_TYPE (expr), argnum, fn);
4274 warning (OPT_Wconversion, "converting to %qT from %qT", t, TREE_TYPE (expr));
4277 /* Issue warnings if "false" is converted to a NULL pointer */
4278 if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4279 warning (OPT_Wconversion,
4280 "converting %<false%> to pointer type for argument %P of %qD",
4284 /* Perform the conversions in CONVS on the expression EXPR. FN and
4285 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4286 indicates the `this' argument of a method. INNER is nonzero when
4287 being called to continue a conversion chain. It is negative when a
4288 reference binding will be applied, positive otherwise. If
4289 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4290 conversions will be emitted if appropriate. If C_CAST_P is true,
4291 this conversion is coming from a C-style cast; in that case,
4292 conversions to inaccessible bases are permitted. */
4295 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4296 int inner, bool issue_conversion_warnings,
4299 tree totype = convs->type;
4300 diagnostic_fn_t diagnostic_fn;
4303 && convs->kind != ck_user
4304 && convs->kind != ck_ambig
4305 && convs->kind != ck_ref_bind)
4307 conversion *t = convs;
4308 for (; t; t = convs->u.next)
4310 if (t->kind == ck_user || !t->bad_p)
4312 expr = convert_like_real (t, expr, fn, argnum, 1,
4313 /*issue_conversion_warnings=*/false,
4314 /*c_cast_p=*/false);
4317 else if (t->kind == ck_ambig)
4318 return convert_like_real (t, expr, fn, argnum, 1,
4319 /*issue_conversion_warnings=*/false,
4320 /*c_cast_p=*/false);
4321 else if (t->kind == ck_identity)
4324 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4326 pedwarn (" initializing argument %P of %qD", argnum, fn);
4327 return cp_convert (totype, expr);
4330 if (issue_conversion_warnings)
4331 convert_conversion_warnings (totype, expr, fn, argnum);
4333 switch (convs->kind)
4337 struct z_candidate *cand = convs->cand;
4338 tree convfn = cand->fn;
4341 if (DECL_CONSTRUCTOR_P (convfn))
4343 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4346 args = build_tree_list (NULL_TREE, expr);
4347 /* We should never try to call the abstract or base constructor
4349 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4350 && !DECL_HAS_VTT_PARM_P (convfn));
4351 args = tree_cons (NULL_TREE, t, args);
4354 args = build_this (expr);
4355 expr = build_over_call (cand, LOOKUP_NORMAL);
4357 /* If this is a constructor or a function returning an aggr type,
4358 we need to build up a TARGET_EXPR. */
4359 if (DECL_CONSTRUCTOR_P (convfn))
4360 expr = build_cplus_new (totype, expr);
4362 /* The result of the call is then used to direct-initialize the object
4363 that is the destination of the copy-initialization. [dcl.init]
4365 Note that this step is not reflected in the conversion sequence;
4366 it affects the semantics when we actually perform the
4367 conversion, but is not considered during overload resolution.
4369 If the target is a class, that means call a ctor. */
4370 if (IS_AGGR_TYPE (totype)
4371 && (inner >= 0 || !lvalue_p (expr)))
4375 /* Core issue 84, now a DR, says that we don't
4376 allow UDCs for these args (which deliberately
4377 breaks copy-init of an auto_ptr<Base> from an
4378 auto_ptr<Derived>). */
4379 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4386 (" initializing argument %P of %qD from result of %qD",
4387 argnum, fn, convfn);
4390 (" initializing temporary from result of %qD", convfn);
4392 expr = build_cplus_new (totype, expr);
4397 if (type_unknown_p (expr))
4398 expr = instantiate_type (totype, expr, tf_warning_or_error);
4399 /* Convert a constant to its underlying value, unless we are
4400 about to bind it to a reference, in which case we need to
4401 leave it as an lvalue. */
4403 expr = decl_constant_value (expr);
4404 if (convs->check_copy_constructor_p)
4405 check_constructor_callable (totype, expr);
4408 /* Call build_user_type_conversion again for the error. */
4409 return build_user_type_conversion
4410 (totype, convs->u.expr, LOOKUP_NORMAL);
4416 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4417 convs->kind == ck_ref_bind ? -1 : 1,
4418 /*issue_conversion_warnings=*/false,
4420 if (expr == error_mark_node)
4421 return error_mark_node;
4423 switch (convs->kind)
4426 expr = convert_bitfield_to_declared_type (expr);
4427 if (! IS_AGGR_TYPE (totype))
4429 /* Else fall through. */
4431 if (convs->kind == ck_base && !convs->need_temporary_p)
4433 /* We are going to bind a reference directly to a base-class
4434 subobject of EXPR. */
4435 if (convs->check_copy_constructor_p)
4436 check_constructor_callable (TREE_TYPE (expr), expr);
4437 /* Build an expression for `*((base*) &expr)'. */
4438 expr = build_unary_op (ADDR_EXPR, expr, 0);
4439 expr = convert_to_base (expr, build_pointer_type (totype),
4440 !c_cast_p, /*nonnull=*/true);
4441 expr = build_indirect_ref (expr, "implicit conversion");
4445 /* Copy-initialization where the cv-unqualified version of the source
4446 type is the same class as, or a derived class of, the class of the
4447 destination [is treated as direct-initialization]. [dcl.init] */
4448 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4450 if (diagnostic_fn && fn)
4451 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4452 return build_cplus_new (totype, expr);
4456 tree ref_type = totype;
4458 /* If necessary, create a temporary. */
4459 if (convs->need_temporary_p || !lvalue_p (expr))
4461 tree type = convs->u.next->type;
4462 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4464 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4466 /* If the reference is volatile or non-const, we
4467 cannot create a temporary. */
4468 if (lvalue & clk_bitfield)
4469 error ("cannot bind bitfield %qE to %qT",
4471 else if (lvalue & clk_packed)
4472 error ("cannot bind packed field %qE to %qT",
4475 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4476 return error_mark_node;
4478 /* If the source is a packed field, and we must use a copy
4479 constructor, then building the target expr will require
4480 binding the field to the reference parameter to the
4481 copy constructor, and we'll end up with an infinite
4482 loop. If we can use a bitwise copy, then we'll be
4484 if ((lvalue & clk_packed)
4485 && CLASS_TYPE_P (type)
4486 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4488 error ("cannot bind packed field %qE to %qT",
4490 return error_mark_node;
4492 expr = build_target_expr_with_type (expr, type);
4495 /* Take the address of the thing to which we will bind the
4497 expr = build_unary_op (ADDR_EXPR, expr, 1);
4498 if (expr == error_mark_node)
4499 return error_mark_node;
4501 /* Convert it to a pointer to the type referred to by the
4502 reference. This will adjust the pointer if a derived to
4503 base conversion is being performed. */
4504 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4506 /* Convert the pointer to the desired reference type. */
4507 return build_nop (ref_type, expr);
4511 return decay_conversion (expr);
4514 /* Warn about deprecated conversion if appropriate. */
4515 string_conv_p (totype, expr, 1);
4520 expr = convert_to_base (expr, totype, !c_cast_p,
4522 return build_nop (totype, expr);
4525 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4532 if (issue_conversion_warnings)
4533 expr = convert_and_check (totype, expr);
4535 expr = convert (totype, expr);
4540 /* Build a call to __builtin_trap. */
4543 call_builtin_trap (void)
4545 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4547 gcc_assert (fn != NULL);
4548 fn = build_call_n (fn, 0);
4552 /* ARG is being passed to a varargs function. Perform any conversions
4553 required. Return the converted value. */
4556 convert_arg_to_ellipsis (tree arg)
4560 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4561 standard conversions are performed. */
4562 arg = decay_conversion (arg);
4565 If the argument has integral or enumeration type that is subject
4566 to the integral promotions (_conv.prom_), or a floating point
4567 type that is subject to the floating point promotion
4568 (_conv.fpprom_), the value of the argument is converted to the
4569 promoted type before the call. */
4570 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4571 && (TYPE_PRECISION (TREE_TYPE (arg))
4572 < TYPE_PRECISION (double_type_node)))
4573 arg = convert_to_real (double_type_node, arg);
4574 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4575 arg = perform_integral_promotions (arg);
4577 arg = require_complete_type (arg);
4579 if (arg != error_mark_node
4580 && !pod_type_p (TREE_TYPE (arg)))
4582 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4583 here and do a bitwise copy, but now cp_expr_size will abort if we
4585 If the call appears in the context of a sizeof expression,
4586 there is no need to emit a warning, since the expression won't be
4587 evaluated. We keep the builtin_trap just as a safety check. */
4588 if (!skip_evaluation)
4589 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4590 "call will abort at runtime", TREE_TYPE (arg));
4591 arg = call_builtin_trap ();
4592 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4599 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4602 build_x_va_arg (tree expr, tree type)
4604 if (processing_template_decl)
4605 return build_min (VA_ARG_EXPR, type, expr);
4607 type = complete_type_or_else (type, NULL_TREE);
4609 if (expr == error_mark_node || !type)
4610 return error_mark_node;
4612 if (! pod_type_p (type))
4614 /* Remove reference types so we don't ICE later on. */
4615 tree type1 = non_reference (type);
4616 /* Undefined behavior [expr.call] 5.2.2/7. */
4617 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4618 "call will abort at runtime", type);
4619 expr = convert (build_pointer_type (type1), null_node);
4620 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4621 call_builtin_trap (), expr);
4622 expr = build_indirect_ref (expr, NULL);
4626 return build_va_arg (expr, type);
4629 /* TYPE has been given to va_arg. Apply the default conversions which
4630 would have happened when passed via ellipsis. Return the promoted
4631 type, or the passed type if there is no change. */
4634 cxx_type_promotes_to (tree type)
4638 /* Perform the array-to-pointer and function-to-pointer
4640 type = type_decays_to (type);
4642 promote = type_promotes_to (type);
4643 if (same_type_p (type, promote))
4649 /* ARG is a default argument expression being passed to a parameter of
4650 the indicated TYPE, which is a parameter to FN. Do any required
4651 conversions. Return the converted value. */
4654 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4656 /* If the ARG is an unparsed default argument expression, the
4657 conversion cannot be performed. */
4658 if (TREE_CODE (arg) == DEFAULT_ARG)
4660 error ("the default argument for parameter %d of %qD has "
4661 "not yet been parsed",
4663 return error_mark_node;
4666 if (fn && DECL_TEMPLATE_INFO (fn))
4667 arg = tsubst_default_argument (fn, type, arg);
4669 arg = break_out_target_exprs (arg);
4671 if (TREE_CODE (arg) == CONSTRUCTOR)
4673 arg = digest_init (type, arg);
4674 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4675 "default argument", fn, parmnum);
4679 /* We must make a copy of ARG, in case subsequent processing
4680 alters any part of it. For example, during gimplification a
4681 cast of the form (T) &X::f (where "f" is a member function)
4682 will lead to replacing the PTRMEM_CST for &X::f with a
4683 VAR_DECL. We can avoid the copy for constants, since they
4684 are never modified in place. */
4685 if (!CONSTANT_CLASS_P (arg))
4686 arg = unshare_expr (arg);
4687 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4688 "default argument", fn, parmnum);
4689 arg = convert_for_arg_passing (type, arg);
4695 /* Returns the type which will really be used for passing an argument of
4699 type_passed_as (tree type)
4701 /* Pass classes with copy ctors by invisible reference. */
4702 if (TREE_ADDRESSABLE (type))
4704 type = build_reference_type (type);
4705 /* There are no other pointers to this temporary. */
4706 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4708 else if (targetm.calls.promote_prototypes (type)
4709 && INTEGRAL_TYPE_P (type)
4710 && COMPLETE_TYPE_P (type)
4711 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4712 TYPE_SIZE (integer_type_node)))
4713 type = integer_type_node;
4718 /* Actually perform the appropriate conversion. */
4721 convert_for_arg_passing (tree type, tree val)
4723 if (val == error_mark_node)
4725 /* Pass classes with copy ctors by invisible reference. */
4726 else if (TREE_ADDRESSABLE (type))
4727 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4728 else if (targetm.calls.promote_prototypes (type)
4729 && INTEGRAL_TYPE_P (type)
4730 && COMPLETE_TYPE_P (type)
4731 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4732 TYPE_SIZE (integer_type_node)))
4733 val = perform_integral_promotions (val);
4734 if (warn_missing_format_attribute)
4736 tree rhstype = TREE_TYPE (val);
4737 const enum tree_code coder = TREE_CODE (rhstype);
4738 const enum tree_code codel = TREE_CODE (type);
4739 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4741 && check_missing_format_attribute (type, rhstype))
4742 warning (OPT_Wmissing_format_attribute,
4743 "argument of function call might be a candidate for a format attribute");
4748 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4749 which no conversions at all should be done. This is true for some
4750 builtins which don't act like normal functions. */
4753 magic_varargs_p (tree fn)
4755 if (DECL_BUILT_IN (fn))
4756 switch (DECL_FUNCTION_CODE (fn))
4758 case BUILT_IN_CLASSIFY_TYPE:
4759 case BUILT_IN_CONSTANT_P:
4760 case BUILT_IN_NEXT_ARG:
4761 case BUILT_IN_STDARG_START:
4762 case BUILT_IN_VA_START:
4771 /* Subroutine of the various build_*_call functions. Overload resolution
4772 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4773 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4774 bitmask of various LOOKUP_* flags which apply to the call itself. */
4777 build_over_call (struct z_candidate *cand, int flags)
4780 tree args = cand->args;
4781 conversion **convs = cand->convs;
4783 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4792 /* In a template, there is no need to perform all of the work that
4793 is normally done. We are only interested in the type of the call
4794 expression, i.e., the return type of the function. Any semantic
4795 errors will be deferred until the template is instantiated. */
4796 if (processing_template_decl)
4800 return_type = TREE_TYPE (TREE_TYPE (fn));
4801 expr = build_call_list (return_type, fn, args);
4802 if (TREE_THIS_VOLATILE (fn) && cfun)
4803 current_function_returns_abnormally = 1;
4804 if (!VOID_TYPE_P (return_type))
4805 require_complete_type (return_type);
4806 return convert_from_reference (expr);
4809 /* Give any warnings we noticed during overload resolution. */
4812 struct candidate_warning *w;
4813 for (w = cand->warnings; w; w = w->next)
4814 joust (cand, w->loser, 1);
4817 if (DECL_FUNCTION_MEMBER_P (fn))
4819 /* If FN is a template function, two cases must be considered.
4824 template <class T> void f();
4826 template <class T> struct B {
4830 struct C : A, B<int> {
4832 using B<int>::g; // #2
4835 In case #1 where `A::f' is a member template, DECL_ACCESS is
4836 recorded in the primary template but not in its specialization.
4837 We check access of FN using its primary template.
4839 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4840 because it is a member of class template B, DECL_ACCESS is
4841 recorded in the specialization `B<int>::g'. We cannot use its
4842 primary template because `B<T>::g' and `B<int>::g' may have
4843 different access. */
4844 if (DECL_TEMPLATE_INFO (fn)
4845 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4846 perform_or_defer_access_check (cand->access_path,
4847 DECL_TI_TEMPLATE (fn), fn);
4849 perform_or_defer_access_check (cand->access_path, fn, fn);
4852 if (args && TREE_CODE (args) != TREE_LIST)
4853 args = build_tree_list (NULL_TREE, args);
4856 /* Find maximum size of vector to hold converted arguments. */
4857 parmlen = list_length (parm);
4858 nargs = list_length (args);
4859 if (parmlen > nargs)
4861 argarray = (tree *) alloca (nargs * sizeof (tree));
4863 /* The implicit parameters to a constructor are not considered by overload
4864 resolution, and must be of the proper type. */
4865 if (DECL_CONSTRUCTOR_P (fn))
4867 argarray[j++] = TREE_VALUE (arg);
4868 arg = TREE_CHAIN (arg);
4869 parm = TREE_CHAIN (parm);
4870 /* We should never try to call the abstract constructor. */
4871 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4873 if (DECL_HAS_VTT_PARM_P (fn))
4875 argarray[j++] = TREE_VALUE (arg);
4876 arg = TREE_CHAIN (arg);
4877 parm = TREE_CHAIN (parm);
4880 /* Bypass access control for 'this' parameter. */
4881 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4883 tree parmtype = TREE_VALUE (parm);
4884 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4888 if (convs[i]->bad_p)
4889 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4890 TREE_TYPE (argtype), fn);
4892 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4893 X is called for an object that is not of type X, or of a type
4894 derived from X, the behavior is undefined.
4896 So we can assume that anything passed as 'this' is non-null, and
4897 optimize accordingly. */
4898 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4899 /* Convert to the base in which the function was declared. */
4900 gcc_assert (cand->conversion_path != NULL_TREE);
4901 converted_arg = build_base_path (PLUS_EXPR,
4903 cand->conversion_path,
4905 /* Check that the base class is accessible. */
4906 if (!accessible_base_p (TREE_TYPE (argtype),
4907 BINFO_TYPE (cand->conversion_path), true))
4908 error ("%qT is not an accessible base of %qT",
4909 BINFO_TYPE (cand->conversion_path),
4910 TREE_TYPE (argtype));
4911 /* If fn was found by a using declaration, the conversion path
4912 will be to the derived class, not the base declaring fn. We
4913 must convert from derived to base. */
4914 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4915 TREE_TYPE (parmtype), ba_unique, NULL);
4916 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4919 argarray[j++] = converted_arg;
4920 parm = TREE_CHAIN (parm);
4921 arg = TREE_CHAIN (arg);
4927 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4929 tree type = TREE_VALUE (parm);
4933 /* Don't make a copy here if build_call is going to. */
4934 if (conv->kind == ck_rvalue
4935 && !TREE_ADDRESSABLE (complete_type (type)))
4936 conv = conv->u.next;
4938 val = convert_like_with_context
4939 (conv, TREE_VALUE (arg), fn, i - is_method);
4941 val = convert_for_arg_passing (type, val);
4942 argarray[j++] = val;
4945 /* Default arguments */
4946 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4947 argarray[j++] = convert_default_arg (TREE_VALUE (parm),
4948 TREE_PURPOSE (parm),
4951 for (; arg; arg = TREE_CHAIN (arg))
4953 tree a = TREE_VALUE (arg);
4954 if (magic_varargs_p (fn))
4955 /* Do no conversions for magic varargs. */;
4957 a = convert_arg_to_ellipsis (a);
4961 gcc_assert (j <= nargs);
4964 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4965 nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
4967 /* Avoid actually calling copy constructors and copy assignment operators,
4970 if (! flag_elide_constructors)
4971 /* Do things the hard way. */;
4972 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4975 arg = argarray[num_artificial_parms_for (fn)];
4977 /* Pull out the real argument, disregarding const-correctness. */
4979 while (TREE_CODE (targ) == NOP_EXPR
4980 || TREE_CODE (targ) == NON_LVALUE_EXPR
4981 || TREE_CODE (targ) == CONVERT_EXPR)
4982 targ = TREE_OPERAND (targ, 0);
4983 if (TREE_CODE (targ) == ADDR_EXPR)
4985 targ = TREE_OPERAND (targ, 0);
4986 if (!same_type_ignoring_top_level_qualifiers_p
4987 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4996 arg = build_indirect_ref (arg, 0);
4998 /* [class.copy]: the copy constructor is implicitly defined even if
4999 the implementation elided its use. */
5000 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
5003 /* If we're creating a temp and we already have one, don't create a
5004 new one. If we're not creating a temp but we get one, use
5005 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5006 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5007 temp or an INIT_EXPR otherwise. */
5008 if (integer_zerop (TREE_VALUE (args)))
5010 if (TREE_CODE (arg) == TARGET_EXPR)
5012 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5013 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5015 else if (TREE_CODE (arg) == TARGET_EXPR
5016 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5018 tree to = stabilize_reference
5019 (build_indirect_ref (TREE_VALUE (args), 0));
5021 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5025 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5027 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5029 tree to = stabilize_reference
5030 (build_indirect_ref (argarray[0], 0));
5031 tree type = TREE_TYPE (to);
5032 tree as_base = CLASSTYPE_AS_BASE (type);
5035 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5037 arg = build_indirect_ref (arg, 0);
5038 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5042 /* We must only copy the non-tail padding parts.
5043 Use __builtin_memcpy for the bitwise copy. */
5045 tree arg0, arg1, arg2, t;
5047 arg2 = TYPE_SIZE_UNIT (as_base);
5049 arg0 = build_unary_op (ADDR_EXPR, to, 0);
5050 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5051 t = build_call_n (t, 3, arg0, arg1, arg2);
5053 t = convert (TREE_TYPE (arg0), t);
5054 val = build_indirect_ref (t, 0);
5062 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5065 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5068 gcc_assert (binfo && binfo != error_mark_node);
5070 argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5071 if (TREE_SIDE_EFFECTS (argarray[0]))
5072 argarray[0] = save_expr (argarray[0]);
5073 t = build_pointer_type (TREE_TYPE (fn));
5074 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5075 fn = build_java_interface_fn_ref (fn, argarray[0]);
5077 fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5080 else if (DECL_INLINE (fn))
5081 fn = inline_conversion (fn);
5083 fn = build_addr_func (fn);
5085 return build_cxx_call (fn, nargs, argarray);
5088 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5089 This function performs no overload resolution, conversion, or other
5090 high-level operations. */
5093 build_cxx_call (tree fn, int nargs, tree *argarray)
5097 fn = build_call_a (fn, nargs, argarray);
5099 /* If this call might throw an exception, note that fact. */
5100 fndecl = get_callee_fndecl (fn);
5101 if ((!fndecl || !TREE_NOTHROW (fndecl))
5102 && at_function_scope_p ()
5104 cp_function_chain->can_throw = 1;
5106 /* Some built-in function calls will be evaluated at compile-time in
5108 fn = fold_if_not_in_template (fn);
5110 if (VOID_TYPE_P (TREE_TYPE (fn)))
5113 fn = require_complete_type (fn);
5114 if (fn == error_mark_node)
5115 return error_mark_node;
5117 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5118 fn = build_cplus_new (TREE_TYPE (fn), fn);
5119 return convert_from_reference (fn);
5122 static GTY(()) tree java_iface_lookup_fn;
5124 /* Make an expression which yields the address of the Java interface
5125 method FN. This is achieved by generating a call to libjava's
5126 _Jv_LookupInterfaceMethodIdx(). */
5129 build_java_interface_fn_ref (tree fn, tree instance)
5131 tree lookup_fn, method, idx;
5132 tree klass_ref, iface, iface_ref;
5135 if (!java_iface_lookup_fn)
5137 tree endlink = build_void_list_node ();
5138 tree t = tree_cons (NULL_TREE, ptr_type_node,
5139 tree_cons (NULL_TREE, ptr_type_node,
5140 tree_cons (NULL_TREE, java_int_type_node,
5142 java_iface_lookup_fn
5143 = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5144 build_function_type (ptr_type_node, t),
5145 0, NOT_BUILT_IN, NULL, NULL_TREE);
5148 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5149 This is the first entry in the vtable. */
5150 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5153 /* Get the java.lang.Class pointer for the interface being called. */
5154 iface = DECL_CONTEXT (fn);
5155 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5156 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5157 || DECL_CONTEXT (iface_ref) != iface)
5159 error ("could not find class$ field in java interface type %qT",
5161 return error_mark_node;
5163 iface_ref = build_address (iface_ref);
5164 iface_ref = convert (build_pointer_type (iface), iface_ref);
5166 /* Determine the itable index of FN. */
5168 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5170 if (!DECL_VIRTUAL_P (method))
5176 idx = build_int_cst (NULL_TREE, i);
5178 lookup_fn = build1 (ADDR_EXPR,
5179 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5180 java_iface_lookup_fn);
5181 return build_call_nary (ptr_type_node, lookup_fn,
5182 3, klass_ref, iface_ref, idx);
5185 /* Returns the value to use for the in-charge parameter when making a
5186 call to a function with the indicated NAME.
5188 FIXME:Can't we find a neater way to do this mapping? */
5191 in_charge_arg_for_name (tree name)
5193 if (name == base_ctor_identifier
5194 || name == base_dtor_identifier)
5195 return integer_zero_node;
5196 else if (name == complete_ctor_identifier)
5197 return integer_one_node;
5198 else if (name == complete_dtor_identifier)
5199 return integer_two_node;
5200 else if (name == deleting_dtor_identifier)
5201 return integer_three_node;
5203 /* This function should only be called with one of the names listed
5209 /* Build a call to a constructor, destructor, or an assignment
5210 operator for INSTANCE, an expression with class type. NAME
5211 indicates the special member function to call; ARGS are the
5212 arguments. BINFO indicates the base of INSTANCE that is to be
5213 passed as the `this' parameter to the member function called.
5215 FLAGS are the LOOKUP_* flags to use when processing the call.
5217 If NAME indicates a complete object constructor, INSTANCE may be
5218 NULL_TREE. In this case, the caller will call build_cplus_new to
5219 store the newly constructed object into a VAR_DECL. */
5222 build_special_member_call (tree instance, tree name, tree args,
5223 tree binfo, int flags)
5226 /* The type of the subobject to be constructed or destroyed. */
5229 gcc_assert (name == complete_ctor_identifier
5230 || name == base_ctor_identifier
5231 || name == complete_dtor_identifier
5232 || name == base_dtor_identifier
5233 || name == deleting_dtor_identifier
5234 || name == ansi_assopname (NOP_EXPR));
5237 /* Resolve the name. */
5238 if (!complete_type_or_else (binfo, NULL_TREE))
5239 return error_mark_node;
5241 binfo = TYPE_BINFO (binfo);
5244 gcc_assert (binfo != NULL_TREE);
5246 class_type = BINFO_TYPE (binfo);
5248 /* Handle the special case where INSTANCE is NULL_TREE. */
5249 if (name == complete_ctor_identifier && !instance)
5251 instance = build_int_cst (build_pointer_type (class_type), 0);
5252 instance = build1 (INDIRECT_REF, class_type, instance);
5256 if (name == complete_dtor_identifier
5257 || name == base_dtor_identifier
5258 || name == deleting_dtor_identifier)
5259 gcc_assert (args == NULL_TREE);
5261 /* Convert to the base class, if necessary. */
5262 if (!same_type_ignoring_top_level_qualifiers_p
5263 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5265 if (name != ansi_assopname (NOP_EXPR))
5266 /* For constructors and destructors, either the base is
5267 non-virtual, or it is virtual but we are doing the
5268 conversion from a constructor or destructor for the
5269 complete object. In either case, we can convert
5271 instance = convert_to_base_statically (instance, binfo);
5273 /* However, for assignment operators, we must convert
5274 dynamically if the base is virtual. */
5275 instance = build_base_path (PLUS_EXPR, instance,
5276 binfo, /*nonnull=*/1);
5280 gcc_assert (instance != NULL_TREE);
5282 fns = lookup_fnfields (binfo, name, 1);
5284 /* When making a call to a constructor or destructor for a subobject
5285 that uses virtual base classes, pass down a pointer to a VTT for
5287 if ((name == base_ctor_identifier
5288 || name == base_dtor_identifier)
5289 && CLASSTYPE_VBASECLASSES (class_type))
5294 /* If the current function is a complete object constructor
5295 or destructor, then we fetch the VTT directly.
5296 Otherwise, we look it up using the VTT we were given. */
5297 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5298 vtt = decay_conversion (vtt);
5299 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5300 build2 (EQ_EXPR, boolean_type_node,
5301 current_in_charge_parm, integer_zero_node),
5304 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5305 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5306 BINFO_SUBVTT_INDEX (binfo));
5308 args = tree_cons (NULL_TREE, sub_vtt, args);
5311 return build_new_method_call (instance, fns, args,
5312 TYPE_BINFO (BINFO_TYPE (binfo)),
5313 flags, /*fn=*/NULL);
5316 /* Return the NAME, as a C string. The NAME indicates a function that
5317 is a member of TYPE. *FREE_P is set to true if the caller must
5318 free the memory returned.
5320 Rather than go through all of this, we should simply set the names
5321 of constructors and destructors appropriately, and dispense with
5322 ctor_identifier, dtor_identifier, etc. */
5325 name_as_c_string (tree name, tree type, bool *free_p)
5329 /* Assume that we will not allocate memory. */
5331 /* Constructors and destructors are special. */
5332 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5335 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5336 /* For a destructor, add the '~'. */
5337 if (name == complete_dtor_identifier
5338 || name == base_dtor_identifier
5339 || name == deleting_dtor_identifier)
5341 pretty_name = concat ("~", pretty_name, NULL);
5342 /* Remember that we need to free the memory allocated. */
5346 else if (IDENTIFIER_TYPENAME_P (name))
5348 pretty_name = concat ("operator ",
5349 type_as_string (TREE_TYPE (name),
5350 TFF_PLAIN_IDENTIFIER),
5352 /* Remember that we need to free the memory allocated. */
5356 pretty_name = (char *) IDENTIFIER_POINTER (name);
5361 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5362 be set, upon return, to the function called. */
5365 build_new_method_call (tree instance, tree fns, tree args,
5366 tree conversion_path, int flags,
5369 struct z_candidate *candidates = 0, *cand;
5370 tree explicit_targs = NULL_TREE;
5371 tree basetype = NULL_TREE;
5374 tree mem_args = NULL_TREE, instance_ptr;
5380 int template_only = 0;
5387 gcc_assert (instance != NULL_TREE);
5389 /* We don't know what function we're going to call, yet. */
5393 if (error_operand_p (instance)
5394 || error_operand_p (fns)
5395 || args == error_mark_node)
5396 return error_mark_node;
5398 if (!BASELINK_P (fns))
5400 error ("call to non-function %qD", fns);
5401 return error_mark_node;
5404 orig_instance = instance;
5408 /* Dismantle the baselink to collect all the information we need. */
5409 if (!conversion_path)
5410 conversion_path = BASELINK_BINFO (fns);
5411 access_binfo = BASELINK_ACCESS_BINFO (fns);
5412 optype = BASELINK_OPTYPE (fns);
5413 fns = BASELINK_FUNCTIONS (fns);
5414 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5416 explicit_targs = TREE_OPERAND (fns, 1);
5417 fns = TREE_OPERAND (fns, 0);
5420 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5421 || TREE_CODE (fns) == TEMPLATE_DECL
5422 || TREE_CODE (fns) == OVERLOAD);
5423 fn = get_first_fn (fns);
5424 name = DECL_NAME (fn);
5426 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5427 gcc_assert (CLASS_TYPE_P (basetype));
5429 if (processing_template_decl)
5431 instance = build_non_dependent_expr (instance);
5432 args = build_non_dependent_args (orig_args);
5435 /* The USER_ARGS are the arguments we will display to users if an
5436 error occurs. The USER_ARGS should not include any
5437 compiler-generated arguments. The "this" pointer hasn't been
5438 added yet. However, we must remove the VTT pointer if this is a
5439 call to a base-class constructor or destructor. */
5441 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5443 /* Callers should explicitly indicate whether they want to construct
5444 the complete object or just the part without virtual bases. */
5445 gcc_assert (name != ctor_identifier);
5446 /* Similarly for destructors. */
5447 gcc_assert (name != dtor_identifier);
5448 /* Remove the VTT pointer, if present. */
5449 if ((name == base_ctor_identifier || name == base_dtor_identifier)
5450 && CLASSTYPE_VBASECLASSES (basetype))
5451 user_args = TREE_CHAIN (user_args);
5454 /* Process the argument list. */
5455 args = resolve_args (args);
5456 if (args == error_mark_node)
5457 return error_mark_node;
5459 instance_ptr = build_this (instance);
5461 /* It's OK to call destructors on cv-qualified objects. Therefore,
5462 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5463 if (DECL_DESTRUCTOR_P (fn))
5465 tree type = build_pointer_type (basetype);
5466 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5467 instance_ptr = build_nop (type, instance_ptr);
5468 name = complete_dtor_identifier;
5471 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5472 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5474 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5475 p = conversion_obstack_alloc (0);
5477 for (fn = fns; fn; fn = OVL_NEXT (fn))
5479 tree t = OVL_CURRENT (fn);
5482 /* We can end up here for copy-init of same or base class. */
5483 if ((flags & LOOKUP_ONLYCONVERTING)
5484 && DECL_NONCONVERTING_P (t))
5487 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5488 this_arglist = mem_args;
5490 this_arglist = args;
5492 if (TREE_CODE (t) == TEMPLATE_DECL)
5493 /* A member template. */
5494 add_template_candidate (&candidates, t,
5497 this_arglist, optype,
5502 else if (! template_only)
5503 add_function_candidate (&candidates, t,
5511 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5514 if (!COMPLETE_TYPE_P (basetype))
5515 cxx_incomplete_type_error (instance_ptr, basetype);
5521 pretty_name = name_as_c_string (name, basetype, &free_p);
5522 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5523 basetype, pretty_name, user_args,
5524 TREE_TYPE (TREE_TYPE (instance_ptr)));
5528 print_z_candidates (candidates);
5529 call = error_mark_node;
5533 cand = tourney (candidates);
5539 pretty_name = name_as_c_string (name, basetype, &free_p);
5540 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5542 print_z_candidates (candidates);
5545 call = error_mark_node;
5551 if (!(flags & LOOKUP_NONVIRTUAL)
5552 && DECL_PURE_VIRTUAL_P (fn)
5553 && instance == current_class_ref
5554 && (DECL_CONSTRUCTOR_P (current_function_decl)
5555 || DECL_DESTRUCTOR_P (current_function_decl)))
5556 /* This is not an error, it is runtime undefined
5558 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5559 "abstract virtual %q#D called from constructor"
5560 : "abstract virtual %q#D called from destructor"),
5563 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5564 && is_dummy_object (instance_ptr))
5566 error ("cannot call member function %qD without object",
5568 call = error_mark_node;
5572 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5573 && resolves_to_fixed_type_p (instance, 0))
5574 flags |= LOOKUP_NONVIRTUAL;
5575 /* Now we know what function is being called. */
5578 /* Build the actual CALL_EXPR. */
5579 call = build_over_call (cand, flags);
5580 /* In an expression of the form `a->f()' where `f' turns
5581 out to be a static member function, `a' is
5582 none-the-less evaluated. */
5583 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
5584 && !is_dummy_object (instance_ptr)
5585 && TREE_SIDE_EFFECTS (instance_ptr))
5586 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5587 instance_ptr, call);
5588 else if (call != error_mark_node
5589 && DECL_DESTRUCTOR_P (cand->fn)
5590 && !VOID_TYPE_P (TREE_TYPE (call)))
5591 /* An explicit call of the form "x->~X()" has type
5592 "void". However, on platforms where destructors
5593 return "this" (i.e., those where
5594 targetm.cxx.cdtor_returns_this is true), such calls
5595 will appear to have a return value of pointer type
5596 to the low-level call machinery. We do not want to
5597 change the low-level machinery, since we want to be
5598 able to optimize "delete f()" on such platforms as
5599 "operator delete(~X(f()))" (rather than generating
5600 "t = f(), ~X(t), operator delete (t)"). */
5601 call = build_nop (void_type_node, call);
5606 if (processing_template_decl && call != error_mark_node)
5607 call = (build_min_non_dep_call_list
5609 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5612 /* Free all the conversions we allocated. */
5613 obstack_free (&conversion_obstack, p);
5618 /* Returns true iff standard conversion sequence ICS1 is a proper
5619 subsequence of ICS2. */
5622 is_subseq (conversion *ics1, conversion *ics2)
5624 /* We can assume that a conversion of the same code
5625 between the same types indicates a subsequence since we only get
5626 here if the types we are converting from are the same. */
5628 while (ics1->kind == ck_rvalue
5629 || ics1->kind == ck_lvalue)
5630 ics1 = ics1->u.next;
5634 while (ics2->kind == ck_rvalue
5635 || ics2->kind == ck_lvalue)
5636 ics2 = ics2->u.next;
5638 if (ics2->kind == ck_user
5639 || ics2->kind == ck_ambig
5640 || ics2->kind == ck_identity)
5641 /* At this point, ICS1 cannot be a proper subsequence of
5642 ICS2. We can get a USER_CONV when we are comparing the
5643 second standard conversion sequence of two user conversion
5647 ics2 = ics2->u.next;
5649 if (ics2->kind == ics1->kind
5650 && same_type_p (ics2->type, ics1->type)
5651 && same_type_p (ics2->u.next->type,
5652 ics1->u.next->type))
5657 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5658 be any _TYPE nodes. */
5661 is_properly_derived_from (tree derived, tree base)
5663 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5664 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5667 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5668 considers every class derived from itself. */
5669 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5670 && DERIVED_FROM_P (base, derived));
5673 /* We build the ICS for an implicit object parameter as a pointer
5674 conversion sequence. However, such a sequence should be compared
5675 as if it were a reference conversion sequence. If ICS is the
5676 implicit conversion sequence for an implicit object parameter,
5677 modify it accordingly. */
5680 maybe_handle_implicit_object (conversion **ics)
5684 /* [over.match.funcs]
5686 For non-static member functions, the type of the
5687 implicit object parameter is "reference to cv X"
5688 where X is the class of which the function is a
5689 member and cv is the cv-qualification on the member
5690 function declaration. */
5691 conversion *t = *ics;
5692 tree reference_type;
5694 /* The `this' parameter is a pointer to a class type. Make the
5695 implicit conversion talk about a reference to that same class
5697 reference_type = TREE_TYPE (t->type);
5698 reference_type = build_reference_type (reference_type);
5700 if (t->kind == ck_qual)
5702 if (t->kind == ck_ptr)
5704 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5705 t = direct_reference_binding (reference_type, t);
5710 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5711 and return the type to which the reference refers. Otherwise,
5712 leave *ICS unchanged and return NULL_TREE. */
5715 maybe_handle_ref_bind (conversion **ics)
5717 if ((*ics)->kind == ck_ref_bind)
5719 conversion *old_ics = *ics;
5720 tree type = TREE_TYPE (old_ics->type);
5721 *ics = old_ics->u.next;
5722 (*ics)->user_conv_p = old_ics->user_conv_p;
5723 (*ics)->bad_p = old_ics->bad_p;
5730 /* Compare two implicit conversion sequences according to the rules set out in
5731 [over.ics.rank]. Return values:
5733 1: ics1 is better than ics2
5734 -1: ics2 is better than ics1
5735 0: ics1 and ics2 are indistinguishable */
5738 compare_ics (conversion *ics1, conversion *ics2)
5744 tree deref_from_type1 = NULL_TREE;
5745 tree deref_from_type2 = NULL_TREE;
5746 tree deref_to_type1 = NULL_TREE;
5747 tree deref_to_type2 = NULL_TREE;
5748 conversion_rank rank1, rank2;
5750 /* REF_BINDING is nonzero if the result of the conversion sequence
5751 is a reference type. In that case TARGET_TYPE is the
5752 type referred to by the reference. */
5756 /* Handle implicit object parameters. */
5757 maybe_handle_implicit_object (&ics1);
5758 maybe_handle_implicit_object (&ics2);
5760 /* Handle reference parameters. */
5761 target_type1 = maybe_handle_ref_bind (&ics1);
5762 target_type2 = maybe_handle_ref_bind (&ics2);
5766 When comparing the basic forms of implicit conversion sequences (as
5767 defined in _over.best.ics_)
5769 --a standard conversion sequence (_over.ics.scs_) is a better
5770 conversion sequence than a user-defined conversion sequence
5771 or an ellipsis conversion sequence, and
5773 --a user-defined conversion sequence (_over.ics.user_) is a
5774 better conversion sequence than an ellipsis conversion sequence
5775 (_over.ics.ellipsis_). */
5776 rank1 = CONVERSION_RANK (ics1);
5777 rank2 = CONVERSION_RANK (ics2);
5781 else if (rank1 < rank2)
5784 if (rank1 == cr_bad)
5786 /* XXX Isn't this an extension? */
5787 /* Both ICS are bad. We try to make a decision based on what
5788 would have happened if they'd been good. */
5789 if (ics1->user_conv_p > ics2->user_conv_p
5790 || ics1->rank > ics2->rank)
5792 else if (ics1->user_conv_p < ics2->user_conv_p
5793 || ics1->rank < ics2->rank)
5796 /* We couldn't make up our minds; try to figure it out below. */
5799 if (ics1->ellipsis_p)
5800 /* Both conversions are ellipsis conversions. */
5803 /* User-defined conversion sequence U1 is a better conversion sequence
5804 than another user-defined conversion sequence U2 if they contain the
5805 same user-defined conversion operator or constructor and if the sec-
5806 ond standard conversion sequence of U1 is better than the second
5807 standard conversion sequence of U2. */
5809 if (ics1->user_conv_p)
5814 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5815 if (t1->kind == ck_ambig)
5817 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5818 if (t2->kind == ck_ambig)
5821 if (t1->cand->fn != t2->cand->fn)
5824 /* We can just fall through here, after setting up
5825 FROM_TYPE1 and FROM_TYPE2. */
5826 from_type1 = t1->type;
5827 from_type2 = t2->type;
5834 /* We're dealing with two standard conversion sequences.
5838 Standard conversion sequence S1 is a better conversion
5839 sequence than standard conversion sequence S2 if
5841 --S1 is a proper subsequence of S2 (comparing the conversion
5842 sequences in the canonical form defined by _over.ics.scs_,
5843 excluding any Lvalue Transformation; the identity
5844 conversion sequence is considered to be a subsequence of
5845 any non-identity conversion sequence */
5848 while (t1->kind != ck_identity)
5850 from_type1 = t1->type;
5853 while (t2->kind != ck_identity)
5855 from_type2 = t2->type;
5858 if (same_type_p (from_type1, from_type2))
5860 if (is_subseq (ics1, ics2))
5862 if (is_subseq (ics2, ics1))
5865 /* Otherwise, one sequence cannot be a subsequence of the other; they
5866 don't start with the same type. This can happen when comparing the
5867 second standard conversion sequence in two user-defined conversion
5874 --the rank of S1 is better than the rank of S2 (by the rules
5877 Standard conversion sequences are ordered by their ranks: an Exact
5878 Match is a better conversion than a Promotion, which is a better
5879 conversion than a Conversion.
5881 Two conversion sequences with the same rank are indistinguishable
5882 unless one of the following rules applies:
5884 --A conversion that is not a conversion of a pointer, or pointer
5885 to member, to bool is better than another conversion that is such
5888 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5889 so that we do not have to check it explicitly. */
5890 if (ics1->rank < ics2->rank)
5892 else if (ics2->rank < ics1->rank)
5895 to_type1 = ics1->type;
5896 to_type2 = ics2->type;
5898 if (TYPE_PTR_P (from_type1)
5899 && TYPE_PTR_P (from_type2)
5900 && TYPE_PTR_P (to_type1)
5901 && TYPE_PTR_P (to_type2))
5903 deref_from_type1 = TREE_TYPE (from_type1);
5904 deref_from_type2 = TREE_TYPE (from_type2);
5905 deref_to_type1 = TREE_TYPE (to_type1);
5906 deref_to_type2 = TREE_TYPE (to_type2);
5908 /* The rules for pointers to members A::* are just like the rules
5909 for pointers A*, except opposite: if B is derived from A then
5910 A::* converts to B::*, not vice versa. For that reason, we
5911 switch the from_ and to_ variables here. */
5912 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5913 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5914 || (TYPE_PTRMEMFUNC_P (from_type1)
5915 && TYPE_PTRMEMFUNC_P (from_type2)
5916 && TYPE_PTRMEMFUNC_P (to_type1)
5917 && TYPE_PTRMEMFUNC_P (to_type2)))
5919 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5920 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5921 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5922 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5925 if (deref_from_type1 != NULL_TREE
5926 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5927 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5929 /* This was one of the pointer or pointer-like conversions.
5933 --If class B is derived directly or indirectly from class A,
5934 conversion of B* to A* is better than conversion of B* to
5935 void*, and conversion of A* to void* is better than
5936 conversion of B* to void*. */
5937 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5938 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5940 if (is_properly_derived_from (deref_from_type1,
5943 else if (is_properly_derived_from (deref_from_type2,
5947 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5948 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5950 if (same_type_p (deref_from_type1, deref_from_type2))
5952 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5954 if (is_properly_derived_from (deref_from_type1,
5958 /* We know that DEREF_TO_TYPE1 is `void' here. */
5959 else if (is_properly_derived_from (deref_from_type1,
5964 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5965 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5969 --If class B is derived directly or indirectly from class A
5970 and class C is derived directly or indirectly from B,
5972 --conversion of C* to B* is better than conversion of C* to
5975 --conversion of B* to A* is better than conversion of C* to
5977 if (same_type_p (deref_from_type1, deref_from_type2))
5979 if (is_properly_derived_from (deref_to_type1,
5982 else if (is_properly_derived_from (deref_to_type2,
5986 else if (same_type_p (deref_to_type1, deref_to_type2))
5988 if (is_properly_derived_from (deref_from_type2,
5991 else if (is_properly_derived_from (deref_from_type1,
5997 else if (CLASS_TYPE_P (non_reference (from_type1))
5998 && same_type_p (from_type1, from_type2))
6000 tree from = non_reference (from_type1);
6004 --binding of an expression of type C to a reference of type
6005 B& is better than binding an expression of type C to a
6006 reference of type A&
6008 --conversion of C to B is better than conversion of C to A, */
6009 if (is_properly_derived_from (from, to_type1)
6010 && is_properly_derived_from (from, to_type2))
6012 if (is_properly_derived_from (to_type1, to_type2))
6014 else if (is_properly_derived_from (to_type2, to_type1))
6018 else if (CLASS_TYPE_P (non_reference (to_type1))
6019 && same_type_p (to_type1, to_type2))
6021 tree to = non_reference (to_type1);
6025 --binding of an expression of type B to a reference of type
6026 A& is better than binding an expression of type C to a
6027 reference of type A&,
6029 --conversion of B to A is better than conversion of C to A */
6030 if (is_properly_derived_from (from_type1, to)
6031 && is_properly_derived_from (from_type2, to))
6033 if (is_properly_derived_from (from_type2, from_type1))
6035 else if (is_properly_derived_from (from_type1, from_type2))
6042 --S1 and S2 differ only in their qualification conversion and yield
6043 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6044 qualification signature of type T1 is a proper subset of the cv-
6045 qualification signature of type T2 */
6046 if (ics1->kind == ck_qual
6047 && ics2->kind == ck_qual
6048 && same_type_p (from_type1, from_type2))
6049 return comp_cv_qual_signature (to_type1, to_type2);
6053 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6054 types to which the references refer are the same type except for
6055 top-level cv-qualifiers, and the type to which the reference
6056 initialized by S2 refers is more cv-qualified than the type to
6057 which the reference initialized by S1 refers */
6059 if (target_type1 && target_type2
6060 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
6061 return comp_cv_qualification (target_type2, target_type1);
6063 /* Neither conversion sequence is better than the other. */
6067 /* The source type for this standard conversion sequence. */
6070 source_type (conversion *t)
6072 for (;; t = t->u.next)
6074 if (t->kind == ck_user
6075 || t->kind == ck_ambig
6076 || t->kind == ck_identity)
6082 /* Note a warning about preferring WINNER to LOSER. We do this by storing
6083 a pointer to LOSER and re-running joust to produce the warning if WINNER
6084 is actually used. */
6087 add_warning (struct z_candidate *winner, struct z_candidate *loser)
6089 candidate_warning *cw = (candidate_warning *)
6090 conversion_obstack_alloc (sizeof (candidate_warning));
6092 cw->next = winner->warnings;
6093 winner->warnings = cw;
6096 /* Compare two candidates for overloading as described in
6097 [over.match.best]. Return values:
6099 1: cand1 is better than cand2
6100 -1: cand2 is better than cand1
6101 0: cand1 and cand2 are indistinguishable */
6104 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6107 int off1 = 0, off2 = 0;
6111 /* Candidates that involve bad conversions are always worse than those
6113 if (cand1->viable > cand2->viable)
6115 if (cand1->viable < cand2->viable)
6118 /* If we have two pseudo-candidates for conversions to the same type,
6119 or two candidates for the same function, arbitrarily pick one. */
6120 if (cand1->fn == cand2->fn
6121 && (IS_TYPE_OR_DECL_P (cand1->fn)))
6124 /* a viable function F1
6125 is defined to be a better function than another viable function F2 if
6126 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6127 ICSi(F2), and then */
6129 /* for some argument j, ICSj(F1) is a better conversion sequence than
6132 /* For comparing static and non-static member functions, we ignore
6133 the implicit object parameter of the non-static function. The
6134 standard says to pretend that the static function has an object
6135 parm, but that won't work with operator overloading. */
6136 len = cand1->num_convs;
6137 if (len != cand2->num_convs)
6139 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6140 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6142 gcc_assert (static_1 != static_2);
6153 for (i = 0; i < len; ++i)
6155 conversion *t1 = cand1->convs[i + off1];
6156 conversion *t2 = cand2->convs[i + off2];
6157 int comp = compare_ics (t1, t2);
6162 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6163 == cr_std + cr_promotion)
6164 && t1->kind == ck_std
6165 && t2->kind == ck_std
6166 && TREE_CODE (t1->type) == INTEGER_TYPE
6167 && TREE_CODE (t2->type) == INTEGER_TYPE
6168 && (TYPE_PRECISION (t1->type)
6169 == TYPE_PRECISION (t2->type))
6170 && (TYPE_UNSIGNED (t1->u.next->type)
6171 || (TREE_CODE (t1->u.next->type)
6174 tree type = t1->u.next->type;
6176 struct z_candidate *w, *l;
6178 type1 = t1->type, type2 = t2->type,
6179 w = cand1, l = cand2;
6181 type1 = t2->type, type2 = t1->type,
6182 w = cand2, l = cand1;
6186 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6187 type, type1, type2);
6188 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
6194 if (winner && comp != winner)
6203 /* warn about confusing overload resolution for user-defined conversions,
6204 either between a constructor and a conversion op, or between two
6206 if (winner && warn_conversion && cand1->second_conv
6207 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6208 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6210 struct z_candidate *w, *l;
6211 bool give_warning = false;
6214 w = cand1, l = cand2;
6216 w = cand2, l = cand1;
6218 /* We don't want to complain about `X::operator T1 ()'
6219 beating `X::operator T2 () const', when T2 is a no less
6220 cv-qualified version of T1. */
6221 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6222 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6224 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6225 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6227 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6232 if (!comp_ptr_ttypes (t, f))
6233 give_warning = true;
6236 give_warning = true;
6242 tree source = source_type (w->convs[0]);
6243 if (! DECL_CONSTRUCTOR_P (w->fn))
6244 source = TREE_TYPE (source);
6245 warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn);
6246 warning (OPT_Wconversion, " for conversion from %qT to %qT",
6247 source, w->second_conv->type);
6248 inform (" because conversion sequence for the argument is better");
6258 F1 is a non-template function and F2 is a template function
6261 if (!cand1->template_decl && cand2->template_decl)
6263 else if (cand1->template_decl && !cand2->template_decl)
6267 F1 and F2 are template functions and the function template for F1 is
6268 more specialized than the template for F2 according to the partial
6271 if (cand1->template_decl && cand2->template_decl)
6273 winner = more_specialized_fn
6274 (TI_TEMPLATE (cand1->template_decl),
6275 TI_TEMPLATE (cand2->template_decl),
6276 /* [temp.func.order]: The presence of unused ellipsis and default
6277 arguments has no effect on the partial ordering of function
6278 templates. add_function_candidate() will not have
6279 counted the "this" argument for constructors. */
6280 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6286 the context is an initialization by user-defined conversion (see
6287 _dcl.init_ and _over.match.user_) and the standard conversion
6288 sequence from the return type of F1 to the destination type (i.e.,
6289 the type of the entity being initialized) is a better conversion
6290 sequence than the standard conversion sequence from the return type
6291 of F2 to the destination type. */
6293 if (cand1->second_conv)
6295 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6300 /* Check whether we can discard a builtin candidate, either because we
6301 have two identical ones or matching builtin and non-builtin candidates.
6303 (Pedantically in the latter case the builtin which matched the user
6304 function should not be added to the overload set, but we spot it here.
6307 ... the builtin candidates include ...
6308 - do not have the same parameter type list as any non-template
6309 non-member candidate. */
6311 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6312 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6314 for (i = 0; i < len; ++i)
6315 if (!same_type_p (cand1->convs[i]->type,
6316 cand2->convs[i]->type))
6318 if (i == cand1->num_convs)
6320 if (cand1->fn == cand2->fn)
6321 /* Two built-in candidates; arbitrarily pick one. */
6323 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6324 /* cand1 is built-in; prefer cand2. */
6327 /* cand2 is built-in; prefer cand1. */
6332 /* If the two functions are the same (this can happen with declarations
6333 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6334 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6335 && equal_functions (cand1->fn, cand2->fn))
6340 /* Extension: If the worst conversion for one candidate is worse than the
6341 worst conversion for the other, take the first. */
6344 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6345 struct z_candidate *w = 0, *l = 0;
6347 for (i = 0; i < len; ++i)
6349 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6350 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6351 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6352 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6355 winner = 1, w = cand1, l = cand2;
6357 winner = -1, w = cand2, l = cand1;
6363 ISO C++ says that these are ambiguous, even \
6364 though the worst conversion for the first is better than \
6365 the worst conversion for the second:");
6366 print_z_candidate (_("candidate 1:"), w);
6367 print_z_candidate (_("candidate 2:"), l);
6375 gcc_assert (!winner);
6379 /* Given a list of candidates for overloading, find the best one, if any.
6380 This algorithm has a worst case of O(2n) (winner is last), and a best
6381 case of O(n/2) (totally ambiguous); much better than a sorting
6384 static struct z_candidate *
6385 tourney (struct z_candidate *candidates)
6387 struct z_candidate *champ = candidates, *challenger;
6389 int champ_compared_to_predecessor = 0;
6391 /* Walk through the list once, comparing each current champ to the next
6392 candidate, knocking out a candidate or two with each comparison. */
6394 for (challenger = champ->next; challenger; )
6396 fate = joust (champ, challenger, 0);
6398 challenger = challenger->next;
6403 champ = challenger->next;
6406 champ_compared_to_predecessor = 0;
6411 champ_compared_to_predecessor = 1;
6414 challenger = champ->next;
6418 /* Make sure the champ is better than all the candidates it hasn't yet
6419 been compared to. */
6421 for (challenger = candidates;
6423 && !(champ_compared_to_predecessor && challenger->next == champ);
6424 challenger = challenger->next)
6426 fate = joust (champ, challenger, 0);
6434 /* Returns nonzero if things of type FROM can be converted to TO. */
6437 can_convert (tree to, tree from)
6439 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6442 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6445 can_convert_arg (tree to, tree from, tree arg, int flags)
6451 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6452 p = conversion_obstack_alloc (0);
6454 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6456 ok_p = (t && !t->bad_p);
6458 /* Free all the conversions we allocated. */
6459 obstack_free (&conversion_obstack, p);
6464 /* Like can_convert_arg, but allows dubious conversions as well. */
6467 can_convert_arg_bad (tree to, tree from, tree arg)
6472 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6473 p = conversion_obstack_alloc (0);
6474 /* Try to perform the conversion. */
6475 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6477 /* Free all the conversions we allocated. */
6478 obstack_free (&conversion_obstack, p);
6483 /* Convert EXPR to TYPE. Return the converted expression.
6485 Note that we allow bad conversions here because by the time we get to
6486 this point we are committed to doing the conversion. If we end up
6487 doing a bad conversion, convert_like will complain. */
6490 perform_implicit_conversion (tree type, tree expr)
6495 if (error_operand_p (expr))
6496 return error_mark_node;
6498 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6499 p = conversion_obstack_alloc (0);
6501 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6506 error ("could not convert %qE to %qT", expr, type);
6507 expr = error_mark_node;
6509 else if (processing_template_decl)
6511 /* In a template, we are only concerned about determining the
6512 type of non-dependent expressions, so we do not have to
6513 perform the actual conversion. */
6514 if (TREE_TYPE (expr) != type)
6515 expr = build_nop (type, expr);
6518 expr = convert_like (conv, expr);
6520 /* Free all the conversions we allocated. */
6521 obstack_free (&conversion_obstack, p);
6526 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6527 permitted. If the conversion is valid, the converted expression is
6528 returned. Otherwise, NULL_TREE is returned, except in the case
6529 that TYPE is a class type; in that case, an error is issued. If
6530 C_CAST_P is true, then this direction initialization is taking
6531 place as part of a static_cast being attempted as part of a C-style
6535 perform_direct_initialization_if_possible (tree type,
6542 if (type == error_mark_node || error_operand_p (expr))
6543 return error_mark_node;
6546 If the destination type is a (possibly cv-qualified) class type:
6548 -- If the initialization is direct-initialization ...,
6549 constructors are considered. ... If no constructor applies, or
6550 the overload resolution is ambiguous, the initialization is
6552 if (CLASS_TYPE_P (type))
6554 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6555 build_tree_list (NULL_TREE, expr),
6556 type, LOOKUP_NORMAL);
6557 return build_cplus_new (type, expr);
6560 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6561 p = conversion_obstack_alloc (0);
6563 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6566 if (!conv || conv->bad_p)
6569 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6570 /*issue_conversion_warnings=*/false,
6573 /* Free all the conversions we allocated. */
6574 obstack_free (&conversion_obstack, p);
6579 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6580 is being bound to a temporary. Create and return a new VAR_DECL
6581 with the indicated TYPE; this variable will store the value to
6582 which the reference is bound. */
6585 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6589 /* Create the variable. */
6590 var = create_temporary_var (type);
6592 /* Register the variable. */
6593 if (TREE_STATIC (decl))
6595 /* Namespace-scope or local static; give it a mangled name. */
6598 TREE_STATIC (var) = 1;
6599 name = mangle_ref_init_variable (decl);
6600 DECL_NAME (var) = name;
6601 SET_DECL_ASSEMBLER_NAME (var, name);
6602 var = pushdecl_top_level (var);
6605 /* Create a new cleanup level if necessary. */
6606 maybe_push_cleanup_level (type);
6611 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6612 initializing a variable of that TYPE. If DECL is non-NULL, it is
6613 the VAR_DECL being initialized with the EXPR. (In that case, the
6614 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6615 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6616 return, if *CLEANUP is no longer NULL, it will be an expression
6617 that should be pushed as a cleanup after the returned expression
6618 is used to initialize DECL.
6620 Return the converted expression. */
6623 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6628 if (type == error_mark_node || error_operand_p (expr))
6629 return error_mark_node;
6631 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6632 p = conversion_obstack_alloc (0);
6634 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6635 if (!conv || conv->bad_p)
6637 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6638 && !real_lvalue_p (expr))
6639 error ("invalid initialization of non-const reference of "
6640 "type %qT from a temporary of type %qT",
6641 type, TREE_TYPE (expr));
6643 error ("invalid initialization of reference of type "
6644 "%qT from expression of type %qT", type,
6646 return error_mark_node;
6649 /* If DECL is non-NULL, then this special rule applies:
6653 The temporary to which the reference is bound or the temporary
6654 that is the complete object to which the reference is bound
6655 persists for the lifetime of the reference.
6657 The temporaries created during the evaluation of the expression
6658 initializing the reference, except the temporary to which the
6659 reference is bound, are destroyed at the end of the
6660 full-expression in which they are created.
6662 In that case, we store the converted expression into a new
6663 VAR_DECL in a new scope.
6665 However, we want to be careful not to create temporaries when
6666 they are not required. For example, given:
6669 struct D : public B {};
6673 there is no need to copy the return value from "f"; we can just
6674 extend its lifetime. Similarly, given:
6677 struct T { operator S(); };
6681 we can extend the lifetime of the return value of the conversion
6683 gcc_assert (conv->kind == ck_ref_bind);
6687 tree base_conv_type;
6689 /* Skip over the REF_BIND. */
6690 conv = conv->u.next;
6691 /* If the next conversion is a BASE_CONV, skip that too -- but
6692 remember that the conversion was required. */
6693 if (conv->kind == ck_base)
6695 if (conv->check_copy_constructor_p)
6696 check_constructor_callable (TREE_TYPE (expr), expr);
6697 base_conv_type = conv->type;
6698 conv = conv->u.next;
6701 base_conv_type = NULL_TREE;
6702 /* Perform the remainder of the conversion. */
6703 expr = convert_like_real (conv, expr,
6704 /*fn=*/NULL_TREE, /*argnum=*/0,
6706 /*issue_conversion_warnings=*/true,
6707 /*c_cast_p=*/false);
6708 if (error_operand_p (expr))
6709 expr = error_mark_node;
6712 if (!real_lvalue_p (expr))
6717 /* Create the temporary variable. */
6718 type = TREE_TYPE (expr);
6719 var = make_temporary_var_for_ref_to_temp (decl, type);
6720 layout_decl (var, 0);
6721 /* If the rvalue is the result of a function call it will be
6722 a TARGET_EXPR. If it is some other construct (such as a
6723 member access expression where the underlying object is
6724 itself the result of a function call), turn it into a
6725 TARGET_EXPR here. It is important that EXPR be a
6726 TARGET_EXPR below since otherwise the INIT_EXPR will
6727 attempt to make a bitwise copy of EXPR to initialize
6729 if (TREE_CODE (expr) != TARGET_EXPR)
6730 expr = get_target_expr (expr);
6731 /* Create the INIT_EXPR that will initialize the temporary
6733 init = build2 (INIT_EXPR, type, var, expr);
6734 if (at_function_scope_p ())
6736 add_decl_expr (var);
6737 *cleanup = cxx_maybe_build_cleanup (var);
6739 /* We must be careful to destroy the temporary only
6740 after its initialization has taken place. If the
6741 initialization throws an exception, then the
6742 destructor should not be run. We cannot simply
6743 transform INIT into something like:
6745 (INIT, ({ CLEANUP_STMT; }))
6747 because emit_local_var always treats the
6748 initializer as a full-expression. Thus, the
6749 destructor would run too early; it would run at the
6750 end of initializing the reference variable, rather
6751 than at the end of the block enclosing the
6754 The solution is to pass back a cleanup expression
6755 which the caller is responsible for attaching to
6756 the statement tree. */
6760 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6761 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6762 static_aggregates = tree_cons (NULL_TREE, var,
6765 /* Use its address to initialize the reference variable. */
6766 expr = build_address (var);
6768 expr = convert_to_base (expr,
6769 build_pointer_type (base_conv_type),
6770 /*check_access=*/true,
6772 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6775 /* Take the address of EXPR. */
6776 expr = build_unary_op (ADDR_EXPR, expr, 0);
6777 /* If a BASE_CONV was required, perform it now. */
6779 expr = (perform_implicit_conversion
6780 (build_pointer_type (base_conv_type), expr));
6781 expr = build_nop (type, expr);
6785 /* Perform the conversion. */
6786 expr = convert_like (conv, expr);
6788 /* Free all the conversions we allocated. */
6789 obstack_free (&conversion_obstack, p);
6794 #include "gt-cp-call.h"