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 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 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
286 sorry ("unable to call pointer to member function here");
287 return error_mark_node;
290 fntype = TREE_TYPE (TREE_TYPE (function));
291 result_type = TREE_TYPE (fntype);
293 if (TREE_CODE (function) == ADDR_EXPR
294 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
295 decl = TREE_OPERAND (function, 0);
299 /* We check both the decl and the type; a function may be known not to
300 throw without being declared throw(). */
301 nothrow = ((decl && TREE_NOTHROW (decl))
302 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
304 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
305 current_function_returns_abnormally = 1;
307 if (decl && TREE_DEPRECATED (decl))
308 warn_deprecated_use (decl);
309 require_complete_eh_spec_types (fntype, decl);
311 if (decl && DECL_CONSTRUCTOR_P (decl))
314 if (decl && ! TREE_USED (decl))
316 /* We invoke build_call directly for several library functions.
317 These may have been declared normally if we're building libgcc,
318 so we can't just check DECL_ARTIFICIAL. */
319 gcc_assert (DECL_ARTIFICIAL (decl)
320 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
325 /* Don't pass empty class objects by value. This is useful
326 for tags in STL, which are used to control overload resolution.
327 We don't need to handle other cases of copying empty classes. */
328 if (! decl || ! DECL_BUILT_IN (decl))
329 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
330 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
331 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
333 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
334 TREE_VALUE (tmp) = build2 (COMPOUND_EXPR, TREE_TYPE (t),
335 TREE_VALUE (tmp), t);
338 function = build3 (CALL_EXPR, result_type, function, parms, NULL_TREE);
339 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
340 TREE_NOTHROW (function) = nothrow;
345 /* Build something of the form ptr->method (args)
346 or object.method (args). This can also build
347 calls to constructors, and find friends.
349 Member functions always take their class variable
352 INSTANCE is a class instance.
354 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
356 PARMS help to figure out what that NAME really refers to.
358 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
359 down to the real instance type to use for access checking. We need this
360 information to get protected accesses correct.
362 FLAGS is the logical disjunction of zero or more LOOKUP_
363 flags. See cp-tree.h for more info.
365 If this is all OK, calls build_function_call with the resolved
368 This function must also handle being called to perform
369 initialization, promotion/coercion of arguments, and
370 instantiation of default parameters.
372 Note that NAME may refer to an instance variable name. If
373 `operator()()' is defined for the type of that field, then we return
376 /* New overloading code. */
378 typedef struct z_candidate z_candidate;
380 typedef struct candidate_warning candidate_warning;
381 struct candidate_warning {
383 candidate_warning *next;
387 /* The FUNCTION_DECL that will be called if this candidate is
388 selected by overload resolution. */
390 /* The arguments to use when calling this function. */
392 /* The implicit conversion sequences for each of the arguments to
395 /* The number of implicit conversion sequences. */
397 /* If FN is a user-defined conversion, the standard conversion
398 sequence from the type returned by FN to the desired destination
400 conversion *second_conv;
402 /* If FN is a member function, the binfo indicating the path used to
403 qualify the name of FN at the call site. This path is used to
404 determine whether or not FN is accessible if it is selected by
405 overload resolution. The DECL_CONTEXT of FN will always be a
406 (possibly improper) base of this binfo. */
408 /* If FN is a non-static member function, the binfo indicating the
409 subobject to which the `this' pointer should be converted if FN
410 is selected by overload resolution. The type pointed to the by
411 the `this' pointer must correspond to the most derived class
412 indicated by the CONVERSION_PATH. */
413 tree conversion_path;
415 candidate_warning *warnings;
419 /* Returns true iff T is a null pointer constant in the sense of
423 null_ptr_cst_p (tree t)
427 A null pointer constant is an integral constant expression
428 (_expr.const_) rvalue of integer type that evaluates to zero. */
429 t = integral_constant_value (t);
431 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
436 /* Returns nonzero if PARMLIST consists of only default parms and/or
440 sufficient_parms_p (tree parmlist)
442 for (; parmlist && parmlist != void_list_node;
443 parmlist = TREE_CHAIN (parmlist))
444 if (!TREE_PURPOSE (parmlist))
449 /* Allocate N bytes of memory from the conversion obstack. The memory
450 is zeroed before being returned. */
453 conversion_obstack_alloc (size_t n)
456 if (!conversion_obstack_initialized)
458 gcc_obstack_init (&conversion_obstack);
459 conversion_obstack_initialized = true;
461 p = obstack_alloc (&conversion_obstack, n);
466 /* Dynamically allocate a conversion. */
469 alloc_conversion (conversion_kind kind)
472 c = conversion_obstack_alloc (sizeof (conversion));
477 #ifdef ENABLE_CHECKING
479 /* Make sure that all memory on the conversion obstack has been
483 validate_conversion_obstack (void)
485 if (conversion_obstack_initialized)
486 gcc_assert ((obstack_next_free (&conversion_obstack)
487 == obstack_base (&conversion_obstack)));
490 #endif /* ENABLE_CHECKING */
492 /* Dynamically allocate an array of N conversions. */
495 alloc_conversions (size_t n)
497 return conversion_obstack_alloc (n * sizeof (conversion *));
501 build_conv (conversion_kind code, tree type, conversion *from)
504 conversion_rank rank = CONVERSION_RANK (from);
506 /* We can't use buildl1 here because CODE could be USER_CONV, which
507 takes two arguments. In that case, the caller is responsible for
508 filling in the second argument. */
509 t = alloc_conversion (code);
532 t->user_conv_p = (code == ck_user || from->user_conv_p);
533 t->bad_p = from->bad_p;
538 /* Build a representation of the identity conversion from EXPR to
539 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
542 build_identity_conv (tree type, tree expr)
546 c = alloc_conversion (ck_identity);
553 /* Converting from EXPR to TYPE was ambiguous in the sense that there
554 were multiple user-defined conversions to accomplish the job.
555 Build a conversion that indicates that ambiguity. */
558 build_ambiguous_conv (tree type, tree expr)
562 c = alloc_conversion (ck_ambig);
570 strip_top_quals (tree t)
572 if (TREE_CODE (t) == ARRAY_TYPE)
574 return cp_build_qualified_type (t, 0);
577 /* Returns the standard conversion path (see [conv]) from type FROM to type
578 TO, if any. For proper handling of null pointer constants, you must
579 also pass the expression EXPR to convert from. If C_CAST_P is true,
580 this conversion is coming from a C-style cast. */
583 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
586 enum tree_code fcode, tcode;
588 bool fromref = false;
590 to = non_reference (to);
591 if (TREE_CODE (from) == REFERENCE_TYPE)
594 from = TREE_TYPE (from);
596 to = strip_top_quals (to);
597 from = strip_top_quals (from);
599 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
600 && expr && type_unknown_p (expr))
602 expr = instantiate_type (to, expr, tf_conv);
603 if (expr == error_mark_node)
605 from = TREE_TYPE (expr);
608 fcode = TREE_CODE (from);
609 tcode = TREE_CODE (to);
611 conv = build_identity_conv (from, expr);
612 if (fcode == FUNCTION_TYPE)
614 from = build_pointer_type (from);
615 fcode = TREE_CODE (from);
616 conv = build_conv (ck_lvalue, from, conv);
618 else if (fcode == ARRAY_TYPE)
620 from = build_pointer_type (TREE_TYPE (from));
621 fcode = TREE_CODE (from);
622 conv = build_conv (ck_lvalue, from, conv);
624 else if (fromref || (expr && lvalue_p (expr)))
625 conv = build_conv (ck_rvalue, from, conv);
627 /* Allow conversion between `__complex__' data types. */
628 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
630 /* The standard conversion sequence to convert FROM to TO is
631 the standard conversion sequence to perform componentwise
633 conversion *part_conv = standard_conversion
634 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
638 conv = build_conv (part_conv->kind, to, conv);
639 conv->rank = part_conv->rank;
647 if (same_type_p (from, to))
650 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
651 && expr && null_ptr_cst_p (expr))
652 conv = build_conv (ck_std, to, conv);
653 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
654 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
656 /* For backwards brain damage compatibility, allow interconversion of
657 pointers and integers with a pedwarn. */
658 conv = build_conv (ck_std, to, conv);
661 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
663 /* For backwards brain damage compatibility, allow interconversion of
664 enums and integers with a pedwarn. */
665 conv = build_conv (ck_std, to, conv);
668 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
669 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
674 if (tcode == POINTER_TYPE
675 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
678 else if (VOID_TYPE_P (TREE_TYPE (to))
679 && !TYPE_PTRMEM_P (from)
680 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
682 from = build_pointer_type
683 (cp_build_qualified_type (void_type_node,
684 cp_type_quals (TREE_TYPE (from))));
685 conv = build_conv (ck_ptr, from, conv);
687 else if (TYPE_PTRMEM_P (from))
689 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
690 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
692 if (DERIVED_FROM_P (fbase, tbase)
693 && (same_type_ignoring_top_level_qualifiers_p
694 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
695 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
697 from = build_ptrmem_type (tbase,
698 TYPE_PTRMEM_POINTED_TO_TYPE (from));
699 conv = build_conv (ck_pmem, from, conv);
701 else if (!same_type_p (fbase, tbase))
704 else if (IS_AGGR_TYPE (TREE_TYPE (from))
705 && IS_AGGR_TYPE (TREE_TYPE (to))
708 An rvalue of type "pointer to cv D," where D is a
709 class type, can be converted to an rvalue of type
710 "pointer to cv B," where B is a base class (clause
711 _class.derived_) of D. If B is an inaccessible
712 (clause _class.access_) or ambiguous
713 (_class.member.lookup_) base class of D, a program
714 that necessitates this conversion is ill-formed.
715 Therefore, we use DERIVED_FROM_P, and do not check
716 access or uniqueness. */
717 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from))
718 /* If FROM is not yet complete, then we must be parsing
719 the body of a class. We know what's derived from
720 what, but we can't actually perform a
721 derived-to-base conversion. For example, in:
723 struct D : public B {
724 static const int i = sizeof((B*)(D*)0);
727 the D*-to-B* conversion is a reinterpret_cast, not a
729 && COMPLETE_TYPE_P (TREE_TYPE (from)))
732 cp_build_qualified_type (TREE_TYPE (to),
733 cp_type_quals (TREE_TYPE (from)));
734 from = build_pointer_type (from);
735 conv = build_conv (ck_ptr, from, conv);
739 if (tcode == POINTER_TYPE)
741 to_pointee = TREE_TYPE (to);
742 from_pointee = TREE_TYPE (from);
746 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
747 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
750 if (same_type_p (from, to))
752 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
753 /* In a C-style cast, we ignore CV-qualification because we
754 are allowed to perform a static_cast followed by a
756 conv = build_conv (ck_qual, to, conv);
757 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
758 conv = build_conv (ck_qual, to, conv);
759 else if (expr && string_conv_p (to, expr, 0))
760 /* converting from string constant to char *. */
761 conv = build_conv (ck_qual, to, conv);
762 else if (ptr_reasonably_similar (to_pointee, from_pointee))
764 conv = build_conv (ck_ptr, to, conv);
772 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
774 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
775 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
776 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
777 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
779 if (!DERIVED_FROM_P (fbase, tbase)
780 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
781 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
782 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
783 || cp_type_quals (fbase) != cp_type_quals (tbase))
786 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
787 from = build_method_type_directly (from,
789 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
790 from = build_ptrmemfunc_type (build_pointer_type (from));
791 conv = build_conv (ck_pmem, from, conv);
794 else if (tcode == BOOLEAN_TYPE)
798 An rvalue of arithmetic, enumeration, pointer, or pointer to
799 member type can be converted to an rvalue of type bool. */
800 if (ARITHMETIC_TYPE_P (from)
801 || fcode == ENUMERAL_TYPE
802 || fcode == POINTER_TYPE
803 || TYPE_PTR_TO_MEMBER_P (from))
805 conv = build_conv (ck_std, to, conv);
806 if (fcode == POINTER_TYPE
807 || TYPE_PTRMEM_P (from)
808 || (TYPE_PTRMEMFUNC_P (from)
809 && conv->rank < cr_pbool))
810 conv->rank = cr_pbool;
816 /* We don't check for ENUMERAL_TYPE here because there are no standard
817 conversions to enum type. */
818 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
819 || tcode == REAL_TYPE)
821 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
823 conv = build_conv (ck_std, to, conv);
825 /* Give this a better rank if it's a promotion. */
826 if (same_type_p (to, type_promotes_to (from))
827 && conv->u.next->rank <= cr_promotion)
828 conv->rank = cr_promotion;
830 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
831 && vector_types_convertible_p (from, to))
832 return build_conv (ck_std, to, conv);
833 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
834 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
835 && is_properly_derived_from (from, to))
837 if (conv->kind == ck_rvalue)
839 conv = build_conv (ck_base, to, conv);
840 /* The derived-to-base conversion indicates the initialization
841 of a parameter with base type from an object of a derived
842 type. A temporary object is created to hold the result of
844 conv->need_temporary_p = true;
852 /* Returns nonzero if T1 is reference-related to T2. */
855 reference_related_p (tree t1, tree t2)
857 t1 = TYPE_MAIN_VARIANT (t1);
858 t2 = TYPE_MAIN_VARIANT (t2);
862 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
863 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
865 return (same_type_p (t1, t2)
866 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
867 && DERIVED_FROM_P (t1, t2)));
870 /* Returns nonzero if T1 is reference-compatible with T2. */
873 reference_compatible_p (tree t1, tree t2)
877 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
878 reference-related to T2 and cv1 is the same cv-qualification as,
879 or greater cv-qualification than, cv2. */
880 return (reference_related_p (t1, t2)
881 && at_least_as_qualified_p (t1, t2));
884 /* Determine whether or not the EXPR (of class type S) can be
885 converted to T as in [over.match.ref]. */
888 convert_class_to_reference (tree t, tree s, tree expr)
894 struct z_candidate *candidates;
895 struct z_candidate *cand;
898 conversions = lookup_conversions (s);
904 Assuming that "cv1 T" is the underlying type of the reference
905 being initialized, and "cv S" is the type of the initializer
906 expression, with S a class type, the candidate functions are
909 --The conversion functions of S and its base classes are
910 considered. Those that are not hidden within S and yield type
911 "reference to cv2 T2", where "cv1 T" is reference-compatible
912 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
914 The argument list has one argument, which is the initializer
919 /* Conceptually, we should take the address of EXPR and put it in
920 the argument list. Unfortunately, however, that can result in
921 error messages, which we should not issue now because we are just
922 trying to find a conversion operator. Therefore, we use NULL,
923 cast to the appropriate type. */
924 arglist = build_int_cst (build_pointer_type (s), 0);
925 arglist = build_tree_list (NULL_TREE, arglist);
927 reference_type = build_reference_type (t);
931 tree fns = TREE_VALUE (conversions);
933 for (; fns; fns = OVL_NEXT (fns))
935 tree f = OVL_CURRENT (fns);
936 tree t2 = TREE_TYPE (TREE_TYPE (f));
940 /* If this is a template function, try to get an exact
942 if (TREE_CODE (f) == TEMPLATE_DECL)
944 cand = add_template_candidate (&candidates,
950 TREE_PURPOSE (conversions),
956 /* Now, see if the conversion function really returns
957 an lvalue of the appropriate type. From the
958 point of view of unification, simply returning an
959 rvalue of the right type is good enough. */
961 t2 = TREE_TYPE (TREE_TYPE (f));
962 if (TREE_CODE (t2) != REFERENCE_TYPE
963 || !reference_compatible_p (t, TREE_TYPE (t2)))
965 candidates = candidates->next;
970 else if (TREE_CODE (t2) == REFERENCE_TYPE
971 && reference_compatible_p (t, TREE_TYPE (t2)))
972 cand = add_function_candidate (&candidates, f, s, arglist,
974 TREE_PURPOSE (conversions),
979 conversion *identity_conv;
980 /* Build a standard conversion sequence indicating the
981 binding from the reference type returned by the
982 function to the desired REFERENCE_TYPE. */
984 = build_identity_conv (TREE_TYPE (TREE_TYPE
985 (TREE_TYPE (cand->fn))),
988 = (direct_reference_binding
989 (reference_type, identity_conv));
990 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
993 conversions = TREE_CHAIN (conversions);
996 candidates = splice_viable (candidates, pedantic, &any_viable_p);
997 /* If none of the conversion functions worked out, let our caller
1002 cand = tourney (candidates);
1006 /* Now that we know that this is the function we're going to use fix
1007 the dummy first argument. */
1008 cand->args = tree_cons (NULL_TREE,
1010 TREE_CHAIN (cand->args));
1012 /* Build a user-defined conversion sequence representing the
1014 conv = build_conv (ck_user,
1015 TREE_TYPE (TREE_TYPE (cand->fn)),
1016 build_identity_conv (TREE_TYPE (expr), expr));
1019 /* Merge it with the standard conversion sequence from the
1020 conversion function's return type to the desired type. */
1021 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1023 if (cand->viable == -1)
1026 return cand->second_conv;
1029 /* A reference of the indicated TYPE is being bound directly to the
1030 expression represented by the implicit conversion sequence CONV.
1031 Return a conversion sequence for this binding. */
1034 direct_reference_binding (tree type, conversion *conv)
1038 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1039 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1041 t = TREE_TYPE (type);
1045 When a parameter of reference type binds directly
1046 (_dcl.init.ref_) to an argument expression, the implicit
1047 conversion sequence is the identity conversion, unless the
1048 argument expression has a type that is a derived class of the
1049 parameter type, in which case the implicit conversion sequence is
1050 a derived-to-base Conversion.
1052 If the parameter binds directly to the result of applying a
1053 conversion function to the argument expression, the implicit
1054 conversion sequence is a user-defined conversion sequence
1055 (_over.ics.user_), with the second standard conversion sequence
1056 either an identity conversion or, if the conversion function
1057 returns an entity of a type that is a derived class of the
1058 parameter type, a derived-to-base conversion. */
1059 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1061 /* Represent the derived-to-base conversion. */
1062 conv = build_conv (ck_base, t, conv);
1063 /* We will actually be binding to the base-class subobject in
1064 the derived class, so we mark this conversion appropriately.
1065 That way, convert_like knows not to generate a temporary. */
1066 conv->need_temporary_p = false;
1068 return build_conv (ck_ref_bind, type, conv);
1071 /* Returns the conversion path from type FROM to reference type TO for
1072 purposes of reference binding. For lvalue binding, either pass a
1073 reference type to FROM or an lvalue expression to EXPR. If the
1074 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1075 the conversion returned. */
1078 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1080 conversion *conv = NULL;
1081 tree to = TREE_TYPE (rto);
1085 cp_lvalue_kind lvalue_p = clk_none;
1087 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1089 expr = instantiate_type (to, expr, tf_none);
1090 if (expr == error_mark_node)
1092 from = TREE_TYPE (expr);
1095 if (TREE_CODE (from) == REFERENCE_TYPE)
1097 /* Anything with reference type is an lvalue. */
1098 lvalue_p = clk_ordinary;
1099 from = TREE_TYPE (from);
1102 lvalue_p = real_lvalue_p (expr);
1104 /* Figure out whether or not the types are reference-related and
1105 reference compatible. We have do do this after stripping
1106 references from FROM. */
1107 related_p = reference_related_p (to, from);
1108 compatible_p = reference_compatible_p (to, from);
1110 if (lvalue_p && compatible_p)
1114 If the initializer expression
1116 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1117 is reference-compatible with "cv2 T2,"
1119 the reference is bound directly to the initializer expression
1121 conv = build_identity_conv (from, expr);
1122 conv = direct_reference_binding (rto, conv);
1123 if ((lvalue_p & clk_bitfield) != 0
1124 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1125 /* For the purposes of overload resolution, we ignore the fact
1126 this expression is a bitfield or packed field. (In particular,
1127 [over.ics.ref] says specifically that a function with a
1128 non-const reference parameter is viable even if the
1129 argument is a bitfield.)
1131 However, when we actually call the function we must create
1132 a temporary to which to bind the reference. If the
1133 reference is volatile, or isn't const, then we cannot make
1134 a temporary, so we just issue an error when the conversion
1136 conv->need_temporary_p = true;
1140 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1144 If the initializer expression
1146 -- has a class type (i.e., T2 is a class type) can be
1147 implicitly converted to an lvalue of type "cv3 T3," where
1148 "cv1 T1" is reference-compatible with "cv3 T3". (this
1149 conversion is selected by enumerating the applicable
1150 conversion functions (_over.match.ref_) and choosing the
1151 best one through overload resolution. (_over.match_).
1153 the reference is bound to the lvalue result of the conversion
1154 in the second case. */
1155 conv = convert_class_to_reference (to, from, expr);
1160 /* From this point on, we conceptually need temporaries, even if we
1161 elide them. Only the cases above are "direct bindings". */
1162 if (flags & LOOKUP_NO_TEMP_BIND)
1167 When a parameter of reference type is not bound directly to an
1168 argument expression, the conversion sequence is the one required
1169 to convert the argument expression to the underlying type of the
1170 reference according to _over.best.ics_. Conceptually, this
1171 conversion sequence corresponds to copy-initializing a temporary
1172 of the underlying type with the argument expression. Any
1173 difference in top-level cv-qualification is subsumed by the
1174 initialization itself and does not constitute a conversion. */
1178 Otherwise, the reference shall be to a non-volatile const type. */
1179 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1184 If the initializer expression is an rvalue, with T2 a class type,
1185 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1186 is bound in one of the following ways:
1188 -- The reference is bound to the object represented by the rvalue
1189 or to a sub-object within that object.
1193 We use the first alternative. The implicit conversion sequence
1194 is supposed to be same as we would obtain by generating a
1195 temporary. Fortunately, if the types are reference compatible,
1196 then this is either an identity conversion or the derived-to-base
1197 conversion, just as for direct binding. */
1198 if (CLASS_TYPE_P (from) && compatible_p)
1200 conv = build_identity_conv (from, expr);
1201 conv = direct_reference_binding (rto, conv);
1202 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1203 conv->u.next->check_copy_constructor_p = true;
1209 Otherwise, a temporary of type "cv1 T1" is created and
1210 initialized from the initializer expression using the rules for a
1211 non-reference copy initialization. If T1 is reference-related to
1212 T2, cv1 must be the same cv-qualification as, or greater
1213 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1214 if (related_p && !at_least_as_qualified_p (to, from))
1217 conv = implicit_conversion (to, from, expr, /*c_cast_p=*/false,
1222 conv = build_conv (ck_ref_bind, rto, conv);
1223 /* This reference binding, unlike those above, requires the
1224 creation of a temporary. */
1225 conv->need_temporary_p = true;
1230 /* Returns the implicit conversion sequence (see [over.ics]) from type
1231 FROM to type TO. The optional expression EXPR may affect the
1232 conversion. FLAGS are the usual overloading flags. Only
1233 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1234 conversion is coming from a C-style cast. */
1237 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1242 if (from == error_mark_node || to == error_mark_node
1243 || expr == error_mark_node)
1246 if (TREE_CODE (to) == REFERENCE_TYPE)
1247 conv = reference_binding (to, from, expr, flags);
1249 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1254 if (expr != NULL_TREE
1255 && (IS_AGGR_TYPE (from)
1256 || IS_AGGR_TYPE (to))
1257 && (flags & LOOKUP_NO_CONVERSION) == 0)
1259 struct z_candidate *cand;
1261 cand = build_user_type_conversion_1
1262 (to, expr, LOOKUP_ONLYCONVERTING);
1264 conv = cand->second_conv;
1266 /* We used to try to bind a reference to a temporary here, but that
1267 is now handled by the recursive call to this function at the end
1268 of reference_binding. */
1275 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1278 static struct z_candidate *
1279 add_candidate (struct z_candidate **candidates,
1281 size_t num_convs, conversion **convs,
1282 tree access_path, tree conversion_path,
1285 struct z_candidate *cand
1286 = conversion_obstack_alloc (sizeof (struct z_candidate));
1290 cand->convs = convs;
1291 cand->num_convs = num_convs;
1292 cand->access_path = access_path;
1293 cand->conversion_path = conversion_path;
1294 cand->viable = viable;
1295 cand->next = *candidates;
1301 /* Create an overload candidate for the function or method FN called with
1302 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1303 to implicit_conversion.
1305 CTYPE, if non-NULL, is the type we want to pretend this function
1306 comes from for purposes of overload resolution. */
1308 static struct z_candidate *
1309 add_function_candidate (struct z_candidate **candidates,
1310 tree fn, tree ctype, tree arglist,
1311 tree access_path, tree conversion_path,
1314 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1317 tree parmnode, argnode;
1321 /* At this point we should not see any functions which haven't been
1322 explicitly declared, except for friend functions which will have
1323 been found using argument dependent lookup. */
1324 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1326 /* The `this', `in_chrg' and VTT arguments to constructors are not
1327 considered in overload resolution. */
1328 if (DECL_CONSTRUCTOR_P (fn))
1330 parmlist = skip_artificial_parms_for (fn, parmlist);
1331 orig_arglist = arglist;
1332 arglist = skip_artificial_parms_for (fn, arglist);
1335 orig_arglist = arglist;
1337 len = list_length (arglist);
1338 convs = alloc_conversions (len);
1340 /* 13.3.2 - Viable functions [over.match.viable]
1341 First, to be a viable function, a candidate function shall have enough
1342 parameters to agree in number with the arguments in the list.
1344 We need to check this first; otherwise, checking the ICSes might cause
1345 us to produce an ill-formed template instantiation. */
1347 parmnode = parmlist;
1348 for (i = 0; i < len; ++i)
1350 if (parmnode == NULL_TREE || parmnode == void_list_node)
1352 parmnode = TREE_CHAIN (parmnode);
1355 if (i < len && parmnode)
1358 /* Make sure there are default args for the rest of the parms. */
1359 else if (!sufficient_parms_p (parmnode))
1365 /* Second, for F to be a viable function, there shall exist for each
1366 argument an implicit conversion sequence that converts that argument
1367 to the corresponding parameter of F. */
1369 parmnode = parmlist;
1372 for (i = 0; i < len; ++i)
1374 tree arg = TREE_VALUE (argnode);
1375 tree argtype = lvalue_type (arg);
1379 if (parmnode == void_list_node)
1382 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1383 && ! DECL_CONSTRUCTOR_P (fn));
1387 tree parmtype = TREE_VALUE (parmnode);
1389 /* The type of the implicit object parameter ('this') for
1390 overload resolution is not always the same as for the
1391 function itself; conversion functions are considered to
1392 be members of the class being converted, and functions
1393 introduced by a using-declaration are considered to be
1394 members of the class that uses them.
1396 Since build_over_call ignores the ICS for the `this'
1397 parameter, we can just change the parm type. */
1398 if (ctype && is_this)
1401 = build_qualified_type (ctype,
1402 TYPE_QUALS (TREE_TYPE (parmtype)));
1403 parmtype = build_pointer_type (parmtype);
1406 t = implicit_conversion (parmtype, argtype, arg,
1407 /*c_cast_p=*/false, flags);
1411 t = build_identity_conv (argtype, arg);
1412 t->ellipsis_p = true;
1429 parmnode = TREE_CHAIN (parmnode);
1430 argnode = TREE_CHAIN (argnode);
1434 return add_candidate (candidates, fn, orig_arglist, len, convs,
1435 access_path, conversion_path, viable);
1438 /* Create an overload candidate for the conversion function FN which will
1439 be invoked for expression OBJ, producing a pointer-to-function which
1440 will in turn be called with the argument list ARGLIST, and add it to
1441 CANDIDATES. FLAGS is passed on to implicit_conversion.
1443 Actually, we don't really care about FN; we care about the type it
1444 converts to. There may be multiple conversion functions that will
1445 convert to that type, and we rely on build_user_type_conversion_1 to
1446 choose the best one; so when we create our candidate, we record the type
1447 instead of the function. */
1449 static struct z_candidate *
1450 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1451 tree arglist, tree access_path, tree conversion_path)
1453 tree totype = TREE_TYPE (TREE_TYPE (fn));
1454 int i, len, viable, flags;
1455 tree parmlist, parmnode, argnode;
1458 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1459 parmlist = TREE_TYPE (parmlist);
1460 parmlist = TYPE_ARG_TYPES (parmlist);
1462 len = list_length (arglist) + 1;
1463 convs = alloc_conversions (len);
1464 parmnode = parmlist;
1467 flags = LOOKUP_NORMAL;
1469 /* Don't bother looking up the same type twice. */
1470 if (*candidates && (*candidates)->fn == totype)
1473 for (i = 0; i < len; ++i)
1475 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1476 tree argtype = lvalue_type (arg);
1480 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1482 else if (parmnode == void_list_node)
1485 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1486 /*c_cast_p=*/false, flags);
1489 t = build_identity_conv (argtype, arg);
1490 t->ellipsis_p = true;
1504 parmnode = TREE_CHAIN (parmnode);
1505 argnode = TREE_CHAIN (argnode);
1511 if (!sufficient_parms_p (parmnode))
1514 return add_candidate (candidates, totype, arglist, len, convs,
1515 access_path, conversion_path, viable);
1519 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1520 tree type1, tree type2, tree *args, tree *argtypes,
1532 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1533 convs = alloc_conversions (num_convs);
1535 for (i = 0; i < 2; ++i)
1540 t = implicit_conversion (types[i], argtypes[i], args[i],
1541 /*c_cast_p=*/false, flags);
1545 /* We need something for printing the candidate. */
1546 t = build_identity_conv (types[i], NULL_TREE);
1553 /* For COND_EXPR we rearranged the arguments; undo that now. */
1556 convs[2] = convs[1];
1557 convs[1] = convs[0];
1558 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1559 /*c_cast_p=*/false, flags);
1566 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1568 /*access_path=*/NULL_TREE,
1569 /*conversion_path=*/NULL_TREE,
1574 is_complete (tree t)
1576 return COMPLETE_TYPE_P (complete_type (t));
1579 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1582 promoted_arithmetic_type_p (tree type)
1586 In this section, the term promoted integral type is used to refer
1587 to those integral types which are preserved by integral promotion
1588 (including e.g. int and long but excluding e.g. char).
1589 Similarly, the term promoted arithmetic type refers to promoted
1590 integral types plus floating types. */
1591 return ((INTEGRAL_TYPE_P (type)
1592 && same_type_p (type_promotes_to (type), type))
1593 || TREE_CODE (type) == REAL_TYPE);
1596 /* Create any builtin operator overload candidates for the operator in
1597 question given the converted operand types TYPE1 and TYPE2. The other
1598 args are passed through from add_builtin_candidates to
1599 build_builtin_candidate.
1601 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1602 If CODE is requires candidates operands of the same type of the kind
1603 of which TYPE1 and TYPE2 are, we add both candidates
1604 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1607 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1608 enum tree_code code2, tree fnname, tree type1,
1609 tree type2, tree *args, tree *argtypes, int flags)
1613 case POSTINCREMENT_EXPR:
1614 case POSTDECREMENT_EXPR:
1615 args[1] = integer_zero_node;
1616 type2 = integer_type_node;
1625 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1626 and VQ is either volatile or empty, there exist candidate operator
1627 functions of the form
1628 VQ T& operator++(VQ T&);
1629 T operator++(VQ T&, int);
1630 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1631 type other than bool, and VQ is either volatile or empty, there exist
1632 candidate operator functions of the form
1633 VQ T& operator--(VQ T&);
1634 T operator--(VQ T&, int);
1635 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1636 complete object type, and VQ is either volatile or empty, there exist
1637 candidate operator functions of the form
1638 T*VQ& operator++(T*VQ&);
1639 T*VQ& operator--(T*VQ&);
1640 T* operator++(T*VQ&, int);
1641 T* operator--(T*VQ&, int); */
1643 case POSTDECREMENT_EXPR:
1644 case PREDECREMENT_EXPR:
1645 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1647 case POSTINCREMENT_EXPR:
1648 case PREINCREMENT_EXPR:
1649 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1651 type1 = build_reference_type (type1);
1656 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1657 exist candidate operator functions of the form
1661 8 For every function type T, there exist candidate operator functions of
1663 T& operator*(T*); */
1666 if (TREE_CODE (type1) == POINTER_TYPE
1667 && (TYPE_PTROB_P (type1)
1668 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1672 /* 9 For every type T, there exist candidate operator functions of the form
1675 10For every promoted arithmetic type T, there exist candidate operator
1676 functions of the form
1680 case UNARY_PLUS_EXPR: /* unary + */
1681 if (TREE_CODE (type1) == POINTER_TYPE)
1684 if (ARITHMETIC_TYPE_P (type1))
1688 /* 11For every promoted integral type T, there exist candidate operator
1689 functions of the form
1693 if (INTEGRAL_TYPE_P (type1))
1697 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1698 is the same type as C2 or is a derived class of C2, T is a complete
1699 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1700 there exist candidate operator functions of the form
1701 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1702 where CV12 is the union of CV1 and CV2. */
1705 if (TREE_CODE (type1) == POINTER_TYPE
1706 && TYPE_PTR_TO_MEMBER_P (type2))
1708 tree c1 = TREE_TYPE (type1);
1709 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1711 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1712 && (TYPE_PTRMEMFUNC_P (type2)
1713 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1718 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1719 didate operator functions of the form
1724 bool operator<(L, R);
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 where LR is the result of the usual arithmetic conversions between
1733 14For every pair of types T and I, where T is a cv-qualified or cv-
1734 unqualified complete object type and I is a promoted integral type,
1735 there exist candidate operator functions of the form
1736 T* operator+(T*, I);
1737 T& operator[](T*, I);
1738 T* operator-(T*, I);
1739 T* operator+(I, T*);
1740 T& operator[](I, T*);
1742 15For every T, where T is a pointer to complete object type, there exist
1743 candidate operator functions of the form112)
1744 ptrdiff_t operator-(T, T);
1746 16For every pointer or enumeration type T, there exist candidate operator
1747 functions of the form
1748 bool operator<(T, T);
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);
1755 17For every pointer to member type T, there exist candidate operator
1756 functions of the form
1757 bool operator==(T, T);
1758 bool operator!=(T, T); */
1761 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1763 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1765 type2 = ptrdiff_type_node;
1769 case TRUNC_DIV_EXPR:
1770 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1776 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1777 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1779 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1784 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1796 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1798 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1800 if (TREE_CODE (type1) == ENUMERAL_TYPE
1801 && TREE_CODE (type2) == ENUMERAL_TYPE)
1803 if (TYPE_PTR_P (type1)
1804 && null_ptr_cst_p (args[1])
1805 && !uses_template_parms (type1))
1810 if (null_ptr_cst_p (args[0])
1811 && TYPE_PTR_P (type2)
1812 && !uses_template_parms (type2))
1820 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1823 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1825 type1 = ptrdiff_type_node;
1828 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1830 type2 = ptrdiff_type_node;
1835 /* 18For every pair of promoted integral types L and R, there exist candi-
1836 date operator functions of the form
1843 where LR is the result of the usual arithmetic conversions between
1846 case TRUNC_MOD_EXPR:
1852 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1856 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1857 type, VQ is either volatile or empty, and R is a promoted arithmetic
1858 type, there exist candidate operator functions of the form
1859 VQ L& operator=(VQ L&, R);
1860 VQ L& operator*=(VQ L&, R);
1861 VQ L& operator/=(VQ L&, R);
1862 VQ L& operator+=(VQ L&, R);
1863 VQ L& operator-=(VQ L&, R);
1865 20For every pair T, VQ), where T is any type and VQ is either volatile
1866 or empty, there exist candidate operator functions of the form
1867 T*VQ& operator=(T*VQ&, T*);
1869 21For every pair T, VQ), where T is a pointer to member type and VQ is
1870 either volatile or empty, there exist candidate operator functions of
1872 VQ T& operator=(VQ T&, T);
1874 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1875 unqualified complete object type, VQ is either volatile or empty, and
1876 I is a promoted integral type, there exist candidate operator func-
1878 T*VQ& operator+=(T*VQ&, I);
1879 T*VQ& operator-=(T*VQ&, I);
1881 23For every triple L, VQ, R), where L is an integral or enumeration
1882 type, VQ is either volatile or empty, and R is a promoted integral
1883 type, there exist candidate operator functions of the form
1885 VQ L& operator%=(VQ L&, R);
1886 VQ L& operator<<=(VQ L&, R);
1887 VQ L& operator>>=(VQ L&, R);
1888 VQ L& operator&=(VQ L&, R);
1889 VQ L& operator^=(VQ L&, R);
1890 VQ L& operator|=(VQ L&, R); */
1897 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1899 type2 = ptrdiff_type_node;
1903 case TRUNC_DIV_EXPR:
1904 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1908 case TRUNC_MOD_EXPR:
1914 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1919 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1921 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1922 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1923 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1924 || ((TYPE_PTRMEMFUNC_P (type1)
1925 || TREE_CODE (type1) == POINTER_TYPE)
1926 && null_ptr_cst_p (args[1])))
1936 type1 = build_reference_type (type1);
1942 For every pair of promoted arithmetic types L and R, there
1943 exist candidate operator functions of the form
1945 LR operator?(bool, L, R);
1947 where LR is the result of the usual arithmetic conversions
1948 between types L and R.
1950 For every type T, where T is a pointer or pointer-to-member
1951 type, there exist candidate operator functions of the form T
1952 operator?(bool, T, T); */
1954 if (promoted_arithmetic_type_p (type1)
1955 && promoted_arithmetic_type_p (type2))
1959 /* Otherwise, the types should be pointers. */
1960 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1961 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1964 /* We don't check that the two types are the same; the logic
1965 below will actually create two candidates; one in which both
1966 parameter types are TYPE1, and one in which both parameter
1974 /* If we're dealing with two pointer types or two enumeral types,
1975 we need candidates for both of them. */
1976 if (type2 && !same_type_p (type1, type2)
1977 && TREE_CODE (type1) == TREE_CODE (type2)
1978 && (TREE_CODE (type1) == REFERENCE_TYPE
1979 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1980 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1981 || TYPE_PTRMEMFUNC_P (type1)
1982 || IS_AGGR_TYPE (type1)
1983 || TREE_CODE (type1) == ENUMERAL_TYPE))
1985 build_builtin_candidate
1986 (candidates, fnname, type1, type1, args, argtypes, flags);
1987 build_builtin_candidate
1988 (candidates, fnname, type2, type2, args, argtypes, flags);
1992 build_builtin_candidate
1993 (candidates, fnname, type1, type2, args, argtypes, flags);
1997 type_decays_to (tree type)
1999 if (TREE_CODE (type) == ARRAY_TYPE)
2000 return build_pointer_type (TREE_TYPE (type));
2001 if (TREE_CODE (type) == FUNCTION_TYPE)
2002 return build_pointer_type (type);
2006 /* There are three conditions of builtin candidates:
2008 1) bool-taking candidates. These are the same regardless of the input.
2009 2) pointer-pair taking candidates. These are generated for each type
2010 one of the input types converts to.
2011 3) arithmetic candidates. According to the standard, we should generate
2012 all of these, but I'm trying not to...
2014 Here we generate a superset of the possible candidates for this particular
2015 case. That is a subset of the full set the standard defines, plus some
2016 other cases which the standard disallows. add_builtin_candidate will
2017 filter out the invalid set. */
2020 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2021 enum tree_code code2, tree fnname, tree *args,
2026 tree type, argtypes[3];
2027 /* TYPES[i] is the set of possible builtin-operator parameter types
2028 we will consider for the Ith argument. These are represented as
2029 a TREE_LIST; the TREE_VALUE of each node is the potential
2033 for (i = 0; i < 3; ++i)
2036 argtypes[i] = lvalue_type (args[i]);
2038 argtypes[i] = NULL_TREE;
2043 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2044 and VQ is either volatile or empty, there exist candidate operator
2045 functions of the form
2046 VQ T& operator++(VQ T&); */
2048 case POSTINCREMENT_EXPR:
2049 case PREINCREMENT_EXPR:
2050 case POSTDECREMENT_EXPR:
2051 case PREDECREMENT_EXPR:
2056 /* 24There also exist candidate operator functions of the form
2057 bool operator!(bool);
2058 bool operator&&(bool, bool);
2059 bool operator||(bool, bool); */
2061 case TRUTH_NOT_EXPR:
2062 build_builtin_candidate
2063 (candidates, fnname, boolean_type_node,
2064 NULL_TREE, args, argtypes, flags);
2067 case TRUTH_ORIF_EXPR:
2068 case TRUTH_ANDIF_EXPR:
2069 build_builtin_candidate
2070 (candidates, fnname, boolean_type_node,
2071 boolean_type_node, args, argtypes, flags);
2093 types[0] = types[1] = NULL_TREE;
2095 for (i = 0; i < 2; ++i)
2099 else if (IS_AGGR_TYPE (argtypes[i]))
2103 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2106 convs = lookup_conversions (argtypes[i]);
2108 if (code == COND_EXPR)
2110 if (real_lvalue_p (args[i]))
2111 types[i] = tree_cons
2112 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2114 types[i] = tree_cons
2115 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2121 for (; convs; convs = TREE_CHAIN (convs))
2123 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2126 && (TREE_CODE (type) != REFERENCE_TYPE
2127 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2130 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2131 types[i] = tree_cons (NULL_TREE, type, types[i]);
2133 type = non_reference (type);
2134 if (i != 0 || ! ref1)
2136 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2137 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2138 types[i] = tree_cons (NULL_TREE, type, types[i]);
2139 if (INTEGRAL_TYPE_P (type))
2140 type = type_promotes_to (type);
2143 if (! value_member (type, types[i]))
2144 types[i] = tree_cons (NULL_TREE, type, types[i]);
2149 if (code == COND_EXPR && real_lvalue_p (args[i]))
2150 types[i] = tree_cons
2151 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2152 type = non_reference (argtypes[i]);
2153 if (i != 0 || ! ref1)
2155 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2156 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2157 types[i] = tree_cons (NULL_TREE, type, types[i]);
2158 if (INTEGRAL_TYPE_P (type))
2159 type = type_promotes_to (type);
2161 types[i] = tree_cons (NULL_TREE, type, types[i]);
2165 /* Run through the possible parameter types of both arguments,
2166 creating candidates with those parameter types. */
2167 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2170 for (type = types[1]; type; type = TREE_CHAIN (type))
2171 add_builtin_candidate
2172 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2173 TREE_VALUE (type), args, argtypes, flags);
2175 add_builtin_candidate
2176 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2177 NULL_TREE, args, argtypes, flags);
2184 /* If TMPL can be successfully instantiated as indicated by
2185 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2187 TMPL is the template. EXPLICIT_TARGS are any explicit template
2188 arguments. ARGLIST is the arguments provided at the call-site.
2189 The RETURN_TYPE is the desired type for conversion operators. If
2190 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2191 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2192 add_conv_candidate. */
2194 static struct z_candidate*
2195 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2196 tree ctype, tree explicit_targs, tree arglist,
2197 tree return_type, tree access_path,
2198 tree conversion_path, int flags, tree obj,
2199 unification_kind_t strict)
2201 int ntparms = DECL_NTPARMS (tmpl);
2202 tree targs = make_tree_vec (ntparms);
2203 tree args_without_in_chrg = arglist;
2204 struct z_candidate *cand;
2208 /* We don't do deduction on the in-charge parameter, the VTT
2209 parameter or 'this'. */
2210 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2211 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2213 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2214 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2215 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2216 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2218 i = fn_type_unification (tmpl, explicit_targs, targs,
2219 args_without_in_chrg,
2220 return_type, strict, flags);
2225 fn = instantiate_template (tmpl, targs, tf_none);
2226 if (fn == error_mark_node)
2231 A member function template is never instantiated to perform the
2232 copy of a class object to an object of its class type.
2234 It's a little unclear what this means; the standard explicitly
2235 does allow a template to be used to copy a class. For example,
2240 template <class T> A(const T&);
2243 void g () { A a (f ()); }
2245 the member template will be used to make the copy. The section
2246 quoted above appears in the paragraph that forbids constructors
2247 whose only parameter is (a possibly cv-qualified variant of) the
2248 class type, and a logical interpretation is that the intent was
2249 to forbid the instantiation of member templates which would then
2251 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2253 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2254 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2259 if (obj != NULL_TREE)
2260 /* Aha, this is a conversion function. */
2261 cand = add_conv_candidate (candidates, fn, obj, access_path,
2262 conversion_path, arglist);
2264 cand = add_function_candidate (candidates, fn, ctype,
2265 arglist, access_path,
2266 conversion_path, flags);
2267 if (DECL_TI_TEMPLATE (fn) != tmpl)
2268 /* This situation can occur if a member template of a template
2269 class is specialized. Then, instantiate_template might return
2270 an instantiation of the specialization, in which case the
2271 DECL_TI_TEMPLATE field will point at the original
2272 specialization. For example:
2274 template <class T> struct S { template <class U> void f(U);
2275 template <> void f(int) {}; };
2279 Here, TMPL will be template <class U> S<double>::f(U).
2280 And, instantiate template will give us the specialization
2281 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2282 for this will point at template <class T> template <> S<T>::f(int),
2283 so that we can find the definition. For the purposes of
2284 overload resolution, however, we want the original TMPL. */
2285 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2287 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2293 static struct z_candidate *
2294 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2295 tree explicit_targs, tree arglist, tree return_type,
2296 tree access_path, tree conversion_path, int flags,
2297 unification_kind_t strict)
2300 add_template_candidate_real (candidates, tmpl, ctype,
2301 explicit_targs, arglist, return_type,
2302 access_path, conversion_path,
2303 flags, NULL_TREE, strict);
2307 static struct z_candidate *
2308 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2309 tree obj, tree arglist, tree return_type,
2310 tree access_path, tree conversion_path)
2313 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2314 arglist, return_type, access_path,
2315 conversion_path, 0, obj, DEDUCE_CONV);
2318 /* The CANDS are the set of candidates that were considered for
2319 overload resolution. Return the set of viable candidates. If none
2320 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2321 is true if a candidate should be considered viable only if it is
2324 static struct z_candidate*
2325 splice_viable (struct z_candidate *cands,
2329 struct z_candidate *viable;
2330 struct z_candidate **last_viable;
2331 struct z_candidate **cand;
2334 last_viable = &viable;
2335 *any_viable_p = false;
2340 struct z_candidate *c = *cand;
2341 if (strict_p ? c->viable == 1 : c->viable)
2346 last_viable = &c->next;
2347 *any_viable_p = true;
2353 return viable ? viable : cands;
2357 any_strictly_viable (struct z_candidate *cands)
2359 for (; cands; cands = cands->next)
2360 if (cands->viable == 1)
2365 /* OBJ is being used in an expression like "OBJ.f (...)". In other
2366 words, it is about to become the "this" pointer for a member
2367 function call. Take the address of the object. */
2370 build_this (tree obj)
2372 /* In a template, we are only concerned about the type of the
2373 expression, so we can take a shortcut. */
2374 if (processing_template_decl)
2375 return build_address (obj);
2377 return build_unary_op (ADDR_EXPR, obj, 0);
2380 /* Returns true iff functions are equivalent. Equivalent functions are
2381 not '==' only if one is a function-local extern function or if
2382 both are extern "C". */
2385 equal_functions (tree fn1, tree fn2)
2387 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2388 || DECL_EXTERN_C_FUNCTION_P (fn1))
2389 return decls_match (fn1, fn2);
2393 /* Print information about one overload candidate CANDIDATE. MSGSTR
2394 is the text to print before the candidate itself.
2396 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2397 to have been run through gettext by the caller. This wart makes
2398 life simpler in print_z_candidates and for the translators. */
2401 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2403 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2405 if (candidate->num_convs == 3)
2406 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2407 candidate->convs[0]->type,
2408 candidate->convs[1]->type,
2409 candidate->convs[2]->type);
2410 else if (candidate->num_convs == 2)
2411 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2412 candidate->convs[0]->type,
2413 candidate->convs[1]->type);
2415 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2416 candidate->convs[0]->type);
2418 else if (TYPE_P (candidate->fn))
2419 inform ("%s %T <conversion>", msgstr, candidate->fn);
2420 else if (candidate->viable == -1)
2421 inform ("%s %+#D <near match>", msgstr, candidate->fn);
2423 inform ("%s %+#D", msgstr, candidate->fn);
2427 print_z_candidates (struct z_candidate *candidates)
2430 struct z_candidate *cand1;
2431 struct z_candidate **cand2;
2433 /* There may be duplicates in the set of candidates. We put off
2434 checking this condition as long as possible, since we have no way
2435 to eliminate duplicates from a set of functions in less than n^2
2436 time. Now we are about to emit an error message, so it is more
2437 permissible to go slowly. */
2438 for (cand1 = candidates; cand1; cand1 = cand1->next)
2440 tree fn = cand1->fn;
2441 /* Skip builtin candidates and conversion functions. */
2442 if (TREE_CODE (fn) != FUNCTION_DECL)
2444 cand2 = &cand1->next;
2447 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2448 && equal_functions (fn, (*cand2)->fn))
2449 *cand2 = (*cand2)->next;
2451 cand2 = &(*cand2)->next;
2458 str = _("candidates are:");
2459 print_z_candidate (str, candidates);
2460 if (candidates->next)
2462 /* Indent successive candidates by the width of the translation
2463 of the above string. */
2464 size_t len = gcc_gettext_width (str) + 1;
2465 char *spaces = alloca (len);
2466 memset (spaces, ' ', len-1);
2467 spaces[len - 1] = '\0';
2469 candidates = candidates->next;
2472 print_z_candidate (spaces, candidates);
2473 candidates = candidates->next;
2479 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2480 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2481 the result of the conversion function to convert it to the final
2482 desired type. Merge the two sequences into a single sequence,
2483 and return the merged sequence. */
2486 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2490 gcc_assert (user_seq->kind == ck_user);
2492 /* Find the end of the second conversion sequence. */
2494 while ((*t)->kind != ck_identity)
2495 t = &((*t)->u.next);
2497 /* Replace the identity conversion with the user conversion
2501 /* The entire sequence is a user-conversion sequence. */
2502 std_seq->user_conv_p = true;
2507 /* Returns the best overload candidate to perform the requested
2508 conversion. This function is used for three the overloading situations
2509 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2510 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2511 per [dcl.init.ref], so we ignore temporary bindings. */
2513 static struct z_candidate *
2514 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2516 struct z_candidate *candidates, *cand;
2517 tree fromtype = TREE_TYPE (expr);
2518 tree ctors = NULL_TREE;
2519 tree conv_fns = NULL_TREE;
2520 conversion *conv = NULL;
2521 tree args = NULL_TREE;
2524 /* We represent conversion within a hierarchy using RVALUE_CONV and
2525 BASE_CONV, as specified by [over.best.ics]; these become plain
2526 constructor calls, as specified in [dcl.init]. */
2527 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2528 || !DERIVED_FROM_P (totype, fromtype));
2530 if (IS_AGGR_TYPE (totype))
2531 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2533 if (IS_AGGR_TYPE (fromtype))
2534 conv_fns = lookup_conversions (fromtype);
2537 flags |= LOOKUP_NO_CONVERSION;
2543 ctors = BASELINK_FUNCTIONS (ctors);
2545 t = build_int_cst (build_pointer_type (totype), 0);
2546 args = build_tree_list (NULL_TREE, expr);
2547 /* We should never try to call the abstract or base constructor
2549 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2550 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2551 args = tree_cons (NULL_TREE, t, args);
2553 for (; ctors; ctors = OVL_NEXT (ctors))
2555 tree ctor = OVL_CURRENT (ctors);
2556 if (DECL_NONCONVERTING_P (ctor))
2559 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2560 cand = add_template_candidate (&candidates, ctor, totype,
2561 NULL_TREE, args, NULL_TREE,
2562 TYPE_BINFO (totype),
2563 TYPE_BINFO (totype),
2567 cand = add_function_candidate (&candidates, ctor, totype,
2568 args, TYPE_BINFO (totype),
2569 TYPE_BINFO (totype),
2573 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2577 args = build_tree_list (NULL_TREE, build_this (expr));
2579 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2582 tree conversion_path = TREE_PURPOSE (conv_fns);
2583 int convflags = LOOKUP_NO_CONVERSION;
2585 /* If we are called to convert to a reference type, we are trying to
2586 find an lvalue binding, so don't even consider temporaries. If
2587 we don't find an lvalue binding, the caller will try again to
2588 look for a temporary binding. */
2589 if (TREE_CODE (totype) == REFERENCE_TYPE)
2590 convflags |= LOOKUP_NO_TEMP_BIND;
2592 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2594 tree fn = OVL_CURRENT (fns);
2596 /* [over.match.funcs] For conversion functions, the function
2597 is considered to be a member of the class of the implicit
2598 object argument for the purpose of defining the type of
2599 the implicit object parameter.
2601 So we pass fromtype as CTYPE to add_*_candidate. */
2603 if (TREE_CODE (fn) == TEMPLATE_DECL)
2604 cand = add_template_candidate (&candidates, fn, fromtype,
2607 TYPE_BINFO (fromtype),
2612 cand = add_function_candidate (&candidates, fn, fromtype,
2614 TYPE_BINFO (fromtype),
2621 = implicit_conversion (totype,
2622 TREE_TYPE (TREE_TYPE (cand->fn)),
2624 /*c_cast_p=*/false, convflags);
2626 cand->second_conv = ics;
2630 else if (candidates->viable == 1 && ics->bad_p)
2636 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2640 cand = tourney (candidates);
2643 if (flags & LOOKUP_COMPLAIN)
2645 error ("conversion from %qT to %qT is ambiguous",
2647 print_z_candidates (candidates);
2650 cand = candidates; /* any one will do */
2651 cand->second_conv = build_ambiguous_conv (totype, expr);
2652 cand->second_conv->user_conv_p = true;
2653 if (!any_strictly_viable (candidates))
2654 cand->second_conv->bad_p = true;
2655 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2656 ambiguous conversion is no worse than another user-defined
2662 /* Build the user conversion sequence. */
2665 (DECL_CONSTRUCTOR_P (cand->fn)
2666 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2667 build_identity_conv (TREE_TYPE (expr), expr));
2670 /* Combine it with the second conversion sequence. */
2671 cand->second_conv = merge_conversion_sequences (conv,
2674 if (cand->viable == -1)
2675 cand->second_conv->bad_p = true;
2681 build_user_type_conversion (tree totype, tree expr, int flags)
2683 struct z_candidate *cand
2684 = build_user_type_conversion_1 (totype, expr, flags);
2688 if (cand->second_conv->kind == ck_ambig)
2689 return error_mark_node;
2690 expr = convert_like (cand->second_conv, expr);
2691 return convert_from_reference (expr);
2696 /* Do any initial processing on the arguments to a function call. */
2699 resolve_args (tree args)
2702 for (t = args; t; t = TREE_CHAIN (t))
2704 tree arg = TREE_VALUE (t);
2706 if (error_operand_p (arg))
2707 return error_mark_node;
2708 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2710 error ("invalid use of void expression");
2711 return error_mark_node;
2713 else if (invalid_nonstatic_memfn_p (arg))
2714 return error_mark_node;
2719 /* Perform overload resolution on FN, which is called with the ARGS.
2721 Return the candidate function selected by overload resolution, or
2722 NULL if the event that overload resolution failed. In the case
2723 that overload resolution fails, *CANDIDATES will be the set of
2724 candidates considered, and ANY_VIABLE_P will be set to true or
2725 false to indicate whether or not any of the candidates were
2728 The ARGS should already have gone through RESOLVE_ARGS before this
2729 function is called. */
2731 static struct z_candidate *
2732 perform_overload_resolution (tree fn,
2734 struct z_candidate **candidates,
2737 struct z_candidate *cand;
2738 tree explicit_targs = NULL_TREE;
2739 int template_only = 0;
2742 *any_viable_p = true;
2744 /* Check FN and ARGS. */
2745 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2746 || TREE_CODE (fn) == TEMPLATE_DECL
2747 || TREE_CODE (fn) == OVERLOAD
2748 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2749 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2751 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2753 explicit_targs = TREE_OPERAND (fn, 1);
2754 fn = TREE_OPERAND (fn, 0);
2758 /* Add the various candidate functions. */
2759 add_candidates (fn, args, explicit_targs, template_only,
2760 /*conversion_path=*/NULL_TREE,
2761 /*access_path=*/NULL_TREE,
2765 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2769 cand = tourney (*candidates);
2773 /* Return an expression for a call to FN (a namespace-scope function,
2774 or a static member function) with the ARGS. */
2777 build_new_function_call (tree fn, tree args, bool koenig_p)
2779 struct z_candidate *candidates, *cand;
2784 args = resolve_args (args);
2785 if (args == error_mark_node)
2786 return error_mark_node;
2788 /* If this function was found without using argument dependent
2789 lookup, then we want to ignore any undeclared friend
2795 fn = remove_hidden_names (fn);
2798 error ("no matching function for call to %<%D(%A)%>",
2799 DECL_NAME (OVL_CURRENT (orig_fn)), args);
2800 return error_mark_node;
2804 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2805 p = conversion_obstack_alloc (0);
2807 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2811 if (!any_viable_p && candidates && ! candidates->next)
2812 return build_function_call (candidates->fn, args);
2813 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2814 fn = TREE_OPERAND (fn, 0);
2816 error ("no matching function for call to %<%D(%A)%>",
2817 DECL_NAME (OVL_CURRENT (fn)), args);
2819 error ("call of overloaded %<%D(%A)%> is ambiguous",
2820 DECL_NAME (OVL_CURRENT (fn)), args);
2822 print_z_candidates (candidates);
2823 result = error_mark_node;
2826 result = build_over_call (cand, LOOKUP_NORMAL);
2828 /* Free all the conversions we allocated. */
2829 obstack_free (&conversion_obstack, p);
2834 /* Build a call to a global operator new. FNNAME is the name of the
2835 operator (either "operator new" or "operator new[]") and ARGS are
2836 the arguments provided. *SIZE points to the total number of bytes
2837 required by the allocation, and is updated if that is changed here.
2838 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2839 function determines that no cookie should be used, after all,
2840 *COOKIE_SIZE is set to NULL_TREE. */
2843 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2846 struct z_candidate *candidates;
2847 struct z_candidate *cand;
2850 args = tree_cons (NULL_TREE, *size, args);
2851 args = resolve_args (args);
2852 if (args == error_mark_node)
2859 If this lookup fails to find the name, or if the allocated type
2860 is not a class type, the allocation function's name is looked
2861 up in the global scope.
2863 we disregard block-scope declarations of "operator new". */
2864 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2866 /* Figure out what function is being called. */
2867 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2869 /* If no suitable function could be found, issue an error message
2874 error ("no matching function for call to %<%D(%A)%>",
2875 DECL_NAME (OVL_CURRENT (fns)), args);
2877 error ("call of overloaded %<%D(%A)%> is ambiguous",
2878 DECL_NAME (OVL_CURRENT (fns)), args);
2880 print_z_candidates (candidates);
2881 return error_mark_node;
2884 /* If a cookie is required, add some extra space. Whether
2885 or not a cookie is required cannot be determined until
2886 after we know which function was called. */
2889 bool use_cookie = true;
2890 if (!abi_version_at_least (2))
2892 tree placement = TREE_CHAIN (args);
2893 /* In G++ 3.2, the check was implemented incorrectly; it
2894 looked at the placement expression, rather than the
2895 type of the function. */
2896 if (placement && !TREE_CHAIN (placement)
2897 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2905 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2906 /* Skip the size_t parameter. */
2907 arg_types = TREE_CHAIN (arg_types);
2908 /* Check the remaining parameters (if any). */
2910 && TREE_CHAIN (arg_types) == void_list_node
2911 && same_type_p (TREE_VALUE (arg_types),
2915 /* If we need a cookie, adjust the number of bytes allocated. */
2918 /* Update the total size. */
2919 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2920 /* Update the argument list to reflect the adjusted size. */
2921 TREE_VALUE (args) = *size;
2924 *cookie_size = NULL_TREE;
2927 /* Build the CALL_EXPR. */
2928 return build_over_call (cand, LOOKUP_NORMAL);
2932 build_object_call (tree obj, tree args)
2934 struct z_candidate *candidates = 0, *cand;
2935 tree fns, convs, mem_args = NULL_TREE;
2936 tree type = TREE_TYPE (obj);
2938 tree result = NULL_TREE;
2941 if (TYPE_PTRMEMFUNC_P (type))
2943 /* It's no good looking for an overloaded operator() on a
2944 pointer-to-member-function. */
2945 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2946 return error_mark_node;
2949 if (TYPE_BINFO (type))
2951 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2952 if (fns == error_mark_node)
2953 return error_mark_node;
2958 args = resolve_args (args);
2960 if (args == error_mark_node)
2961 return error_mark_node;
2963 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2964 p = conversion_obstack_alloc (0);
2968 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2969 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2971 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2973 tree fn = OVL_CURRENT (fns);
2974 if (TREE_CODE (fn) == TEMPLATE_DECL)
2975 add_template_candidate (&candidates, fn, base, NULL_TREE,
2976 mem_args, NULL_TREE,
2979 LOOKUP_NORMAL, DEDUCE_CALL);
2981 add_function_candidate
2982 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2983 TYPE_BINFO (type), LOOKUP_NORMAL);
2987 convs = lookup_conversions (type);
2989 for (; convs; convs = TREE_CHAIN (convs))
2991 tree fns = TREE_VALUE (convs);
2992 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2994 if ((TREE_CODE (totype) == POINTER_TYPE
2995 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2996 || (TREE_CODE (totype) == REFERENCE_TYPE
2997 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2998 || (TREE_CODE (totype) == REFERENCE_TYPE
2999 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3000 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3001 for (; fns; fns = OVL_NEXT (fns))
3003 tree fn = OVL_CURRENT (fns);
3004 if (TREE_CODE (fn) == TEMPLATE_DECL)
3005 add_template_conv_candidate
3006 (&candidates, fn, obj, args, totype,
3007 /*access_path=*/NULL_TREE,
3008 /*conversion_path=*/NULL_TREE);
3010 add_conv_candidate (&candidates, fn, obj, args,
3011 /*conversion_path=*/NULL_TREE,
3012 /*access_path=*/NULL_TREE);
3016 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3019 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3020 print_z_candidates (candidates);
3021 result = error_mark_node;
3025 cand = tourney (candidates);
3028 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
3029 print_z_candidates (candidates);
3030 result = error_mark_node;
3032 /* Since cand->fn will be a type, not a function, for a conversion
3033 function, we must be careful not to unconditionally look at
3035 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3036 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3037 result = build_over_call (cand, LOOKUP_NORMAL);
3040 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
3041 obj = convert_from_reference (obj);
3042 result = build_function_call (obj, args);
3046 /* Free all the conversions we allocated. */
3047 obstack_free (&conversion_obstack, p);
3053 op_error (enum tree_code code, enum tree_code code2,
3054 tree arg1, tree arg2, tree arg3, const char *problem)
3058 if (code == MODIFY_EXPR)
3059 opname = assignment_operator_name_info[code2].name;
3061 opname = operator_name_info[code].name;
3066 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3067 problem, arg1, arg2, arg3);
3070 case POSTINCREMENT_EXPR:
3071 case POSTDECREMENT_EXPR:
3072 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3076 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3081 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3086 error ("%s for %<operator%s%> in %<%E %s %E%>",
3087 problem, opname, arg1, opname, arg2);
3089 error ("%s for %<operator%s%> in %<%s%E%>",
3090 problem, opname, opname, arg1);
3095 /* Return the implicit conversion sequence that could be used to
3096 convert E1 to E2 in [expr.cond]. */
3099 conditional_conversion (tree e1, tree e2)
3101 tree t1 = non_reference (TREE_TYPE (e1));
3102 tree t2 = non_reference (TREE_TYPE (e2));
3108 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3109 implicitly converted (clause _conv_) to the type "reference to
3110 T2", subject to the constraint that in the conversion the
3111 reference must bind directly (_dcl.init.ref_) to E1. */
3112 if (real_lvalue_p (e2))
3114 conv = implicit_conversion (build_reference_type (t2),
3118 LOOKUP_NO_TEMP_BIND);
3125 If E1 and E2 have class type, and the underlying class types are
3126 the same or one is a base class of the other: E1 can be converted
3127 to match E2 if the class of T2 is the same type as, or a base
3128 class of, the class of T1, and the cv-qualification of T2 is the
3129 same cv-qualification as, or a greater cv-qualification than, the
3130 cv-qualification of T1. If the conversion is applied, E1 is
3131 changed to an rvalue of type T2 that still refers to the original
3132 source class object (or the appropriate subobject thereof). */
3133 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3134 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3136 if (good_base && at_least_as_qualified_p (t2, t1))
3138 conv = build_identity_conv (t1, e1);
3139 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3140 TYPE_MAIN_VARIANT (t2)))
3141 conv = build_conv (ck_base, t2, conv);
3143 conv = build_conv (ck_rvalue, t2, conv);
3152 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3153 converted to the type that expression E2 would have if E2 were
3154 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3155 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3159 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3160 arguments to the conditional expression. */
3163 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3167 tree result = NULL_TREE;
3168 tree result_type = NULL_TREE;
3169 bool lvalue_p = true;
3170 struct z_candidate *candidates = 0;
3171 struct z_candidate *cand;
3174 /* As a G++ extension, the second argument to the conditional can be
3175 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3176 c'.) If the second operand is omitted, make sure it is
3177 calculated only once. */
3181 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3183 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3184 if (real_lvalue_p (arg1))
3185 arg2 = arg1 = stabilize_reference (arg1);
3187 arg2 = arg1 = save_expr (arg1);
3192 The first expr ession is implicitly converted to bool (clause
3194 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3196 /* If something has already gone wrong, just pass that fact up the
3198 if (error_operand_p (arg1)
3199 || error_operand_p (arg2)
3200 || error_operand_p (arg3))
3201 return error_mark_node;
3205 If either the second or the third operand has type (possibly
3206 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3207 array-to-pointer (_conv.array_), and function-to-pointer
3208 (_conv.func_) standard conversions are performed on the second
3209 and third operands. */
3210 arg2_type = TREE_TYPE (arg2);
3211 arg3_type = TREE_TYPE (arg3);
3212 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3214 /* Do the conversions. We don't these for `void' type arguments
3215 since it can't have any effect and since decay_conversion
3216 does not handle that case gracefully. */
3217 if (!VOID_TYPE_P (arg2_type))
3218 arg2 = decay_conversion (arg2);
3219 if (!VOID_TYPE_P (arg3_type))
3220 arg3 = decay_conversion (arg3);
3221 arg2_type = TREE_TYPE (arg2);
3222 arg3_type = TREE_TYPE (arg3);
3226 One of the following shall hold:
3228 --The second or the third operand (but not both) is a
3229 throw-expression (_except.throw_); the result is of the
3230 type of the other and is an rvalue.
3232 --Both the second and the third operands have type void; the
3233 result is of type void and is an rvalue.
3235 We must avoid calling force_rvalue for expressions of type
3236 "void" because it will complain that their value is being
3238 if (TREE_CODE (arg2) == THROW_EXPR
3239 && TREE_CODE (arg3) != THROW_EXPR)
3241 if (!VOID_TYPE_P (arg3_type))
3242 arg3 = force_rvalue (arg3);
3243 arg3_type = TREE_TYPE (arg3);
3244 result_type = arg3_type;
3246 else if (TREE_CODE (arg2) != THROW_EXPR
3247 && TREE_CODE (arg3) == THROW_EXPR)
3249 if (!VOID_TYPE_P (arg2_type))
3250 arg2 = force_rvalue (arg2);
3251 arg2_type = TREE_TYPE (arg2);
3252 result_type = arg2_type;
3254 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3255 result_type = void_type_node;
3258 error ("%qE has type %<void%> and is not a throw-expression",
3259 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3260 return error_mark_node;
3264 goto valid_operands;
3268 Otherwise, if the second and third operand have different types,
3269 and either has (possibly cv-qualified) class type, an attempt is
3270 made to convert each of those operands to the type of the other. */
3271 else if (!same_type_p (arg2_type, arg3_type)
3272 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3277 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3278 p = conversion_obstack_alloc (0);
3280 conv2 = conditional_conversion (arg2, arg3);
3281 conv3 = conditional_conversion (arg3, arg2);
3285 If both can be converted, or one can be converted but the
3286 conversion is ambiguous, the program is ill-formed. If
3287 neither can be converted, the operands are left unchanged and
3288 further checking is performed as described below. If exactly
3289 one conversion is possible, that conversion is applied to the
3290 chosen operand and the converted operand is used in place of
3291 the original operand for the remainder of this section. */
3292 if ((conv2 && !conv2->bad_p
3293 && conv3 && !conv3->bad_p)
3294 || (conv2 && conv2->kind == ck_ambig)
3295 || (conv3 && conv3->kind == ck_ambig))
3297 error ("operands to ?: have different types");
3298 result = error_mark_node;
3300 else if (conv2 && (!conv2->bad_p || !conv3))
3302 arg2 = convert_like (conv2, arg2);
3303 arg2 = convert_from_reference (arg2);
3304 arg2_type = TREE_TYPE (arg2);
3305 /* Even if CONV2 is a valid conversion, the result of the
3306 conversion may be invalid. For example, if ARG3 has type
3307 "volatile X", and X does not have a copy constructor
3308 accepting a "volatile X&", then even if ARG2 can be
3309 converted to X, the conversion will fail. */
3310 if (error_operand_p (arg2))
3311 result = error_mark_node;
3313 else if (conv3 && (!conv3->bad_p || !conv2))
3315 arg3 = convert_like (conv3, arg3);
3316 arg3 = convert_from_reference (arg3);
3317 arg3_type = TREE_TYPE (arg3);
3318 if (error_operand_p (arg3))
3319 result = error_mark_node;
3322 /* Free all the conversions we allocated. */
3323 obstack_free (&conversion_obstack, p);
3328 /* If, after the conversion, both operands have class type,
3329 treat the cv-qualification of both operands as if it were the
3330 union of the cv-qualification of the operands.
3332 The standard is not clear about what to do in this
3333 circumstance. For example, if the first operand has type
3334 "const X" and the second operand has a user-defined
3335 conversion to "volatile X", what is the type of the second
3336 operand after this step? Making it be "const X" (matching
3337 the first operand) seems wrong, as that discards the
3338 qualification without actually performing a copy. Leaving it
3339 as "volatile X" seems wrong as that will result in the
3340 conditional expression failing altogether, even though,
3341 according to this step, the one operand could be converted to
3342 the type of the other. */
3343 if ((conv2 || conv3)
3344 && CLASS_TYPE_P (arg2_type)
3345 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3346 arg2_type = arg3_type =
3347 cp_build_qualified_type (arg2_type,
3348 TYPE_QUALS (arg2_type)
3349 | TYPE_QUALS (arg3_type));
3354 If the second and third operands are lvalues and have the same
3355 type, the result is of that type and is an lvalue. */
3356 if (real_lvalue_p (arg2)
3357 && real_lvalue_p (arg3)
3358 && same_type_p (arg2_type, arg3_type))
3360 result_type = arg2_type;
3361 goto valid_operands;
3366 Otherwise, the result is an rvalue. If the second and third
3367 operand do not have the same type, and either has (possibly
3368 cv-qualified) class type, overload resolution is used to
3369 determine the conversions (if any) to be applied to the operands
3370 (_over.match.oper_, _over.built_). */
3372 if (!same_type_p (arg2_type, arg3_type)
3373 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3379 /* Rearrange the arguments so that add_builtin_candidate only has
3380 to know about two args. In build_builtin_candidates, the
3381 arguments are unscrambled. */
3385 add_builtin_candidates (&candidates,
3388 ansi_opname (COND_EXPR),
3394 If the overload resolution fails, the program is
3396 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3399 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3400 print_z_candidates (candidates);
3401 return error_mark_node;
3403 cand = tourney (candidates);
3406 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3407 print_z_candidates (candidates);
3408 return error_mark_node;
3413 Otherwise, the conversions thus determined are applied, and
3414 the converted operands are used in place of the original
3415 operands for the remainder of this section. */
3416 conv = cand->convs[0];
3417 arg1 = convert_like (conv, arg1);
3418 conv = cand->convs[1];
3419 arg2 = convert_like (conv, arg2);
3420 conv = cand->convs[2];
3421 arg3 = convert_like (conv, arg3);
3426 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3427 and function-to-pointer (_conv.func_) standard conversions are
3428 performed on the second and third operands.
3430 We need to force the lvalue-to-rvalue conversion here for class types,
3431 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3432 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3435 arg2 = force_rvalue (arg2);
3436 if (!CLASS_TYPE_P (arg2_type))
3437 arg2_type = TREE_TYPE (arg2);
3439 arg3 = force_rvalue (arg3);
3440 if (!CLASS_TYPE_P (arg2_type))
3441 arg3_type = TREE_TYPE (arg3);
3443 if (arg2 == error_mark_node || arg3 == error_mark_node)
3444 return error_mark_node;
3448 After those conversions, one of the following shall hold:
3450 --The second and third operands have the same type; the result is of
3452 if (same_type_p (arg2_type, arg3_type))
3453 result_type = arg2_type;
3456 --The second and third operands have arithmetic or enumeration
3457 type; the usual arithmetic conversions are performed to bring
3458 them to a common type, and the result is of that type. */
3459 else if ((ARITHMETIC_TYPE_P (arg2_type)
3460 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3461 && (ARITHMETIC_TYPE_P (arg3_type)
3462 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3464 /* In this case, there is always a common type. */
3465 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3468 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3469 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3470 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3471 arg2_type, arg3_type);
3472 else if (extra_warnings
3473 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3474 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3475 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3476 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3477 warning (0, "enumeral and non-enumeral type in conditional expression");
3479 arg2 = perform_implicit_conversion (result_type, arg2);
3480 arg3 = perform_implicit_conversion (result_type, arg3);
3484 --The second and third operands have pointer type, or one has
3485 pointer type and the other is a null pointer constant; pointer
3486 conversions (_conv.ptr_) and qualification conversions
3487 (_conv.qual_) are performed to bring them to their composite
3488 pointer type (_expr.rel_). The result is of the composite
3491 --The second and third operands have pointer to member type, or
3492 one has pointer to member type and the other is a null pointer
3493 constant; pointer to member conversions (_conv.mem_) and
3494 qualification conversions (_conv.qual_) are performed to bring
3495 them to a common type, whose cv-qualification shall match the
3496 cv-qualification of either the second or the third operand.
3497 The result is of the common type. */
3498 else if ((null_ptr_cst_p (arg2)
3499 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3500 || (null_ptr_cst_p (arg3)
3501 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3502 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3503 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3504 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3506 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3507 arg3, "conditional expression");
3508 if (result_type == error_mark_node)
3509 return error_mark_node;
3510 arg2 = perform_implicit_conversion (result_type, arg2);
3511 arg3 = perform_implicit_conversion (result_type, arg3);
3516 error ("operands to ?: have different types");
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
3526 /* Expand both sides into the same slot, hopefully the target of the
3527 ?: expression. We used to check for TARGET_EXPRs here, but now we
3528 sometimes wrap them in NOP_EXPRs so the test would fail. */
3529 if (!lvalue_p && CLASS_TYPE_P (TREE_TYPE (result)))
3530 result = get_target_expr (result);
3532 /* If this expression is an rvalue, but might be mistaken for an
3533 lvalue, we must add a NON_LVALUE_EXPR. */
3534 if (!lvalue_p && real_lvalue_p (result))
3535 result = rvalue (result);
3540 /* OPERAND is an operand to an expression. Perform necessary steps
3541 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3545 prep_operand (tree operand)
3549 if (CLASS_TYPE_P (TREE_TYPE (operand))
3550 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3551 /* Make sure the template type is instantiated now. */
3552 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3558 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3559 OVERLOAD) to the CANDIDATES, returning an updated list of
3560 CANDIDATES. The ARGS are the arguments provided to the call,
3561 without any implicit object parameter. The EXPLICIT_TARGS are
3562 explicit template arguments provided. TEMPLATE_ONLY is true if
3563 only template functions should be considered. CONVERSION_PATH,
3564 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3567 add_candidates (tree fns, tree args,
3568 tree explicit_targs, bool template_only,
3569 tree conversion_path, tree access_path,
3571 struct z_candidate **candidates)
3574 tree non_static_args;
3576 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3577 /* Delay creating the implicit this parameter until it is needed. */
3578 non_static_args = NULL_TREE;
3585 fn = OVL_CURRENT (fns);
3586 /* Figure out which set of arguments to use. */
3587 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3589 /* If this function is a non-static member, prepend the implicit
3590 object parameter. */
3591 if (!non_static_args)
3592 non_static_args = tree_cons (NULL_TREE,
3593 build_this (TREE_VALUE (args)),
3595 fn_args = non_static_args;
3598 /* Otherwise, just use the list of arguments provided. */
3601 if (TREE_CODE (fn) == TEMPLATE_DECL)
3602 add_template_candidate (candidates,
3612 else if (!template_only)
3613 add_function_candidate (candidates,
3620 fns = OVL_NEXT (fns);
3625 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3628 struct z_candidate *candidates = 0, *cand;
3629 tree arglist, fnname;
3631 tree result = NULL_TREE;
3632 bool result_valid_p = false;
3633 enum tree_code code2 = NOP_EXPR;
3639 if (error_operand_p (arg1)
3640 || error_operand_p (arg2)
3641 || error_operand_p (arg3))
3642 return error_mark_node;
3644 if (code == MODIFY_EXPR)
3646 code2 = TREE_CODE (arg3);
3648 fnname = ansi_assopname (code2);
3651 fnname = ansi_opname (code);
3653 arg1 = prep_operand (arg1);
3659 case VEC_DELETE_EXPR:
3661 /* Use build_op_new_call and build_op_delete_call instead. */
3665 return build_object_call (arg1, arg2);
3671 arg2 = prep_operand (arg2);
3672 arg3 = prep_operand (arg3);
3674 if (code == COND_EXPR)
3676 if (arg2 == NULL_TREE
3677 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3678 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3679 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3680 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3683 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3684 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3687 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3688 arg2 = integer_zero_node;
3690 arglist = NULL_TREE;
3692 arglist = tree_cons (NULL_TREE, arg3, arglist);
3694 arglist = tree_cons (NULL_TREE, arg2, arglist);
3695 arglist = tree_cons (NULL_TREE, arg1, arglist);
3697 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3698 p = conversion_obstack_alloc (0);
3700 /* Add namespace-scope operators to the list of functions to
3702 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3703 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3704 flags, &candidates);
3705 /* Add class-member operators to the candidate set. */
3706 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3710 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3711 if (fns == error_mark_node)
3713 result = error_mark_node;
3714 goto user_defined_result_ready;
3717 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3719 BASELINK_BINFO (fns),
3720 TYPE_BINFO (TREE_TYPE (arg1)),
3721 flags, &candidates);
3724 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3725 to know about two args; a builtin candidate will always have a first
3726 parameter of type bool. We'll handle that in
3727 build_builtin_candidate. */
3728 if (code == COND_EXPR)
3738 args[2] = NULL_TREE;
3741 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3747 /* For these, the built-in candidates set is empty
3748 [over.match.oper]/3. We don't want non-strict matches
3749 because exact matches are always possible with built-in
3750 operators. The built-in candidate set for COMPONENT_REF
3751 would be empty too, but since there are no such built-in
3752 operators, we accept non-strict matches for them. */
3757 strict_p = pedantic;
3761 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3766 case POSTINCREMENT_EXPR:
3767 case POSTDECREMENT_EXPR:
3768 /* Look for an `operator++ (int)'. If they didn't have
3769 one, then we fall back to the old way of doing things. */
3770 if (flags & LOOKUP_COMPLAIN)
3771 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3772 "trying prefix operator instead",
3774 operator_name_info[code].name);
3775 if (code == POSTINCREMENT_EXPR)
3776 code = PREINCREMENT_EXPR;
3778 code = PREDECREMENT_EXPR;
3779 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3783 /* The caller will deal with these. */
3788 result_valid_p = true;
3792 if (flags & LOOKUP_COMPLAIN)
3794 op_error (code, code2, arg1, arg2, arg3, "no match");
3795 print_z_candidates (candidates);
3797 result = error_mark_node;
3803 cand = tourney (candidates);
3806 if (flags & LOOKUP_COMPLAIN)
3808 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3809 print_z_candidates (candidates);
3811 result = error_mark_node;
3813 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3816 *overloaded_p = true;
3818 result = build_over_call (cand, LOOKUP_NORMAL);
3822 /* Give any warnings we noticed during overload resolution. */
3825 struct candidate_warning *w;
3826 for (w = cand->warnings; w; w = w->next)
3827 joust (cand, w->loser, 1);
3830 /* Check for comparison of different enum types. */
3839 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3840 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3841 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3842 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3844 warning (0, "comparison between %q#T and %q#T",
3845 TREE_TYPE (arg1), TREE_TYPE (arg2));
3852 /* We need to strip any leading REF_BIND so that bitfields
3853 don't cause errors. This should not remove any important
3854 conversions, because builtins don't apply to class
3855 objects directly. */
3856 conv = cand->convs[0];
3857 if (conv->kind == ck_ref_bind)
3858 conv = conv->u.next;
3859 arg1 = convert_like (conv, arg1);
3862 conv = cand->convs[1];
3863 if (conv->kind == ck_ref_bind)
3864 conv = conv->u.next;
3865 arg2 = convert_like (conv, arg2);
3869 conv = cand->convs[2];
3870 if (conv->kind == ck_ref_bind)
3871 conv = conv->u.next;
3872 arg3 = convert_like (conv, arg3);
3877 user_defined_result_ready:
3879 /* Free all the conversions we allocated. */
3880 obstack_free (&conversion_obstack, p);
3882 if (result || result_valid_p)
3889 return build_modify_expr (arg1, code2, arg2);
3892 return build_indirect_ref (arg1, "unary *");
3897 case TRUNC_DIV_EXPR:
3908 case TRUNC_MOD_EXPR:
3912 case TRUTH_ANDIF_EXPR:
3913 case TRUTH_ORIF_EXPR:
3914 return cp_build_binary_op (code, arg1, arg2);
3916 case UNARY_PLUS_EXPR:
3919 case TRUTH_NOT_EXPR:
3920 case PREINCREMENT_EXPR:
3921 case POSTINCREMENT_EXPR:
3922 case PREDECREMENT_EXPR:
3923 case POSTDECREMENT_EXPR:
3926 return build_unary_op (code, arg1, candidates != 0);
3929 return build_array_ref (arg1, arg2);
3932 return build_conditional_expr (arg1, arg2, arg3);
3935 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
3937 /* The caller will deal with these. */
3949 /* Build a call to operator delete. This has to be handled very specially,
3950 because the restrictions on what signatures match are different from all
3951 other call instances. For a normal delete, only a delete taking (void *)
3952 or (void *, size_t) is accepted. For a placement delete, only an exact
3953 match with the placement new is accepted.
3955 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3956 ADDR is the pointer to be deleted.
3957 SIZE is the size of the memory block to be deleted.
3958 GLOBAL_P is true if the delete-expression should not consider
3959 class-specific delete operators.
3960 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3963 build_op_delete_call (enum tree_code code, tree addr, tree size,
3964 bool global_p, tree placement)
3966 tree fn = NULL_TREE;
3967 tree fns, fnname, argtypes, args, type;
3970 if (addr == error_mark_node)
3971 return error_mark_node;
3973 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3975 fnname = ansi_opname (code);
3977 if (CLASS_TYPE_P (type)
3978 && COMPLETE_TYPE_P (complete_type (type))
3982 If the result of the lookup is ambiguous or inaccessible, or if
3983 the lookup selects a placement deallocation function, the
3984 program is ill-formed.
3986 Therefore, we ask lookup_fnfields to complain about ambiguity. */
3988 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3989 if (fns == error_mark_node)
3990 return error_mark_node;
3995 if (fns == NULL_TREE)
3996 fns = lookup_name_nonclass (fnname);
4003 /* Find the allocation function that is being called. */
4004 call_expr = placement;
4005 /* Extract the function. */
4006 alloc_fn = get_callee_fndecl (call_expr);
4007 gcc_assert (alloc_fn != NULL_TREE);
4008 /* Then the second parm type. */
4009 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4010 /* Also the second argument. */
4011 args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
4015 /* First try it without the size argument. */
4016 argtypes = void_list_node;
4020 /* Strip const and volatile from addr. */
4021 addr = cp_convert (ptr_type_node, addr);
4023 /* We make two tries at finding a matching `operator delete'. On
4024 the first pass, we look for a one-operator (or placement)
4025 operator delete. If we're not doing placement delete, then on
4026 the second pass we look for a two-argument delete. */
4027 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4029 /* Go through the `operator delete' functions looking for one
4030 with a matching type. */
4031 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4037 /* The first argument must be "void *". */
4038 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4039 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4042 /* On the first pass, check the rest of the arguments. */
4048 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4056 /* On the second pass, the second argument must be
4059 && same_type_p (TREE_VALUE (t), sizetype)
4060 && TREE_CHAIN (t) == void_list_node)
4064 /* If we found a match, we're done. */
4069 /* If we have a matching function, call it. */
4072 /* Make sure we have the actual function, and not an
4074 fn = OVL_CURRENT (fn);
4076 /* If the FN is a member function, make sure that it is
4078 if (DECL_CLASS_SCOPE_P (fn))
4079 perform_or_defer_access_check (TYPE_BINFO (type), fn);
4082 args = tree_cons (NULL_TREE, addr, args);
4084 args = tree_cons (NULL_TREE, addr,
4085 build_tree_list (NULL_TREE, size));
4089 /* The placement args might not be suitable for overload
4090 resolution at this point, so build the call directly. */
4092 return build_cxx_call (fn, args);
4095 return build_function_call (fn, args);
4098 /* If we are doing placement delete we do nothing if we don't find a
4099 matching op delete. */
4103 error ("no suitable %<operator %s%> for %qT",
4104 operator_name_info[(int)code].name, type);
4105 return error_mark_node;
4108 /* If the current scope isn't allowed to access DECL along
4109 BASETYPE_PATH, give an error. The most derived class in
4110 BASETYPE_PATH is the one used to qualify DECL. */
4113 enforce_access (tree basetype_path, tree decl)
4115 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4117 if (!accessible_p (basetype_path, decl, true))
4119 if (TREE_PRIVATE (decl))
4120 error ("%q+#D is private", decl);
4121 else if (TREE_PROTECTED (decl))
4122 error ("%q+#D is protected", decl);
4124 error ("%q+#D is inaccessible", decl);
4125 error ("within this context");
4132 /* Check that a callable constructor to initialize a temporary of
4133 TYPE from an EXPR exists. */
4136 check_constructor_callable (tree type, tree expr)
4138 build_special_member_call (NULL_TREE,
4139 complete_ctor_identifier,
4140 build_tree_list (NULL_TREE, expr),
4142 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4143 | LOOKUP_NO_CONVERSION
4144 | LOOKUP_CONSTRUCTOR_CALLABLE);
4147 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4148 bitwise or of LOOKUP_* values. If any errors are warnings are
4149 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4150 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4154 build_temp (tree expr, tree type, int flags,
4155 diagnostic_fn_t *diagnostic_fn)
4159 savew = warningcount, savee = errorcount;
4160 expr = build_special_member_call (NULL_TREE,
4161 complete_ctor_identifier,
4162 build_tree_list (NULL_TREE, expr),
4164 if (warningcount > savew)
4165 *diagnostic_fn = warning0;
4166 else if (errorcount > savee)
4167 *diagnostic_fn = error;
4169 *diagnostic_fn = NULL;
4174 /* Perform the conversions in CONVS on the expression EXPR. FN and
4175 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4176 indicates the `this' argument of a method. INNER is nonzero when
4177 being called to continue a conversion chain. It is negative when a
4178 reference binding will be applied, positive otherwise. If
4179 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4180 conversions will be emitted if appropriate. If C_CAST_P is true,
4181 this conversion is coming from a C-style cast; in that case,
4182 conversions to inaccessible bases are permitted. */
4185 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4186 int inner, bool issue_conversion_warnings,
4189 tree totype = convs->type;
4190 diagnostic_fn_t diagnostic_fn;
4193 && convs->kind != ck_user
4194 && convs->kind != ck_ambig
4195 && convs->kind != ck_ref_bind)
4197 conversion *t = convs;
4198 for (; t; t = convs->u.next)
4200 if (t->kind == ck_user || !t->bad_p)
4202 expr = convert_like_real (t, expr, fn, argnum, 1,
4203 /*issue_conversion_warnings=*/false,
4204 /*c_cast_p=*/false);
4207 else if (t->kind == ck_ambig)
4208 return convert_like_real (t, expr, fn, argnum, 1,
4209 /*issue_conversion_warnings=*/false,
4210 /*c_cast_p=*/false);
4211 else if (t->kind == ck_identity)
4214 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4216 pedwarn (" initializing argument %P of %qD", argnum, fn);
4217 return cp_convert (totype, expr);
4220 if (issue_conversion_warnings)
4222 tree t = non_reference (totype);
4224 /* Issue warnings about peculiar, but valid, uses of NULL. */
4225 if (ARITHMETIC_TYPE_P (t) && expr == null_node)
4228 warning (0, "passing NULL to non-pointer argument %P of %qD",
4231 warning (0, "converting to non-pointer type %qT from NULL", t);
4234 /* Warn about assigning a floating-point type to an integer type. */
4235 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4236 && TREE_CODE (t) == INTEGER_TYPE)
4239 warning (0, "passing %qT for argument %P to %qD",
4240 TREE_TYPE (expr), argnum, fn);
4242 warning (0, "converting to %qT from %qT", t, TREE_TYPE (expr));
4246 switch (convs->kind)
4250 struct z_candidate *cand = convs->cand;
4251 tree convfn = cand->fn;
4254 if (DECL_CONSTRUCTOR_P (convfn))
4256 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4259 args = build_tree_list (NULL_TREE, expr);
4260 /* We should never try to call the abstract or base constructor
4262 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4263 && !DECL_HAS_VTT_PARM_P (convfn));
4264 args = tree_cons (NULL_TREE, t, args);
4267 args = build_this (expr);
4268 expr = build_over_call (cand, LOOKUP_NORMAL);
4270 /* If this is a constructor or a function returning an aggr type,
4271 we need to build up a TARGET_EXPR. */
4272 if (DECL_CONSTRUCTOR_P (convfn))
4273 expr = build_cplus_new (totype, expr);
4275 /* The result of the call is then used to direct-initialize the object
4276 that is the destination of the copy-initialization. [dcl.init]
4278 Note that this step is not reflected in the conversion sequence;
4279 it affects the semantics when we actually perform the
4280 conversion, but is not considered during overload resolution.
4282 If the target is a class, that means call a ctor. */
4283 if (IS_AGGR_TYPE (totype)
4284 && (inner >= 0 || !lvalue_p (expr)))
4288 /* Core issue 84, now a DR, says that we don't
4289 allow UDCs for these args (which deliberately
4290 breaks copy-init of an auto_ptr<Base> from an
4291 auto_ptr<Derived>). */
4292 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4299 (" initializing argument %P of %qD from result of %qD",
4300 argnum, fn, convfn);
4303 (" initializing temporary from result of %qD", convfn);
4305 expr = build_cplus_new (totype, expr);
4310 if (type_unknown_p (expr))
4311 expr = instantiate_type (totype, expr, tf_error | tf_warning);
4312 /* Convert a constant to its underlying value, unless we are
4313 about to bind it to a reference, in which case we need to
4314 leave it as an lvalue. */
4316 expr = decl_constant_value (expr);
4317 if (convs->check_copy_constructor_p)
4318 check_constructor_callable (totype, expr);
4321 /* Call build_user_type_conversion again for the error. */
4322 return build_user_type_conversion
4323 (totype, convs->u.expr, LOOKUP_NORMAL);
4329 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4330 convs->kind == ck_ref_bind ? -1 : 1,
4331 /*issue_conversion_warnings=*/false,
4333 if (expr == error_mark_node)
4334 return error_mark_node;
4336 switch (convs->kind)
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 /* Remove reference types so we don't ICE later on. */
4527 tree type1 = non_reference (type);
4528 /* Undefined behavior [expr.call] 5.2.2/7. */
4529 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4530 "call will abort at runtime", type);
4531 expr = convert (build_pointer_type (type1), null_node);
4532 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4533 call_builtin_trap (), expr);
4534 expr = build_indirect_ref (expr, NULL);
4538 return build_va_arg (expr, type);
4541 /* TYPE has been given to va_arg. Apply the default conversions which
4542 would have happened when passed via ellipsis. Return the promoted
4543 type, or the passed type if there is no change. */
4546 cxx_type_promotes_to (tree type)
4550 /* Perform the array-to-pointer and function-to-pointer
4552 type = type_decays_to (type);
4554 promote = type_promotes_to (type);
4555 if (same_type_p (type, promote))
4561 /* ARG is a default argument expression being passed to a parameter of
4562 the indicated TYPE, which is a parameter to FN. Do any required
4563 conversions. Return the converted value. */
4566 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4568 /* If the ARG is an unparsed default argument expression, the
4569 conversion cannot be performed. */
4570 if (TREE_CODE (arg) == DEFAULT_ARG)
4572 error ("the default argument for parameter %d of %qD has "
4573 "not yet been parsed",
4575 return error_mark_node;
4578 if (fn && DECL_TEMPLATE_INFO (fn))
4579 arg = tsubst_default_argument (fn, type, arg);
4581 arg = break_out_target_exprs (arg);
4583 if (TREE_CODE (arg) == CONSTRUCTOR)
4585 arg = digest_init (type, arg);
4586 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4587 "default argument", fn, parmnum);
4591 /* This could get clobbered by the following call. */
4592 if (TREE_HAS_CONSTRUCTOR (arg))
4593 arg = copy_node (arg);
4595 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4596 "default argument", fn, parmnum);
4597 arg = convert_for_arg_passing (type, arg);
4603 /* Returns the type which will really be used for passing an argument of
4607 type_passed_as (tree type)
4609 /* Pass classes with copy ctors by invisible reference. */
4610 if (TREE_ADDRESSABLE (type))
4612 type = build_reference_type (type);
4613 /* There are no other pointers to this temporary. */
4614 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4616 else if (targetm.calls.promote_prototypes (type)
4617 && INTEGRAL_TYPE_P (type)
4618 && COMPLETE_TYPE_P (type)
4619 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4620 TYPE_SIZE (integer_type_node)))
4621 type = integer_type_node;
4626 /* Actually perform the appropriate conversion. */
4629 convert_for_arg_passing (tree type, tree val)
4631 if (val == error_mark_node)
4633 /* Pass classes with copy ctors by invisible reference. */
4634 else if (TREE_ADDRESSABLE (type))
4635 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4636 else if (targetm.calls.promote_prototypes (type)
4637 && INTEGRAL_TYPE_P (type)
4638 && COMPLETE_TYPE_P (type)
4639 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4640 TYPE_SIZE (integer_type_node)))
4641 val = perform_integral_promotions (val);
4642 if (warn_missing_format_attribute)
4644 tree rhstype = TREE_TYPE (val);
4645 const enum tree_code coder = TREE_CODE (rhstype);
4646 const enum tree_code codel = TREE_CODE (type);
4647 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4649 && check_missing_format_attribute (type, rhstype))
4650 warning (OPT_Wmissing_format_attribute,
4651 "argument of function call might be a candidate for a format attribute");
4656 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4657 which no conversions at all should be done. This is true for some
4658 builtins which don't act like normal functions. */
4661 magic_varargs_p (tree fn)
4663 if (DECL_BUILT_IN (fn))
4664 switch (DECL_FUNCTION_CODE (fn))
4666 case BUILT_IN_CLASSIFY_TYPE:
4667 case BUILT_IN_CONSTANT_P:
4668 case BUILT_IN_NEXT_ARG:
4669 case BUILT_IN_STDARG_START:
4670 case BUILT_IN_VA_START:
4679 /* Subroutine of the various build_*_call functions. Overload resolution
4680 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4681 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4682 bitmask of various LOOKUP_* flags which apply to the call itself. */
4685 build_over_call (struct z_candidate *cand, int flags)
4688 tree args = cand->args;
4689 conversion **convs = cand->convs;
4691 tree converted_args = NULL_TREE;
4692 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4697 /* In a template, there is no need to perform all of the work that
4698 is normally done. We are only interested in the type of the call
4699 expression, i.e., the return type of the function. Any semantic
4700 errors will be deferred until the template is instantiated. */
4701 if (processing_template_decl)
4705 return_type = TREE_TYPE (TREE_TYPE (fn));
4706 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4707 if (TREE_THIS_VOLATILE (fn) && cfun)
4708 current_function_returns_abnormally = 1;
4709 if (!VOID_TYPE_P (return_type))
4710 require_complete_type (return_type);
4711 return convert_from_reference (expr);
4714 /* Give any warnings we noticed during overload resolution. */
4717 struct candidate_warning *w;
4718 for (w = cand->warnings; w; w = w->next)
4719 joust (cand, w->loser, 1);
4722 if (DECL_FUNCTION_MEMBER_P (fn))
4724 /* If FN is a template function, two cases must be considered.
4729 template <class T> void f();
4731 template <class T> struct B {
4735 struct C : A, B<int> {
4737 using B<int>::g; // #2
4740 In case #1 where `A::f' is a member template, DECL_ACCESS is
4741 recorded in the primary template but not in its specialization.
4742 We check access of FN using its primary template.
4744 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4745 because it is a member of class template B, DECL_ACCESS is
4746 recorded in the specialization `B<int>::g'. We cannot use its
4747 primary template because `B<T>::g' and `B<int>::g' may have
4748 different access. */
4749 if (DECL_TEMPLATE_INFO (fn)
4750 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4751 perform_or_defer_access_check (cand->access_path,
4752 DECL_TI_TEMPLATE (fn));
4754 perform_or_defer_access_check (cand->access_path, fn);
4757 if (args && TREE_CODE (args) != TREE_LIST)
4758 args = build_tree_list (NULL_TREE, args);
4761 /* The implicit parameters to a constructor are not considered by overload
4762 resolution, and must be of the proper type. */
4763 if (DECL_CONSTRUCTOR_P (fn))
4765 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4766 arg = TREE_CHAIN (arg);
4767 parm = TREE_CHAIN (parm);
4768 /* We should never try to call the abstract constructor. */
4769 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4771 if (DECL_HAS_VTT_PARM_P (fn))
4773 converted_args = tree_cons
4774 (NULL_TREE, TREE_VALUE (arg), converted_args);
4775 arg = TREE_CHAIN (arg);
4776 parm = TREE_CHAIN (parm);
4779 /* Bypass access control for 'this' parameter. */
4780 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4782 tree parmtype = TREE_VALUE (parm);
4783 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4787 if (convs[i]->bad_p)
4788 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4789 TREE_TYPE (argtype), fn);
4791 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4792 X is called for an object that is not of type X, or of a type
4793 derived from X, the behavior is undefined.
4795 So we can assume that anything passed as 'this' is non-null, and
4796 optimize accordingly. */
4797 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4798 /* Convert to the base in which the function was declared. */
4799 gcc_assert (cand->conversion_path != NULL_TREE);
4800 converted_arg = build_base_path (PLUS_EXPR,
4802 cand->conversion_path,
4804 /* Check that the base class is accessible. */
4805 if (!accessible_base_p (TREE_TYPE (argtype),
4806 BINFO_TYPE (cand->conversion_path), true))
4807 error ("%qT is not an accessible base of %qT",
4808 BINFO_TYPE (cand->conversion_path),
4809 TREE_TYPE (argtype));
4810 /* If fn was found by a using declaration, the conversion path
4811 will be to the derived class, not the base declaring fn. We
4812 must convert from derived to base. */
4813 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4814 TREE_TYPE (parmtype), ba_unique, NULL);
4815 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4818 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4819 parm = TREE_CHAIN (parm);
4820 arg = TREE_CHAIN (arg);
4826 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4828 tree type = TREE_VALUE (parm);
4832 /* Don't make a copy here if build_call is going to. */
4833 if (conv->kind == ck_rvalue
4834 && !TREE_ADDRESSABLE (complete_type (type)))
4835 conv = conv->u.next;
4837 val = convert_like_with_context
4838 (conv, TREE_VALUE (arg), fn, i - is_method);
4840 val = convert_for_arg_passing (type, val);
4841 converted_args = tree_cons (NULL_TREE, val, converted_args);
4844 /* Default arguments */
4845 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4847 = tree_cons (NULL_TREE,
4848 convert_default_arg (TREE_VALUE (parm),
4849 TREE_PURPOSE (parm),
4854 for (; arg; arg = TREE_CHAIN (arg))
4856 tree a = TREE_VALUE (arg);
4857 if (magic_varargs_p (fn))
4858 /* Do no conversions for magic varargs. */;
4860 a = convert_arg_to_ellipsis (a);
4861 converted_args = tree_cons (NULL_TREE, a, converted_args);
4864 converted_args = nreverse (converted_args);
4866 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4867 converted_args, TYPE_ARG_TYPES (TREE_TYPE (fn)));
4869 /* Avoid actually calling copy constructors and copy assignment operators,
4872 if (! flag_elide_constructors)
4873 /* Do things the hard way. */;
4874 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4877 arg = skip_artificial_parms_for (fn, converted_args);
4878 arg = TREE_VALUE (arg);
4880 /* Pull out the real argument, disregarding const-correctness. */
4882 while (TREE_CODE (targ) == NOP_EXPR
4883 || TREE_CODE (targ) == NON_LVALUE_EXPR
4884 || TREE_CODE (targ) == CONVERT_EXPR)
4885 targ = TREE_OPERAND (targ, 0);
4886 if (TREE_CODE (targ) == ADDR_EXPR)
4888 targ = TREE_OPERAND (targ, 0);
4889 if (!same_type_ignoring_top_level_qualifiers_p
4890 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4899 arg = build_indirect_ref (arg, 0);
4901 /* [class.copy]: the copy constructor is implicitly defined even if
4902 the implementation elided its use. */
4903 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4906 /* If we're creating a temp and we already have one, don't create a
4907 new one. If we're not creating a temp but we get one, use
4908 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4909 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4910 temp or an INIT_EXPR otherwise. */
4911 if (integer_zerop (TREE_VALUE (args)))
4913 if (TREE_CODE (arg) == TARGET_EXPR)
4915 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4916 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4918 else if (TREE_CODE (arg) == TARGET_EXPR
4919 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4921 tree to = stabilize_reference
4922 (build_indirect_ref (TREE_VALUE (args), 0));
4924 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4928 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4930 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4932 tree to = stabilize_reference
4933 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4934 tree type = TREE_TYPE (to);
4935 tree as_base = CLASSTYPE_AS_BASE (type);
4937 arg = TREE_VALUE (TREE_CHAIN (converted_args));
4938 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4940 arg = build_indirect_ref (arg, 0);
4941 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4945 /* We must only copy the non-tail padding parts.
4946 Use __builtin_memcpy for the bitwise copy. */
4950 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
4951 args = tree_cons (NULL, arg, args);
4952 t = build_unary_op (ADDR_EXPR, to, 0);
4953 args = tree_cons (NULL, t, args);
4954 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
4955 t = build_call (t, args);
4957 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
4958 val = build_indirect_ref (t, 0);
4966 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4968 tree t, *p = &TREE_VALUE (converted_args);
4969 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
4972 gcc_assert (binfo && binfo != error_mark_node);
4974 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
4975 if (TREE_SIDE_EFFECTS (*p))
4976 *p = save_expr (*p);
4977 t = build_pointer_type (TREE_TYPE (fn));
4978 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
4979 fn = build_java_interface_fn_ref (fn, *p);
4981 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
4984 else if (DECL_INLINE (fn))
4985 fn = inline_conversion (fn);
4987 fn = build_addr_func (fn);
4989 return build_cxx_call (fn, converted_args);
4992 /* Build and return a call to FN, using ARGS. This function performs
4993 no overload resolution, conversion, or other high-level
4997 build_cxx_call (tree fn, tree args)
5001 fn = build_call (fn, args);
5003 /* If this call might throw an exception, note that fact. */
5004 fndecl = get_callee_fndecl (fn);
5005 if ((!fndecl || !TREE_NOTHROW (fndecl))
5006 && at_function_scope_p ()
5008 cp_function_chain->can_throw = 1;
5010 /* Some built-in function calls will be evaluated at compile-time in
5012 fn = fold_if_not_in_template (fn);
5014 if (VOID_TYPE_P (TREE_TYPE (fn)))
5017 fn = require_complete_type (fn);
5018 if (fn == error_mark_node)
5019 return error_mark_node;
5021 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5022 fn = build_cplus_new (TREE_TYPE (fn), fn);
5023 return convert_from_reference (fn);
5026 static GTY(()) tree java_iface_lookup_fn;
5028 /* Make an expression which yields the address of the Java interface
5029 method FN. This is achieved by generating a call to libjava's
5030 _Jv_LookupInterfaceMethodIdx(). */
5033 build_java_interface_fn_ref (tree fn, tree instance)
5035 tree lookup_args, lookup_fn, method, idx;
5036 tree klass_ref, iface, iface_ref;
5039 if (!java_iface_lookup_fn)
5041 tree endlink = build_void_list_node ();
5042 tree t = tree_cons (NULL_TREE, ptr_type_node,
5043 tree_cons (NULL_TREE, ptr_type_node,
5044 tree_cons (NULL_TREE, java_int_type_node,
5046 java_iface_lookup_fn
5047 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
5048 build_function_type (ptr_type_node, t),
5049 0, NOT_BUILT_IN, NULL, NULL_TREE);
5052 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5053 This is the first entry in the vtable. */
5054 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5057 /* Get the java.lang.Class pointer for the interface being called. */
5058 iface = DECL_CONTEXT (fn);
5059 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5060 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5061 || DECL_CONTEXT (iface_ref) != iface)
5063 error ("could not find class$ field in java interface type %qT",
5065 return error_mark_node;
5067 iface_ref = build_address (iface_ref);
5068 iface_ref = convert (build_pointer_type (iface), iface_ref);
5070 /* Determine the itable index of FN. */
5072 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5074 if (!DECL_VIRTUAL_P (method))
5080 idx = build_int_cst (NULL_TREE, i);
5082 lookup_args = tree_cons (NULL_TREE, klass_ref,
5083 tree_cons (NULL_TREE, iface_ref,
5084 build_tree_list (NULL_TREE, idx)));
5085 lookup_fn = build1 (ADDR_EXPR,
5086 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5087 java_iface_lookup_fn);
5088 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
5091 /* Returns the value to use for the in-charge parameter when making a
5092 call to a function with the indicated NAME.
5094 FIXME:Can't we find a neater way to do this mapping? */
5097 in_charge_arg_for_name (tree name)
5099 if (name == base_ctor_identifier
5100 || name == base_dtor_identifier)
5101 return integer_zero_node;
5102 else if (name == complete_ctor_identifier)
5103 return integer_one_node;
5104 else if (name == complete_dtor_identifier)
5105 return integer_two_node;
5106 else if (name == deleting_dtor_identifier)
5107 return integer_three_node;
5109 /* This function should only be called with one of the names listed
5115 /* Build a call to a constructor, destructor, or an assignment
5116 operator for INSTANCE, an expression with class type. NAME
5117 indicates the special member function to call; ARGS are the
5118 arguments. BINFO indicates the base of INSTANCE that is to be
5119 passed as the `this' parameter to the member function called.
5121 FLAGS are the LOOKUP_* flags to use when processing the call.
5123 If NAME indicates a complete object constructor, INSTANCE may be
5124 NULL_TREE. In this case, the caller will call build_cplus_new to
5125 store the newly constructed object into a VAR_DECL. */
5128 build_special_member_call (tree instance, tree name, tree args,
5129 tree binfo, int flags)
5132 /* The type of the subobject to be constructed or destroyed. */
5135 gcc_assert (name == complete_ctor_identifier
5136 || name == base_ctor_identifier
5137 || name == complete_dtor_identifier
5138 || name == base_dtor_identifier
5139 || name == deleting_dtor_identifier
5140 || name == ansi_assopname (NOP_EXPR));
5143 /* Resolve the name. */
5144 if (!complete_type_or_else (binfo, NULL_TREE))
5145 return error_mark_node;
5147 binfo = TYPE_BINFO (binfo);
5150 gcc_assert (binfo != NULL_TREE);
5152 class_type = BINFO_TYPE (binfo);
5154 /* Handle the special case where INSTANCE is NULL_TREE. */
5155 if (name == complete_ctor_identifier && !instance)
5157 instance = build_int_cst (build_pointer_type (class_type), 0);
5158 instance = build1 (INDIRECT_REF, class_type, instance);
5162 if (name == complete_dtor_identifier
5163 || name == base_dtor_identifier
5164 || name == deleting_dtor_identifier)
5165 gcc_assert (args == NULL_TREE);
5167 /* Convert to the base class, if necessary. */
5168 if (!same_type_ignoring_top_level_qualifiers_p
5169 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5171 if (name != ansi_assopname (NOP_EXPR))
5172 /* For constructors and destructors, either the base is
5173 non-virtual, or it is virtual but we are doing the
5174 conversion from a constructor or destructor for the
5175 complete object. In either case, we can convert
5177 instance = convert_to_base_statically (instance, binfo);
5179 /* However, for assignment operators, we must convert
5180 dynamically if the base is virtual. */
5181 instance = build_base_path (PLUS_EXPR, instance,
5182 binfo, /*nonnull=*/1);
5186 gcc_assert (instance != NULL_TREE);
5188 fns = lookup_fnfields (binfo, name, 1);
5190 /* When making a call to a constructor or destructor for a subobject
5191 that uses virtual base classes, pass down a pointer to a VTT for
5193 if ((name == base_ctor_identifier
5194 || name == base_dtor_identifier)
5195 && CLASSTYPE_VBASECLASSES (class_type))
5200 /* If the current function is a complete object constructor
5201 or destructor, then we fetch the VTT directly.
5202 Otherwise, we look it up using the VTT we were given. */
5203 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5204 vtt = decay_conversion (vtt);
5205 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5206 build2 (EQ_EXPR, boolean_type_node,
5207 current_in_charge_parm, integer_zero_node),
5210 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5211 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5212 BINFO_SUBVTT_INDEX (binfo));
5214 args = tree_cons (NULL_TREE, sub_vtt, args);
5217 return build_new_method_call (instance, fns, args,
5218 TYPE_BINFO (BINFO_TYPE (binfo)),
5222 /* Return the NAME, as a C string. The NAME indicates a function that
5223 is a member of TYPE. *FREE_P is set to true if the caller must
5224 free the memory returned.
5226 Rather than go through all of this, we should simply set the names
5227 of constructors and destructors appropriately, and dispense with
5228 ctor_identifier, dtor_identifier, etc. */
5231 name_as_c_string (tree name, tree type, bool *free_p)
5235 /* Assume that we will not allocate memory. */
5237 /* Constructors and destructors are special. */
5238 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5241 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5242 /* For a destructor, add the '~'. */
5243 if (name == complete_dtor_identifier
5244 || name == base_dtor_identifier
5245 || name == deleting_dtor_identifier)
5247 pretty_name = concat ("~", pretty_name, NULL);
5248 /* Remember that we need to free the memory allocated. */
5252 else if (IDENTIFIER_TYPENAME_P (name))
5254 pretty_name = concat ("operator ",
5255 type_as_string (TREE_TYPE (name),
5256 TFF_PLAIN_IDENTIFIER),
5258 /* Remember that we need to free the memory allocated. */
5262 pretty_name = (char *) IDENTIFIER_POINTER (name);
5267 /* Build a call to "INSTANCE.FN (ARGS)". */
5270 build_new_method_call (tree instance, tree fns, tree args,
5271 tree conversion_path, int flags)
5273 struct z_candidate *candidates = 0, *cand;
5274 tree explicit_targs = NULL_TREE;
5275 tree basetype = NULL_TREE;
5278 tree mem_args = NULL_TREE, instance_ptr;
5284 int template_only = 0;
5291 gcc_assert (instance != NULL_TREE);
5293 if (error_operand_p (instance)
5294 || error_operand_p (fns)
5295 || args == error_mark_node)
5296 return error_mark_node;
5298 if (!BASELINK_P (fns))
5300 error ("call to non-function %qD", fns);
5301 return error_mark_node;
5304 orig_instance = instance;
5308 /* Dismantle the baselink to collect all the information we need. */
5309 if (!conversion_path)
5310 conversion_path = BASELINK_BINFO (fns);
5311 access_binfo = BASELINK_ACCESS_BINFO (fns);
5312 optype = BASELINK_OPTYPE (fns);
5313 fns = BASELINK_FUNCTIONS (fns);
5314 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5316 explicit_targs = TREE_OPERAND (fns, 1);
5317 fns = TREE_OPERAND (fns, 0);
5320 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5321 || TREE_CODE (fns) == TEMPLATE_DECL
5322 || TREE_CODE (fns) == OVERLOAD);
5323 fn = get_first_fn (fns);
5324 name = DECL_NAME (fn);
5326 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5327 gcc_assert (CLASS_TYPE_P (basetype));
5329 if (processing_template_decl)
5331 instance = build_non_dependent_expr (instance);
5332 args = build_non_dependent_args (orig_args);
5335 /* The USER_ARGS are the arguments we will display to users if an
5336 error occurs. The USER_ARGS should not include any
5337 compiler-generated arguments. The "this" pointer hasn't been
5338 added yet. However, we must remove the VTT pointer if this is a
5339 call to a base-class constructor or destructor. */
5341 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5343 /* Callers should explicitly indicate whether they want to construct
5344 the complete object or just the part without virtual bases. */
5345 gcc_assert (name != ctor_identifier);
5346 /* Similarly for destructors. */
5347 gcc_assert (name != dtor_identifier);
5348 /* Remove the VTT pointer, if present. */
5349 if ((name == base_ctor_identifier || name == base_dtor_identifier)
5350 && CLASSTYPE_VBASECLASSES (basetype))
5351 user_args = TREE_CHAIN (user_args);
5354 /* Process the argument list. */
5355 args = resolve_args (args);
5356 if (args == error_mark_node)
5357 return error_mark_node;
5359 instance_ptr = build_this (instance);
5361 /* It's OK to call destructors on cv-qualified objects. Therefore,
5362 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5363 if (DECL_DESTRUCTOR_P (fn))
5365 tree type = build_pointer_type (basetype);
5366 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5367 instance_ptr = build_nop (type, instance_ptr);
5368 name = complete_dtor_identifier;
5371 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5372 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5374 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5375 p = conversion_obstack_alloc (0);
5377 for (fn = fns; fn; fn = OVL_NEXT (fn))
5379 tree t = OVL_CURRENT (fn);
5382 /* We can end up here for copy-init of same or base class. */
5383 if ((flags & LOOKUP_ONLYCONVERTING)
5384 && DECL_NONCONVERTING_P (t))
5387 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5388 this_arglist = mem_args;
5390 this_arglist = args;
5392 if (TREE_CODE (t) == TEMPLATE_DECL)
5393 /* A member template. */
5394 add_template_candidate (&candidates, t,
5397 this_arglist, optype,
5402 else if (! template_only)
5403 add_function_candidate (&candidates, t,
5411 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5414 if (!COMPLETE_TYPE_P (basetype))
5415 cxx_incomplete_type_error (instance_ptr, basetype);
5421 pretty_name = name_as_c_string (name, basetype, &free_p);
5422 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5423 basetype, pretty_name, user_args,
5424 TREE_TYPE (TREE_TYPE (instance_ptr)));
5428 print_z_candidates (candidates);
5429 call = error_mark_node;
5433 cand = tourney (candidates);
5439 pretty_name = name_as_c_string (name, basetype, &free_p);
5440 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5442 print_z_candidates (candidates);
5445 call = error_mark_node;
5449 if (!(flags & LOOKUP_NONVIRTUAL)
5450 && DECL_PURE_VIRTUAL_P (cand->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 (cand->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 (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5471 && resolves_to_fixed_type_p (instance, 0))
5472 flags |= LOOKUP_NONVIRTUAL;
5474 call = build_over_call (cand, flags);
5476 /* In an expression of the form `a->f()' where `f' turns
5477 out to be a static member function, `a' is
5478 none-the-less evaluated. */
5479 if (TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE
5480 && !is_dummy_object (instance_ptr)
5481 && TREE_SIDE_EFFECTS (instance_ptr))
5482 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5483 instance_ptr, call);
5488 if (processing_template_decl && call != error_mark_node)
5489 call = (build_min_non_dep
5491 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5492 orig_args, NULL_TREE));
5494 /* Free all the conversions we allocated. */
5495 obstack_free (&conversion_obstack, p);
5500 /* Returns true iff standard conversion sequence ICS1 is a proper
5501 subsequence of ICS2. */
5504 is_subseq (conversion *ics1, conversion *ics2)
5506 /* We can assume that a conversion of the same code
5507 between the same types indicates a subsequence since we only get
5508 here if the types we are converting from are the same. */
5510 while (ics1->kind == ck_rvalue
5511 || ics1->kind == ck_lvalue)
5512 ics1 = ics1->u.next;
5516 while (ics2->kind == ck_rvalue
5517 || ics2->kind == ck_lvalue)
5518 ics2 = ics2->u.next;
5520 if (ics2->kind == ck_user
5521 || ics2->kind == ck_ambig
5522 || ics2->kind == ck_identity)
5523 /* At this point, ICS1 cannot be a proper subsequence of
5524 ICS2. We can get a USER_CONV when we are comparing the
5525 second standard conversion sequence of two user conversion
5529 ics2 = ics2->u.next;
5531 if (ics2->kind == ics1->kind
5532 && same_type_p (ics2->type, ics1->type)
5533 && same_type_p (ics2->u.next->type,
5534 ics1->u.next->type))
5539 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5540 be any _TYPE nodes. */
5543 is_properly_derived_from (tree derived, tree base)
5545 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5546 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5549 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5550 considers every class derived from itself. */
5551 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5552 && DERIVED_FROM_P (base, derived));
5555 /* We build the ICS for an implicit object parameter as a pointer
5556 conversion sequence. However, such a sequence should be compared
5557 as if it were a reference conversion sequence. If ICS is the
5558 implicit conversion sequence for an implicit object parameter,
5559 modify it accordingly. */
5562 maybe_handle_implicit_object (conversion **ics)
5566 /* [over.match.funcs]
5568 For non-static member functions, the type of the
5569 implicit object parameter is "reference to cv X"
5570 where X is the class of which the function is a
5571 member and cv is the cv-qualification on the member
5572 function declaration. */
5573 conversion *t = *ics;
5574 tree reference_type;
5576 /* The `this' parameter is a pointer to a class type. Make the
5577 implicit conversion talk about a reference to that same class
5579 reference_type = TREE_TYPE (t->type);
5580 reference_type = build_reference_type (reference_type);
5582 if (t->kind == ck_qual)
5584 if (t->kind == ck_ptr)
5586 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5587 t = direct_reference_binding (reference_type, t);
5592 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5593 and return the type to which the reference refers. Otherwise,
5594 leave *ICS unchanged and return NULL_TREE. */
5597 maybe_handle_ref_bind (conversion **ics)
5599 if ((*ics)->kind == ck_ref_bind)
5601 conversion *old_ics = *ics;
5602 tree type = TREE_TYPE (old_ics->type);
5603 *ics = old_ics->u.next;
5604 (*ics)->user_conv_p = old_ics->user_conv_p;
5605 (*ics)->bad_p = old_ics->bad_p;
5612 /* Compare two implicit conversion sequences according to the rules set out in
5613 [over.ics.rank]. Return values:
5615 1: ics1 is better than ics2
5616 -1: ics2 is better than ics1
5617 0: ics1 and ics2 are indistinguishable */
5620 compare_ics (conversion *ics1, conversion *ics2)
5626 tree deref_from_type1 = NULL_TREE;
5627 tree deref_from_type2 = NULL_TREE;
5628 tree deref_to_type1 = NULL_TREE;
5629 tree deref_to_type2 = NULL_TREE;
5630 conversion_rank rank1, rank2;
5632 /* REF_BINDING is nonzero if the result of the conversion sequence
5633 is a reference type. In that case TARGET_TYPE is the
5634 type referred to by the reference. */
5638 /* Handle implicit object parameters. */
5639 maybe_handle_implicit_object (&ics1);
5640 maybe_handle_implicit_object (&ics2);
5642 /* Handle reference parameters. */
5643 target_type1 = maybe_handle_ref_bind (&ics1);
5644 target_type2 = maybe_handle_ref_bind (&ics2);
5648 When comparing the basic forms of implicit conversion sequences (as
5649 defined in _over.best.ics_)
5651 --a standard conversion sequence (_over.ics.scs_) is a better
5652 conversion sequence than a user-defined conversion sequence
5653 or an ellipsis conversion sequence, and
5655 --a user-defined conversion sequence (_over.ics.user_) is a
5656 better conversion sequence than an ellipsis conversion sequence
5657 (_over.ics.ellipsis_). */
5658 rank1 = CONVERSION_RANK (ics1);
5659 rank2 = CONVERSION_RANK (ics2);
5663 else if (rank1 < rank2)
5666 if (rank1 == cr_bad)
5668 /* XXX Isn't this an extension? */
5669 /* Both ICS are bad. We try to make a decision based on what
5670 would have happened if they'd been good. */
5671 if (ics1->user_conv_p > ics2->user_conv_p
5672 || ics1->rank > ics2->rank)
5674 else if (ics1->user_conv_p < ics2->user_conv_p
5675 || ics1->rank < ics2->rank)
5678 /* We couldn't make up our minds; try to figure it out below. */
5681 if (ics1->ellipsis_p)
5682 /* Both conversions are ellipsis conversions. */
5685 /* User-defined conversion sequence U1 is a better conversion sequence
5686 than another user-defined conversion sequence U2 if they contain the
5687 same user-defined conversion operator or constructor and if the sec-
5688 ond standard conversion sequence of U1 is better than the second
5689 standard conversion sequence of U2. */
5691 if (ics1->user_conv_p)
5696 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5697 if (t1->kind == ck_ambig)
5699 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5700 if (t2->kind == ck_ambig)
5703 if (t1->cand->fn != t2->cand->fn)
5706 /* We can just fall through here, after setting up
5707 FROM_TYPE1 and FROM_TYPE2. */
5708 from_type1 = t1->type;
5709 from_type2 = t2->type;
5716 /* We're dealing with two standard conversion sequences.
5720 Standard conversion sequence S1 is a better conversion
5721 sequence than standard conversion sequence S2 if
5723 --S1 is a proper subsequence of S2 (comparing the conversion
5724 sequences in the canonical form defined by _over.ics.scs_,
5725 excluding any Lvalue Transformation; the identity
5726 conversion sequence is considered to be a subsequence of
5727 any non-identity conversion sequence */
5730 while (t1->kind != ck_identity)
5732 from_type1 = t1->type;
5735 while (t2->kind != ck_identity)
5737 from_type2 = t2->type;
5740 if (same_type_p (from_type1, from_type2))
5742 if (is_subseq (ics1, ics2))
5744 if (is_subseq (ics2, ics1))
5747 /* Otherwise, one sequence cannot be a subsequence of the other; they
5748 don't start with the same type. This can happen when comparing the
5749 second standard conversion sequence in two user-defined conversion
5756 --the rank of S1 is better than the rank of S2 (by the rules
5759 Standard conversion sequences are ordered by their ranks: an Exact
5760 Match is a better conversion than a Promotion, which is a better
5761 conversion than a Conversion.
5763 Two conversion sequences with the same rank are indistinguishable
5764 unless one of the following rules applies:
5766 --A conversion that is not a conversion of a pointer, or pointer
5767 to member, to bool is better than another conversion that is such
5770 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5771 so that we do not have to check it explicitly. */
5772 if (ics1->rank < ics2->rank)
5774 else if (ics2->rank < ics1->rank)
5777 to_type1 = ics1->type;
5778 to_type2 = ics2->type;
5780 if (TYPE_PTR_P (from_type1)
5781 && TYPE_PTR_P (from_type2)
5782 && TYPE_PTR_P (to_type1)
5783 && TYPE_PTR_P (to_type2))
5785 deref_from_type1 = TREE_TYPE (from_type1);
5786 deref_from_type2 = TREE_TYPE (from_type2);
5787 deref_to_type1 = TREE_TYPE (to_type1);
5788 deref_to_type2 = TREE_TYPE (to_type2);
5790 /* The rules for pointers to members A::* are just like the rules
5791 for pointers A*, except opposite: if B is derived from A then
5792 A::* converts to B::*, not vice versa. For that reason, we
5793 switch the from_ and to_ variables here. */
5794 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5795 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5796 || (TYPE_PTRMEMFUNC_P (from_type1)
5797 && TYPE_PTRMEMFUNC_P (from_type2)
5798 && TYPE_PTRMEMFUNC_P (to_type1)
5799 && TYPE_PTRMEMFUNC_P (to_type2)))
5801 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5802 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5803 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5804 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5807 if (deref_from_type1 != NULL_TREE
5808 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5809 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5811 /* This was one of the pointer or pointer-like conversions.
5815 --If class B is derived directly or indirectly from class A,
5816 conversion of B* to A* is better than conversion of B* to
5817 void*, and conversion of A* to void* is better than
5818 conversion of B* to void*. */
5819 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5820 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5822 if (is_properly_derived_from (deref_from_type1,
5825 else if (is_properly_derived_from (deref_from_type2,
5829 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5830 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5832 if (same_type_p (deref_from_type1, deref_from_type2))
5834 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5836 if (is_properly_derived_from (deref_from_type1,
5840 /* We know that DEREF_TO_TYPE1 is `void' here. */
5841 else if (is_properly_derived_from (deref_from_type1,
5846 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5847 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5851 --If class B is derived directly or indirectly from class A
5852 and class C is derived directly or indirectly from B,
5854 --conversion of C* to B* is better than conversion of C* to
5857 --conversion of B* to A* is better than conversion of C* to
5859 if (same_type_p (deref_from_type1, deref_from_type2))
5861 if (is_properly_derived_from (deref_to_type1,
5864 else if (is_properly_derived_from (deref_to_type2,
5868 else if (same_type_p (deref_to_type1, deref_to_type2))
5870 if (is_properly_derived_from (deref_from_type2,
5873 else if (is_properly_derived_from (deref_from_type1,
5879 else if (CLASS_TYPE_P (non_reference (from_type1))
5880 && same_type_p (from_type1, from_type2))
5882 tree from = non_reference (from_type1);
5886 --binding of an expression of type C to a reference of type
5887 B& is better than binding an expression of type C to a
5888 reference of type A&
5890 --conversion of C to B is better than conversion of C to A, */
5891 if (is_properly_derived_from (from, to_type1)
5892 && is_properly_derived_from (from, to_type2))
5894 if (is_properly_derived_from (to_type1, to_type2))
5896 else if (is_properly_derived_from (to_type2, to_type1))
5900 else if (CLASS_TYPE_P (non_reference (to_type1))
5901 && same_type_p (to_type1, to_type2))
5903 tree to = non_reference (to_type1);
5907 --binding of an expression of type B to a reference of type
5908 A& is better than binding an expression of type C to a
5909 reference of type A&,
5911 --conversion of B to A is better than conversion of C to A */
5912 if (is_properly_derived_from (from_type1, to)
5913 && is_properly_derived_from (from_type2, to))
5915 if (is_properly_derived_from (from_type2, from_type1))
5917 else if (is_properly_derived_from (from_type1, from_type2))
5924 --S1 and S2 differ only in their qualification conversion and yield
5925 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5926 qualification signature of type T1 is a proper subset of the cv-
5927 qualification signature of type T2 */
5928 if (ics1->kind == ck_qual
5929 && ics2->kind == ck_qual
5930 && same_type_p (from_type1, from_type2))
5931 return comp_cv_qual_signature (to_type1, to_type2);
5935 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5936 types to which the references refer are the same type except for
5937 top-level cv-qualifiers, and the type to which the reference
5938 initialized by S2 refers is more cv-qualified than the type to
5939 which the reference initialized by S1 refers */
5941 if (target_type1 && target_type2
5942 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5943 return comp_cv_qualification (target_type2, target_type1);
5945 /* Neither conversion sequence is better than the other. */
5949 /* The source type for this standard conversion sequence. */
5952 source_type (conversion *t)
5954 for (;; t = t->u.next)
5956 if (t->kind == ck_user
5957 || t->kind == ck_ambig
5958 || t->kind == ck_identity)
5964 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5965 a pointer to LOSER and re-running joust to produce the warning if WINNER
5966 is actually used. */
5969 add_warning (struct z_candidate *winner, struct z_candidate *loser)
5971 candidate_warning *cw;
5973 cw = conversion_obstack_alloc (sizeof (candidate_warning));
5975 cw->next = winner->warnings;
5976 winner->warnings = cw;
5979 /* Compare two candidates for overloading as described in
5980 [over.match.best]. Return values:
5982 1: cand1 is better than cand2
5983 -1: cand2 is better than cand1
5984 0: cand1 and cand2 are indistinguishable */
5987 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
5990 int off1 = 0, off2 = 0;
5994 /* Candidates that involve bad conversions are always worse than those
5996 if (cand1->viable > cand2->viable)
5998 if (cand1->viable < cand2->viable)
6001 /* If we have two pseudo-candidates for conversions to the same type,
6002 or two candidates for the same function, arbitrarily pick one. */
6003 if (cand1->fn == cand2->fn
6004 && (IS_TYPE_OR_DECL_P (cand1->fn)))
6007 /* a viable function F1
6008 is defined to be a better function than another viable function F2 if
6009 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6010 ICSi(F2), and then */
6012 /* for some argument j, ICSj(F1) is a better conversion sequence than
6015 /* For comparing static and non-static member functions, we ignore
6016 the implicit object parameter of the non-static function. The
6017 standard says to pretend that the static function has an object
6018 parm, but that won't work with operator overloading. */
6019 len = cand1->num_convs;
6020 if (len != cand2->num_convs)
6022 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6023 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6025 gcc_assert (static_1 != static_2);
6036 for (i = 0; i < len; ++i)
6038 conversion *t1 = cand1->convs[i + off1];
6039 conversion *t2 = cand2->convs[i + off2];
6040 int comp = compare_ics (t1, t2);
6045 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6046 == cr_std + cr_promotion)
6047 && t1->kind == ck_std
6048 && t2->kind == ck_std
6049 && TREE_CODE (t1->type) == INTEGER_TYPE
6050 && TREE_CODE (t2->type) == INTEGER_TYPE
6051 && (TYPE_PRECISION (t1->type)
6052 == TYPE_PRECISION (t2->type))
6053 && (TYPE_UNSIGNED (t1->u.next->type)
6054 || (TREE_CODE (t1->u.next->type)
6057 tree type = t1->u.next->type;
6059 struct z_candidate *w, *l;
6061 type1 = t1->type, type2 = t2->type,
6062 w = cand1, l = cand2;
6064 type1 = t2->type, type2 = t1->type,
6065 w = cand2, l = cand1;
6069 warning (0, "passing %qT chooses %qT over %qT",
6070 type, type1, type2);
6071 warning (0, " in call to %qD", w->fn);
6077 if (winner && comp != winner)
6086 /* warn about confusing overload resolution for user-defined conversions,
6087 either between a constructor and a conversion op, or between two
6089 if (winner && warn_conversion && cand1->second_conv
6090 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6091 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6093 struct z_candidate *w, *l;
6094 bool give_warning = false;
6097 w = cand1, l = cand2;
6099 w = cand2, l = cand1;
6101 /* We don't want to complain about `X::operator T1 ()'
6102 beating `X::operator T2 () const', when T2 is a no less
6103 cv-qualified version of T1. */
6104 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6105 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6107 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6108 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6110 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6115 if (!comp_ptr_ttypes (t, f))
6116 give_warning = true;
6119 give_warning = true;
6125 tree source = source_type (w->convs[0]);
6126 if (! DECL_CONSTRUCTOR_P (w->fn))
6127 source = TREE_TYPE (source);
6128 warning (0, "choosing %qD over %qD", w->fn, l->fn);
6129 warning (0, " for conversion from %qT to %qT",
6130 source, w->second_conv->type);
6131 warning (0, " because conversion sequence for the argument is better");
6141 F1 is a non-template function and F2 is a template function
6144 if (!cand1->template_decl && cand2->template_decl)
6146 else if (cand1->template_decl && !cand2->template_decl)
6150 F1 and F2 are template functions and the function template for F1 is
6151 more specialized than the template for F2 according to the partial
6154 if (cand1->template_decl && cand2->template_decl)
6156 winner = more_specialized_fn
6157 (TI_TEMPLATE (cand1->template_decl),
6158 TI_TEMPLATE (cand2->template_decl),
6159 /* [temp.func.order]: The presence of unused ellipsis and default
6160 arguments has no effect on the partial ordering of function
6161 templates. add_function_candidate() will not have
6162 counted the "this" argument for constructors. */
6163 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6169 the context is an initialization by user-defined conversion (see
6170 _dcl.init_ and _over.match.user_) and the standard conversion
6171 sequence from the return type of F1 to the destination type (i.e.,
6172 the type of the entity being initialized) is a better conversion
6173 sequence than the standard conversion sequence from the return type
6174 of F2 to the destination type. */
6176 if (cand1->second_conv)
6178 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6183 /* Check whether we can discard a builtin candidate, either because we
6184 have two identical ones or matching builtin and non-builtin candidates.
6186 (Pedantically in the latter case the builtin which matched the user
6187 function should not be added to the overload set, but we spot it here.
6190 ... the builtin candidates include ...
6191 - do not have the same parameter type list as any non-template
6192 non-member candidate. */
6194 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6195 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6197 for (i = 0; i < len; ++i)
6198 if (!same_type_p (cand1->convs[i]->type,
6199 cand2->convs[i]->type))
6201 if (i == cand1->num_convs)
6203 if (cand1->fn == cand2->fn)
6204 /* Two built-in candidates; arbitrarily pick one. */
6206 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6207 /* cand1 is built-in; prefer cand2. */
6210 /* cand2 is built-in; prefer cand1. */
6215 /* If the two functions are the same (this can happen with declarations
6216 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6217 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6218 && equal_functions (cand1->fn, cand2->fn))
6223 /* Extension: If the worst conversion for one candidate is worse than the
6224 worst conversion for the other, take the first. */
6227 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6228 struct z_candidate *w = 0, *l = 0;
6230 for (i = 0; i < len; ++i)
6232 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6233 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6234 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6235 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6238 winner = 1, w = cand1, l = cand2;
6240 winner = -1, w = cand2, l = cand1;
6246 ISO C++ says that these are ambiguous, even \
6247 though the worst conversion for the first is better than \
6248 the worst conversion for the second:");
6249 print_z_candidate (_("candidate 1:"), w);
6250 print_z_candidate (_("candidate 2:"), l);
6258 gcc_assert (!winner);
6262 /* Given a list of candidates for overloading, find the best one, if any.
6263 This algorithm has a worst case of O(2n) (winner is last), and a best
6264 case of O(n/2) (totally ambiguous); much better than a sorting
6267 static struct z_candidate *
6268 tourney (struct z_candidate *candidates)
6270 struct z_candidate *champ = candidates, *challenger;
6272 int champ_compared_to_predecessor = 0;
6274 /* Walk through the list once, comparing each current champ to the next
6275 candidate, knocking out a candidate or two with each comparison. */
6277 for (challenger = champ->next; challenger; )
6279 fate = joust (champ, challenger, 0);
6281 challenger = challenger->next;
6286 champ = challenger->next;
6289 champ_compared_to_predecessor = 0;
6294 champ_compared_to_predecessor = 1;
6297 challenger = champ->next;
6301 /* Make sure the champ is better than all the candidates it hasn't yet
6302 been compared to. */
6304 for (challenger = candidates;
6306 && !(champ_compared_to_predecessor && challenger->next == champ);
6307 challenger = challenger->next)
6309 fate = joust (champ, challenger, 0);
6317 /* Returns nonzero if things of type FROM can be converted to TO. */
6320 can_convert (tree to, tree from)
6322 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6325 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6328 can_convert_arg (tree to, tree from, tree arg, int flags)
6334 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6335 p = conversion_obstack_alloc (0);
6337 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6339 ok_p = (t && !t->bad_p);
6341 /* Free all the conversions we allocated. */
6342 obstack_free (&conversion_obstack, p);
6347 /* Like can_convert_arg, but allows dubious conversions as well. */
6350 can_convert_arg_bad (tree to, tree from, tree arg)
6355 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6356 p = conversion_obstack_alloc (0);
6357 /* Try to perform the conversion. */
6358 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6360 /* Free all the conversions we allocated. */
6361 obstack_free (&conversion_obstack, p);
6366 /* Convert EXPR to TYPE. Return the converted expression.
6368 Note that we allow bad conversions here because by the time we get to
6369 this point we are committed to doing the conversion. If we end up
6370 doing a bad conversion, convert_like will complain. */
6373 perform_implicit_conversion (tree type, tree expr)
6378 if (error_operand_p (expr))
6379 return error_mark_node;
6381 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6382 p = conversion_obstack_alloc (0);
6384 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6389 error ("could not convert %qE to %qT", expr, type);
6390 expr = error_mark_node;
6392 else if (processing_template_decl)
6394 /* In a template, we are only concerned about determining the
6395 type of non-dependent expressions, so we do not have to
6396 perform the actual conversion. */
6397 if (TREE_TYPE (expr) != type)
6398 expr = build_nop (type, expr);
6401 expr = convert_like (conv, expr);
6403 /* Free all the conversions we allocated. */
6404 obstack_free (&conversion_obstack, p);
6409 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6410 permitted. If the conversion is valid, the converted expression is
6411 returned. Otherwise, NULL_TREE is returned, except in the case
6412 that TYPE is a class type; in that case, an error is issued. If
6413 C_CAST_P is true, then this direction initialization is taking
6414 place as part of a static_cast being attempted as part of a C-style
6418 perform_direct_initialization_if_possible (tree type,
6425 if (type == error_mark_node || error_operand_p (expr))
6426 return error_mark_node;
6429 If the destination type is a (possibly cv-qualified) class type:
6431 -- If the initialization is direct-initialization ...,
6432 constructors are considered. ... If no constructor applies, or
6433 the overload resolution is ambiguous, the initialization is
6435 if (CLASS_TYPE_P (type))
6437 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6438 build_tree_list (NULL_TREE, expr),
6439 type, LOOKUP_NORMAL);
6440 return build_cplus_new (type, expr);
6443 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6444 p = conversion_obstack_alloc (0);
6446 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6449 if (!conv || conv->bad_p)
6452 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6453 /*issue_conversion_warnings=*/false,
6456 /* Free all the conversions we allocated. */
6457 obstack_free (&conversion_obstack, p);
6462 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6463 is being bound to a temporary. Create and return a new VAR_DECL
6464 with the indicated TYPE; this variable will store the value to
6465 which the reference is bound. */
6468 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6472 /* Create the variable. */
6473 var = create_temporary_var (type);
6475 /* Register the variable. */
6476 if (TREE_STATIC (decl))
6478 /* Namespace-scope or local static; give it a mangled name. */
6481 TREE_STATIC (var) = 1;
6482 name = mangle_ref_init_variable (decl);
6483 DECL_NAME (var) = name;
6484 SET_DECL_ASSEMBLER_NAME (var, name);
6485 var = pushdecl_top_level (var);
6488 /* Create a new cleanup level if necessary. */
6489 maybe_push_cleanup_level (type);
6494 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6495 initializing a variable of that TYPE. If DECL is non-NULL, it is
6496 the VAR_DECL being initialized with the EXPR. (In that case, the
6497 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6498 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6499 return, if *CLEANUP is no longer NULL, it will be an expression
6500 that should be pushed as a cleanup after the returned expression
6501 is used to initialize DECL.
6503 Return the converted expression. */
6506 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6511 if (type == error_mark_node || error_operand_p (expr))
6512 return error_mark_node;
6514 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6515 p = conversion_obstack_alloc (0);
6517 conv = reference_binding (type, TREE_TYPE (expr), expr, LOOKUP_NORMAL);
6518 if (!conv || conv->bad_p)
6520 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6521 && !real_lvalue_p (expr))
6522 error ("invalid initialization of non-const reference of "
6523 "type %qT from a temporary of type %qT",
6524 type, TREE_TYPE (expr));
6526 error ("invalid initialization of reference of type "
6527 "%qT from expression of type %qT", type,
6529 return error_mark_node;
6532 /* If DECL is non-NULL, then this special rule applies:
6536 The temporary to which the reference is bound or the temporary
6537 that is the complete object to which the reference is bound
6538 persists for the lifetime of the reference.
6540 The temporaries created during the evaluation of the expression
6541 initializing the reference, except the temporary to which the
6542 reference is bound, are destroyed at the end of the
6543 full-expression in which they are created.
6545 In that case, we store the converted expression into a new
6546 VAR_DECL in a new scope.
6548 However, we want to be careful not to create temporaries when
6549 they are not required. For example, given:
6552 struct D : public B {};
6556 there is no need to copy the return value from "f"; we can just
6557 extend its lifetime. Similarly, given:
6560 struct T { operator S(); };
6564 we can extend the lifetime of the return value of the conversion
6566 gcc_assert (conv->kind == ck_ref_bind);
6570 tree base_conv_type;
6572 /* Skip over the REF_BIND. */
6573 conv = conv->u.next;
6574 /* If the next conversion is a BASE_CONV, skip that too -- but
6575 remember that the conversion was required. */
6576 if (conv->kind == ck_base)
6578 if (conv->check_copy_constructor_p)
6579 check_constructor_callable (TREE_TYPE (expr), expr);
6580 base_conv_type = conv->type;
6581 conv = conv->u.next;
6584 base_conv_type = NULL_TREE;
6585 /* Perform the remainder of the conversion. */
6586 expr = convert_like_real (conv, expr,
6587 /*fn=*/NULL_TREE, /*argnum=*/0,
6589 /*issue_conversion_warnings=*/true,
6590 /*c_cast_p=*/false);
6591 if (error_operand_p (expr))
6592 expr = error_mark_node;
6595 if (!real_lvalue_p (expr))
6600 /* Create the temporary variable. */
6601 type = TREE_TYPE (expr);
6602 var = make_temporary_var_for_ref_to_temp (decl, type);
6603 layout_decl (var, 0);
6604 /* If the rvalue is the result of a function call it will be
6605 a TARGET_EXPR. If it is some other construct (such as a
6606 member access expression where the underlying object is
6607 itself the result of a function call), turn it into a
6608 TARGET_EXPR here. It is important that EXPR be a
6609 TARGET_EXPR below since otherwise the INIT_EXPR will
6610 attempt to make a bitwise copy of EXPR to initialize
6612 if (TREE_CODE (expr) != TARGET_EXPR)
6613 expr = get_target_expr (expr);
6614 /* Create the INIT_EXPR that will initialize the temporary
6616 init = build2 (INIT_EXPR, type, var, expr);
6617 if (at_function_scope_p ())
6619 add_decl_expr (var);
6620 *cleanup = cxx_maybe_build_cleanup (var);
6622 /* We must be careful to destroy the temporary only
6623 after its initialization has taken place. If the
6624 initialization throws an exception, then the
6625 destructor should not be run. We cannot simply
6626 transform INIT into something like:
6628 (INIT, ({ CLEANUP_STMT; }))
6630 because emit_local_var always treats the
6631 initializer as a full-expression. Thus, the
6632 destructor would run too early; it would run at the
6633 end of initializing the reference variable, rather
6634 than at the end of the block enclosing the
6637 The solution is to pass back a cleanup expression
6638 which the caller is responsible for attaching to
6639 the statement tree. */
6643 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6644 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6645 static_aggregates = tree_cons (NULL_TREE, var,
6648 /* Use its address to initialize the reference variable. */
6649 expr = build_address (var);
6651 expr = convert_to_base (expr,
6652 build_pointer_type (base_conv_type),
6653 /*check_access=*/true,
6655 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6658 /* Take the address of EXPR. */
6659 expr = build_unary_op (ADDR_EXPR, expr, 0);
6660 /* If a BASE_CONV was required, perform it now. */
6662 expr = (perform_implicit_conversion
6663 (build_pointer_type (base_conv_type), expr));
6664 expr = build_nop (type, expr);
6668 /* Perform the conversion. */
6669 expr = convert_like (conv, expr);
6671 /* Free all the conversions we allocated. */
6672 obstack_free (&conversion_obstack, p);
6677 #include "gt-cp-call.h"