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, 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)
618 from = build_pointer_type (from);
619 fcode = TREE_CODE (from);
620 conv = build_conv (ck_lvalue, from, conv);
622 else if (fcode == ARRAY_TYPE)
624 from = build_pointer_type (TREE_TYPE (from));
625 fcode = TREE_CODE (from);
626 conv = build_conv (ck_lvalue, from, conv);
628 else if (fromref || (expr && lvalue_p (expr)))
633 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
635 from = bitfield_type;
637 conv = build_conv (ck_rvalue, from, conv);
640 /* Allow conversion between `__complex__' data types. */
641 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
643 /* The standard conversion sequence to convert FROM to TO is
644 the standard conversion sequence to perform componentwise
646 conversion *part_conv = standard_conversion
647 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
651 conv = build_conv (part_conv->kind, to, conv);
652 conv->rank = part_conv->rank;
660 if (same_type_p (from, to))
663 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
664 && expr && null_ptr_cst_p (expr))
665 conv = build_conv (ck_std, to, conv);
666 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
667 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
669 /* For backwards brain damage compatibility, allow interconversion of
670 pointers and integers with a pedwarn. */
671 conv = build_conv (ck_std, to, conv);
674 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
676 /* For backwards brain damage compatibility, allow interconversion of
677 enums and integers with a pedwarn. */
678 conv = build_conv (ck_std, to, conv);
681 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
682 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
687 if (tcode == POINTER_TYPE
688 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
691 else if (VOID_TYPE_P (TREE_TYPE (to))
692 && !TYPE_PTRMEM_P (from)
693 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
695 from = build_pointer_type
696 (cp_build_qualified_type (void_type_node,
697 cp_type_quals (TREE_TYPE (from))));
698 conv = build_conv (ck_ptr, from, conv);
700 else if (TYPE_PTRMEM_P (from))
702 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
703 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
705 if (DERIVED_FROM_P (fbase, tbase)
706 && (same_type_ignoring_top_level_qualifiers_p
707 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
708 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
710 from = build_ptrmem_type (tbase,
711 TYPE_PTRMEM_POINTED_TO_TYPE (from));
712 conv = build_conv (ck_pmem, from, conv);
714 else if (!same_type_p (fbase, tbase))
717 else if (IS_AGGR_TYPE (TREE_TYPE (from))
718 && IS_AGGR_TYPE (TREE_TYPE (to))
721 An rvalue of type "pointer to cv D," where D is a
722 class type, can be converted to an rvalue of type
723 "pointer to cv B," where B is a base class (clause
724 _class.derived_) of D. If B is an inaccessible
725 (clause _class.access_) or ambiguous
726 (_class.member.lookup_) base class of D, a program
727 that necessitates this conversion is ill-formed.
728 Therefore, we use DERIVED_FROM_P, and do not check
729 access or uniqueness. */
730 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
733 cp_build_qualified_type (TREE_TYPE (to),
734 cp_type_quals (TREE_TYPE (from)));
735 from = build_pointer_type (from);
736 conv = build_conv (ck_ptr, from, conv);
740 if (tcode == POINTER_TYPE)
742 to_pointee = TREE_TYPE (to);
743 from_pointee = TREE_TYPE (from);
747 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
748 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
751 if (same_type_p (from, to))
753 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
754 /* In a C-style cast, we ignore CV-qualification because we
755 are allowed to perform a static_cast followed by a
757 conv = build_conv (ck_qual, to, conv);
758 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
759 conv = build_conv (ck_qual, to, conv);
760 else if (expr && string_conv_p (to, expr, 0))
761 /* converting from string constant to char *. */
762 conv = build_conv (ck_qual, to, conv);
763 else if (ptr_reasonably_similar (to_pointee, from_pointee))
765 conv = build_conv (ck_ptr, to, conv);
773 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
775 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
776 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
777 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
778 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
780 if (!DERIVED_FROM_P (fbase, tbase)
781 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
782 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
783 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
784 || cp_type_quals (fbase) != cp_type_quals (tbase))
787 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
788 from = build_method_type_directly (from,
790 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
791 from = build_ptrmemfunc_type (build_pointer_type (from));
792 conv = build_conv (ck_pmem, from, conv);
795 else if (tcode == BOOLEAN_TYPE)
799 An rvalue of arithmetic, enumeration, pointer, or pointer to
800 member type can be converted to an rvalue of type bool. */
801 if (ARITHMETIC_TYPE_P (from)
802 || fcode == ENUMERAL_TYPE
803 || fcode == POINTER_TYPE
804 || TYPE_PTR_TO_MEMBER_P (from))
806 conv = build_conv (ck_std, to, conv);
807 if (fcode == POINTER_TYPE
808 || TYPE_PTRMEM_P (from)
809 || (TYPE_PTRMEMFUNC_P (from)
810 && conv->rank < cr_pbool))
811 conv->rank = cr_pbool;
817 /* We don't check for ENUMERAL_TYPE here because there are no standard
818 conversions to enum type. */
819 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
820 || tcode == REAL_TYPE)
822 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
824 conv = build_conv (ck_std, to, conv);
826 /* Give this a better rank if it's a promotion. */
827 if (same_type_p (to, type_promotes_to (from))
828 && conv->u.next->rank <= cr_promotion)
829 conv->rank = cr_promotion;
831 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
832 && vector_types_convertible_p (from, to))
833 return build_conv (ck_std, to, conv);
834 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
835 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
836 && is_properly_derived_from (from, to))
838 if (conv->kind == ck_rvalue)
840 conv = build_conv (ck_base, to, conv);
841 /* The derived-to-base conversion indicates the initialization
842 of a parameter with base type from an object of a derived
843 type. A temporary object is created to hold the result of
845 conv->need_temporary_p = true;
853 /* Returns nonzero if T1 is reference-related to T2. */
856 reference_related_p (tree t1, tree t2)
858 t1 = TYPE_MAIN_VARIANT (t1);
859 t2 = TYPE_MAIN_VARIANT (t2);
863 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
864 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
866 return (same_type_p (t1, t2)
867 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
868 && DERIVED_FROM_P (t1, t2)));
871 /* Returns nonzero if T1 is reference-compatible with T2. */
874 reference_compatible_p (tree t1, tree t2)
878 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
879 reference-related to T2 and cv1 is the same cv-qualification as,
880 or greater cv-qualification than, cv2. */
881 return (reference_related_p (t1, t2)
882 && at_least_as_qualified_p (t1, t2));
885 /* Determine whether or not the EXPR (of class type S) can be
886 converted to T as in [over.match.ref]. */
889 convert_class_to_reference (tree t, tree s, tree expr)
895 struct z_candidate *candidates;
896 struct z_candidate *cand;
899 conversions = lookup_conversions (s);
905 Assuming that "cv1 T" is the underlying type of the reference
906 being initialized, and "cv S" is the type of the initializer
907 expression, with S a class type, the candidate functions are
910 --The conversion functions of S and its base classes are
911 considered. Those that are not hidden within S and yield type
912 "reference to cv2 T2", where "cv1 T" is reference-compatible
913 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
915 The argument list has one argument, which is the initializer
920 /* Conceptually, we should take the address of EXPR and put it in
921 the argument list. Unfortunately, however, that can result in
922 error messages, which we should not issue now because we are just
923 trying to find a conversion operator. Therefore, we use NULL,
924 cast to the appropriate type. */
925 arglist = build_int_cst (build_pointer_type (s), 0);
926 arglist = build_tree_list (NULL_TREE, arglist);
928 reference_type = build_reference_type (t);
932 tree fns = TREE_VALUE (conversions);
934 for (; fns; fns = OVL_NEXT (fns))
936 tree f = OVL_CURRENT (fns);
937 tree t2 = TREE_TYPE (TREE_TYPE (f));
941 /* If this is a template function, try to get an exact
943 if (TREE_CODE (f) == TEMPLATE_DECL)
945 cand = add_template_candidate (&candidates,
951 TREE_PURPOSE (conversions),
957 /* Now, see if the conversion function really returns
958 an lvalue of the appropriate type. From the
959 point of view of unification, simply returning an
960 rvalue of the right type is good enough. */
962 t2 = TREE_TYPE (TREE_TYPE (f));
963 if (TREE_CODE (t2) != REFERENCE_TYPE
964 || !reference_compatible_p (t, TREE_TYPE (t2)))
966 candidates = candidates->next;
971 else if (TREE_CODE (t2) == REFERENCE_TYPE
972 && reference_compatible_p (t, TREE_TYPE (t2)))
973 cand = add_function_candidate (&candidates, f, s, arglist,
975 TREE_PURPOSE (conversions),
980 conversion *identity_conv;
981 /* Build a standard conversion sequence indicating the
982 binding from the reference type returned by the
983 function to the desired REFERENCE_TYPE. */
985 = build_identity_conv (TREE_TYPE (TREE_TYPE
986 (TREE_TYPE (cand->fn))),
989 = (direct_reference_binding
990 (reference_type, identity_conv));
991 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
994 conversions = TREE_CHAIN (conversions);
997 candidates = splice_viable (candidates, pedantic, &any_viable_p);
998 /* If none of the conversion functions worked out, let our caller
1003 cand = tourney (candidates);
1007 /* Now that we know that this is the function we're going to use fix
1008 the dummy first argument. */
1009 cand->args = tree_cons (NULL_TREE,
1011 TREE_CHAIN (cand->args));
1013 /* Build a user-defined conversion sequence representing the
1015 conv = build_conv (ck_user,
1016 TREE_TYPE (TREE_TYPE (cand->fn)),
1017 build_identity_conv (TREE_TYPE (expr), expr));
1020 /* Merge it with the standard conversion sequence from the
1021 conversion function's return type to the desired type. */
1022 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1024 if (cand->viable == -1)
1027 return cand->second_conv;
1030 /* A reference of the indicated TYPE is being bound directly to the
1031 expression represented by the implicit conversion sequence CONV.
1032 Return a conversion sequence for this binding. */
1035 direct_reference_binding (tree type, conversion *conv)
1039 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1040 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1042 t = TREE_TYPE (type);
1046 When a parameter of reference type binds directly
1047 (_dcl.init.ref_) to an argument expression, the implicit
1048 conversion sequence is the identity conversion, unless the
1049 argument expression has a type that is a derived class of the
1050 parameter type, in which case the implicit conversion sequence is
1051 a derived-to-base Conversion.
1053 If the parameter binds directly to the result of applying a
1054 conversion function to the argument expression, the implicit
1055 conversion sequence is a user-defined conversion sequence
1056 (_over.ics.user_), with the second standard conversion sequence
1057 either an identity conversion or, if the conversion function
1058 returns an entity of a type that is a derived class of the
1059 parameter type, a derived-to-base conversion. */
1060 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1062 /* Represent the derived-to-base conversion. */
1063 conv = build_conv (ck_base, t, conv);
1064 /* We will actually be binding to the base-class subobject in
1065 the derived class, so we mark this conversion appropriately.
1066 That way, convert_like knows not to generate a temporary. */
1067 conv->need_temporary_p = false;
1069 return build_conv (ck_ref_bind, type, conv);
1072 /* Returns the conversion path from type FROM to reference type TO for
1073 purposes of reference binding. For lvalue binding, either pass a
1074 reference type to FROM or an lvalue expression to EXPR. If the
1075 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1076 the conversion returned. */
1079 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1081 conversion *conv = NULL;
1082 tree to = TREE_TYPE (rto);
1086 cp_lvalue_kind lvalue_p = clk_none;
1088 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1090 expr = instantiate_type (to, expr, tf_none);
1091 if (expr == error_mark_node)
1093 from = TREE_TYPE (expr);
1096 if (TREE_CODE (from) == REFERENCE_TYPE)
1098 /* Anything with reference type is an lvalue. */
1099 lvalue_p = clk_ordinary;
1100 from = TREE_TYPE (from);
1103 lvalue_p = real_lvalue_p (expr);
1105 /* Figure out whether or not the types are reference-related and
1106 reference compatible. We have do do this after stripping
1107 references from FROM. */
1108 related_p = reference_related_p (to, from);
1109 compatible_p = reference_compatible_p (to, from);
1111 if (lvalue_p && compatible_p)
1115 If the initializer expression
1117 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1118 is reference-compatible with "cv2 T2,"
1120 the reference is bound directly to the initializer expression
1122 conv = build_identity_conv (from, expr);
1123 conv = direct_reference_binding (rto, conv);
1124 if ((lvalue_p & clk_bitfield) != 0
1125 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1126 /* For the purposes of overload resolution, we ignore the fact
1127 this expression is a bitfield or packed field. (In particular,
1128 [over.ics.ref] says specifically that a function with a
1129 non-const reference parameter is viable even if the
1130 argument is a bitfield.)
1132 However, when we actually call the function we must create
1133 a temporary to which to bind the reference. If the
1134 reference is volatile, or isn't const, then we cannot make
1135 a temporary, so we just issue an error when the conversion
1137 conv->need_temporary_p = true;
1141 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1145 If the initializer expression
1147 -- has a class type (i.e., T2 is a class type) can be
1148 implicitly converted to an lvalue of type "cv3 T3," where
1149 "cv1 T1" is reference-compatible with "cv3 T3". (this
1150 conversion is selected by enumerating the applicable
1151 conversion functions (_over.match.ref_) and choosing the
1152 best one through overload resolution. (_over.match_).
1154 the reference is bound to the lvalue result of the conversion
1155 in the second case. */
1156 conv = convert_class_to_reference (to, from, expr);
1161 /* From this point on, we conceptually need temporaries, even if we
1162 elide them. Only the cases above are "direct bindings". */
1163 if (flags & LOOKUP_NO_TEMP_BIND)
1168 When a parameter of reference type is not bound directly to an
1169 argument expression, the conversion sequence is the one required
1170 to convert the argument expression to the underlying type of the
1171 reference according to _over.best.ics_. Conceptually, this
1172 conversion sequence corresponds to copy-initializing a temporary
1173 of the underlying type with the argument expression. Any
1174 difference in top-level cv-qualification is subsumed by the
1175 initialization itself and does not constitute a conversion. */
1179 Otherwise, the reference shall be to a non-volatile const type. */
1180 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1185 If the initializer expression is an rvalue, with T2 a class type,
1186 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1187 is bound in one of the following ways:
1189 -- The reference is bound to the object represented by the rvalue
1190 or to a sub-object within that object.
1194 We use the first alternative. The implicit conversion sequence
1195 is supposed to be same as we would obtain by generating a
1196 temporary. Fortunately, if the types are reference compatible,
1197 then this is either an identity conversion or the derived-to-base
1198 conversion, just as for direct binding. */
1199 if (CLASS_TYPE_P (from) && compatible_p)
1201 conv = build_identity_conv (from, expr);
1202 conv = direct_reference_binding (rto, conv);
1203 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1204 conv->u.next->check_copy_constructor_p = true;
1210 Otherwise, a temporary of type "cv1 T1" is created and
1211 initialized from the initializer expression using the rules for a
1212 non-reference copy initialization. If T1 is reference-related to
1213 T2, cv1 must be the same cv-qualification as, or greater
1214 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1215 if (related_p && !at_least_as_qualified_p (to, from))
1218 conv = implicit_conversion (to, from, expr, /*c_cast_p=*/false,
1223 conv = build_conv (ck_ref_bind, rto, conv);
1224 /* This reference binding, unlike those above, requires the
1225 creation of a temporary. */
1226 conv->need_temporary_p = true;
1231 /* Returns the implicit conversion sequence (see [over.ics]) from type
1232 FROM to type TO. The optional expression EXPR may affect the
1233 conversion. FLAGS are the usual overloading flags. Only
1234 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1235 conversion is coming from a C-style cast. */
1238 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1243 if (from == error_mark_node || to == error_mark_node
1244 || expr == error_mark_node)
1247 if (TREE_CODE (to) == REFERENCE_TYPE)
1248 conv = reference_binding (to, from, expr, flags);
1250 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1255 if (expr != NULL_TREE
1256 && (IS_AGGR_TYPE (from)
1257 || IS_AGGR_TYPE (to))
1258 && (flags & LOOKUP_NO_CONVERSION) == 0)
1260 struct z_candidate *cand;
1262 cand = build_user_type_conversion_1
1263 (to, expr, LOOKUP_ONLYCONVERTING);
1265 conv = cand->second_conv;
1267 /* We used to try to bind a reference to a temporary here, but that
1268 is now handled by the recursive call to this function at the end
1269 of reference_binding. */
1276 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1279 static struct z_candidate *
1280 add_candidate (struct z_candidate **candidates,
1282 size_t num_convs, conversion **convs,
1283 tree access_path, tree conversion_path,
1286 struct z_candidate *cand = (struct z_candidate *)
1287 conversion_obstack_alloc (sizeof (struct z_candidate));
1291 cand->convs = convs;
1292 cand->num_convs = num_convs;
1293 cand->access_path = access_path;
1294 cand->conversion_path = conversion_path;
1295 cand->viable = viable;
1296 cand->next = *candidates;
1302 /* Create an overload candidate for the function or method FN called with
1303 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1304 to implicit_conversion.
1306 CTYPE, if non-NULL, is the type we want to pretend this function
1307 comes from for purposes of overload resolution. */
1309 static struct z_candidate *
1310 add_function_candidate (struct z_candidate **candidates,
1311 tree fn, tree ctype, tree arglist,
1312 tree access_path, tree conversion_path,
1315 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1318 tree parmnode, argnode;
1322 /* At this point we should not see any functions which haven't been
1323 explicitly declared, except for friend functions which will have
1324 been found using argument dependent lookup. */
1325 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1327 /* The `this', `in_chrg' and VTT arguments to constructors are not
1328 considered in overload resolution. */
1329 if (DECL_CONSTRUCTOR_P (fn))
1331 parmlist = skip_artificial_parms_for (fn, parmlist);
1332 orig_arglist = arglist;
1333 arglist = skip_artificial_parms_for (fn, arglist);
1336 orig_arglist = arglist;
1338 len = list_length (arglist);
1339 convs = alloc_conversions (len);
1341 /* 13.3.2 - Viable functions [over.match.viable]
1342 First, to be a viable function, a candidate function shall have enough
1343 parameters to agree in number with the arguments in the list.
1345 We need to check this first; otherwise, checking the ICSes might cause
1346 us to produce an ill-formed template instantiation. */
1348 parmnode = parmlist;
1349 for (i = 0; i < len; ++i)
1351 if (parmnode == NULL_TREE || parmnode == void_list_node)
1353 parmnode = TREE_CHAIN (parmnode);
1356 if (i < len && parmnode)
1359 /* Make sure there are default args for the rest of the parms. */
1360 else if (!sufficient_parms_p (parmnode))
1366 /* Second, for F to be a viable function, there shall exist for each
1367 argument an implicit conversion sequence that converts that argument
1368 to the corresponding parameter of F. */
1370 parmnode = parmlist;
1373 for (i = 0; i < len; ++i)
1375 tree arg = TREE_VALUE (argnode);
1376 tree argtype = lvalue_type (arg);
1380 if (parmnode == void_list_node)
1383 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1384 && ! DECL_CONSTRUCTOR_P (fn));
1388 tree parmtype = TREE_VALUE (parmnode);
1390 /* The type of the implicit object parameter ('this') for
1391 overload resolution is not always the same as for the
1392 function itself; conversion functions are considered to
1393 be members of the class being converted, and functions
1394 introduced by a using-declaration are considered to be
1395 members of the class that uses them.
1397 Since build_over_call ignores the ICS for the `this'
1398 parameter, we can just change the parm type. */
1399 if (ctype && is_this)
1402 = build_qualified_type (ctype,
1403 TYPE_QUALS (TREE_TYPE (parmtype)));
1404 parmtype = build_pointer_type (parmtype);
1407 t = implicit_conversion (parmtype, argtype, arg,
1408 /*c_cast_p=*/false, flags);
1412 t = build_identity_conv (argtype, arg);
1413 t->ellipsis_p = true;
1430 parmnode = TREE_CHAIN (parmnode);
1431 argnode = TREE_CHAIN (argnode);
1435 return add_candidate (candidates, fn, orig_arglist, len, convs,
1436 access_path, conversion_path, viable);
1439 /* Create an overload candidate for the conversion function FN which will
1440 be invoked for expression OBJ, producing a pointer-to-function which
1441 will in turn be called with the argument list ARGLIST, and add it to
1442 CANDIDATES. FLAGS is passed on to implicit_conversion.
1444 Actually, we don't really care about FN; we care about the type it
1445 converts to. There may be multiple conversion functions that will
1446 convert to that type, and we rely on build_user_type_conversion_1 to
1447 choose the best one; so when we create our candidate, we record the type
1448 instead of the function. */
1450 static struct z_candidate *
1451 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1452 tree arglist, tree access_path, tree conversion_path)
1454 tree totype = TREE_TYPE (TREE_TYPE (fn));
1455 int i, len, viable, flags;
1456 tree parmlist, parmnode, argnode;
1459 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1460 parmlist = TREE_TYPE (parmlist);
1461 parmlist = TYPE_ARG_TYPES (parmlist);
1463 len = list_length (arglist) + 1;
1464 convs = alloc_conversions (len);
1465 parmnode = parmlist;
1468 flags = LOOKUP_NORMAL;
1470 /* Don't bother looking up the same type twice. */
1471 if (*candidates && (*candidates)->fn == totype)
1474 for (i = 0; i < len; ++i)
1476 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1477 tree argtype = lvalue_type (arg);
1481 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1483 else if (parmnode == void_list_node)
1486 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1487 /*c_cast_p=*/false, flags);
1490 t = build_identity_conv (argtype, arg);
1491 t->ellipsis_p = true;
1505 parmnode = TREE_CHAIN (parmnode);
1506 argnode = TREE_CHAIN (argnode);
1512 if (!sufficient_parms_p (parmnode))
1515 return add_candidate (candidates, totype, arglist, len, convs,
1516 access_path, conversion_path, viable);
1520 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1521 tree type1, tree type2, tree *args, tree *argtypes,
1533 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1534 convs = alloc_conversions (num_convs);
1536 for (i = 0; i < 2; ++i)
1541 t = implicit_conversion (types[i], argtypes[i], args[i],
1542 /*c_cast_p=*/false, flags);
1546 /* We need something for printing the candidate. */
1547 t = build_identity_conv (types[i], NULL_TREE);
1554 /* For COND_EXPR we rearranged the arguments; undo that now. */
1557 convs[2] = convs[1];
1558 convs[1] = convs[0];
1559 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1560 /*c_cast_p=*/false, flags);
1567 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1569 /*access_path=*/NULL_TREE,
1570 /*conversion_path=*/NULL_TREE,
1575 is_complete (tree t)
1577 return COMPLETE_TYPE_P (complete_type (t));
1580 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1583 promoted_arithmetic_type_p (tree type)
1587 In this section, the term promoted integral type is used to refer
1588 to those integral types which are preserved by integral promotion
1589 (including e.g. int and long but excluding e.g. char).
1590 Similarly, the term promoted arithmetic type refers to promoted
1591 integral types plus floating types. */
1592 return ((INTEGRAL_TYPE_P (type)
1593 && same_type_p (type_promotes_to (type), type))
1594 || TREE_CODE (type) == REAL_TYPE);
1597 /* Create any builtin operator overload candidates for the operator in
1598 question given the converted operand types TYPE1 and TYPE2. The other
1599 args are passed through from add_builtin_candidates to
1600 build_builtin_candidate.
1602 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1603 If CODE is requires candidates operands of the same type of the kind
1604 of which TYPE1 and TYPE2 are, we add both candidates
1605 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1608 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1609 enum tree_code code2, tree fnname, tree type1,
1610 tree type2, tree *args, tree *argtypes, int flags)
1614 case POSTINCREMENT_EXPR:
1615 case POSTDECREMENT_EXPR:
1616 args[1] = integer_zero_node;
1617 type2 = integer_type_node;
1626 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1627 and VQ is either volatile or empty, there exist candidate operator
1628 functions of the form
1629 VQ T& operator++(VQ T&);
1630 T operator++(VQ T&, int);
1631 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1632 type other than bool, and VQ is either volatile or empty, there exist
1633 candidate operator functions of the form
1634 VQ T& operator--(VQ T&);
1635 T operator--(VQ T&, int);
1636 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1637 complete object type, and VQ is either volatile or empty, there exist
1638 candidate operator functions of the form
1639 T*VQ& operator++(T*VQ&);
1640 T*VQ& operator--(T*VQ&);
1641 T* operator++(T*VQ&, int);
1642 T* operator--(T*VQ&, int); */
1644 case POSTDECREMENT_EXPR:
1645 case PREDECREMENT_EXPR:
1646 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1648 case POSTINCREMENT_EXPR:
1649 case PREINCREMENT_EXPR:
1650 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1652 type1 = build_reference_type (type1);
1657 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1658 exist candidate operator functions of the form
1662 8 For every function type T, there exist candidate operator functions of
1664 T& operator*(T*); */
1667 if (TREE_CODE (type1) == POINTER_TYPE
1668 && (TYPE_PTROB_P (type1)
1669 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1673 /* 9 For every type T, there exist candidate operator functions of the form
1676 10For every promoted arithmetic type T, there exist candidate operator
1677 functions of the form
1681 case UNARY_PLUS_EXPR: /* unary + */
1682 if (TREE_CODE (type1) == POINTER_TYPE)
1685 if (ARITHMETIC_TYPE_P (type1))
1689 /* 11For every promoted integral type T, there exist candidate operator
1690 functions of the form
1694 if (INTEGRAL_TYPE_P (type1))
1698 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1699 is the same type as C2 or is a derived class of C2, T is a complete
1700 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1701 there exist candidate operator functions of the form
1702 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1703 where CV12 is the union of CV1 and CV2. */
1706 if (TREE_CODE (type1) == POINTER_TYPE
1707 && TYPE_PTR_TO_MEMBER_P (type2))
1709 tree c1 = TREE_TYPE (type1);
1710 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1712 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1713 && (TYPE_PTRMEMFUNC_P (type2)
1714 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1719 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1720 didate operator functions of the form
1725 bool operator<(L, R);
1726 bool operator>(L, R);
1727 bool operator<=(L, R);
1728 bool operator>=(L, R);
1729 bool operator==(L, R);
1730 bool operator!=(L, R);
1731 where LR is the result of the usual arithmetic conversions between
1734 14For every pair of types T and I, where T is a cv-qualified or cv-
1735 unqualified complete object type and I is a promoted integral type,
1736 there exist candidate operator functions of the form
1737 T* operator+(T*, I);
1738 T& operator[](T*, I);
1739 T* operator-(T*, I);
1740 T* operator+(I, T*);
1741 T& operator[](I, T*);
1743 15For every T, where T is a pointer to complete object type, there exist
1744 candidate operator functions of the form112)
1745 ptrdiff_t operator-(T, T);
1747 16For every pointer or enumeration type T, there exist candidate operator
1748 functions of the form
1749 bool operator<(T, T);
1750 bool operator>(T, T);
1751 bool operator<=(T, T);
1752 bool operator>=(T, T);
1753 bool operator==(T, T);
1754 bool operator!=(T, T);
1756 17For every pointer to member type T, there exist candidate operator
1757 functions of the form
1758 bool operator==(T, T);
1759 bool operator!=(T, T); */
1762 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1764 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1766 type2 = ptrdiff_type_node;
1770 case TRUNC_DIV_EXPR:
1771 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1777 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1778 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1780 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1785 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1797 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1799 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1801 if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1803 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1808 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1816 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1819 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1821 type1 = ptrdiff_type_node;
1824 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1826 type2 = ptrdiff_type_node;
1831 /* 18For every pair of promoted integral types L and R, there exist candi-
1832 date operator functions of the form
1839 where LR is the result of the usual arithmetic conversions between
1842 case TRUNC_MOD_EXPR:
1848 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1852 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1853 type, VQ is either volatile or empty, and R is a promoted arithmetic
1854 type, there exist candidate operator functions of the form
1855 VQ L& operator=(VQ L&, R);
1856 VQ L& operator*=(VQ L&, R);
1857 VQ L& operator/=(VQ L&, R);
1858 VQ L& operator+=(VQ L&, R);
1859 VQ L& operator-=(VQ L&, R);
1861 20For every pair T, VQ), where T is any type and VQ is either volatile
1862 or empty, there exist candidate operator functions of the form
1863 T*VQ& operator=(T*VQ&, T*);
1865 21For every pair T, VQ), where T is a pointer to member type and VQ is
1866 either volatile or empty, there exist candidate operator functions of
1868 VQ T& operator=(VQ T&, T);
1870 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1871 unqualified complete object type, VQ is either volatile or empty, and
1872 I is a promoted integral type, there exist candidate operator func-
1874 T*VQ& operator+=(T*VQ&, I);
1875 T*VQ& operator-=(T*VQ&, I);
1877 23For every triple L, VQ, R), where L is an integral or enumeration
1878 type, VQ is either volatile or empty, and R is a promoted integral
1879 type, there exist candidate operator functions of the form
1881 VQ L& operator%=(VQ L&, R);
1882 VQ L& operator<<=(VQ L&, R);
1883 VQ L& operator>>=(VQ L&, R);
1884 VQ L& operator&=(VQ L&, R);
1885 VQ L& operator^=(VQ L&, R);
1886 VQ L& operator|=(VQ L&, R); */
1893 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1895 type2 = ptrdiff_type_node;
1899 case TRUNC_DIV_EXPR:
1900 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1904 case TRUNC_MOD_EXPR:
1910 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1915 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1917 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1918 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1919 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1920 || ((TYPE_PTRMEMFUNC_P (type1)
1921 || TREE_CODE (type1) == POINTER_TYPE)
1922 && null_ptr_cst_p (args[1])))
1932 type1 = build_reference_type (type1);
1938 For every pair of promoted arithmetic types L and R, there
1939 exist candidate operator functions of the form
1941 LR operator?(bool, L, R);
1943 where LR is the result of the usual arithmetic conversions
1944 between types L and R.
1946 For every type T, where T is a pointer or pointer-to-member
1947 type, there exist candidate operator functions of the form T
1948 operator?(bool, T, T); */
1950 if (promoted_arithmetic_type_p (type1)
1951 && promoted_arithmetic_type_p (type2))
1955 /* Otherwise, the types should be pointers. */
1956 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1957 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1960 /* We don't check that the two types are the same; the logic
1961 below will actually create two candidates; one in which both
1962 parameter types are TYPE1, and one in which both parameter
1970 /* If we're dealing with two pointer types or two enumeral types,
1971 we need candidates for both of them. */
1972 if (type2 && !same_type_p (type1, type2)
1973 && TREE_CODE (type1) == TREE_CODE (type2)
1974 && (TREE_CODE (type1) == REFERENCE_TYPE
1975 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1976 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1977 || TYPE_PTRMEMFUNC_P (type1)
1978 || IS_AGGR_TYPE (type1)
1979 || TREE_CODE (type1) == ENUMERAL_TYPE))
1981 build_builtin_candidate
1982 (candidates, fnname, type1, type1, args, argtypes, flags);
1983 build_builtin_candidate
1984 (candidates, fnname, type2, type2, args, argtypes, flags);
1988 build_builtin_candidate
1989 (candidates, fnname, type1, type2, args, argtypes, flags);
1993 type_decays_to (tree type)
1995 if (TREE_CODE (type) == ARRAY_TYPE)
1996 return build_pointer_type (TREE_TYPE (type));
1997 if (TREE_CODE (type) == FUNCTION_TYPE)
1998 return build_pointer_type (type);
2002 /* There are three conditions of builtin candidates:
2004 1) bool-taking candidates. These are the same regardless of the input.
2005 2) pointer-pair taking candidates. These are generated for each type
2006 one of the input types converts to.
2007 3) arithmetic candidates. According to the standard, we should generate
2008 all of these, but I'm trying not to...
2010 Here we generate a superset of the possible candidates for this particular
2011 case. That is a subset of the full set the standard defines, plus some
2012 other cases which the standard disallows. add_builtin_candidate will
2013 filter out the invalid set. */
2016 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2017 enum tree_code code2, tree fnname, tree *args,
2022 tree type, argtypes[3];
2023 /* TYPES[i] is the set of possible builtin-operator parameter types
2024 we will consider for the Ith argument. These are represented as
2025 a TREE_LIST; the TREE_VALUE of each node is the potential
2029 for (i = 0; i < 3; ++i)
2032 argtypes[i] = lvalue_type (args[i]);
2034 argtypes[i] = NULL_TREE;
2039 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2040 and VQ is either volatile or empty, there exist candidate operator
2041 functions of the form
2042 VQ T& operator++(VQ T&); */
2044 case POSTINCREMENT_EXPR:
2045 case PREINCREMENT_EXPR:
2046 case POSTDECREMENT_EXPR:
2047 case PREDECREMENT_EXPR:
2052 /* 24There also exist candidate operator functions of the form
2053 bool operator!(bool);
2054 bool operator&&(bool, bool);
2055 bool operator||(bool, bool); */
2057 case TRUTH_NOT_EXPR:
2058 build_builtin_candidate
2059 (candidates, fnname, boolean_type_node,
2060 NULL_TREE, args, argtypes, flags);
2063 case TRUTH_ORIF_EXPR:
2064 case TRUTH_ANDIF_EXPR:
2065 build_builtin_candidate
2066 (candidates, fnname, boolean_type_node,
2067 boolean_type_node, args, argtypes, flags);
2089 types[0] = types[1] = NULL_TREE;
2091 for (i = 0; i < 2; ++i)
2095 else if (IS_AGGR_TYPE (argtypes[i]))
2099 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2102 convs = lookup_conversions (argtypes[i]);
2104 if (code == COND_EXPR)
2106 if (real_lvalue_p (args[i]))
2107 types[i] = tree_cons
2108 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2110 types[i] = tree_cons
2111 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2117 for (; convs; convs = TREE_CHAIN (convs))
2119 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2122 && (TREE_CODE (type) != REFERENCE_TYPE
2123 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2126 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2127 types[i] = tree_cons (NULL_TREE, type, types[i]);
2129 type = non_reference (type);
2130 if (i != 0 || ! ref1)
2132 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2133 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2134 types[i] = tree_cons (NULL_TREE, type, types[i]);
2135 if (INTEGRAL_TYPE_P (type))
2136 type = type_promotes_to (type);
2139 if (! value_member (type, types[i]))
2140 types[i] = tree_cons (NULL_TREE, type, types[i]);
2145 if (code == COND_EXPR && real_lvalue_p (args[i]))
2146 types[i] = tree_cons
2147 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2148 type = non_reference (argtypes[i]);
2149 if (i != 0 || ! ref1)
2151 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2152 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2153 types[i] = tree_cons (NULL_TREE, type, types[i]);
2154 if (INTEGRAL_TYPE_P (type))
2155 type = type_promotes_to (type);
2157 types[i] = tree_cons (NULL_TREE, type, types[i]);
2161 /* Run through the possible parameter types of both arguments,
2162 creating candidates with those parameter types. */
2163 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2166 for (type = types[1]; type; type = TREE_CHAIN (type))
2167 add_builtin_candidate
2168 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2169 TREE_VALUE (type), args, argtypes, flags);
2171 add_builtin_candidate
2172 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2173 NULL_TREE, args, argtypes, flags);
2178 /* If TMPL can be successfully instantiated as indicated by
2179 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2181 TMPL is the template. EXPLICIT_TARGS are any explicit template
2182 arguments. ARGLIST is the arguments provided at the call-site.
2183 The RETURN_TYPE is the desired type for conversion operators. If
2184 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2185 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2186 add_conv_candidate. */
2188 static struct z_candidate*
2189 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2190 tree ctype, tree explicit_targs, tree arglist,
2191 tree return_type, tree access_path,
2192 tree conversion_path, int flags, tree obj,
2193 unification_kind_t strict)
2195 int ntparms = DECL_NTPARMS (tmpl);
2196 tree targs = make_tree_vec (ntparms);
2197 tree args_without_in_chrg = arglist;
2198 struct z_candidate *cand;
2202 /* We don't do deduction on the in-charge parameter, the VTT
2203 parameter or 'this'. */
2204 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2205 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2207 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2208 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2209 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2210 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2212 i = fn_type_unification (tmpl, explicit_targs, targs,
2213 args_without_in_chrg,
2214 return_type, strict, flags);
2219 fn = instantiate_template (tmpl, targs, tf_none);
2220 if (fn == error_mark_node)
2225 A member function template is never instantiated to perform the
2226 copy of a class object to an object of its class type.
2228 It's a little unclear what this means; the standard explicitly
2229 does allow a template to be used to copy a class. For example,
2234 template <class T> A(const T&);
2237 void g () { A a (f ()); }
2239 the member template will be used to make the copy. The section
2240 quoted above appears in the paragraph that forbids constructors
2241 whose only parameter is (a possibly cv-qualified variant of) the
2242 class type, and a logical interpretation is that the intent was
2243 to forbid the instantiation of member templates which would then
2245 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2247 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2248 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2253 if (obj != NULL_TREE)
2254 /* Aha, this is a conversion function. */
2255 cand = add_conv_candidate (candidates, fn, obj, access_path,
2256 conversion_path, arglist);
2258 cand = add_function_candidate (candidates, fn, ctype,
2259 arglist, access_path,
2260 conversion_path, flags);
2261 if (DECL_TI_TEMPLATE (fn) != tmpl)
2262 /* This situation can occur if a member template of a template
2263 class is specialized. Then, instantiate_template might return
2264 an instantiation of the specialization, in which case the
2265 DECL_TI_TEMPLATE field will point at the original
2266 specialization. For example:
2268 template <class T> struct S { template <class U> void f(U);
2269 template <> void f(int) {}; };
2273 Here, TMPL will be template <class U> S<double>::f(U).
2274 And, instantiate template will give us the specialization
2275 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2276 for this will point at template <class T> template <> S<T>::f(int),
2277 so that we can find the definition. For the purposes of
2278 overload resolution, however, we want the original TMPL. */
2279 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2281 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2287 static struct z_candidate *
2288 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2289 tree explicit_targs, tree arglist, tree return_type,
2290 tree access_path, tree conversion_path, int flags,
2291 unification_kind_t strict)
2294 add_template_candidate_real (candidates, tmpl, ctype,
2295 explicit_targs, arglist, return_type,
2296 access_path, conversion_path,
2297 flags, NULL_TREE, strict);
2301 static struct z_candidate *
2302 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2303 tree obj, tree arglist, tree return_type,
2304 tree access_path, tree conversion_path)
2307 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2308 arglist, return_type, access_path,
2309 conversion_path, 0, obj, DEDUCE_CONV);
2312 /* The CANDS are the set of candidates that were considered for
2313 overload resolution. Return the set of viable candidates. If none
2314 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2315 is true if a candidate should be considered viable only if it is
2318 static struct z_candidate*
2319 splice_viable (struct z_candidate *cands,
2323 struct z_candidate *viable;
2324 struct z_candidate **last_viable;
2325 struct z_candidate **cand;
2328 last_viable = &viable;
2329 *any_viable_p = false;
2334 struct z_candidate *c = *cand;
2335 if (strict_p ? c->viable == 1 : c->viable)
2340 last_viable = &c->next;
2341 *any_viable_p = true;
2347 return viable ? viable : cands;
2351 any_strictly_viable (struct z_candidate *cands)
2353 for (; cands; cands = cands->next)
2354 if (cands->viable == 1)
2359 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2360 words, it is about to become the "this" pointer for a member
2361 function call. Take the address of the object. */
2364 build_this (tree obj)
2366 /* In a template, we are only concerned about the type of the
2367 expression, so we can take a shortcut. */
2368 if (processing_template_decl)
2369 return build_address (obj);
2371 return build_unary_op (ADDR_EXPR, obj, 0);
2374 /* Returns true iff functions are equivalent. Equivalent functions are
2375 not '==' only if one is a function-local extern function or if
2376 both are extern "C". */
2379 equal_functions (tree fn1, tree fn2)
2381 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2382 || DECL_EXTERN_C_FUNCTION_P (fn1))
2383 return decls_match (fn1, fn2);
2387 /* Print information about one overload candidate CANDIDATE. MSGSTR
2388 is the text to print before the candidate itself.
2390 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2391 to have been run through gettext by the caller. This wart makes
2392 life simpler in print_z_candidates and for the translators. */
2395 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2397 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2399 if (candidate->num_convs == 3)
2400 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2401 candidate->convs[0]->type,
2402 candidate->convs[1]->type,
2403 candidate->convs[2]->type);
2404 else if (candidate->num_convs == 2)
2405 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2406 candidate->convs[0]->type,
2407 candidate->convs[1]->type);
2409 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2410 candidate->convs[0]->type);
2412 else if (TYPE_P (candidate->fn))
2413 inform ("%s %T <conversion>", msgstr, candidate->fn);
2414 else if (candidate->viable == -1)
2415 inform ("%s %+#D <near match>", msgstr, candidate->fn);
2417 inform ("%s %+#D", msgstr, candidate->fn);
2421 print_z_candidates (struct z_candidate *candidates)
2424 struct z_candidate *cand1;
2425 struct z_candidate **cand2;
2427 /* There may be duplicates in the set of candidates. We put off
2428 checking this condition as long as possible, since we have no way
2429 to eliminate duplicates from a set of functions in less than n^2
2430 time. Now we are about to emit an error message, so it is more
2431 permissible to go slowly. */
2432 for (cand1 = candidates; cand1; cand1 = cand1->next)
2434 tree fn = cand1->fn;
2435 /* Skip builtin candidates and conversion functions. */
2436 if (TREE_CODE (fn) != FUNCTION_DECL)
2438 cand2 = &cand1->next;
2441 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2442 && equal_functions (fn, (*cand2)->fn))
2443 *cand2 = (*cand2)->next;
2445 cand2 = &(*cand2)->next;
2452 str = _("candidates are:");
2453 print_z_candidate (str, candidates);
2454 if (candidates->next)
2456 /* Indent successive candidates by the width of the translation
2457 of the above string. */
2458 size_t len = gcc_gettext_width (str) + 1;
2459 char *spaces = (char *) alloca (len);
2460 memset (spaces, ' ', len-1);
2461 spaces[len - 1] = '\0';
2463 candidates = candidates->next;
2466 print_z_candidate (spaces, candidates);
2467 candidates = candidates->next;
2473 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2474 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2475 the result of the conversion function to convert it to the final
2476 desired type. Merge the two sequences into a single sequence,
2477 and return the merged sequence. */
2480 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2484 gcc_assert (user_seq->kind == ck_user);
2486 /* Find the end of the second conversion sequence. */
2488 while ((*t)->kind != ck_identity)
2489 t = &((*t)->u.next);
2491 /* Replace the identity conversion with the user conversion
2495 /* The entire sequence is a user-conversion sequence. */
2496 std_seq->user_conv_p = true;
2501 /* Returns the best overload candidate to perform the requested
2502 conversion. This function is used for three the overloading situations
2503 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2504 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2505 per [dcl.init.ref], so we ignore temporary bindings. */
2507 static struct z_candidate *
2508 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2510 struct z_candidate *candidates, *cand;
2511 tree fromtype = TREE_TYPE (expr);
2512 tree ctors = NULL_TREE;
2513 tree conv_fns = NULL_TREE;
2514 conversion *conv = NULL;
2515 tree args = NULL_TREE;
2518 /* We represent conversion within a hierarchy using RVALUE_CONV and
2519 BASE_CONV, as specified by [over.best.ics]; these become plain
2520 constructor calls, as specified in [dcl.init]. */
2521 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2522 || !DERIVED_FROM_P (totype, fromtype));
2524 if (IS_AGGR_TYPE (totype))
2525 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2527 if (IS_AGGR_TYPE (fromtype))
2528 conv_fns = lookup_conversions (fromtype);
2531 flags |= LOOKUP_NO_CONVERSION;
2537 ctors = BASELINK_FUNCTIONS (ctors);
2539 t = build_int_cst (build_pointer_type (totype), 0);
2540 args = build_tree_list (NULL_TREE, expr);
2541 /* We should never try to call the abstract or base constructor
2543 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2544 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2545 args = tree_cons (NULL_TREE, t, args);
2547 for (; ctors; ctors = OVL_NEXT (ctors))
2549 tree ctor = OVL_CURRENT (ctors);
2550 if (DECL_NONCONVERTING_P (ctor))
2553 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2554 cand = add_template_candidate (&candidates, ctor, totype,
2555 NULL_TREE, args, NULL_TREE,
2556 TYPE_BINFO (totype),
2557 TYPE_BINFO (totype),
2561 cand = add_function_candidate (&candidates, ctor, totype,
2562 args, TYPE_BINFO (totype),
2563 TYPE_BINFO (totype),
2567 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2571 args = build_tree_list (NULL_TREE, build_this (expr));
2573 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2576 tree conversion_path = TREE_PURPOSE (conv_fns);
2577 int convflags = LOOKUP_NO_CONVERSION;
2579 /* If we are called to convert to a reference type, we are trying to
2580 find an lvalue binding, so don't even consider temporaries. If
2581 we don't find an lvalue binding, the caller will try again to
2582 look for a temporary binding. */
2583 if (TREE_CODE (totype) == REFERENCE_TYPE)
2584 convflags |= LOOKUP_NO_TEMP_BIND;
2586 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2588 tree fn = OVL_CURRENT (fns);
2590 /* [over.match.funcs] For conversion functions, the function
2591 is considered to be a member of the class of the implicit
2592 object argument for the purpose of defining the type of
2593 the implicit object parameter.
2595 So we pass fromtype as CTYPE to add_*_candidate. */
2597 if (TREE_CODE (fn) == TEMPLATE_DECL)
2598 cand = add_template_candidate (&candidates, fn, fromtype,
2601 TYPE_BINFO (fromtype),
2606 cand = add_function_candidate (&candidates, fn, fromtype,
2608 TYPE_BINFO (fromtype),
2615 = implicit_conversion (totype,
2616 TREE_TYPE (TREE_TYPE (cand->fn)),
2618 /*c_cast_p=*/false, convflags);
2620 cand->second_conv = ics;
2624 else if (candidates->viable == 1 && ics->bad_p)
2630 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2634 cand = tourney (candidates);
2637 if (flags & LOOKUP_COMPLAIN)
2639 error ("conversion from %qT to %qT is ambiguous",
2641 print_z_candidates (candidates);
2644 cand = candidates; /* any one will do */
2645 cand->second_conv = build_ambiguous_conv (totype, expr);
2646 cand->second_conv->user_conv_p = true;
2647 if (!any_strictly_viable (candidates))
2648 cand->second_conv->bad_p = true;
2649 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2650 ambiguous conversion is no worse than another user-defined
2656 /* Build the user conversion sequence. */
2659 (DECL_CONSTRUCTOR_P (cand->fn)
2660 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2661 build_identity_conv (TREE_TYPE (expr), expr));
2664 /* Combine it with the second conversion sequence. */
2665 cand->second_conv = merge_conversion_sequences (conv,
2668 if (cand->viable == -1)
2669 cand->second_conv->bad_p = true;
2675 build_user_type_conversion (tree totype, tree expr, int flags)
2677 struct z_candidate *cand
2678 = build_user_type_conversion_1 (totype, expr, flags);
2682 if (cand->second_conv->kind == ck_ambig)
2683 return error_mark_node;
2684 expr = convert_like (cand->second_conv, expr);
2685 return convert_from_reference (expr);
2690 /* Do any initial processing on the arguments to a function call. */
2693 resolve_args (tree args)
2696 for (t = args; t; t = TREE_CHAIN (t))
2698 tree arg = TREE_VALUE (t);
2700 if (error_operand_p (arg))
2701 return error_mark_node;
2702 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2704 error ("invalid use of void expression");
2705 return error_mark_node;
2707 else if (invalid_nonstatic_memfn_p (arg))
2708 return error_mark_node;
2713 /* Perform overload resolution on FN, which is called with the ARGS.
2715 Return the candidate function selected by overload resolution, or
2716 NULL if the event that overload resolution failed. In the case
2717 that overload resolution fails, *CANDIDATES will be the set of
2718 candidates considered, and ANY_VIABLE_P will be set to true or
2719 false to indicate whether or not any of the candidates were
2722 The ARGS should already have gone through RESOLVE_ARGS before this
2723 function is called. */
2725 static struct z_candidate *
2726 perform_overload_resolution (tree fn,
2728 struct z_candidate **candidates,
2731 struct z_candidate *cand;
2732 tree explicit_targs = NULL_TREE;
2733 int template_only = 0;
2736 *any_viable_p = true;
2738 /* Check FN and ARGS. */
2739 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2740 || TREE_CODE (fn) == TEMPLATE_DECL
2741 || TREE_CODE (fn) == OVERLOAD
2742 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2743 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2745 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2747 explicit_targs = TREE_OPERAND (fn, 1);
2748 fn = TREE_OPERAND (fn, 0);
2752 /* Add the various candidate functions. */
2753 add_candidates (fn, args, explicit_targs, template_only,
2754 /*conversion_path=*/NULL_TREE,
2755 /*access_path=*/NULL_TREE,
2759 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2763 cand = tourney (*candidates);
2767 /* Return an expression for a call to FN (a namespace-scope function,
2768 or a static member function) with the ARGS. */
2771 build_new_function_call (tree fn, tree args, bool koenig_p)
2773 struct z_candidate *candidates, *cand;
2778 args = resolve_args (args);
2779 if (args == error_mark_node)
2780 return error_mark_node;
2782 /* If this function was found without using argument dependent
2783 lookup, then we want to ignore any undeclared friend
2789 fn = remove_hidden_names (fn);
2792 error ("no matching function for call to %<%D(%A)%>",
2793 DECL_NAME (OVL_CURRENT (orig_fn)), args);
2794 return error_mark_node;
2798 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2799 p = conversion_obstack_alloc (0);
2801 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2805 if (!any_viable_p && candidates && ! candidates->next)
2806 return build_function_call (candidates->fn, args);
2807 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2808 fn = TREE_OPERAND (fn, 0);
2810 error ("no matching function for call to %<%D(%A)%>",
2811 DECL_NAME (OVL_CURRENT (fn)), args);
2813 error ("call of overloaded %<%D(%A)%> is ambiguous",
2814 DECL_NAME (OVL_CURRENT (fn)), args);
2816 print_z_candidates (candidates);
2817 result = error_mark_node;
2820 result = build_over_call (cand, LOOKUP_NORMAL);
2822 /* Free all the conversions we allocated. */
2823 obstack_free (&conversion_obstack, p);
2828 /* Build a call to a global operator new. FNNAME is the name of the
2829 operator (either "operator new" or "operator new[]") and ARGS are
2830 the arguments provided. *SIZE points to the total number of bytes
2831 required by the allocation, and is updated if that is changed here.
2832 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2833 function determines that no cookie should be used, after all,
2834 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2835 set, upon return, to the allocation function called. */
2838 build_operator_new_call (tree fnname, tree args,
2839 tree *size, tree *cookie_size,
2843 struct z_candidate *candidates;
2844 struct z_candidate *cand;
2849 args = tree_cons (NULL_TREE, *size, args);
2850 args = resolve_args (args);
2851 if (args == error_mark_node)
2858 If this lookup fails to find the name, or if the allocated type
2859 is not a class type, the allocation function's name is looked
2860 up in the global scope.
2862 we disregard block-scope declarations of "operator new". */
2863 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2865 /* Figure out what function is being called. */
2866 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2868 /* If no suitable function could be found, issue an error message
2873 error ("no matching function for call to %<%D(%A)%>",
2874 DECL_NAME (OVL_CURRENT (fns)), args);
2876 error ("call of overloaded %<%D(%A)%> is ambiguous",
2877 DECL_NAME (OVL_CURRENT (fns)), args);
2879 print_z_candidates (candidates);
2880 return error_mark_node;
2883 /* If a cookie is required, add some extra space. Whether
2884 or not a cookie is required cannot be determined until
2885 after we know which function was called. */
2888 bool use_cookie = true;
2889 if (!abi_version_at_least (2))
2891 tree placement = TREE_CHAIN (args);
2892 /* In G++ 3.2, the check was implemented incorrectly; it
2893 looked at the placement expression, rather than the
2894 type of the function. */
2895 if (placement && !TREE_CHAIN (placement)
2896 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2904 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2905 /* Skip the size_t parameter. */
2906 arg_types = TREE_CHAIN (arg_types);
2907 /* Check the remaining parameters (if any). */
2909 && TREE_CHAIN (arg_types) == void_list_node
2910 && same_type_p (TREE_VALUE (arg_types),
2914 /* If we need a cookie, adjust the number of bytes allocated. */
2917 /* Update the total size. */
2918 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2919 /* Update the argument list to reflect the adjusted size. */
2920 TREE_VALUE (args) = *size;
2923 *cookie_size = NULL_TREE;
2926 /* Tell our caller which function we decided to call. */
2930 /* Build the CALL_EXPR. */
2931 return build_over_call (cand, LOOKUP_NORMAL);
2935 build_object_call (tree obj, tree args)
2937 struct z_candidate *candidates = 0, *cand;
2938 tree fns, convs, mem_args = NULL_TREE;
2939 tree type = TREE_TYPE (obj);
2941 tree result = NULL_TREE;
2944 if (TYPE_PTRMEMFUNC_P (type))
2946 /* It's no good looking for an overloaded operator() on a
2947 pointer-to-member-function. */
2948 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2949 return error_mark_node;
2952 if (TYPE_BINFO (type))
2954 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2955 if (fns == error_mark_node)
2956 return error_mark_node;
2961 args = resolve_args (args);
2963 if (args == error_mark_node)
2964 return error_mark_node;
2966 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2967 p = conversion_obstack_alloc (0);
2971 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2972 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2974 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2976 tree fn = OVL_CURRENT (fns);
2977 if (TREE_CODE (fn) == TEMPLATE_DECL)
2978 add_template_candidate (&candidates, fn, base, NULL_TREE,
2979 mem_args, NULL_TREE,
2982 LOOKUP_NORMAL, DEDUCE_CALL);
2984 add_function_candidate
2985 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2986 TYPE_BINFO (type), LOOKUP_NORMAL);
2990 convs = lookup_conversions (type);
2992 for (; convs; convs = TREE_CHAIN (convs))
2994 tree fns = TREE_VALUE (convs);
2995 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2997 if ((TREE_CODE (totype) == POINTER_TYPE
2998 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2999 || (TREE_CODE (totype) == REFERENCE_TYPE
3000 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3001 || (TREE_CODE (totype) == REFERENCE_TYPE
3002 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3003 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3004 for (; fns; fns = OVL_NEXT (fns))
3006 tree fn = OVL_CURRENT (fns);
3007 if (TREE_CODE (fn) == TEMPLATE_DECL)
3008 add_template_conv_candidate
3009 (&candidates, fn, obj, args, totype,
3010 /*access_path=*/NULL_TREE,
3011 /*conversion_path=*/NULL_TREE);
3013 add_conv_candidate (&candidates, fn, obj, args,
3014 /*conversion_path=*/NULL_TREE,
3015 /*access_path=*/NULL_TREE);
3019 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3022 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3023 print_z_candidates (candidates);
3024 result = error_mark_node;
3028 cand = tourney (candidates);
3031 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
3032 print_z_candidates (candidates);
3033 result = error_mark_node;
3035 /* Since cand->fn will be a type, not a function, for a conversion
3036 function, we must be careful not to unconditionally look at
3038 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3039 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3040 result = build_over_call (cand, LOOKUP_NORMAL);
3043 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
3044 obj = convert_from_reference (obj);
3045 result = build_function_call (obj, args);
3049 /* Free all the conversions we allocated. */
3050 obstack_free (&conversion_obstack, p);
3056 op_error (enum tree_code code, enum tree_code code2,
3057 tree arg1, tree arg2, tree arg3, const char *problem)
3061 if (code == MODIFY_EXPR)
3062 opname = assignment_operator_name_info[code2].name;
3064 opname = operator_name_info[code].name;
3069 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3070 problem, arg1, arg2, arg3);
3073 case POSTINCREMENT_EXPR:
3074 case POSTDECREMENT_EXPR:
3075 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3079 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3084 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3089 error ("%s for %<operator%s%> in %<%E %s %E%>",
3090 problem, opname, arg1, opname, arg2);
3092 error ("%s for %<operator%s%> in %<%s%E%>",
3093 problem, opname, opname, arg1);
3098 /* Return the implicit conversion sequence that could be used to
3099 convert E1 to E2 in [expr.cond]. */
3102 conditional_conversion (tree e1, tree e2)
3104 tree t1 = non_reference (TREE_TYPE (e1));
3105 tree t2 = non_reference (TREE_TYPE (e2));
3111 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3112 implicitly converted (clause _conv_) to the type "reference to
3113 T2", subject to the constraint that in the conversion the
3114 reference must bind directly (_dcl.init.ref_) to E1. */
3115 if (real_lvalue_p (e2))
3117 conv = implicit_conversion (build_reference_type (t2),
3121 LOOKUP_NO_TEMP_BIND);
3128 If E1 and E2 have class type, and the underlying class types are
3129 the same or one is a base class of the other: E1 can be converted
3130 to match E2 if the class of T2 is the same type as, or a base
3131 class of, the class of T1, and the cv-qualification of T2 is the
3132 same cv-qualification as, or a greater cv-qualification than, the
3133 cv-qualification of T1. If the conversion is applied, E1 is
3134 changed to an rvalue of type T2 that still refers to the original
3135 source class object (or the appropriate subobject thereof). */
3136 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3137 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3139 if (good_base && at_least_as_qualified_p (t2, t1))
3141 conv = build_identity_conv (t1, e1);
3142 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3143 TYPE_MAIN_VARIANT (t2)))
3144 conv = build_conv (ck_base, t2, conv);
3146 conv = build_conv (ck_rvalue, t2, conv);
3155 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3156 converted to the type that expression E2 would have if E2 were
3157 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3158 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3162 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3163 arguments to the conditional expression. */
3166 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3170 tree result = NULL_TREE;
3171 tree result_type = NULL_TREE;
3172 bool lvalue_p = true;
3173 struct z_candidate *candidates = 0;
3174 struct z_candidate *cand;
3177 /* As a G++ extension, the second argument to the conditional can be
3178 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3179 c'.) If the second operand is omitted, make sure it is
3180 calculated only once. */
3184 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3186 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3187 if (real_lvalue_p (arg1))
3188 arg2 = arg1 = stabilize_reference (arg1);
3190 arg2 = arg1 = save_expr (arg1);
3195 The first expr ession is implicitly converted to bool (clause
3197 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3199 /* If something has already gone wrong, just pass that fact up the
3201 if (error_operand_p (arg1)
3202 || error_operand_p (arg2)
3203 || error_operand_p (arg3))
3204 return error_mark_node;
3208 If either the second or the third operand has type (possibly
3209 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3210 array-to-pointer (_conv.array_), and function-to-pointer
3211 (_conv.func_) standard conversions are performed on the second
3212 and third operands. */
3213 arg2_type = is_bitfield_expr_with_lowered_type (arg2);
3215 arg2_type = TREE_TYPE (arg2);
3216 arg3_type = is_bitfield_expr_with_lowered_type (arg3);
3218 arg3_type = TREE_TYPE (arg3);
3219 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3221 /* Do the conversions. We don't these for `void' type arguments
3222 since it can't have any effect and since decay_conversion
3223 does not handle that case gracefully. */
3224 if (!VOID_TYPE_P (arg2_type))
3225 arg2 = decay_conversion (arg2);
3226 if (!VOID_TYPE_P (arg3_type))
3227 arg3 = decay_conversion (arg3);
3228 arg2_type = TREE_TYPE (arg2);
3229 arg3_type = TREE_TYPE (arg3);
3233 One of the following shall hold:
3235 --The second or the third operand (but not both) is a
3236 throw-expression (_except.throw_); the result is of the
3237 type of the other and is an rvalue.
3239 --Both the second and the third operands have type void; the
3240 result is of type void and is an rvalue.
3242 We must avoid calling force_rvalue for expressions of type
3243 "void" because it will complain that their value is being
3245 if (TREE_CODE (arg2) == THROW_EXPR
3246 && TREE_CODE (arg3) != THROW_EXPR)
3248 if (!VOID_TYPE_P (arg3_type))
3249 arg3 = force_rvalue (arg3);
3250 arg3_type = TREE_TYPE (arg3);
3251 result_type = arg3_type;
3253 else if (TREE_CODE (arg2) != THROW_EXPR
3254 && TREE_CODE (arg3) == THROW_EXPR)
3256 if (!VOID_TYPE_P (arg2_type))
3257 arg2 = force_rvalue (arg2);
3258 arg2_type = TREE_TYPE (arg2);
3259 result_type = arg2_type;
3261 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3262 result_type = void_type_node;
3265 error ("%qE has type %<void%> and is not a throw-expression",
3266 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3267 return error_mark_node;
3271 goto valid_operands;
3275 Otherwise, if the second and third operand have different types,
3276 and either has (possibly cv-qualified) class type, an attempt is
3277 made to convert each of those operands to the type of the other. */
3278 else if (!same_type_p (arg2_type, arg3_type)
3279 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3284 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3285 p = conversion_obstack_alloc (0);
3287 conv2 = conditional_conversion (arg2, arg3);
3288 conv3 = conditional_conversion (arg3, arg2);
3292 If both can be converted, or one can be converted but the
3293 conversion is ambiguous, the program is ill-formed. If
3294 neither can be converted, the operands are left unchanged and
3295 further checking is performed as described below. If exactly
3296 one conversion is possible, that conversion is applied to the
3297 chosen operand and the converted operand is used in place of
3298 the original operand for the remainder of this section. */
3299 if ((conv2 && !conv2->bad_p
3300 && conv3 && !conv3->bad_p)
3301 || (conv2 && conv2->kind == ck_ambig)
3302 || (conv3 && conv3->kind == ck_ambig))
3304 error ("operands to ?: have different types %qT and %qT",
3305 arg2_type, arg3_type);
3306 result = error_mark_node;
3308 else if (conv2 && (!conv2->bad_p || !conv3))
3310 arg2 = convert_like (conv2, arg2);
3311 arg2 = convert_from_reference (arg2);
3312 arg2_type = TREE_TYPE (arg2);
3314 else if (conv3 && (!conv3->bad_p || !conv2))
3316 arg3 = convert_like (conv3, arg3);
3317 arg3 = convert_from_reference (arg3);
3318 arg3_type = TREE_TYPE (arg3);
3321 /* Free all the conversions we allocated. */
3322 obstack_free (&conversion_obstack, p);
3327 /* If, after the conversion, both operands have class type,
3328 treat the cv-qualification of both operands as if it were the
3329 union of the cv-qualification of the operands.
3331 The standard is not clear about what to do in this
3332 circumstance. For example, if the first operand has type
3333 "const X" and the second operand has a user-defined
3334 conversion to "volatile X", what is the type of the second
3335 operand after this step? Making it be "const X" (matching
3336 the first operand) seems wrong, as that discards the
3337 qualification without actually performing a copy. Leaving it
3338 as "volatile X" seems wrong as that will result in the
3339 conditional expression failing altogether, even though,
3340 according to this step, the one operand could be converted to
3341 the type of the other. */
3342 if ((conv2 || conv3)
3343 && CLASS_TYPE_P (arg2_type)
3344 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3345 arg2_type = arg3_type =
3346 cp_build_qualified_type (arg2_type,
3347 TYPE_QUALS (arg2_type)
3348 | TYPE_QUALS (arg3_type));
3353 If the second and third operands are lvalues and have the same
3354 type, the result is of that type and is an lvalue. */
3355 if (real_lvalue_p (arg2)
3356 && real_lvalue_p (arg3)
3357 && same_type_p (arg2_type, arg3_type))
3359 result_type = arg2_type;
3360 goto valid_operands;
3365 Otherwise, the result is an rvalue. If the second and third
3366 operand do not have the same type, and either has (possibly
3367 cv-qualified) class type, overload resolution is used to
3368 determine the conversions (if any) to be applied to the operands
3369 (_over.match.oper_, _over.built_). */
3371 if (!same_type_p (arg2_type, arg3_type)
3372 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3378 /* Rearrange the arguments so that add_builtin_candidate only has
3379 to know about two args. In build_builtin_candidates, the
3380 arguments are unscrambled. */
3384 add_builtin_candidates (&candidates,
3387 ansi_opname (COND_EXPR),
3393 If the overload resolution fails, the program is
3395 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3398 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3399 print_z_candidates (candidates);
3400 return error_mark_node;
3402 cand = tourney (candidates);
3405 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3406 print_z_candidates (candidates);
3407 return error_mark_node;
3412 Otherwise, the conversions thus determined are applied, and
3413 the converted operands are used in place of the original
3414 operands for the remainder of this section. */
3415 conv = cand->convs[0];
3416 arg1 = convert_like (conv, arg1);
3417 conv = cand->convs[1];
3418 arg2 = convert_like (conv, arg2);
3419 conv = cand->convs[2];
3420 arg3 = convert_like (conv, arg3);
3425 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3426 and function-to-pointer (_conv.func_) standard conversions are
3427 performed on the second and third operands.
3429 We need to force the lvalue-to-rvalue conversion here for class types,
3430 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3431 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3434 arg2 = force_rvalue (arg2);
3435 if (!CLASS_TYPE_P (arg2_type))
3436 arg2_type = TREE_TYPE (arg2);
3438 arg3 = force_rvalue (arg3);
3439 if (!CLASS_TYPE_P (arg2_type))
3440 arg3_type = TREE_TYPE (arg3);
3442 if (arg2 == error_mark_node || arg3 == error_mark_node)
3443 return error_mark_node;
3447 After those conversions, one of the following shall hold:
3449 --The second and third operands have the same type; the result is of
3451 if (same_type_p (arg2_type, arg3_type))
3452 result_type = arg2_type;
3455 --The second and third operands have arithmetic or enumeration
3456 type; the usual arithmetic conversions are performed to bring
3457 them to a common type, and the result is of that type. */
3458 else if ((ARITHMETIC_TYPE_P (arg2_type)
3459 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3460 && (ARITHMETIC_TYPE_P (arg3_type)
3461 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3463 /* In this case, there is always a common type. */
3464 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3467 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3468 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3469 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3470 arg2_type, arg3_type);
3471 else if (extra_warnings
3472 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3473 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3474 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3475 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3476 warning (0, "enumeral and non-enumeral type in conditional expression");
3478 arg2 = perform_implicit_conversion (result_type, arg2);
3479 arg3 = perform_implicit_conversion (result_type, arg3);
3483 --The second and third operands have pointer type, or one has
3484 pointer type and the other is a null pointer constant; pointer
3485 conversions (_conv.ptr_) and qualification conversions
3486 (_conv.qual_) are performed to bring them to their composite
3487 pointer type (_expr.rel_). The result is of the composite
3490 --The second and third operands have pointer to member type, or
3491 one has pointer to member type and the other is a null pointer
3492 constant; pointer to member conversions (_conv.mem_) and
3493 qualification conversions (_conv.qual_) are performed to bring
3494 them to a common type, whose cv-qualification shall match the
3495 cv-qualification of either the second or the third operand.
3496 The result is of the common type. */
3497 else if ((null_ptr_cst_p (arg2)
3498 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3499 || (null_ptr_cst_p (arg3)
3500 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3501 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3502 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3503 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3505 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3506 arg3, "conditional expression");
3507 if (result_type == error_mark_node)
3508 return error_mark_node;
3509 arg2 = perform_implicit_conversion (result_type, arg2);
3510 arg3 = perform_implicit_conversion (result_type, arg3);
3515 error ("operands to ?: have different types %qT and %qT",
3516 arg2_type, arg3_type);
3517 return error_mark_node;
3521 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3523 /* We can't use result_type below, as fold might have returned a
3528 /* Expand both sides into the same slot, hopefully the target of
3529 the ?: expression. We used to check for TARGET_EXPRs here,
3530 but now we sometimes wrap them in NOP_EXPRs so the test would
3532 if (CLASS_TYPE_P (TREE_TYPE (result)))
3533 result = get_target_expr (result);
3534 /* If this expression is an rvalue, but might be mistaken for an
3535 lvalue, we must add a NON_LVALUE_EXPR. */
3536 result = rvalue (result);
3542 /* OPERAND is an operand to an expression. Perform necessary steps
3543 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3547 prep_operand (tree operand)
3551 if (CLASS_TYPE_P (TREE_TYPE (operand))
3552 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3553 /* Make sure the template type is instantiated now. */
3554 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3560 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3561 OVERLOAD) to the CANDIDATES, returning an updated list of
3562 CANDIDATES. The ARGS are the arguments provided to the call,
3563 without any implicit object parameter. The EXPLICIT_TARGS are
3564 explicit template arguments provided. TEMPLATE_ONLY is true if
3565 only template functions should be considered. CONVERSION_PATH,
3566 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3569 add_candidates (tree fns, tree args,
3570 tree explicit_targs, bool template_only,
3571 tree conversion_path, tree access_path,
3573 struct z_candidate **candidates)
3576 tree non_static_args;
3578 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3579 /* Delay creating the implicit this parameter until it is needed. */
3580 non_static_args = NULL_TREE;
3587 fn = OVL_CURRENT (fns);
3588 /* Figure out which set of arguments to use. */
3589 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3591 /* If this function is a non-static member, prepend the implicit
3592 object parameter. */
3593 if (!non_static_args)
3594 non_static_args = tree_cons (NULL_TREE,
3595 build_this (TREE_VALUE (args)),
3597 fn_args = non_static_args;
3600 /* Otherwise, just use the list of arguments provided. */
3603 if (TREE_CODE (fn) == TEMPLATE_DECL)
3604 add_template_candidate (candidates,
3614 else if (!template_only)
3615 add_function_candidate (candidates,
3622 fns = OVL_NEXT (fns);
3627 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3630 struct z_candidate *candidates = 0, *cand;
3631 tree arglist, fnname;
3633 tree result = NULL_TREE;
3634 bool result_valid_p = false;
3635 enum tree_code code2 = NOP_EXPR;
3641 if (error_operand_p (arg1)
3642 || error_operand_p (arg2)
3643 || error_operand_p (arg3))
3644 return error_mark_node;
3646 if (code == MODIFY_EXPR)
3648 code2 = TREE_CODE (arg3);
3650 fnname = ansi_assopname (code2);
3653 fnname = ansi_opname (code);
3655 arg1 = prep_operand (arg1);
3661 case VEC_DELETE_EXPR:
3663 /* Use build_op_new_call and build_op_delete_call instead. */
3667 return build_object_call (arg1, arg2);
3673 arg2 = prep_operand (arg2);
3674 arg3 = prep_operand (arg3);
3676 if (code == COND_EXPR)
3678 if (arg2 == NULL_TREE
3679 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3680 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3681 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3682 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3685 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3686 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3689 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3690 arg2 = integer_zero_node;
3692 arglist = NULL_TREE;
3694 arglist = tree_cons (NULL_TREE, arg3, arglist);
3696 arglist = tree_cons (NULL_TREE, arg2, arglist);
3697 arglist = tree_cons (NULL_TREE, arg1, arglist);
3699 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3700 p = conversion_obstack_alloc (0);
3702 /* Add namespace-scope operators to the list of functions to
3704 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3705 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3706 flags, &candidates);
3707 /* Add class-member operators to the candidate set. */
3708 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3712 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3713 if (fns == error_mark_node)
3715 result = error_mark_node;
3716 goto user_defined_result_ready;
3719 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3721 BASELINK_BINFO (fns),
3722 TYPE_BINFO (TREE_TYPE (arg1)),
3723 flags, &candidates);
3726 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3727 to know about two args; a builtin candidate will always have a first
3728 parameter of type bool. We'll handle that in
3729 build_builtin_candidate. */
3730 if (code == COND_EXPR)
3740 args[2] = NULL_TREE;
3743 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3749 /* For these, the built-in candidates set is empty
3750 [over.match.oper]/3. We don't want non-strict matches
3751 because exact matches are always possible with built-in
3752 operators. The built-in candidate set for COMPONENT_REF
3753 would be empty too, but since there are no such built-in
3754 operators, we accept non-strict matches for them. */
3759 strict_p = pedantic;
3763 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3768 case POSTINCREMENT_EXPR:
3769 case POSTDECREMENT_EXPR:
3770 /* Look for an `operator++ (int)'. If they didn't have
3771 one, then we fall back to the old way of doing things. */
3772 if (flags & LOOKUP_COMPLAIN)
3773 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3774 "trying prefix operator instead",
3776 operator_name_info[code].name);
3777 if (code == POSTINCREMENT_EXPR)
3778 code = PREINCREMENT_EXPR;
3780 code = PREDECREMENT_EXPR;
3781 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3785 /* The caller will deal with these. */
3790 result_valid_p = true;
3794 if (flags & LOOKUP_COMPLAIN)
3796 op_error (code, code2, arg1, arg2, arg3, "no match");
3797 print_z_candidates (candidates);
3799 result = error_mark_node;
3805 cand = tourney (candidates);
3808 if (flags & LOOKUP_COMPLAIN)
3810 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3811 print_z_candidates (candidates);
3813 result = error_mark_node;
3815 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3818 *overloaded_p = true;
3820 result = build_over_call (cand, LOOKUP_NORMAL);
3824 /* Give any warnings we noticed during overload resolution. */
3827 struct candidate_warning *w;
3828 for (w = cand->warnings; w; w = w->next)
3829 joust (cand, w->loser, 1);
3832 /* Check for comparison of different enum types. */
3841 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3842 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3843 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3844 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3846 warning (0, "comparison between %q#T and %q#T",
3847 TREE_TYPE (arg1), TREE_TYPE (arg2));
3854 /* We need to strip any leading REF_BIND so that bitfields
3855 don't cause errors. This should not remove any important
3856 conversions, because builtins don't apply to class
3857 objects directly. */
3858 conv = cand->convs[0];
3859 if (conv->kind == ck_ref_bind)
3860 conv = conv->u.next;
3861 arg1 = convert_like (conv, arg1);
3864 conv = cand->convs[1];
3865 if (conv->kind == ck_ref_bind)
3866 conv = conv->u.next;
3867 arg2 = convert_like (conv, arg2);
3871 conv = cand->convs[2];
3872 if (conv->kind == ck_ref_bind)
3873 conv = conv->u.next;
3874 arg3 = convert_like (conv, arg3);
3879 user_defined_result_ready:
3881 /* Free all the conversions we allocated. */
3882 obstack_free (&conversion_obstack, p);
3884 if (result || result_valid_p)
3891 return build_modify_expr (arg1, code2, arg2);
3894 return build_indirect_ref (arg1, "unary *");
3899 case TRUNC_DIV_EXPR:
3910 case TRUNC_MOD_EXPR:
3914 case TRUTH_ANDIF_EXPR:
3915 case TRUTH_ORIF_EXPR:
3916 return cp_build_binary_op (code, arg1, arg2);
3918 case UNARY_PLUS_EXPR:
3921 case TRUTH_NOT_EXPR:
3922 case PREINCREMENT_EXPR:
3923 case POSTINCREMENT_EXPR:
3924 case PREDECREMENT_EXPR:
3925 case POSTDECREMENT_EXPR:
3928 return build_unary_op (code, arg1, candidates != 0);
3931 return build_array_ref (arg1, arg2);
3934 return build_conditional_expr (arg1, arg2, arg3);
3937 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
3939 /* The caller will deal with these. */
3951 /* Build a call to operator delete. This has to be handled very specially,
3952 because the restrictions on what signatures match are different from all
3953 other call instances. For a normal delete, only a delete taking (void *)
3954 or (void *, size_t) is accepted. For a placement delete, only an exact
3955 match with the placement new is accepted.
3957 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3958 ADDR is the pointer to be deleted.
3959 SIZE is the size of the memory block to be deleted.
3960 GLOBAL_P is true if the delete-expression should not consider
3961 class-specific delete operators.
3962 PLACEMENT is the corresponding placement new call, or NULL_TREE.
3963 If PLACEMENT is non-NULL, then ALLOC_FN is the allocation function
3964 called to perform the placement new. */
3967 build_op_delete_call (enum tree_code code, tree addr, tree size,
3968 bool global_p, tree placement,
3971 tree fn = NULL_TREE;
3972 tree fns, fnname, argtypes, args, type;
3975 if (addr == error_mark_node)
3976 return error_mark_node;
3978 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3980 fnname = ansi_opname (code);
3982 if (CLASS_TYPE_P (type)
3983 && COMPLETE_TYPE_P (complete_type (type))
3987 If the result of the lookup is ambiguous or inaccessible, or if
3988 the lookup selects a placement deallocation function, the
3989 program is ill-formed.
3991 Therefore, we ask lookup_fnfields to complain about ambiguity. */
3993 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3994 if (fns == error_mark_node)
3995 return error_mark_node;
4000 if (fns == NULL_TREE)
4001 fns = lookup_name_nonclass (fnname);
4005 /* Get the parameter types for the allocation function that is
4007 gcc_assert (alloc_fn != NULL_TREE);
4008 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4009 /* Also the second argument. */
4010 args = TREE_CHAIN (TREE_OPERAND (placement, 1));
4014 /* First try it without the size argument. */
4015 argtypes = void_list_node;
4019 /* Strip const and volatile from addr. */
4020 addr = cp_convert (ptr_type_node, addr);
4022 /* We make two tries at finding a matching `operator delete'. On
4023 the first pass, we look for a one-operator (or placement)
4024 operator delete. If we're not doing placement delete, then on
4025 the second pass we look for a two-argument delete. */
4026 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4028 /* Go through the `operator delete' functions looking for one
4029 with a matching type. */
4030 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4036 /* The first argument must be "void *". */
4037 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4038 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4041 /* On the first pass, check the rest of the arguments. */
4047 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4055 /* On the second pass, the second argument must be
4058 && same_type_p (TREE_VALUE (t), sizetype)
4059 && TREE_CHAIN (t) == void_list_node)
4063 /* If we found a match, we're done. */
4068 /* If we have a matching function, call it. */
4071 /* Make sure we have the actual function, and not an
4073 fn = OVL_CURRENT (fn);
4075 /* If the FN is a member function, make sure that it is
4077 if (DECL_CLASS_SCOPE_P (fn))
4078 perform_or_defer_access_check (TYPE_BINFO (type), fn);
4081 args = tree_cons (NULL_TREE, addr, args);
4083 args = tree_cons (NULL_TREE, addr,
4084 build_tree_list (NULL_TREE, size));
4088 /* The placement args might not be suitable for overload
4089 resolution at this point, so build the call directly. */
4091 return build_cxx_call (fn, args);
4094 return build_function_call (fn, args);
4097 /* If we are doing placement delete we do nothing if we don't find a
4098 matching op delete. */
4102 error ("no suitable %<operator %s%> for %qT",
4103 operator_name_info[(int)code].name, type);
4104 return error_mark_node;
4107 /* If the current scope isn't allowed to access DECL along
4108 BASETYPE_PATH, give an error. The most derived class in
4109 BASETYPE_PATH is the one used to qualify DECL. */
4112 enforce_access (tree basetype_path, tree decl)
4114 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4116 if (!accessible_p (basetype_path, decl, true))
4118 if (TREE_PRIVATE (decl))
4119 error ("%q+#D is private", decl);
4120 else if (TREE_PROTECTED (decl))
4121 error ("%q+#D is protected", decl);
4123 error ("%q+#D is inaccessible", decl);
4124 error ("within this context");
4131 /* Check that a callable constructor to initialize a temporary of
4132 TYPE from an EXPR exists. */
4135 check_constructor_callable (tree type, tree expr)
4137 build_special_member_call (NULL_TREE,
4138 complete_ctor_identifier,
4139 build_tree_list (NULL_TREE, expr),
4141 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4142 | LOOKUP_NO_CONVERSION
4143 | LOOKUP_CONSTRUCTOR_CALLABLE);
4146 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4147 bitwise or of LOOKUP_* values. If any errors are warnings are
4148 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4149 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4153 build_temp (tree expr, tree type, int flags,
4154 diagnostic_fn_t *diagnostic_fn)
4158 savew = warningcount, savee = errorcount;
4159 expr = build_special_member_call (NULL_TREE,
4160 complete_ctor_identifier,
4161 build_tree_list (NULL_TREE, expr),
4163 if (warningcount > savew)
4164 *diagnostic_fn = warning0;
4165 else if (errorcount > savee)
4166 *diagnostic_fn = error;
4168 *diagnostic_fn = NULL;
4173 /* Perform the conversions in CONVS on the expression EXPR. FN and
4174 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4175 indicates the `this' argument of a method. INNER is nonzero when
4176 being called to continue a conversion chain. It is negative when a
4177 reference binding will be applied, positive otherwise. If
4178 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4179 conversions will be emitted if appropriate. If C_CAST_P is true,
4180 this conversion is coming from a C-style cast; in that case,
4181 conversions to inaccessible bases are permitted. */
4184 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4185 int inner, bool issue_conversion_warnings,
4188 tree totype = convs->type;
4189 diagnostic_fn_t diagnostic_fn;
4192 && convs->kind != ck_user
4193 && convs->kind != ck_ambig
4194 && convs->kind != ck_ref_bind)
4196 conversion *t = convs;
4197 for (; t; t = convs->u.next)
4199 if (t->kind == ck_user || !t->bad_p)
4201 expr = convert_like_real (t, expr, fn, argnum, 1,
4202 /*issue_conversion_warnings=*/false,
4203 /*c_cast_p=*/false);
4206 else if (t->kind == ck_ambig)
4207 return convert_like_real (t, expr, fn, argnum, 1,
4208 /*issue_conversion_warnings=*/false,
4209 /*c_cast_p=*/false);
4210 else if (t->kind == ck_identity)
4213 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4215 pedwarn (" initializing argument %P of %qD", argnum, fn);
4216 return cp_convert (totype, expr);
4219 if (issue_conversion_warnings)
4221 tree t = non_reference (totype);
4223 /* Issue warnings about peculiar, but valid, uses of NULL. */
4224 if (ARITHMETIC_TYPE_P (t) && expr == null_node)
4227 warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4230 warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4233 /* Warn about assigning a floating-point type to an integer type. */
4234 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4235 && TREE_CODE (t) == INTEGER_TYPE)
4238 warning (OPT_Wconversion, "passing %qT for argument %P to %qD",
4239 TREE_TYPE (expr), argnum, fn);
4241 warning (OPT_Wconversion, "converting to %qT from %qT", t, TREE_TYPE (expr));
4245 switch (convs->kind)
4249 struct z_candidate *cand = convs->cand;
4250 tree convfn = cand->fn;
4253 if (DECL_CONSTRUCTOR_P (convfn))
4255 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4258 args = build_tree_list (NULL_TREE, expr);
4259 /* We should never try to call the abstract or base constructor
4261 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4262 && !DECL_HAS_VTT_PARM_P (convfn));
4263 args = tree_cons (NULL_TREE, t, args);
4266 args = build_this (expr);
4267 expr = build_over_call (cand, LOOKUP_NORMAL);
4269 /* If this is a constructor or a function returning an aggr type,
4270 we need to build up a TARGET_EXPR. */
4271 if (DECL_CONSTRUCTOR_P (convfn))
4272 expr = build_cplus_new (totype, expr);
4274 /* The result of the call is then used to direct-initialize the object
4275 that is the destination of the copy-initialization. [dcl.init]
4277 Note that this step is not reflected in the conversion sequence;
4278 it affects the semantics when we actually perform the
4279 conversion, but is not considered during overload resolution.
4281 If the target is a class, that means call a ctor. */
4282 if (IS_AGGR_TYPE (totype)
4283 && (inner >= 0 || !lvalue_p (expr)))
4287 /* Core issue 84, now a DR, says that we don't
4288 allow UDCs for these args (which deliberately
4289 breaks copy-init of an auto_ptr<Base> from an
4290 auto_ptr<Derived>). */
4291 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4298 (" initializing argument %P of %qD from result of %qD",
4299 argnum, fn, convfn);
4302 (" initializing temporary from result of %qD", convfn);
4304 expr = build_cplus_new (totype, expr);
4309 if (type_unknown_p (expr))
4310 expr = instantiate_type (totype, expr, tf_warning_or_error);
4311 /* Convert a constant to its underlying value, unless we are
4312 about to bind it to a reference, in which case we need to
4313 leave it as an lvalue. */
4315 expr = decl_constant_value (expr);
4316 if (convs->check_copy_constructor_p)
4317 check_constructor_callable (totype, expr);
4320 /* Call build_user_type_conversion again for the error. */
4321 return build_user_type_conversion
4322 (totype, convs->u.expr, LOOKUP_NORMAL);
4328 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4329 convs->kind == ck_ref_bind ? -1 : 1,
4330 /*issue_conversion_warnings=*/false,
4332 if (expr == error_mark_node)
4333 return error_mark_node;
4335 switch (convs->kind)
4338 expr = convert_bitfield_to_declared_type (expr);
4339 if (! IS_AGGR_TYPE (totype))
4341 /* Else fall through. */
4343 if (convs->kind == ck_base && !convs->need_temporary_p)
4345 /* We are going to bind a reference directly to a base-class
4346 subobject of EXPR. */
4347 if (convs->check_copy_constructor_p)
4348 check_constructor_callable (TREE_TYPE (expr), expr);
4349 /* Build an expression for `*((base*) &expr)'. */
4350 expr = build_unary_op (ADDR_EXPR, expr, 0);
4351 expr = convert_to_base (expr, build_pointer_type (totype),
4352 !c_cast_p, /*nonnull=*/true);
4353 expr = build_indirect_ref (expr, "implicit conversion");
4357 /* Copy-initialization where the cv-unqualified version of the source
4358 type is the same class as, or a derived class of, the class of the
4359 destination [is treated as direct-initialization]. [dcl.init] */
4360 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4362 if (diagnostic_fn && fn)
4363 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4364 return build_cplus_new (totype, expr);
4368 tree ref_type = totype;
4370 /* If necessary, create a temporary. */
4371 if (convs->need_temporary_p || !lvalue_p (expr))
4373 tree type = convs->u.next->type;
4374 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4376 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4378 /* If the reference is volatile or non-const, we
4379 cannot create a temporary. */
4380 if (lvalue & clk_bitfield)
4381 error ("cannot bind bitfield %qE to %qT",
4383 else if (lvalue & clk_packed)
4384 error ("cannot bind packed field %qE to %qT",
4387 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4388 return error_mark_node;
4390 /* If the source is a packed field, and we must use a copy
4391 constructor, then building the target expr will require
4392 binding the field to the reference parameter to the
4393 copy constructor, and we'll end up with an infinite
4394 loop. If we can use a bitwise copy, then we'll be
4396 if ((lvalue & clk_packed)
4397 && CLASS_TYPE_P (type)
4398 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4400 error ("cannot bind packed field %qE to %qT",
4402 return error_mark_node;
4404 expr = build_target_expr_with_type (expr, type);
4407 /* Take the address of the thing to which we will bind the
4409 expr = build_unary_op (ADDR_EXPR, expr, 1);
4410 if (expr == error_mark_node)
4411 return error_mark_node;
4413 /* Convert it to a pointer to the type referred to by the
4414 reference. This will adjust the pointer if a derived to
4415 base conversion is being performed. */
4416 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4418 /* Convert the pointer to the desired reference type. */
4419 return build_nop (ref_type, expr);
4423 return decay_conversion (expr);
4426 /* Warn about deprecated conversion if appropriate. */
4427 string_conv_p (totype, expr, 1);
4432 expr = convert_to_base (expr, totype, !c_cast_p,
4434 return build_nop (totype, expr);
4437 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4444 if (issue_conversion_warnings)
4445 expr = convert_and_check (totype, expr);
4447 expr = convert (totype, expr);
4452 /* Build a call to __builtin_trap. */
4455 call_builtin_trap (void)
4457 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4459 gcc_assert (fn != NULL);
4460 fn = build_call (fn, NULL_TREE);
4464 /* ARG is being passed to a varargs function. Perform any conversions
4465 required. Return the converted value. */
4468 convert_arg_to_ellipsis (tree arg)
4472 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4473 standard conversions are performed. */
4474 arg = decay_conversion (arg);
4477 If the argument has integral or enumeration type that is subject
4478 to the integral promotions (_conv.prom_), or a floating point
4479 type that is subject to the floating point promotion
4480 (_conv.fpprom_), the value of the argument is converted to the
4481 promoted type before the call. */
4482 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4483 && (TYPE_PRECISION (TREE_TYPE (arg))
4484 < TYPE_PRECISION (double_type_node)))
4485 arg = convert_to_real (double_type_node, arg);
4486 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4487 arg = perform_integral_promotions (arg);
4489 arg = require_complete_type (arg);
4491 if (arg != error_mark_node
4492 && !pod_type_p (TREE_TYPE (arg)))
4494 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4495 here and do a bitwise copy, but now cp_expr_size will abort if we
4497 If the call appears in the context of a sizeof expression,
4498 there is no need to emit a warning, since the expression won't be
4499 evaluated. We keep the builtin_trap just as a safety check. */
4500 if (!skip_evaluation)
4501 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4502 "call will abort at runtime", TREE_TYPE (arg));
4503 arg = call_builtin_trap ();
4504 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4511 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4514 build_x_va_arg (tree expr, tree type)
4516 if (processing_template_decl)
4517 return build_min (VA_ARG_EXPR, type, expr);
4519 type = complete_type_or_else (type, NULL_TREE);
4521 if (expr == error_mark_node || !type)
4522 return error_mark_node;
4524 if (! pod_type_p (type))
4526 /* Undefined behavior [expr.call] 5.2.2/7. */
4527 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4528 "call will abort at runtime", type);
4529 expr = convert (build_pointer_type (type), null_node);
4530 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4531 call_builtin_trap (), expr);
4532 expr = build_indirect_ref (expr, NULL);
4536 return build_va_arg (expr, type);
4539 /* TYPE has been given to va_arg. Apply the default conversions which
4540 would have happened when passed via ellipsis. Return the promoted
4541 type, or the passed type if there is no change. */
4544 cxx_type_promotes_to (tree type)
4548 /* Perform the array-to-pointer and function-to-pointer
4550 type = type_decays_to (type);
4552 promote = type_promotes_to (type);
4553 if (same_type_p (type, promote))
4559 /* ARG is a default argument expression being passed to a parameter of
4560 the indicated TYPE, which is a parameter to FN. Do any required
4561 conversions. Return the converted value. */
4564 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4566 /* If the ARG is an unparsed default argument expression, the
4567 conversion cannot be performed. */
4568 if (TREE_CODE (arg) == DEFAULT_ARG)
4570 error ("the default argument for parameter %d of %qD has "
4571 "not yet been parsed",
4573 return error_mark_node;
4576 if (fn && DECL_TEMPLATE_INFO (fn))
4577 arg = tsubst_default_argument (fn, type, arg);
4579 arg = break_out_target_exprs (arg);
4581 if (TREE_CODE (arg) == CONSTRUCTOR)
4583 arg = digest_init (type, arg);
4584 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4585 "default argument", fn, parmnum);
4589 /* This could get clobbered by the following call. */
4590 if (TREE_HAS_CONSTRUCTOR (arg))
4591 arg = copy_node (arg);
4593 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4594 "default argument", fn, parmnum);
4595 arg = convert_for_arg_passing (type, arg);
4601 /* Returns the type which will really be used for passing an argument of
4605 type_passed_as (tree type)
4607 /* Pass classes with copy ctors by invisible reference. */
4608 if (TREE_ADDRESSABLE (type))
4610 type = build_reference_type (type);
4611 /* There are no other pointers to this temporary. */
4612 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4614 else if (targetm.calls.promote_prototypes (type)
4615 && INTEGRAL_TYPE_P (type)
4616 && COMPLETE_TYPE_P (type)
4617 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4618 TYPE_SIZE (integer_type_node)))
4619 type = integer_type_node;
4624 /* Actually perform the appropriate conversion. */
4627 convert_for_arg_passing (tree type, tree val)
4629 if (val == error_mark_node)
4631 /* Pass classes with copy ctors by invisible reference. */
4632 else if (TREE_ADDRESSABLE (type))
4633 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4634 else if (targetm.calls.promote_prototypes (type)
4635 && INTEGRAL_TYPE_P (type)
4636 && COMPLETE_TYPE_P (type)
4637 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4638 TYPE_SIZE (integer_type_node)))
4639 val = perform_integral_promotions (val);
4640 if (warn_missing_format_attribute)
4642 tree rhstype = TREE_TYPE (val);
4643 const enum tree_code coder = TREE_CODE (rhstype);
4644 const enum tree_code codel = TREE_CODE (type);
4645 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4647 && check_missing_format_attribute (type, rhstype))
4648 warning (OPT_Wmissing_format_attribute,
4649 "argument of function call might be a candidate for a format attribute");
4654 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4655 which no conversions at all should be done. This is true for some
4656 builtins which don't act like normal functions. */
4659 magic_varargs_p (tree fn)
4661 if (DECL_BUILT_IN (fn))
4662 switch (DECL_FUNCTION_CODE (fn))
4664 case BUILT_IN_CLASSIFY_TYPE:
4665 case BUILT_IN_CONSTANT_P:
4666 case BUILT_IN_NEXT_ARG:
4667 case BUILT_IN_STDARG_START:
4668 case BUILT_IN_VA_START:
4677 /* Subroutine of the various build_*_call functions. Overload resolution
4678 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4679 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4680 bitmask of various LOOKUP_* flags which apply to the call itself. */
4683 build_over_call (struct z_candidate *cand, int flags)
4686 tree args = cand->args;
4687 conversion **convs = cand->convs;
4689 tree converted_args = NULL_TREE;
4690 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4695 /* In a template, there is no need to perform all of the work that
4696 is normally done. We are only interested in the type of the call
4697 expression, i.e., the return type of the function. Any semantic
4698 errors will be deferred until the template is instantiated. */
4699 if (processing_template_decl)
4703 return_type = TREE_TYPE (TREE_TYPE (fn));
4704 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4705 if (TREE_THIS_VOLATILE (fn) && cfun)
4706 current_function_returns_abnormally = 1;
4707 if (!VOID_TYPE_P (return_type))
4708 require_complete_type (return_type);
4709 return convert_from_reference (expr);
4712 /* Give any warnings we noticed during overload resolution. */
4715 struct candidate_warning *w;
4716 for (w = cand->warnings; w; w = w->next)
4717 joust (cand, w->loser, 1);
4720 if (DECL_FUNCTION_MEMBER_P (fn))
4722 /* If FN is a template function, two cases must be considered.
4727 template <class T> void f();
4729 template <class T> struct B {
4733 struct C : A, B<int> {
4735 using B<int>::g; // #2
4738 In case #1 where `A::f' is a member template, DECL_ACCESS is
4739 recorded in the primary template but not in its specialization.
4740 We check access of FN using its primary template.
4742 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4743 because it is a member of class template B, DECL_ACCESS is
4744 recorded in the specialization `B<int>::g'. We cannot use its
4745 primary template because `B<T>::g' and `B<int>::g' may have
4746 different access. */
4747 if (DECL_TEMPLATE_INFO (fn)
4748 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4749 perform_or_defer_access_check (cand->access_path,
4750 DECL_TI_TEMPLATE (fn));
4752 perform_or_defer_access_check (cand->access_path, fn);
4755 if (args && TREE_CODE (args) != TREE_LIST)
4756 args = build_tree_list (NULL_TREE, args);
4759 /* The implicit parameters to a constructor are not considered by overload
4760 resolution, and must be of the proper type. */
4761 if (DECL_CONSTRUCTOR_P (fn))
4763 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4764 arg = TREE_CHAIN (arg);
4765 parm = TREE_CHAIN (parm);
4766 /* We should never try to call the abstract constructor. */
4767 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4769 if (DECL_HAS_VTT_PARM_P (fn))
4771 converted_args = tree_cons
4772 (NULL_TREE, TREE_VALUE (arg), converted_args);
4773 arg = TREE_CHAIN (arg);
4774 parm = TREE_CHAIN (parm);
4777 /* Bypass access control for 'this' parameter. */
4778 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4780 tree parmtype = TREE_VALUE (parm);
4781 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4785 if (convs[i]->bad_p)
4786 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4787 TREE_TYPE (argtype), fn);
4789 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4790 X is called for an object that is not of type X, or of a type
4791 derived from X, the behavior is undefined.
4793 So we can assume that anything passed as 'this' is non-null, and
4794 optimize accordingly. */
4795 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4796 /* Convert to the base in which the function was declared. */
4797 gcc_assert (cand->conversion_path != NULL_TREE);
4798 converted_arg = build_base_path (PLUS_EXPR,
4800 cand->conversion_path,
4802 /* Check that the base class is accessible. */
4803 if (!accessible_base_p (TREE_TYPE (argtype),
4804 BINFO_TYPE (cand->conversion_path), true))
4805 error ("%qT is not an accessible base of %qT",
4806 BINFO_TYPE (cand->conversion_path),
4807 TREE_TYPE (argtype));
4808 /* If fn was found by a using declaration, the conversion path
4809 will be to the derived class, not the base declaring fn. We
4810 must convert from derived to base. */
4811 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4812 TREE_TYPE (parmtype), ba_unique, NULL);
4813 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4816 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4817 parm = TREE_CHAIN (parm);
4818 arg = TREE_CHAIN (arg);
4824 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4826 tree type = TREE_VALUE (parm);
4829 val = convert_like_with_context
4830 (conv, TREE_VALUE (arg), fn, i - is_method);
4832 val = convert_for_arg_passing (type, val);
4833 converted_args = tree_cons (NULL_TREE, val, converted_args);
4836 /* Default arguments */
4837 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4839 = tree_cons (NULL_TREE,
4840 convert_default_arg (TREE_VALUE (parm),
4841 TREE_PURPOSE (parm),
4846 for (; arg; arg = TREE_CHAIN (arg))
4848 tree a = TREE_VALUE (arg);
4849 if (magic_varargs_p (fn))
4850 /* Do no conversions for magic varargs. */;
4852 a = convert_arg_to_ellipsis (a);
4853 converted_args = tree_cons (NULL_TREE, a, converted_args);
4856 converted_args = nreverse (converted_args);
4858 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4859 converted_args, TYPE_ARG_TYPES (TREE_TYPE (fn)));
4861 /* Avoid actually calling copy constructors and copy assignment operators,
4864 if (! flag_elide_constructors)
4865 /* Do things the hard way. */;
4866 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4869 arg = skip_artificial_parms_for (fn, converted_args);
4870 arg = TREE_VALUE (arg);
4872 /* Pull out the real argument, disregarding const-correctness. */
4874 while (TREE_CODE (targ) == NOP_EXPR
4875 || TREE_CODE (targ) == NON_LVALUE_EXPR
4876 || TREE_CODE (targ) == CONVERT_EXPR)
4877 targ = TREE_OPERAND (targ, 0);
4878 if (TREE_CODE (targ) == ADDR_EXPR)
4880 targ = TREE_OPERAND (targ, 0);
4881 if (!same_type_ignoring_top_level_qualifiers_p
4882 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4891 arg = build_indirect_ref (arg, 0);
4893 /* [class.copy]: the copy constructor is implicitly defined even if
4894 the implementation elided its use. */
4895 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4898 /* If we're creating a temp and we already have one, don't create a
4899 new one. If we're not creating a temp but we get one, use
4900 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4901 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4902 temp or an INIT_EXPR otherwise. */
4903 if (integer_zerop (TREE_VALUE (args)))
4905 if (TREE_CODE (arg) == TARGET_EXPR)
4907 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4908 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4910 else if (TREE_CODE (arg) == TARGET_EXPR
4911 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4913 tree to = stabilize_reference
4914 (build_indirect_ref (TREE_VALUE (args), 0));
4916 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4920 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4922 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4924 tree to = stabilize_reference
4925 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4926 tree type = TREE_TYPE (to);
4927 tree as_base = CLASSTYPE_AS_BASE (type);
4929 arg = TREE_VALUE (TREE_CHAIN (converted_args));
4930 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4932 arg = build_indirect_ref (arg, 0);
4933 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4937 /* We must only copy the non-tail padding parts.
4938 Use __builtin_memcpy for the bitwise copy. */
4942 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
4943 args = tree_cons (NULL, arg, args);
4944 t = build_unary_op (ADDR_EXPR, to, 0);
4945 args = tree_cons (NULL, t, args);
4946 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
4947 t = build_call (t, args);
4949 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
4950 val = build_indirect_ref (t, 0);
4958 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4960 tree t, *p = &TREE_VALUE (converted_args);
4961 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4964 gcc_assert (binfo && binfo != error_mark_node);
4966 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4967 if (TREE_SIDE_EFFECTS (*p))
4968 *p = save_expr (*p);
4969 t = build_pointer_type (TREE_TYPE (fn));
4970 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4971 fn = build_java_interface_fn_ref (fn, *p);
4973 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
4976 else if (DECL_INLINE (fn))
4977 fn = inline_conversion (fn);
4979 fn = build_addr_func (fn);
4981 return build_cxx_call (fn, converted_args);
4984 /* Build and return a call to FN, using ARGS. This function performs
4985 no overload resolution, conversion, or other high-level
4989 build_cxx_call (tree fn, tree args)
4993 fn = build_call (fn, args);
4995 /* If this call might throw an exception, note that fact. */
4996 fndecl = get_callee_fndecl (fn);
4997 if ((!fndecl || !TREE_NOTHROW (fndecl))
4998 && at_function_scope_p ()
5000 cp_function_chain->can_throw = 1;
5002 /* Some built-in function calls will be evaluated at compile-time in
5004 fn = fold_if_not_in_template (fn);
5006 if (VOID_TYPE_P (TREE_TYPE (fn)))
5009 fn = require_complete_type (fn);
5010 if (fn == error_mark_node)
5011 return error_mark_node;
5013 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5014 fn = build_cplus_new (TREE_TYPE (fn), fn);
5015 return convert_from_reference (fn);
5018 static GTY(()) tree java_iface_lookup_fn;
5020 /* Make an expression which yields the address of the Java interface
5021 method FN. This is achieved by generating a call to libjava's
5022 _Jv_LookupInterfaceMethodIdx(). */
5025 build_java_interface_fn_ref (tree fn, tree instance)
5027 tree lookup_args, lookup_fn, method, idx;
5028 tree klass_ref, iface, iface_ref;
5031 if (!java_iface_lookup_fn)
5033 tree endlink = build_void_list_node ();
5034 tree t = tree_cons (NULL_TREE, ptr_type_node,
5035 tree_cons (NULL_TREE, ptr_type_node,
5036 tree_cons (NULL_TREE, java_int_type_node,
5038 java_iface_lookup_fn
5039 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
5040 build_function_type (ptr_type_node, t),
5041 0, NOT_BUILT_IN, NULL, NULL_TREE);
5044 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5045 This is the first entry in the vtable. */
5046 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5049 /* Get the java.lang.Class pointer for the interface being called. */
5050 iface = DECL_CONTEXT (fn);
5051 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5052 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5053 || DECL_CONTEXT (iface_ref) != iface)
5055 error ("could not find class$ field in java interface type %qT",
5057 return error_mark_node;
5059 iface_ref = build_address (iface_ref);
5060 iface_ref = convert (build_pointer_type (iface), iface_ref);
5062 /* Determine the itable index of FN. */
5064 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5066 if (!DECL_VIRTUAL_P (method))
5072 idx = build_int_cst (NULL_TREE, i);
5074 lookup_args = tree_cons (NULL_TREE, klass_ref,
5075 tree_cons (NULL_TREE, iface_ref,
5076 build_tree_list (NULL_TREE, idx)));
5077 lookup_fn = build1 (ADDR_EXPR,
5078 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5079 java_iface_lookup_fn);
5080 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
5083 /* Returns the value to use for the in-charge parameter when making a
5084 call to a function with the indicated NAME.
5086 FIXME:Can't we find a neater way to do this mapping? */
5089 in_charge_arg_for_name (tree name)
5091 if (name == base_ctor_identifier
5092 || name == base_dtor_identifier)
5093 return integer_zero_node;
5094 else if (name == complete_ctor_identifier)
5095 return integer_one_node;
5096 else if (name == complete_dtor_identifier)
5097 return integer_two_node;
5098 else if (name == deleting_dtor_identifier)
5099 return integer_three_node;
5101 /* This function should only be called with one of the names listed
5107 /* Build a call to a constructor, destructor, or an assignment
5108 operator for INSTANCE, an expression with class type. NAME
5109 indicates the special member function to call; ARGS are the
5110 arguments. BINFO indicates the base of INSTANCE that is to be
5111 passed as the `this' parameter to the member function called.
5113 FLAGS are the LOOKUP_* flags to use when processing the call.
5115 If NAME indicates a complete object constructor, INSTANCE may be
5116 NULL_TREE. In this case, the caller will call build_cplus_new to
5117 store the newly constructed object into a VAR_DECL. */
5120 build_special_member_call (tree instance, tree name, tree args,
5121 tree binfo, int flags)
5124 /* The type of the subobject to be constructed or destroyed. */
5127 gcc_assert (name == complete_ctor_identifier
5128 || name == base_ctor_identifier
5129 || name == complete_dtor_identifier
5130 || name == base_dtor_identifier
5131 || name == deleting_dtor_identifier
5132 || name == ansi_assopname (NOP_EXPR));
5135 /* Resolve the name. */
5136 if (!complete_type_or_else (binfo, NULL_TREE))
5137 return error_mark_node;
5139 binfo = TYPE_BINFO (binfo);
5142 gcc_assert (binfo != NULL_TREE);
5144 class_type = BINFO_TYPE (binfo);
5146 /* Handle the special case where INSTANCE is NULL_TREE. */
5147 if (name == complete_ctor_identifier && !instance)
5149 instance = build_int_cst (build_pointer_type (class_type), 0);
5150 instance = build1 (INDIRECT_REF, class_type, instance);
5154 if (name == complete_dtor_identifier
5155 || name == base_dtor_identifier
5156 || name == deleting_dtor_identifier)
5157 gcc_assert (args == NULL_TREE);
5159 /* Convert to the base class, if necessary. */
5160 if (!same_type_ignoring_top_level_qualifiers_p
5161 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5163 if (name != ansi_assopname (NOP_EXPR))
5164 /* For constructors and destructors, either the base is
5165 non-virtual, or it is virtual but we are doing the
5166 conversion from a constructor or destructor for the
5167 complete object. In either case, we can convert
5169 instance = convert_to_base_statically (instance, binfo);
5171 /* However, for assignment operators, we must convert
5172 dynamically if the base is virtual. */
5173 instance = build_base_path (PLUS_EXPR, instance,
5174 binfo, /*nonnull=*/1);
5178 gcc_assert (instance != NULL_TREE);
5180 fns = lookup_fnfields (binfo, name, 1);
5182 /* When making a call to a constructor or destructor for a subobject
5183 that uses virtual base classes, pass down a pointer to a VTT for
5185 if ((name == base_ctor_identifier
5186 || name == base_dtor_identifier)
5187 && CLASSTYPE_VBASECLASSES (class_type))
5192 /* If the current function is a complete object constructor
5193 or destructor, then we fetch the VTT directly.
5194 Otherwise, we look it up using the VTT we were given. */
5195 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5196 vtt = decay_conversion (vtt);
5197 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5198 build2 (EQ_EXPR, boolean_type_node,
5199 current_in_charge_parm, integer_zero_node),
5202 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5203 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5204 BINFO_SUBVTT_INDEX (binfo));
5206 args = tree_cons (NULL_TREE, sub_vtt, args);
5209 return build_new_method_call (instance, fns, args,
5210 TYPE_BINFO (BINFO_TYPE (binfo)),
5211 flags, /*fn=*/NULL);
5214 /* Return the NAME, as a C string. The NAME indicates a function that
5215 is a member of TYPE. *FREE_P is set to true if the caller must
5216 free the memory returned.
5218 Rather than go through all of this, we should simply set the names
5219 of constructors and destructors appropriately, and dispense with
5220 ctor_identifier, dtor_identifier, etc. */
5223 name_as_c_string (tree name, tree type, bool *free_p)
5227 /* Assume that we will not allocate memory. */
5229 /* Constructors and destructors are special. */
5230 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5233 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5234 /* For a destructor, add the '~'. */
5235 if (name == complete_dtor_identifier
5236 || name == base_dtor_identifier
5237 || name == deleting_dtor_identifier)
5239 pretty_name = concat ("~", pretty_name, NULL);
5240 /* Remember that we need to free the memory allocated. */
5244 else if (IDENTIFIER_TYPENAME_P (name))
5246 pretty_name = concat ("operator ",
5247 type_as_string (TREE_TYPE (name),
5248 TFF_PLAIN_IDENTIFIER),
5250 /* Remember that we need to free the memory allocated. */
5254 pretty_name = (char *) IDENTIFIER_POINTER (name);
5259 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5260 be set, upon return, to the function called. */
5263 build_new_method_call (tree instance, tree fns, tree args,
5264 tree conversion_path, int flags,
5267 struct z_candidate *candidates = 0, *cand;
5268 tree explicit_targs = NULL_TREE;
5269 tree basetype = NULL_TREE;
5272 tree mem_args = NULL_TREE, instance_ptr;
5278 int template_only = 0;
5285 gcc_assert (instance != NULL_TREE);
5287 /* We don't know what function we're going to call, yet. */
5291 if (error_operand_p (instance)
5292 || error_operand_p (fns)
5293 || args == error_mark_node)
5294 return error_mark_node;
5296 if (!BASELINK_P (fns))
5298 error ("call to non-function %qD", fns);
5299 return error_mark_node;
5302 orig_instance = instance;
5306 /* Dismantle the baselink to collect all the information we need. */
5307 if (!conversion_path)
5308 conversion_path = BASELINK_BINFO (fns);
5309 access_binfo = BASELINK_ACCESS_BINFO (fns);
5310 optype = BASELINK_OPTYPE (fns);
5311 fns = BASELINK_FUNCTIONS (fns);
5312 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5314 explicit_targs = TREE_OPERAND (fns, 1);
5315 fns = TREE_OPERAND (fns, 0);
5318 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5319 || TREE_CODE (fns) == TEMPLATE_DECL
5320 || TREE_CODE (fns) == OVERLOAD);
5321 fn = get_first_fn (fns);
5322 name = DECL_NAME (fn);
5324 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5325 gcc_assert (CLASS_TYPE_P (basetype));
5327 if (processing_template_decl)
5329 instance = build_non_dependent_expr (instance);
5330 args = build_non_dependent_args (orig_args);
5333 /* The USER_ARGS are the arguments we will display to users if an
5334 error occurs. The USER_ARGS should not include any
5335 compiler-generated arguments. The "this" pointer hasn't been
5336 added yet. However, we must remove the VTT pointer if this is a
5337 call to a base-class constructor or destructor. */
5339 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5341 /* Callers should explicitly indicate whether they want to construct
5342 the complete object or just the part without virtual bases. */
5343 gcc_assert (name != ctor_identifier);
5344 /* Similarly for destructors. */
5345 gcc_assert (name != dtor_identifier);
5346 /* Remove the VTT pointer, if present. */
5347 if ((name == base_ctor_identifier || name == base_dtor_identifier)
5348 && CLASSTYPE_VBASECLASSES (basetype))
5349 user_args = TREE_CHAIN (user_args);
5352 /* Process the argument list. */
5353 args = resolve_args (args);
5354 if (args == error_mark_node)
5355 return error_mark_node;
5357 instance_ptr = build_this (instance);
5359 /* It's OK to call destructors on cv-qualified objects. Therefore,
5360 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5361 if (DECL_DESTRUCTOR_P (fn))
5363 tree type = build_pointer_type (basetype);
5364 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5365 instance_ptr = build_nop (type, instance_ptr);
5366 name = complete_dtor_identifier;
5369 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5370 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5372 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5373 p = conversion_obstack_alloc (0);
5375 for (fn = fns; fn; fn = OVL_NEXT (fn))
5377 tree t = OVL_CURRENT (fn);
5380 /* We can end up here for copy-init of same or base class. */
5381 if ((flags & LOOKUP_ONLYCONVERTING)
5382 && DECL_NONCONVERTING_P (t))
5385 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5386 this_arglist = mem_args;
5388 this_arglist = args;
5390 if (TREE_CODE (t) == TEMPLATE_DECL)
5391 /* A member template. */
5392 add_template_candidate (&candidates, t,
5395 this_arglist, optype,
5400 else if (! template_only)
5401 add_function_candidate (&candidates, t,
5409 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5412 if (!COMPLETE_TYPE_P (basetype))
5413 cxx_incomplete_type_error (instance_ptr, basetype);
5419 pretty_name = name_as_c_string (name, basetype, &free_p);
5420 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5421 basetype, pretty_name, user_args,
5422 TREE_TYPE (TREE_TYPE (instance_ptr)));
5426 print_z_candidates (candidates);
5427 call = error_mark_node;
5431 cand = tourney (candidates);
5437 pretty_name = name_as_c_string (name, basetype, &free_p);
5438 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5440 print_z_candidates (candidates);
5443 call = error_mark_node;
5449 if (!(flags & LOOKUP_NONVIRTUAL)
5450 && DECL_PURE_VIRTUAL_P (fn)
5451 && instance == current_class_ref
5452 && (DECL_CONSTRUCTOR_P (current_function_decl)
5453 || DECL_DESTRUCTOR_P (current_function_decl)))
5454 /* This is not an error, it is runtime undefined
5456 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5457 "abstract virtual %q#D called from constructor"
5458 : "abstract virtual %q#D called from destructor"),
5461 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5462 && is_dummy_object (instance_ptr))
5464 error ("cannot call member function %qD without object",
5466 call = error_mark_node;
5470 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5471 && resolves_to_fixed_type_p (instance, 0))
5472 flags |= LOOKUP_NONVIRTUAL;
5473 /* Now we know what function is being called. */
5476 /* Build the actual CALL_EXPR. */
5477 call = build_over_call (cand, flags);
5478 /* In an expression of the form `a->f()' where `f' turns
5479 out to be a static member function, `a' is
5480 none-the-less evaluated. */
5481 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
5482 && !is_dummy_object (instance_ptr)
5483 && TREE_SIDE_EFFECTS (instance))
5484 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5490 if (processing_template_decl && call != error_mark_node)
5491 call = (build_min_non_dep
5493 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5494 orig_args, NULL_TREE));
5496 /* Free all the conversions we allocated. */
5497 obstack_free (&conversion_obstack, p);
5502 /* Returns true iff standard conversion sequence ICS1 is a proper
5503 subsequence of ICS2. */
5506 is_subseq (conversion *ics1, conversion *ics2)
5508 /* We can assume that a conversion of the same code
5509 between the same types indicates a subsequence since we only get
5510 here if the types we are converting from are the same. */
5512 while (ics1->kind == ck_rvalue
5513 || ics1->kind == ck_lvalue)
5514 ics1 = ics1->u.next;
5518 while (ics2->kind == ck_rvalue
5519 || ics2->kind == ck_lvalue)
5520 ics2 = ics2->u.next;
5522 if (ics2->kind == ck_user
5523 || ics2->kind == ck_ambig
5524 || ics2->kind == ck_identity)
5525 /* At this point, ICS1 cannot be a proper subsequence of
5526 ICS2. We can get a USER_CONV when we are comparing the
5527 second standard conversion sequence of two user conversion
5531 ics2 = ics2->u.next;
5533 if (ics2->kind == ics1->kind
5534 && same_type_p (ics2->type, ics1->type)
5535 && same_type_p (ics2->u.next->type,
5536 ics1->u.next->type))
5541 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5542 be any _TYPE nodes. */
5545 is_properly_derived_from (tree derived, tree base)
5547 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5548 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5551 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5552 considers every class derived from itself. */
5553 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5554 && DERIVED_FROM_P (base, derived));
5557 /* We build the ICS for an implicit object parameter as a pointer
5558 conversion sequence. However, such a sequence should be compared
5559 as if it were a reference conversion sequence. If ICS is the
5560 implicit conversion sequence for an implicit object parameter,
5561 modify it accordingly. */
5564 maybe_handle_implicit_object (conversion **ics)
5568 /* [over.match.funcs]
5570 For non-static member functions, the type of the
5571 implicit object parameter is "reference to cv X"
5572 where X is the class of which the function is a
5573 member and cv is the cv-qualification on the member
5574 function declaration. */
5575 conversion *t = *ics;
5576 tree reference_type;
5578 /* The `this' parameter is a pointer to a class type. Make the
5579 implicit conversion talk about a reference to that same class
5581 reference_type = TREE_TYPE (t->type);
5582 reference_type = build_reference_type (reference_type);
5584 if (t->kind == ck_qual)
5586 if (t->kind == ck_ptr)
5588 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5589 t = direct_reference_binding (reference_type, t);
5594 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5595 and return the type to which the reference refers. Otherwise,
5596 leave *ICS unchanged and return NULL_TREE. */
5599 maybe_handle_ref_bind (conversion **ics)
5601 if ((*ics)->kind == ck_ref_bind)
5603 conversion *old_ics = *ics;
5604 tree type = TREE_TYPE (old_ics->type);
5605 *ics = old_ics->u.next;
5606 (*ics)->user_conv_p = old_ics->user_conv_p;
5607 (*ics)->bad_p = old_ics->bad_p;
5614 /* Compare two implicit conversion sequences according to the rules set out in
5615 [over.ics.rank]. Return values:
5617 1: ics1 is better than ics2
5618 -1: ics2 is better than ics1
5619 0: ics1 and ics2 are indistinguishable */
5622 compare_ics (conversion *ics1, conversion *ics2)
5628 tree deref_from_type1 = NULL_TREE;
5629 tree deref_from_type2 = NULL_TREE;
5630 tree deref_to_type1 = NULL_TREE;
5631 tree deref_to_type2 = NULL_TREE;
5632 conversion_rank rank1, rank2;
5634 /* REF_BINDING is nonzero if the result of the conversion sequence
5635 is a reference type. In that case TARGET_TYPE is the
5636 type referred to by the reference. */
5640 /* Handle implicit object parameters. */
5641 maybe_handle_implicit_object (&ics1);
5642 maybe_handle_implicit_object (&ics2);
5644 /* Handle reference parameters. */
5645 target_type1 = maybe_handle_ref_bind (&ics1);
5646 target_type2 = maybe_handle_ref_bind (&ics2);
5650 When comparing the basic forms of implicit conversion sequences (as
5651 defined in _over.best.ics_)
5653 --a standard conversion sequence (_over.ics.scs_) is a better
5654 conversion sequence than a user-defined conversion sequence
5655 or an ellipsis conversion sequence, and
5657 --a user-defined conversion sequence (_over.ics.user_) is a
5658 better conversion sequence than an ellipsis conversion sequence
5659 (_over.ics.ellipsis_). */
5660 rank1 = CONVERSION_RANK (ics1);
5661 rank2 = CONVERSION_RANK (ics2);
5665 else if (rank1 < rank2)
5668 if (rank1 == cr_bad)
5670 /* XXX Isn't this an extension? */
5671 /* Both ICS are bad. We try to make a decision based on what
5672 would have happened if they'd been good. */
5673 if (ics1->user_conv_p > ics2->user_conv_p
5674 || ics1->rank > ics2->rank)
5676 else if (ics1->user_conv_p < ics2->user_conv_p
5677 || ics1->rank < ics2->rank)
5680 /* We couldn't make up our minds; try to figure it out below. */
5683 if (ics1->ellipsis_p)
5684 /* Both conversions are ellipsis conversions. */
5687 /* User-defined conversion sequence U1 is a better conversion sequence
5688 than another user-defined conversion sequence U2 if they contain the
5689 same user-defined conversion operator or constructor and if the sec-
5690 ond standard conversion sequence of U1 is better than the second
5691 standard conversion sequence of U2. */
5693 if (ics1->user_conv_p)
5698 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5699 if (t1->kind == ck_ambig)
5701 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5702 if (t2->kind == ck_ambig)
5705 if (t1->cand->fn != t2->cand->fn)
5708 /* We can just fall through here, after setting up
5709 FROM_TYPE1 and FROM_TYPE2. */
5710 from_type1 = t1->type;
5711 from_type2 = t2->type;
5718 /* We're dealing with two standard conversion sequences.
5722 Standard conversion sequence S1 is a better conversion
5723 sequence than standard conversion sequence S2 if
5725 --S1 is a proper subsequence of S2 (comparing the conversion
5726 sequences in the canonical form defined by _over.ics.scs_,
5727 excluding any Lvalue Transformation; the identity
5728 conversion sequence is considered to be a subsequence of
5729 any non-identity conversion sequence */
5732 while (t1->kind != ck_identity)
5734 from_type1 = t1->type;
5737 while (t2->kind != ck_identity)
5739 from_type2 = t2->type;
5742 if (same_type_p (from_type1, from_type2))
5744 if (is_subseq (ics1, ics2))
5746 if (is_subseq (ics2, ics1))
5749 /* Otherwise, one sequence cannot be a subsequence of the other; they
5750 don't start with the same type. This can happen when comparing the
5751 second standard conversion sequence in two user-defined conversion
5758 --the rank of S1 is better than the rank of S2 (by the rules
5761 Standard conversion sequences are ordered by their ranks: an Exact
5762 Match is a better conversion than a Promotion, which is a better
5763 conversion than a Conversion.
5765 Two conversion sequences with the same rank are indistinguishable
5766 unless one of the following rules applies:
5768 --A conversion that is not a conversion of a pointer, or pointer
5769 to member, to bool is better than another conversion that is such
5772 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5773 so that we do not have to check it explicitly. */
5774 if (ics1->rank < ics2->rank)
5776 else if (ics2->rank < ics1->rank)
5779 to_type1 = ics1->type;
5780 to_type2 = ics2->type;
5782 if (TYPE_PTR_P (from_type1)
5783 && TYPE_PTR_P (from_type2)
5784 && TYPE_PTR_P (to_type1)
5785 && TYPE_PTR_P (to_type2))
5787 deref_from_type1 = TREE_TYPE (from_type1);
5788 deref_from_type2 = TREE_TYPE (from_type2);
5789 deref_to_type1 = TREE_TYPE (to_type1);
5790 deref_to_type2 = TREE_TYPE (to_type2);
5792 /* The rules for pointers to members A::* are just like the rules
5793 for pointers A*, except opposite: if B is derived from A then
5794 A::* converts to B::*, not vice versa. For that reason, we
5795 switch the from_ and to_ variables here. */
5796 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5797 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5798 || (TYPE_PTRMEMFUNC_P (from_type1)
5799 && TYPE_PTRMEMFUNC_P (from_type2)
5800 && TYPE_PTRMEMFUNC_P (to_type1)
5801 && TYPE_PTRMEMFUNC_P (to_type2)))
5803 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5804 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5805 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5806 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5809 if (deref_from_type1 != NULL_TREE
5810 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5811 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5813 /* This was one of the pointer or pointer-like conversions.
5817 --If class B is derived directly or indirectly from class A,
5818 conversion of B* to A* is better than conversion of B* to
5819 void*, and conversion of A* to void* is better than
5820 conversion of B* to void*. */
5821 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5822 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5824 if (is_properly_derived_from (deref_from_type1,
5827 else if (is_properly_derived_from (deref_from_type2,
5831 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5832 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5834 if (same_type_p (deref_from_type1, deref_from_type2))
5836 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5838 if (is_properly_derived_from (deref_from_type1,
5842 /* We know that DEREF_TO_TYPE1 is `void' here. */
5843 else if (is_properly_derived_from (deref_from_type1,
5848 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5849 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5853 --If class B is derived directly or indirectly from class A
5854 and class C is derived directly or indirectly from B,
5856 --conversion of C* to B* is better than conversion of C* to
5859 --conversion of B* to A* is better than conversion of C* to
5861 if (same_type_p (deref_from_type1, deref_from_type2))
5863 if (is_properly_derived_from (deref_to_type1,
5866 else if (is_properly_derived_from (deref_to_type2,
5870 else if (same_type_p (deref_to_type1, deref_to_type2))
5872 if (is_properly_derived_from (deref_from_type2,
5875 else if (is_properly_derived_from (deref_from_type1,
5881 else if (CLASS_TYPE_P (non_reference (from_type1))
5882 && same_type_p (from_type1, from_type2))
5884 tree from = non_reference (from_type1);
5888 --binding of an expression of type C to a reference of type
5889 B& is better than binding an expression of type C to a
5890 reference of type A&
5892 --conversion of C to B is better than conversion of C to A, */
5893 if (is_properly_derived_from (from, to_type1)
5894 && is_properly_derived_from (from, to_type2))
5896 if (is_properly_derived_from (to_type1, to_type2))
5898 else if (is_properly_derived_from (to_type2, to_type1))
5902 else if (CLASS_TYPE_P (non_reference (to_type1))
5903 && same_type_p (to_type1, to_type2))
5905 tree to = non_reference (to_type1);
5909 --binding of an expression of type B to a reference of type
5910 A& is better than binding an expression of type C to a
5911 reference of type A&,
5913 --conversion of B to A is better than conversion of C to A */
5914 if (is_properly_derived_from (from_type1, to)
5915 && is_properly_derived_from (from_type2, to))
5917 if (is_properly_derived_from (from_type2, from_type1))
5919 else if (is_properly_derived_from (from_type1, from_type2))
5926 --S1 and S2 differ only in their qualification conversion and yield
5927 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5928 qualification signature of type T1 is a proper subset of the cv-
5929 qualification signature of type T2 */
5930 if (ics1->kind == ck_qual
5931 && ics2->kind == ck_qual
5932 && same_type_p (from_type1, from_type2))
5933 return comp_cv_qual_signature (to_type1, to_type2);
5937 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5938 types to which the references refer are the same type except for
5939 top-level cv-qualifiers, and the type to which the reference
5940 initialized by S2 refers is more cv-qualified than the type to
5941 which the reference initialized by S1 refers */
5943 if (target_type1 && target_type2
5944 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5945 return comp_cv_qualification (target_type2, target_type1);
5947 /* Neither conversion sequence is better than the other. */
5951 /* The source type for this standard conversion sequence. */
5954 source_type (conversion *t)
5956 for (;; t = t->u.next)
5958 if (t->kind == ck_user
5959 || t->kind == ck_ambig
5960 || t->kind == ck_identity)
5966 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5967 a pointer to LOSER and re-running joust to produce the warning if WINNER
5968 is actually used. */
5971 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5973 candidate_warning *cw = (candidate_warning *)
5974 conversion_obstack_alloc (sizeof (candidate_warning));
5976 cw->next = winner->warnings;
5977 winner->warnings = cw;
5980 /* Compare two candidates for overloading as described in
5981 [over.match.best]. Return values:
5983 1: cand1 is better than cand2
5984 -1: cand2 is better than cand1
5985 0: cand1 and cand2 are indistinguishable */
5988 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5991 int off1 = 0, off2 = 0;
5995 /* Candidates that involve bad conversions are always worse than those
5997 if (cand1->viable > cand2->viable)
5999 if (cand1->viable < cand2->viable)
6002 /* If we have two pseudo-candidates for conversions to the same type,
6003 or two candidates for the same function, arbitrarily pick one. */
6004 if (cand1->fn == cand2->fn
6005 && (IS_TYPE_OR_DECL_P (cand1->fn)))
6008 /* a viable function F1
6009 is defined to be a better function than another viable function F2 if
6010 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6011 ICSi(F2), and then */
6013 /* for some argument j, ICSj(F1) is a better conversion sequence than
6016 /* For comparing static and non-static member functions, we ignore
6017 the implicit object parameter of the non-static function. The
6018 standard says to pretend that the static function has an object
6019 parm, but that won't work with operator overloading. */
6020 len = cand1->num_convs;
6021 if (len != cand2->num_convs)
6023 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6024 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6026 gcc_assert (static_1 != static_2);
6037 for (i = 0; i < len; ++i)
6039 conversion *t1 = cand1->convs[i + off1];
6040 conversion *t2 = cand2->convs[i + off2];
6041 int comp = compare_ics (t1, t2);
6046 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6047 == cr_std + cr_promotion)
6048 && t1->kind == ck_std
6049 && t2->kind == ck_std
6050 && TREE_CODE (t1->type) == INTEGER_TYPE
6051 && TREE_CODE (t2->type) == INTEGER_TYPE
6052 && (TYPE_PRECISION (t1->type)
6053 == TYPE_PRECISION (t2->type))
6054 && (TYPE_UNSIGNED (t1->u.next->type)
6055 || (TREE_CODE (t1->u.next->type)
6058 tree type = t1->u.next->type;
6060 struct z_candidate *w, *l;
6062 type1 = t1->type, type2 = t2->type,
6063 w = cand1, l = cand2;
6065 type1 = t2->type, type2 = t1->type,
6066 w = cand2, l = cand1;
6070 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6071 type, type1, type2);
6072 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
6078 if (winner && comp != winner)
6087 /* warn about confusing overload resolution for user-defined conversions,
6088 either between a constructor and a conversion op, or between two
6090 if (winner && warn_conversion && cand1->second_conv
6091 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6092 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6094 struct z_candidate *w, *l;
6095 bool give_warning = false;
6098 w = cand1, l = cand2;
6100 w = cand2, l = cand1;
6102 /* We don't want to complain about `X::operator T1 ()'
6103 beating `X::operator T2 () const', when T2 is a no less
6104 cv-qualified version of T1. */
6105 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6106 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6108 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6109 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6111 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6116 if (!comp_ptr_ttypes (t, f))
6117 give_warning = true;
6120 give_warning = true;
6126 tree source = source_type (w->convs[0]);
6127 if (! DECL_CONSTRUCTOR_P (w->fn))
6128 source = TREE_TYPE (source);
6129 warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn);
6130 warning (OPT_Wconversion, " for conversion from %qT to %qT",
6131 source, w->second_conv->type);
6132 inform (" because conversion sequence for the argument is better");
6142 F1 is a non-template function and F2 is a template function
6145 if (!cand1->template_decl && cand2->template_decl)
6147 else if (cand1->template_decl && !cand2->template_decl)
6151 F1 and F2 are template functions and the function template for F1 is
6152 more specialized than the template for F2 according to the partial
6155 if (cand1->template_decl && cand2->template_decl)
6157 winner = more_specialized_fn
6158 (TI_TEMPLATE (cand1->template_decl),
6159 TI_TEMPLATE (cand2->template_decl),
6160 /* [temp.func.order]: The presence of unused ellipsis and default
6161 arguments has no effect on the partial ordering of function
6162 templates. add_function_candidate() will not have
6163 counted the "this" argument for constructors. */
6164 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6170 the context is an initialization by user-defined conversion (see
6171 _dcl.init_ and _over.match.user_) and the standard conversion
6172 sequence from the return type of F1 to the destination type (i.e.,
6173 the type of the entity being initialized) is a better conversion
6174 sequence than the standard conversion sequence from the return type
6175 of F2 to the destination type. */
6177 if (cand1->second_conv)
6179 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6184 /* Check whether we can discard a builtin candidate, either because we
6185 have two identical ones or matching builtin and non-builtin candidates.
6187 (Pedantically in the latter case the builtin which matched the user
6188 function should not be added to the overload set, but we spot it here.
6191 ... the builtin candidates include ...
6192 - do not have the same parameter type list as any non-template
6193 non-member candidate. */
6195 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6196 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6198 for (i = 0; i < len; ++i)
6199 if (!same_type_p (cand1->convs[i]->type,
6200 cand2->convs[i]->type))
6202 if (i == cand1->num_convs)
6204 if (cand1->fn == cand2->fn)
6205 /* Two built-in candidates; arbitrarily pick one. */
6207 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6208 /* cand1 is built-in; prefer cand2. */
6211 /* cand2 is built-in; prefer cand1. */
6216 /* If the two functions are the same (this can happen with declarations
6217 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6218 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6219 && equal_functions (cand1->fn, cand2->fn))
6224 /* Extension: If the worst conversion for one candidate is worse than the
6225 worst conversion for the other, take the first. */
6228 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6229 struct z_candidate *w = 0, *l = 0;
6231 for (i = 0; i < len; ++i)
6233 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6234 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6235 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6236 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6239 winner = 1, w = cand1, l = cand2;
6241 winner = -1, w = cand2, l = cand1;
6247 ISO C++ says that these are ambiguous, even \
6248 though the worst conversion for the first is better than \
6249 the worst conversion for the second:");
6250 print_z_candidate (_("candidate 1:"), w);
6251 print_z_candidate (_("candidate 2:"), l);
6259 gcc_assert (!winner);
6263 /* Given a list of candidates for overloading, find the best one, if any.
6264 This algorithm has a worst case of O(2n) (winner is last), and a best
6265 case of O(n/2) (totally ambiguous); much better than a sorting
6268 static struct z_candidate *
6269 tourney (struct z_candidate *candidates)
6271 struct z_candidate *champ = candidates, *challenger;
6273 int champ_compared_to_predecessor = 0;
6275 /* Walk through the list once, comparing each current champ to the next
6276 candidate, knocking out a candidate or two with each comparison. */
6278 for (challenger = champ->next; challenger; )
6280 fate = joust (champ, challenger, 0);
6282 challenger = challenger->next;
6287 champ = challenger->next;
6290 champ_compared_to_predecessor = 0;
6295 champ_compared_to_predecessor = 1;
6298 challenger = champ->next;
6302 /* Make sure the champ is better than all the candidates it hasn't yet
6303 been compared to. */
6305 for (challenger = candidates;
6307 && !(champ_compared_to_predecessor && challenger->next == champ);
6308 challenger = challenger->next)
6310 fate = joust (champ, challenger, 0);
6318 /* Returns nonzero if things of type FROM can be converted to TO. */
6321 can_convert (tree to, tree from)
6323 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6326 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6329 can_convert_arg (tree to, tree from, tree arg, int flags)
6335 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6336 p = conversion_obstack_alloc (0);
6338 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6340 ok_p = (t && !t->bad_p);
6342 /* Free all the conversions we allocated. */
6343 obstack_free (&conversion_obstack, p);
6348 /* Like can_convert_arg, but allows dubious conversions as well. */
6351 can_convert_arg_bad (tree to, tree from, tree arg)
6356 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6357 p = conversion_obstack_alloc (0);
6358 /* Try to perform the conversion. */
6359 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6361 /* Free all the conversions we allocated. */
6362 obstack_free (&conversion_obstack, p);
6367 /* Convert EXPR to TYPE. Return the converted expression.
6369 Note that we allow bad conversions here because by the time we get to
6370 this point we are committed to doing the conversion. If we end up
6371 doing a bad conversion, convert_like will complain. */
6374 perform_implicit_conversion (tree type, tree expr)
6379 if (error_operand_p (expr))
6380 return error_mark_node;
6382 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6383 p = conversion_obstack_alloc (0);
6385 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6390 error ("could not convert %qE to %qT", expr, type);
6391 expr = error_mark_node;
6393 else if (processing_template_decl)
6395 /* In a template, we are only concerned about determining the
6396 type of non-dependent expressions, so we do not have to
6397 perform the actual conversion. */
6398 if (TREE_TYPE (expr) != type)
6399 expr = build_nop (type, expr);
6402 expr = convert_like (conv, expr);
6404 /* Free all the conversions we allocated. */
6405 obstack_free (&conversion_obstack, p);
6410 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6411 permitted. If the conversion is valid, the converted expression is
6412 returned. Otherwise, NULL_TREE is returned, except in the case
6413 that TYPE is a class type; in that case, an error is issued. If
6414 C_CAST_P is true, then this direction initialization is taking
6415 place as part of a static_cast being attempted as part of a C-style
6419 perform_direct_initialization_if_possible (tree type,
6426 if (type == error_mark_node || error_operand_p (expr))
6427 return error_mark_node;
6430 If the destination type is a (possibly cv-qualified) class type:
6432 -- If the initialization is direct-initialization ...,
6433 constructors are considered. ... If no constructor applies, or
6434 the overload resolution is ambiguous, the initialization is
6436 if (CLASS_TYPE_P (type))
6438 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6439 build_tree_list (NULL_TREE, expr),
6440 type, LOOKUP_NORMAL);
6441 return build_cplus_new (type, expr);
6444 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6445 p = conversion_obstack_alloc (0);
6447 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6450 if (!conv || conv->bad_p)
6453 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6454 /*issue_conversion_warnings=*/false,
6457 /* Free all the conversions we allocated. */
6458 obstack_free (&conversion_obstack, p);
6463 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6464 is being bound to a temporary. Create and return a new VAR_DECL
6465 with the indicated TYPE; this variable will store the value to
6466 which the reference is bound. */
6469 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6473 /* Create the variable. */
6474 var = create_temporary_var (type);
6476 /* Register the variable. */
6477 if (TREE_STATIC (decl))
6479 /* Namespace-scope or local static; give it a mangled name. */
6482 TREE_STATIC (var) = 1;
6483 name = mangle_ref_init_variable (decl);
6484 DECL_NAME (var) = name;
6485 SET_DECL_ASSEMBLER_NAME (var, name);
6486 var = pushdecl_top_level (var);
6489 /* Create a new cleanup level if necessary. */
6490 maybe_push_cleanup_level (type);
6495 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6496 initializing a variable of that TYPE. If DECL is non-NULL, it is
6497 the VAR_DECL being initialized with the EXPR. (In that case, the
6498 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6499 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6500 return, if *CLEANUP is no longer NULL, it will be an expression
6501 that should be pushed as a cleanup after the returned expression
6502 is used to initialize DECL.
6504 Return the converted expression. */
6507 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6512 if (type == error_mark_node || error_operand_p (expr))
6513 return error_mark_node;
6515 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6516 p = conversion_obstack_alloc (0);
6518 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6519 if (!conv || conv->bad_p)
6521 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6522 && !real_lvalue_p (expr))
6523 error ("invalid initialization of non-const reference of "
6524 "type %qT from a temporary of type %qT",
6525 type, TREE_TYPE (expr));
6527 error ("invalid initialization of reference of type "
6528 "%qT from expression of type %qT", type,
6530 return error_mark_node;
6533 /* If DECL is non-NULL, then this special rule applies:
6537 The temporary to which the reference is bound or the temporary
6538 that is the complete object to which the reference is bound
6539 persists for the lifetime of the reference.
6541 The temporaries created during the evaluation of the expression
6542 initializing the reference, except the temporary to which the
6543 reference is bound, are destroyed at the end of the
6544 full-expression in which they are created.
6546 In that case, we store the converted expression into a new
6547 VAR_DECL in a new scope.
6549 However, we want to be careful not to create temporaries when
6550 they are not required. For example, given:
6553 struct D : public B {};
6557 there is no need to copy the return value from "f"; we can just
6558 extend its lifetime. Similarly, given:
6561 struct T { operator S(); };
6565 we can extend the lifetime of the return value of the conversion
6567 gcc_assert (conv->kind == ck_ref_bind);
6571 tree base_conv_type;
6573 /* Skip over the REF_BIND. */
6574 conv = conv->u.next;
6575 /* If the next conversion is a BASE_CONV, skip that too -- but
6576 remember that the conversion was required. */
6577 if (conv->kind == ck_base)
6579 if (conv->check_copy_constructor_p)
6580 check_constructor_callable (TREE_TYPE (expr), expr);
6581 base_conv_type = conv->type;
6582 conv = conv->u.next;
6585 base_conv_type = NULL_TREE;
6586 /* Perform the remainder of the conversion. */
6587 expr = convert_like_real (conv, expr,
6588 /*fn=*/NULL_TREE, /*argnum=*/0,
6590 /*issue_conversion_warnings=*/true,
6591 /*c_cast_p=*/false);
6592 if (error_operand_p (expr))
6593 expr = error_mark_node;
6596 if (!real_lvalue_p (expr))
6601 /* Create the temporary variable. */
6602 type = TREE_TYPE (expr);
6603 var = make_temporary_var_for_ref_to_temp (decl, type);
6604 layout_decl (var, 0);
6605 /* If the rvalue is the result of a function call it will be
6606 a TARGET_EXPR. If it is some other construct (such as a
6607 member access expression where the underlying object is
6608 itself the result of a function call), turn it into a
6609 TARGET_EXPR here. It is important that EXPR be a
6610 TARGET_EXPR below since otherwise the INIT_EXPR will
6611 attempt to make a bitwise copy of EXPR to initialize
6613 if (TREE_CODE (expr) != TARGET_EXPR)
6614 expr = get_target_expr (expr);
6615 /* Create the INIT_EXPR that will initialize the temporary
6617 init = build2 (INIT_EXPR, type, var, expr);
6618 if (at_function_scope_p ())
6620 add_decl_expr (var);
6621 *cleanup = cxx_maybe_build_cleanup (var);
6623 /* We must be careful to destroy the temporary only
6624 after its initialization has taken place. If the
6625 initialization throws an exception, then the
6626 destructor should not be run. We cannot simply
6627 transform INIT into something like:
6629 (INIT, ({ CLEANUP_STMT; }))
6631 because emit_local_var always treats the
6632 initializer as a full-expression. Thus, the
6633 destructor would run too early; it would run at the
6634 end of initializing the reference variable, rather
6635 than at the end of the block enclosing the
6638 The solution is to pass back a cleanup expression
6639 which the caller is responsible for attaching to
6640 the statement tree. */
6644 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6645 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6646 static_aggregates = tree_cons (NULL_TREE, var,
6649 /* Use its address to initialize the reference variable. */
6650 expr = build_address (var);
6652 expr = convert_to_base (expr,
6653 build_pointer_type (base_conv_type),
6654 /*check_access=*/true,
6656 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6659 /* Take the address of EXPR. */
6660 expr = build_unary_op (ADDR_EXPR, expr, 0);
6661 /* If a BASE_CONV was required, perform it now. */
6663 expr = (perform_implicit_conversion
6664 (build_pointer_type (base_conv_type), expr));
6665 expr = build_nop (type, expr);
6669 /* Perform the conversion. */
6670 expr = convert_like (conv, expr);
6672 /* Free all the conversions we allocated. */
6673 obstack_free (&conversion_obstack, p);
6678 #include "gt-cp-call.h"