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 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, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* High-level class interface. */
29 #include "coretypes.h"
38 #include "diagnostic.h"
41 static tree
build_field_call (tree
, tree
, tree
);
42 static struct z_candidate
* tourney (struct z_candidate
*);
43 static int equal_functions (tree
, tree
);
44 static int joust (struct z_candidate
*, struct z_candidate
*, bool);
45 static int compare_ics (tree
, tree
);
46 static tree
build_over_call (struct z_candidate
*, int);
47 static tree
build_java_interface_fn_ref (tree
, tree
);
48 #define convert_like(CONV, EXPR) \
49 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
50 /*issue_conversion_warnings=*/true)
51 #define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
52 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
53 /*issue_conversion_warnings=*/true)
54 static tree
convert_like_real (tree
, tree
, tree
, int, int, bool);
55 static void op_error (enum tree_code
, enum tree_code
, tree
, tree
,
57 static tree
build_object_call (tree
, tree
);
58 static tree
resolve_args (tree
);
59 static struct z_candidate
*build_user_type_conversion_1 (tree
, tree
, int);
60 static void print_z_candidate (const char *, struct z_candidate
*);
61 static void print_z_candidates (struct z_candidate
*);
62 static tree
build_this (tree
);
63 static struct z_candidate
*splice_viable (struct z_candidate
*, bool, bool *);
64 static bool any_strictly_viable (struct z_candidate
*);
65 static struct z_candidate
*add_template_candidate
66 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
,
67 tree
, tree
, int, unification_kind_t
);
68 static struct z_candidate
*add_template_candidate_real
69 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
,
70 tree
, tree
, int, tree
, unification_kind_t
);
71 static struct z_candidate
*add_template_conv_candidate
72 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
, tree
);
73 static void add_builtin_candidates
74 (struct z_candidate
**, enum tree_code
, enum tree_code
,
76 static void add_builtin_candidate
77 (struct z_candidate
**, enum tree_code
, enum tree_code
,
78 tree
, tree
, tree
, tree
*, tree
*, int);
79 static bool is_complete (tree
);
80 static void build_builtin_candidate
81 (struct z_candidate
**, tree
, tree
, tree
, tree
*, tree
*,
83 static struct z_candidate
*add_conv_candidate
84 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
);
85 static struct z_candidate
*add_function_candidate
86 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
, int);
87 static tree
implicit_conversion (tree
, tree
, tree
, int);
88 static tree
standard_conversion (tree
, tree
, tree
);
89 static tree
reference_binding (tree
, tree
, tree
, int);
90 static tree
build_conv (enum tree_code
, tree
, tree
);
91 static bool is_subseq (tree
, tree
);
92 static tree
maybe_handle_ref_bind (tree
*);
93 static void maybe_handle_implicit_object (tree
*);
94 static struct z_candidate
*add_candidate
95 (struct z_candidate
**, tree
, tree
, tree
, tree
, tree
, int);
96 static tree
source_type (tree
);
97 static void add_warning (struct z_candidate
*, struct z_candidate
*);
98 static bool reference_related_p (tree
, tree
);
99 static bool reference_compatible_p (tree
, tree
);
100 static tree
convert_class_to_reference (tree
, tree
, tree
);
101 static tree
direct_reference_binding (tree
, tree
);
102 static bool promoted_arithmetic_type_p (tree
);
103 static tree
conditional_conversion (tree
, tree
);
104 static char *name_as_c_string (tree
, tree
, bool *);
105 static tree
call_builtin_trap (void);
106 static tree
prep_operand (tree
);
107 static void add_candidates (tree
, tree
, tree
, bool, tree
, tree
,
108 int, struct z_candidate
**);
109 static tree
merge_conversion_sequences (tree
, tree
);
112 build_vfield_ref (tree datum
, tree type
)
114 if (datum
== error_mark_node
)
115 return error_mark_node
;
117 if (TREE_CODE (TREE_TYPE (datum
)) == REFERENCE_TYPE
)
118 datum
= convert_from_reference (datum
);
120 if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type
)
121 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum
), type
))
122 datum
= convert_to_base (datum
, type
, /*check_access=*/false);
124 return build (COMPONENT_REF
, TREE_TYPE (TYPE_VFIELD (type
)),
125 datum
, TYPE_VFIELD (type
));
128 /* Build a call to a member of an object. I.e., one that overloads
129 operator ()(), or is a pointer-to-function or pointer-to-method. */
132 build_field_call (tree instance_ptr
, tree decl
, tree parms
)
136 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
139 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
141 /* If it's a field, try overloading operator (),
142 or calling if the field is a pointer-to-function. */
143 instance
= build_indirect_ref (instance_ptr
, NULL
);
144 instance
= build_class_member_access_expr (instance
, decl
,
145 /*access_path=*/NULL_TREE
,
146 /*preserve_reference=*/false);
148 if (instance
== error_mark_node
)
149 return error_mark_node
;
151 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
152 return build_new_op (CALL_EXPR
, LOOKUP_NORMAL
,
153 instance
, parms
, NULL_TREE
);
154 else if (TREE_CODE (TREE_TYPE (instance
)) == FUNCTION_TYPE
155 || (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
156 && (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
)))
158 return build_function_call (instance
, parms
);
164 /* Returns nonzero iff the destructor name specified in NAME
165 (a BIT_NOT_EXPR) matches BASETYPE. The operand of NAME can take many
169 check_dtor_name (tree basetype
, tree name
)
171 name
= TREE_OPERAND (name
, 0);
173 /* Just accept something we've already complained about. */
174 if (name
== error_mark_node
)
177 if (TREE_CODE (name
) == TYPE_DECL
)
178 name
= TREE_TYPE (name
);
179 else if (TYPE_P (name
))
181 else if (TREE_CODE (name
) == IDENTIFIER_NODE
)
183 if ((IS_AGGR_TYPE (basetype
) && name
== constructor_name (basetype
))
184 || (TREE_CODE (basetype
) == ENUMERAL_TYPE
185 && name
== TYPE_IDENTIFIER (basetype
)))
188 name
= get_type_value (name
);
192 template <class T> struct S { ~S(); };
196 NAME will be a class template. */
197 else if (DECL_CLASS_TEMPLATE_P (name
))
202 if (name
&& TYPE_MAIN_VARIANT (basetype
) == TYPE_MAIN_VARIANT (name
))
207 /* We want the address of a function or method. We avoid creating a
208 pointer-to-member function. */
211 build_addr_func (tree function
)
213 tree type
= TREE_TYPE (function
);
215 /* We have to do these by hand to avoid real pointer to member
217 if (TREE_CODE (type
) == METHOD_TYPE
)
219 if (TREE_CODE (function
) == OFFSET_REF
)
221 tree object
= build_address (TREE_OPERAND (function
, 0));
222 return get_member_function_from_ptrfunc (&object
,
223 TREE_OPERAND (function
, 1));
225 function
= build_address (function
);
228 function
= decay_conversion (function
);
233 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
234 POINTER_TYPE to those. Note, pointer to member function types
235 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
238 build_call (tree function
, tree parms
)
240 int is_constructor
= 0;
247 function
= build_addr_func (function
);
249 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
251 sorry ("unable to call pointer to member function here");
252 return error_mark_node
;
255 fntype
= TREE_TYPE (TREE_TYPE (function
));
256 result_type
= TREE_TYPE (fntype
);
258 if (TREE_CODE (function
) == ADDR_EXPR
259 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
260 decl
= TREE_OPERAND (function
, 0);
264 /* We check both the decl and the type; a function may be known not to
265 throw without being declared throw(). */
266 nothrow
= ((decl
&& TREE_NOTHROW (decl
))
267 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function
))));
269 if (decl
&& TREE_THIS_VOLATILE (decl
) && cfun
)
270 current_function_returns_abnormally
= 1;
272 if (decl
&& TREE_DEPRECATED (decl
))
273 warn_deprecated_use (decl
);
274 require_complete_eh_spec_types (fntype
, decl
);
276 if (decl
&& DECL_CONSTRUCTOR_P (decl
))
279 if (decl
&& ! TREE_USED (decl
))
281 /* We invoke build_call directly for several library functions.
282 These may have been declared normally if we're building libgcc,
283 so we can't just check DECL_ARTIFICIAL. */
284 if (DECL_ARTIFICIAL (decl
)
285 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "__", 2))
291 /* Don't pass empty class objects by value. This is useful
292 for tags in STL, which are used to control overload resolution.
293 We don't need to handle other cases of copying empty classes. */
294 if (! decl
|| ! DECL_BUILT_IN (decl
))
295 for (tmp
= parms
; tmp
; tmp
= TREE_CHAIN (tmp
))
296 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp
)))
297 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp
))))
299 tree t
= build (EMPTY_CLASS_EXPR
, TREE_TYPE (TREE_VALUE (tmp
)));
300 TREE_VALUE (tmp
) = build (COMPOUND_EXPR
, TREE_TYPE (t
),
301 TREE_VALUE (tmp
), t
);
304 function
= build_nt (CALL_EXPR
, function
, parms
, NULL_TREE
);
305 TREE_HAS_CONSTRUCTOR (function
) = is_constructor
;
306 TREE_TYPE (function
) = result_type
;
307 TREE_SIDE_EFFECTS (function
) = 1;
308 TREE_NOTHROW (function
) = nothrow
;
313 /* Build something of the form ptr->method (args)
314 or object.method (args). This can also build
315 calls to constructors, and find friends.
317 Member functions always take their class variable
320 INSTANCE is a class instance.
322 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
324 PARMS help to figure out what that NAME really refers to.
326 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
327 down to the real instance type to use for access checking. We need this
328 information to get protected accesses correct. This parameter is used
329 by build_member_call.
331 FLAGS is the logical disjunction of zero or more LOOKUP_
332 flags. See cp-tree.h for more info.
334 If this is all OK, calls build_function_call with the resolved
337 This function must also handle being called to perform
338 initialization, promotion/coercion of arguments, and
339 instantiation of default parameters.
341 Note that NAME may refer to an instance variable name. If
342 `operator()()' is defined for the type of that field, then we return
345 #ifdef GATHER_STATISTICS
346 extern int n_build_method_call
;
350 build_method_call (tree instance
, tree name
, tree parms
,
351 tree basetype_path
, int flags
)
355 tree template_args
= NULL_TREE
;
356 bool has_template_args
= false;
358 #ifdef GATHER_STATISTICS
359 n_build_method_call
++;
362 if (error_operand_p (instance
)
363 || name
== error_mark_node
364 || parms
== error_mark_node
)
365 return error_mark_node
;
367 my_friendly_assert (!processing_template_decl
, 20030707);
369 if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
370 instance
= convert_from_reference (instance
);
371 object_type
= TREE_TYPE (instance
);
373 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
378 error ("destructors take no parameters");
380 if (! check_dtor_name (object_type
, name
))
382 ("destructor name `~%T' does not match type `%T' of expression",
383 TREE_OPERAND (name
, 0), object_type
);
385 if (! TYPE_HAS_DESTRUCTOR (complete_type (object_type
)))
386 return convert_to_void (instance
, /*implicit=*/NULL
);
387 instance
= default_conversion (instance
);
388 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
389 return build_delete (build_pointer_type (object_type
),
390 instance_ptr
, sfk_complete_destructor
,
391 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0);
394 if (!CLASS_TYPE_P (object_type
))
396 if ((flags
& LOOKUP_COMPLAIN
)
397 && TREE_TYPE (instance
) != error_mark_node
)
398 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
399 name
, instance
, object_type
);
400 return error_mark_node
;
403 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
405 template_args
= TREE_OPERAND (name
, 1);
406 has_template_args
= true;
407 name
= TREE_OPERAND (name
, 0);
409 if (TREE_CODE (name
) == OVERLOAD
)
410 name
= DECL_NAME (get_first_fn (name
));
411 else if (DECL_P (name
))
412 name
= DECL_NAME (name
);
413 if (has_template_args
)
414 fn
= lookup_fnfields (object_type
, name
, /*protect=*/2);
416 fn
= lookup_member (object_type
, name
, /*protect=*/2, /*want_type=*/false);
418 if (fn
&& TREE_CODE (fn
) == TREE_LIST
)
420 error ("request for member `%D' is ambiguous", name
);
421 print_candidates (fn
);
422 return error_mark_node
;
425 /* If the name could not be found, issue an error. */
428 unqualified_name_lookup_error (name
);
429 return error_mark_node
;
432 if (BASELINK_P (fn
) && has_template_args
)
433 BASELINK_FUNCTIONS (fn
)
434 = build_nt (TEMPLATE_ID_EXPR
,
435 BASELINK_FUNCTIONS (fn
),
437 if (BASELINK_P (fn
) && basetype_path
)
438 BASELINK_ACCESS_BINFO (fn
) = basetype_path
;
440 return build_new_method_call (instance
, fn
, parms
,
441 /*conversion_path=*/NULL_TREE
, flags
);
444 /* New overloading code. */
446 struct z_candidate
GTY(()) {
447 /* The FUNCTION_DECL that will be called if this candidate is
448 selected by overload resolution. */
450 /* The arguments to use when calling this function. */
452 /* The implicit conversion sequences for each of the arguments to
455 /* If FN is a user-defined conversion, the standard conversion
456 sequence from the type returned by FN to the desired destination
460 /* If FN is a member function, the binfo indicating the path used to
461 qualify the name of FN at the call site. This path is used to
462 determine whether or not FN is accessible if it is selected by
463 overload resolution. The DECL_CONTEXT of FN will always be a
464 (possibly improper) base of this binfo. */
466 /* If FN is a non-static member function, the binfo indicating the
467 subobject to which the `this' pointer should be converted if FN
468 is selected by overload resolution. The type pointed to the by
469 the `this' pointer must correspond to the most derived class
470 indicated by the CONVERSION_PATH. */
471 tree conversion_path
;
474 struct z_candidate
*next
;
477 #define IDENTITY_RANK 0
483 #define ELLIPSIS_RANK 6
486 #define ICS_RANK(NODE) \
487 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
488 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
489 : ICS_USER_FLAG (NODE) ? USER_RANK \
490 : ICS_STD_RANK (NODE))
492 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
494 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
495 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
496 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
497 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
499 /* In a REF_BIND or a BASE_CONV, this indicates that a temporary
500 should be created to hold the result of the conversion. */
501 #define NEED_TEMPORARY_P(NODE) TREE_LANG_FLAG_4 (NODE)
503 #define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1))
504 #define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
507 null_ptr_cst_p (tree t
)
511 A null pointer constant is an integral constant expression
512 (_expr.const_) rvalue of integer type that evaluates to zero. */
514 || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t
)) && integer_zerop (t
)))
520 /* Returns nonzero if PARMLIST consists of only default parms and/or
524 sufficient_parms_p (tree parmlist
)
526 for (; parmlist
&& parmlist
!= void_list_node
;
527 parmlist
= TREE_CHAIN (parmlist
))
528 if (!TREE_PURPOSE (parmlist
))
534 build_conv (enum tree_code code
, tree type
, tree from
)
537 int rank
= ICS_STD_RANK (from
);
539 /* We can't use buildl1 here because CODE could be USER_CONV, which
540 takes two arguments. In that case, the caller is responsible for
541 filling in the second argument. */
542 t
= make_node (code
);
543 TREE_TYPE (t
) = type
;
544 TREE_OPERAND (t
, 0) = from
;
557 if (rank
< EXACT_RANK
)
563 ICS_STD_RANK (t
) = rank
;
564 ICS_USER_FLAG (t
) = (code
== USER_CONV
|| ICS_USER_FLAG (from
));
565 ICS_BAD_FLAG (t
) = ICS_BAD_FLAG (from
);
570 strip_top_quals (tree t
)
572 if (TREE_CODE (t
) == ARRAY_TYPE
)
574 return TYPE_MAIN_VARIANT (t
);
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. */
582 standard_conversion (tree to
, tree from
, tree expr
)
584 enum tree_code fcode
, tcode
;
586 bool fromref
= false;
588 to
= non_reference (to
);
589 if (TREE_CODE (from
) == REFERENCE_TYPE
)
592 from
= TREE_TYPE (from
);
594 to
= strip_top_quals (to
);
595 from
= strip_top_quals (from
);
597 if ((TYPE_PTRFN_P (to
) || TYPE_PTRMEMFUNC_P (to
))
598 && expr
&& type_unknown_p (expr
))
600 expr
= instantiate_type (to
, expr
, tf_none
);
601 if (expr
== error_mark_node
)
603 from
= TREE_TYPE (expr
);
606 fcode
= TREE_CODE (from
);
607 tcode
= TREE_CODE (to
);
609 conv
= build1 (IDENTITY_CONV
, from
, expr
);
611 if (fcode
== FUNCTION_TYPE
)
613 from
= build_pointer_type (from
);
614 fcode
= TREE_CODE (from
);
615 conv
= build_conv (LVALUE_CONV
, from
, conv
);
617 else if (fcode
== ARRAY_TYPE
)
619 from
= build_pointer_type (TREE_TYPE (from
));
620 fcode
= TREE_CODE (from
);
621 conv
= build_conv (LVALUE_CONV
, from
, conv
);
623 else if (fromref
|| (expr
&& lvalue_p (expr
)))
624 conv
= build_conv (RVALUE_CONV
, from
, conv
);
626 /* Allow conversion between `__complex__' data types */
627 if (tcode
== COMPLEX_TYPE
&& fcode
== COMPLEX_TYPE
)
629 /* The standard conversion sequence to convert FROM to TO is
630 the standard conversion sequence to perform componentwise
632 tree part_conv
= standard_conversion
633 (TREE_TYPE (to
), TREE_TYPE (from
), NULL_TREE
);
637 conv
= build_conv (TREE_CODE (part_conv
), to
, conv
);
638 ICS_STD_RANK (conv
) = ICS_STD_RANK (part_conv
);
646 if (same_type_p (from
, to
))
649 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (to
))
650 && expr
&& null_ptr_cst_p (expr
))
652 conv
= build_conv (STD_CONV
, to
, conv
);
654 else if ((tcode
== INTEGER_TYPE
&& fcode
== POINTER_TYPE
)
655 || (tcode
== POINTER_TYPE
&& fcode
== INTEGER_TYPE
))
657 /* For backwards brain damage compatibility, allow interconversion of
658 pointers and integers with a pedwarn. */
659 conv
= build_conv (STD_CONV
, to
, conv
);
660 ICS_BAD_FLAG (conv
) = 1;
662 else if (tcode
== ENUMERAL_TYPE
&& fcode
== INTEGER_TYPE
663 && TYPE_PRECISION (to
) == TYPE_PRECISION (from
))
665 /* For backwards brain damage compatibility, allow interconversion of
666 enums and integers with a pedwarn. */
667 conv
= build_conv (STD_CONV
, to
, conv
);
668 ICS_BAD_FLAG (conv
) = 1;
670 else if (tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
672 enum tree_code ufcode
= TREE_CODE (TREE_TYPE (from
));
673 enum tree_code utcode
= TREE_CODE (TREE_TYPE (to
));
675 if (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from
),
678 else if (utcode
== VOID_TYPE
&& ufcode
!= OFFSET_TYPE
679 && ufcode
!= FUNCTION_TYPE
)
681 from
= build_pointer_type
682 (cp_build_qualified_type (void_type_node
,
683 cp_type_quals (TREE_TYPE (from
))));
684 conv
= build_conv (PTR_CONV
, from
, conv
);
686 else if (ufcode
== OFFSET_TYPE
&& utcode
== OFFSET_TYPE
)
688 tree fbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (from
));
689 tree tbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (to
));
691 if (DERIVED_FROM_P (fbase
, tbase
)
692 && (same_type_ignoring_top_level_qualifiers_p
693 (TREE_TYPE (TREE_TYPE (from
)),
694 TREE_TYPE (TREE_TYPE (to
)))))
696 from
= build_ptrmem_type (tbase
, TREE_TYPE (TREE_TYPE (from
)));
697 conv
= build_conv (PMEM_CONV
, from
, conv
);
700 else if (IS_AGGR_TYPE (TREE_TYPE (from
))
701 && IS_AGGR_TYPE (TREE_TYPE (to
)))
703 if (DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
706 cp_build_qualified_type (TREE_TYPE (to
),
707 cp_type_quals (TREE_TYPE (from
)));
708 from
= build_pointer_type (from
);
709 conv
= build_conv (PTR_CONV
, from
, conv
);
713 if (same_type_p (from
, to
))
715 else if (comp_ptr_ttypes (TREE_TYPE (to
), TREE_TYPE (from
)))
716 conv
= build_conv (QUAL_CONV
, to
, conv
);
717 else if (expr
&& string_conv_p (to
, expr
, 0))
718 /* converting from string constant to char *. */
719 conv
= build_conv (QUAL_CONV
, to
, conv
);
720 else if (ptr_reasonably_similar (TREE_TYPE (to
), TREE_TYPE (from
)))
722 conv
= build_conv (PTR_CONV
, to
, conv
);
723 ICS_BAD_FLAG (conv
) = 1;
730 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
732 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
733 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
734 tree fbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn
)));
735 tree tbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn
)));
737 if (!DERIVED_FROM_P (fbase
, tbase
)
738 || !same_type_p (TREE_TYPE (fromfn
), TREE_TYPE (tofn
))
739 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)),
740 TREE_CHAIN (TYPE_ARG_TYPES (tofn
)))
741 || cp_type_quals (fbase
) != cp_type_quals (tbase
))
744 from
= cp_build_qualified_type (tbase
, cp_type_quals (fbase
));
745 from
= build_cplus_method_type (from
, TREE_TYPE (fromfn
),
746 TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)));
747 from
= build_ptrmemfunc_type (build_pointer_type (from
));
748 conv
= build_conv (PMEM_CONV
, from
, conv
);
750 else if (tcode
== BOOLEAN_TYPE
)
752 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
753 || fcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (from
)))
756 conv
= build_conv (STD_CONV
, to
, conv
);
757 if (fcode
== POINTER_TYPE
758 || (TYPE_PTRMEMFUNC_P (from
) && ICS_STD_RANK (conv
) < PBOOL_RANK
))
759 ICS_STD_RANK (conv
) = PBOOL_RANK
;
761 /* We don't check for ENUMERAL_TYPE here because there are no standard
762 conversions to enum type. */
763 else if (tcode
== INTEGER_TYPE
|| tcode
== BOOLEAN_TYPE
764 || tcode
== REAL_TYPE
)
766 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
))
768 conv
= build_conv (STD_CONV
, to
, conv
);
770 /* Give this a better rank if it's a promotion. */
771 if (to
== type_promotes_to (from
)
772 && ICS_STD_RANK (TREE_OPERAND (conv
, 0)) <= PROMO_RANK
)
773 ICS_STD_RANK (conv
) = PROMO_RANK
;
775 else if (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
776 && is_properly_derived_from (from
, to
))
778 if (TREE_CODE (conv
) == RVALUE_CONV
)
779 conv
= TREE_OPERAND (conv
, 0);
780 conv
= build_conv (BASE_CONV
, to
, conv
);
781 /* The derived-to-base conversion indicates the initialization
782 of a parameter with base type from an object of a derived
783 type. A temporary object is created to hold the result of
785 NEED_TEMPORARY_P (conv
) = 1;
793 /* Returns nonzero if T1 is reference-related to T2. */
796 reference_related_p (tree t1
, tree t2
)
798 t1
= TYPE_MAIN_VARIANT (t1
);
799 t2
= TYPE_MAIN_VARIANT (t2
);
803 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
804 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
806 return (same_type_p (t1
, t2
)
807 || (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
808 && DERIVED_FROM_P (t1
, t2
)));
811 /* Returns nonzero if T1 is reference-compatible with T2. */
814 reference_compatible_p (tree t1
, tree t2
)
818 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
819 reference-related to T2 and cv1 is the same cv-qualification as,
820 or greater cv-qualification than, cv2. */
821 return (reference_related_p (t1
, t2
)
822 && at_least_as_qualified_p (t1
, t2
));
825 /* Determine whether or not the EXPR (of class type S) can be
826 converted to T as in [over.match.ref]. */
829 convert_class_to_reference (tree t
, tree s
, tree expr
)
835 struct z_candidate
*candidates
;
836 struct z_candidate
*cand
;
839 conversions
= lookup_conversions (s
);
845 Assuming that "cv1 T" is the underlying type of the reference
846 being initialized, and "cv S" is the type of the initializer
847 expression, with S a class type, the candidate functions are
850 --The conversion functions of S and its base classes are
851 considered. Those that are not hidden within S and yield type
852 "reference to cv2 T2", where "cv1 T" is reference-compatible
853 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
855 The argument list has one argument, which is the initializer
860 /* Conceptually, we should take the address of EXPR and put it in
861 the argument list. Unfortunately, however, that can result in
862 error messages, which we should not issue now because we are just
863 trying to find a conversion operator. Therefore, we use NULL,
864 cast to the appropriate type. */
865 arglist
= build_int_2 (0, 0);
866 TREE_TYPE (arglist
) = build_pointer_type (s
);
867 arglist
= build_tree_list (NULL_TREE
, arglist
);
869 reference_type
= build_reference_type (t
);
873 tree fns
= TREE_VALUE (conversions
);
875 for (; fns
; fns
= OVL_NEXT (fns
))
877 tree f
= OVL_CURRENT (fns
);
878 tree t2
= TREE_TYPE (TREE_TYPE (f
));
882 /* If this is a template function, try to get an exact
884 if (TREE_CODE (f
) == TEMPLATE_DECL
)
886 cand
= add_template_candidate (&candidates
,
892 TREE_PURPOSE (conversions
),
898 /* Now, see if the conversion function really returns
899 an lvalue of the appropriate type. From the
900 point of view of unification, simply returning an
901 rvalue of the right type is good enough. */
903 t2
= TREE_TYPE (TREE_TYPE (f
));
904 if (TREE_CODE (t2
) != REFERENCE_TYPE
905 || !reference_compatible_p (t
, TREE_TYPE (t2
)))
907 candidates
= candidates
->next
;
912 else if (TREE_CODE (t2
) == REFERENCE_TYPE
913 && reference_compatible_p (t
, TREE_TYPE (t2
)))
914 cand
= add_function_candidate (&candidates
, f
, s
, arglist
,
916 TREE_PURPOSE (conversions
),
920 /* Build a standard conversion sequence indicating the
921 binding from the reference type returned by the
922 function to the desired REFERENCE_TYPE. */
924 = (direct_reference_binding
926 build1 (IDENTITY_CONV
,
927 TREE_TYPE (TREE_TYPE (TREE_TYPE (cand
->fn
))),
930 conversions
= TREE_CHAIN (conversions
);
933 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
934 /* If none of the conversion functions worked out, let our caller
939 cand
= tourney (candidates
);
943 /* Now that we know that this is the function we're going to use fix
944 the dummy first argument. */
945 cand
->args
= tree_cons (NULL_TREE
,
947 TREE_CHAIN (cand
->args
));
949 /* Build a user-defined conversion sequence representing the
951 conv
= build_conv (USER_CONV
,
952 TREE_TYPE (TREE_TYPE (cand
->fn
)),
953 build1 (IDENTITY_CONV
, TREE_TYPE (expr
), expr
));
954 TREE_OPERAND (conv
, 1) = build_zc_wrapper (cand
);
956 /* Merge it with the standard conversion sequence from the
957 conversion function's return type to the desired type. */
958 cand
->second_conv
= merge_conversion_sequences (conv
, cand
->second_conv
);
960 if (cand
->viable
== -1)
961 ICS_BAD_FLAG (conv
) = 1;
963 return cand
->second_conv
;
966 /* A reference of the indicated TYPE is being bound directly to the
967 expression represented by the implicit conversion sequence CONV.
968 Return a conversion sequence for this binding. */
971 direct_reference_binding (tree type
, tree conv
)
975 my_friendly_assert (TREE_CODE (type
) == REFERENCE_TYPE
, 20030306);
976 my_friendly_assert (TREE_CODE (TREE_TYPE (conv
)) != REFERENCE_TYPE
,
979 t
= TREE_TYPE (type
);
983 When a parameter of reference type binds directly
984 (_dcl.init.ref_) to an argument expression, the implicit
985 conversion sequence is the identity conversion, unless the
986 argument expression has a type that is a derived class of the
987 parameter type, in which case the implicit conversion sequence is
988 a derived-to-base Conversion.
990 If the parameter binds directly to the result of applying a
991 conversion function to the argument expression, the implicit
992 conversion sequence is a user-defined conversion sequence
993 (_over.ics.user_), with the second standard conversion sequence
994 either an identity conversion or, if the conversion function
995 returns an entity of a type that is a derived class of the
996 parameter type, a derived-to-base conversion. */
997 if (!same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (conv
)))
999 /* Represent the derived-to-base conversion. */
1000 conv
= build_conv (BASE_CONV
, t
, conv
);
1001 /* We will actually be binding to the base-class subobject in
1002 the derived class, so we mark this conversion appropriately.
1003 That way, convert_like knows not to generate a temporary. */
1004 NEED_TEMPORARY_P (conv
) = 0;
1006 return build_conv (REF_BIND
, type
, conv
);
1009 /* Returns the conversion path from type FROM to reference type TO for
1010 purposes of reference binding. For lvalue binding, either pass a
1011 reference type to FROM or an lvalue expression to EXPR. If the
1012 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1013 the conversion returned. */
1016 reference_binding (tree rto
, tree rfrom
, tree expr
, int flags
)
1018 tree conv
= NULL_TREE
;
1019 tree to
= TREE_TYPE (rto
);
1023 cp_lvalue_kind lvalue_p
= clk_none
;
1025 if (TREE_CODE (to
) == FUNCTION_TYPE
&& expr
&& type_unknown_p (expr
))
1027 expr
= instantiate_type (to
, expr
, tf_none
);
1028 if (expr
== error_mark_node
)
1030 from
= TREE_TYPE (expr
);
1033 if (TREE_CODE (from
) == REFERENCE_TYPE
)
1035 /* Anything with reference type is an lvalue. */
1036 lvalue_p
= clk_ordinary
;
1037 from
= TREE_TYPE (from
);
1040 lvalue_p
= real_lvalue_p (expr
);
1042 /* Figure out whether or not the types are reference-related and
1043 reference compatible. We have do do this after stripping
1044 references from FROM. */
1045 related_p
= reference_related_p (to
, from
);
1046 compatible_p
= reference_compatible_p (to
, from
);
1048 if (lvalue_p
&& compatible_p
)
1052 If the initializer expression
1054 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1055 is reference-compatible with "cv2 T2,"
1057 the reference is bound directly to the initializer expression
1059 conv
= build1 (IDENTITY_CONV
, from
, expr
);
1060 conv
= direct_reference_binding (rto
, conv
);
1061 if ((lvalue_p
& clk_bitfield
) != 0
1062 && CP_TYPE_CONST_NON_VOLATILE_P (to
))
1063 /* For the purposes of overload resolution, we ignore the fact
1064 this expression is a bitfield. (In particular,
1065 [over.ics.ref] says specifically that a function with a
1066 non-const reference parameter is viable even if the
1067 argument is a bitfield.)
1069 However, when we actually call the function we must create
1070 a temporary to which to bind the reference. If the
1071 reference is volatile, or isn't const, then we cannot make
1072 a temporary, so we just issue an error when the conversion
1074 NEED_TEMPORARY_P (conv
) = 1;
1077 else if (CLASS_TYPE_P (from
) && !(flags
& LOOKUP_NO_CONVERSION
))
1081 If the initializer expression
1083 -- has a class type (i.e., T2 is a class type) can be
1084 implicitly converted to an lvalue of type "cv3 T3," where
1085 "cv1 T1" is reference-compatible with "cv3 T3". (this
1086 conversion is selected by enumerating the applicable
1087 conversion functions (_over.match.ref_) and choosing the
1088 best one through overload resolution. (_over.match_).
1090 the reference is bound to the lvalue result of the conversion
1091 in the second case. */
1092 conv
= convert_class_to_reference (to
, from
, expr
);
1097 /* From this point on, we conceptually need temporaries, even if we
1098 elide them. Only the cases above are "direct bindings". */
1099 if (flags
& LOOKUP_NO_TEMP_BIND
)
1104 When a parameter of reference type is not bound directly to an
1105 argument expression, the conversion sequence is the one required
1106 to convert the argument expression to the underlying type of the
1107 reference according to _over.best.ics_. Conceptually, this
1108 conversion sequence corresponds to copy-initializing a temporary
1109 of the underlying type with the argument expression. Any
1110 difference in top-level cv-qualification is subsumed by the
1111 initialization itself and does not constitute a conversion. */
1115 Otherwise, the reference shall be to a non-volatile const type. */
1116 if (!CP_TYPE_CONST_NON_VOLATILE_P (to
))
1121 If the initializer expression is an rvalue, with T2 a class type,
1122 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1123 is bound in one of the following ways:
1125 -- The reference is bound to the object represented by the rvalue
1126 or to a sub-object within that object.
1130 We use the first alternative. The implicit conversion sequence
1131 is supposed to be same as we would obtain by generating a
1132 temporary. Fortunately, if the types are reference compatible,
1133 then this is either an identity conversion or the derived-to-base
1134 conversion, just as for direct binding. */
1135 if (CLASS_TYPE_P (from
) && compatible_p
)
1137 conv
= build1 (IDENTITY_CONV
, from
, expr
);
1138 return direct_reference_binding (rto
, conv
);
1143 Otherwise, a temporary of type "cv1 T1" is created and
1144 initialized from the initializer expression using the rules for a
1145 non-reference copy initialization. If T1 is reference-related to
1146 T2, cv1 must be the same cv-qualification as, or greater
1147 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1148 if (related_p
&& !at_least_as_qualified_p (to
, from
))
1151 conv
= implicit_conversion (to
, from
, expr
, flags
);
1155 conv
= build_conv (REF_BIND
, rto
, conv
);
1156 /* This reference binding, unlike those above, requires the
1157 creation of a temporary. */
1158 NEED_TEMPORARY_P (conv
) = 1;
1163 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1164 to type TO. The optional expression EXPR may affect the conversion.
1165 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
1169 implicit_conversion (tree to
, tree from
, tree expr
, int flags
)
1173 if (from
== error_mark_node
|| to
== error_mark_node
1174 || expr
== error_mark_node
)
1177 if (TREE_CODE (to
) == REFERENCE_TYPE
)
1178 conv
= reference_binding (to
, from
, expr
, flags
);
1180 conv
= standard_conversion (to
, from
, expr
);
1185 if (expr
!= NULL_TREE
1186 && (IS_AGGR_TYPE (from
)
1187 || IS_AGGR_TYPE (to
))
1188 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
1190 struct z_candidate
*cand
;
1192 cand
= build_user_type_conversion_1
1193 (to
, expr
, LOOKUP_ONLYCONVERTING
);
1195 conv
= cand
->second_conv
;
1197 /* We used to try to bind a reference to a temporary here, but that
1198 is now handled by the recursive call to this function at the end
1199 of reference_binding. */
1206 /* Add a new entry to the list of candidates. Used by the add_*_candidate
1209 static struct z_candidate
*
1210 add_candidate (struct z_candidate
**candidates
,
1211 tree fn
, tree args
, tree convs
, tree access_path
,
1212 tree conversion_path
, int viable
)
1214 struct z_candidate
*cand
1215 = (struct z_candidate
*) ggc_alloc_cleared (sizeof (struct z_candidate
));
1219 cand
->convs
= convs
;
1220 cand
->access_path
= access_path
;
1221 cand
->conversion_path
= conversion_path
;
1222 cand
->viable
= viable
;
1223 cand
->next
= *candidates
;
1229 /* Create an overload candidate for the function or method FN called with
1230 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1231 to implicit_conversion.
1233 CTYPE, if non-NULL, is the type we want to pretend this function
1234 comes from for purposes of overload resolution. */
1236 static struct z_candidate
*
1237 add_function_candidate (struct z_candidate
**candidates
,
1238 tree fn
, tree ctype
, tree arglist
,
1239 tree access_path
, tree conversion_path
,
1242 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1245 tree parmnode
, argnode
;
1249 /* Built-in functions that haven't been declared don't really
1251 if (DECL_ANTICIPATED (fn
))
1254 /* The `this', `in_chrg' and VTT arguments to constructors are not
1255 considered in overload resolution. */
1256 if (DECL_CONSTRUCTOR_P (fn
))
1258 parmlist
= skip_artificial_parms_for (fn
, parmlist
);
1259 orig_arglist
= arglist
;
1260 arglist
= skip_artificial_parms_for (fn
, arglist
);
1263 orig_arglist
= arglist
;
1265 len
= list_length (arglist
);
1266 convs
= make_tree_vec (len
);
1268 /* 13.3.2 - Viable functions [over.match.viable]
1269 First, to be a viable function, a candidate function shall have enough
1270 parameters to agree in number with the arguments in the list.
1272 We need to check this first; otherwise, checking the ICSes might cause
1273 us to produce an ill-formed template instantiation. */
1275 parmnode
= parmlist
;
1276 for (i
= 0; i
< len
; ++i
)
1278 if (parmnode
== NULL_TREE
|| parmnode
== void_list_node
)
1280 parmnode
= TREE_CHAIN (parmnode
);
1283 if (i
< len
&& parmnode
)
1286 /* Make sure there are default args for the rest of the parms. */
1287 else if (!sufficient_parms_p (parmnode
))
1293 /* Second, for F to be a viable function, there shall exist for each
1294 argument an implicit conversion sequence that converts that argument
1295 to the corresponding parameter of F. */
1297 parmnode
= parmlist
;
1300 for (i
= 0; i
< len
; ++i
)
1302 tree arg
= TREE_VALUE (argnode
);
1303 tree argtype
= lvalue_type (arg
);
1307 if (parmnode
== void_list_node
)
1310 is_this
= (i
== 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1311 && ! DECL_CONSTRUCTOR_P (fn
));
1315 tree parmtype
= TREE_VALUE (parmnode
);
1317 /* The type of the implicit object parameter ('this') for
1318 overload resolution is not always the same as for the
1319 function itself; conversion functions are considered to
1320 be members of the class being converted, and functions
1321 introduced by a using-declaration are considered to be
1322 members of the class that uses them.
1324 Since build_over_call ignores the ICS for the `this'
1325 parameter, we can just change the parm type. */
1326 if (ctype
&& is_this
)
1329 = build_qualified_type (ctype
,
1330 TYPE_QUALS (TREE_TYPE (parmtype
)));
1331 parmtype
= build_pointer_type (parmtype
);
1334 t
= implicit_conversion (parmtype
, argtype
, arg
, flags
);
1338 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
1339 ICS_ELLIPSIS_FLAG (t
) = 1;
1343 ICS_THIS_FLAG (t
) = 1;
1345 TREE_VEC_ELT (convs
, i
) = t
;
1352 if (ICS_BAD_FLAG (t
))
1356 parmnode
= TREE_CHAIN (parmnode
);
1357 argnode
= TREE_CHAIN (argnode
);
1361 return add_candidate (candidates
, fn
, orig_arglist
, convs
, access_path
,
1362 conversion_path
, viable
);
1365 /* Create an overload candidate for the conversion function FN which will
1366 be invoked for expression OBJ, producing a pointer-to-function which
1367 will in turn be called with the argument list ARGLIST, and add it to
1368 CANDIDATES. FLAGS is passed on to implicit_conversion.
1370 Actually, we don't really care about FN; we care about the type it
1371 converts to. There may be multiple conversion functions that will
1372 convert to that type, and we rely on build_user_type_conversion_1 to
1373 choose the best one; so when we create our candidate, we record the type
1374 instead of the function. */
1376 static struct z_candidate
*
1377 add_conv_candidate (struct z_candidate
**candidates
, tree fn
, tree obj
,
1378 tree arglist
, tree access_path
, tree conversion_path
)
1380 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
1381 int i
, len
, viable
, flags
;
1382 tree parmlist
, convs
, parmnode
, argnode
;
1384 for (parmlist
= totype
; TREE_CODE (parmlist
) != FUNCTION_TYPE
; )
1385 parmlist
= TREE_TYPE (parmlist
);
1386 parmlist
= TYPE_ARG_TYPES (parmlist
);
1388 len
= list_length (arglist
) + 1;
1389 convs
= make_tree_vec (len
);
1390 parmnode
= parmlist
;
1393 flags
= LOOKUP_NORMAL
;
1395 /* Don't bother looking up the same type twice. */
1396 if (*candidates
&& (*candidates
)->fn
== totype
)
1399 for (i
= 0; i
< len
; ++i
)
1401 tree arg
= i
== 0 ? obj
: TREE_VALUE (argnode
);
1402 tree argtype
= lvalue_type (arg
);
1406 t
= implicit_conversion (totype
, argtype
, arg
, flags
);
1407 else if (parmnode
== void_list_node
)
1410 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
, flags
);
1413 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
1414 ICS_ELLIPSIS_FLAG (t
) = 1;
1417 TREE_VEC_ELT (convs
, i
) = t
;
1421 if (ICS_BAD_FLAG (t
))
1428 parmnode
= TREE_CHAIN (parmnode
);
1429 argnode
= TREE_CHAIN (argnode
);
1435 if (!sufficient_parms_p (parmnode
))
1438 return add_candidate (candidates
, totype
, arglist
, convs
, access_path
,
1439 conversion_path
, viable
);
1443 build_builtin_candidate (struct z_candidate
**candidates
, tree fnname
,
1444 tree type1
, tree type2
, tree
*args
, tree
*argtypes
,
1454 convs
= make_tree_vec (args
[2] ? 3 : (args
[1] ? 2 : 1));
1456 for (i
= 0; i
< 2; ++i
)
1461 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
], flags
);
1465 /* We need something for printing the candidate. */
1466 t
= build1 (IDENTITY_CONV
, types
[i
], NULL_TREE
);
1468 else if (ICS_BAD_FLAG (t
))
1470 TREE_VEC_ELT (convs
, i
) = t
;
1473 /* For COND_EXPR we rearranged the arguments; undo that now. */
1476 TREE_VEC_ELT (convs
, 2) = TREE_VEC_ELT (convs
, 1);
1477 TREE_VEC_ELT (convs
, 1) = TREE_VEC_ELT (convs
, 0);
1478 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2], flags
);
1480 TREE_VEC_ELT (convs
, 0) = t
;
1485 add_candidate (candidates
, fnname
, /*args=*/NULL_TREE
, convs
,
1486 /*access_path=*/NULL_TREE
,
1487 /*conversion_path=*/NULL_TREE
,
1492 is_complete (tree t
)
1494 return COMPLETE_TYPE_P (complete_type (t
));
1497 /* Returns nonzero if TYPE is a promoted arithmetic type. */
1500 promoted_arithmetic_type_p (tree type
)
1504 In this section, the term promoted integral type is used to refer
1505 to those integral types which are preserved by integral promotion
1506 (including e.g. int and long but excluding e.g. char).
1507 Similarly, the term promoted arithmetic type refers to promoted
1508 integral types plus floating types. */
1509 return ((INTEGRAL_TYPE_P (type
)
1510 && same_type_p (type_promotes_to (type
), type
))
1511 || TREE_CODE (type
) == REAL_TYPE
);
1514 /* Create any builtin operator overload candidates for the operator in
1515 question given the converted operand types TYPE1 and TYPE2. The other
1516 args are passed through from add_builtin_candidates to
1517 build_builtin_candidate.
1519 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1520 If CODE is requires candidates operands of the same type of the kind
1521 of which TYPE1 and TYPE2 are, we add both candidates
1522 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1525 add_builtin_candidate (struct z_candidate
**candidates
, enum tree_code code
,
1526 enum tree_code code2
, tree fnname
, tree type1
,
1527 tree type2
, tree
*args
, tree
*argtypes
, int flags
)
1531 case POSTINCREMENT_EXPR
:
1532 case POSTDECREMENT_EXPR
:
1533 args
[1] = integer_zero_node
;
1534 type2
= integer_type_node
;
1543 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1544 and VQ is either volatile or empty, there exist candidate operator
1545 functions of the form
1546 VQ T& operator++(VQ T&);
1547 T operator++(VQ T&, int);
1548 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1549 type other than bool, and VQ is either volatile or empty, there exist
1550 candidate operator functions of the form
1551 VQ T& operator--(VQ T&);
1552 T operator--(VQ T&, int);
1553 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1554 complete object type, and VQ is either volatile or empty, there exist
1555 candidate operator functions of the form
1556 T*VQ& operator++(T*VQ&);
1557 T*VQ& operator--(T*VQ&);
1558 T* operator++(T*VQ&, int);
1559 T* operator--(T*VQ&, int); */
1561 case POSTDECREMENT_EXPR
:
1562 case PREDECREMENT_EXPR
:
1563 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
1565 case POSTINCREMENT_EXPR
:
1566 case PREINCREMENT_EXPR
:
1567 if (ARITHMETIC_TYPE_P (type1
) || TYPE_PTROB_P (type1
))
1569 type1
= build_reference_type (type1
);
1574 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1575 exist candidate operator functions of the form
1579 8 For every function type T, there exist candidate operator functions of
1581 T& operator*(T*); */
1584 if (TREE_CODE (type1
) == POINTER_TYPE
1585 && (TYPE_PTROB_P (type1
)
1586 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
1590 /* 9 For every type T, there exist candidate operator functions of the form
1593 10For every promoted arithmetic type T, there exist candidate operator
1594 functions of the form
1598 case CONVERT_EXPR
: /* unary + */
1599 if (TREE_CODE (type1
) == POINTER_TYPE
1600 && TREE_CODE (TREE_TYPE (type1
)) != OFFSET_TYPE
)
1603 if (ARITHMETIC_TYPE_P (type1
))
1607 /* 11For every promoted integral type T, there exist candidate operator
1608 functions of the form
1612 if (INTEGRAL_TYPE_P (type1
))
1616 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1617 is the same type as C2 or is a derived class of C2, T is a complete
1618 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1619 there exist candidate operator functions of the form
1620 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1621 where CV12 is the union of CV1 and CV2. */
1624 if (TREE_CODE (type1
) == POINTER_TYPE
1625 && (TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
)))
1627 tree c1
= TREE_TYPE (type1
);
1628 tree c2
= (TYPE_PTRMEMFUNC_P (type2
)
1629 ? TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2
)))
1630 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2
)));
1632 if (IS_AGGR_TYPE (c1
) && DERIVED_FROM_P (c2
, c1
)
1633 && (TYPE_PTRMEMFUNC_P (type2
)
1634 || is_complete (TREE_TYPE (TREE_TYPE (type2
)))))
1639 /* 13For every pair of promoted arithmetic types L and R, there exist can-
1640 didate operator functions of the form
1645 bool operator<(L, R);
1646 bool operator>(L, R);
1647 bool operator<=(L, R);
1648 bool operator>=(L, R);
1649 bool operator==(L, R);
1650 bool operator!=(L, R);
1651 where LR is the result of the usual arithmetic conversions between
1654 14For every pair of types T and I, where T is a cv-qualified or cv-
1655 unqualified complete object type and I is a promoted integral type,
1656 there exist candidate operator functions of the form
1657 T* operator+(T*, I);
1658 T& operator[](T*, I);
1659 T* operator-(T*, I);
1660 T* operator+(I, T*);
1661 T& operator[](I, T*);
1663 15For every T, where T is a pointer to complete object type, there exist
1664 candidate operator functions of the form112)
1665 ptrdiff_t operator-(T, T);
1667 16For every pointer or enumeration type T, there exist candidate operator
1668 functions of the form
1669 bool operator<(T, T);
1670 bool operator>(T, T);
1671 bool operator<=(T, T);
1672 bool operator>=(T, T);
1673 bool operator==(T, T);
1674 bool operator!=(T, T);
1676 17For every pointer to member type T, there exist candidate operator
1677 functions of the form
1678 bool operator==(T, T);
1679 bool operator!=(T, T); */
1682 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
1684 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1686 type2
= ptrdiff_type_node
;
1690 case TRUNC_DIV_EXPR
:
1691 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1697 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
1698 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
)))
1700 if ((TYPE_PTRMEMFUNC_P (type1
) || TYPE_PTRMEM_P (type1
))
1701 && null_ptr_cst_p (args
[1]))
1706 if ((TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
))
1707 && null_ptr_cst_p (args
[0]))
1719 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1721 if (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1723 if (TREE_CODE (type1
) == ENUMERAL_TYPE
&& TREE_CODE (type2
) == ENUMERAL_TYPE
)
1725 if (TYPE_PTR_P (type1
) && null_ptr_cst_p (args
[1]))
1730 if (null_ptr_cst_p (args
[0]) && TYPE_PTR_P (type2
))
1738 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1741 if (INTEGRAL_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
1743 type1
= ptrdiff_type_node
;
1746 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1748 type2
= ptrdiff_type_node
;
1753 /* 18For every pair of promoted integral types L and R, there exist candi-
1754 date operator functions of the form
1761 where LR is the result of the usual arithmetic conversions between
1764 case TRUNC_MOD_EXPR
:
1770 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
1774 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1775 type, VQ is either volatile or empty, and R is a promoted arithmetic
1776 type, there exist candidate operator functions of the form
1777 VQ L& operator=(VQ L&, R);
1778 VQ L& operator*=(VQ L&, R);
1779 VQ L& operator/=(VQ L&, R);
1780 VQ L& operator+=(VQ L&, R);
1781 VQ L& operator-=(VQ L&, R);
1783 20For every pair T, VQ), where T is any type and VQ is either volatile
1784 or empty, there exist candidate operator functions of the form
1785 T*VQ& operator=(T*VQ&, T*);
1787 21For every pair T, VQ), where T is a pointer to member type and VQ is
1788 either volatile or empty, there exist candidate operator functions of
1790 VQ T& operator=(VQ T&, T);
1792 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1793 unqualified complete object type, VQ is either volatile or empty, and
1794 I is a promoted integral type, there exist candidate operator func-
1796 T*VQ& operator+=(T*VQ&, I);
1797 T*VQ& operator-=(T*VQ&, I);
1799 23For every triple L, VQ, R), where L is an integral or enumeration
1800 type, VQ is either volatile or empty, and R is a promoted integral
1801 type, there exist candidate operator functions of the form
1803 VQ L& operator%=(VQ L&, R);
1804 VQ L& operator<<=(VQ L&, R);
1805 VQ L& operator>>=(VQ L&, R);
1806 VQ L& operator&=(VQ L&, R);
1807 VQ L& operator^=(VQ L&, R);
1808 VQ L& operator|=(VQ L&, R); */
1815 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
1817 type2
= ptrdiff_type_node
;
1821 case TRUNC_DIV_EXPR
:
1822 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1826 case TRUNC_MOD_EXPR
:
1832 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
1837 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
1839 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
1840 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1841 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
1842 || ((TYPE_PTRMEMFUNC_P (type1
)
1843 || TREE_CODE (type1
) == POINTER_TYPE
)
1844 && null_ptr_cst_p (args
[1])))
1854 type1
= build_reference_type (type1
);
1860 For every pair of promoted arithmetic types L and R, there
1861 exist candidate operator functions of the form
1863 LR operator?(bool, L, R);
1865 where LR is the result of the usual arithmetic conversions
1866 between types L and R.
1868 For every type T, where T is a pointer or pointer-to-member
1869 type, there exist candidate operator functions of the form T
1870 operator?(bool, T, T); */
1872 if (promoted_arithmetic_type_p (type1
)
1873 && promoted_arithmetic_type_p (type2
))
1877 /* Otherwise, the types should be pointers. */
1878 if (!(TREE_CODE (type1
) == POINTER_TYPE
1879 || TYPE_PTRMEM_P (type1
)
1880 || TYPE_PTRMEMFUNC_P (type1
))
1881 || !(TREE_CODE (type2
) == POINTER_TYPE
1882 || TYPE_PTRMEM_P (type2
)
1883 || TYPE_PTRMEMFUNC_P (type2
)))
1886 /* We don't check that the two types are the same; the logic
1887 below will actually create two candidates; one in which both
1888 parameter types are TYPE1, and one in which both parameter
1896 /* If we're dealing with two pointer types or two enumeral types,
1897 we need candidates for both of them. */
1898 if (type2
&& !same_type_p (type1
, type2
)
1899 && TREE_CODE (type1
) == TREE_CODE (type2
)
1900 && (TREE_CODE (type1
) == REFERENCE_TYPE
1901 || (TREE_CODE (type1
) == POINTER_TYPE
1902 && TYPE_PTRMEM_P (type1
) == TYPE_PTRMEM_P (type2
))
1903 || TYPE_PTRMEMFUNC_P (type1
)
1904 || IS_AGGR_TYPE (type1
)
1905 || TREE_CODE (type1
) == ENUMERAL_TYPE
))
1907 build_builtin_candidate
1908 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
);
1909 build_builtin_candidate
1910 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
);
1914 build_builtin_candidate
1915 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
);
1919 type_decays_to (tree type
)
1921 if (TREE_CODE (type
) == ARRAY_TYPE
)
1922 return build_pointer_type (TREE_TYPE (type
));
1923 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1924 return build_pointer_type (type
);
1928 /* There are three conditions of builtin candidates:
1930 1) bool-taking candidates. These are the same regardless of the input.
1931 2) pointer-pair taking candidates. These are generated for each type
1932 one of the input types converts to.
1933 3) arithmetic candidates. According to the standard, we should generate
1934 all of these, but I'm trying not to...
1936 Here we generate a superset of the possible candidates for this particular
1937 case. That is a subset of the full set the standard defines, plus some
1938 other cases which the standard disallows. add_builtin_candidate will
1939 filter out the invalid set. */
1942 add_builtin_candidates (struct z_candidate
**candidates
, enum tree_code code
,
1943 enum tree_code code2
, tree fnname
, tree
*args
,
1948 tree type
, argtypes
[3];
1949 /* TYPES[i] is the set of possible builtin-operator parameter types
1950 we will consider for the Ith argument. These are represented as
1951 a TREE_LIST; the TREE_VALUE of each node is the potential
1955 for (i
= 0; i
< 3; ++i
)
1958 argtypes
[i
] = lvalue_type (args
[i
]);
1960 argtypes
[i
] = NULL_TREE
;
1965 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1966 and VQ is either volatile or empty, there exist candidate operator
1967 functions of the form
1968 VQ T& operator++(VQ T&); */
1970 case POSTINCREMENT_EXPR
:
1971 case PREINCREMENT_EXPR
:
1972 case POSTDECREMENT_EXPR
:
1973 case PREDECREMENT_EXPR
:
1978 /* 24There also exist candidate operator functions of the form
1979 bool operator!(bool);
1980 bool operator&&(bool, bool);
1981 bool operator||(bool, bool); */
1983 case TRUTH_NOT_EXPR
:
1984 build_builtin_candidate
1985 (candidates
, fnname
, boolean_type_node
,
1986 NULL_TREE
, args
, argtypes
, flags
);
1989 case TRUTH_ORIF_EXPR
:
1990 case TRUTH_ANDIF_EXPR
:
1991 build_builtin_candidate
1992 (candidates
, fnname
, boolean_type_node
,
1993 boolean_type_node
, args
, argtypes
, flags
);
2015 types
[0] = types
[1] = NULL_TREE
;
2017 for (i
= 0; i
< 2; ++i
)
2021 else if (IS_AGGR_TYPE (argtypes
[i
]))
2025 if (i
== 0 && code
== MODIFY_EXPR
&& code2
== NOP_EXPR
)
2028 convs
= lookup_conversions (argtypes
[i
]);
2030 if (code
== COND_EXPR
)
2032 if (real_lvalue_p (args
[i
]))
2033 types
[i
] = tree_cons
2034 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
2036 types
[i
] = tree_cons
2037 (NULL_TREE
, TYPE_MAIN_VARIANT (argtypes
[i
]), types
[i
]);
2043 for (; convs
; convs
= TREE_CHAIN (convs
))
2045 type
= TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs
))));
2048 && (TREE_CODE (type
) != REFERENCE_TYPE
2049 || CP_TYPE_CONST_P (TREE_TYPE (type
))))
2052 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
2053 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2055 type
= non_reference (type
);
2056 if (i
!= 0 || ! ref1
)
2058 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
2059 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2060 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2061 if (INTEGRAL_TYPE_P (type
))
2062 type
= type_promotes_to (type
);
2065 if (! value_member (type
, types
[i
]))
2066 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2071 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
2072 types
[i
] = tree_cons
2073 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
2074 type
= non_reference (argtypes
[i
]);
2075 if (i
!= 0 || ! ref1
)
2077 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
2078 if (enum_p
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2079 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2080 if (INTEGRAL_TYPE_P (type
))
2081 type
= type_promotes_to (type
);
2083 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
2087 /* Run through the possible parameter types of both arguments,
2088 creating candidates with those parameter types. */
2089 for (; types
[0]; types
[0] = TREE_CHAIN (types
[0]))
2092 for (type
= types
[1]; type
; type
= TREE_CHAIN (type
))
2093 add_builtin_candidate
2094 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
2095 TREE_VALUE (type
), args
, argtypes
, flags
);
2097 add_builtin_candidate
2098 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
2099 NULL_TREE
, args
, argtypes
, flags
);
2106 /* If TMPL can be successfully instantiated as indicated by
2107 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2109 TMPL is the template. EXPLICIT_TARGS are any explicit template
2110 arguments. ARGLIST is the arguments provided at the call-site.
2111 The RETURN_TYPE is the desired type for conversion operators. If
2112 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2113 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2114 add_conv_candidate. */
2116 static struct z_candidate
*
2117 add_template_candidate_real (struct z_candidate
**candidates
, tree tmpl
,
2118 tree ctype
, tree explicit_targs
, tree arglist
,
2119 tree return_type
, tree access_path
,
2120 tree conversion_path
, int flags
, tree obj
,
2121 unification_kind_t strict
)
2123 int ntparms
= DECL_NTPARMS (tmpl
);
2124 tree targs
= make_tree_vec (ntparms
);
2125 tree args_without_in_chrg
= arglist
;
2126 struct z_candidate
*cand
;
2130 /* We don't do deduction on the in-charge parameter, the VTT
2131 parameter or 'this'. */
2132 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl
))
2133 args_without_in_chrg
= TREE_CHAIN (args_without_in_chrg
);
2135 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl
)
2136 || DECL_BASE_CONSTRUCTOR_P (tmpl
))
2137 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl
)))
2138 args_without_in_chrg
= TREE_CHAIN (args_without_in_chrg
);
2140 i
= fn_type_unification (tmpl
, explicit_targs
, targs
,
2141 args_without_in_chrg
,
2142 return_type
, strict
, -1);
2147 fn
= instantiate_template (tmpl
, targs
, tf_none
);
2148 if (fn
== error_mark_node
)
2153 A member function template is never instantiated to perform the
2154 copy of a class object to an object of its class type.
2156 It's a little unclear what this means; the standard explicitly
2157 does allow a template to be used to copy a class. For example,
2162 template <class T> A(const T&);
2165 void g () { A a (f ()); }
2167 the member template will be used to make the copy. The section
2168 quoted above appears in the paragraph that forbids constructors
2169 whose only parameter is (a possibly cv-qualified variant of) the
2170 class type, and a logical interpretation is that the intent was
2171 to forbid the instantiation of member templates which would then
2173 if (DECL_CONSTRUCTOR_P (fn
) && list_length (arglist
) == 2)
2175 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
2176 if (arg_types
&& same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types
)),
2181 if (obj
!= NULL_TREE
)
2182 /* Aha, this is a conversion function. */
2183 cand
= add_conv_candidate (candidates
, fn
, obj
, access_path
,
2184 conversion_path
, arglist
);
2186 cand
= add_function_candidate (candidates
, fn
, ctype
,
2187 arglist
, access_path
,
2188 conversion_path
, flags
);
2189 if (DECL_TI_TEMPLATE (fn
) != tmpl
)
2190 /* This situation can occur if a member template of a template
2191 class is specialized. Then, instantiate_template might return
2192 an instantiation of the specialization, in which case the
2193 DECL_TI_TEMPLATE field will point at the original
2194 specialization. For example:
2196 template <class T> struct S { template <class U> void f(U);
2197 template <> void f(int) {}; };
2201 Here, TMPL will be template <class U> S<double>::f(U).
2202 And, instantiate template will give us the specialization
2203 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2204 for this will point at template <class T> template <> S<T>::f(int),
2205 so that we can find the definition. For the purposes of
2206 overload resolution, however, we want the original TMPL. */
2207 cand
->template = tree_cons (tmpl
, targs
, NULL_TREE
);
2209 cand
->template = DECL_TEMPLATE_INFO (fn
);
2215 static struct z_candidate
*
2216 add_template_candidate (struct z_candidate
**candidates
, tree tmpl
, tree ctype
,
2217 tree explicit_targs
, tree arglist
, tree return_type
,
2218 tree access_path
, tree conversion_path
, int flags
,
2219 unification_kind_t strict
)
2222 add_template_candidate_real (candidates
, tmpl
, ctype
,
2223 explicit_targs
, arglist
, return_type
,
2224 access_path
, conversion_path
,
2225 flags
, NULL_TREE
, strict
);
2229 static struct z_candidate
*
2230 add_template_conv_candidate (struct z_candidate
**candidates
, tree tmpl
,
2231 tree obj
, tree arglist
, tree return_type
,
2232 tree access_path
, tree conversion_path
)
2235 add_template_candidate_real (candidates
, tmpl
, NULL_TREE
, NULL_TREE
,
2236 arglist
, return_type
, access_path
,
2237 conversion_path
, 0, obj
, DEDUCE_CONV
);
2240 /* The CANDS are the set of candidates that were considered for
2241 overload resolution. Return the set of viable candidates. If none
2242 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2243 is true if a candidate should be considered viable only if it is
2246 static struct z_candidate
*
2247 splice_viable (struct z_candidate
*cands
,
2251 struct z_candidate
*viable
;
2252 struct z_candidate
**last_viable
;
2253 struct z_candidate
**cand
;
2256 last_viable
= &viable
;
2257 *any_viable_p
= false;
2262 struct z_candidate
*c
= *cand
;
2263 if (strict_p
? c
->viable
== 1 : c
->viable
)
2268 last_viable
= &c
->next
;
2269 *any_viable_p
= true;
2275 return viable
? viable
: cands
;
2279 any_strictly_viable (struct z_candidate
*cands
)
2281 for (; cands
; cands
= cands
->next
)
2282 if (cands
->viable
== 1)
2288 build_this (tree obj
)
2290 /* Fix this to work on non-lvalues. */
2291 return build_unary_op (ADDR_EXPR
, obj
, 0);
2294 /* Returns true iff functions are equivalent. Equivalent functions are
2295 not '==' only if one is a function-local extern function or if
2296 both are extern "C". */
2299 equal_functions (tree fn1
, tree fn2
)
2301 if (DECL_LOCAL_FUNCTION_P (fn1
) || DECL_LOCAL_FUNCTION_P (fn2
)
2302 || DECL_EXTERN_C_FUNCTION_P (fn1
))
2303 return decls_match (fn1
, fn2
);
2307 /* Print information about one overload candidate CANDIDATE. MSGSTR
2308 is the text to print before the candidate itself.
2310 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2311 to have been run through gettext by the caller. This wart makes
2312 life simpler in print_z_candidates and for the translators. */
2315 print_z_candidate (const char *msgstr
, struct z_candidate
*candidate
)
2317 if (TREE_CODE (candidate
->fn
) == IDENTIFIER_NODE
)
2319 if (TREE_VEC_LENGTH (candidate
->convs
) == 3)
2320 inform ("%s %D(%T, %T, %T) <built-in>", msgstr
, candidate
->fn
,
2321 TREE_TYPE (TREE_VEC_ELT (candidate
->convs
, 0)),
2322 TREE_TYPE (TREE_VEC_ELT (candidate
->convs
, 1)),
2323 TREE_TYPE (TREE_VEC_ELT (candidate
->convs
, 2)));
2324 else if (TREE_VEC_LENGTH (candidate
->convs
) == 2)
2325 inform ("%s %D(%T, %T) <built-in>", msgstr
, candidate
->fn
,
2326 TREE_TYPE (TREE_VEC_ELT (candidate
->convs
, 0)),
2327 TREE_TYPE (TREE_VEC_ELT (candidate
->convs
, 1)));
2329 inform ("%s %D(%T) <built-in>", msgstr
, candidate
->fn
,
2330 TREE_TYPE (TREE_VEC_ELT (candidate
->convs
, 0)));
2332 else if (TYPE_P (candidate
->fn
))
2333 inform ("%s %T <conversion>", msgstr
, candidate
->fn
);
2334 else if (candidate
->viable
== -1)
2335 inform ("%H%s %+#D <near match>",
2336 &DECL_SOURCE_LOCATION (candidate
->fn
), msgstr
, candidate
->fn
);
2338 inform ("%H%s %+#D",
2339 &DECL_SOURCE_LOCATION (candidate
->fn
), msgstr
, candidate
->fn
);
2343 print_z_candidates (struct z_candidate
*candidates
)
2346 struct z_candidate
*cand1
;
2347 struct z_candidate
**cand2
;
2349 /* There may be duplicates in the set of candidates. We put off
2350 checking this condition as long as possible, since we have no way
2351 to eliminate duplicates from a set of functions in less than n^2
2352 time. Now we are about to emit an error message, so it is more
2353 permissible to go slowly. */
2354 for (cand1
= candidates
; cand1
; cand1
= cand1
->next
)
2356 tree fn
= cand1
->fn
;
2357 /* Skip builtin candidates and conversion functions. */
2358 if (TREE_CODE (fn
) != FUNCTION_DECL
)
2360 cand2
= &cand1
->next
;
2363 if (TREE_CODE ((*cand2
)->fn
) == FUNCTION_DECL
2364 && equal_functions (fn
, (*cand2
)->fn
))
2365 *cand2
= (*cand2
)->next
;
2367 cand2
= &(*cand2
)->next
;
2374 str
= _("candidates are:");
2375 print_z_candidate (str
, candidates
);
2376 if (candidates
->next
)
2378 /* Indent successive candidates by the width of the translation
2379 of the above string. */
2380 size_t len
= gcc_gettext_width (str
) + 1;
2381 char *spaces
= alloca (len
);
2382 memset (spaces
, ' ', len
-1);
2383 spaces
[len
- 1] = '\0';
2385 candidates
= candidates
->next
;
2388 print_z_candidate (spaces
, candidates
);
2389 candidates
= candidates
->next
;
2395 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2396 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2397 the result of the conversion function to convert it to the final
2398 desired type. Merge the the two sequences into a single sequence,
2399 and return the merged sequence. */
2402 merge_conversion_sequences (tree user_seq
, tree std_seq
)
2406 my_friendly_assert (TREE_CODE (user_seq
) == USER_CONV
,
2409 /* Find the end of the second conversion sequence. */
2411 while (TREE_CODE (*t
) != IDENTITY_CONV
)
2412 t
= &TREE_OPERAND (*t
, 0);
2414 /* Replace the identity conversion with the user conversion
2418 /* The entire sequence is a user-conversion sequence. */
2419 ICS_USER_FLAG (std_seq
) = 1;
2424 /* Returns the best overload candidate to perform the requested
2425 conversion. This function is used for three the overloading situations
2426 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2427 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2428 per [dcl.init.ref], so we ignore temporary bindings. */
2430 static struct z_candidate
*
2431 build_user_type_conversion_1 (tree totype
, tree expr
, int flags
)
2433 struct z_candidate
*candidates
, *cand
;
2434 tree fromtype
= TREE_TYPE (expr
);
2435 tree ctors
= NULL_TREE
, convs
= NULL_TREE
;
2436 tree args
= NULL_TREE
;
2439 /* We represent conversion within a hierarchy using RVALUE_CONV and
2440 BASE_CONV, as specified by [over.best.ics]; these become plain
2441 constructor calls, as specified in [dcl.init]. */
2442 my_friendly_assert (!IS_AGGR_TYPE (fromtype
) || !IS_AGGR_TYPE (totype
)
2443 || !DERIVED_FROM_P (totype
, fromtype
), 20011226);
2445 if (IS_AGGR_TYPE (totype
))
2446 ctors
= lookup_fnfields (TYPE_BINFO (totype
),
2447 complete_ctor_identifier
,
2450 if (IS_AGGR_TYPE (fromtype
))
2451 convs
= lookup_conversions (fromtype
);
2454 flags
|= LOOKUP_NO_CONVERSION
;
2460 ctors
= BASELINK_FUNCTIONS (ctors
);
2462 t
= build_int_2 (0, 0);
2463 TREE_TYPE (t
) = build_pointer_type (totype
);
2464 args
= build_tree_list (NULL_TREE
, expr
);
2465 /* We should never try to call the abstract or base constructor
2467 my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors
))
2468 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors
)),
2470 args
= tree_cons (NULL_TREE
, t
, args
);
2472 for (; ctors
; ctors
= OVL_NEXT (ctors
))
2474 tree ctor
= OVL_CURRENT (ctors
);
2475 if (DECL_NONCONVERTING_P (ctor
))
2478 if (TREE_CODE (ctor
) == TEMPLATE_DECL
)
2479 cand
= add_template_candidate (&candidates
, ctor
, totype
,
2480 NULL_TREE
, args
, NULL_TREE
,
2481 TYPE_BINFO (totype
),
2482 TYPE_BINFO (totype
),
2486 cand
= add_function_candidate (&candidates
, ctor
, totype
,
2487 args
, TYPE_BINFO (totype
),
2488 TYPE_BINFO (totype
),
2492 cand
->second_conv
= build1 (IDENTITY_CONV
, totype
, NULL_TREE
);
2496 args
= build_tree_list (NULL_TREE
, build_this (expr
));
2498 for (; convs
; convs
= TREE_CHAIN (convs
))
2501 tree conversion_path
= TREE_PURPOSE (convs
);
2502 int convflags
= LOOKUP_NO_CONVERSION
;
2504 /* If we are called to convert to a reference type, we are trying to
2505 find an lvalue binding, so don't even consider temporaries. If
2506 we don't find an lvalue binding, the caller will try again to
2507 look for a temporary binding. */
2508 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
2509 convflags
|= LOOKUP_NO_TEMP_BIND
;
2511 for (fns
= TREE_VALUE (convs
); fns
; fns
= OVL_NEXT (fns
))
2513 tree fn
= OVL_CURRENT (fns
);
2515 /* [over.match.funcs] For conversion functions, the function
2516 is considered to be a member of the class of the implicit
2517 object argument for the purpose of defining the type of
2518 the implicit object parameter.
2520 So we pass fromtype as CTYPE to add_*_candidate. */
2522 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2523 cand
= add_template_candidate (&candidates
, fn
, fromtype
,
2526 TYPE_BINFO (fromtype
),
2531 cand
= add_function_candidate (&candidates
, fn
, fromtype
,
2533 TYPE_BINFO (fromtype
),
2539 tree ics
= implicit_conversion (totype
,
2540 TREE_TYPE (TREE_TYPE (cand
->fn
)),
2543 cand
->second_conv
= ics
;
2545 if (ics
== NULL_TREE
)
2547 else if (candidates
->viable
== 1 && ICS_BAD_FLAG (ics
))
2553 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
2557 cand
= tourney (candidates
);
2560 if (flags
& LOOKUP_COMPLAIN
)
2562 error ("conversion from `%T' to `%T' is ambiguous",
2564 print_z_candidates (candidates
);
2567 cand
= candidates
; /* any one will do */
2568 cand
->second_conv
= build1 (AMBIG_CONV
, totype
, expr
);
2569 ICS_USER_FLAG (cand
->second_conv
) = 1;
2570 if (!any_strictly_viable (candidates
))
2571 ICS_BAD_FLAG (cand
->second_conv
) = 1;
2572 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2573 ambiguous conversion is no worse than another user-defined
2579 /* Build the user conversion sequence. */
2582 (DECL_CONSTRUCTOR_P (cand
->fn
)
2583 ? totype
: non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)))),
2584 build1 (IDENTITY_CONV
, TREE_TYPE (expr
), expr
));
2585 TREE_OPERAND (convs
, 1) = build_zc_wrapper (cand
);
2587 /* Combine it with the second conversion sequence. */
2588 cand
->second_conv
= merge_conversion_sequences (convs
,
2591 if (cand
->viable
== -1)
2592 ICS_BAD_FLAG (cand
->second_conv
) = 1;
2598 build_user_type_conversion (tree totype
, tree expr
, int flags
)
2600 struct z_candidate
*cand
2601 = build_user_type_conversion_1 (totype
, expr
, flags
);
2605 if (TREE_CODE (cand
->second_conv
) == AMBIG_CONV
)
2606 return error_mark_node
;
2607 return convert_from_reference (convert_like (cand
->second_conv
, expr
));
2612 /* Find the possibly overloaded set of functions corresponding to a
2613 call of the form SCOPE::NAME (...). NAME might be a
2614 TEMPLATE_ID_EXPR, OVERLOAD, _DECL, IDENTIFIER_NODE or LOOKUP_EXPR. */
2617 resolve_scoped_fn_name (tree scope
, tree name
)
2619 tree fn
= NULL_TREE
;
2620 tree template_args
= NULL_TREE
;
2621 bool is_template_id
= TREE_CODE (name
) == TEMPLATE_ID_EXPR
;
2625 template_args
= TREE_OPERAND (name
, 1);
2626 name
= TREE_OPERAND (name
, 0);
2628 if (TREE_CODE (name
) == OVERLOAD
)
2629 name
= DECL_NAME (get_first_fn (name
));
2630 else if (TREE_CODE (name
) == LOOKUP_EXPR
)
2631 name
= TREE_OPERAND (name
, 0);
2633 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
2634 fn
= lookup_namespace_name (scope
, name
);
2635 else if (!CLASS_TYPE_P (scope
))
2637 error ("`%T' is not a class type", scope
);
2638 return error_mark_node
;
2642 if (!TYPE_BEING_DEFINED (scope
)
2643 && !COMPLETE_TYPE_P (complete_type (scope
)))
2645 error ("incomplete type '%T' cannot be used to name a scope",
2647 return error_mark_node
;
2650 if (BASELINK_P (name
))
2653 fn
= lookup_member (scope
, name
, /*protect=*/1, /*want_type=*/false);
2654 if (fn
&& current_class_type
)
2655 fn
= (adjust_result_of_qualified_name_lookup
2656 (fn
, scope
, current_class_type
));
2658 /* It might be the name of a function pointer member. */
2659 if (fn
&& TREE_CODE (fn
) == FIELD_DECL
)
2660 fn
= finish_non_static_data_member (fn
, scope
);
2665 error ("'%D' has no member named '%E'", scope
, name
);
2666 return error_mark_node
;
2672 if (BASELINK_P (fn
))
2673 fns
= BASELINK_FUNCTIONS (fns
);
2674 fns
= build_nt (TEMPLATE_ID_EXPR
, fns
, template_args
);
2675 if (BASELINK_P (fn
))
2676 BASELINK_FUNCTIONS (fn
) = fns
;
2684 /* Do any initial processing on the arguments to a function call. */
2687 resolve_args (tree args
)
2690 for (t
= args
; t
; t
= TREE_CHAIN (t
))
2692 tree arg
= TREE_VALUE (t
);
2694 if (arg
== error_mark_node
)
2695 return error_mark_node
;
2696 else if (VOID_TYPE_P (TREE_TYPE (arg
)))
2698 error ("invalid use of void expression");
2699 return error_mark_node
;
2701 arg
= convert_from_reference (arg
);
2702 TREE_VALUE (t
) = arg
;
2707 /* Perform overload resolution on FN, which is called with the ARGS.
2709 Return the candidate function selected by overload resolution, or
2710 NULL if the event that overload resolution failed. In the case
2711 that overload resolution fails, *CANDIDATES will be the set of
2712 candidates considered, and ANY_VIABLE_P will be set to true or
2713 false to indicate whether or not any of the candidates were
2716 The ARGS should already have gone through RESOLVE_ARGS before this
2717 function is called. */
2719 static struct z_candidate
*
2720 perform_overload_resolution (tree fn
,
2722 struct z_candidate
**candidates
,
2725 struct z_candidate
*cand
;
2726 tree explicit_targs
= NULL_TREE
;
2727 int template_only
= 0;
2730 *any_viable_p
= true;
2732 /* Check FN and ARGS. */
2733 my_friendly_assert (TREE_CODE (fn
) == FUNCTION_DECL
2734 || TREE_CODE (fn
) == TEMPLATE_DECL
2735 || TREE_CODE (fn
) == OVERLOAD
2736 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
,
2738 my_friendly_assert (!args
|| TREE_CODE (args
) == TREE_LIST
,
2741 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2743 explicit_targs
= TREE_OPERAND (fn
, 1);
2744 fn
= TREE_OPERAND (fn
, 0);
2748 /* Add the various candidate functions. */
2749 add_candidates (fn
, args
, explicit_targs
, template_only
,
2750 /*conversion_path=*/NULL_TREE
,
2751 /*access_path=*/NULL_TREE
,
2755 *candidates
= splice_viable (*candidates
, pedantic
, any_viable_p
);
2759 cand
= tourney (*candidates
);
2763 /* Return an expression for a call to FN (a namespace-scope function,
2764 or a static member function) with the ARGS. */
2767 build_new_function_call (tree fn
, tree args
)
2769 struct z_candidate
*candidates
, *cand
;
2772 args
= resolve_args (args
);
2773 if (args
== error_mark_node
)
2774 return error_mark_node
;
2776 cand
= perform_overload_resolution (fn
, args
, &candidates
, &any_viable_p
);
2780 if (!any_viable_p
&& candidates
&& ! candidates
->next
)
2781 return build_function_call (candidates
->fn
, args
);
2782 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2783 fn
= TREE_OPERAND (fn
, 0);
2785 error ("no matching function for call to `%D(%A)'",
2786 DECL_NAME (OVL_CURRENT (fn
)), args
);
2788 error ("call of overloaded `%D(%A)' is ambiguous",
2789 DECL_NAME (OVL_CURRENT (fn
)), args
);
2791 print_z_candidates (candidates
);
2792 return error_mark_node
;
2795 return build_over_call (cand
, LOOKUP_NORMAL
);
2798 /* Build a call to a global operator new. FNNAME is the name of the
2799 operator (either "operator new" or "operator new[]") and ARGS are
2800 the arguments provided. *SIZE points to the total number of bytes
2801 required by the allocation, and is updated if that is changed here.
2802 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2803 function determines that no cookie should be used, after all,
2804 *COOKIE_SIZE is set to NULL_TREE. */
2807 build_operator_new_call (tree fnname
, tree args
, tree
*size
, tree
*cookie_size
)
2810 struct z_candidate
*candidates
;
2811 struct z_candidate
*cand
;
2814 args
= tree_cons (NULL_TREE
, *size
, args
);
2815 args
= resolve_args (args
);
2816 if (args
== error_mark_node
)
2819 fns
= lookup_function_nonclass (fnname
, args
);
2821 /* Figure out what function is being called. */
2822 cand
= perform_overload_resolution (fns
, args
, &candidates
, &any_viable_p
);
2824 /* If no suitable function could be found, issue an error message
2829 error ("no matching function for call to `%D(%A)'",
2830 DECL_NAME (OVL_CURRENT (fns
)), args
);
2832 error ("call of overloaded `%D(%A)' is ambiguous",
2833 DECL_NAME (OVL_CURRENT (fns
)), args
);
2835 print_z_candidates (candidates
);
2836 return error_mark_node
;
2839 /* If a cookie is required, add some extra space. Whether
2840 or not a cookie is required cannot be determined until
2841 after we know which function was called. */
2844 bool use_cookie
= true;
2845 if (!abi_version_at_least (2))
2847 tree placement
= TREE_CHAIN (args
);
2848 /* In G++ 3.2, the check was implemented incorrectly; it
2849 looked at the placement expression, rather than the
2850 type of the function. */
2851 if (placement
&& !TREE_CHAIN (placement
)
2852 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2860 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (cand
->fn
));
2861 /* Skip the size_t parameter. */
2862 arg_types
= TREE_CHAIN (arg_types
);
2863 /* Check the remaining parameters (if any). */
2865 && TREE_CHAIN (arg_types
) == void_list_node
2866 && same_type_p (TREE_VALUE (arg_types
),
2870 /* If we need a cookie, adjust the number of bytes allocated. */
2873 /* Update the total size. */
2874 *size
= size_binop (PLUS_EXPR
, *size
, *cookie_size
);
2875 /* Update the argument list to reflect the adjusted size. */
2876 TREE_VALUE (args
) = *size
;
2879 *cookie_size
= NULL_TREE
;
2882 /* Build the CALL_EXPR. */
2883 return build_over_call (cand
, LOOKUP_NORMAL
);
2887 build_object_call (tree obj
, tree args
)
2889 struct z_candidate
*candidates
= 0, *cand
;
2890 tree fns
, convs
, mem_args
= NULL_TREE
;
2891 tree type
= TREE_TYPE (obj
);
2894 if (TYPE_PTRMEMFUNC_P (type
))
2896 /* It's no good looking for an overloaded operator() on a
2897 pointer-to-member-function. */
2898 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj
);
2899 return error_mark_node
;
2902 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname (CALL_EXPR
), 1);
2903 if (fns
== error_mark_node
)
2904 return error_mark_node
;
2906 args
= resolve_args (args
);
2908 if (args
== error_mark_node
)
2909 return error_mark_node
;
2913 tree base
= BINFO_TYPE (BASELINK_BINFO (fns
));
2914 mem_args
= tree_cons (NULL_TREE
, build_this (obj
), args
);
2916 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
2918 tree fn
= OVL_CURRENT (fns
);
2919 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2920 add_template_candidate (&candidates
, fn
, base
, NULL_TREE
,
2921 mem_args
, NULL_TREE
,
2924 LOOKUP_NORMAL
, DEDUCE_CALL
);
2926 add_function_candidate
2927 (&candidates
, fn
, base
, mem_args
, TYPE_BINFO (type
),
2928 TYPE_BINFO (type
), LOOKUP_NORMAL
);
2932 convs
= lookup_conversions (type
);
2934 for (; convs
; convs
= TREE_CHAIN (convs
))
2936 tree fns
= TREE_VALUE (convs
);
2937 tree totype
= TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns
)));
2939 if ((TREE_CODE (totype
) == POINTER_TYPE
2940 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
2941 || (TREE_CODE (totype
) == REFERENCE_TYPE
2942 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
2943 || (TREE_CODE (totype
) == REFERENCE_TYPE
2944 && TREE_CODE (TREE_TYPE (totype
)) == POINTER_TYPE
2945 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype
))) == FUNCTION_TYPE
))
2946 for (; fns
; fns
= OVL_NEXT (fns
))
2948 tree fn
= OVL_CURRENT (fns
);
2949 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2950 add_template_conv_candidate
2951 (&candidates
, fn
, obj
, args
, totype
,
2952 /*access_path=*/NULL_TREE
,
2953 /*conversion_path=*/NULL_TREE
);
2955 add_conv_candidate (&candidates
, fn
, obj
, args
,
2956 /*conversion_path=*/NULL_TREE
,
2957 /*access_path=*/NULL_TREE
);
2961 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
2964 error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj
), args
);
2965 print_z_candidates (candidates
);
2966 return error_mark_node
;
2969 cand
= tourney (candidates
);
2972 error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj
), args
);
2973 print_z_candidates (candidates
);
2974 return error_mark_node
;
2977 /* Since cand->fn will be a type, not a function, for a conversion
2978 function, we must be careful not to unconditionally look at
2980 if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
2981 && DECL_OVERLOADED_OPERATOR_P (cand
->fn
) == CALL_EXPR
)
2982 return build_over_call (cand
, LOOKUP_NORMAL
);
2984 obj
= convert_like_with_context
2985 (TREE_VEC_ELT (cand
->convs
, 0), obj
, cand
->fn
, -1);
2988 return build_function_call (obj
, args
);
2992 op_error (enum tree_code code
, enum tree_code code2
,
2993 tree arg1
, tree arg2
, tree arg3
, const char *problem
)
2997 if (code
== MODIFY_EXPR
)
2998 opname
= assignment_operator_name_info
[code2
].name
;
3000 opname
= operator_name_info
[code
].name
;
3005 error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
3006 problem
, arg1
, arg2
, arg3
);
3009 case POSTINCREMENT_EXPR
:
3010 case POSTDECREMENT_EXPR
:
3011 error ("%s for 'operator%s' in '%E%s'", problem
, opname
, arg1
, opname
);
3015 error ("%s for 'operator[]' in '%E[%E]'", problem
, arg1
, arg2
);
3020 error ("%s for 'operator%s' in '%E %s %E'",
3021 problem
, opname
, arg1
, opname
, arg2
);
3023 error ("%s for 'operator%s' in '%s%E'",
3024 problem
, opname
, opname
, arg1
);
3029 /* Return the implicit conversion sequence that could be used to
3030 convert E1 to E2 in [expr.cond]. */
3033 conditional_conversion (tree e1
, tree e2
)
3035 tree t1
= non_reference (TREE_TYPE (e1
));
3036 tree t2
= non_reference (TREE_TYPE (e2
));
3042 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3043 implicitly converted (clause _conv_) to the type "reference to
3044 T2", subject to the constraint that in the conversion the
3045 reference must bind directly (_dcl.init.ref_) to E1. */
3046 if (real_lvalue_p (e2
))
3048 conv
= implicit_conversion (build_reference_type (t2
),
3051 LOOKUP_NO_TEMP_BIND
);
3058 If E1 and E2 have class type, and the underlying class types are
3059 the same or one is a base class of the other: E1 can be converted
3060 to match E2 if the class of T2 is the same type as, or a base
3061 class of, the class of T1, and the cv-qualification of T2 is the
3062 same cv-qualification as, or a greater cv-qualification than, the
3063 cv-qualification of T1. If the conversion is applied, E1 is
3064 changed to an rvalue of type T2 that still refers to the original
3065 source class object (or the appropriate subobject thereof).
3067 FIXME we can't express an rvalue that refers to the original object;
3068 we have to create a new one. */
3069 if (CLASS_TYPE_P (t1
) && CLASS_TYPE_P (t2
)
3070 && ((good_base
= DERIVED_FROM_P (t2
, t1
)) || DERIVED_FROM_P (t1
, t2
)))
3072 if (good_base
&& at_least_as_qualified_p (t2
, t1
))
3074 conv
= build1 (IDENTITY_CONV
, t1
, e1
);
3075 if (!same_type_p (TYPE_MAIN_VARIANT (t1
),
3076 TYPE_MAIN_VARIANT (t2
)))
3078 conv
= build_conv (BASE_CONV
, t2
, conv
);
3079 NEED_TEMPORARY_P (conv
) = 1;
3082 conv
= build_conv (RVALUE_CONV
, t2
, conv
);
3091 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3092 converted to the type that expression E2 would have if E2 were
3093 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3094 return implicit_conversion (t2
, t1
, e1
, LOOKUP_NORMAL
);
3097 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3098 arguments to the conditional expression. */
3101 build_conditional_expr (tree arg1
, tree arg2
, tree arg3
)
3106 tree result_type
= NULL_TREE
;
3107 bool lvalue_p
= true;
3108 struct z_candidate
*candidates
= 0;
3109 struct z_candidate
*cand
;
3111 /* As a G++ extension, the second argument to the conditional can be
3112 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3113 c'.) If the second operand is omitted, make sure it is
3114 calculated only once. */
3118 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3120 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3121 if (real_lvalue_p (arg1
))
3122 arg2
= arg1
= stabilize_reference (arg1
);
3124 arg2
= arg1
= save_expr (arg1
);
3129 The first expr ession is implicitly converted to bool (clause
3131 arg1
= cp_convert (boolean_type_node
, arg1
);
3133 /* If something has already gone wrong, just pass that fact up the
3135 if (arg1
== error_mark_node
3136 || arg2
== error_mark_node
3137 || arg3
== error_mark_node
3138 || TREE_TYPE (arg1
) == error_mark_node
3139 || TREE_TYPE (arg2
) == error_mark_node
3140 || TREE_TYPE (arg3
) == error_mark_node
)
3141 return error_mark_node
;
3145 If either the second or the third operand has type (possibly
3146 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3147 array-to-pointer (_conv.array_), and function-to-pointer
3148 (_conv.func_) standard conversions are performed on the second
3149 and third operands. */
3150 arg2_type
= TREE_TYPE (arg2
);
3151 arg3_type
= TREE_TYPE (arg3
);
3152 if (VOID_TYPE_P (arg2_type
) || VOID_TYPE_P (arg3_type
))
3154 /* Do the conversions. We don't these for `void' type arguments
3155 since it can't have any effect and since decay_conversion
3156 does not handle that case gracefully. */
3157 if (!VOID_TYPE_P (arg2_type
))
3158 arg2
= decay_conversion (arg2
);
3159 if (!VOID_TYPE_P (arg3_type
))
3160 arg3
= decay_conversion (arg3
);
3161 arg2_type
= TREE_TYPE (arg2
);
3162 arg3_type
= TREE_TYPE (arg3
);
3166 One of the following shall hold:
3168 --The second or the third operand (but not both) is a
3169 throw-expression (_except.throw_); the result is of the
3170 type of the other and is an rvalue.
3172 --Both the second and the third operands have type void; the
3173 result is of type void and is an rvalue. */
3174 if ((TREE_CODE (arg2
) == THROW_EXPR
)
3175 ^ (TREE_CODE (arg3
) == THROW_EXPR
))
3176 result_type
= ((TREE_CODE (arg2
) == THROW_EXPR
)
3177 ? arg3_type
: arg2_type
);
3178 else if (VOID_TYPE_P (arg2_type
) && VOID_TYPE_P (arg3_type
))
3179 result_type
= void_type_node
;
3182 error ("`%E' has type `void' and is not a throw-expression",
3183 VOID_TYPE_P (arg2_type
) ? arg2
: arg3
);
3184 return error_mark_node
;
3188 goto valid_operands
;
3192 Otherwise, if the second and third operand have different types,
3193 and either has (possibly cv-qualified) class type, an attempt is
3194 made to convert each of those operands to the type of the other. */
3195 else if (!same_type_p (arg2_type
, arg3_type
)
3196 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
3198 tree conv2
= conditional_conversion (arg2
, arg3
);
3199 tree conv3
= conditional_conversion (arg3
, arg2
);
3203 If both can be converted, or one can be converted but the
3204 conversion is ambiguous, the program is ill-formed. If
3205 neither can be converted, the operands are left unchanged and
3206 further checking is performed as described below. If exactly
3207 one conversion is possible, that conversion is applied to the
3208 chosen operand and the converted operand is used in place of
3209 the original operand for the remainder of this section. */
3210 if ((conv2
&& !ICS_BAD_FLAG (conv2
)
3211 && conv3
&& !ICS_BAD_FLAG (conv3
))
3212 || (conv2
&& TREE_CODE (conv2
) == AMBIG_CONV
)
3213 || (conv3
&& TREE_CODE (conv3
) == AMBIG_CONV
))
3215 error ("operands to ?: have different types");
3216 return error_mark_node
;
3218 else if (conv2
&& !ICS_BAD_FLAG (conv2
))
3220 arg2
= convert_like (conv2
, arg2
);
3221 arg2
= convert_from_reference (arg2
);
3222 if (!same_type_p (TREE_TYPE (arg2
), arg3_type
))
3224 arg2_type
= TREE_TYPE (arg2
);
3226 else if (conv3
&& !ICS_BAD_FLAG (conv3
))
3228 arg3
= convert_like (conv3
, arg3
);
3229 arg3
= convert_from_reference (arg3
);
3230 if (!same_type_p (TREE_TYPE (arg3
), arg2_type
))
3232 arg3_type
= TREE_TYPE (arg3
);
3238 If the second and third operands are lvalues and have the same
3239 type, the result is of that type and is an lvalue. */
3240 if (real_lvalue_p (arg2
) && real_lvalue_p (arg3
) &&
3241 same_type_p (arg2_type
, arg3_type
))
3243 result_type
= arg2_type
;
3244 goto valid_operands
;
3249 Otherwise, the result is an rvalue. If the second and third
3250 operand do not have the same type, and either has (possibly
3251 cv-qualified) class type, overload resolution is used to
3252 determine the conversions (if any) to be applied to the operands
3253 (_over.match.oper_, _over.built_). */
3255 if (!same_type_p (arg2_type
, arg3_type
)
3256 && (CLASS_TYPE_P (arg2_type
) || CLASS_TYPE_P (arg3_type
)))
3262 /* Rearrange the arguments so that add_builtin_candidate only has
3263 to know about two args. In build_builtin_candidates, the
3264 arguments are unscrambled. */
3268 add_builtin_candidates (&candidates
,
3271 ansi_opname (COND_EXPR
),
3277 If the overload resolution fails, the program is
3279 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
3282 op_error (COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, "no match");
3283 print_z_candidates (candidates
);
3284 return error_mark_node
;
3286 cand
= tourney (candidates
);
3289 op_error (COND_EXPR
, NOP_EXPR
, arg1
, arg2
, arg3
, "no match");
3290 print_z_candidates (candidates
);
3291 return error_mark_node
;
3296 Otherwise, the conversions thus determined are applied, and
3297 the converted operands are used in place of the original
3298 operands for the remainder of this section. */
3299 conv
= TREE_VEC_ELT (cand
->convs
, 0);
3300 arg1
= convert_like (conv
, arg1
);
3301 conv
= TREE_VEC_ELT (cand
->convs
, 1);
3302 arg2
= convert_like (conv
, arg2
);
3303 conv
= TREE_VEC_ELT (cand
->convs
, 2);
3304 arg3
= convert_like (conv
, arg3
);
3309 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3310 and function-to-pointer (_conv.func_) standard conversions are
3311 performed on the second and third operands.
3313 We need to force the lvalue-to-rvalue conversion here for class types,
3314 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3315 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3318 We use ocp_convert rather than build_user_type_conversion because the
3319 latter returns NULL_TREE on failure, while the former gives an error. */
3321 arg2
= force_rvalue (arg2
);
3322 arg2_type
= TREE_TYPE (arg2
);
3324 arg3
= force_rvalue (arg3
);
3325 arg3_type
= TREE_TYPE (arg3
);
3327 if (arg2
== error_mark_node
|| arg3
== error_mark_node
)
3328 return error_mark_node
;
3332 After those conversions, one of the following shall hold:
3334 --The second and third operands have the same type; the result is of
3336 if (same_type_p (arg2_type
, arg3_type
))
3337 result_type
= arg2_type
;
3340 --The second and third operands have arithmetic or enumeration
3341 type; the usual arithmetic conversions are performed to bring
3342 them to a common type, and the result is of that type. */
3343 else if ((ARITHMETIC_TYPE_P (arg2_type
)
3344 || TREE_CODE (arg2_type
) == ENUMERAL_TYPE
)
3345 && (ARITHMETIC_TYPE_P (arg3_type
)
3346 || TREE_CODE (arg3_type
) == ENUMERAL_TYPE
))
3348 /* In this case, there is always a common type. */
3349 result_type
= type_after_usual_arithmetic_conversions (arg2_type
,
3352 if (TREE_CODE (arg2_type
) == ENUMERAL_TYPE
3353 && TREE_CODE (arg3_type
) == ENUMERAL_TYPE
)
3354 warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3355 arg2_type
, arg3_type
);
3356 else if (extra_warnings
3357 && ((TREE_CODE (arg2_type
) == ENUMERAL_TYPE
3358 && !same_type_p (arg3_type
, type_promotes_to (arg2_type
)))
3359 || (TREE_CODE (arg3_type
) == ENUMERAL_TYPE
3360 && !same_type_p (arg2_type
, type_promotes_to (arg3_type
)))))
3361 warning ("enumeral and non-enumeral type in conditional expression");
3363 arg2
= perform_implicit_conversion (result_type
, arg2
);
3364 arg3
= perform_implicit_conversion (result_type
, arg3
);
3368 --The second and third operands have pointer type, or one has
3369 pointer type and the other is a null pointer constant; pointer
3370 conversions (_conv.ptr_) and qualification conversions
3371 (_conv.qual_) are performed to bring them to their composite
3372 pointer type (_expr.rel_). The result is of the composite
3375 --The second and third operands have pointer to member type, or
3376 one has pointer to member type and the other is a null pointer
3377 constant; pointer to member conversions (_conv.mem_) and
3378 qualification conversions (_conv.qual_) are performed to bring
3379 them to a common type, whose cv-qualification shall match the
3380 cv-qualification of either the second or the third operand.
3381 The result is of the common type. */
3382 else if ((null_ptr_cst_p (arg2
)
3383 && (TYPE_PTR_P (arg3_type
) || TYPE_PTRMEM_P (arg3_type
)
3384 || TYPE_PTRMEMFUNC_P (arg3_type
)))
3385 || (null_ptr_cst_p (arg3
)
3386 && (TYPE_PTR_P (arg2_type
) || TYPE_PTRMEM_P (arg2_type
)
3387 || TYPE_PTRMEMFUNC_P (arg2_type
)))
3388 || (TYPE_PTR_P (arg2_type
) && TYPE_PTR_P (arg3_type
))
3389 || (TYPE_PTRMEM_P (arg2_type
) && TYPE_PTRMEM_P (arg3_type
))
3390 || (TYPE_PTRMEMFUNC_P (arg2_type
)
3391 && TYPE_PTRMEMFUNC_P (arg3_type
)))
3393 result_type
= composite_pointer_type (arg2_type
, arg3_type
, arg2
,
3394 arg3
, "conditional expression");
3395 arg2
= perform_implicit_conversion (result_type
, arg2
);
3396 arg3
= perform_implicit_conversion (result_type
, arg3
);
3401 error ("operands to ?: have different types");
3402 return error_mark_node
;
3406 result
= fold (build (COND_EXPR
, result_type
, arg1
, arg2
, arg3
));
3407 /* We can't use result_type below, as fold might have returned a
3410 /* Expand both sides into the same slot, hopefully the target of the
3411 ?: expression. We used to check for TARGET_EXPRs here, but now we
3412 sometimes wrap them in NOP_EXPRs so the test would fail. */
3413 if (!lvalue_p
&& IS_AGGR_TYPE (TREE_TYPE (result
)))
3414 result
= get_target_expr (result
);
3416 /* If this expression is an rvalue, but might be mistaken for an
3417 lvalue, we must add a NON_LVALUE_EXPR. */
3418 if (!lvalue_p
&& real_lvalue_p (result
))
3419 result
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (result
), result
);
3424 /* OPERAND is an operand to an expression. Perform necessary steps
3425 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3429 prep_operand (tree operand
)
3433 operand
= convert_from_reference (operand
);
3434 if (CLASS_TYPE_P (TREE_TYPE (operand
))
3435 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand
)))
3436 /* Make sure the template type is instantiated now. */
3437 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand
)));
3443 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3444 OVERLOAD) to the CANDIDATES, returning an updated list of
3445 CANDIDATES. The ARGS are the arguments provided to the call,
3446 without any implicit object parameter. The EXPLICIT_TARGS are
3447 explicit template arguments provided. TEMPLATE_ONLY is true if
3448 only template fucntions should be considered. CONVERSION_PATH,
3449 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3452 add_candidates (tree fns
, tree args
,
3453 tree explicit_targs
, bool template_only
,
3454 tree conversion_path
, tree access_path
,
3456 struct z_candidate
**candidates
)
3459 tree non_static_args
;
3461 ctype
= conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
;
3462 /* Delay creating the implicit this parameter until it is needed. */
3463 non_static_args
= NULL_TREE
;
3470 fn
= OVL_CURRENT (fns
);
3471 /* Figure out which set of arguments to use. */
3472 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
3474 /* If this function is a non-static member, prepend the implicit
3475 object parameter. */
3476 if (!non_static_args
)
3477 non_static_args
= tree_cons (NULL_TREE
,
3478 build_this (TREE_VALUE (args
)),
3480 fn_args
= non_static_args
;
3483 /* Otherwise, just use the list of arguments provided. */
3486 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
3487 add_template_candidate (candidates
,
3497 else if (!template_only
)
3498 add_function_candidate (candidates
,
3505 fns
= OVL_NEXT (fns
);
3510 build_new_op (enum tree_code code
, int flags
, tree arg1
, tree arg2
, tree arg3
)
3512 struct z_candidate
*candidates
= 0, *cand
;
3513 tree arglist
, fnname
;
3515 enum tree_code code2
= NOP_EXPR
;
3520 if (error_operand_p (arg1
)
3521 || error_operand_p (arg2
)
3522 || error_operand_p (arg3
))
3523 return error_mark_node
;
3525 if (code
== MODIFY_EXPR
)
3527 code2
= TREE_CODE (arg3
);
3529 fnname
= ansi_assopname (code2
);
3532 fnname
= ansi_opname (code
);
3534 arg1
= prep_operand (arg1
);
3540 case VEC_DELETE_EXPR
:
3542 /* Use build_op_new_call and build_op_delete_call instead. */
3546 return build_object_call (arg1
, arg2
);
3552 arg2
= prep_operand (arg2
);
3553 arg3
= prep_operand (arg3
);
3555 if (code
== COND_EXPR
)
3557 if (arg2
== NULL_TREE
3558 || TREE_CODE (TREE_TYPE (arg2
)) == VOID_TYPE
3559 || TREE_CODE (TREE_TYPE (arg3
)) == VOID_TYPE
3560 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))
3561 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3
))))
3564 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1
))
3565 && (! arg2
|| ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))))
3568 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
3569 arg2
= integer_zero_node
;
3571 arglist
= NULL_TREE
;
3573 arglist
= tree_cons (NULL_TREE
, arg3
, arglist
);
3575 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3576 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3578 /* Add namespace-scope operators to the list of functions to
3580 add_candidates (lookup_function_nonclass (fnname
, arglist
),
3581 arglist
, NULL_TREE
, false, NULL_TREE
, NULL_TREE
,
3582 flags
, &candidates
);
3583 /* Add class-member operators to the candidate set. */
3584 if (CLASS_TYPE_P (TREE_TYPE (arg1
)))
3588 fns
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1
)), fnname
, 1);
3589 if (fns
== error_mark_node
)
3592 add_candidates (BASELINK_FUNCTIONS (fns
), arglist
,
3594 BASELINK_BINFO (fns
),
3595 TYPE_BINFO (TREE_TYPE (arg1
)),
3596 flags
, &candidates
);
3599 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3600 to know about two args; a builtin candidate will always have a first
3601 parameter of type bool. We'll handle that in
3602 build_builtin_candidate. */
3603 if (code
== COND_EXPR
)
3613 args
[2] = NULL_TREE
;
3616 add_builtin_candidates (&candidates
, code
, code2
, fnname
, args
, flags
);
3622 /* For these, the built-in candidates set is empty
3623 [over.match.oper]/3. We don't want non-strict matches
3624 because exact matches are always possible with built-in
3625 operators. The built-in candidate set for COMPONENT_REF
3626 would be empty too, but since there are no such built-in
3627 operators, we accept non-strict matches for them. */
3632 strict_p
= pedantic
;
3636 candidates
= splice_viable (candidates
, strict_p
, &any_viable_p
);
3641 case POSTINCREMENT_EXPR
:
3642 case POSTDECREMENT_EXPR
:
3643 /* Look for an `operator++ (int)'. If they didn't have
3644 one, then we fall back to the old way of doing things. */
3645 if (flags
& LOOKUP_COMPLAIN
)
3646 pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3648 operator_name_info
[code
].name
);
3649 if (code
== POSTINCREMENT_EXPR
)
3650 code
= PREINCREMENT_EXPR
;
3652 code
= PREDECREMENT_EXPR
;
3653 return build_new_op (code
, flags
, arg1
, NULL_TREE
, NULL_TREE
);
3655 /* The caller will deal with these. */
3664 if (flags
& LOOKUP_COMPLAIN
)
3666 op_error (code
, code2
, arg1
, arg2
, arg3
, "no match");
3667 print_z_candidates (candidates
);
3669 return error_mark_node
;
3672 cand
= tourney (candidates
);
3675 if (flags
& LOOKUP_COMPLAIN
)
3677 op_error (code
, code2
, arg1
, arg2
, arg3
, "ambiguous overload");
3678 print_z_candidates (candidates
);
3680 return error_mark_node
;
3683 if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
3686 && fnname
== ansi_assopname (NOP_EXPR
)
3687 && DECL_ARTIFICIAL (cand
->fn
)
3689 && ! candidates
->next
->next
)
3691 warning ("using synthesized `%#D' for copy assignment",
3693 cp_warning_at (" where cfront would use `%#D'",
3695 ? candidates
->next
->fn
3699 return build_over_call (cand
, LOOKUP_NORMAL
);
3702 /* Check for comparison of different enum types. */
3711 if (TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
3712 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
3713 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
3714 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
))))
3716 warning ("comparison between `%#T' and `%#T'",
3717 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
3724 /* We need to strip any leading REF_BIND so that bitfields don't cause
3725 errors. This should not remove any important conversions, because
3726 builtins don't apply to class objects directly. */
3727 conv
= TREE_VEC_ELT (cand
->convs
, 0);
3728 if (TREE_CODE (conv
) == REF_BIND
)
3729 conv
= TREE_OPERAND (conv
, 0);
3730 arg1
= convert_like (conv
, arg1
);
3733 conv
= TREE_VEC_ELT (cand
->convs
, 1);
3734 if (TREE_CODE (conv
) == REF_BIND
)
3735 conv
= TREE_OPERAND (conv
, 0);
3736 arg2
= convert_like (conv
, arg2
);
3740 conv
= TREE_VEC_ELT (cand
->convs
, 2);
3741 if (TREE_CODE (conv
) == REF_BIND
)
3742 conv
= TREE_OPERAND (conv
, 0);
3743 arg3
= convert_like (conv
, arg3
);
3750 return build_modify_expr (arg1
, code2
, arg2
);
3753 return build_indirect_ref (arg1
, "unary *");
3758 case TRUNC_DIV_EXPR
:
3769 case TRUNC_MOD_EXPR
:
3773 case TRUTH_ANDIF_EXPR
:
3774 case TRUTH_ORIF_EXPR
:
3775 return cp_build_binary_op (code
, arg1
, arg2
);
3780 case TRUTH_NOT_EXPR
:
3781 case PREINCREMENT_EXPR
:
3782 case POSTINCREMENT_EXPR
:
3783 case PREDECREMENT_EXPR
:
3784 case POSTDECREMENT_EXPR
:
3787 return build_unary_op (code
, arg1
, candidates
!= 0);
3790 return build_array_ref (arg1
, arg2
);
3793 return build_conditional_expr (arg1
, arg2
, arg3
);
3796 return build_m_component_ref
3797 (build_indirect_ref (arg1
, NULL
), arg2
);
3799 /* The caller will deal with these. */
3811 /* Build a call to operator delete. This has to be handled very specially,
3812 because the restrictions on what signatures match are different from all
3813 other call instances. For a normal delete, only a delete taking (void *)
3814 or (void *, size_t) is accepted. For a placement delete, only an exact
3815 match with the placement new is accepted.
3817 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3818 ADDR is the pointer to be deleted.
3819 SIZE is the size of the memory block to be deleted.
3820 FLAGS are the usual overloading flags.
3821 PLACEMENT is the corresponding placement new call, or NULL_TREE. */
3824 build_op_delete_call (enum tree_code code
, tree addr
, tree size
,
3825 int flags
, tree placement
)
3827 tree fn
= NULL_TREE
;
3828 tree fns
, fnname
, argtypes
, args
, type
;
3831 if (addr
== error_mark_node
)
3832 return error_mark_node
;
3834 type
= strip_array_types (TREE_TYPE (TREE_TYPE (addr
)));
3836 fnname
= ansi_opname (code
);
3838 if (IS_AGGR_TYPE (type
) && ! (flags
& LOOKUP_GLOBAL
))
3841 If the result of the lookup is ambiguous or inaccessible, or if
3842 the lookup selects a placement deallocation function, the
3843 program is ill-formed.
3845 Therefore, we ask lookup_fnfields to complain ambout ambiguity. */
3847 fns
= lookup_fnfields (TYPE_BINFO (type
), fnname
, 1);
3848 if (fns
== error_mark_node
)
3849 return error_mark_node
;
3854 if (fns
== NULL_TREE
)
3855 fns
= lookup_name_nonclass (fnname
);
3862 /* Find the allocation function that is being called. */
3863 call_expr
= placement
;
3864 /* Sometimes we have a COMPOUND_EXPR, rather than a simple
3866 while (TREE_CODE (call_expr
) == COMPOUND_EXPR
)
3867 call_expr
= TREE_OPERAND (call_expr
, 1);
3868 /* Extract the function. */
3869 alloc_fn
= get_callee_fndecl (call_expr
);
3870 my_friendly_assert (alloc_fn
!= NULL_TREE
, 20020327);
3871 /* Then the second parm type. */
3872 argtypes
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn
)));
3873 /* Also the second argument. */
3874 args
= TREE_CHAIN (TREE_OPERAND (call_expr
, 1));
3878 /* First try it without the size argument. */
3879 argtypes
= void_list_node
;
3883 /* Strip const and volatile from addr. */
3884 addr
= cp_convert (ptr_type_node
, addr
);
3886 /* We make two tries at finding a matching `operator delete'. On
3887 the first pass, we look for a one-operator (or placement)
3888 operator delete. If we're not doing placement delete, then on
3889 the second pass we look for a two-argument delete. */
3890 for (pass
= 0; pass
< (placement
? 1 : 2); ++pass
)
3892 /* Go through the `operator delete' functions looking for one
3893 with a matching type. */
3894 for (fn
= BASELINK_P (fns
) ? BASELINK_FUNCTIONS (fns
) : fns
;
3900 /* The first argument must be "void *". */
3901 t
= TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn
)));
3902 if (!same_type_p (TREE_VALUE (t
), ptr_type_node
))
3905 /* On the first pass, check the rest of the arguments. */
3908 while (argtypes
&& t
)
3910 if (!same_type_p (TREE_VALUE (argtypes
),
3913 argtypes
= TREE_CHAIN (argtypes
);
3916 if (!argtypes
&& !t
)
3919 /* On the second pass, the second argument must be
3922 && same_type_p (TREE_VALUE (t
), sizetype
)
3923 && TREE_CHAIN (t
) == void_list_node
)
3927 /* If we found a match, we're done. */
3932 /* If we have a matching function, call it. */
3935 /* Make sure we have the actual function, and not an
3937 fn
= OVL_CURRENT (fn
);
3939 /* If the FN is a member function, make sure that it is
3941 if (DECL_CLASS_SCOPE_P (fn
))
3942 perform_or_defer_access_check (TYPE_BINFO (type
), fn
);
3945 args
= tree_cons (NULL_TREE
, addr
, args
);
3947 args
= tree_cons (NULL_TREE
, addr
,
3948 build_tree_list (NULL_TREE
, size
));
3950 return build_function_call (fn
, args
);
3953 /* If we are doing placement delete we do nothing if we don't find a
3954 matching op delete. */
3958 error ("no suitable `operator %s' for `%T'",
3959 operator_name_info
[(int)code
].name
, type
);
3960 return error_mark_node
;
3963 /* If the current scope isn't allowed to access DECL along
3964 BASETYPE_PATH, give an error. The most derived class in
3965 BASETYPE_PATH is the one used to qualify DECL. */
3968 enforce_access (tree basetype_path
, tree decl
)
3970 my_friendly_assert (TREE_CODE (basetype_path
) == TREE_VEC
, 20030624);
3972 if (!accessible_p (basetype_path
, decl
))
3974 if (TREE_PRIVATE (decl
))
3975 cp_error_at ("`%+#D' is private", decl
);
3976 else if (TREE_PROTECTED (decl
))
3977 cp_error_at ("`%+#D' is protected", decl
);
3979 cp_error_at ("`%+#D' is inaccessible", decl
);
3980 error ("within this context");
3987 /* Perform the conversions in CONVS on the expression EXPR. FN and
3988 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
3989 indicates the `this' argument of a method. INNER is nonzero when
3990 being called to continue a conversion chain. It is negative when a
3991 reference binding will be applied, positive otherwise. If
3992 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
3993 conversions will be emitted if appropriate. */
3996 convert_like_real (tree convs
, tree expr
, tree fn
, int argnum
, int inner
,
3997 bool issue_conversion_warnings
)
4001 tree totype
= TREE_TYPE (convs
);
4003 if (ICS_BAD_FLAG (convs
)
4004 && TREE_CODE (convs
) != USER_CONV
4005 && TREE_CODE (convs
) != AMBIG_CONV
4006 && TREE_CODE (convs
) != REF_BIND
)
4009 for (; t
; t
= TREE_OPERAND (t
, 0))
4011 if (TREE_CODE (t
) == USER_CONV
|| !ICS_BAD_FLAG (t
))
4013 expr
= convert_like_real (t
, expr
, fn
, argnum
, 1,
4014 /*issue_conversion_warnings=*/false);
4017 else if (TREE_CODE (t
) == AMBIG_CONV
)
4018 return convert_like_real (t
, expr
, fn
, argnum
, 1,
4019 /*issue_conversion_warnings=*/false);
4020 else if (TREE_CODE (t
) == IDENTITY_CONV
)
4023 pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr
), totype
);
4025 pedwarn (" initializing argument %P of `%D'", argnum
, fn
);
4026 return cp_convert (totype
, expr
);
4029 if (issue_conversion_warnings
)
4030 expr
= dubious_conversion_warnings
4031 (totype
, expr
, "argument", fn
, argnum
);
4032 switch (TREE_CODE (convs
))
4036 struct z_candidate
*cand
= USER_CONV_CAND (convs
);
4037 tree convfn
= cand
->fn
;
4040 if (DECL_CONSTRUCTOR_P (convfn
))
4042 tree t
= build_int_2 (0, 0);
4043 TREE_TYPE (t
) = build_pointer_type (DECL_CONTEXT (convfn
));
4045 args
= build_tree_list (NULL_TREE
, expr
);
4046 if (DECL_HAS_IN_CHARGE_PARM_P (convfn
)
4047 || DECL_HAS_VTT_PARM_P (convfn
))
4048 /* We should never try to call the abstract or base constructor
4051 args
= tree_cons (NULL_TREE
, t
, args
);
4054 args
= build_this (expr
);
4055 expr
= build_over_call (cand
, LOOKUP_NORMAL
);
4057 /* If this is a constructor or a function returning an aggr type,
4058 we need to build up a TARGET_EXPR. */
4059 if (DECL_CONSTRUCTOR_P (convfn
))
4060 expr
= build_cplus_new (totype
, expr
);
4062 /* The result of the call is then used to direct-initialize the object
4063 that is the destination of the copy-initialization. [dcl.init]
4065 Note that this step is not reflected in the conversion sequence;
4066 it affects the semantics when we actually perform the
4067 conversion, but is not considered during overload resolution.
4069 If the target is a class, that means call a ctor. */
4070 if (IS_AGGR_TYPE (totype
)
4071 && (inner
>= 0 || !lvalue_p (expr
)))
4073 savew
= warningcount
, savee
= errorcount
;
4074 expr
= build_special_member_call
4075 (NULL_TREE
, complete_ctor_identifier
,
4076 build_tree_list (NULL_TREE
, expr
), TYPE_BINFO (totype
),
4077 /* Core issue 84, now a DR, says that we don't allow UDCs
4078 for these args (which deliberately breaks copy-init of an
4079 auto_ptr<Base> from an auto_ptr<Derived>). */
4080 LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
|LOOKUP_NO_CONVERSION
);
4082 /* Tell the user where this failing constructor call came from. */
4085 if (warningcount
> savew
)
4087 (" initializing argument %P of `%D' from result of `%D'",
4088 argnum
, fn
, convfn
);
4089 else if (errorcount
> savee
)
4091 (" initializing argument %P of `%D' from result of `%D'",
4092 argnum
, fn
, convfn
);
4096 if (warningcount
> savew
)
4097 warning (" initializing temporary from result of `%D'",
4099 else if (errorcount
> savee
)
4100 error (" initializing temporary from result of `%D'",
4103 expr
= build_cplus_new (totype
, expr
);
4108 if (type_unknown_p (expr
))
4109 expr
= instantiate_type (totype
, expr
, tf_error
| tf_warning
);
4110 /* Convert a non-array constant variable to its underlying value, unless we
4111 are about to bind it to a reference, in which case we need to
4112 leave it as an lvalue. */
4114 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
4115 expr
= decl_constant_value (expr
);
4118 /* Call build_user_type_conversion again for the error. */
4119 return build_user_type_conversion
4120 (totype
, TREE_OPERAND (convs
, 0), LOOKUP_NORMAL
);
4126 expr
= convert_like_real (TREE_OPERAND (convs
, 0), expr
, fn
, argnum
,
4127 TREE_CODE (convs
) == REF_BIND
? -1 : 1,
4128 /*issue_conversion_warnings=*/false);
4129 if (expr
== error_mark_node
)
4130 return error_mark_node
;
4132 switch (TREE_CODE (convs
))
4135 if (! IS_AGGR_TYPE (totype
))
4137 /* else fall through */
4139 if (TREE_CODE (convs
) == BASE_CONV
&& !NEED_TEMPORARY_P (convs
))
4141 /* We are going to bind a reference directly to a base-class
4142 subobject of EXPR. */
4143 tree base_ptr
= build_pointer_type (totype
);
4145 /* Build an expression for `*((base*) &expr)'. */
4146 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
4147 expr
= perform_implicit_conversion (base_ptr
, expr
);
4148 expr
= build_indirect_ref (expr
, "implicit conversion");
4152 /* Copy-initialization where the cv-unqualified version of the source
4153 type is the same class as, or a derived class of, the class of the
4154 destination [is treated as direct-initialization]. [dcl.init] */
4155 savew
= warningcount
, savee
= errorcount
;
4156 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
4157 build_tree_list (NULL_TREE
, expr
),
4158 TYPE_BINFO (totype
),
4159 LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
);
4162 if (warningcount
> savew
)
4163 warning (" initializing argument %P of `%D'", argnum
, fn
);
4164 else if (errorcount
> savee
)
4165 error (" initializing argument %P of `%D'", argnum
, fn
);
4167 return build_cplus_new (totype
, expr
);
4171 tree ref_type
= totype
;
4173 /* If necessary, create a temporary. */
4174 if (NEED_TEMPORARY_P (convs
) || !non_cast_lvalue_p (expr
))
4176 tree type
= TREE_TYPE (TREE_OPERAND (convs
, 0));
4177 expr
= build_target_expr_with_type (expr
, type
);
4180 /* Take the address of the thing to which we will bind the
4182 expr
= build_unary_op (ADDR_EXPR
, expr
, 1);
4183 if (expr
== error_mark_node
)
4184 return error_mark_node
;
4186 /* Convert it to a pointer to the type referred to by the
4187 reference. This will adjust the pointer if a derived to
4188 base conversion is being performed. */
4189 expr
= cp_convert (build_pointer_type (TREE_TYPE (ref_type
)),
4191 /* Convert the pointer to the desired reference type. */
4192 return build_nop (ref_type
, expr
);
4196 return decay_conversion (expr
);
4199 /* Warn about deprecated conversion if appropriate. */
4200 string_conv_p (totype
, expr
, 1);
4206 return ocp_convert (totype
, expr
, CONV_IMPLICIT
,
4207 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
);
4210 /* Build a call to __builtin_trap which can be used in an expression. */
4213 call_builtin_trap (void)
4215 tree fn
= get_identifier ("__builtin_trap");
4216 if (IDENTIFIER_GLOBAL_VALUE (fn
))
4217 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
4221 fn
= build_call (fn
, NULL_TREE
);
4222 fn
= build (COMPOUND_EXPR
, integer_type_node
, fn
, integer_zero_node
);
4226 /* ARG is being passed to a varargs function. Perform any conversions
4227 required. Return the converted value. */
4230 convert_arg_to_ellipsis (tree arg
)
4234 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4235 standard conversions are performed. */
4236 arg
= decay_conversion (arg
);
4239 If the argument has integral or enumeration type that is subject
4240 to the integral promotions (_conv.prom_), or a floating point
4241 type that is subject to the floating point promotion
4242 (_conv.fpprom_), the value of the argument is converted to the
4243 promoted type before the call. */
4244 if (TREE_CODE (TREE_TYPE (arg
)) == REAL_TYPE
4245 && (TYPE_PRECISION (TREE_TYPE (arg
))
4246 < TYPE_PRECISION (double_type_node
)))
4247 arg
= cp_convert (double_type_node
, arg
);
4248 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
4249 arg
= perform_integral_promotions (arg
);
4251 arg
= require_complete_type (arg
);
4253 if (arg
!= error_mark_node
&& ! pod_type_p (TREE_TYPE (arg
)))
4255 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4256 here and do a bitwise copy, but now cp_expr_size will abort if we
4258 warning ("cannot pass objects of non-POD type `%#T' through `...'; \
4259 call will abort at runtime",
4261 arg
= call_builtin_trap ();
4267 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4270 build_x_va_arg (tree expr
, tree type
)
4272 if (processing_template_decl
)
4273 return build_min (VA_ARG_EXPR
, type
, expr
);
4275 type
= complete_type_or_else (type
, NULL_TREE
);
4277 if (expr
== error_mark_node
|| !type
)
4278 return error_mark_node
;
4280 if (! pod_type_p (type
))
4282 /* Undefined behavior [expr.call] 5.2.2/7. */
4283 warning ("cannot receive objects of non-POD type `%#T' through `...'",
4287 return build_va_arg (expr
, type
);
4290 /* TYPE has been given to va_arg. Apply the default conversions which
4291 would have happened when passed via ellipsis. Return the promoted
4292 type, or the passed type if there is no change. */
4295 cxx_type_promotes_to (tree type
)
4299 if (TREE_CODE (type
) == ARRAY_TYPE
)
4300 return build_pointer_type (TREE_TYPE (type
));
4302 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4303 return build_pointer_type (type
);
4305 promote
= type_promotes_to (type
);
4306 if (same_type_p (type
, promote
))
4312 /* ARG is a default argument expression being passed to a parameter of
4313 the indicated TYPE, which is a parameter to FN. Do any required
4314 conversions. Return the converted value. */
4317 convert_default_arg (tree type
, tree arg
, tree fn
, int parmnum
)
4319 /* If the ARG is an unparsed default argument expression, the
4320 conversion cannot be performed. */
4321 if (TREE_CODE (arg
) == DEFAULT_ARG
)
4323 error ("the default argument for parameter %d of `%D' has "
4324 "not yet been parsed",
4326 return error_mark_node
;
4329 if (fn
&& DECL_TEMPLATE_INFO (fn
))
4330 arg
= tsubst_default_argument (fn
, type
, arg
);
4332 arg
= break_out_target_exprs (arg
);
4334 if (TREE_CODE (arg
) == CONSTRUCTOR
)
4336 arg
= digest_init (type
, arg
, 0);
4337 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4338 "default argument", fn
, parmnum
);
4342 /* This could get clobbered by the following call. */
4343 if (TREE_HAS_CONSTRUCTOR (arg
))
4344 arg
= copy_node (arg
);
4346 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4347 "default argument", fn
, parmnum
);
4348 arg
= convert_for_arg_passing (type
, arg
);
4354 /* Returns the type which will really be used for passing an argument of
4358 type_passed_as (tree type
)
4360 /* Pass classes with copy ctors by invisible reference. */
4361 if (TREE_ADDRESSABLE (type
))
4362 type
= build_reference_type (type
);
4363 else if (PROMOTE_PROTOTYPES
4364 && INTEGRAL_TYPE_P (type
)
4365 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4366 type
= integer_type_node
;
4371 /* Actually perform the appropriate conversion. */
4374 convert_for_arg_passing (tree type
, tree val
)
4376 if (val
== error_mark_node
)
4378 /* Pass classes with copy ctors by invisible reference. */
4379 else if (TREE_ADDRESSABLE (type
))
4380 val
= build1 (ADDR_EXPR
, build_reference_type (type
), val
);
4381 else if (PROMOTE_PROTOTYPES
4382 && INTEGRAL_TYPE_P (type
)
4383 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4384 val
= perform_integral_promotions (val
);
4388 /* Subroutine of the various build_*_call functions. Overload resolution
4389 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4390 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4391 bitmask of various LOOKUP_* flags which apply to the call itself. */
4394 build_over_call (struct z_candidate
*cand
, int flags
)
4397 tree args
= cand
->args
;
4398 tree convs
= cand
->convs
;
4399 tree converted_args
= NULL_TREE
;
4400 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
4401 tree conv
, arg
, val
;
4405 /* Give any warnings we noticed during overload resolution. */
4407 for (val
= cand
->warnings
; val
; val
= TREE_CHAIN (val
))
4408 joust (cand
, WRAPPER_ZC (TREE_VALUE (val
)), 1);
4410 if (DECL_FUNCTION_MEMBER_P (fn
))
4411 perform_or_defer_access_check (cand
->access_path
, fn
);
4413 if (args
&& TREE_CODE (args
) != TREE_LIST
)
4414 args
= build_tree_list (NULL_TREE
, args
);
4417 /* The implicit parameters to a constructor are not considered by overload
4418 resolution, and must be of the proper type. */
4419 if (DECL_CONSTRUCTOR_P (fn
))
4421 converted_args
= tree_cons (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
4422 arg
= TREE_CHAIN (arg
);
4423 parm
= TREE_CHAIN (parm
);
4424 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
4425 /* We should never try to call the abstract constructor. */
4427 if (DECL_HAS_VTT_PARM_P (fn
))
4429 converted_args
= tree_cons
4430 (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
4431 arg
= TREE_CHAIN (arg
);
4432 parm
= TREE_CHAIN (parm
);
4435 /* Bypass access control for 'this' parameter. */
4436 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4438 tree parmtype
= TREE_VALUE (parm
);
4439 tree argtype
= TREE_TYPE (TREE_VALUE (arg
));
4443 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs
, i
)))
4444 pedwarn ("passing `%T' as `this' argument of `%#D' discards qualifiers",
4445 TREE_TYPE (argtype
), fn
);
4447 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4448 X is called for an object that is not of type X, or of a type
4449 derived from X, the behavior is undefined.
4451 So we can assume that anything passed as 'this' is non-null, and
4452 optimize accordingly. */
4453 my_friendly_assert (TREE_CODE (parmtype
) == POINTER_TYPE
, 19990811);
4454 /* Convert to the base in which the function was declared. */
4455 my_friendly_assert (cand
->conversion_path
!= NULL_TREE
, 20020730);
4456 converted_arg
= build_base_path (PLUS_EXPR
,
4458 cand
->conversion_path
,
4460 /* If fn was found by a using declaration, the conversion path
4461 will be to the derived class, not the base declaring fn. We
4462 must convert from derived to base. */
4463 base_binfo
= lookup_base (TREE_TYPE (TREE_TYPE (converted_arg
)),
4464 TREE_TYPE (parmtype
), ba_ignore
, NULL
);
4466 converted_arg
= build_base_path (PLUS_EXPR
, converted_arg
,
4469 converted_args
= tree_cons (NULL_TREE
, converted_arg
, converted_args
);
4470 parm
= TREE_CHAIN (parm
);
4471 arg
= TREE_CHAIN (arg
);
4477 parm
= TREE_CHAIN (parm
), arg
= TREE_CHAIN (arg
), ++i
)
4479 tree type
= TREE_VALUE (parm
);
4481 conv
= TREE_VEC_ELT (convs
, i
);
4482 val
= convert_like_with_context
4483 (conv
, TREE_VALUE (arg
), fn
, i
- is_method
);
4485 val
= convert_for_arg_passing (type
, val
);
4486 converted_args
= tree_cons (NULL_TREE
, val
, converted_args
);
4489 /* Default arguments */
4490 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
), i
++)
4492 = tree_cons (NULL_TREE
,
4493 convert_default_arg (TREE_VALUE (parm
),
4494 TREE_PURPOSE (parm
),
4499 for (; arg
; arg
= TREE_CHAIN (arg
))
4501 = tree_cons (NULL_TREE
,
4502 convert_arg_to_ellipsis (TREE_VALUE (arg
)),
4505 converted_args
= nreverse (converted_args
);
4508 check_function_format (NULL
, TYPE_ATTRIBUTES (TREE_TYPE (fn
)),
4511 /* Avoid actually calling copy constructors and copy assignment operators,
4514 if (! flag_elide_constructors
)
4515 /* Do things the hard way. */;
4516 else if (TREE_VEC_LENGTH (convs
) == 1
4517 && DECL_COPY_CONSTRUCTOR_P (fn
))
4520 arg
= skip_artificial_parms_for (fn
, converted_args
);
4521 arg
= TREE_VALUE (arg
);
4523 /* Pull out the real argument, disregarding const-correctness. */
4525 while (TREE_CODE (targ
) == NOP_EXPR
4526 || TREE_CODE (targ
) == NON_LVALUE_EXPR
4527 || TREE_CODE (targ
) == CONVERT_EXPR
)
4528 targ
= TREE_OPERAND (targ
, 0);
4529 if (TREE_CODE (targ
) == ADDR_EXPR
)
4531 targ
= TREE_OPERAND (targ
, 0);
4532 if (!same_type_ignoring_top_level_qualifiers_p
4533 (TREE_TYPE (TREE_TYPE (arg
)), TREE_TYPE (targ
)))
4542 arg
= build_indirect_ref (arg
, 0);
4544 /* [class.copy]: the copy constructor is implicitly defined even if
4545 the implementation elided its use. */
4546 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn
)))
4549 /* If we're creating a temp and we already have one, don't create a
4550 new one. If we're not creating a temp but we get one, use
4551 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4552 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4553 temp or an INIT_EXPR otherwise. */
4554 if (integer_zerop (TREE_VALUE (args
)))
4556 if (TREE_CODE (arg
) == TARGET_EXPR
)
4558 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
4559 return build_target_expr_with_type (arg
, DECL_CONTEXT (fn
));
4561 else if (TREE_CODE (arg
) == TARGET_EXPR
4562 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
4565 tree to
= stabilize_reference
4566 (build_indirect_ref (TREE_VALUE (args
), 0));
4568 val
= build (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
4569 address
= build_unary_op (ADDR_EXPR
, val
, 0);
4570 /* Avoid a warning about this expression, if the address is
4572 TREE_USED (address
) = 1;
4576 else if (DECL_OVERLOADED_OPERATOR_P (fn
) == NOP_EXPR
4578 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn
)))
4580 tree to
= stabilize_reference
4581 (build_indirect_ref (TREE_VALUE (converted_args
), 0));
4583 arg
= build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args
)), 0);
4584 val
= build (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
4590 if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
4592 tree t
, *p
= &TREE_VALUE (converted_args
);
4593 tree binfo
= lookup_base (TREE_TYPE (TREE_TYPE (*p
)),
4596 my_friendly_assert (binfo
&& binfo
!= error_mark_node
, 20010730);
4598 *p
= build_base_path (PLUS_EXPR
, *p
, binfo
, 1);
4599 if (TREE_SIDE_EFFECTS (*p
))
4600 *p
= save_expr (*p
);
4601 t
= build_pointer_type (TREE_TYPE (fn
));
4602 if (DECL_CONTEXT (fn
) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn
)))
4603 fn
= build_java_interface_fn_ref (fn
, *p
);
4605 fn
= build_vfn_ref (build_indirect_ref (*p
, 0), DECL_VINDEX (fn
));
4608 else if (DECL_INLINE (fn
))
4609 fn
= inline_conversion (fn
);
4611 fn
= build_addr_func (fn
);
4613 return build_cxx_call (fn
, args
, converted_args
);
4616 /* Build and return a call to FN, using the the CONVERTED_ARGS. ARGS
4617 gives the original form of the arguments. This function performs
4618 no overload resolution, conversion, or other high-level
4622 build_cxx_call(tree fn
, tree args
, tree converted_args
)
4626 /* Recognize certain built-in functions so we can make tree-codes
4627 other than CALL_EXPR. We do this when it enables fold-const.c
4628 to do something useful. */
4629 if (TREE_CODE (fn
) == ADDR_EXPR
4630 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
4631 && DECL_BUILT_IN (TREE_OPERAND (fn
, 0)))
4634 exp
= expand_tree_builtin (TREE_OPERAND (fn
, 0), args
, converted_args
);
4639 fn
= build_call (fn
, converted_args
);
4641 /* If this call might throw an exception, note that fact. */
4642 fndecl
= get_callee_fndecl (fn
);
4643 if ((!fndecl
|| !TREE_NOTHROW (fndecl
))
4644 && at_function_scope_p ()
4646 cp_function_chain
->can_throw
= 1;
4648 /* Some built-in function calls will be evaluated at compile-time in
4652 if (VOID_TYPE_P (TREE_TYPE (fn
)))
4655 fn
= require_complete_type (fn
);
4656 if (fn
== error_mark_node
)
4657 return error_mark_node
;
4659 if (IS_AGGR_TYPE (TREE_TYPE (fn
)))
4660 fn
= build_cplus_new (TREE_TYPE (fn
), fn
);
4661 return convert_from_reference (fn
);
4664 static GTY(()) tree java_iface_lookup_fn
;
4666 /* Make an expression which yields the address of the Java interface
4667 method FN. This is achieved by generating a call to libjava's
4668 _Jv_LookupInterfaceMethodIdx(). */
4671 build_java_interface_fn_ref (tree fn
, tree instance
)
4673 tree lookup_args
, lookup_fn
, method
, idx
;
4674 tree klass_ref
, iface
, iface_ref
;
4677 if (!java_iface_lookup_fn
)
4679 tree endlink
= build_void_list_node ();
4680 tree t
= tree_cons (NULL_TREE
, ptr_type_node
,
4681 tree_cons (NULL_TREE
, ptr_type_node
,
4682 tree_cons (NULL_TREE
, java_int_type_node
,
4684 java_iface_lookup_fn
4685 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
4686 build_function_type (ptr_type_node
, t
),
4687 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
4690 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
4691 This is the first entry in the vtable. */
4692 klass_ref
= build_vtbl_ref (build_indirect_ref (instance
, 0),
4695 /* Get the java.lang.Class pointer for the interface being called. */
4696 iface
= DECL_CONTEXT (fn
);
4697 iface_ref
= lookup_field (iface
, get_identifier ("class$"), 0, false);
4698 if (!iface_ref
|| TREE_CODE (iface_ref
) != VAR_DECL
4699 || DECL_CONTEXT (iface_ref
) != iface
)
4701 error ("could not find class$ field in java interface type `%T'",
4703 return error_mark_node
;
4705 iface_ref
= build1 (ADDR_EXPR
, build_pointer_type (iface
), iface_ref
);
4707 /* Determine the itable index of FN. */
4709 for (method
= TYPE_METHODS (iface
); method
; method
= TREE_CHAIN (method
))
4711 if (!DECL_VIRTUAL_P (method
))
4717 idx
= build_int_2 (i
, 0);
4719 lookup_args
= tree_cons (NULL_TREE
, klass_ref
,
4720 tree_cons (NULL_TREE
, iface_ref
,
4721 build_tree_list (NULL_TREE
, idx
)));
4722 lookup_fn
= build1 (ADDR_EXPR
,
4723 build_pointer_type (TREE_TYPE (java_iface_lookup_fn
)),
4724 java_iface_lookup_fn
);
4725 return build (CALL_EXPR
, ptr_type_node
, lookup_fn
, lookup_args
, NULL_TREE
);
4728 /* Returns the value to use for the in-charge parameter when making a
4729 call to a function with the indicated NAME. */
4732 in_charge_arg_for_name (tree name
)
4734 if (name
== base_ctor_identifier
4735 || name
== base_dtor_identifier
)
4736 return integer_zero_node
;
4737 else if (name
== complete_ctor_identifier
)
4738 return integer_one_node
;
4739 else if (name
== complete_dtor_identifier
)
4740 return integer_two_node
;
4741 else if (name
== deleting_dtor_identifier
)
4742 return integer_three_node
;
4744 /* This function should only be called with one of the names listed
4750 /* Build a call to a constructor, destructor, or an assignment
4751 operator for INSTANCE, an expression with class type. NAME
4752 indicates the special member function to call; ARGS are the
4753 arguments. BINFO indicates the base of INSTANCE that is to be
4754 passed as the `this' parameter to the member function called.
4756 FLAGS are the LOOKUP_* flags to use when processing the call.
4758 If NAME indicates a complete object constructor, INSTANCE may be
4759 NULL_TREE. In this case, the caller will call build_cplus_new to
4760 store the newly constructed object into a VAR_DECL. */
4763 build_special_member_call (tree instance
, tree name
, tree args
,
4764 tree binfo
, int flags
)
4767 /* The type of the subobject to be constructed or destroyed. */
4770 my_friendly_assert (name
== complete_ctor_identifier
4771 || name
== base_ctor_identifier
4772 || name
== complete_dtor_identifier
4773 || name
== base_dtor_identifier
4774 || name
== deleting_dtor_identifier
4775 || name
== ansi_assopname (NOP_EXPR
),
4777 my_friendly_assert (binfo
!= NULL_TREE
, 20020712);
4779 class_type
= BINFO_TYPE (binfo
);
4781 /* Handle the special case where INSTANCE is NULL_TREE. */
4782 if (name
== complete_ctor_identifier
&& !instance
)
4784 instance
= build_int_2 (0, 0);
4785 TREE_TYPE (instance
) = build_pointer_type (class_type
);
4786 instance
= build1 (INDIRECT_REF
, class_type
, instance
);
4788 else if (name
== complete_dtor_identifier
4789 || name
== base_dtor_identifier
4790 || name
== deleting_dtor_identifier
)
4791 my_friendly_assert (args
== NULL_TREE
, 20020712);
4793 my_friendly_assert (instance
!= NULL_TREE
, 20020712);
4795 /* Resolve the name. */
4796 if (!complete_type_or_else (BINFO_TYPE (binfo
), NULL_TREE
))
4797 return error_mark_node
;
4799 fns
= lookup_fnfields (binfo
, name
, 1);
4801 /* When making a call to a constructor or destructor for a subobject
4802 that uses virtual base classes, pass down a pointer to a VTT for
4804 if ((name
== base_ctor_identifier
4805 || name
== base_dtor_identifier
)
4806 && TYPE_USES_VIRTUAL_BASECLASSES (class_type
))
4811 /* If the current function is a complete object constructor
4812 or destructor, then we fetch the VTT directly.
4813 Otherwise, we look it up using the VTT we were given. */
4814 vtt
= TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type
));
4815 vtt
= decay_conversion (vtt
);
4816 vtt
= build (COND_EXPR
, TREE_TYPE (vtt
),
4817 build (EQ_EXPR
, boolean_type_node
,
4818 current_in_charge_parm
, integer_zero_node
),
4821 my_friendly_assert (BINFO_SUBVTT_INDEX (binfo
), 20010110);
4822 sub_vtt
= build (PLUS_EXPR
, TREE_TYPE (vtt
), vtt
,
4823 BINFO_SUBVTT_INDEX (binfo
));
4825 args
= tree_cons (NULL_TREE
, sub_vtt
, args
);
4828 return build_new_method_call (instance
, fns
, args
, binfo
, flags
);
4831 /* Return the NAME, as a C string. The NAME indicates a function that
4832 is a member of TYPE. *FREE_P is set to true if the caller must
4833 free the memory returned.
4835 Rather than go through all of this, we should simply set the names
4836 of constructors and destructors appropriately, and dispense with
4837 ctor_identifier, dtor_identifier, etc. */
4840 name_as_c_string (tree name
, tree type
, bool *free_p
)
4844 /* Assume that we will not allocate memory. */
4846 /* Constructors and destructors are special. */
4847 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
4850 = (char *) IDENTIFIER_POINTER (constructor_name (type
));
4851 /* For a destructor, add the '~'. */
4852 if (name
== complete_dtor_identifier
4853 || name
== base_dtor_identifier
4854 || name
== deleting_dtor_identifier
)
4856 pretty_name
= concat ("~", pretty_name
, NULL
);
4857 /* Remember that we need to free the memory allocated. */
4862 pretty_name
= (char *) IDENTIFIER_POINTER (name
);
4867 /* Build a call to "INSTANCE.FN (ARGS)". */
4870 build_new_method_call (tree instance
, tree fns
, tree args
,
4871 tree conversion_path
, int flags
)
4873 struct z_candidate
*candidates
= 0, *cand
;
4874 tree explicit_targs
= NULL_TREE
;
4875 tree basetype
= NULL_TREE
;
4878 tree mem_args
= NULL_TREE
, instance_ptr
;
4884 int template_only
= 0;
4887 my_friendly_assert (instance
!= NULL_TREE
, 20020729);
4889 if (error_operand_p (instance
)
4890 || error_operand_p (fns
)
4891 || args
== error_mark_node
)
4892 return error_mark_node
;
4894 /* Process the argument list. */
4896 args
= resolve_args (args
);
4897 if (args
== error_mark_node
)
4898 return error_mark_node
;
4900 if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
4901 instance
= convert_from_reference (instance
);
4902 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (instance
));
4903 instance_ptr
= build_this (instance
);
4905 if (!BASELINK_P (fns
))
4907 call
= build_field_call (instance_ptr
, fns
, args
);
4910 error ("call to non-function `%D'", fns
);
4911 return error_mark_node
;
4914 if (!conversion_path
)
4915 conversion_path
= BASELINK_BINFO (fns
);
4916 access_binfo
= BASELINK_ACCESS_BINFO (fns
);
4917 optype
= BASELINK_OPTYPE (fns
);
4918 fns
= BASELINK_FUNCTIONS (fns
);
4920 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
4922 explicit_targs
= TREE_OPERAND (fns
, 1);
4923 fns
= TREE_OPERAND (fns
, 0);
4927 my_friendly_assert (TREE_CODE (fns
) == FUNCTION_DECL
4928 || TREE_CODE (fns
) == TEMPLATE_DECL
4929 || TREE_CODE (fns
) == OVERLOAD
,
4932 /* XXX this should be handled before we get here. */
4933 if (! IS_AGGR_TYPE (basetype
))
4935 if ((flags
& LOOKUP_COMPLAIN
) && basetype
!= error_mark_node
)
4936 error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
4937 fns
, instance
, basetype
);
4939 return error_mark_node
;
4942 fn
= get_first_fn (fns
);
4943 name
= DECL_NAME (fn
);
4945 if (IDENTIFIER_CTOR_OR_DTOR_P (name
))
4947 /* Callers should explicitly indicate whether they want to construct
4948 the complete object or just the part without virtual bases. */
4949 my_friendly_assert (name
!= ctor_identifier
, 20000408);
4950 /* Similarly for destructors. */
4951 my_friendly_assert (name
!= dtor_identifier
, 20000408);
4954 /* It's OK to call destructors on cv-qualified objects. Therefore,
4955 convert the INSTANCE_PTR to the unqualified type, if necessary. */
4956 if (DECL_DESTRUCTOR_P (fn
))
4958 tree type
= build_pointer_type (basetype
);
4959 if (!same_type_p (type
, TREE_TYPE (instance_ptr
)))
4960 instance_ptr
= build_nop (type
, instance_ptr
);
4963 class_type
= (conversion_path
? BINFO_TYPE (conversion_path
) : NULL_TREE
);
4964 mem_args
= tree_cons (NULL_TREE
, instance_ptr
, args
);
4966 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
4968 tree t
= OVL_CURRENT (fn
);
4971 /* We can end up here for copy-init of same or base class. */
4972 if ((flags
& LOOKUP_ONLYCONVERTING
)
4973 && DECL_NONCONVERTING_P (t
))
4976 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t
))
4977 this_arglist
= mem_args
;
4979 this_arglist
= args
;
4981 if (TREE_CODE (t
) == TEMPLATE_DECL
)
4982 /* A member template. */
4983 add_template_candidate (&candidates
, t
,
4986 this_arglist
, optype
,
4991 else if (! template_only
)
4992 add_function_candidate (&candidates
, t
,
5000 candidates
= splice_viable (candidates
, pedantic
, &any_viable_p
);
5003 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5004 if (flags
& LOOKUP_SPECULATIVELY
)
5006 if (!COMPLETE_TYPE_P (basetype
))
5007 cxx_incomplete_type_error (instance_ptr
, basetype
);
5013 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
5014 error ("no matching function for call to `%T::%s(%A)%#V'",
5015 basetype
, pretty_name
, user_args
,
5016 TREE_TYPE (TREE_TYPE (instance_ptr
)));
5020 print_z_candidates (candidates
);
5021 return error_mark_node
;
5024 cand
= tourney (candidates
);
5030 pretty_name
= name_as_c_string (name
, basetype
, &free_p
);
5031 error ("call of overloaded `%s(%A)' is ambiguous", pretty_name
,
5033 print_z_candidates (candidates
);
5036 return error_mark_node
;
5039 if (DECL_PURE_VIRTUAL_P (cand
->fn
)
5040 && instance
== current_class_ref
5041 && (DECL_CONSTRUCTOR_P (current_function_decl
)
5042 || DECL_DESTRUCTOR_P (current_function_decl
))
5043 && ! (flags
& LOOKUP_NONVIRTUAL
)
5044 && value_member (cand
->fn
, CLASSTYPE_PURE_VIRTUALS (basetype
)))
5045 error ((DECL_CONSTRUCTOR_P (current_function_decl
) ?
5046 "abstract virtual `%#D' called from constructor"
5047 : "abstract virtual `%#D' called from destructor"),
5049 if (TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
5050 && is_dummy_object (instance_ptr
))
5052 error ("cannot call member function `%D' without object", cand
->fn
);
5053 return error_mark_node
;
5056 if (DECL_VINDEX (cand
->fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
5057 && resolves_to_fixed_type_p (instance
, 0))
5058 flags
|= LOOKUP_NONVIRTUAL
;
5060 if (TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
)
5061 call
= build_over_call (cand
, flags
);
5064 call
= build_over_call (cand
, flags
);
5065 /* In an expression of the form `a->f()' where `f' turns out to
5066 be a static member function, `a' is none-the-less evaluated. */
5067 if (!is_dummy_object (instance_ptr
) && TREE_SIDE_EFFECTS (instance
))
5068 call
= build (COMPOUND_EXPR
, TREE_TYPE (call
), instance
, call
);
5074 /* Returns true iff standard conversion sequence ICS1 is a proper
5075 subsequence of ICS2. */
5078 is_subseq (tree ics1
, tree ics2
)
5080 /* We can assume that a conversion of the same code
5081 between the same types indicates a subsequence since we only get
5082 here if the types we are converting from are the same. */
5084 while (TREE_CODE (ics1
) == RVALUE_CONV
5085 || TREE_CODE (ics1
) == LVALUE_CONV
)
5086 ics1
= TREE_OPERAND (ics1
, 0);
5090 while (TREE_CODE (ics2
) == RVALUE_CONV
5091 || TREE_CODE (ics2
) == LVALUE_CONV
)
5092 ics2
= TREE_OPERAND (ics2
, 0);
5094 if (TREE_CODE (ics2
) == USER_CONV
5095 || TREE_CODE (ics2
) == AMBIG_CONV
5096 || TREE_CODE (ics2
) == IDENTITY_CONV
)
5097 /* At this point, ICS1 cannot be a proper subsequence of
5098 ICS2. We can get a USER_CONV when we are comparing the
5099 second standard conversion sequence of two user conversion
5103 ics2
= TREE_OPERAND (ics2
, 0);
5105 if (TREE_CODE (ics2
) == TREE_CODE (ics1
)
5106 && same_type_p (TREE_TYPE (ics2
), TREE_TYPE (ics1
))
5107 && same_type_p (TREE_TYPE (TREE_OPERAND (ics2
, 0)),
5108 TREE_TYPE (TREE_OPERAND (ics1
, 0))))
5113 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5114 be any _TYPE nodes. */
5117 is_properly_derived_from (tree derived
, tree base
)
5119 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived
))
5120 || !IS_AGGR_TYPE_CODE (TREE_CODE (base
)))
5123 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5124 considers every class derived from itself. */
5125 return (!same_type_ignoring_top_level_qualifiers_p (derived
, base
)
5126 && DERIVED_FROM_P (base
, derived
));
5129 /* We build the ICS for an implicit object parameter as a pointer
5130 conversion sequence. However, such a sequence should be compared
5131 as if it were a reference conversion sequence. If ICS is the
5132 implicit conversion sequence for an implicit object parameter,
5133 modify it accordingly. */
5136 maybe_handle_implicit_object (tree
*ics
)
5138 if (ICS_THIS_FLAG (*ics
))
5140 /* [over.match.funcs]
5142 For non-static member functions, the type of the
5143 implicit object parameter is "reference to cv X"
5144 where X is the class of which the function is a
5145 member and cv is the cv-qualification on the member
5146 function declaration. */
5148 tree reference_type
;
5150 /* The `this' parameter is a pointer to a class type. Make the
5151 implicit conversion talk about a reference to that same class
5153 reference_type
= TREE_TYPE (TREE_TYPE (*ics
));
5154 reference_type
= build_reference_type (reference_type
);
5156 if (TREE_CODE (t
) == QUAL_CONV
)
5157 t
= TREE_OPERAND (t
, 0);
5158 if (TREE_CODE (t
) == PTR_CONV
)
5159 t
= TREE_OPERAND (t
, 0);
5160 t
= build1 (IDENTITY_CONV
, TREE_TYPE (TREE_TYPE (t
)), NULL_TREE
);
5161 t
= direct_reference_binding (reference_type
, t
);
5166 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5167 and return the type to which the reference refers. Otherwise,
5168 leave *ICS unchanged and return NULL_TREE. */
5171 maybe_handle_ref_bind (tree
*ics
)
5173 if (TREE_CODE (*ics
) == REF_BIND
)
5175 tree old_ics
= *ics
;
5176 tree type
= TREE_TYPE (TREE_TYPE (old_ics
));
5177 *ics
= TREE_OPERAND (old_ics
, 0);
5178 ICS_USER_FLAG (*ics
) = ICS_USER_FLAG (old_ics
);
5179 ICS_BAD_FLAG (*ics
) = ICS_BAD_FLAG (old_ics
);
5186 /* Compare two implicit conversion sequences according to the rules set out in
5187 [over.ics.rank]. Return values:
5189 1: ics1 is better than ics2
5190 -1: ics2 is better than ics1
5191 0: ics1 and ics2 are indistinguishable */
5194 compare_ics (tree ics1
, tree ics2
)
5200 tree deref_from_type1
= NULL_TREE
;
5201 tree deref_from_type2
= NULL_TREE
;
5202 tree deref_to_type1
= NULL_TREE
;
5203 tree deref_to_type2
= NULL_TREE
;
5206 /* REF_BINDING is nonzero if the result of the conversion sequence
5207 is a reference type. In that case TARGET_TYPE is the
5208 type referred to by the reference. */
5212 /* Handle implicit object parameters. */
5213 maybe_handle_implicit_object (&ics1
);
5214 maybe_handle_implicit_object (&ics2
);
5216 /* Handle reference parameters. */
5217 target_type1
= maybe_handle_ref_bind (&ics1
);
5218 target_type2
= maybe_handle_ref_bind (&ics2
);
5222 When comparing the basic forms of implicit conversion sequences (as
5223 defined in _over.best.ics_)
5225 --a standard conversion sequence (_over.ics.scs_) is a better
5226 conversion sequence than a user-defined conversion sequence
5227 or an ellipsis conversion sequence, and
5229 --a user-defined conversion sequence (_over.ics.user_) is a
5230 better conversion sequence than an ellipsis conversion sequence
5231 (_over.ics.ellipsis_). */
5232 rank1
= ICS_RANK (ics1
);
5233 rank2
= ICS_RANK (ics2
);
5237 else if (rank1
< rank2
)
5240 if (rank1
== BAD_RANK
)
5242 /* XXX Isn't this an extension? */
5243 /* Both ICS are bad. We try to make a decision based on what
5244 would have happenned if they'd been good. */
5245 if (ICS_USER_FLAG (ics1
) > ICS_USER_FLAG (ics2
)
5246 || ICS_STD_RANK (ics1
) > ICS_STD_RANK (ics2
))
5248 else if (ICS_USER_FLAG (ics1
) < ICS_USER_FLAG (ics2
)
5249 || ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5252 /* We couldn't make up our minds; try to figure it out below. */
5255 if (ICS_ELLIPSIS_FLAG (ics1
))
5256 /* Both conversions are ellipsis conversions. */
5259 /* User-defined conversion sequence U1 is a better conversion sequence
5260 than another user-defined conversion sequence U2 if they contain the
5261 same user-defined conversion operator or constructor and if the sec-
5262 ond standard conversion sequence of U1 is better than the second
5263 standard conversion sequence of U2. */
5265 if (ICS_USER_FLAG (ics1
))
5269 for (t1
= ics1
; TREE_CODE (t1
) != USER_CONV
; t1
= TREE_OPERAND (t1
, 0))
5270 if (TREE_CODE (t1
) == AMBIG_CONV
)
5272 for (t2
= ics2
; TREE_CODE (t2
) != USER_CONV
; t2
= TREE_OPERAND (t2
, 0))
5273 if (TREE_CODE (t2
) == AMBIG_CONV
)
5276 if (USER_CONV_FN (t1
) != USER_CONV_FN (t2
))
5279 /* We can just fall through here, after setting up
5280 FROM_TYPE1 and FROM_TYPE2. */
5281 from_type1
= TREE_TYPE (t1
);
5282 from_type2
= TREE_TYPE (t2
);
5286 /* We're dealing with two standard conversion sequences.
5290 Standard conversion sequence S1 is a better conversion
5291 sequence than standard conversion sequence S2 if
5293 --S1 is a proper subsequence of S2 (comparing the conversion
5294 sequences in the canonical form defined by _over.ics.scs_,
5295 excluding any Lvalue Transformation; the identity
5296 conversion sequence is considered to be a subsequence of
5297 any non-identity conversion sequence */
5300 while (TREE_CODE (from_type1
) != IDENTITY_CONV
)
5301 from_type1
= TREE_OPERAND (from_type1
, 0);
5302 from_type1
= TREE_TYPE (from_type1
);
5305 while (TREE_CODE (from_type2
) != IDENTITY_CONV
)
5306 from_type2
= TREE_OPERAND (from_type2
, 0);
5307 from_type2
= TREE_TYPE (from_type2
);
5310 if (same_type_p (from_type1
, from_type2
))
5312 if (is_subseq (ics1
, ics2
))
5314 if (is_subseq (ics2
, ics1
))
5317 /* Otherwise, one sequence cannot be a subsequence of the other; they
5318 don't start with the same type. This can happen when comparing the
5319 second standard conversion sequence in two user-defined conversion
5326 --the rank of S1 is better than the rank of S2 (by the rules
5329 Standard conversion sequences are ordered by their ranks: an Exact
5330 Match is a better conversion than a Promotion, which is a better
5331 conversion than a Conversion.
5333 Two conversion sequences with the same rank are indistinguishable
5334 unless one of the following rules applies:
5336 --A conversion that is not a conversion of a pointer, or pointer
5337 to member, to bool is better than another conversion that is such
5340 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5341 so that we do not have to check it explicitly. */
5342 if (ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5344 else if (ICS_STD_RANK (ics2
) < ICS_STD_RANK (ics1
))
5347 to_type1
= TREE_TYPE (ics1
);
5348 to_type2
= TREE_TYPE (ics2
);
5350 if (TYPE_PTR_P (from_type1
)
5351 && TYPE_PTR_P (from_type2
)
5352 && TYPE_PTR_P (to_type1
)
5353 && TYPE_PTR_P (to_type2
))
5355 deref_from_type1
= TREE_TYPE (from_type1
);
5356 deref_from_type2
= TREE_TYPE (from_type2
);
5357 deref_to_type1
= TREE_TYPE (to_type1
);
5358 deref_to_type2
= TREE_TYPE (to_type2
);
5360 /* The rules for pointers to members A::* are just like the rules
5361 for pointers A*, except opposite: if B is derived from A then
5362 A::* converts to B::*, not vice versa. For that reason, we
5363 switch the from_ and to_ variables here. */
5364 else if (TYPE_PTRMEM_P (from_type1
)
5365 && TYPE_PTRMEM_P (from_type2
)
5366 && TYPE_PTRMEM_P (to_type1
)
5367 && TYPE_PTRMEM_P (to_type2
))
5369 deref_to_type1
= TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type1
));
5370 deref_to_type2
= TYPE_OFFSET_BASETYPE (TREE_TYPE (from_type2
));
5371 deref_from_type1
= TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type1
));
5372 deref_from_type2
= TYPE_OFFSET_BASETYPE (TREE_TYPE (to_type2
));
5374 else if (TYPE_PTRMEMFUNC_P (from_type1
)
5375 && TYPE_PTRMEMFUNC_P (from_type2
)
5376 && TYPE_PTRMEMFUNC_P (to_type1
)
5377 && TYPE_PTRMEMFUNC_P (to_type2
))
5379 deref_to_type1
= TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type1
);
5380 deref_to_type2
= TYPE_PTRMEMFUNC_OBJECT_TYPE (from_type2
);
5381 deref_from_type1
= TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type1
);
5382 deref_from_type2
= TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type2
);
5385 if (deref_from_type1
!= NULL_TREE
5386 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1
))
5387 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2
)))
5389 /* This was one of the pointer or pointer-like conversions.
5393 --If class B is derived directly or indirectly from class A,
5394 conversion of B* to A* is better than conversion of B* to
5395 void*, and conversion of A* to void* is better than
5396 conversion of B* to void*. */
5397 if (TREE_CODE (deref_to_type1
) == VOID_TYPE
5398 && TREE_CODE (deref_to_type2
) == VOID_TYPE
)
5400 if (is_properly_derived_from (deref_from_type1
,
5403 else if (is_properly_derived_from (deref_from_type2
,
5407 else if (TREE_CODE (deref_to_type1
) == VOID_TYPE
5408 || TREE_CODE (deref_to_type2
) == VOID_TYPE
)
5410 if (same_type_p (deref_from_type1
, deref_from_type2
))
5412 if (TREE_CODE (deref_to_type2
) == VOID_TYPE
)
5414 if (is_properly_derived_from (deref_from_type1
,
5418 /* We know that DEREF_TO_TYPE1 is `void' here. */
5419 else if (is_properly_derived_from (deref_from_type1
,
5424 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1
))
5425 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2
)))
5429 --If class B is derived directly or indirectly from class A
5430 and class C is derived directly or indirectly from B,
5432 --conversion of C* to B* is better than conversion of C* to
5435 --conversion of B* to A* is better than conversion of C* to
5437 if (same_type_p (deref_from_type1
, deref_from_type2
))
5439 if (is_properly_derived_from (deref_to_type1
,
5442 else if (is_properly_derived_from (deref_to_type2
,
5446 else if (same_type_p (deref_to_type1
, deref_to_type2
))
5448 if (is_properly_derived_from (deref_from_type2
,
5451 else if (is_properly_derived_from (deref_from_type1
,
5457 else if (CLASS_TYPE_P (non_reference (from_type1
))
5458 && same_type_p (from_type1
, from_type2
))
5460 tree from
= non_reference (from_type1
);
5464 --binding of an expression of type C to a reference of type
5465 B& is better than binding an expression of type C to a
5466 reference of type A&
5468 --conversion of C to B is better than conversion of C to A, */
5469 if (is_properly_derived_from (from
, to_type1
)
5470 && is_properly_derived_from (from
, to_type2
))
5472 if (is_properly_derived_from (to_type1
, to_type2
))
5474 else if (is_properly_derived_from (to_type2
, to_type1
))
5478 else if (CLASS_TYPE_P (non_reference (to_type1
))
5479 && same_type_p (to_type1
, to_type2
))
5481 tree to
= non_reference (to_type1
);
5485 --binding of an expression of type B to a reference of type
5486 A& is better than binding an expression of type C to a
5487 reference of type A&,
5489 --onversion of B to A is better than conversion of C to A */
5490 if (is_properly_derived_from (from_type1
, to
)
5491 && is_properly_derived_from (from_type2
, to
))
5493 if (is_properly_derived_from (from_type2
, from_type1
))
5495 else if (is_properly_derived_from (from_type1
, from_type2
))
5502 --S1 and S2 differ only in their qualification conversion and yield
5503 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5504 qualification signature of type T1 is a proper subset of the cv-
5505 qualification signature of type T2 */
5506 if (TREE_CODE (ics1
) == QUAL_CONV
5507 && TREE_CODE (ics2
) == QUAL_CONV
5508 && same_type_p (from_type1
, from_type2
))
5509 return comp_cv_qual_signature (to_type1
, to_type2
);
5513 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5514 types to which the references refer are the same type except for
5515 top-level cv-qualifiers, and the type to which the reference
5516 initialized by S2 refers is more cv-qualified than the type to
5517 which the reference initialized by S1 refers */
5519 if (target_type1
&& target_type2
5520 && same_type_ignoring_top_level_qualifiers_p (to_type1
, to_type2
))
5521 return comp_cv_qualification (target_type2
, target_type1
);
5523 /* Neither conversion sequence is better than the other. */
5527 /* The source type for this standard conversion sequence. */
5530 source_type (tree t
)
5532 for (;; t
= TREE_OPERAND (t
, 0))
5534 if (TREE_CODE (t
) == USER_CONV
5535 || TREE_CODE (t
) == AMBIG_CONV
5536 || TREE_CODE (t
) == IDENTITY_CONV
)
5537 return TREE_TYPE (t
);
5542 /* Note a warning about preferring WINNER to LOSER. We do this by storing
5543 a pointer to LOSER and re-running joust to produce the warning if WINNER
5544 is actually used. */
5547 add_warning (struct z_candidate
*winner
, struct z_candidate
*loser
)
5549 winner
->warnings
= tree_cons (NULL_TREE
,
5550 build_zc_wrapper (loser
),
5554 /* Compare two candidates for overloading as described in
5555 [over.match.best]. Return values:
5557 1: cand1 is better than cand2
5558 -1: cand2 is better than cand1
5559 0: cand1 and cand2 are indistinguishable */
5562 joust (struct z_candidate
*cand1
, struct z_candidate
*cand2
, bool warn
)
5565 int i
, off1
= 0, off2
= 0, len
;
5567 /* Candidates that involve bad conversions are always worse than those
5569 if (cand1
->viable
> cand2
->viable
)
5571 if (cand1
->viable
< cand2
->viable
)
5574 /* If we have two pseudo-candidates for conversions to the same type,
5575 or two candidates for the same function, arbitrarily pick one. */
5576 if (cand1
->fn
== cand2
->fn
5577 && (TYPE_P (cand1
->fn
) || DECL_P (cand1
->fn
)))
5580 /* a viable function F1
5581 is defined to be a better function than another viable function F2 if
5582 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5583 ICSi(F2), and then */
5585 /* for some argument j, ICSj(F1) is a better conversion sequence than
5588 /* For comparing static and non-static member functions, we ignore
5589 the implicit object parameter of the non-static function. The
5590 standard says to pretend that the static function has an object
5591 parm, but that won't work with operator overloading. */
5592 len
= TREE_VEC_LENGTH (cand1
->convs
);
5593 if (len
!= TREE_VEC_LENGTH (cand2
->convs
))
5595 if (DECL_STATIC_FUNCTION_P (cand1
->fn
)
5596 && ! DECL_STATIC_FUNCTION_P (cand2
->fn
))
5598 else if (! DECL_STATIC_FUNCTION_P (cand1
->fn
)
5599 && DECL_STATIC_FUNCTION_P (cand2
->fn
))
5608 for (i
= 0; i
< len
; ++i
)
5610 tree t1
= TREE_VEC_ELT (cand1
->convs
, i
+off1
);
5611 tree t2
= TREE_VEC_ELT (cand2
->convs
, i
+off2
);
5612 int comp
= compare_ics (t1
, t2
);
5617 && ICS_RANK (t1
) + ICS_RANK (t2
) == STD_RANK
+ PROMO_RANK
5618 && TREE_CODE (t1
) == STD_CONV
5619 && TREE_CODE (t2
) == STD_CONV
5620 && TREE_CODE (TREE_TYPE (t1
)) == INTEGER_TYPE
5621 && TREE_CODE (TREE_TYPE (t2
)) == INTEGER_TYPE
5622 && (TYPE_PRECISION (TREE_TYPE (t1
))
5623 == TYPE_PRECISION (TREE_TYPE (t2
)))
5624 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1
, 0)))
5625 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1
, 0)))
5628 tree type
= TREE_TYPE (TREE_OPERAND (t1
, 0));
5630 struct z_candidate
*w
, *l
;
5632 type1
= TREE_TYPE (t1
), type2
= TREE_TYPE (t2
),
5633 w
= cand1
, l
= cand2
;
5635 type1
= TREE_TYPE (t2
), type2
= TREE_TYPE (t1
),
5636 w
= cand2
, l
= cand1
;
5640 warning ("passing `%T' chooses `%T' over `%T'",
5641 type
, type1
, type2
);
5642 warning (" in call to `%D'", w
->fn
);
5648 if (winner
&& comp
!= winner
)
5657 /* warn about confusing overload resolution for user-defined conversions,
5658 either between a constructor and a conversion op, or between two
5660 if (winner
&& warn_conversion
&& cand1
->second_conv
5661 && (!DECL_CONSTRUCTOR_P (cand1
->fn
) || !DECL_CONSTRUCTOR_P (cand2
->fn
))
5662 && winner
!= compare_ics (cand1
->second_conv
, cand2
->second_conv
))
5664 struct z_candidate
*w
, *l
;
5665 bool give_warning
= false;
5668 w
= cand1
, l
= cand2
;
5670 w
= cand2
, l
= cand1
;
5672 /* We don't want to complain about `X::operator T1 ()'
5673 beating `X::operator T2 () const', when T2 is a no less
5674 cv-qualified version of T1. */
5675 if (DECL_CONTEXT (w
->fn
) == DECL_CONTEXT (l
->fn
)
5676 && !DECL_CONSTRUCTOR_P (w
->fn
) && !DECL_CONSTRUCTOR_P (l
->fn
))
5678 tree t
= TREE_TYPE (TREE_TYPE (l
->fn
));
5679 tree f
= TREE_TYPE (TREE_TYPE (w
->fn
));
5681 if (TREE_CODE (t
) == TREE_CODE (f
) && POINTER_TYPE_P (t
))
5686 if (!comp_ptr_ttypes (t
, f
))
5687 give_warning
= true;
5690 give_warning
= true;
5696 tree source
= source_type (TREE_VEC_ELT (w
->convs
, 0));
5697 if (! DECL_CONSTRUCTOR_P (w
->fn
))
5698 source
= TREE_TYPE (source
);
5699 warning ("choosing `%D' over `%D'", w
->fn
, l
->fn
);
5700 warning (" for conversion from `%T' to `%T'",
5701 source
, TREE_TYPE (w
->second_conv
));
5702 warning (" because conversion sequence for the argument is better");
5712 F1 is a non-template function and F2 is a template function
5715 if (! cand1
->template && cand2
->template)
5717 else if (cand1
->template && ! cand2
->template)
5721 F1 and F2 are template functions and the function template for F1 is
5722 more specialized than the template for F2 according to the partial
5725 if (cand1
->template && cand2
->template)
5727 winner
= more_specialized
5728 (TI_TEMPLATE (cand1
->template), TI_TEMPLATE (cand2
->template),
5730 /* Tell the deduction code how many real function arguments
5731 we saw, not counting the implicit 'this' argument. But,
5732 add_function_candidate() suppresses the "this" argument
5735 [temp.func.order]: The presence of unused ellipsis and default
5736 arguments has no effect on the partial ordering of function
5738 TREE_VEC_LENGTH (cand1
->convs
)
5739 - (DECL_NONSTATIC_MEMBER_FUNCTION_P (cand1
->fn
)
5740 - DECL_CONSTRUCTOR_P (cand1
->fn
)));
5746 the context is an initialization by user-defined conversion (see
5747 _dcl.init_ and _over.match.user_) and the standard conversion
5748 sequence from the return type of F1 to the destination type (i.e.,
5749 the type of the entity being initialized) is a better conversion
5750 sequence than the standard conversion sequence from the return type
5751 of F2 to the destination type. */
5753 if (cand1
->second_conv
)
5755 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
5760 /* Check whether we can discard a builtin candidate, either because we
5761 have two identical ones or matching builtin and non-builtin candidates.
5763 (Pedantically in the latter case the builtin which matched the user
5764 function should not be added to the overload set, but we spot it here.
5767 ... the builtin candidates include ...
5768 - do not have the same parameter type list as any non-template
5769 non-member candidate. */
5771 if (TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
5772 || TREE_CODE (cand2
->fn
) == IDENTIFIER_NODE
)
5774 for (i
= 0; i
< len
; ++i
)
5775 if (!same_type_p (TREE_TYPE (TREE_VEC_ELT (cand1
->convs
, i
)),
5776 TREE_TYPE (TREE_VEC_ELT (cand2
->convs
, i
))))
5778 if (i
== TREE_VEC_LENGTH (cand1
->convs
))
5780 if (cand1
->fn
== cand2
->fn
)
5781 /* Two built-in candidates; arbitrarily pick one. */
5783 else if (TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
)
5784 /* cand1 is built-in; prefer cand2. */
5787 /* cand2 is built-in; prefer cand1. */
5792 /* If the two functions are the same (this can happen with declarations
5793 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
5794 if (DECL_P (cand1
->fn
) && DECL_P (cand2
->fn
)
5795 && equal_functions (cand1
->fn
, cand2
->fn
))
5800 /* Extension: If the worst conversion for one candidate is worse than the
5801 worst conversion for the other, take the first. */
5804 int rank1
= IDENTITY_RANK
, rank2
= IDENTITY_RANK
;
5805 struct z_candidate
*w
= 0, *l
= 0;
5807 for (i
= 0; i
< len
; ++i
)
5809 if (ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
)) > rank1
)
5810 rank1
= ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
));
5811 if (ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
)) > rank2
)
5812 rank2
= ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
));
5815 winner
= 1, w
= cand1
, l
= cand2
;
5817 winner
= -1, w
= cand2
, l
= cand1
;
5823 ISO C++ says that these are ambiguous, even \
5824 though the worst conversion for the first is better than \
5825 the worst conversion for the second:");
5826 print_z_candidate (_("candidate 1:"), w
);
5827 print_z_candidate (_("candidate 2:"), l
);
5835 my_friendly_assert (!winner
, 20010121);
5839 /* Given a list of candidates for overloading, find the best one, if any.
5840 This algorithm has a worst case of O(2n) (winner is last), and a best
5841 case of O(n/2) (totally ambiguous); much better than a sorting
5844 static struct z_candidate
*
5845 tourney (struct z_candidate
*candidates
)
5847 struct z_candidate
*champ
= candidates
, *challenger
;
5849 int champ_compared_to_predecessor
= 0;
5851 /* Walk through the list once, comparing each current champ to the next
5852 candidate, knocking out a candidate or two with each comparison. */
5854 for (challenger
= champ
->next
; challenger
; )
5856 fate
= joust (champ
, challenger
, 0);
5858 challenger
= challenger
->next
;
5863 champ
= challenger
->next
;
5866 champ_compared_to_predecessor
= 0;
5871 champ_compared_to_predecessor
= 1;
5874 challenger
= champ
->next
;
5878 /* Make sure the champ is better than all the candidates it hasn't yet
5879 been compared to. */
5881 for (challenger
= candidates
;
5883 && !(champ_compared_to_predecessor
&& challenger
->next
== champ
);
5884 challenger
= challenger
->next
)
5886 fate
= joust (champ
, challenger
, 0);
5894 /* Returns nonzero if things of type FROM can be converted to TO. */
5897 can_convert (tree to
, tree from
)
5899 return can_convert_arg (to
, from
, NULL_TREE
);
5902 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
5905 can_convert_arg (tree to
, tree from
, tree arg
)
5907 tree t
= implicit_conversion (to
, from
, arg
, LOOKUP_NORMAL
);
5908 return (t
&& ! ICS_BAD_FLAG (t
));
5911 /* Like can_convert_arg, but allows dubious conversions as well. */
5914 can_convert_arg_bad (tree to
, tree from
, tree arg
)
5916 return implicit_conversion (to
, from
, arg
, LOOKUP_NORMAL
) != 0;
5919 /* Convert EXPR to TYPE. Return the converted expression.
5921 Note that we allow bad conversions here because by the time we get to
5922 this point we are committed to doing the conversion. If we end up
5923 doing a bad conversion, convert_like will complain. */
5926 perform_implicit_conversion (tree type
, tree expr
)
5930 if (error_operand_p (expr
))
5931 return error_mark_node
;
5932 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
5936 error ("could not convert `%E' to `%T'", expr
, type
);
5937 return error_mark_node
;
5940 return convert_like (conv
, expr
);
5943 /* Convert EXPR to TYPE (as a direct-initialization) if that is
5944 permitted. If the conversion is valid, the converted expression is
5945 returned. Otherwise, NULL_TREE is returned. */
5948 perform_direct_initialization_if_possible (tree type
, tree expr
)
5952 if (type
== error_mark_node
|| error_operand_p (expr
))
5953 return error_mark_node
;
5954 conv
= implicit_conversion (type
, TREE_TYPE (expr
), expr
,
5956 if (!conv
|| ICS_BAD_FLAG (conv
))
5958 return convert_like_real (conv
, expr
, NULL_TREE
, 0, 0,
5959 /*issue_conversion_warnings=*/false);
5962 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
5963 is being bound to a temporary. Create and return a new VAR_DECL
5964 with the indicated TYPE; this variable will store the value to
5965 which the reference is bound. */
5968 make_temporary_var_for_ref_to_temp (tree decl
, tree type
)
5972 /* Create the variable. */
5973 var
= build_decl (VAR_DECL
, NULL_TREE
, type
);
5974 DECL_ARTIFICIAL (var
) = 1;
5975 TREE_USED (var
) = 1;
5977 /* Register the variable. */
5978 if (TREE_STATIC (decl
))
5980 /* Namespace-scope or local static; give it a mangled name. */
5983 TREE_STATIC (var
) = 1;
5984 name
= mangle_ref_init_variable (decl
);
5985 DECL_NAME (var
) = name
;
5986 SET_DECL_ASSEMBLER_NAME (var
, name
);
5987 var
= pushdecl_top_level (var
);
5991 /* Create a new cleanup level if necessary. */
5992 maybe_push_cleanup_level (type
);
5993 /* Don't push unnamed temps. Do set DECL_CONTEXT, though. */
5994 DECL_CONTEXT (var
) = current_function_decl
;
6000 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6001 initializing a variable of that TYPE. If DECL is non-NULL, it is
6002 the VAR_DECL being initialized with the EXPR. (In that case, the
6003 type of DECL will be TYPE.)
6005 Return the converted expression. */
6008 initialize_reference (tree type
, tree expr
, tree decl
)
6012 if (type
== error_mark_node
|| error_operand_p (expr
))
6013 return error_mark_node
;
6015 conv
= reference_binding (type
, TREE_TYPE (expr
), expr
, LOOKUP_NORMAL
);
6016 if (!conv
|| ICS_BAD_FLAG (conv
))
6018 error ("could not convert `%E' to `%T'", expr
, type
);
6019 return error_mark_node
;
6022 /* If DECL is non-NULL, then this special rule applies:
6026 The temporary to which the reference is bound or the temporary
6027 that is the complete object to which the reference is bound
6028 persists for the lifetime of the reference.
6030 The temporaries created during the evaluation of the expression
6031 initializing the reference, except the temporary to which the
6032 reference is bound, are destroyed at the end of the
6033 full-expression in which they are created.
6035 In that case, we store the converted expression into a new
6036 VAR_DECL in a new scope.
6038 However, we want to be careful not to create temporaries when
6039 they are not required. For example, given:
6042 struct D : public B {};
6046 there is no need to copy the return value from "f"; we can just
6047 extend its lifetime. Similarly, given:
6050 struct T { operator S(); };
6054 we can extend the lifetime of the return value of the conversion
6056 my_friendly_assert (TREE_CODE (conv
) == REF_BIND
, 20030302);
6060 tree base_conv_type
;
6062 /* Skip over the REF_BIND. */
6063 conv
= TREE_OPERAND (conv
, 0);
6064 /* If the next conversion is a BASE_CONV, skip that too -- but
6065 remember that the conversion was required. */
6066 if (TREE_CODE (conv
) == BASE_CONV
&& !NEED_TEMPORARY_P (conv
))
6068 base_conv_type
= TREE_TYPE (conv
);
6069 conv
= TREE_OPERAND (conv
, 0);
6072 base_conv_type
= NULL_TREE
;
6073 /* Perform the remainder of the conversion. */
6074 expr
= convert_like (conv
, expr
);
6075 if (!real_non_cast_lvalue_p (expr
))
6080 /* Create the temporary variable. */
6081 type
= TREE_TYPE (expr
);
6082 var
= make_temporary_var_for_ref_to_temp (decl
, type
);
6083 layout_decl (var
, 0);
6084 if (at_function_scope_p ())
6088 add_decl_stmt (var
);
6089 cleanup
= cxx_maybe_build_cleanup (var
);
6091 finish_decl_cleanup (var
, cleanup
);
6095 rest_of_decl_compilation (var
, NULL
, /*toplev=*/1, at_eof
);
6096 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6097 static_aggregates
= tree_cons (NULL_TREE
, var
,
6100 init
= build (INIT_EXPR
, type
, var
, expr
);
6101 /* Use its address to initialize the reference variable. */
6102 expr
= build_address (var
);
6103 expr
= build (COMPOUND_EXPR
, TREE_TYPE (expr
), init
, expr
);
6106 /* Take the address of EXPR. */
6107 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
6108 /* If a BASE_CONV was required, perform it now. */
6110 expr
= (perform_implicit_conversion
6111 (build_pointer_type (base_conv_type
), expr
));
6112 return build_nop (type
, expr
);
6115 /* Perform the conversion. */
6116 return convert_like (conv
, expr
);
6119 #include "gt-cp-call.h"