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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
5 modified by Brendan Kehoe (brendan@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 /* High-level class interface. */
29 #include "coretypes.h"
38 #include "diagnostic.h"
43 /* The various kinds of conversion. */
45 typedef enum conversion_kind {
59 /* The rank of the conversion. Order of the enumerals matters; better
60 conversions should come earlier in the list. */
62 typedef enum conversion_rank {
73 /* An implicit conversion sequence, in the sense of [over.best.ics].
74 The first conversion to be performed is at the end of the chain.
75 That conversion is always a cr_identity conversion. */
77 typedef struct conversion conversion;
79 /* The kind of conversion represented by this step. */
81 /* The rank of this conversion. */
83 BOOL_BITFIELD user_conv_p : 1;
84 BOOL_BITFIELD ellipsis_p : 1;
85 BOOL_BITFIELD this_p : 1;
86 BOOL_BITFIELD bad_p : 1;
87 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
88 temporary should be created to hold the result of the
90 BOOL_BITFIELD need_temporary_p : 1;
91 /* If KIND is ck_identity or ck_base_conv, true to indicate that the
92 copy constructor must be accessible, even though it is not being
94 BOOL_BITFIELD check_copy_constructor_p : 1;
95 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
96 from a pointer-to-derived to pointer-to-base is being performed. */
97 BOOL_BITFIELD base_p : 1;
98 /* The type of the expression resulting from the conversion. */
101 /* The next conversion in the chain. Since the conversions are
102 arranged from outermost to innermost, the NEXT conversion will
103 actually be performed before this conversion. This variant is
104 used only when KIND is neither ck_identity nor ck_ambig. */
106 /* The expression at the beginning of the conversion chain. This
107 variant is used only if KIND is ck_identity or ck_ambig. */
110 /* The function candidate corresponding to this conversion
111 sequence. This field is only used if KIND is ck_user. */
112 struct z_candidate *cand;
115 #define CONVERSION_RANK(NODE) \
116 ((NODE)->bad_p ? cr_bad \
117 : (NODE)->ellipsis_p ? cr_ellipsis \
118 : (NODE)->user_conv_p ? cr_user \
121 static struct obstack conversion_obstack;
122 static bool conversion_obstack_initialized;
124 static struct z_candidate * tourney (struct z_candidate *);
125 static int equal_functions (tree, tree);
126 static int joust (struct z_candidate *, struct z_candidate *, bool);
127 static int compare_ics (conversion *, conversion *);
128 static tree build_over_call (struct z_candidate *, int);
129 static tree build_java_interface_fn_ref (tree, tree);
130 #define convert_like(CONV, EXPR) \
131 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
132 /*issue_conversion_warnings=*/true, \
134 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
135 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
136 /*issue_conversion_warnings=*/true, \
138 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
140 static void op_error (enum tree_code, enum tree_code, tree, tree,
142 static tree build_object_call (tree, tree);
143 static tree resolve_args (tree);
144 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
145 static void print_z_candidate (const char *, struct z_candidate *);
146 static void print_z_candidates (struct z_candidate *);
147 static tree build_this (tree);
148 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
149 static bool any_strictly_viable (struct z_candidate *);
150 static struct z_candidate *add_template_candidate
151 (struct z_candidate **, tree, tree, tree, tree, tree,
152 tree, tree, int, unification_kind_t);
153 static struct z_candidate *add_template_candidate_real
154 (struct z_candidate **, tree, tree, tree, tree, tree,
155 tree, tree, int, tree, unification_kind_t);
156 static struct z_candidate *add_template_conv_candidate
157 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
158 static void add_builtin_candidates
159 (struct z_candidate **, enum tree_code, enum tree_code,
161 static void add_builtin_candidate
162 (struct z_candidate **, enum tree_code, enum tree_code,
163 tree, tree, tree, tree *, tree *, int);
164 static bool is_complete (tree);
165 static void build_builtin_candidate
166 (struct z_candidate **, tree, tree, tree, tree *, tree *,
168 static struct z_candidate *add_conv_candidate
169 (struct z_candidate **, tree, tree, tree, tree, tree);
170 static struct z_candidate *add_function_candidate
171 (struct z_candidate **, tree, tree, tree, tree, tree, int);
172 static conversion *implicit_conversion (tree, tree, tree, bool, int);
173 static conversion *standard_conversion (tree, tree, tree, bool, int);
174 static conversion *reference_binding (tree, tree, tree, bool, int);
175 static conversion *build_conv (conversion_kind, tree, conversion *);
176 static bool is_subseq (conversion *, conversion *);
177 static tree maybe_handle_ref_bind (conversion **);
178 static void maybe_handle_implicit_object (conversion **);
179 static struct z_candidate *add_candidate
180 (struct z_candidate **, tree, tree, size_t,
181 conversion **, tree, tree, int);
182 static tree source_type (conversion *);
183 static void add_warning (struct z_candidate *, struct z_candidate *);
184 static bool reference_related_p (tree, tree);
185 static bool reference_compatible_p (tree, tree);
186 static conversion *convert_class_to_reference (tree, tree, tree);
187 static conversion *direct_reference_binding (tree, conversion *);
188 static bool promoted_arithmetic_type_p (tree);
189 static conversion *conditional_conversion (tree, tree);
190 static char *name_as_c_string (tree, tree, bool *);
191 static tree call_builtin_trap (void);
192 static tree prep_operand (tree);
193 static void add_candidates (tree, tree, tree, bool, tree, tree,
194 int, struct z_candidate **);
195 static conversion *merge_conversion_sequences (conversion *, conversion *);
196 static bool magic_varargs_p (tree);
197 typedef void (*diagnostic_fn_t) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
198 static tree build_temp (tree, tree, int, diagnostic_fn_t *);
199 static void check_constructor_callable (tree, tree);
201 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
202 NAME can take many forms... */
205 check_dtor_name (tree basetype, tree name)
207 /* Just accept something we've already complained about. */
208 if (name == error_mark_node)
211 if (TREE_CODE (name) == TYPE_DECL)
212 name = TREE_TYPE (name);
213 else if (TYPE_P (name))
215 else if (TREE_CODE (name) == IDENTIFIER_NODE)
217 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
218 || (TREE_CODE (basetype) == ENUMERAL_TYPE
219 && name == TYPE_IDENTIFIER (basetype)))
222 name = get_type_value (name);
228 template <class T> struct S { ~S(); };
232 NAME will be a class template. */
233 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
239 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
242 /* We want the address of a function or method. We avoid creating a
243 pointer-to-member function. */
246 build_addr_func (tree function)
248 tree type = TREE_TYPE (function);
250 /* We have to do these by hand to avoid real pointer to member
252 if (TREE_CODE (type) == METHOD_TYPE)
254 if (TREE_CODE (function) == OFFSET_REF)
256 tree object = build_address (TREE_OPERAND (function, 0));
257 return get_member_function_from_ptrfunc (&object,
258 TREE_OPERAND (function, 1));
260 function = build_address (function);
263 function = decay_conversion (function);
268 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
269 POINTER_TYPE to those. Note, pointer to member function types
270 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
273 build_call (tree function, tree parms)
275 int is_constructor = 0;
282 function = build_addr_func (function);
284 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
285 fntype = TREE_TYPE (TREE_TYPE (function));
286 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
287 || TREE_CODE (fntype) == METHOD_TYPE);
288 result_type = TREE_TYPE (fntype);
290 if (TREE_CODE (function) == ADDR_EXPR
291 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
293 decl = TREE_OPERAND (function, 0);
294 if (!TREE_USED (decl))
296 /* We invoke build_call directly for several library
297 functions. These may have been declared normally if
298 we're building libgcc, so we can't just check
300 gcc_assert (DECL_ARTIFICIAL (decl)
301 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
309 /* We check both the decl and the type; a function may be known not to
310 throw without being declared throw(). */
311 nothrow = ((decl && TREE_NOTHROW (decl))
312 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
314 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
315 current_function_returns_abnormally = 1;
317 if (decl && TREE_DEPRECATED (decl))
318 warn_deprecated_use (decl);
319 require_complete_eh_spec_types (fntype, decl);
321 if (decl && DECL_CONSTRUCTOR_P (decl))
324 /* Don't pass empty class objects by value. This is useful
325 for tags in STL, which are used to control overload resolution.
326 We don't need to handle other cases of copying empty classes. */
327 if (! decl || ! DECL_BUILT_IN (decl))
328 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
329 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
330 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
332 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
333 TREE_VALUE (tmp) = build2 (COMPOUND_EXPR, TREE_TYPE (t),
334 TREE_VALUE (tmp), t);
337 function = build3 (CALL_EXPR, result_type, function, parms, NULL_TREE);
338 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
339 TREE_NOTHROW (function) = nothrow;
344 /* Build something of the form ptr->method (args)
345 or object.method (args). This can also build
346 calls to constructors, and find friends.
348 Member functions always take their class variable
351 INSTANCE is a class instance.
353 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
355 PARMS help to figure out what that NAME really refers to.
357 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
358 down to the real instance type to use for access checking. We need this
359 information to get protected accesses correct.
361 FLAGS is the logical disjunction of zero or more LOOKUP_
362 flags. See cp-tree.h for more info.
364 If this is all OK, calls build_function_call with the resolved
367 This function must also handle being called to perform
368 initialization, promotion/coercion of arguments, and
369 instantiation of default parameters.
371 Note that NAME may refer to an instance variable name. If
372 `operator()()' is defined for the type of that field, then we return
375 /* New overloading code. */
377 typedef struct z_candidate z_candidate;
379 typedef struct candidate_warning candidate_warning;
380 struct candidate_warning {
382 candidate_warning *next;
386 /* The FUNCTION_DECL that will be called if this candidate is
387 selected by overload resolution. */
389 /* The arguments to use when calling this function. */
391 /* The implicit conversion sequences for each of the arguments to
394 /* The number of implicit conversion sequences. */
396 /* If FN is a user-defined conversion, the standard conversion
397 sequence from the type returned by FN to the desired destination
399 conversion *second_conv;
401 /* If FN is a member function, the binfo indicating the path used to
402 qualify the name of FN at the call site. This path is used to
403 determine whether or not FN is accessible if it is selected by
404 overload resolution. The DECL_CONTEXT of FN will always be a
405 (possibly improper) base of this binfo. */
407 /* If FN is a non-static member function, the binfo indicating the
408 subobject to which the `this' pointer should be converted if FN
409 is selected by overload resolution. The type pointed to the by
410 the `this' pointer must correspond to the most derived class
411 indicated by the CONVERSION_PATH. */
412 tree conversion_path;
414 candidate_warning *warnings;
418 /* Returns true iff T is a null pointer constant in the sense of
422 null_ptr_cst_p (tree t)
426 A null pointer constant is an integral constant expression
427 (_expr.const_) rvalue of integer type that evaluates to zero. */
428 t = integral_constant_value (t);
431 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
434 if (!TREE_CONSTANT_OVERFLOW (t))
440 /* Returns nonzero if PARMLIST consists of only default parms and/or
444 sufficient_parms_p (tree parmlist)
446 for (; parmlist && parmlist != void_list_node;
447 parmlist = TREE_CHAIN (parmlist))
448 if (!TREE_PURPOSE (parmlist))
453 /* Allocate N bytes of memory from the conversion obstack. The memory
454 is zeroed before being returned. */
457 conversion_obstack_alloc (size_t n)
460 if (!conversion_obstack_initialized)
462 gcc_obstack_init (&conversion_obstack);
463 conversion_obstack_initialized = true;
465 p = obstack_alloc (&conversion_obstack, n);
470 /* Dynamically allocate a conversion. */
473 alloc_conversion (conversion_kind kind)
476 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
481 #ifdef ENABLE_CHECKING
483 /* Make sure that all memory on the conversion obstack has been
487 validate_conversion_obstack (void)
489 if (conversion_obstack_initialized)
490 gcc_assert ((obstack_next_free (&conversion_obstack)
491 == obstack_base (&conversion_obstack)));
494 #endif /* ENABLE_CHECKING */
496 /* Dynamically allocate an array of N conversions. */
499 alloc_conversions (size_t n)
501 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
505 build_conv (conversion_kind code, tree type, conversion *from)
508 conversion_rank rank = CONVERSION_RANK (from);
510 /* We can't use buildl1 here because CODE could be USER_CONV, which
511 takes two arguments. In that case, the caller is responsible for
512 filling in the second argument. */
513 t = alloc_conversion (code);
536 t->user_conv_p = (code == ck_user || from->user_conv_p);
537 t->bad_p = from->bad_p;
542 /* Build a representation of the identity conversion from EXPR to
543 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
546 build_identity_conv (tree type, tree expr)
550 c = alloc_conversion (ck_identity);
557 /* Converting from EXPR to TYPE was ambiguous in the sense that there
558 were multiple user-defined conversions to accomplish the job.
559 Build a conversion that indicates that ambiguity. */
562 build_ambiguous_conv (tree type, tree expr)
566 c = alloc_conversion (ck_ambig);
574 strip_top_quals (tree t)
576 if (TREE_CODE (t) == ARRAY_TYPE)
578 return cp_build_qualified_type (t, 0);
581 /* Returns the standard conversion path (see [conv]) from type FROM to type
582 TO, if any. For proper handling of null pointer constants, you must
583 also pass the expression EXPR to convert from. If C_CAST_P is true,
584 this conversion is coming from a C-style cast. */
587 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
590 enum tree_code fcode, tcode;
592 bool fromref = false;
594 to = non_reference (to);
595 if (TREE_CODE (from) == REFERENCE_TYPE)
598 from = TREE_TYPE (from);
600 to = strip_top_quals (to);
601 from = strip_top_quals (from);
603 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
604 && expr && type_unknown_p (expr))
606 expr = instantiate_type (to, expr, tf_conv);
607 if (expr == error_mark_node)
609 from = TREE_TYPE (expr);
612 fcode = TREE_CODE (from);
613 tcode = TREE_CODE (to);
615 conv = build_identity_conv (from, expr);
616 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
618 from = type_decays_to (from);
619 fcode = TREE_CODE (from);
620 conv = build_conv (ck_lvalue, from, conv);
622 else if (fromref || (expr && lvalue_p (expr)))
627 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
630 from = strip_top_quals (bitfield_type);
631 fcode = TREE_CODE (from);
634 conv = build_conv (ck_rvalue, from, conv);
637 /* Allow conversion between `__complex__' data types. */
638 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
640 /* The standard conversion sequence to convert FROM to TO is
641 the standard conversion sequence to perform componentwise
643 conversion *part_conv = standard_conversion
644 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
648 conv = build_conv (part_conv->kind, to, conv);
649 conv->rank = part_conv->rank;
657 if (same_type_p (from, to))
660 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
661 && expr && null_ptr_cst_p (expr))
662 conv = build_conv (ck_std, to, conv);
663 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
664 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
666 /* For backwards brain damage compatibility, allow interconversion of
667 pointers and integers with a pedwarn. */
668 conv = build_conv (ck_std, to, conv);
671 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
673 /* For backwards brain damage compatibility, allow interconversion of
674 enums and integers with a pedwarn. */
675 conv = build_conv (ck_std, to, conv);
678 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
679 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
684 if (tcode == POINTER_TYPE
685 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
688 else if (VOID_TYPE_P (TREE_TYPE (to))
689 && !TYPE_PTRMEM_P (from)
690 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
692 from = build_pointer_type
693 (cp_build_qualified_type (void_type_node,
694 cp_type_quals (TREE_TYPE (from))));
695 conv = build_conv (ck_ptr, from, conv);
697 else if (TYPE_PTRMEM_P (from))
699 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
700 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
702 if (DERIVED_FROM_P (fbase, tbase)
703 && (same_type_ignoring_top_level_qualifiers_p
704 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
705 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
707 from = build_ptrmem_type (tbase,
708 TYPE_PTRMEM_POINTED_TO_TYPE (from));
709 conv = build_conv (ck_pmem, from, conv);
711 else if (!same_type_p (fbase, tbase))
714 else if (IS_AGGR_TYPE (TREE_TYPE (from))
715 && IS_AGGR_TYPE (TREE_TYPE (to))
718 An rvalue of type "pointer to cv D," where D is a
719 class type, can be converted to an rvalue of type
720 "pointer to cv B," where B is a base class (clause
721 _class.derived_) of D. If B is an inaccessible
722 (clause _class.access_) or ambiguous
723 (_class.member.lookup_) base class of D, a program
724 that necessitates this conversion is ill-formed.
725 Therefore, we use DERIVED_FROM_P, and do not check
726 access or uniqueness. */
727 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from))
728 /* If FROM is not yet complete, then we must be parsing
729 the body of a class. We know what's derived from
730 what, but we can't actually perform a
731 derived-to-base conversion. For example, in:
733 struct D : public B {
734 static const int i = sizeof((B*)(D*)0);
737 the D*-to-B* conversion is a reinterpret_cast, not a
739 && COMPLETE_TYPE_P (TREE_TYPE (from)))
742 cp_build_qualified_type (TREE_TYPE (to),
743 cp_type_quals (TREE_TYPE (from)));
744 from = build_pointer_type (from);
745 conv = build_conv (ck_ptr, from, conv);
749 if (tcode == POINTER_TYPE)
751 to_pointee = TREE_TYPE (to);
752 from_pointee = TREE_TYPE (from);
756 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
757 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
760 if (same_type_p (from, to))
762 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
763 /* In a C-style cast, we ignore CV-qualification because we
764 are allowed to perform a static_cast followed by a
766 conv = build_conv (ck_qual, to, conv);
767 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
768 conv = build_conv (ck_qual, to, conv);
769 else if (expr && string_conv_p (to, expr, 0))
770 /* converting from string constant to char *. */
771 conv = build_conv (ck_qual, to, conv);
772 else if (ptr_reasonably_similar (to_pointee, from_pointee))
774 conv = build_conv (ck_ptr, to, conv);
782 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
784 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
785 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
786 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
787 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
789 if (!DERIVED_FROM_P (fbase, tbase)
790 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
791 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
792 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
793 || cp_type_quals (fbase) != cp_type_quals (tbase))
796 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
797 from = build_method_type_directly (from,
799 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
800 from = build_ptrmemfunc_type (build_pointer_type (from));
801 conv = build_conv (ck_pmem, from, conv);
804 else if (tcode == BOOLEAN_TYPE)
808 An rvalue of arithmetic, enumeration, pointer, or pointer to
809 member type can be converted to an rvalue of type bool. */
810 if (ARITHMETIC_TYPE_P (from)
811 || fcode == ENUMERAL_TYPE
812 || fcode == POINTER_TYPE
813 || TYPE_PTR_TO_MEMBER_P (from))
815 conv = build_conv (ck_std, to, conv);
816 if (fcode == POINTER_TYPE
817 || TYPE_PTRMEM_P (from)
818 || (TYPE_PTRMEMFUNC_P (from)
819 && conv->rank < cr_pbool))
820 conv->rank = cr_pbool;
826 /* We don't check for ENUMERAL_TYPE here because there are no standard
827 conversions to enum type. */
828 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
829 || tcode == REAL_TYPE)
831 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
833 conv = build_conv (ck_std, to, conv);
835 /* Give this a better rank if it's a promotion. */
836 if (same_type_p (to, type_promotes_to (from))
837 && conv->u.next->rank <= cr_promotion)
838 conv->rank = cr_promotion;
840 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
841 && vector_types_convertible_p (from, to))
842 return build_conv (ck_std, to, conv);
843 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
844 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
845 && is_properly_derived_from (from, to))
847 if (conv->kind == ck_rvalue)
849 conv = build_conv (ck_base, to, conv);
850 /* The derived-to-base conversion indicates the initialization
851 of a parameter with base type from an object of a derived
852 type. A temporary object is created to hold the result of
854 conv->need_temporary_p = true;
862 /* Returns nonzero if T1 is reference-related to T2. */
865 reference_related_p (tree t1, tree t2)
867 t1 = TYPE_MAIN_VARIANT (t1);
868 t2 = TYPE_MAIN_VARIANT (t2);
872 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
873 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
875 return (same_type_p (t1, t2)
876 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
877 && DERIVED_FROM_P (t1, t2)));
880 /* Returns nonzero if T1 is reference-compatible with T2. */
883 reference_compatible_p (tree t1, tree t2)
887 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
888 reference-related to T2 and cv1 is the same cv-qualification as,
889 or greater cv-qualification than, cv2. */
890 return (reference_related_p (t1, t2)
891 && at_least_as_qualified_p (t1, t2));
894 /* Determine whether or not the EXPR (of class type S) can be
895 converted to T as in [over.match.ref]. */
898 convert_class_to_reference (tree t, tree s, tree expr)
904 struct z_candidate *candidates;
905 struct z_candidate *cand;
908 conversions = lookup_conversions (s);
914 Assuming that "cv1 T" is the underlying type of the reference
915 being initialized, and "cv S" is the type of the initializer
916 expression, with S a class type, the candidate functions are
919 --The conversion functions of S and its base classes are
920 considered. Those that are not hidden within S and yield type
921 "reference to cv2 T2", where "cv1 T" is reference-compatible
922 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
924 The argument list has one argument, which is the initializer
929 /* Conceptually, we should take the address of EXPR and put it in
930 the argument list. Unfortunately, however, that can result in
931 error messages, which we should not issue now because we are just
932 trying to find a conversion operator. Therefore, we use NULL,
933 cast to the appropriate type. */
934 arglist = build_int_cst (build_pointer_type (s), 0);
935 arglist = build_tree_list (NULL_TREE, arglist);
937 reference_type = build_reference_type (t);
941 tree fns = TREE_VALUE (conversions);
943 for (; fns; fns = OVL_NEXT (fns))
945 tree f = OVL_CURRENT (fns);
946 tree t2 = TREE_TYPE (TREE_TYPE (f));
950 /* If this is a template function, try to get an exact
952 if (TREE_CODE (f) == TEMPLATE_DECL)
954 cand = add_template_candidate (&candidates,
960 TREE_PURPOSE (conversions),
966 /* Now, see if the conversion function really returns
967 an lvalue of the appropriate type. From the
968 point of view of unification, simply returning an
969 rvalue of the right type is good enough. */
971 t2 = TREE_TYPE (TREE_TYPE (f));
972 if (TREE_CODE (t2) != REFERENCE_TYPE
973 || !reference_compatible_p (t, TREE_TYPE (t2)))
975 candidates = candidates->next;
980 else if (TREE_CODE (t2) == REFERENCE_TYPE
981 && reference_compatible_p (t, TREE_TYPE (t2)))
982 cand = add_function_candidate (&candidates, f, s, arglist,
984 TREE_PURPOSE (conversions),
989 conversion *identity_conv;
990 /* Build a standard conversion sequence indicating the
991 binding from the reference type returned by the
992 function to the desired REFERENCE_TYPE. */
994 = build_identity_conv (TREE_TYPE (TREE_TYPE
995 (TREE_TYPE (cand->fn))),
998 = (direct_reference_binding
999 (reference_type, identity_conv));
1000 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1003 conversions = TREE_CHAIN (conversions);
1006 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1007 /* If none of the conversion functions worked out, let our caller
1012 cand = tourney (candidates);
1016 /* Now that we know that this is the function we're going to use fix
1017 the dummy first argument. */
1018 cand->args = tree_cons (NULL_TREE,
1020 TREE_CHAIN (cand->args));
1022 /* Build a user-defined conversion sequence representing the
1024 conv = build_conv (ck_user,
1025 TREE_TYPE (TREE_TYPE (cand->fn)),
1026 build_identity_conv (TREE_TYPE (expr), expr));
1029 /* Merge it with the standard conversion sequence from the
1030 conversion function's return type to the desired type. */
1031 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1033 if (cand->viable == -1)
1036 return cand->second_conv;
1039 /* A reference of the indicated TYPE is being bound directly to the
1040 expression represented by the implicit conversion sequence CONV.
1041 Return a conversion sequence for this binding. */
1044 direct_reference_binding (tree type, conversion *conv)
1048 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1049 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1051 t = TREE_TYPE (type);
1055 When a parameter of reference type binds directly
1056 (_dcl.init.ref_) to an argument expression, the implicit
1057 conversion sequence is the identity conversion, unless the
1058 argument expression has a type that is a derived class of the
1059 parameter type, in which case the implicit conversion sequence is
1060 a derived-to-base Conversion.
1062 If the parameter binds directly to the result of applying a
1063 conversion function to the argument expression, the implicit
1064 conversion sequence is a user-defined conversion sequence
1065 (_over.ics.user_), with the second standard conversion sequence
1066 either an identity conversion or, if the conversion function
1067 returns an entity of a type that is a derived class of the
1068 parameter type, a derived-to-base conversion. */
1069 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1071 /* Represent the derived-to-base conversion. */
1072 conv = build_conv (ck_base, t, conv);
1073 /* We will actually be binding to the base-class subobject in
1074 the derived class, so we mark this conversion appropriately.
1075 That way, convert_like knows not to generate a temporary. */
1076 conv->need_temporary_p = false;
1078 return build_conv (ck_ref_bind, type, conv);
1081 /* Returns the conversion path from type FROM to reference type TO for
1082 purposes of reference binding. For lvalue binding, either pass a
1083 reference type to FROM or an lvalue expression to EXPR. If the
1084 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1085 the conversion returned. If C_CAST_P is true, this
1086 conversion is coming from a C-style cast. */
1089 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1091 conversion *conv = NULL;
1092 tree to = TREE_TYPE (rto);
1096 cp_lvalue_kind lvalue_p = clk_none;
1098 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1100 expr = instantiate_type (to, expr, tf_none);
1101 if (expr == error_mark_node)
1103 from = TREE_TYPE (expr);
1106 if (TREE_CODE (from) == REFERENCE_TYPE)
1108 /* Anything with reference type is an lvalue. */
1109 lvalue_p = clk_ordinary;
1110 from = TREE_TYPE (from);
1113 lvalue_p = real_lvalue_p (expr);
1115 /* Figure out whether or not the types are reference-related and
1116 reference compatible. We have do do this after stripping
1117 references from FROM. */
1118 related_p = reference_related_p (to, from);
1119 /* If this is a C cast, first convert to an appropriately qualified
1120 type, so that we can later do a const_cast to the desired type. */
1121 if (related_p && c_cast_p
1122 && !at_least_as_qualified_p (to, from))
1123 to = build_qualified_type (to, cp_type_quals (from));
1124 compatible_p = reference_compatible_p (to, from);
1126 if (lvalue_p && compatible_p)
1130 If the initializer expression
1132 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1133 is reference-compatible with "cv2 T2,"
1135 the reference is bound directly to the initializer expression
1137 conv = build_identity_conv (from, expr);
1138 conv = direct_reference_binding (rto, conv);
1139 if ((lvalue_p & clk_bitfield) != 0
1140 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1141 /* For the purposes of overload resolution, we ignore the fact
1142 this expression is a bitfield or packed field. (In particular,
1143 [over.ics.ref] says specifically that a function with a
1144 non-const reference parameter is viable even if the
1145 argument is a bitfield.)
1147 However, when we actually call the function we must create
1148 a temporary to which to bind the reference. If the
1149 reference is volatile, or isn't const, then we cannot make
1150 a temporary, so we just issue an error when the conversion
1152 conv->need_temporary_p = true;
1156 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1160 If the initializer expression
1162 -- has a class type (i.e., T2 is a class type) can be
1163 implicitly converted to an lvalue of type "cv3 T3," where
1164 "cv1 T1" is reference-compatible with "cv3 T3". (this
1165 conversion is selected by enumerating the applicable
1166 conversion functions (_over.match.ref_) and choosing the
1167 best one through overload resolution. (_over.match_).
1169 the reference is bound to the lvalue result of the conversion
1170 in the second case. */
1171 conv = convert_class_to_reference (to, from, expr);
1176 /* From this point on, we conceptually need temporaries, even if we
1177 elide them. Only the cases above are "direct bindings". */
1178 if (flags & LOOKUP_NO_TEMP_BIND)
1183 When a parameter of reference type is not bound directly to an
1184 argument expression, the conversion sequence is the one required
1185 to convert the argument expression to the underlying type of the
1186 reference according to _over.best.ics_. Conceptually, this
1187 conversion sequence corresponds to copy-initializing a temporary
1188 of the underlying type with the argument expression. Any
1189 difference in top-level cv-qualification is subsumed by the
1190 initialization itself and does not constitute a conversion. */
1194 Otherwise, the reference shall be to a non-volatile const type. */
1195 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1200 If the initializer expression is an rvalue, with T2 a class type,
1201 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1202 is bound in one of the following ways:
1204 -- The reference is bound to the object represented by the rvalue
1205 or to a sub-object within that object.
1209 We use the first alternative. The implicit conversion sequence
1210 is supposed to be same as we would obtain by generating a
1211 temporary. Fortunately, if the types are reference compatible,
1212 then this is either an identity conversion or the derived-to-base
1213 conversion, just as for direct binding. */
1214 if (CLASS_TYPE_P (from) && compatible_p)
1216 conv = build_identity_conv (from, expr);
1217 conv = direct_reference_binding (rto, conv);
1218 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1219 conv->u.next->check_copy_constructor_p = true;
1225 Otherwise, a temporary of type "cv1 T1" is created and
1226 initialized from the initializer expression using the rules for a
1227 non-reference copy initialization. If T1 is reference-related to
1228 T2, cv1 must be the same cv-qualification as, or greater
1229 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1230 if (related_p && !at_least_as_qualified_p (to, from))
1233 conv = implicit_conversion (to, from, expr, c_cast_p,
1238 conv = build_conv (ck_ref_bind, rto, conv);
1239 /* This reference binding, unlike those above, requires the
1240 creation of a temporary. */
1241 conv->need_temporary_p = true;
1246 /* Returns the implicit conversion sequence (see [over.ics]) from type
1247 FROM to type TO. The optional expression EXPR may affect the
1248 conversion. FLAGS are the usual overloading flags. Only
1249 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1250 conversion is coming from a C-style cast. */
1253 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1258 if (from == error_mark_node || to == error_mark_node
1259 || expr == error_mark_node)
1262 if (TREE_CODE (to) == REFERENCE_TYPE)
1263 conv = reference_binding (to, from, expr, c_cast_p, flags);
1265 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1270 if (expr != NULL_TREE
1271 && (IS_AGGR_TYPE (from)
1272 || IS_AGGR_TYPE (to))
1273 && (flags & LOOKUP_NO_CONVERSION) == 0)
1275 struct z_candidate *cand;
1277 cand = build_user_type_conversion_1
1278 (to, expr, LOOKUP_ONLYCONVERTING);
1280 conv = cand->second_conv;
1282 /* We used to try to bind a reference to a temporary here, but that
1283 is now handled by the recursive call to this function at the end
1284 of reference_binding. */
1291 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1294 static struct z_candidate *
1295 add_candidate (struct z_candidate **candidates,
1297 size_t num_convs, conversion **convs,
1298 tree access_path, tree conversion_path,
1301 struct z_candidate *cand = (struct z_candidate *)
1302 conversion_obstack_alloc (sizeof (struct z_candidate));
1306 cand->convs = convs;
1307 cand->num_convs = num_convs;
1308 cand->access_path = access_path;
1309 cand->conversion_path = conversion_path;
1310 cand->viable = viable;
1311 cand->next = *candidates;
1317 /* Create an overload candidate for the function or method FN called with
1318 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1319 to implicit_conversion.
1321 CTYPE, if non-NULL, is the type we want to pretend this function
1322 comes from for purposes of overload resolution. */
1324 static struct z_candidate *
1325 add_function_candidate (struct z_candidate **candidates,
1326 tree fn, tree ctype, tree arglist,
1327 tree access_path, tree conversion_path,
1330 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1333 tree parmnode, argnode;
1337 /* At this point we should not see any functions which haven't been
1338 explicitly declared, except for friend functions which will have
1339 been found using argument dependent lookup. */
1340 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1342 /* The `this', `in_chrg' and VTT arguments to constructors are not
1343 considered in overload resolution. */
1344 if (DECL_CONSTRUCTOR_P (fn))
1346 parmlist = skip_artificial_parms_for (fn, parmlist);
1347 orig_arglist = arglist;
1348 arglist = skip_artificial_parms_for (fn, arglist);
1351 orig_arglist = arglist;
1353 len = list_length (arglist);
1354 convs = alloc_conversions (len);
1356 /* 13.3.2 - Viable functions [over.match.viable]
1357 First, to be a viable function, a candidate function shall have enough
1358 parameters to agree in number with the arguments in the list.
1360 We need to check this first; otherwise, checking the ICSes might cause
1361 us to produce an ill-formed template instantiation. */
1363 parmnode = parmlist;
1364 for (i = 0; i < len; ++i)
1366 if (parmnode == NULL_TREE || parmnode == void_list_node)
1368 parmnode = TREE_CHAIN (parmnode);
1371 if (i < len && parmnode)
1374 /* Make sure there are default args for the rest of the parms. */
1375 else if (!sufficient_parms_p (parmnode))
1381 /* Second, for F to be a viable function, there shall exist for each
1382 argument an implicit conversion sequence that converts that argument
1383 to the corresponding parameter of F. */
1385 parmnode = parmlist;
1388 for (i = 0; i < len; ++i)
1390 tree arg = TREE_VALUE (argnode);
1391 tree argtype = lvalue_type (arg);
1395 if (parmnode == void_list_node)
1398 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1399 && ! DECL_CONSTRUCTOR_P (fn));
1403 tree parmtype = TREE_VALUE (parmnode);
1405 /* The type of the implicit object parameter ('this') for
1406 overload resolution is not always the same as for the
1407 function itself; conversion functions are considered to
1408 be members of the class being converted, and functions
1409 introduced by a using-declaration are considered to be
1410 members of the class that uses them.
1412 Since build_over_call ignores the ICS for the `this'
1413 parameter, we can just change the parm type. */
1414 if (ctype && is_this)
1417 = build_qualified_type (ctype,
1418 TYPE_QUALS (TREE_TYPE (parmtype)));
1419 parmtype = build_pointer_type (parmtype);
1422 t = implicit_conversion (parmtype, argtype, arg,
1423 /*c_cast_p=*/false, flags);
1427 t = build_identity_conv (argtype, arg);
1428 t->ellipsis_p = true;
1445 parmnode = TREE_CHAIN (parmnode);
1446 argnode = TREE_CHAIN (argnode);
1450 return add_candidate (candidates, fn, orig_arglist, len, convs,
1451 access_path, conversion_path, viable);
1454 /* Create an overload candidate for the conversion function FN which will
1455 be invoked for expression OBJ, producing a pointer-to-function which
1456 will in turn be called with the argument list ARGLIST, and add it to
1457 CANDIDATES. FLAGS is passed on to implicit_conversion.
1459 Actually, we don't really care about FN; we care about the type it
1460 converts to. There may be multiple conversion functions that will
1461 convert to that type, and we rely on build_user_type_conversion_1 to
1462 choose the best one; so when we create our candidate, we record the type
1463 instead of the function. */
1465 static struct z_candidate *
1466 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1467 tree arglist, tree access_path, tree conversion_path)
1469 tree totype = TREE_TYPE (TREE_TYPE (fn));
1470 int i, len, viable, flags;
1471 tree parmlist, parmnode, argnode;
1474 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1475 parmlist = TREE_TYPE (parmlist);
1476 parmlist = TYPE_ARG_TYPES (parmlist);
1478 len = list_length (arglist) + 1;
1479 convs = alloc_conversions (len);
1480 parmnode = parmlist;
1483 flags = LOOKUP_NORMAL;
1485 /* Don't bother looking up the same type twice. */
1486 if (*candidates && (*candidates)->fn == totype)
1489 for (i = 0; i < len; ++i)
1491 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1492 tree argtype = lvalue_type (arg);
1496 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1498 else if (parmnode == void_list_node)
1501 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1502 /*c_cast_p=*/false, flags);
1505 t = build_identity_conv (argtype, arg);
1506 t->ellipsis_p = true;
1520 parmnode = TREE_CHAIN (parmnode);
1521 argnode = TREE_CHAIN (argnode);
1527 if (!sufficient_parms_p (parmnode))
1530 return add_candidate (candidates, totype, arglist, len, convs,
1531 access_path, conversion_path, viable);
1535 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1536 tree type1, tree type2, tree *args, tree *argtypes,
1548 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1549 convs = alloc_conversions (num_convs);
1551 for (i = 0; i < 2; ++i)
1556 t = implicit_conversion (types[i], argtypes[i], args[i],
1557 /*c_cast_p=*/false, flags);
1561 /* We need something for printing the candidate. */
1562 t = build_identity_conv (types[i], NULL_TREE);
1569 /* For COND_EXPR we rearranged the arguments; undo that now. */
1572 convs[2] = convs[1];
1573 convs[1] = convs[0];
1574 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1575 /*c_cast_p=*/false, flags);
1582 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1584 /*access_path=*/NULL_TREE,
1585 /*conversion_path=*/NULL_TREE,
1590 is_complete (tree t)
1592 return COMPLETE_TYPE_P (complete_type (t));
1595 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1598 promoted_arithmetic_type_p (tree type)
1602 In this section, the term promoted integral type is used to refer
1603 to those integral types which are preserved by integral promotion
1604 (including e.g. int and long but excluding e.g. char).
1605 Similarly, the term promoted arithmetic type refers to promoted
1606 integral types plus floating types. */
1607 return ((INTEGRAL_TYPE_P (type)
1608 && same_type_p (type_promotes_to (type), type))
1609 || TREE_CODE (type) == REAL_TYPE);
1612 /* Create any builtin operator overload candidates for the operator in
1613 question given the converted operand types TYPE1 and TYPE2. The other
1614 args are passed through from add_builtin_candidates to
1615 build_builtin_candidate.
1617 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1618 If CODE is requires candidates operands of the same type of the kind
1619 of which TYPE1 and TYPE2 are, we add both candidates
1620 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1623 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1624 enum tree_code code2, tree fnname, tree type1,
1625 tree type2, tree *args, tree *argtypes, int flags)
1629 case POSTINCREMENT_EXPR:
1630 case POSTDECREMENT_EXPR:
1631 args[1] = integer_zero_node;
1632 type2 = integer_type_node;
1641 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1642 and VQ is either volatile or empty, there exist candidate operator
1643 functions of the form
1644 VQ T& operator++(VQ T&);
1645 T operator++(VQ T&, int);
1646 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1647 type other than bool, and VQ is either volatile or empty, there exist
1648 candidate operator functions of the form
1649 VQ T& operator--(VQ T&);
1650 T operator--(VQ T&, int);
1651 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1652 complete object type, and VQ is either volatile or empty, there exist
1653 candidate operator functions of the form
1654 T*VQ& operator++(T*VQ&);
1655 T*VQ& operator--(T*VQ&);
1656 T* operator++(T*VQ&, int);
1657 T* operator--(T*VQ&, int); */
1659 case POSTDECREMENT_EXPR:
1660 case PREDECREMENT_EXPR:
1661 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1663 case POSTINCREMENT_EXPR:
1664 case PREINCREMENT_EXPR:
1665 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1667 type1 = build_reference_type (type1);
1672 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1673 exist candidate operator functions of the form
1677 8 For every function type T, there exist candidate operator functions of
1679 T& operator*(T*); */
1682 if (TREE_CODE (type1) == POINTER_TYPE
1683 && (TYPE_PTROB_P (type1)
1684 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1688 /* 9 For every type T, there exist candidate operator functions of the form
1691 10For every promoted arithmetic type T, there exist candidate operator
1692 functions of the form
1696 case UNARY_PLUS_EXPR: /* unary + */
1697 if (TREE_CODE (type1) == POINTER_TYPE)
1700 if (ARITHMETIC_TYPE_P (type1))
1704 /* 11For every promoted integral type T, there exist candidate operator
1705 functions of the form
1709 if (INTEGRAL_TYPE_P (type1))
1713 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1714 is the same type as C2 or is a derived class of C2, T is a complete
1715 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1716 there exist candidate operator functions of the form
1717 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1718 where CV12 is the union of CV1 and CV2. */
1721 if (TREE_CODE (type1) == POINTER_TYPE
1722 && TYPE_PTR_TO_MEMBER_P (type2))
1724 tree c1 = TREE_TYPE (type1);
1725 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1727 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1728 && (TYPE_PTRMEMFUNC_P (type2)
1729 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1734 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1735 didate operator functions of the form
1740 bool operator<(L, R);
1741 bool operator>(L, R);
1742 bool operator<=(L, R);
1743 bool operator>=(L, R);
1744 bool operator==(L, R);
1745 bool operator!=(L, R);
1746 where LR is the result of the usual arithmetic conversions between
1749 14For every pair of types T and I, where T is a cv-qualified or cv-
1750 unqualified complete object type and I is a promoted integral type,
1751 there exist candidate operator functions of the form
1752 T* operator+(T*, I);
1753 T& operator[](T*, I);
1754 T* operator-(T*, I);
1755 T* operator+(I, T*);
1756 T& operator[](I, T*);
1758 15For every T, where T is a pointer to complete object type, there exist
1759 candidate operator functions of the form112)
1760 ptrdiff_t operator-(T, T);
1762 16For every pointer or enumeration type T, there exist candidate operator
1763 functions of the form
1764 bool operator<(T, T);
1765 bool operator>(T, T);
1766 bool operator<=(T, T);
1767 bool operator>=(T, T);
1768 bool operator==(T, T);
1769 bool operator!=(T, T);
1771 17For every pointer to member type T, there exist candidate operator
1772 functions of the form
1773 bool operator==(T, T);
1774 bool operator!=(T, T); */
1777 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1779 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1781 type2 = ptrdiff_type_node;
1785 case TRUNC_DIV_EXPR:
1786 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1792 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1793 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1795 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1800 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1812 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1814 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1816 if (TREE_CODE (type1) == ENUMERAL_TYPE
1817 && TREE_CODE (type2) == ENUMERAL_TYPE)
1819 if (TYPE_PTR_P (type1)
1820 && null_ptr_cst_p (args[1])
1821 && !uses_template_parms (type1))
1826 if (null_ptr_cst_p (args[0])
1827 && TYPE_PTR_P (type2)
1828 && !uses_template_parms (type2))
1836 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1839 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1841 type1 = ptrdiff_type_node;
1844 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1846 type2 = ptrdiff_type_node;
1851 /* 18For every pair of promoted integral types L and R, there exist candi-
1852 date operator functions of the form
1859 where LR is the result of the usual arithmetic conversions between
1862 case TRUNC_MOD_EXPR:
1868 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1872 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1873 type, VQ is either volatile or empty, and R is a promoted arithmetic
1874 type, there exist candidate operator functions of the form
1875 VQ L& operator=(VQ L&, R);
1876 VQ L& operator*=(VQ L&, R);
1877 VQ L& operator/=(VQ L&, R);
1878 VQ L& operator+=(VQ L&, R);
1879 VQ L& operator-=(VQ L&, R);
1881 20For every pair T, VQ), where T is any type and VQ is either volatile
1882 or empty, there exist candidate operator functions of the form
1883 T*VQ& operator=(T*VQ&, T*);
1885 21For every pair T, VQ), where T is a pointer to member type and VQ is
1886 either volatile or empty, there exist candidate operator functions of
1888 VQ T& operator=(VQ T&, T);
1890 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1891 unqualified complete object type, VQ is either volatile or empty, and
1892 I is a promoted integral type, there exist candidate operator func-
1894 T*VQ& operator+=(T*VQ&, I);
1895 T*VQ& operator-=(T*VQ&, I);
1897 23For every triple L, VQ, R), where L is an integral or enumeration
1898 type, VQ is either volatile or empty, and R is a promoted integral
1899 type, there exist candidate operator functions of the form
1901 VQ L& operator%=(VQ L&, R);
1902 VQ L& operator<<=(VQ L&, R);
1903 VQ L& operator>>=(VQ L&, R);
1904 VQ L& operator&=(VQ L&, R);
1905 VQ L& operator^=(VQ L&, R);
1906 VQ L& operator|=(VQ L&, R); */
1913 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1915 type2 = ptrdiff_type_node;
1919 case TRUNC_DIV_EXPR:
1920 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1924 case TRUNC_MOD_EXPR:
1930 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1935 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1937 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1938 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1939 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1940 || ((TYPE_PTRMEMFUNC_P (type1)
1941 || TREE_CODE (type1) == POINTER_TYPE)
1942 && null_ptr_cst_p (args[1])))
1952 type1 = build_reference_type (type1);
1958 For every pair of promoted arithmetic types L and R, there
1959 exist candidate operator functions of the form
1961 LR operator?(bool, L, R);
1963 where LR is the result of the usual arithmetic conversions
1964 between types L and R.
1966 For every type T, where T is a pointer or pointer-to-member
1967 type, there exist candidate operator functions of the form T
1968 operator?(bool, T, T); */
1970 if (promoted_arithmetic_type_p (type1)
1971 && promoted_arithmetic_type_p (type2))
1975 /* Otherwise, the types should be pointers. */
1976 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1977 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1980 /* We don't check that the two types are the same; the logic
1981 below will actually create two candidates; one in which both
1982 parameter types are TYPE1, and one in which both parameter
1990 /* If we're dealing with two pointer types or two enumeral types,
1991 we need candidates for both of them. */
1992 if (type2 && !same_type_p (type1, type2)
1993 && TREE_CODE (type1) == TREE_CODE (type2)
1994 && (TREE_CODE (type1) == REFERENCE_TYPE
1995 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1996 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1997 || TYPE_PTRMEMFUNC_P (type1)
1998 || IS_AGGR_TYPE (type1)
1999 || TREE_CODE (type1) == ENUMERAL_TYPE))
2001 build_builtin_candidate
2002 (candidates, fnname, type1, type1, args, argtypes, flags);
2003 build_builtin_candidate
2004 (candidates, fnname, type2, type2, args, argtypes, flags);
2008 build_builtin_candidate
2009 (candidates, fnname, type1, type2, args, argtypes, flags);
2013 type_decays_to (tree type)
2015 if (TREE_CODE (type) == ARRAY_TYPE)
2016 return build_pointer_type (TREE_TYPE (type));
2017 if (TREE_CODE (type) == FUNCTION_TYPE)
2018 return build_pointer_type (type);
2022 /* There are three conditions of builtin candidates:
2024 1) bool-taking candidates. These are the same regardless of the input.
2025 2) pointer-pair taking candidates. These are generated for each type
2026 one of the input types converts to.
2027 3) arithmetic candidates. According to the standard, we should generate
2028 all of these, but I'm trying not to...
2030 Here we generate a superset of the possible candidates for this particular
2031 case. That is a subset of the full set the standard defines, plus some
2032 other cases which the standard disallows. add_builtin_candidate will
2033 filter out the invalid set. */
2036 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2037 enum tree_code code2, tree fnname, tree *args,
2042 tree type, argtypes[3];
2043 /* TYPES[i] is the set of possible builtin-operator parameter types
2044 we will consider for the Ith argument. These are represented as
2045 a TREE_LIST; the TREE_VALUE of each node is the potential
2049 for (i = 0; i < 3; ++i)
2052 argtypes[i] = lvalue_type (args[i]);
2054 argtypes[i] = NULL_TREE;
2059 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2060 and VQ is either volatile or empty, there exist candidate operator
2061 functions of the form
2062 VQ T& operator++(VQ T&); */
2064 case POSTINCREMENT_EXPR:
2065 case PREINCREMENT_EXPR:
2066 case POSTDECREMENT_EXPR:
2067 case PREDECREMENT_EXPR:
2072 /* 24There also exist candidate operator functions of the form
2073 bool operator!(bool);
2074 bool operator&&(bool, bool);
2075 bool operator||(bool, bool); */
2077 case TRUTH_NOT_EXPR:
2078 build_builtin_candidate
2079 (candidates, fnname, boolean_type_node,
2080 NULL_TREE, args, argtypes, flags);
2083 case TRUTH_ORIF_EXPR:
2084 case TRUTH_ANDIF_EXPR:
2085 build_builtin_candidate
2086 (candidates, fnname, boolean_type_node,
2087 boolean_type_node, args, argtypes, flags);
2109 types[0] = types[1] = NULL_TREE;
2111 for (i = 0; i < 2; ++i)
2115 else if (IS_AGGR_TYPE (argtypes[i]))
2119 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2122 convs = lookup_conversions (argtypes[i]);
2124 if (code == COND_EXPR)
2126 if (real_lvalue_p (args[i]))
2127 types[i] = tree_cons
2128 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2130 types[i] = tree_cons
2131 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2137 for (; convs; convs = TREE_CHAIN (convs))
2139 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2142 && (TREE_CODE (type) != REFERENCE_TYPE
2143 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2146 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2147 types[i] = tree_cons (NULL_TREE, type, types[i]);
2149 type = non_reference (type);
2150 if (i != 0 || ! ref1)
2152 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2153 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2154 types[i] = tree_cons (NULL_TREE, type, types[i]);
2155 if (INTEGRAL_TYPE_P (type))
2156 type = type_promotes_to (type);
2159 if (! value_member (type, types[i]))
2160 types[i] = tree_cons (NULL_TREE, type, types[i]);
2165 if (code == COND_EXPR && real_lvalue_p (args[i]))
2166 types[i] = tree_cons
2167 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2168 type = non_reference (argtypes[i]);
2169 if (i != 0 || ! ref1)
2171 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2172 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2173 types[i] = tree_cons (NULL_TREE, type, types[i]);
2174 if (INTEGRAL_TYPE_P (type))
2175 type = type_promotes_to (type);
2177 types[i] = tree_cons (NULL_TREE, type, types[i]);
2181 /* Run through the possible parameter types of both arguments,
2182 creating candidates with those parameter types. */
2183 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2186 for (type = types[1]; type; type = TREE_CHAIN (type))
2187 add_builtin_candidate
2188 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2189 TREE_VALUE (type), args, argtypes, flags);
2191 add_builtin_candidate
2192 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2193 NULL_TREE, args, argtypes, flags);
2198 /* If TMPL can be successfully instantiated as indicated by
2199 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2201 TMPL is the template. EXPLICIT_TARGS are any explicit template
2202 arguments. ARGLIST is the arguments provided at the call-site.
2203 The RETURN_TYPE is the desired type for conversion operators. If
2204 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2205 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2206 add_conv_candidate. */
2208 static struct z_candidate*
2209 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2210 tree ctype, tree explicit_targs, tree arglist,
2211 tree return_type, tree access_path,
2212 tree conversion_path, int flags, tree obj,
2213 unification_kind_t strict)
2215 int ntparms = DECL_NTPARMS (tmpl);
2216 tree targs = make_tree_vec (ntparms);
2217 tree args_without_in_chrg = arglist;
2218 struct z_candidate *cand;
2222 /* We don't do deduction on the in-charge parameter, the VTT
2223 parameter or 'this'. */
2224 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2225 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2227 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2228 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2229 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2230 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2232 i = fn_type_unification (tmpl, explicit_targs, targs,
2233 args_without_in_chrg,
2234 return_type, strict, flags);
2239 fn = instantiate_template (tmpl, targs, tf_none);
2240 if (fn == error_mark_node)
2245 A member function template is never instantiated to perform the
2246 copy of a class object to an object of its class type.
2248 It's a little unclear what this means; the standard explicitly
2249 does allow a template to be used to copy a class. For example,
2254 template <class T> A(const T&);
2257 void g () { A a (f ()); }
2259 the member template will be used to make the copy. The section
2260 quoted above appears in the paragraph that forbids constructors
2261 whose only parameter is (a possibly cv-qualified variant of) the
2262 class type, and a logical interpretation is that the intent was
2263 to forbid the instantiation of member templates which would then
2265 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2267 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2268 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2273 if (obj != NULL_TREE)
2274 /* Aha, this is a conversion function. */
2275 cand = add_conv_candidate (candidates, fn, obj, access_path,
2276 conversion_path, arglist);
2278 cand = add_function_candidate (candidates, fn, ctype,
2279 arglist, access_path,
2280 conversion_path, flags);
2281 if (DECL_TI_TEMPLATE (fn) != tmpl)
2282 /* This situation can occur if a member template of a template
2283 class is specialized. Then, instantiate_template might return
2284 an instantiation of the specialization, in which case the
2285 DECL_TI_TEMPLATE field will point at the original
2286 specialization. For example:
2288 template <class T> struct S { template <class U> void f(U);
2289 template <> void f(int) {}; };
2293 Here, TMPL will be template <class U> S<double>::f(U).
2294 And, instantiate template will give us the specialization
2295 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2296 for this will point at template <class T> template <> S<T>::f(int),
2297 so that we can find the definition. For the purposes of
2298 overload resolution, however, we want the original TMPL. */
2299 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2301 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2307 static struct z_candidate *
2308 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2309 tree explicit_targs, tree arglist, tree return_type,
2310 tree access_path, tree conversion_path, int flags,
2311 unification_kind_t strict)
2314 add_template_candidate_real (candidates, tmpl, ctype,
2315 explicit_targs, arglist, return_type,
2316 access_path, conversion_path,
2317 flags, NULL_TREE, strict);
2321 static struct z_candidate *
2322 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2323 tree obj, tree arglist, tree return_type,
2324 tree access_path, tree conversion_path)
2327 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2328 arglist, return_type, access_path,
2329 conversion_path, 0, obj, DEDUCE_CONV);
2332 /* The CANDS are the set of candidates that were considered for
2333 overload resolution. Return the set of viable candidates. If none
2334 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2335 is true if a candidate should be considered viable only if it is
2338 static struct z_candidate*
2339 splice_viable (struct z_candidate *cands,
2343 struct z_candidate *viable;
2344 struct z_candidate **last_viable;
2345 struct z_candidate **cand;
2348 last_viable = &viable;
2349 *any_viable_p = false;
2354 struct z_candidate *c = *cand;
2355 if (strict_p ? c->viable == 1 : c->viable)
2360 last_viable = &c->next;
2361 *any_viable_p = true;
2367 return viable ? viable : cands;
2371 any_strictly_viable (struct z_candidate *cands)
2373 for (; cands; cands = cands->next)
2374 if (cands->viable == 1)
2379 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2380 words, it is about to become the "this" pointer for a member
2381 function call. Take the address of the object. */
2384 build_this (tree obj)
2386 /* In a template, we are only concerned about the type of the
2387 expression, so we can take a shortcut. */
2388 if (processing_template_decl)
2389 return build_address (obj);
2391 return build_unary_op (ADDR_EXPR, obj, 0);
2394 /* Returns true iff functions are equivalent. Equivalent functions are
2395 not '==' only if one is a function-local extern function or if
2396 both are extern "C". */
2399 equal_functions (tree fn1, tree fn2)
2401 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2402 || DECL_EXTERN_C_FUNCTION_P (fn1))
2403 return decls_match (fn1, fn2);
2407 /* Print information about one overload candidate CANDIDATE. MSGSTR
2408 is the text to print before the candidate itself.
2410 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2411 to have been run through gettext by the caller. This wart makes
2412 life simpler in print_z_candidates and for the translators. */
2415 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2417 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2419 if (candidate->num_convs == 3)
2420 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2421 candidate->convs[0]->type,
2422 candidate->convs[1]->type,
2423 candidate->convs[2]->type);
2424 else if (candidate->num_convs == 2)
2425 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2426 candidate->convs[0]->type,
2427 candidate->convs[1]->type);
2429 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2430 candidate->convs[0]->type);
2432 else if (TYPE_P (candidate->fn))
2433 inform ("%s %T <conversion>", msgstr, candidate->fn);
2434 else if (candidate->viable == -1)
2435 inform ("%s %+#D <near match>", msgstr, candidate->fn);
2437 inform ("%s %+#D", msgstr, candidate->fn);
2441 print_z_candidates (struct z_candidate *candidates)
2444 struct z_candidate *cand1;
2445 struct z_candidate **cand2;
2447 /* There may be duplicates in the set of candidates. We put off
2448 checking this condition as long as possible, since we have no way
2449 to eliminate duplicates from a set of functions in less than n^2
2450 time. Now we are about to emit an error message, so it is more
2451 permissible to go slowly. */
2452 for (cand1 = candidates; cand1; cand1 = cand1->next)
2454 tree fn = cand1->fn;
2455 /* Skip builtin candidates and conversion functions. */
2456 if (TREE_CODE (fn) != FUNCTION_DECL)
2458 cand2 = &cand1->next;
2461 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2462 && equal_functions (fn, (*cand2)->fn))
2463 *cand2 = (*cand2)->next;
2465 cand2 = &(*cand2)->next;
2472 str = _("candidates are:");
2473 print_z_candidate (str, candidates);
2474 if (candidates->next)
2476 /* Indent successive candidates by the width of the translation
2477 of the above string. */
2478 size_t len = gcc_gettext_width (str) + 1;
2479 char *spaces = (char *) alloca (len);
2480 memset (spaces, ' ', len-1);
2481 spaces[len - 1] = '\0';
2483 candidates = candidates->next;
2486 print_z_candidate (spaces, candidates);
2487 candidates = candidates->next;
2493 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2494 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2495 the result of the conversion function to convert it to the final
2496 desired type. Merge the two sequences into a single sequence,
2497 and return the merged sequence. */
2500 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2504 gcc_assert (user_seq->kind == ck_user);
2506 /* Find the end of the second conversion sequence. */
2508 while ((*t)->kind != ck_identity)
2509 t = &((*t)->u.next);
2511 /* Replace the identity conversion with the user conversion
2515 /* The entire sequence is a user-conversion sequence. */
2516 std_seq->user_conv_p = true;
2521 /* Returns the best overload candidate to perform the requested
2522 conversion. This function is used for three the overloading situations
2523 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2524 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2525 per [dcl.init.ref], so we ignore temporary bindings. */
2527 static struct z_candidate *
2528 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2530 struct z_candidate *candidates, *cand;
2531 tree fromtype = TREE_TYPE (expr);
2532 tree ctors = NULL_TREE;
2533 tree conv_fns = NULL_TREE;
2534 conversion *conv = NULL;
2535 tree args = NULL_TREE;
2538 /* We represent conversion within a hierarchy using RVALUE_CONV and
2539 BASE_CONV, as specified by [over.best.ics]; these become plain
2540 constructor calls, as specified in [dcl.init]. */
2541 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2542 || !DERIVED_FROM_P (totype, fromtype));
2544 if (IS_AGGR_TYPE (totype))
2545 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2547 if (IS_AGGR_TYPE (fromtype))
2548 conv_fns = lookup_conversions (fromtype);
2551 flags |= LOOKUP_NO_CONVERSION;
2557 ctors = BASELINK_FUNCTIONS (ctors);
2559 t = build_int_cst (build_pointer_type (totype), 0);
2560 args = build_tree_list (NULL_TREE, expr);
2561 /* We should never try to call the abstract or base constructor
2563 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2564 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2565 args = tree_cons (NULL_TREE, t, args);
2567 for (; ctors; ctors = OVL_NEXT (ctors))
2569 tree ctor = OVL_CURRENT (ctors);
2570 if (DECL_NONCONVERTING_P (ctor))
2573 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2574 cand = add_template_candidate (&candidates, ctor, totype,
2575 NULL_TREE, args, NULL_TREE,
2576 TYPE_BINFO (totype),
2577 TYPE_BINFO (totype),
2581 cand = add_function_candidate (&candidates, ctor, totype,
2582 args, TYPE_BINFO (totype),
2583 TYPE_BINFO (totype),
2587 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2591 args = build_tree_list (NULL_TREE, build_this (expr));
2593 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2596 tree conversion_path = TREE_PURPOSE (conv_fns);
2597 int convflags = LOOKUP_NO_CONVERSION;
2599 /* If we are called to convert to a reference type, we are trying to
2600 find an lvalue binding, so don't even consider temporaries. If
2601 we don't find an lvalue binding, the caller will try again to
2602 look for a temporary binding. */
2603 if (TREE_CODE (totype) == REFERENCE_TYPE)
2604 convflags |= LOOKUP_NO_TEMP_BIND;
2606 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2608 tree fn = OVL_CURRENT (fns);
2610 /* [over.match.funcs] For conversion functions, the function
2611 is considered to be a member of the class of the implicit
2612 object argument for the purpose of defining the type of
2613 the implicit object parameter.
2615 So we pass fromtype as CTYPE to add_*_candidate. */
2617 if (TREE_CODE (fn) == TEMPLATE_DECL)
2618 cand = add_template_candidate (&candidates, fn, fromtype,
2621 TYPE_BINFO (fromtype),
2626 cand = add_function_candidate (&candidates, fn, fromtype,
2628 TYPE_BINFO (fromtype),
2635 = implicit_conversion (totype,
2636 TREE_TYPE (TREE_TYPE (cand->fn)),
2638 /*c_cast_p=*/false, convflags);
2640 cand->second_conv = ics;
2644 else if (candidates->viable == 1 && ics->bad_p)
2650 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2654 cand = tourney (candidates);
2657 if (flags & LOOKUP_COMPLAIN)
2659 error ("conversion from %qT to %qT is ambiguous",
2661 print_z_candidates (candidates);
2664 cand = candidates; /* any one will do */
2665 cand->second_conv = build_ambiguous_conv (totype, expr);
2666 cand->second_conv->user_conv_p = true;
2667 if (!any_strictly_viable (candidates))
2668 cand->second_conv->bad_p = true;
2669 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2670 ambiguous conversion is no worse than another user-defined
2676 /* Build the user conversion sequence. */
2679 (DECL_CONSTRUCTOR_P (cand->fn)
2680 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2681 build_identity_conv (TREE_TYPE (expr), expr));
2684 /* Combine it with the second conversion sequence. */
2685 cand->second_conv = merge_conversion_sequences (conv,
2688 if (cand->viable == -1)
2689 cand->second_conv->bad_p = true;
2695 build_user_type_conversion (tree totype, tree expr, int flags)
2697 struct z_candidate *cand
2698 = build_user_type_conversion_1 (totype, expr, flags);
2702 if (cand->second_conv->kind == ck_ambig)
2703 return error_mark_node;
2704 expr = convert_like (cand->second_conv, expr);
2705 return convert_from_reference (expr);
2710 /* Do any initial processing on the arguments to a function call. */
2713 resolve_args (tree args)
2716 for (t = args; t; t = TREE_CHAIN (t))
2718 tree arg = TREE_VALUE (t);
2720 if (error_operand_p (arg))
2721 return error_mark_node;
2722 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2724 error ("invalid use of void expression");
2725 return error_mark_node;
2727 else if (invalid_nonstatic_memfn_p (arg))
2728 return error_mark_node;
2733 /* Perform overload resolution on FN, which is called with the ARGS.
2735 Return the candidate function selected by overload resolution, or
2736 NULL if the event that overload resolution failed. In the case
2737 that overload resolution fails, *CANDIDATES will be the set of
2738 candidates considered, and ANY_VIABLE_P will be set to true or
2739 false to indicate whether or not any of the candidates were
2742 The ARGS should already have gone through RESOLVE_ARGS before this
2743 function is called. */
2745 static struct z_candidate *
2746 perform_overload_resolution (tree fn,
2748 struct z_candidate **candidates,
2751 struct z_candidate *cand;
2752 tree explicit_targs = NULL_TREE;
2753 int template_only = 0;
2756 *any_viable_p = true;
2758 /* Check FN and ARGS. */
2759 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2760 || TREE_CODE (fn) == TEMPLATE_DECL
2761 || TREE_CODE (fn) == OVERLOAD
2762 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2763 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2765 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2767 explicit_targs = TREE_OPERAND (fn, 1);
2768 fn = TREE_OPERAND (fn, 0);
2772 /* Add the various candidate functions. */
2773 add_candidates (fn, args, explicit_targs, template_only,
2774 /*conversion_path=*/NULL_TREE,
2775 /*access_path=*/NULL_TREE,
2779 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2783 cand = tourney (*candidates);
2787 /* Return an expression for a call to FN (a namespace-scope function,
2788 or a static member function) with the ARGS. */
2791 build_new_function_call (tree fn, tree args, bool koenig_p)
2793 struct z_candidate *candidates, *cand;
2798 args = resolve_args (args);
2799 if (args == error_mark_node)
2800 return error_mark_node;
2802 /* If this function was found without using argument dependent
2803 lookup, then we want to ignore any undeclared friend
2809 fn = remove_hidden_names (fn);
2812 error ("no matching function for call to %<%D(%A)%>",
2813 DECL_NAME (OVL_CURRENT (orig_fn)), args);
2814 return error_mark_node;
2818 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2819 p = conversion_obstack_alloc (0);
2821 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2825 if (!any_viable_p && candidates && ! candidates->next)
2826 return build_function_call (candidates->fn, args);
2827 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2828 fn = TREE_OPERAND (fn, 0);
2830 error ("no matching function for call to %<%D(%A)%>",
2831 DECL_NAME (OVL_CURRENT (fn)), args);
2833 error ("call of overloaded %<%D(%A)%> is ambiguous",
2834 DECL_NAME (OVL_CURRENT (fn)), args);
2836 print_z_candidates (candidates);
2837 result = error_mark_node;
2840 result = build_over_call (cand, LOOKUP_NORMAL);
2842 /* Free all the conversions we allocated. */
2843 obstack_free (&conversion_obstack, p);
2848 /* Build a call to a global operator new. FNNAME is the name of the
2849 operator (either "operator new" or "operator new[]") and ARGS are
2850 the arguments provided. *SIZE points to the total number of bytes
2851 required by the allocation, and is updated if that is changed here.
2852 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2853 function determines that no cookie should be used, after all,
2854 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2855 set, upon return, to the allocation function called. */
2858 build_operator_new_call (tree fnname, tree args,
2859 tree *size, tree *cookie_size,
2863 struct z_candidate *candidates;
2864 struct z_candidate *cand;
2869 args = tree_cons (NULL_TREE, *size, args);
2870 args = resolve_args (args);
2871 if (args == error_mark_node)
2878 If this lookup fails to find the name, or if the allocated type
2879 is not a class type, the allocation function's name is looked
2880 up in the global scope.
2882 we disregard block-scope declarations of "operator new". */
2883 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2885 /* Figure out what function is being called. */
2886 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2888 /* If no suitable function could be found, issue an error message
2893 error ("no matching function for call to %<%D(%A)%>",
2894 DECL_NAME (OVL_CURRENT (fns)), args);
2896 error ("call of overloaded %<%D(%A)%> is ambiguous",
2897 DECL_NAME (OVL_CURRENT (fns)), args);
2899 print_z_candidates (candidates);
2900 return error_mark_node;
2903 /* If a cookie is required, add some extra space. Whether
2904 or not a cookie is required cannot be determined until
2905 after we know which function was called. */
2908 bool use_cookie = true;
2909 if (!abi_version_at_least (2))
2911 tree placement = TREE_CHAIN (args);
2912 /* In G++ 3.2, the check was implemented incorrectly; it
2913 looked at the placement expression, rather than the
2914 type of the function. */
2915 if (placement && !TREE_CHAIN (placement)
2916 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2924 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2925 /* Skip the size_t parameter. */
2926 arg_types = TREE_CHAIN (arg_types);
2927 /* Check the remaining parameters (if any). */
2929 && TREE_CHAIN (arg_types) == void_list_node
2930 && same_type_p (TREE_VALUE (arg_types),
2934 /* If we need a cookie, adjust the number of bytes allocated. */
2937 /* Update the total size. */
2938 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2939 /* Update the argument list to reflect the adjusted size. */
2940 TREE_VALUE (args) = *size;
2943 *cookie_size = NULL_TREE;
2946 /* Tell our caller which function we decided to call. */
2950 /* Build the CALL_EXPR. */
2951 return build_over_call (cand, LOOKUP_NORMAL);
2955 build_object_call (tree obj, tree args)
2957 struct z_candidate *candidates = 0, *cand;
2958 tree fns, convs, mem_args = NULL_TREE;
2959 tree type = TREE_TYPE (obj);
2961 tree result = NULL_TREE;
2964 if (TYPE_PTRMEMFUNC_P (type))
2966 /* It's no good looking for an overloaded operator() on a
2967 pointer-to-member-function. */
2968 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2969 return error_mark_node;
2972 if (TYPE_BINFO (type))
2974 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2975 if (fns == error_mark_node)
2976 return error_mark_node;
2981 args = resolve_args (args);
2983 if (args == error_mark_node)
2984 return error_mark_node;
2986 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2987 p = conversion_obstack_alloc (0);
2991 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2992 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2994 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2996 tree fn = OVL_CURRENT (fns);
2997 if (TREE_CODE (fn) == TEMPLATE_DECL)
2998 add_template_candidate (&candidates, fn, base, NULL_TREE,
2999 mem_args, NULL_TREE,
3002 LOOKUP_NORMAL, DEDUCE_CALL);
3004 add_function_candidate
3005 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3006 TYPE_BINFO (type), LOOKUP_NORMAL);
3010 convs = lookup_conversions (type);
3012 for (; convs; convs = TREE_CHAIN (convs))
3014 tree fns = TREE_VALUE (convs);
3015 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3017 if ((TREE_CODE (totype) == POINTER_TYPE
3018 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3019 || (TREE_CODE (totype) == REFERENCE_TYPE
3020 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3021 || (TREE_CODE (totype) == REFERENCE_TYPE
3022 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3023 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3024 for (; fns; fns = OVL_NEXT (fns))
3026 tree fn = OVL_CURRENT (fns);
3027 if (TREE_CODE (fn) == TEMPLATE_DECL)
3028 add_template_conv_candidate
3029 (&candidates, fn, obj, args, totype,
3030 /*access_path=*/NULL_TREE,
3031 /*conversion_path=*/NULL_TREE);
3033 add_conv_candidate (&candidates, fn, obj, args,
3034 /*conversion_path=*/NULL_TREE,
3035 /*access_path=*/NULL_TREE);
3039 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3042 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3043 print_z_candidates (candidates);
3044 result = error_mark_node;
3048 cand = tourney (candidates);
3051 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
3052 print_z_candidates (candidates);
3053 result = error_mark_node;
3055 /* Since cand->fn will be a type, not a function, for a conversion
3056 function, we must be careful not to unconditionally look at
3058 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3059 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3060 result = build_over_call (cand, LOOKUP_NORMAL);
3063 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
3064 obj = convert_from_reference (obj);
3065 result = build_function_call (obj, args);
3069 /* Free all the conversions we allocated. */
3070 obstack_free (&conversion_obstack, p);
3076 op_error (enum tree_code code, enum tree_code code2,
3077 tree arg1, tree arg2, tree arg3, const char *problem)
3081 if (code == MODIFY_EXPR)
3082 opname = assignment_operator_name_info[code2].name;
3084 opname = operator_name_info[code].name;
3089 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3090 problem, arg1, arg2, arg3);
3093 case POSTINCREMENT_EXPR:
3094 case POSTDECREMENT_EXPR:
3095 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3099 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3104 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3109 error ("%s for %<operator%s%> in %<%E %s %E%>",
3110 problem, opname, arg1, opname, arg2);
3112 error ("%s for %<operator%s%> in %<%s%E%>",
3113 problem, opname, opname, arg1);
3118 /* Return the implicit conversion sequence that could be used to
3119 convert E1 to E2 in [expr.cond]. */
3122 conditional_conversion (tree e1, tree e2)
3124 tree t1 = non_reference (TREE_TYPE (e1));
3125 tree t2 = non_reference (TREE_TYPE (e2));
3131 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3132 implicitly converted (clause _conv_) to the type "reference to
3133 T2", subject to the constraint that in the conversion the
3134 reference must bind directly (_dcl.init.ref_) to E1. */
3135 if (real_lvalue_p (e2))
3137 conv = implicit_conversion (build_reference_type (t2),
3141 LOOKUP_NO_TEMP_BIND);
3148 If E1 and E2 have class type, and the underlying class types are
3149 the same or one is a base class of the other: E1 can be converted
3150 to match E2 if the class of T2 is the same type as, or a base
3151 class of, the class of T1, and the cv-qualification of T2 is the
3152 same cv-qualification as, or a greater cv-qualification than, the
3153 cv-qualification of T1. If the conversion is applied, E1 is
3154 changed to an rvalue of type T2 that still refers to the original
3155 source class object (or the appropriate subobject thereof). */
3156 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3157 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3159 if (good_base && at_least_as_qualified_p (t2, t1))
3161 conv = build_identity_conv (t1, e1);
3162 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3163 TYPE_MAIN_VARIANT (t2)))
3164 conv = build_conv (ck_base, t2, conv);
3166 conv = build_conv (ck_rvalue, t2, conv);
3175 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3176 converted to the type that expression E2 would have if E2 were
3177 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3178 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3182 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3183 arguments to the conditional expression. */
3186 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3190 tree result = NULL_TREE;
3191 tree result_type = NULL_TREE;
3192 bool lvalue_p = true;
3193 struct z_candidate *candidates = 0;
3194 struct z_candidate *cand;
3197 /* As a G++ extension, the second argument to the conditional can be
3198 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3199 c'.) If the second operand is omitted, make sure it is
3200 calculated only once. */
3204 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3206 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3207 if (real_lvalue_p (arg1))
3208 arg2 = arg1 = stabilize_reference (arg1);
3210 arg2 = arg1 = save_expr (arg1);
3215 The first expr ession is implicitly converted to bool (clause
3217 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3219 /* If something has already gone wrong, just pass that fact up the
3221 if (error_operand_p (arg1)
3222 || error_operand_p (arg2)
3223 || error_operand_p (arg3))
3224 return error_mark_node;
3228 If either the second or the third operand has type (possibly
3229 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3230 array-to-pointer (_conv.array_), and function-to-pointer
3231 (_conv.func_) standard conversions are performed on the second
3232 and third operands. */
3233 arg2_type = unlowered_expr_type (arg2);
3234 arg3_type = unlowered_expr_type (arg3);
3235 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3237 /* Do the conversions. We don't these for `void' type arguments
3238 since it can't have any effect and since decay_conversion
3239 does not handle that case gracefully. */
3240 if (!VOID_TYPE_P (arg2_type))
3241 arg2 = decay_conversion (arg2);
3242 if (!VOID_TYPE_P (arg3_type))
3243 arg3 = decay_conversion (arg3);
3244 arg2_type = TREE_TYPE (arg2);
3245 arg3_type = TREE_TYPE (arg3);
3249 One of the following shall hold:
3251 --The second or the third operand (but not both) is a
3252 throw-expression (_except.throw_); the result is of the
3253 type of the other and is an rvalue.
3255 --Both the second and the third operands have type void; the
3256 result is of type void and is an rvalue.
3258 We must avoid calling force_rvalue for expressions of type
3259 "void" because it will complain that their value is being
3261 if (TREE_CODE (arg2) == THROW_EXPR
3262 && TREE_CODE (arg3) != THROW_EXPR)
3264 if (!VOID_TYPE_P (arg3_type))
3265 arg3 = force_rvalue (arg3);
3266 arg3_type = TREE_TYPE (arg3);
3267 result_type = arg3_type;
3269 else if (TREE_CODE (arg2) != THROW_EXPR
3270 && TREE_CODE (arg3) == THROW_EXPR)
3272 if (!VOID_TYPE_P (arg2_type))
3273 arg2 = force_rvalue (arg2);
3274 arg2_type = TREE_TYPE (arg2);
3275 result_type = arg2_type;
3277 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3278 result_type = void_type_node;
3281 error ("%qE has type %<void%> and is not a throw-expression",
3282 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3283 return error_mark_node;
3287 goto valid_operands;
3291 Otherwise, if the second and third operand have different types,
3292 and either has (possibly cv-qualified) class type, an attempt is
3293 made to convert each of those operands to the type of the other. */
3294 else if (!same_type_p (arg2_type, arg3_type)
3295 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3300 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3301 p = conversion_obstack_alloc (0);
3303 conv2 = conditional_conversion (arg2, arg3);
3304 conv3 = conditional_conversion (arg3, arg2);
3308 If both can be converted, or one can be converted but the
3309 conversion is ambiguous, the program is ill-formed. If
3310 neither can be converted, the operands are left unchanged and
3311 further checking is performed as described below. If exactly
3312 one conversion is possible, that conversion is applied to the
3313 chosen operand and the converted operand is used in place of
3314 the original operand for the remainder of this section. */
3315 if ((conv2 && !conv2->bad_p
3316 && conv3 && !conv3->bad_p)
3317 || (conv2 && conv2->kind == ck_ambig)
3318 || (conv3 && conv3->kind == ck_ambig))
3320 error ("operands to ?: have different types %qT and %qT",
3321 arg2_type, arg3_type);
3322 result = error_mark_node;
3324 else if (conv2 && (!conv2->bad_p || !conv3))
3326 arg2 = convert_like (conv2, arg2);
3327 arg2 = convert_from_reference (arg2);
3328 arg2_type = TREE_TYPE (arg2);
3329 /* Even if CONV2 is a valid conversion, the result of the
3330 conversion may be invalid. For example, if ARG3 has type
3331 "volatile X", and X does not have a copy constructor
3332 accepting a "volatile X&", then even if ARG2 can be
3333 converted to X, the conversion will fail. */
3334 if (error_operand_p (arg2))
3335 result = error_mark_node;
3337 else if (conv3 && (!conv3->bad_p || !conv2))
3339 arg3 = convert_like (conv3, arg3);
3340 arg3 = convert_from_reference (arg3);
3341 arg3_type = TREE_TYPE (arg3);
3342 if (error_operand_p (arg3))
3343 result = error_mark_node;
3346 /* Free all the conversions we allocated. */
3347 obstack_free (&conversion_obstack, p);
3352 /* If, after the conversion, both operands have class type,
3353 treat the cv-qualification of both operands as if it were the
3354 union of the cv-qualification of the operands.
3356 The standard is not clear about what to do in this
3357 circumstance. For example, if the first operand has type
3358 "const X" and the second operand has a user-defined
3359 conversion to "volatile X", what is the type of the second
3360 operand after this step? Making it be "const X" (matching
3361 the first operand) seems wrong, as that discards the
3362 qualification without actually performing a copy. Leaving it
3363 as "volatile X" seems wrong as that will result in the
3364 conditional expression failing altogether, even though,
3365 according to this step, the one operand could be converted to
3366 the type of the other. */
3367 if ((conv2 || conv3)
3368 && CLASS_TYPE_P (arg2_type)
3369 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3370 arg2_type = arg3_type =
3371 cp_build_qualified_type (arg2_type,
3372 TYPE_QUALS (arg2_type)
3373 | TYPE_QUALS (arg3_type));
3378 If the second and third operands are lvalues and have the same
3379 type, the result is of that type and is an lvalue. */
3380 if (real_lvalue_p (arg2)
3381 && real_lvalue_p (arg3)
3382 && same_type_p (arg2_type, arg3_type))
3384 result_type = arg2_type;
3385 goto valid_operands;
3390 Otherwise, the result is an rvalue. If the second and third
3391 operand do not have the same type, and either has (possibly
3392 cv-qualified) class type, overload resolution is used to
3393 determine the conversions (if any) to be applied to the operands
3394 (_over.match.oper_, _over.built_). */
3396 if (!same_type_p (arg2_type, arg3_type)
3397 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3403 /* Rearrange the arguments so that add_builtin_candidate only has
3404 to know about two args. In build_builtin_candidates, the
3405 arguments are unscrambled. */
3409 add_builtin_candidates (&candidates,
3412 ansi_opname (COND_EXPR),
3418 If the overload resolution fails, the program is
3420 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3423 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3424 print_z_candidates (candidates);
3425 return error_mark_node;
3427 cand = tourney (candidates);
3430 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3431 print_z_candidates (candidates);
3432 return error_mark_node;
3437 Otherwise, the conversions thus determined are applied, and
3438 the converted operands are used in place of the original
3439 operands for the remainder of this section. */
3440 conv = cand->convs[0];
3441 arg1 = convert_like (conv, arg1);
3442 conv = cand->convs[1];
3443 arg2 = convert_like (conv, arg2);
3444 conv = cand->convs[2];
3445 arg3 = convert_like (conv, arg3);
3450 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3451 and function-to-pointer (_conv.func_) standard conversions are
3452 performed on the second and third operands.
3454 We need to force the lvalue-to-rvalue conversion here for class types,
3455 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3456 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3459 arg2 = force_rvalue (arg2);
3460 if (!CLASS_TYPE_P (arg2_type))
3461 arg2_type = TREE_TYPE (arg2);
3463 arg3 = force_rvalue (arg3);
3464 if (!CLASS_TYPE_P (arg2_type))
3465 arg3_type = TREE_TYPE (arg3);
3467 if (arg2 == error_mark_node || arg3 == error_mark_node)
3468 return error_mark_node;
3472 After those conversions, one of the following shall hold:
3474 --The second and third operands have the same type; the result is of
3476 if (same_type_p (arg2_type, arg3_type))
3477 result_type = arg2_type;
3480 --The second and third operands have arithmetic or enumeration
3481 type; the usual arithmetic conversions are performed to bring
3482 them to a common type, and the result is of that type. */
3483 else if ((ARITHMETIC_TYPE_P (arg2_type)
3484 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3485 && (ARITHMETIC_TYPE_P (arg3_type)
3486 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3488 /* In this case, there is always a common type. */
3489 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3492 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3493 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3494 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3495 arg2_type, arg3_type);
3496 else if (extra_warnings
3497 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3498 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3499 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3500 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3501 warning (0, "enumeral and non-enumeral type in conditional expression");
3503 arg2 = perform_implicit_conversion (result_type, arg2);
3504 arg3 = perform_implicit_conversion (result_type, arg3);
3508 --The second and third operands have pointer type, or one has
3509 pointer type and the other is a null pointer constant; pointer
3510 conversions (_conv.ptr_) and qualification conversions
3511 (_conv.qual_) are performed to bring them to their composite
3512 pointer type (_expr.rel_). The result is of the composite
3515 --The second and third operands have pointer to member type, or
3516 one has pointer to member type and the other is a null pointer
3517 constant; pointer to member conversions (_conv.mem_) and
3518 qualification conversions (_conv.qual_) are performed to bring
3519 them to a common type, whose cv-qualification shall match the
3520 cv-qualification of either the second or the third operand.
3521 The result is of the common type. */
3522 else if ((null_ptr_cst_p (arg2)
3523 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3524 || (null_ptr_cst_p (arg3)
3525 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3526 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3527 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3528 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3530 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3531 arg3, "conditional expression");
3532 if (result_type == error_mark_node)
3533 return error_mark_node;
3534 arg2 = perform_implicit_conversion (result_type, arg2);
3535 arg3 = perform_implicit_conversion (result_type, arg3);
3540 error ("operands to ?: have different types %qT and %qT",
3541 arg2_type, arg3_type);
3542 return error_mark_node;
3546 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3548 /* We can't use result_type below, as fold might have returned a
3553 /* Expand both sides into the same slot, hopefully the target of
3554 the ?: expression. We used to check for TARGET_EXPRs here,
3555 but now we sometimes wrap them in NOP_EXPRs so the test would
3557 if (CLASS_TYPE_P (TREE_TYPE (result)))
3558 result = get_target_expr (result);
3559 /* If this expression is an rvalue, but might be mistaken for an
3560 lvalue, we must add a NON_LVALUE_EXPR. */
3561 result = rvalue (result);
3567 /* OPERAND is an operand to an expression. Perform necessary steps
3568 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3572 prep_operand (tree operand)
3576 if (CLASS_TYPE_P (TREE_TYPE (operand))
3577 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3578 /* Make sure the template type is instantiated now. */
3579 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3585 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3586 OVERLOAD) to the CANDIDATES, returning an updated list of
3587 CANDIDATES. The ARGS are the arguments provided to the call,
3588 without any implicit object parameter. The EXPLICIT_TARGS are
3589 explicit template arguments provided. TEMPLATE_ONLY is true if
3590 only template functions should be considered. CONVERSION_PATH,
3591 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3594 add_candidates (tree fns, tree args,
3595 tree explicit_targs, bool template_only,
3596 tree conversion_path, tree access_path,
3598 struct z_candidate **candidates)
3601 tree non_static_args;
3603 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3604 /* Delay creating the implicit this parameter until it is needed. */
3605 non_static_args = NULL_TREE;
3612 fn = OVL_CURRENT (fns);
3613 /* Figure out which set of arguments to use. */
3614 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3616 /* If this function is a non-static member, prepend the implicit
3617 object parameter. */
3618 if (!non_static_args)
3619 non_static_args = tree_cons (NULL_TREE,
3620 build_this (TREE_VALUE (args)),
3622 fn_args = non_static_args;
3625 /* Otherwise, just use the list of arguments provided. */
3628 if (TREE_CODE (fn) == TEMPLATE_DECL)
3629 add_template_candidate (candidates,
3639 else if (!template_only)
3640 add_function_candidate (candidates,
3647 fns = OVL_NEXT (fns);
3652 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3655 struct z_candidate *candidates = 0, *cand;
3656 tree arglist, fnname;
3658 tree result = NULL_TREE;
3659 bool result_valid_p = false;
3660 enum tree_code code2 = NOP_EXPR;
3666 if (error_operand_p (arg1)
3667 || error_operand_p (arg2)
3668 || error_operand_p (arg3))
3669 return error_mark_node;
3671 if (code == MODIFY_EXPR)
3673 code2 = TREE_CODE (arg3);
3675 fnname = ansi_assopname (code2);
3678 fnname = ansi_opname (code);
3680 arg1 = prep_operand (arg1);
3686 case VEC_DELETE_EXPR:
3688 /* Use build_op_new_call and build_op_delete_call instead. */
3692 return build_object_call (arg1, arg2);
3698 arg2 = prep_operand (arg2);
3699 arg3 = prep_operand (arg3);
3701 if (code == COND_EXPR)
3703 if (arg2 == NULL_TREE
3704 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3705 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3706 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3707 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3710 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3711 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3714 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3715 arg2 = integer_zero_node;
3717 arglist = NULL_TREE;
3719 arglist = tree_cons (NULL_TREE, arg3, arglist);
3721 arglist = tree_cons (NULL_TREE, arg2, arglist);
3722 arglist = tree_cons (NULL_TREE, arg1, arglist);
3724 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3725 p = conversion_obstack_alloc (0);
3727 /* Add namespace-scope operators to the list of functions to
3729 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3730 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3731 flags, &candidates);
3732 /* Add class-member operators to the candidate set. */
3733 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3737 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3738 if (fns == error_mark_node)
3740 result = error_mark_node;
3741 goto user_defined_result_ready;
3744 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3746 BASELINK_BINFO (fns),
3747 TYPE_BINFO (TREE_TYPE (arg1)),
3748 flags, &candidates);
3751 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3752 to know about two args; a builtin candidate will always have a first
3753 parameter of type bool. We'll handle that in
3754 build_builtin_candidate. */
3755 if (code == COND_EXPR)
3765 args[2] = NULL_TREE;
3768 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3774 /* For these, the built-in candidates set is empty
3775 [over.match.oper]/3. We don't want non-strict matches
3776 because exact matches are always possible with built-in
3777 operators. The built-in candidate set for COMPONENT_REF
3778 would be empty too, but since there are no such built-in
3779 operators, we accept non-strict matches for them. */
3784 strict_p = pedantic;
3788 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3793 case POSTINCREMENT_EXPR:
3794 case POSTDECREMENT_EXPR:
3795 /* Look for an `operator++ (int)'. If they didn't have
3796 one, then we fall back to the old way of doing things. */
3797 if (flags & LOOKUP_COMPLAIN)
3798 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3799 "trying prefix operator instead",
3801 operator_name_info[code].name);
3802 if (code == POSTINCREMENT_EXPR)
3803 code = PREINCREMENT_EXPR;
3805 code = PREDECREMENT_EXPR;
3806 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3810 /* The caller will deal with these. */
3815 result_valid_p = true;
3819 if (flags & LOOKUP_COMPLAIN)
3821 op_error (code, code2, arg1, arg2, arg3, "no match");
3822 print_z_candidates (candidates);
3824 result = error_mark_node;
3830 cand = tourney (candidates);
3833 if (flags & LOOKUP_COMPLAIN)
3835 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3836 print_z_candidates (candidates);
3838 result = error_mark_node;
3840 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3843 *overloaded_p = true;
3845 result = build_over_call (cand, LOOKUP_NORMAL);
3849 /* Give any warnings we noticed during overload resolution. */
3852 struct candidate_warning *w;
3853 for (w = cand->warnings; w; w = w->next)
3854 joust (cand, w->loser, 1);
3857 /* Check for comparison of different enum types. */
3866 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3867 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3868 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3869 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3871 warning (0, "comparison between %q#T and %q#T",
3872 TREE_TYPE (arg1), TREE_TYPE (arg2));
3879 /* We need to strip any leading REF_BIND so that bitfields
3880 don't cause errors. This should not remove any important
3881 conversions, because builtins don't apply to class
3882 objects directly. */
3883 conv = cand->convs[0];
3884 if (conv->kind == ck_ref_bind)
3885 conv = conv->u.next;
3886 arg1 = convert_like (conv, arg1);
3889 conv = cand->convs[1];
3890 if (conv->kind == ck_ref_bind)
3891 conv = conv->u.next;
3892 arg2 = convert_like (conv, arg2);
3896 conv = cand->convs[2];
3897 if (conv->kind == ck_ref_bind)
3898 conv = conv->u.next;
3899 arg3 = convert_like (conv, arg3);
3904 user_defined_result_ready:
3906 /* Free all the conversions we allocated. */
3907 obstack_free (&conversion_obstack, p);
3909 if (result || result_valid_p)
3916 return build_modify_expr (arg1, code2, arg2);
3919 return build_indirect_ref (arg1, "unary *");
3924 case TRUNC_DIV_EXPR:
3935 case TRUNC_MOD_EXPR:
3939 case TRUTH_ANDIF_EXPR:
3940 case TRUTH_ORIF_EXPR:
3941 return cp_build_binary_op (code, arg1, arg2);
3943 case UNARY_PLUS_EXPR:
3946 case TRUTH_NOT_EXPR:
3947 case PREINCREMENT_EXPR:
3948 case POSTINCREMENT_EXPR:
3949 case PREDECREMENT_EXPR:
3950 case POSTDECREMENT_EXPR:
3953 return build_unary_op (code, arg1, candidates != 0);
3956 return build_array_ref (arg1, arg2);
3959 return build_conditional_expr (arg1, arg2, arg3);
3962 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
3964 /* The caller will deal with these. */
3976 /* Build a call to operator delete. This has to be handled very specially,
3977 because the restrictions on what signatures match are different from all
3978 other call instances. For a normal delete, only a delete taking (void *)
3979 or (void *, size_t) is accepted. For a placement delete, only an exact
3980 match with the placement new is accepted.
3982 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3983 ADDR is the pointer to be deleted.
3984 SIZE is the size of the memory block to be deleted.
3985 GLOBAL_P is true if the delete-expression should not consider
3986 class-specific delete operators.
3987 PLACEMENT is the corresponding placement new call, or NULL_TREE.
3989 If this call to "operator delete" is being generated as part to
3990 deallocate memory allocated via a new-expression (as per [expr.new]
3991 which requires that if the initialization throws an exception then
3992 we call a deallocation function), then ALLOC_FN is the allocation
3996 build_op_delete_call (enum tree_code code, tree addr, tree size,
3997 bool global_p, tree placement,
4000 tree fn = NULL_TREE;
4001 tree fns, fnname, argtypes, args, type;
4004 if (addr == error_mark_node)
4005 return error_mark_node;
4007 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4009 fnname = ansi_opname (code);
4011 if (CLASS_TYPE_P (type)
4012 && COMPLETE_TYPE_P (complete_type (type))
4016 If the result of the lookup is ambiguous or inaccessible, or if
4017 the lookup selects a placement deallocation function, the
4018 program is ill-formed.
4020 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4022 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4023 if (fns == error_mark_node)
4024 return error_mark_node;
4029 if (fns == NULL_TREE)
4030 fns = lookup_name_nonclass (fnname);
4034 /* Get the parameter types for the allocation function that is
4036 gcc_assert (alloc_fn != NULL_TREE);
4037 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4038 /* Also the second argument. */
4039 args = TREE_CHAIN (TREE_OPERAND (placement, 1));
4043 /* First try it without the size argument. */
4044 argtypes = void_list_node;
4048 /* Strip const and volatile from addr. */
4049 addr = cp_convert (ptr_type_node, addr);
4051 /* We make two tries at finding a matching `operator delete'. On
4052 the first pass, we look for a one-operator (or placement)
4053 operator delete. If we're not doing placement delete, then on
4054 the second pass we look for a two-argument delete. */
4055 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4057 /* Go through the `operator delete' functions looking for one
4058 with a matching type. */
4059 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4065 /* The first argument must be "void *". */
4066 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4067 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4070 /* On the first pass, check the rest of the arguments. */
4076 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4084 /* On the second pass, look for a function with exactly two
4085 arguments: "void *" and "size_t". */
4087 /* For "operator delete(void *, ...)" there will be
4088 no second argument, but we will not get an exact
4091 && same_type_p (TREE_VALUE (t), sizetype)
4092 && TREE_CHAIN (t) == void_list_node)
4096 /* If we found a match, we're done. */
4101 /* If we have a matching function, call it. */
4104 /* Make sure we have the actual function, and not an
4106 fn = OVL_CURRENT (fn);
4108 /* If the FN is a member function, make sure that it is
4110 if (DECL_CLASS_SCOPE_P (fn))
4111 perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4114 args = tree_cons (NULL_TREE, addr, args);
4116 args = tree_cons (NULL_TREE, addr,
4117 build_tree_list (NULL_TREE, size));
4121 /* The placement args might not be suitable for overload
4122 resolution at this point, so build the call directly. */
4124 return build_cxx_call (fn, args);
4127 return build_function_call (fn, args);
4132 If no unambiguous matching deallocation function can be found,
4133 propagating the exception does not cause the object's memory to
4138 warning (0, "no corresponding deallocation function for `%D'",
4143 error ("no suitable %<operator %s%> for %qT",
4144 operator_name_info[(int)code].name, type);
4145 return error_mark_node;
4148 /* If the current scope isn't allowed to access DECL along
4149 BASETYPE_PATH, give an error. The most derived class in
4150 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4151 the declaration to use in the error diagnostic. */
4154 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4156 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4158 if (!accessible_p (basetype_path, decl, true))
4160 if (TREE_PRIVATE (decl))
4161 error ("%q+#D is private", diag_decl);
4162 else if (TREE_PROTECTED (decl))
4163 error ("%q+#D is protected", diag_decl);
4165 error ("%q+#D is inaccessible", diag_decl);
4166 error ("within this context");
4173 /* Check that a callable constructor to initialize a temporary of
4174 TYPE from an EXPR exists. */
4177 check_constructor_callable (tree type, tree expr)
4179 build_special_member_call (NULL_TREE,
4180 complete_ctor_identifier,
4181 build_tree_list (NULL_TREE, expr),
4183 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4184 | LOOKUP_NO_CONVERSION
4185 | LOOKUP_CONSTRUCTOR_CALLABLE);
4188 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4189 bitwise or of LOOKUP_* values. If any errors are warnings are
4190 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4191 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4195 build_temp (tree expr, tree type, int flags,
4196 diagnostic_fn_t *diagnostic_fn)
4200 savew = warningcount, savee = errorcount;
4201 expr = build_special_member_call (NULL_TREE,
4202 complete_ctor_identifier,
4203 build_tree_list (NULL_TREE, expr),
4205 if (warningcount > savew)
4206 *diagnostic_fn = warning0;
4207 else if (errorcount > savee)
4208 *diagnostic_fn = error;
4210 *diagnostic_fn = NULL;
4215 /* Perform the conversions in CONVS on the expression EXPR. FN and
4216 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4217 indicates the `this' argument of a method. INNER is nonzero when
4218 being called to continue a conversion chain. It is negative when a
4219 reference binding will be applied, positive otherwise. If
4220 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4221 conversions will be emitted if appropriate. If C_CAST_P is true,
4222 this conversion is coming from a C-style cast; in that case,
4223 conversions to inaccessible bases are permitted. */
4226 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4227 int inner, bool issue_conversion_warnings,
4230 tree totype = convs->type;
4231 diagnostic_fn_t diagnostic_fn;
4234 && convs->kind != ck_user
4235 && convs->kind != ck_ambig
4236 && convs->kind != ck_ref_bind)
4238 conversion *t = convs;
4239 for (; t; t = convs->u.next)
4241 if (t->kind == ck_user || !t->bad_p)
4243 expr = convert_like_real (t, expr, fn, argnum, 1,
4244 /*issue_conversion_warnings=*/false,
4245 /*c_cast_p=*/false);
4248 else if (t->kind == ck_ambig)
4249 return convert_like_real (t, expr, fn, argnum, 1,
4250 /*issue_conversion_warnings=*/false,
4251 /*c_cast_p=*/false);
4252 else if (t->kind == ck_identity)
4255 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4257 pedwarn (" initializing argument %P of %qD", argnum, fn);
4258 return cp_convert (totype, expr);
4261 if (issue_conversion_warnings)
4263 tree t = non_reference (totype);
4265 /* Issue warnings about peculiar, but valid, uses of NULL. */
4266 if (ARITHMETIC_TYPE_P (t) && expr == null_node)
4269 warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4272 warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4275 /* Warn about assigning a floating-point type to an integer type. */
4276 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4277 && TREE_CODE (t) == INTEGER_TYPE)
4280 warning (OPT_Wconversion, "passing %qT for argument %P to %qD",
4281 TREE_TYPE (expr), argnum, fn);
4283 warning (OPT_Wconversion, "converting to %qT from %qT", t, TREE_TYPE (expr));
4287 switch (convs->kind)
4291 struct z_candidate *cand = convs->cand;
4292 tree convfn = cand->fn;
4295 if (DECL_CONSTRUCTOR_P (convfn))
4297 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4300 args = build_tree_list (NULL_TREE, expr);
4301 /* We should never try to call the abstract or base constructor
4303 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4304 && !DECL_HAS_VTT_PARM_P (convfn));
4305 args = tree_cons (NULL_TREE, t, args);
4308 args = build_this (expr);
4309 expr = build_over_call (cand, LOOKUP_NORMAL);
4311 /* If this is a constructor or a function returning an aggr type,
4312 we need to build up a TARGET_EXPR. */
4313 if (DECL_CONSTRUCTOR_P (convfn))
4314 expr = build_cplus_new (totype, expr);
4316 /* The result of the call is then used to direct-initialize the object
4317 that is the destination of the copy-initialization. [dcl.init]
4319 Note that this step is not reflected in the conversion sequence;
4320 it affects the semantics when we actually perform the
4321 conversion, but is not considered during overload resolution.
4323 If the target is a class, that means call a ctor. */
4324 if (IS_AGGR_TYPE (totype)
4325 && (inner >= 0 || !lvalue_p (expr)))
4329 /* Core issue 84, now a DR, says that we don't
4330 allow UDCs for these args (which deliberately
4331 breaks copy-init of an auto_ptr<Base> from an
4332 auto_ptr<Derived>). */
4333 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4340 (" initializing argument %P of %qD from result of %qD",
4341 argnum, fn, convfn);
4344 (" initializing temporary from result of %qD", convfn);
4346 expr = build_cplus_new (totype, expr);
4351 if (type_unknown_p (expr))
4352 expr = instantiate_type (totype, expr, tf_warning_or_error);
4353 /* Convert a constant to its underlying value, unless we are
4354 about to bind it to a reference, in which case we need to
4355 leave it as an lvalue. */
4357 expr = decl_constant_value (expr);
4358 if (convs->check_copy_constructor_p)
4359 check_constructor_callable (totype, expr);
4362 /* Call build_user_type_conversion again for the error. */
4363 return build_user_type_conversion
4364 (totype, convs->u.expr, LOOKUP_NORMAL);
4370 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4371 convs->kind == ck_ref_bind ? -1 : 1,
4372 /*issue_conversion_warnings=*/false,
4374 if (expr == error_mark_node)
4375 return error_mark_node;
4377 switch (convs->kind)
4380 expr = convert_bitfield_to_declared_type (expr);
4381 if (! IS_AGGR_TYPE (totype))
4383 /* Else fall through. */
4385 if (convs->kind == ck_base && !convs->need_temporary_p)
4387 /* We are going to bind a reference directly to a base-class
4388 subobject of EXPR. */
4389 if (convs->check_copy_constructor_p)
4390 check_constructor_callable (TREE_TYPE (expr), expr);
4391 /* Build an expression for `*((base*) &expr)'. */
4392 expr = build_unary_op (ADDR_EXPR, expr, 0);
4393 expr = convert_to_base (expr, build_pointer_type (totype),
4394 !c_cast_p, /*nonnull=*/true);
4395 expr = build_indirect_ref (expr, "implicit conversion");
4399 /* Copy-initialization where the cv-unqualified version of the source
4400 type is the same class as, or a derived class of, the class of the
4401 destination [is treated as direct-initialization]. [dcl.init] */
4402 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4404 if (diagnostic_fn && fn)
4405 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4406 return build_cplus_new (totype, expr);
4410 tree ref_type = totype;
4412 /* If necessary, create a temporary. */
4413 if (convs->need_temporary_p || !lvalue_p (expr))
4415 tree type = convs->u.next->type;
4416 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4418 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4420 /* If the reference is volatile or non-const, we
4421 cannot create a temporary. */
4422 if (lvalue & clk_bitfield)
4423 error ("cannot bind bitfield %qE to %qT",
4425 else if (lvalue & clk_packed)
4426 error ("cannot bind packed field %qE to %qT",
4429 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4430 return error_mark_node;
4432 /* If the source is a packed field, and we must use a copy
4433 constructor, then building the target expr will require
4434 binding the field to the reference parameter to the
4435 copy constructor, and we'll end up with an infinite
4436 loop. If we can use a bitwise copy, then we'll be
4438 if ((lvalue & clk_packed)
4439 && CLASS_TYPE_P (type)
4440 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4442 error ("cannot bind packed field %qE to %qT",
4444 return error_mark_node;
4446 expr = build_target_expr_with_type (expr, type);
4449 /* Take the address of the thing to which we will bind the
4451 expr = build_unary_op (ADDR_EXPR, expr, 1);
4452 if (expr == error_mark_node)
4453 return error_mark_node;
4455 /* Convert it to a pointer to the type referred to by the
4456 reference. This will adjust the pointer if a derived to
4457 base conversion is being performed. */
4458 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4460 /* Convert the pointer to the desired reference type. */
4461 return build_nop (ref_type, expr);
4465 return decay_conversion (expr);
4468 /* Warn about deprecated conversion if appropriate. */
4469 string_conv_p (totype, expr, 1);
4474 expr = convert_to_base (expr, totype, !c_cast_p,
4476 return build_nop (totype, expr);
4479 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4486 if (issue_conversion_warnings)
4487 expr = convert_and_check (totype, expr);
4489 expr = convert (totype, expr);
4494 /* Build a call to __builtin_trap. */
4497 call_builtin_trap (void)
4499 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4501 gcc_assert (fn != NULL);
4502 fn = build_call (fn, NULL_TREE);
4506 /* ARG is being passed to a varargs function. Perform any conversions
4507 required. Return the converted value. */
4510 convert_arg_to_ellipsis (tree arg)
4514 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4515 standard conversions are performed. */
4516 arg = decay_conversion (arg);
4519 If the argument has integral or enumeration type that is subject
4520 to the integral promotions (_conv.prom_), or a floating point
4521 type that is subject to the floating point promotion
4522 (_conv.fpprom_), the value of the argument is converted to the
4523 promoted type before the call. */
4524 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4525 && (TYPE_PRECISION (TREE_TYPE (arg))
4526 < TYPE_PRECISION (double_type_node)))
4527 arg = convert_to_real (double_type_node, arg);
4528 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4529 arg = perform_integral_promotions (arg);
4531 arg = require_complete_type (arg);
4533 if (arg != error_mark_node
4534 && !pod_type_p (TREE_TYPE (arg)))
4536 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4537 here and do a bitwise copy, but now cp_expr_size will abort if we
4539 If the call appears in the context of a sizeof expression,
4540 there is no need to emit a warning, since the expression won't be
4541 evaluated. We keep the builtin_trap just as a safety check. */
4542 if (!skip_evaluation)
4543 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4544 "call will abort at runtime", TREE_TYPE (arg));
4545 arg = call_builtin_trap ();
4546 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4553 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4556 build_x_va_arg (tree expr, tree type)
4558 if (processing_template_decl)
4559 return build_min (VA_ARG_EXPR, type, expr);
4561 type = complete_type_or_else (type, NULL_TREE);
4563 if (expr == error_mark_node || !type)
4564 return error_mark_node;
4566 if (! pod_type_p (type))
4568 /* Remove reference types so we don't ICE later on. */
4569 tree type1 = non_reference (type);
4570 /* Undefined behavior [expr.call] 5.2.2/7. */
4571 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4572 "call will abort at runtime", type);
4573 expr = convert (build_pointer_type (type1), null_node);
4574 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4575 call_builtin_trap (), expr);
4576 expr = build_indirect_ref (expr, NULL);
4580 return build_va_arg (expr, type);
4583 /* TYPE has been given to va_arg. Apply the default conversions which
4584 would have happened when passed via ellipsis. Return the promoted
4585 type, or the passed type if there is no change. */
4588 cxx_type_promotes_to (tree type)
4592 /* Perform the array-to-pointer and function-to-pointer
4594 type = type_decays_to (type);
4596 promote = type_promotes_to (type);
4597 if (same_type_p (type, promote))
4603 /* ARG is a default argument expression being passed to a parameter of
4604 the indicated TYPE, which is a parameter to FN. Do any required
4605 conversions. Return the converted value. */
4608 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4610 /* If the ARG is an unparsed default argument expression, the
4611 conversion cannot be performed. */
4612 if (TREE_CODE (arg) == DEFAULT_ARG)
4614 error ("the default argument for parameter %d of %qD has "
4615 "not yet been parsed",
4617 return error_mark_node;
4620 if (fn && DECL_TEMPLATE_INFO (fn))
4621 arg = tsubst_default_argument (fn, type, arg);
4623 arg = break_out_target_exprs (arg);
4625 if (TREE_CODE (arg) == CONSTRUCTOR)
4627 arg = digest_init (type, arg);
4628 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4629 "default argument", fn, parmnum);
4633 /* We must make a copy of ARG, in case subsequent processing
4634 alters any part of it. For example, during gimplification a
4635 cast of the form (T) &X::f (where "f" is a member function)
4636 will lead to replacing the PTRMEM_CST for &X::f with a
4637 VAR_DECL. We can avoid the copy for constants, since they
4638 are never modified in place. */
4639 if (!CONSTANT_CLASS_P (arg))
4640 arg = unshare_expr (arg);
4641 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4642 "default argument", fn, parmnum);
4643 arg = convert_for_arg_passing (type, arg);
4649 /* Returns the type which will really be used for passing an argument of
4653 type_passed_as (tree type)
4655 /* Pass classes with copy ctors by invisible reference. */
4656 if (TREE_ADDRESSABLE (type))
4658 type = build_reference_type (type);
4659 /* There are no other pointers to this temporary. */
4660 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4662 else if (targetm.calls.promote_prototypes (type)
4663 && INTEGRAL_TYPE_P (type)
4664 && COMPLETE_TYPE_P (type)
4665 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4666 TYPE_SIZE (integer_type_node)))
4667 type = integer_type_node;
4672 /* Actually perform the appropriate conversion. */
4675 convert_for_arg_passing (tree type, tree val)
4679 /* If VAL is a bitfield, then -- since it has already been converted
4680 to TYPE -- it cannot have a precision greater than TYPE.
4682 If it has a smaller precision, we must widen it here. For
4683 example, passing "int f:3;" to a function expecting an "int" will
4684 not result in any conversion before this point.
4686 If the precision is the same we must not risk widening. For
4687 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
4688 often have type "int", even though the C++ type for the field is
4689 "long long". If the value is being passed to a function
4690 expecting an "int", then no conversions will be required. But,
4691 if we call convert_bitfield_to_declared_type, the bitfield will
4692 be converted to "long long". */
4693 bitfield_type = is_bitfield_expr_with_lowered_type (val);
4695 && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
4696 val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
4698 if (val == error_mark_node)
4700 /* Pass classes with copy ctors by invisible reference. */
4701 else if (TREE_ADDRESSABLE (type))
4702 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4703 else if (targetm.calls.promote_prototypes (type)
4704 && INTEGRAL_TYPE_P (type)
4705 && COMPLETE_TYPE_P (type)
4706 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4707 TYPE_SIZE (integer_type_node)))
4708 val = perform_integral_promotions (val);
4709 if (warn_missing_format_attribute)
4711 tree rhstype = TREE_TYPE (val);
4712 const enum tree_code coder = TREE_CODE (rhstype);
4713 const enum tree_code codel = TREE_CODE (type);
4714 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4716 && check_missing_format_attribute (type, rhstype))
4717 warning (OPT_Wmissing_format_attribute,
4718 "argument of function call might be a candidate for a format attribute");
4723 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4724 which no conversions at all should be done. This is true for some
4725 builtins which don't act like normal functions. */
4728 magic_varargs_p (tree fn)
4730 if (DECL_BUILT_IN (fn))
4731 switch (DECL_FUNCTION_CODE (fn))
4733 case BUILT_IN_CLASSIFY_TYPE:
4734 case BUILT_IN_CONSTANT_P:
4735 case BUILT_IN_NEXT_ARG:
4736 case BUILT_IN_STDARG_START:
4737 case BUILT_IN_VA_START:
4746 /* Subroutine of the various build_*_call functions. Overload resolution
4747 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4748 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4749 bitmask of various LOOKUP_* flags which apply to the call itself. */
4752 build_over_call (struct z_candidate *cand, int flags)
4755 tree args = cand->args;
4756 conversion **convs = cand->convs;
4758 tree converted_args = NULL_TREE;
4759 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4764 /* In a template, there is no need to perform all of the work that
4765 is normally done. We are only interested in the type of the call
4766 expression, i.e., the return type of the function. Any semantic
4767 errors will be deferred until the template is instantiated. */
4768 if (processing_template_decl)
4772 return_type = TREE_TYPE (TREE_TYPE (fn));
4773 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4774 if (TREE_THIS_VOLATILE (fn) && cfun)
4775 current_function_returns_abnormally = 1;
4776 if (!VOID_TYPE_P (return_type))
4777 require_complete_type (return_type);
4778 return convert_from_reference (expr);
4781 /* Give any warnings we noticed during overload resolution. */
4784 struct candidate_warning *w;
4785 for (w = cand->warnings; w; w = w->next)
4786 joust (cand, w->loser, 1);
4789 if (DECL_FUNCTION_MEMBER_P (fn))
4791 /* If FN is a template function, two cases must be considered.
4796 template <class T> void f();
4798 template <class T> struct B {
4802 struct C : A, B<int> {
4804 using B<int>::g; // #2
4807 In case #1 where `A::f' is a member template, DECL_ACCESS is
4808 recorded in the primary template but not in its specialization.
4809 We check access of FN using its primary template.
4811 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4812 because it is a member of class template B, DECL_ACCESS is
4813 recorded in the specialization `B<int>::g'. We cannot use its
4814 primary template because `B<T>::g' and `B<int>::g' may have
4815 different access. */
4816 if (DECL_TEMPLATE_INFO (fn)
4817 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4818 perform_or_defer_access_check (cand->access_path,
4819 DECL_TI_TEMPLATE (fn), fn);
4821 perform_or_defer_access_check (cand->access_path, fn, fn);
4824 if (args && TREE_CODE (args) != TREE_LIST)
4825 args = build_tree_list (NULL_TREE, args);
4828 /* The implicit parameters to a constructor are not considered by overload
4829 resolution, and must be of the proper type. */
4830 if (DECL_CONSTRUCTOR_P (fn))
4832 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4833 arg = TREE_CHAIN (arg);
4834 parm = TREE_CHAIN (parm);
4835 /* We should never try to call the abstract constructor. */
4836 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4838 if (DECL_HAS_VTT_PARM_P (fn))
4840 converted_args = tree_cons
4841 (NULL_TREE, TREE_VALUE (arg), converted_args);
4842 arg = TREE_CHAIN (arg);
4843 parm = TREE_CHAIN (parm);
4846 /* Bypass access control for 'this' parameter. */
4847 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4849 tree parmtype = TREE_VALUE (parm);
4850 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4854 if (convs[i]->bad_p)
4855 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4856 TREE_TYPE (argtype), fn);
4858 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4859 X is called for an object that is not of type X, or of a type
4860 derived from X, the behavior is undefined.
4862 So we can assume that anything passed as 'this' is non-null, and
4863 optimize accordingly. */
4864 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4865 /* Convert to the base in which the function was declared. */
4866 gcc_assert (cand->conversion_path != NULL_TREE);
4867 converted_arg = build_base_path (PLUS_EXPR,
4869 cand->conversion_path,
4871 /* Check that the base class is accessible. */
4872 if (!accessible_base_p (TREE_TYPE (argtype),
4873 BINFO_TYPE (cand->conversion_path), true))
4874 error ("%qT is not an accessible base of %qT",
4875 BINFO_TYPE (cand->conversion_path),
4876 TREE_TYPE (argtype));
4877 /* If fn was found by a using declaration, the conversion path
4878 will be to the derived class, not the base declaring fn. We
4879 must convert from derived to base. */
4880 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4881 TREE_TYPE (parmtype), ba_unique, NULL);
4882 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4885 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4886 parm = TREE_CHAIN (parm);
4887 arg = TREE_CHAIN (arg);
4893 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4895 tree type = TREE_VALUE (parm);
4899 /* Don't make a copy here if build_call is going to. */
4900 if (conv->kind == ck_rvalue
4901 && !TREE_ADDRESSABLE (complete_type (type)))
4902 conv = conv->u.next;
4904 val = convert_like_with_context
4905 (conv, TREE_VALUE (arg), fn, i - is_method);
4907 val = convert_for_arg_passing (type, val);
4908 converted_args = tree_cons (NULL_TREE, val, converted_args);
4911 /* Default arguments */
4912 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4914 = tree_cons (NULL_TREE,
4915 convert_default_arg (TREE_VALUE (parm),
4916 TREE_PURPOSE (parm),
4921 for (; arg; arg = TREE_CHAIN (arg))
4923 tree a = TREE_VALUE (arg);
4924 if (magic_varargs_p (fn))
4925 /* Do no conversions for magic varargs. */;
4927 a = convert_arg_to_ellipsis (a);
4928 converted_args = tree_cons (NULL_TREE, a, converted_args);
4931 converted_args = nreverse (converted_args);
4933 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4934 converted_args, TYPE_ARG_TYPES (TREE_TYPE (fn)));
4936 /* Avoid actually calling copy constructors and copy assignment operators,
4939 if (! flag_elide_constructors)
4940 /* Do things the hard way. */;
4941 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4944 arg = skip_artificial_parms_for (fn, converted_args);
4945 arg = TREE_VALUE (arg);
4947 /* Pull out the real argument, disregarding const-correctness. */
4949 while (TREE_CODE (targ) == NOP_EXPR
4950 || TREE_CODE (targ) == NON_LVALUE_EXPR
4951 || TREE_CODE (targ) == CONVERT_EXPR)
4952 targ = TREE_OPERAND (targ, 0);
4953 if (TREE_CODE (targ) == ADDR_EXPR)
4955 targ = TREE_OPERAND (targ, 0);
4956 if (!same_type_ignoring_top_level_qualifiers_p
4957 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4966 arg = build_indirect_ref (arg, 0);
4968 /* [class.copy]: the copy constructor is implicitly defined even if
4969 the implementation elided its use. */
4970 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4973 /* If we're creating a temp and we already have one, don't create a
4974 new one. If we're not creating a temp but we get one, use
4975 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4976 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4977 temp or an INIT_EXPR otherwise. */
4978 if (integer_zerop (TREE_VALUE (args)))
4980 if (TREE_CODE (arg) == TARGET_EXPR)
4982 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4983 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4985 else if (TREE_CODE (arg) == TARGET_EXPR
4986 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4988 tree to = stabilize_reference
4989 (build_indirect_ref (TREE_VALUE (args), 0));
4991 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4995 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4997 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4999 tree to = stabilize_reference
5000 (build_indirect_ref (TREE_VALUE (converted_args), 0));
5001 tree type = TREE_TYPE (to);
5002 tree as_base = CLASSTYPE_AS_BASE (type);
5004 arg = TREE_VALUE (TREE_CHAIN (converted_args));
5005 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5007 arg = build_indirect_ref (arg, 0);
5008 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5012 /* We must only copy the non-tail padding parts.
5013 Use __builtin_memcpy for the bitwise copy. */
5017 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
5018 args = tree_cons (NULL, arg, args);
5019 t = build_unary_op (ADDR_EXPR, to, 0);
5020 args = tree_cons (NULL, t, args);
5021 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5022 t = build_call (t, args);
5024 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
5025 val = build_indirect_ref (t, 0);
5033 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5035 tree t, *p = &TREE_VALUE (converted_args);
5036 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
5039 gcc_assert (binfo && binfo != error_mark_node);
5041 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
5042 if (TREE_SIDE_EFFECTS (*p))
5043 *p = save_expr (*p);
5044 t = build_pointer_type (TREE_TYPE (fn));
5045 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5046 fn = build_java_interface_fn_ref (fn, *p);
5048 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
5051 else if (DECL_INLINE (fn))
5052 fn = inline_conversion (fn);
5054 fn = build_addr_func (fn);
5056 return build_cxx_call (fn, converted_args);
5059 /* Build and return a call to FN, using ARGS. This function performs
5060 no overload resolution, conversion, or other high-level
5064 build_cxx_call (tree fn, tree args)
5068 fn = build_call (fn, args);
5070 /* If this call might throw an exception, note that fact. */
5071 fndecl = get_callee_fndecl (fn);
5072 if ((!fndecl || !TREE_NOTHROW (fndecl))
5073 && at_function_scope_p ()
5075 cp_function_chain->can_throw = 1;
5077 /* Some built-in function calls will be evaluated at compile-time in
5079 fn = fold_if_not_in_template (fn);
5081 if (VOID_TYPE_P (TREE_TYPE (fn)))
5084 fn = require_complete_type (fn);
5085 if (fn == error_mark_node)
5086 return error_mark_node;
5088 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5089 fn = build_cplus_new (TREE_TYPE (fn), fn);
5090 return convert_from_reference (fn);
5093 static GTY(()) tree java_iface_lookup_fn;
5095 /* Make an expression which yields the address of the Java interface
5096 method FN. This is achieved by generating a call to libjava's
5097 _Jv_LookupInterfaceMethodIdx(). */
5100 build_java_interface_fn_ref (tree fn, tree instance)
5102 tree lookup_args, lookup_fn, method, idx;
5103 tree klass_ref, iface, iface_ref;
5106 if (!java_iface_lookup_fn)
5108 tree endlink = build_void_list_node ();
5109 tree t = tree_cons (NULL_TREE, ptr_type_node,
5110 tree_cons (NULL_TREE, ptr_type_node,
5111 tree_cons (NULL_TREE, java_int_type_node,
5113 java_iface_lookup_fn
5114 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
5115 build_function_type (ptr_type_node, t),
5116 0, NOT_BUILT_IN, NULL, NULL_TREE);
5119 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5120 This is the first entry in the vtable. */
5121 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5124 /* Get the java.lang.Class pointer for the interface being called. */
5125 iface = DECL_CONTEXT (fn);
5126 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5127 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5128 || DECL_CONTEXT (iface_ref) != iface)
5130 error ("could not find class$ field in java interface type %qT",
5132 return error_mark_node;
5134 iface_ref = build_address (iface_ref);
5135 iface_ref = convert (build_pointer_type (iface), iface_ref);
5137 /* Determine the itable index of FN. */
5139 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5141 if (!DECL_VIRTUAL_P (method))
5147 idx = build_int_cst (NULL_TREE, i);
5149 lookup_args = tree_cons (NULL_TREE, klass_ref,
5150 tree_cons (NULL_TREE, iface_ref,
5151 build_tree_list (NULL_TREE, idx)));
5152 lookup_fn = build1 (ADDR_EXPR,
5153 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5154 java_iface_lookup_fn);
5155 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
5158 /* Returns the value to use for the in-charge parameter when making a
5159 call to a function with the indicated NAME.
5161 FIXME:Can't we find a neater way to do this mapping? */
5164 in_charge_arg_for_name (tree name)
5166 if (name == base_ctor_identifier
5167 || name == base_dtor_identifier)
5168 return integer_zero_node;
5169 else if (name == complete_ctor_identifier)
5170 return integer_one_node;
5171 else if (name == complete_dtor_identifier)
5172 return integer_two_node;
5173 else if (name == deleting_dtor_identifier)
5174 return integer_three_node;
5176 /* This function should only be called with one of the names listed
5182 /* Build a call to a constructor, destructor, or an assignment
5183 operator for INSTANCE, an expression with class type. NAME
5184 indicates the special member function to call; ARGS are the
5185 arguments. BINFO indicates the base of INSTANCE that is to be
5186 passed as the `this' parameter to the member function called.
5188 FLAGS are the LOOKUP_* flags to use when processing the call.
5190 If NAME indicates a complete object constructor, INSTANCE may be
5191 NULL_TREE. In this case, the caller will call build_cplus_new to
5192 store the newly constructed object into a VAR_DECL. */
5195 build_special_member_call (tree instance, tree name, tree args,
5196 tree binfo, int flags)
5199 /* The type of the subobject to be constructed or destroyed. */
5202 gcc_assert (name == complete_ctor_identifier
5203 || name == base_ctor_identifier
5204 || name == complete_dtor_identifier
5205 || name == base_dtor_identifier
5206 || name == deleting_dtor_identifier
5207 || name == ansi_assopname (NOP_EXPR));
5210 /* Resolve the name. */
5211 if (!complete_type_or_else (binfo, NULL_TREE))
5212 return error_mark_node;
5214 binfo = TYPE_BINFO (binfo);
5217 gcc_assert (binfo != NULL_TREE);
5219 class_type = BINFO_TYPE (binfo);
5221 /* Handle the special case where INSTANCE is NULL_TREE. */
5222 if (name == complete_ctor_identifier && !instance)
5224 instance = build_int_cst (build_pointer_type (class_type), 0);
5225 instance = build1 (INDIRECT_REF, class_type, instance);
5229 if (name == complete_dtor_identifier
5230 || name == base_dtor_identifier
5231 || name == deleting_dtor_identifier)
5232 gcc_assert (args == NULL_TREE);
5234 /* Convert to the base class, if necessary. */
5235 if (!same_type_ignoring_top_level_qualifiers_p
5236 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5238 if (name != ansi_assopname (NOP_EXPR))
5239 /* For constructors and destructors, either the base is
5240 non-virtual, or it is virtual but we are doing the
5241 conversion from a constructor or destructor for the
5242 complete object. In either case, we can convert
5244 instance = convert_to_base_statically (instance, binfo);
5246 /* However, for assignment operators, we must convert
5247 dynamically if the base is virtual. */
5248 instance = build_base_path (PLUS_EXPR, instance,
5249 binfo, /*nonnull=*/1);
5253 gcc_assert (instance != NULL_TREE);
5255 fns = lookup_fnfields (binfo, name, 1);
5257 /* When making a call to a constructor or destructor for a subobject
5258 that uses virtual base classes, pass down a pointer to a VTT for
5260 if ((name == base_ctor_identifier
5261 || name == base_dtor_identifier)
5262 && CLASSTYPE_VBASECLASSES (class_type))
5267 /* If the current function is a complete object constructor
5268 or destructor, then we fetch the VTT directly.
5269 Otherwise, we look it up using the VTT we were given. */
5270 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5271 vtt = decay_conversion (vtt);
5272 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5273 build2 (EQ_EXPR, boolean_type_node,
5274 current_in_charge_parm, integer_zero_node),
5277 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5278 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5279 BINFO_SUBVTT_INDEX (binfo));
5281 args = tree_cons (NULL_TREE, sub_vtt, args);
5284 return build_new_method_call (instance, fns, args,
5285 TYPE_BINFO (BINFO_TYPE (binfo)),
5286 flags, /*fn=*/NULL);
5289 /* Return the NAME, as a C string. The NAME indicates a function that
5290 is a member of TYPE. *FREE_P is set to true if the caller must
5291 free the memory returned.
5293 Rather than go through all of this, we should simply set the names
5294 of constructors and destructors appropriately, and dispense with
5295 ctor_identifier, dtor_identifier, etc. */
5298 name_as_c_string (tree name, tree type, bool *free_p)
5302 /* Assume that we will not allocate memory. */
5304 /* Constructors and destructors are special. */
5305 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5308 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5309 /* For a destructor, add the '~'. */
5310 if (name == complete_dtor_identifier
5311 || name == base_dtor_identifier
5312 || name == deleting_dtor_identifier)
5314 pretty_name = concat ("~", pretty_name, NULL);
5315 /* Remember that we need to free the memory allocated. */
5319 else if (IDENTIFIER_TYPENAME_P (name))
5321 pretty_name = concat ("operator ",
5322 type_as_string (TREE_TYPE (name),
5323 TFF_PLAIN_IDENTIFIER),
5325 /* Remember that we need to free the memory allocated. */
5329 pretty_name = (char *) IDENTIFIER_POINTER (name);
5334 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5335 be set, upon return, to the function called. */
5338 build_new_method_call (tree instance, tree fns, tree args,
5339 tree conversion_path, int flags,
5342 struct z_candidate *candidates = 0, *cand;
5343 tree explicit_targs = NULL_TREE;
5344 tree basetype = NULL_TREE;
5347 tree mem_args = NULL_TREE, instance_ptr;
5353 int template_only = 0;
5360 gcc_assert (instance != NULL_TREE);
5362 /* We don't know what function we're going to call, yet. */
5366 if (error_operand_p (instance)
5367 || error_operand_p (fns)
5368 || args == error_mark_node)
5369 return error_mark_node;
5371 if (!BASELINK_P (fns))
5373 error ("call to non-function %qD", fns);
5374 return error_mark_node;
5377 orig_instance = instance;
5381 /* Dismantle the baselink to collect all the information we need. */
5382 if (!conversion_path)
5383 conversion_path = BASELINK_BINFO (fns);
5384 access_binfo = BASELINK_ACCESS_BINFO (fns);
5385 optype = BASELINK_OPTYPE (fns);
5386 fns = BASELINK_FUNCTIONS (fns);
5387 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5389 explicit_targs = TREE_OPERAND (fns, 1);
5390 fns = TREE_OPERAND (fns, 0);
5393 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5394 || TREE_CODE (fns) == TEMPLATE_DECL
5395 || TREE_CODE (fns) == OVERLOAD);
5396 fn = get_first_fn (fns);
5397 name = DECL_NAME (fn);
5399 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5400 gcc_assert (CLASS_TYPE_P (basetype));
5402 if (processing_template_decl)
5404 instance = build_non_dependent_expr (instance);
5405 args = build_non_dependent_args (orig_args);
5408 /* The USER_ARGS are the arguments we will display to users if an
5409 error occurs. The USER_ARGS should not include any
5410 compiler-generated arguments. The "this" pointer hasn't been
5411 added yet. However, we must remove the VTT pointer if this is a
5412 call to a base-class constructor or destructor. */
5414 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5416 /* Callers should explicitly indicate whether they want to construct
5417 the complete object or just the part without virtual bases. */
5418 gcc_assert (name != ctor_identifier);
5419 /* Similarly for destructors. */
5420 gcc_assert (name != dtor_identifier);
5421 /* Remove the VTT pointer, if present. */
5422 if ((name == base_ctor_identifier || name == base_dtor_identifier)
5423 && CLASSTYPE_VBASECLASSES (basetype))
5424 user_args = TREE_CHAIN (user_args);
5427 /* Process the argument list. */
5428 args = resolve_args (args);
5429 if (args == error_mark_node)
5430 return error_mark_node;
5432 instance_ptr = build_this (instance);
5434 /* It's OK to call destructors on cv-qualified objects. Therefore,
5435 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5436 if (DECL_DESTRUCTOR_P (fn))
5438 tree type = build_pointer_type (basetype);
5439 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5440 instance_ptr = build_nop (type, instance_ptr);
5441 name = complete_dtor_identifier;
5444 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5445 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5447 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5448 p = conversion_obstack_alloc (0);
5450 for (fn = fns; fn; fn = OVL_NEXT (fn))
5452 tree t = OVL_CURRENT (fn);
5455 /* We can end up here for copy-init of same or base class. */
5456 if ((flags & LOOKUP_ONLYCONVERTING)
5457 && DECL_NONCONVERTING_P (t))
5460 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5461 this_arglist = mem_args;
5463 this_arglist = args;
5465 if (TREE_CODE (t) == TEMPLATE_DECL)
5466 /* A member template. */
5467 add_template_candidate (&candidates, t,
5470 this_arglist, optype,
5475 else if (! template_only)
5476 add_function_candidate (&candidates, t,
5484 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5487 if (!COMPLETE_TYPE_P (basetype))
5488 cxx_incomplete_type_error (instance_ptr, basetype);
5494 pretty_name = name_as_c_string (name, basetype, &free_p);
5495 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5496 basetype, pretty_name, user_args,
5497 TREE_TYPE (TREE_TYPE (instance_ptr)));
5501 print_z_candidates (candidates);
5502 call = error_mark_node;
5506 cand = tourney (candidates);
5512 pretty_name = name_as_c_string (name, basetype, &free_p);
5513 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5515 print_z_candidates (candidates);
5518 call = error_mark_node;
5524 if (!(flags & LOOKUP_NONVIRTUAL)
5525 && DECL_PURE_VIRTUAL_P (fn)
5526 && instance == current_class_ref
5527 && (DECL_CONSTRUCTOR_P (current_function_decl)
5528 || DECL_DESTRUCTOR_P (current_function_decl)))
5529 /* This is not an error, it is runtime undefined
5531 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5532 "abstract virtual %q#D called from constructor"
5533 : "abstract virtual %q#D called from destructor"),
5536 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5537 && is_dummy_object (instance_ptr))
5539 error ("cannot call member function %qD without object",
5541 call = error_mark_node;
5545 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5546 && resolves_to_fixed_type_p (instance, 0))
5547 flags |= LOOKUP_NONVIRTUAL;
5548 /* Now we know what function is being called. */
5551 /* Build the actual CALL_EXPR. */
5552 call = build_over_call (cand, flags);
5553 /* In an expression of the form `a->f()' where `f' turns
5554 out to be a static member function, `a' is
5555 none-the-less evaluated. */
5556 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
5557 && !is_dummy_object (instance_ptr)
5558 && TREE_SIDE_EFFECTS (instance_ptr))
5559 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5560 instance_ptr, call);
5561 else if (call != error_mark_node
5562 && DECL_DESTRUCTOR_P (cand->fn)
5563 && !VOID_TYPE_P (TREE_TYPE (call)))
5564 /* An explicit call of the form "x->~X()" has type
5565 "void". However, on platforms where destructors
5566 return "this" (i.e., those where
5567 targetm.cxx.cdtor_returns_this is true), such calls
5568 will appear to have a return value of pointer type
5569 to the low-level call machinery. We do not want to
5570 change the low-level machinery, since we want to be
5571 able to optimize "delete f()" on such platforms as
5572 "operator delete(~X(f()))" (rather than generating
5573 "t = f(), ~X(t), operator delete (t)"). */
5574 call = build_nop (void_type_node, call);
5579 if (processing_template_decl && call != error_mark_node)
5580 call = (build_min_non_dep
5582 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5583 orig_args, NULL_TREE));
5585 /* Free all the conversions we allocated. */
5586 obstack_free (&conversion_obstack, p);
5591 /* Returns true iff standard conversion sequence ICS1 is a proper
5592 subsequence of ICS2. */
5595 is_subseq (conversion *ics1, conversion *ics2)
5597 /* We can assume that a conversion of the same code
5598 between the same types indicates a subsequence since we only get
5599 here if the types we are converting from are the same. */
5601 while (ics1->kind == ck_rvalue
5602 || ics1->kind == ck_lvalue)
5603 ics1 = ics1->u.next;
5607 while (ics2->kind == ck_rvalue
5608 || ics2->kind == ck_lvalue)
5609 ics2 = ics2->u.next;
5611 if (ics2->kind == ck_user
5612 || ics2->kind == ck_ambig
5613 || ics2->kind == ck_identity)
5614 /* At this point, ICS1 cannot be a proper subsequence of
5615 ICS2. We can get a USER_CONV when we are comparing the
5616 second standard conversion sequence of two user conversion
5620 ics2 = ics2->u.next;
5622 if (ics2->kind == ics1->kind
5623 && same_type_p (ics2->type, ics1->type)
5624 && same_type_p (ics2->u.next->type,
5625 ics1->u.next->type))
5630 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5631 be any _TYPE nodes. */
5634 is_properly_derived_from (tree derived, tree base)
5636 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5637 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5640 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5641 considers every class derived from itself. */
5642 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5643 && DERIVED_FROM_P (base, derived));
5646 /* We build the ICS for an implicit object parameter as a pointer
5647 conversion sequence. However, such a sequence should be compared
5648 as if it were a reference conversion sequence. If ICS is the
5649 implicit conversion sequence for an implicit object parameter,
5650 modify it accordingly. */
5653 maybe_handle_implicit_object (conversion **ics)
5657 /* [over.match.funcs]
5659 For non-static member functions, the type of the
5660 implicit object parameter is "reference to cv X"
5661 where X is the class of which the function is a
5662 member and cv is the cv-qualification on the member
5663 function declaration. */
5664 conversion *t = *ics;
5665 tree reference_type;
5667 /* The `this' parameter is a pointer to a class type. Make the
5668 implicit conversion talk about a reference to that same class
5670 reference_type = TREE_TYPE (t->type);
5671 reference_type = build_reference_type (reference_type);
5673 if (t->kind == ck_qual)
5675 if (t->kind == ck_ptr)
5677 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5678 t = direct_reference_binding (reference_type, t);
5683 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5684 and return the type to which the reference refers. Otherwise,
5685 leave *ICS unchanged and return NULL_TREE. */
5688 maybe_handle_ref_bind (conversion **ics)
5690 if ((*ics)->kind == ck_ref_bind)
5692 conversion *old_ics = *ics;
5693 tree type = TREE_TYPE (old_ics->type);
5694 *ics = old_ics->u.next;
5695 (*ics)->user_conv_p = old_ics->user_conv_p;
5696 (*ics)->bad_p = old_ics->bad_p;
5703 /* Compare two implicit conversion sequences according to the rules set out in
5704 [over.ics.rank]. Return values:
5706 1: ics1 is better than ics2
5707 -1: ics2 is better than ics1
5708 0: ics1 and ics2 are indistinguishable */
5711 compare_ics (conversion *ics1, conversion *ics2)
5717 tree deref_from_type1 = NULL_TREE;
5718 tree deref_from_type2 = NULL_TREE;
5719 tree deref_to_type1 = NULL_TREE;
5720 tree deref_to_type2 = NULL_TREE;
5721 conversion_rank rank1, rank2;
5723 /* REF_BINDING is nonzero if the result of the conversion sequence
5724 is a reference type. In that case TARGET_TYPE is the
5725 type referred to by the reference. */
5729 /* Handle implicit object parameters. */
5730 maybe_handle_implicit_object (&ics1);
5731 maybe_handle_implicit_object (&ics2);
5733 /* Handle reference parameters. */
5734 target_type1 = maybe_handle_ref_bind (&ics1);
5735 target_type2 = maybe_handle_ref_bind (&ics2);
5739 When comparing the basic forms of implicit conversion sequences (as
5740 defined in _over.best.ics_)
5742 --a standard conversion sequence (_over.ics.scs_) is a better
5743 conversion sequence than a user-defined conversion sequence
5744 or an ellipsis conversion sequence, and
5746 --a user-defined conversion sequence (_over.ics.user_) is a
5747 better conversion sequence than an ellipsis conversion sequence
5748 (_over.ics.ellipsis_). */
5749 rank1 = CONVERSION_RANK (ics1);
5750 rank2 = CONVERSION_RANK (ics2);
5754 else if (rank1 < rank2)
5757 if (rank1 == cr_bad)
5759 /* XXX Isn't this an extension? */
5760 /* Both ICS are bad. We try to make a decision based on what
5761 would have happened if they'd been good. */
5762 if (ics1->user_conv_p > ics2->user_conv_p
5763 || ics1->rank > ics2->rank)
5765 else if (ics1->user_conv_p < ics2->user_conv_p
5766 || ics1->rank < ics2->rank)
5769 /* We couldn't make up our minds; try to figure it out below. */
5772 if (ics1->ellipsis_p)
5773 /* Both conversions are ellipsis conversions. */
5776 /* User-defined conversion sequence U1 is a better conversion sequence
5777 than another user-defined conversion sequence U2 if they contain the
5778 same user-defined conversion operator or constructor and if the sec-
5779 ond standard conversion sequence of U1 is better than the second
5780 standard conversion sequence of U2. */
5782 if (ics1->user_conv_p)
5787 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5788 if (t1->kind == ck_ambig)
5790 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5791 if (t2->kind == ck_ambig)
5794 if (t1->cand->fn != t2->cand->fn)
5797 /* We can just fall through here, after setting up
5798 FROM_TYPE1 and FROM_TYPE2. */
5799 from_type1 = t1->type;
5800 from_type2 = t2->type;
5807 /* We're dealing with two standard conversion sequences.
5811 Standard conversion sequence S1 is a better conversion
5812 sequence than standard conversion sequence S2 if
5814 --S1 is a proper subsequence of S2 (comparing the conversion
5815 sequences in the canonical form defined by _over.ics.scs_,
5816 excluding any Lvalue Transformation; the identity
5817 conversion sequence is considered to be a subsequence of
5818 any non-identity conversion sequence */
5821 while (t1->kind != ck_identity)
5823 from_type1 = t1->type;
5826 while (t2->kind != ck_identity)
5828 from_type2 = t2->type;
5831 if (same_type_p (from_type1, from_type2))
5833 if (is_subseq (ics1, ics2))
5835 if (is_subseq (ics2, ics1))
5838 /* Otherwise, one sequence cannot be a subsequence of the other; they
5839 don't start with the same type. This can happen when comparing the
5840 second standard conversion sequence in two user-defined conversion
5847 --the rank of S1 is better than the rank of S2 (by the rules
5850 Standard conversion sequences are ordered by their ranks: an Exact
5851 Match is a better conversion than a Promotion, which is a better
5852 conversion than a Conversion.
5854 Two conversion sequences with the same rank are indistinguishable
5855 unless one of the following rules applies:
5857 --A conversion that is not a conversion of a pointer, or pointer
5858 to member, to bool is better than another conversion that is such
5861 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5862 so that we do not have to check it explicitly. */
5863 if (ics1->rank < ics2->rank)
5865 else if (ics2->rank < ics1->rank)
5868 to_type1 = ics1->type;
5869 to_type2 = ics2->type;
5871 if (TYPE_PTR_P (from_type1)
5872 && TYPE_PTR_P (from_type2)
5873 && TYPE_PTR_P (to_type1)
5874 && TYPE_PTR_P (to_type2))
5876 deref_from_type1 = TREE_TYPE (from_type1);
5877 deref_from_type2 = TREE_TYPE (from_type2);
5878 deref_to_type1 = TREE_TYPE (to_type1);
5879 deref_to_type2 = TREE_TYPE (to_type2);
5881 /* The rules for pointers to members A::* are just like the rules
5882 for pointers A*, except opposite: if B is derived from A then
5883 A::* converts to B::*, not vice versa. For that reason, we
5884 switch the from_ and to_ variables here. */
5885 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5886 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5887 || (TYPE_PTRMEMFUNC_P (from_type1)
5888 && TYPE_PTRMEMFUNC_P (from_type2)
5889 && TYPE_PTRMEMFUNC_P (to_type1)
5890 && TYPE_PTRMEMFUNC_P (to_type2)))
5892 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5893 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5894 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5895 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5898 if (deref_from_type1 != NULL_TREE
5899 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5900 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5902 /* This was one of the pointer or pointer-like conversions.
5906 --If class B is derived directly or indirectly from class A,
5907 conversion of B* to A* is better than conversion of B* to
5908 void*, and conversion of A* to void* is better than
5909 conversion of B* to void*. */
5910 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5911 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5913 if (is_properly_derived_from (deref_from_type1,
5916 else if (is_properly_derived_from (deref_from_type2,
5920 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5921 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5923 if (same_type_p (deref_from_type1, deref_from_type2))
5925 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5927 if (is_properly_derived_from (deref_from_type1,
5931 /* We know that DEREF_TO_TYPE1 is `void' here. */
5932 else if (is_properly_derived_from (deref_from_type1,
5937 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5938 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5942 --If class B is derived directly or indirectly from class A
5943 and class C is derived directly or indirectly from B,
5945 --conversion of C* to B* is better than conversion of C* to
5948 --conversion of B* to A* is better than conversion of C* to
5950 if (same_type_p (deref_from_type1, deref_from_type2))
5952 if (is_properly_derived_from (deref_to_type1,
5955 else if (is_properly_derived_from (deref_to_type2,
5959 else if (same_type_p (deref_to_type1, deref_to_type2))
5961 if (is_properly_derived_from (deref_from_type2,
5964 else if (is_properly_derived_from (deref_from_type1,
5970 else if (CLASS_TYPE_P (non_reference (from_type1))
5971 && same_type_p (from_type1, from_type2))
5973 tree from = non_reference (from_type1);
5977 --binding of an expression of type C to a reference of type
5978 B& is better than binding an expression of type C to a
5979 reference of type A&
5981 --conversion of C to B is better than conversion of C to A, */
5982 if (is_properly_derived_from (from, to_type1)
5983 && is_properly_derived_from (from, to_type2))
5985 if (is_properly_derived_from (to_type1, to_type2))
5987 else if (is_properly_derived_from (to_type2, to_type1))
5991 else if (CLASS_TYPE_P (non_reference (to_type1))
5992 && same_type_p (to_type1, to_type2))
5994 tree to = non_reference (to_type1);
5998 --binding of an expression of type B to a reference of type
5999 A& is better than binding an expression of type C to a
6000 reference of type A&,
6002 --conversion of B to A is better than conversion of C to A */
6003 if (is_properly_derived_from (from_type1, to)
6004 && is_properly_derived_from (from_type2, to))
6006 if (is_properly_derived_from (from_type2, from_type1))
6008 else if (is_properly_derived_from (from_type1, from_type2))
6015 --S1 and S2 differ only in their qualification conversion and yield
6016 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6017 qualification signature of type T1 is a proper subset of the cv-
6018 qualification signature of type T2 */
6019 if (ics1->kind == ck_qual
6020 && ics2->kind == ck_qual
6021 && same_type_p (from_type1, from_type2))
6022 return comp_cv_qual_signature (to_type1, to_type2);
6026 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6027 types to which the references refer are the same type except for
6028 top-level cv-qualifiers, and the type to which the reference
6029 initialized by S2 refers is more cv-qualified than the type to
6030 which the reference initialized by S1 refers */
6032 if (target_type1 && target_type2
6033 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
6034 return comp_cv_qualification (target_type2, target_type1);
6036 /* Neither conversion sequence is better than the other. */
6040 /* The source type for this standard conversion sequence. */
6043 source_type (conversion *t)
6045 for (;; t = t->u.next)
6047 if (t->kind == ck_user
6048 || t->kind == ck_ambig
6049 || t->kind == ck_identity)
6055 /* Note a warning about preferring WINNER to LOSER. We do this by storing
6056 a pointer to LOSER and re-running joust to produce the warning if WINNER
6057 is actually used. */
6060 add_warning (struct z_candidate *winner, struct z_candidate *loser)
6062 candidate_warning *cw = (candidate_warning *)
6063 conversion_obstack_alloc (sizeof (candidate_warning));
6065 cw->next = winner->warnings;
6066 winner->warnings = cw;
6069 /* Compare two candidates for overloading as described in
6070 [over.match.best]. Return values:
6072 1: cand1 is better than cand2
6073 -1: cand2 is better than cand1
6074 0: cand1 and cand2 are indistinguishable */
6077 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6080 int off1 = 0, off2 = 0;
6084 /* Candidates that involve bad conversions are always worse than those
6086 if (cand1->viable > cand2->viable)
6088 if (cand1->viable < cand2->viable)
6091 /* If we have two pseudo-candidates for conversions to the same type,
6092 or two candidates for the same function, arbitrarily pick one. */
6093 if (cand1->fn == cand2->fn
6094 && (IS_TYPE_OR_DECL_P (cand1->fn)))
6097 /* a viable function F1
6098 is defined to be a better function than another viable function F2 if
6099 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6100 ICSi(F2), and then */
6102 /* for some argument j, ICSj(F1) is a better conversion sequence than
6105 /* For comparing static and non-static member functions, we ignore
6106 the implicit object parameter of the non-static function. The
6107 standard says to pretend that the static function has an object
6108 parm, but that won't work with operator overloading. */
6109 len = cand1->num_convs;
6110 if (len != cand2->num_convs)
6112 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6113 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6115 gcc_assert (static_1 != static_2);
6126 for (i = 0; i < len; ++i)
6128 conversion *t1 = cand1->convs[i + off1];
6129 conversion *t2 = cand2->convs[i + off2];
6130 int comp = compare_ics (t1, t2);
6135 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6136 == cr_std + cr_promotion)
6137 && t1->kind == ck_std
6138 && t2->kind == ck_std
6139 && TREE_CODE (t1->type) == INTEGER_TYPE
6140 && TREE_CODE (t2->type) == INTEGER_TYPE
6141 && (TYPE_PRECISION (t1->type)
6142 == TYPE_PRECISION (t2->type))
6143 && (TYPE_UNSIGNED (t1->u.next->type)
6144 || (TREE_CODE (t1->u.next->type)
6147 tree type = t1->u.next->type;
6149 struct z_candidate *w, *l;
6151 type1 = t1->type, type2 = t2->type,
6152 w = cand1, l = cand2;
6154 type1 = t2->type, type2 = t1->type,
6155 w = cand2, l = cand1;
6159 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6160 type, type1, type2);
6161 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
6167 if (winner && comp != winner)
6176 /* warn about confusing overload resolution for user-defined conversions,
6177 either between a constructor and a conversion op, or between two
6179 if (winner && warn_conversion && cand1->second_conv
6180 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6181 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6183 struct z_candidate *w, *l;
6184 bool give_warning = false;
6187 w = cand1, l = cand2;
6189 w = cand2, l = cand1;
6191 /* We don't want to complain about `X::operator T1 ()'
6192 beating `X::operator T2 () const', when T2 is a no less
6193 cv-qualified version of T1. */
6194 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6195 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6197 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6198 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6200 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6205 if (!comp_ptr_ttypes (t, f))
6206 give_warning = true;
6209 give_warning = true;
6215 tree source = source_type (w->convs[0]);
6216 if (! DECL_CONSTRUCTOR_P (w->fn))
6217 source = TREE_TYPE (source);
6218 warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn);
6219 warning (OPT_Wconversion, " for conversion from %qT to %qT",
6220 source, w->second_conv->type);
6221 inform (" because conversion sequence for the argument is better");
6231 F1 is a non-template function and F2 is a template function
6234 if (!cand1->template_decl && cand2->template_decl)
6236 else if (cand1->template_decl && !cand2->template_decl)
6240 F1 and F2 are template functions and the function template for F1 is
6241 more specialized than the template for F2 according to the partial
6244 if (cand1->template_decl && cand2->template_decl)
6246 winner = more_specialized_fn
6247 (TI_TEMPLATE (cand1->template_decl),
6248 TI_TEMPLATE (cand2->template_decl),
6249 /* [temp.func.order]: The presence of unused ellipsis and default
6250 arguments has no effect on the partial ordering of function
6251 templates. add_function_candidate() will not have
6252 counted the "this" argument for constructors. */
6253 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6259 the context is an initialization by user-defined conversion (see
6260 _dcl.init_ and _over.match.user_) and the standard conversion
6261 sequence from the return type of F1 to the destination type (i.e.,
6262 the type of the entity being initialized) is a better conversion
6263 sequence than the standard conversion sequence from the return type
6264 of F2 to the destination type. */
6266 if (cand1->second_conv)
6268 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6273 /* Check whether we can discard a builtin candidate, either because we
6274 have two identical ones or matching builtin and non-builtin candidates.
6276 (Pedantically in the latter case the builtin which matched the user
6277 function should not be added to the overload set, but we spot it here.
6280 ... the builtin candidates include ...
6281 - do not have the same parameter type list as any non-template
6282 non-member candidate. */
6284 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6285 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6287 for (i = 0; i < len; ++i)
6288 if (!same_type_p (cand1->convs[i]->type,
6289 cand2->convs[i]->type))
6291 if (i == cand1->num_convs)
6293 if (cand1->fn == cand2->fn)
6294 /* Two built-in candidates; arbitrarily pick one. */
6296 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6297 /* cand1 is built-in; prefer cand2. */
6300 /* cand2 is built-in; prefer cand1. */
6305 /* If the two functions are the same (this can happen with declarations
6306 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6307 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6308 && equal_functions (cand1->fn, cand2->fn))
6313 /* Extension: If the worst conversion for one candidate is worse than the
6314 worst conversion for the other, take the first. */
6317 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6318 struct z_candidate *w = 0, *l = 0;
6320 for (i = 0; i < len; ++i)
6322 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6323 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6324 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6325 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6328 winner = 1, w = cand1, l = cand2;
6330 winner = -1, w = cand2, l = cand1;
6336 ISO C++ says that these are ambiguous, even \
6337 though the worst conversion for the first is better than \
6338 the worst conversion for the second:");
6339 print_z_candidate (_("candidate 1:"), w);
6340 print_z_candidate (_("candidate 2:"), l);
6348 gcc_assert (!winner);
6352 /* Given a list of candidates for overloading, find the best one, if any.
6353 This algorithm has a worst case of O(2n) (winner is last), and a best
6354 case of O(n/2) (totally ambiguous); much better than a sorting
6357 static struct z_candidate *
6358 tourney (struct z_candidate *candidates)
6360 struct z_candidate *champ = candidates, *challenger;
6362 int champ_compared_to_predecessor = 0;
6364 /* Walk through the list once, comparing each current champ to the next
6365 candidate, knocking out a candidate or two with each comparison. */
6367 for (challenger = champ->next; challenger; )
6369 fate = joust (champ, challenger, 0);
6371 challenger = challenger->next;
6376 champ = challenger->next;
6379 champ_compared_to_predecessor = 0;
6384 champ_compared_to_predecessor = 1;
6387 challenger = champ->next;
6391 /* Make sure the champ is better than all the candidates it hasn't yet
6392 been compared to. */
6394 for (challenger = candidates;
6396 && !(champ_compared_to_predecessor && challenger->next == champ);
6397 challenger = challenger->next)
6399 fate = joust (champ, challenger, 0);
6407 /* Returns nonzero if things of type FROM can be converted to TO. */
6410 can_convert (tree to, tree from)
6412 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6415 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6418 can_convert_arg (tree to, tree from, tree arg, int flags)
6424 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6425 p = conversion_obstack_alloc (0);
6427 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6429 ok_p = (t && !t->bad_p);
6431 /* Free all the conversions we allocated. */
6432 obstack_free (&conversion_obstack, p);
6437 /* Like can_convert_arg, but allows dubious conversions as well. */
6440 can_convert_arg_bad (tree to, tree from, tree arg)
6445 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6446 p = conversion_obstack_alloc (0);
6447 /* Try to perform the conversion. */
6448 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6450 /* Free all the conversions we allocated. */
6451 obstack_free (&conversion_obstack, p);
6456 /* Convert EXPR to TYPE. Return the converted expression.
6458 Note that we allow bad conversions here because by the time we get to
6459 this point we are committed to doing the conversion. If we end up
6460 doing a bad conversion, convert_like will complain. */
6463 perform_implicit_conversion (tree type, tree expr)
6468 if (error_operand_p (expr))
6469 return error_mark_node;
6471 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6472 p = conversion_obstack_alloc (0);
6474 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6479 error ("could not convert %qE to %qT", expr, type);
6480 expr = error_mark_node;
6482 else if (processing_template_decl)
6484 /* In a template, we are only concerned about determining the
6485 type of non-dependent expressions, so we do not have to
6486 perform the actual conversion. */
6487 if (TREE_TYPE (expr) != type)
6488 expr = build_nop (type, expr);
6491 expr = convert_like (conv, expr);
6493 /* Free all the conversions we allocated. */
6494 obstack_free (&conversion_obstack, p);
6499 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6500 permitted. If the conversion is valid, the converted expression is
6501 returned. Otherwise, NULL_TREE is returned, except in the case
6502 that TYPE is a class type; in that case, an error is issued. If
6503 C_CAST_P is true, then this direction initialization is taking
6504 place as part of a static_cast being attempted as part of a C-style
6508 perform_direct_initialization_if_possible (tree type,
6515 if (type == error_mark_node || error_operand_p (expr))
6516 return error_mark_node;
6519 If the destination type is a (possibly cv-qualified) class type:
6521 -- If the initialization is direct-initialization ...,
6522 constructors are considered. ... If no constructor applies, or
6523 the overload resolution is ambiguous, the initialization is
6525 if (CLASS_TYPE_P (type))
6527 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6528 build_tree_list (NULL_TREE, expr),
6529 type, LOOKUP_NORMAL);
6530 return build_cplus_new (type, expr);
6533 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6534 p = conversion_obstack_alloc (0);
6536 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6539 if (!conv || conv->bad_p)
6542 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6543 /*issue_conversion_warnings=*/false,
6546 /* Free all the conversions we allocated. */
6547 obstack_free (&conversion_obstack, p);
6552 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6553 is being bound to a temporary. Create and return a new VAR_DECL
6554 with the indicated TYPE; this variable will store the value to
6555 which the reference is bound. */
6558 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6562 /* Create the variable. */
6563 var = create_temporary_var (type);
6565 /* Register the variable. */
6566 if (TREE_STATIC (decl))
6568 /* Namespace-scope or local static; give it a mangled name. */
6571 TREE_STATIC (var) = 1;
6572 name = mangle_ref_init_variable (decl);
6573 DECL_NAME (var) = name;
6574 SET_DECL_ASSEMBLER_NAME (var, name);
6575 var = pushdecl_top_level (var);
6578 /* Create a new cleanup level if necessary. */
6579 maybe_push_cleanup_level (type);
6584 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6585 initializing a variable of that TYPE. If DECL is non-NULL, it is
6586 the VAR_DECL being initialized with the EXPR. (In that case, the
6587 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6588 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6589 return, if *CLEANUP is no longer NULL, it will be an expression
6590 that should be pushed as a cleanup after the returned expression
6591 is used to initialize DECL.
6593 Return the converted expression. */
6596 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6601 if (type == error_mark_node || error_operand_p (expr))
6602 return error_mark_node;
6604 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6605 p = conversion_obstack_alloc (0);
6607 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
6609 if (!conv || conv->bad_p)
6611 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6612 && !real_lvalue_p (expr))
6613 error ("invalid initialization of non-const reference of "
6614 "type %qT from a temporary of type %qT",
6615 type, TREE_TYPE (expr));
6617 error ("invalid initialization of reference of type "
6618 "%qT from expression of type %qT", type,
6620 return error_mark_node;
6623 /* If DECL is non-NULL, then this special rule applies:
6627 The temporary to which the reference is bound or the temporary
6628 that is the complete object to which the reference is bound
6629 persists for the lifetime of the reference.
6631 The temporaries created during the evaluation of the expression
6632 initializing the reference, except the temporary to which the
6633 reference is bound, are destroyed at the end of the
6634 full-expression in which they are created.
6636 In that case, we store the converted expression into a new
6637 VAR_DECL in a new scope.
6639 However, we want to be careful not to create temporaries when
6640 they are not required. For example, given:
6643 struct D : public B {};
6647 there is no need to copy the return value from "f"; we can just
6648 extend its lifetime. Similarly, given:
6651 struct T { operator S(); };
6655 we can extend the lifetime of the return value of the conversion
6657 gcc_assert (conv->kind == ck_ref_bind);
6661 tree base_conv_type;
6663 /* Skip over the REF_BIND. */
6664 conv = conv->u.next;
6665 /* If the next conversion is a BASE_CONV, skip that too -- but
6666 remember that the conversion was required. */
6667 if (conv->kind == ck_base)
6669 if (conv->check_copy_constructor_p)
6670 check_constructor_callable (TREE_TYPE (expr), expr);
6671 base_conv_type = conv->type;
6672 conv = conv->u.next;
6675 base_conv_type = NULL_TREE;
6676 /* Perform the remainder of the conversion. */
6677 expr = convert_like_real (conv, expr,
6678 /*fn=*/NULL_TREE, /*argnum=*/0,
6680 /*issue_conversion_warnings=*/true,
6681 /*c_cast_p=*/false);
6682 if (error_operand_p (expr))
6683 expr = error_mark_node;
6686 if (!real_lvalue_p (expr))
6691 /* Create the temporary variable. */
6692 type = TREE_TYPE (expr);
6693 var = make_temporary_var_for_ref_to_temp (decl, type);
6694 layout_decl (var, 0);
6695 /* If the rvalue is the result of a function call it will be
6696 a TARGET_EXPR. If it is some other construct (such as a
6697 member access expression where the underlying object is
6698 itself the result of a function call), turn it into a
6699 TARGET_EXPR here. It is important that EXPR be a
6700 TARGET_EXPR below since otherwise the INIT_EXPR will
6701 attempt to make a bitwise copy of EXPR to initialize
6703 if (TREE_CODE (expr) != TARGET_EXPR)
6704 expr = get_target_expr (expr);
6705 /* Create the INIT_EXPR that will initialize the temporary
6707 init = build2 (INIT_EXPR, type, var, expr);
6708 if (at_function_scope_p ())
6710 add_decl_expr (var);
6711 *cleanup = cxx_maybe_build_cleanup (var);
6713 /* We must be careful to destroy the temporary only
6714 after its initialization has taken place. If the
6715 initialization throws an exception, then the
6716 destructor should not be run. We cannot simply
6717 transform INIT into something like:
6719 (INIT, ({ CLEANUP_STMT; }))
6721 because emit_local_var always treats the
6722 initializer as a full-expression. Thus, the
6723 destructor would run too early; it would run at the
6724 end of initializing the reference variable, rather
6725 than at the end of the block enclosing the
6728 The solution is to pass back a cleanup expression
6729 which the caller is responsible for attaching to
6730 the statement tree. */
6734 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6735 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6736 static_aggregates = tree_cons (NULL_TREE, var,
6739 /* Use its address to initialize the reference variable. */
6740 expr = build_address (var);
6742 expr = convert_to_base (expr,
6743 build_pointer_type (base_conv_type),
6744 /*check_access=*/true,
6746 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6749 /* Take the address of EXPR. */
6750 expr = build_unary_op (ADDR_EXPR, expr, 0);
6751 /* If a BASE_CONV was required, perform it now. */
6753 expr = (perform_implicit_conversion
6754 (build_pointer_type (base_conv_type), expr));
6755 expr = build_nop (type, expr);
6759 /* Perform the conversion. */
6760 expr = convert_like (conv, expr);
6762 /* Free all the conversions we allocated. */
6763 obstack_free (&conversion_obstack, p);
6768 #include "gt-cp-call.h"