1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 hacked by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* High-level class interface. */
39 #define obstack_chunk_alloc xmalloc
40 #define obstack_chunk_free free
42 extern int inhibit_warnings
;
43 extern tree ctor_label
, dtor_label
;
45 /* Compute the ease with which a conversion can be performed
46 between an expected and the given type. */
48 static struct harshness_code convert_harshness
PROTO((register tree
, register tree
, tree
));
49 static tree build_new_method_call
PROTO((tree
, tree
, tree
, tree
, int));
51 static int rank_for_ideal
PROTO((struct candidate
*,
53 static int user_harshness
PROTO((tree
, tree
));
54 static int strictly_better
PROTO((unsigned short, unsigned short));
55 static struct candidate
* ideal_candidate
PROTO((struct candidate
*,
57 static int may_be_remote
PROTO((tree
));
58 static tree build_field_call
PROTO((tree
, tree
, tree
, tree
));
59 static tree find_scoped_type
PROTO((tree
, tree
, tree
));
60 static void print_candidates
PROTO((tree
));
61 static struct z_candidate
* tourney
PROTO((struct z_candidate
*));
62 static int joust
PROTO((struct z_candidate
*, struct z_candidate
*));
63 static int compare_qual
PROTO((tree
, tree
));
64 static int compare_ics
PROTO((tree
, tree
));
65 static tree build_over_call
PROTO((tree
, tree
, tree
, int));
66 static tree convert_default_arg
PROTO((tree
, tree
));
67 static void enforce_access
PROTO((tree
, tree
));
68 static tree convert_like
PROTO((tree
, tree
));
69 static void op_error
PROTO((enum tree_code
, enum tree_code
, tree
, tree
,
71 static tree build_object_call
PROTO((tree
, tree
));
72 static tree resolve_args
PROTO((tree
));
73 static struct z_candidate
* build_user_type_conversion_1
74 PROTO ((tree
, tree
, int));
75 static void print_z_candidates
PROTO((struct z_candidate
*));
76 static tree build_this
PROTO((tree
));
77 static struct z_candidate
* splice_viable
PROTO((struct z_candidate
*));
78 static int any_viable
PROTO((struct z_candidate
*));
79 static struct z_candidate
* add_template_candidate
80 PROTO((struct z_candidate
*, tree
, tree
, int));
81 static struct z_candidate
* add_builtin_candidates
82 PROTO((struct z_candidate
*, enum tree_code
, enum tree_code
,
84 static struct z_candidate
* add_builtin_candidate
85 PROTO((struct z_candidate
*, enum tree_code
, enum tree_code
,
86 tree
, tree
, tree
, tree
*, tree
*, int));
87 static int is_complete
PROTO((tree
));
88 static struct z_candidate
* build_builtin_candidate
89 PROTO((struct z_candidate
*, tree
, tree
, tree
, tree
*, tree
*,
91 static struct z_candidate
* add_conv_candidate
92 PROTO((struct z_candidate
*, tree
, tree
, tree
));
93 static struct z_candidate
* add_function_candidate
94 PROTO((struct z_candidate
*, tree
, tree
, int));
95 static tree implicit_conversion
PROTO((tree
, tree
, tree
, int));
96 static tree standard_conversion
PROTO((tree
, tree
, tree
));
97 static tree reference_binding
PROTO((tree
, tree
, tree
, int));
98 static tree strip_top_quals
PROTO((tree
));
99 static tree non_reference
PROTO((tree
));
100 static tree build_conv
PROTO((enum tree_code
, tree
, tree
));
101 static void print_n_candidates
PROTO((struct candidate
*, int));
102 static tree default_parm_conversions
PROTO((tree
, tree
*));
104 #define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG))
105 #define STD_RETURN(ARG) ((ARG).code = STD_CODE, (ARG))
106 #define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG))
107 #define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG))
108 #define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG))
110 /* Ordering function for overload resolution. Compare two candidates
114 rank_for_overload (x
, y
)
115 struct candidate
*x
, *y
;
117 if (y
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
118 return y
->h
.code
- x
->h
.code
;
119 if (x
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
122 /* This is set by compute_conversion_costs, for calling a non-const
123 member function from a const member function. */
124 if ((y
->harshness
[0].code
& CONST_CODE
) ^ (x
->harshness
[0].code
& CONST_CODE
))
125 return y
->harshness
[0].code
- x
->harshness
[0].code
;
127 if (y
->h
.code
& STD_CODE
)
129 if (x
->h
.code
& STD_CODE
)
130 return y
->h
.distance
- x
->h
.distance
;
133 if (x
->h
.code
& STD_CODE
)
136 return y
->h
.code
- x
->h
.code
;
139 /* Compare two candidates, argument by argument. */
142 rank_for_ideal (x
, y
)
143 struct candidate
*x
, *y
;
147 if (x
->h_len
!= y
->h_len
)
150 for (i
= 0; i
< x
->h_len
; i
++)
152 if (y
->harshness
[i
].code
- x
->harshness
[i
].code
)
153 return y
->harshness
[i
].code
- x
->harshness
[i
].code
;
154 if ((y
->harshness
[i
].code
& STD_CODE
)
155 && (y
->harshness
[i
].distance
- x
->harshness
[i
].distance
))
156 return y
->harshness
[i
].distance
- x
->harshness
[i
].distance
;
158 /* They're both the same code. Now see if we're dealing with an
159 integral promotion that needs a finer grain of accuracy. */
160 if (y
->harshness
[0].code
& PROMO_CODE
161 && (y
->harshness
[i
].int_penalty
^ x
->harshness
[i
].int_penalty
))
162 return y
->harshness
[i
].int_penalty
- x
->harshness
[i
].int_penalty
;
167 /* TYPE is the type we wish to convert to. PARM is the parameter
168 we have to work with. We use a somewhat arbitrary cost function
169 to measure this conversion. */
171 static struct harshness_code
172 convert_harshness (type
, parmtype
, parm
)
173 register tree type
, parmtype
;
176 struct harshness_code h
;
177 register enum tree_code codel
;
178 register enum tree_code coder
;
185 #ifdef GATHER_STATISTICS
186 n_convert_harshness
++;
189 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
192 parm
= convert_from_reference (parm
);
193 parmtype
= TREE_TYPE (parmtype
);
197 lvalue
= lvalue_p (parm
);
201 if (TYPE_PTRMEMFUNC_P (type
))
202 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
203 if (TYPE_PTRMEMFUNC_P (parmtype
))
204 parmtype
= TYPE_PTRMEMFUNC_FN_TYPE (parmtype
);
206 codel
= TREE_CODE (type
);
207 coder
= TREE_CODE (parmtype
);
209 if (TYPE_MAIN_VARIANT (parmtype
) == TYPE_MAIN_VARIANT (type
))
210 return ZERO_RETURN (h
);
212 if (coder
== ERROR_MARK
)
213 return EVIL_RETURN (h
);
215 if (codel
== REFERENCE_TYPE
)
218 int constp
= parm
? TREE_READONLY (parm
) : TYPE_READONLY (parmtype
);
219 int volatilep
= (parm
? TREE_THIS_VOLATILE (parm
)
220 : TYPE_VOLATILE (parmtype
));
221 register tree intype
= TYPE_MAIN_VARIANT (parmtype
);
222 register enum tree_code form
= TREE_CODE (intype
);
225 ttl
= TREE_TYPE (type
);
227 /* Only allow const reference binding if we were given a parm to deal
228 with, since it isn't really a conversion. This is a hack to
229 prevent build_type_conversion from finding this conversion, but
230 still allow overloading to find it. */
231 if (! lvalue
&& ! (parm
&& TYPE_READONLY (ttl
)))
232 return EVIL_RETURN (h
);
234 if ((TYPE_READONLY (ttl
) < constp
)
235 || (TYPE_VOLATILE (ttl
) < volatilep
))
236 return EVIL_RETURN (h
);
238 /* When passing a non-const argument into a const reference, dig it a
239 little, so a non-const reference is preferred over this one. */
240 penalty
= ((TYPE_READONLY (ttl
) > constp
)
241 + (TYPE_VOLATILE (ttl
) > volatilep
));
243 ttl
= TYPE_MAIN_VARIANT (ttl
);
245 if (form
== OFFSET_TYPE
)
247 intype
= TREE_TYPE (intype
);
248 form
= TREE_CODE (intype
);
253 if (TREE_CODE (ttl
) == ARRAY_TYPE
&& TREE_CODE (ttr
) == ARRAY_TYPE
)
255 if (comptypes (ttl
, ttr
, 1))
256 return ZERO_RETURN (h
);
257 return EVIL_RETURN (h
);
260 h
= convert_harshness (ttl
, ttr
, NULL_TREE
);
261 if (penalty
&& h
.code
== 0)
264 h
.int_penalty
= penalty
;
269 if (codel
== POINTER_TYPE
&& fntype_p (parmtype
))
272 struct harshness_code h1
, h2
;
274 /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */
275 type
= TREE_TYPE (type
);
277 if (coder
== POINTER_TYPE
)
279 parmtype
= TREE_TYPE (parmtype
);
280 coder
= TREE_CODE (parmtype
);
283 if (coder
!= TREE_CODE (type
))
284 return EVIL_RETURN (h
);
286 if (type
!= parmtype
&& coder
== METHOD_TYPE
)
288 tree ttl
= TYPE_METHOD_BASETYPE (type
);
289 tree ttr
= TYPE_METHOD_BASETYPE (parmtype
);
291 int b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
294 b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
296 return EVIL_RETURN (h
);
297 h
.distance
= -b_or_d
;
303 type
= build_function_type
304 (TREE_TYPE (type
), TREE_CHAIN (TYPE_ARG_TYPES (type
)));
305 parmtype
= build_function_type
306 (TREE_TYPE (parmtype
), TREE_CHAIN (TYPE_ARG_TYPES (parmtype
)));
309 /* We allow the default conversion between function type
310 and pointer-to-function type for free. */
311 if (comptypes (type
, parmtype
, 1))
315 return EVIL_RETURN (h
);
317 /* Compare return types. */
318 p1
= TREE_TYPE (type
);
319 p2
= TREE_TYPE (parmtype
);
320 h2
= convert_harshness (p1
, p2
, NULL_TREE
);
321 if (h2
.code
& EVIL_CODE
)
324 h1
.code
= TRIVIAL_CODE
;
327 if (h2
.distance
!= 0)
331 /* This only works for pointers. */
332 if (TREE_CODE (p1
) != POINTER_TYPE
333 && TREE_CODE (p1
) != REFERENCE_TYPE
)
334 return EVIL_RETURN (h
);
338 /* Don't die if we happen to be dealing with void*. */
339 if (!IS_AGGR_TYPE (p1
) || !IS_AGGR_TYPE (p2
))
340 return EVIL_RETURN (h
);
342 binfo
= get_binfo (p2
, p1
, 0);
344 binfo
= get_binfo (p1
, p2
, 0);
346 if (! BINFO_OFFSET_ZEROP (binfo
))
349 static int explained
= 0;
351 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p2
, p1
);
353 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p1
, p2
);
356 sorry ("(because pointer values change during conversion)");
358 return EVIL_RETURN (h
);
363 if (h2
.distance
> h1
.distance
)
364 h1
.distance
= h2
.distance
;
366 p1
= TYPE_ARG_TYPES (type
);
367 p2
= TYPE_ARG_TYPES (parmtype
);
368 while (p1
&& TREE_VALUE (p1
) != void_type_node
369 && p2
&& TREE_VALUE (p2
) != void_type_node
)
371 h2
= convert_harshness (TREE_VALUE (p1
), TREE_VALUE (p2
),
373 if (h2
.code
& EVIL_CODE
)
378 /* This only works for pointers and references. */
379 if (TREE_CODE (TREE_VALUE (p1
)) != POINTER_TYPE
380 && TREE_CODE (TREE_VALUE (p1
)) != REFERENCE_TYPE
)
381 return EVIL_RETURN (h
);
382 h2
.distance
= - h2
.distance
;
386 if (h2
.distance
> h1
.distance
)
387 h1
.distance
= h2
.distance
;
388 p1
= TREE_CHAIN (p1
);
389 p2
= TREE_CHAIN (p2
);
396 return EVIL_RETURN (h
);
397 h1
.code
|= ELLIPSIS_CODE
;
402 if (TREE_PURPOSE (p1
) == NULL_TREE
)
403 h1
.code
|= EVIL_CODE
;
407 else if (codel
== POINTER_TYPE
&& coder
== OFFSET_TYPE
)
411 /* Get to the OFFSET_TYPE that this might be. */
412 type
= TREE_TYPE (type
);
414 if (coder
!= TREE_CODE (type
))
415 return EVIL_RETURN (h
);
417 ttl
= TYPE_OFFSET_BASETYPE (type
);
418 ttr
= TYPE_OFFSET_BASETYPE (parmtype
);
424 int b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
427 b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
429 return EVIL_RETURN (h
);
430 h
.distance
= -b_or_d
;
437 /* Now test the OFFSET_TYPE's target compatibility. */
438 type
= TREE_TYPE (type
);
439 parmtype
= TREE_TYPE (parmtype
);
442 if (coder
== UNKNOWN_TYPE
)
444 if (codel
== FUNCTION_TYPE
445 || codel
== METHOD_TYPE
446 || (codel
== POINTER_TYPE
447 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
448 || TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)))
449 return TRIVIAL_RETURN (h
);
450 return EVIL_RETURN (h
);
453 if (coder
== VOID_TYPE
)
454 return EVIL_RETURN (h
);
456 if (codel
== BOOLEAN_TYPE
)
458 if (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
)
459 return STD_RETURN (h
);
460 else if (coder
== POINTER_TYPE
|| coder
== OFFSET_TYPE
)
462 /* Make this worse than any conversion to another pointer.
463 FIXME this is how I think the language should work, but it may not
464 end up being how the language is standardized (jason 1/30/95). */
466 return STD_RETURN (h
);
468 return EVIL_RETURN (h
);
471 if (INTEGRAL_CODE_P (codel
))
473 /* Control equivalence of ints an enums. */
475 if (codel
== ENUMERAL_TYPE
476 && flag_int_enum_equivalence
== 0)
478 /* Enums can be converted to ints, but not vice-versa. */
479 if (coder
!= ENUMERAL_TYPE
480 || TYPE_MAIN_VARIANT (type
) != TYPE_MAIN_VARIANT (parmtype
))
481 return EVIL_RETURN (h
);
484 /* else enums and ints (almost) freely interconvert. */
486 if (INTEGRAL_CODE_P (coder
))
488 if (TYPE_MAIN_VARIANT (type
)
489 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
498 else if (coder
== REAL_TYPE
)
506 if (codel
== REAL_TYPE
)
508 if (coder
== REAL_TYPE
)
510 if (TYPE_MAIN_VARIANT (type
)
511 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
518 else if (INTEGRAL_CODE_P (coder
))
526 /* Convert arrays which have not previously been converted. */
527 if (coder
== ARRAY_TYPE
)
529 coder
= POINTER_TYPE
;
532 parm
= decay_conversion (parm
);
533 parmtype
= TREE_TYPE (parm
);
536 parmtype
= build_pointer_type (TREE_TYPE (parmtype
));
539 /* Conversions among pointers */
540 if (codel
== POINTER_TYPE
&& coder
== POINTER_TYPE
)
542 register tree ttl
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
543 register tree ttr
= TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
));
544 int penalty
= 4 * (ttl
!= ttr
);
546 /* Anything converts to void *. Since this may be `const void *'
547 (etc.) use VOID_TYPE instead of void_type_node. Otherwise, the
548 targets must be the same, except that we do allow (at some cost)
549 conversion between signed and unsigned pointer types. */
551 if ((TREE_CODE (ttl
) == METHOD_TYPE
552 || TREE_CODE (ttl
) == FUNCTION_TYPE
)
553 && TREE_CODE (ttl
) == TREE_CODE (ttr
))
555 if (comptypes (ttl
, ttr
, -1))
557 h
.code
= penalty
? STD_CODE
: 0;
566 if (TREE_CODE (ttl
) != VOID_TYPE
567 && (TREE_CODE (ttr
) != VOID_TYPE
|| !parm
|| !null_ptr_cst_p (parm
)))
569 if (comp_target_types (type
, parmtype
, 1) <= 0)
570 return EVIL_RETURN (h
);
573 if (!(TREE_CODE (ttl
) == VOID_TYPE
574 || TREE_CODE (ttr
) == VOID_TYPE
575 || (TREE_UNSIGNED (ttl
) ^ TREE_UNSIGNED (ttr
)
576 && (ttl
= unsigned_type (ttl
),
577 ttr
= unsigned_type (ttr
),
579 || (comp_target_types (ttl
, ttr
, 0) > 0)))
580 return EVIL_RETURN (h
);
585 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
588 /* Note conversion from `T*' to `const T*',
589 or `T*' to `volatile T*'. */
590 if ((TYPE_READONLY (tmp1
) < TREE_READONLY (tmp2
))
591 || (TYPE_VOLATILE (tmp1
) < TYPE_VOLATILE (tmp2
)))
593 else if ((TYPE_READONLY (tmp1
) != TREE_READONLY (tmp2
))
594 || (TYPE_VOLATILE (tmp1
) != TYPE_VOLATILE (tmp2
)))
602 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
604 int b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
607 b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
609 return EVIL_RETURN (h
);
610 h
.distance
= -b_or_d
;
618 /* If converting from a `class*' to a `void*', make it
619 less favorable than any inheritance relationship. */
620 if (TREE_CODE (ttl
) == VOID_TYPE
&& IS_AGGR_TYPE (ttr
))
623 h
.distance
= CLASSTYPE_MAX_DEPTH (ttr
)+1;
627 h
.code
= penalty
? STD_CODE
: PROMO_CODE
;
628 /* Catch things like `const char *' -> `const void *'
629 vs `const char *' -> `void *'. */
632 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
633 if ((TYPE_READONLY (tmp1
) < TREE_READONLY (tmp2
))
634 || (TYPE_VOLATILE (tmp1
) < TYPE_VOLATILE (tmp2
)))
636 else if ((TYPE_READONLY (tmp1
) > TREE_READONLY (tmp2
))
637 || (TYPE_VOLATILE (tmp1
) > TYPE_VOLATILE (tmp2
)))
643 if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
645 /* This is not a bad match, but don't let it beat
646 integer-enum combinations. */
647 if (parm
&& integer_zerop (parm
))
655 /* C++: Since the `this' parameter of a signature member function
656 is represented as a signature pointer to handle default implementations
657 correctly, we can have the case that `type' is a signature pointer
658 while `parmtype' is a pointer to a signature table. We don't really
659 do any conversions in this case, so just return 0. */
661 if (codel
== RECORD_TYPE
&& coder
== POINTER_TYPE
662 && IS_SIGNATURE_POINTER (type
) && IS_SIGNATURE (TREE_TYPE (parmtype
)))
663 return ZERO_RETURN (h
);
665 if (codel
== RECORD_TYPE
&& coder
== RECORD_TYPE
)
667 int b_or_d
= get_base_distance (type
, parmtype
, 0, (tree
*)0);
670 b_or_d
= get_base_distance (parmtype
, type
, 0, (tree
*)0);
672 return EVIL_RETURN (h
);
673 h
.distance
= -b_or_d
;
680 return EVIL_RETURN (h
);
683 /* A clone of build_type_conversion for checking user-defined conversions in
684 overload resolution. */
687 user_harshness (type
, parmtype
)
688 register tree type
, parmtype
;
691 tree winner
= NULL_TREE
;
695 tree typename
= build_typename_overload (type
);
696 if (lookup_fnfields (TYPE_BINFO (parmtype
), typename
, 0))
700 for (conv
= lookup_conversions (parmtype
); conv
; conv
= TREE_CHAIN (conv
))
702 struct harshness_code tmp
;
703 tree cand
= TREE_VALUE (conv
);
705 if (winner
&& winner
== cand
)
708 tmp
= convert_harshness (type
, TREE_TYPE (TREE_TYPE (cand
)), NULL_TREE
);
709 if ((tmp
.code
< USER_CODE
) && (tmp
.distance
>= 0))
727 #ifdef DEBUG_MATCHING
730 struct harshness_code
*h
;
732 static char buf
[1024];
735 bzero (buf
, 1024 * sizeof (char));
736 strcat (buf
, "codes=[");
737 if (h
->code
& EVIL_CODE
)
738 strcat (buf
, "EVIL");
739 if (h
->code
& CONST_CODE
)
740 strcat (buf
, " CONST");
741 if (h
->code
& ELLIPSIS_CODE
)
742 strcat (buf
, " ELLIPSIS");
743 if (h
->code
& USER_CODE
)
744 strcat (buf
, " USER");
745 if (h
->code
& STD_CODE
)
746 strcat (buf
, " STD");
747 if (h
->code
& PROMO_CODE
)
748 strcat (buf
, " PROMO");
749 if (h
->code
& QUAL_CODE
)
750 strcat (buf
, " QUAL");
751 if (h
->code
& TRIVIAL_CODE
)
752 strcat (buf
, " TRIVIAL");
756 sprintf (tmp
, "] distance=%d int_penalty=%d", h
->distance
, h
->int_penalty
);
764 /* Algorithm: For each argument, calculate how difficult it is to
765 make FUNCTION accept that argument. If we can easily tell that
766 FUNCTION won't be acceptable to one of the arguments, then we
767 don't need to compute the ease of converting the other arguments,
768 since it will never show up in the intersection of all arguments'
771 Conversions between builtin and user-defined types are allowed, but
772 no function involving such a conversion is preferred to one which
773 does not require such a conversion. Furthermore, such conversions
777 compute_conversion_costs (function
, tta_in
, cp
, arglen
)
780 struct candidate
*cp
;
783 tree ttf_in
= TYPE_ARG_TYPES (TREE_TYPE (function
));
787 /* Start out with no strikes against. */
788 int evil_strikes
= 0;
789 int ellipsis_strikes
= 0;
790 int user_strikes
= 0;
791 int b_or_d_strikes
= 0;
792 int easy_strikes
= 0;
794 int strike_index
= 0, win
;
795 struct harshness_code lose
;
796 extern int cp_silent
;
798 #ifdef GATHER_STATISTICS
799 n_compute_conversion_costs
++;
802 #ifndef DEBUG_MATCHING
803 /* We don't emit any warnings or errors while trying out each candidate. */
807 cp
->function
= function
;
808 cp
->arg
= tta
? TREE_VALUE (tta
) : NULL_TREE
;
809 cp
->u
.bad_arg
= 0; /* optimistic! */
813 cp
->h
.int_penalty
= 0;
814 bzero ((char *) cp
->harshness
,
815 (cp
->h_len
+ 1) * sizeof (struct harshness_code
));
819 struct harshness_code h
;
821 if (ttf
== void_list_node
)
824 if (type_unknown_p (TREE_VALUE (tta
)))
826 /* Must perform some instantiation here. */
827 tree rhs
= TREE_VALUE (tta
);
828 tree lhstype
= TREE_VALUE (ttf
);
830 /* Keep quiet about possible contravariance violations. */
831 int old_inhibit_warnings
= inhibit_warnings
;
832 inhibit_warnings
= 1;
834 /* @@ This is to undo what `grokdeclarator' does to
835 parameter types. It really should go through
836 something more general. */
838 TREE_TYPE (tta
) = unknown_type_node
;
839 rhs
= instantiate_type (lhstype
, rhs
, 0);
840 inhibit_warnings
= old_inhibit_warnings
;
842 if (TREE_CODE (rhs
) == ERROR_MARK
)
845 h
= convert_harshness (lhstype
, TREE_TYPE (rhs
), rhs
);
849 #ifdef DEBUG_MATCHING
850 static tree old_function
= NULL_TREE
;
852 if (!old_function
|| function
!= old_function
)
854 cp_error ("trying %D", function
);
855 old_function
= function
;
858 cp_error (" doing (%T) %E against arg %T",
859 TREE_TYPE (TREE_VALUE (tta
)), TREE_VALUE (tta
),
863 h
= convert_harshness (TREE_VALUE (ttf
),
864 TREE_TYPE (TREE_VALUE (tta
)),
867 #ifdef DEBUG_MATCHING
868 cp_error (" evaluated %s", print_harshness (&h
));
872 cp
->harshness
[strike_index
] = h
;
873 if ((h
.code
& EVIL_CODE
)
874 || ((h
.code
& STD_CODE
) && h
.distance
< 0))
876 cp
->u
.bad_arg
= strike_index
;
879 else if (h
.code
& ELLIPSIS_CODE
)
880 ellipsis_strikes
+= 1;
882 /* This is never set by `convert_harshness'. */
883 else if (h
.code
& USER_CODE
)
890 if ((h
.code
& STD_CODE
) && h
.distance
)
892 if (h
.distance
> b_or_d_strikes
)
893 b_or_d_strikes
= h
.distance
;
896 easy_strikes
+= (h
.code
& (STD_CODE
|PROMO_CODE
|TRIVIAL_CODE
));
897 cp
->h
.code
|= h
.code
;
898 /* Make sure we communicate this. */
899 cp
->h
.int_penalty
+= h
.int_penalty
;
902 ttf
= TREE_CHAIN (ttf
);
903 tta
= TREE_CHAIN (tta
);
909 /* ran out of formals, and parmlist is fixed size. */
910 if (ttf
/* == void_type_node */)
912 cp
->h
.code
= EVIL_CODE
;
919 struct harshness_code h
;
920 int l
= list_length (tta
);
921 ellipsis_strikes
+= l
;
922 h
.code
= ELLIPSIS_CODE
;
926 cp
->harshness
[strike_index
++] = h
;
929 else if (ttf
&& ttf
!= void_list_node
)
931 /* ran out of actuals, and no defaults. */
932 if (TREE_PURPOSE (ttf
) == NULL_TREE
)
934 cp
->h
.code
= EVIL_CODE
;
939 /* Store index of first default. */
940 cp
->harshness
[arglen
].distance
= strike_index
+1;
943 cp
->harshness
[arglen
].distance
= 0;
945 /* Argument list lengths work out, so don't need to check them again. */
948 /* We do not check for derived->base conversions here, since in
949 no case would they give evil strike counts, unless such conversions
950 are somehow ambiguous. */
952 /* See if any user-defined conversions apply.
953 But make sure that we do not loop. */
954 static int dont_convert_types
= 0;
956 if (dont_convert_types
)
958 cp
->h
.code
= EVIL_CODE
;
963 win
= 0; /* Only get one chance to win. */
964 ttf
= TYPE_ARG_TYPES (TREE_TYPE (function
));
971 if (ttf
== void_list_node
)
974 lose
= cp
->harshness
[strike_index
];
975 if ((lose
.code
& EVIL_CODE
)
976 || ((lose
.code
& STD_CODE
) && lose
.distance
< 0))
978 tree actual_type
= TREE_TYPE (TREE_VALUE (tta
));
979 tree formal_type
= TREE_VALUE (ttf
);
980 int extra_conversions
= 0;
982 dont_convert_types
= 1;
984 if (TREE_CODE (formal_type
) == REFERENCE_TYPE
)
985 formal_type
= TREE_TYPE (formal_type
);
986 if (TREE_CODE (actual_type
) == REFERENCE_TYPE
)
987 actual_type
= TREE_TYPE (actual_type
);
989 if (formal_type
!= error_mark_node
990 && actual_type
!= error_mark_node
)
992 formal_type
= complete_type (TYPE_MAIN_VARIANT (formal_type
));
993 actual_type
= complete_type (TYPE_MAIN_VARIANT (actual_type
));
995 if (TYPE_HAS_CONSTRUCTOR (formal_type
))
997 /* If it has a constructor for this type,
999 /* @@ There is no way to save this result yet, so
1000 success is a NULL_TREE for now. */
1001 if (convert_to_aggr (formal_type
, TREE_VALUE (tta
), 0, 1)
1005 if (TYPE_LANG_SPECIFIC (actual_type
)
1006 && TYPE_HAS_CONVERSION (actual_type
))
1008 int extra
= user_harshness (formal_type
, actual_type
);
1010 if (extra
== EVIL_CODE
)
1012 else if (extra
>= 0)
1015 extra_conversions
= extra
;
1019 dont_convert_types
= 0;
1024 cp
->harshness
[strike_index
].code
1025 = USER_CODE
| (extra_conversions
? STD_CODE
: 0);
1030 if (cp
->u
.bad_arg
> strike_index
)
1031 cp
->u
.bad_arg
= strike_index
;
1033 evil_strikes
= win
? 2 : 1;
1038 ttf
= TREE_CHAIN (ttf
);
1039 tta
= TREE_CHAIN (tta
);
1044 /* Const member functions get a small penalty because defaulting
1045 to const is less useful than defaulting to non-const. */
1046 /* This is bogus, it does not correspond to anything in the ARM.
1047 This code will be fixed when this entire section is rewritten
1048 to conform to the ARM. (mrs) */
1049 if (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
1051 tree this_parm
= TREE_VALUE (ttf_in
);
1053 if (TREE_CODE (this_parm
) == RECORD_TYPE
/* Is `this' a sig ptr? */
1054 ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm
))))
1055 : TYPE_READONLY (TREE_TYPE (this_parm
)))
1057 cp
->harshness
[0].code
|= TRIVIAL_CODE
;
1062 /* Calling a non-const member function from a const member function
1063 is probably invalid, but for now we let it only draw a warning.
1064 We indicate that such a mismatch has occurred by setting the
1065 harshness to a maximum value. */
1066 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in
))) == POINTER_TYPE
1067 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in
))))))
1068 cp
->harshness
[0].code
|= CONST_CODE
;
1073 cp
->h
.code
= EVIL_CODE
;
1074 if (ellipsis_strikes
)
1075 cp
->h
.code
|= ELLIPSIS_CODE
;
1077 cp
->h
.code
|= USER_CODE
;
1079 #ifdef DEBUG_MATCHING
1080 cp_error ("final eval %s", print_harshness (&cp
->h
));
1084 /* Subroutine of ideal_candidate. See if X or Y is a better match
1088 strictly_better (x
, y
)
1089 unsigned short x
, y
;
1097 if (xor >= x
|| xor >= y
)
1102 /* When one of several possible overloaded functions and/or methods
1103 can be called, choose the best candidate for overloading.
1105 BASETYPE is the context from which we start method resolution
1106 or NULL if we are comparing overloaded functions.
1107 CANDIDATES is the array of candidates we have to choose from.
1108 N_CANDIDATES is the length of CANDIDATES.
1109 PARMS is a TREE_LIST of parameters to the function we'll ultimately
1110 choose. It is modified in place when resolving methods. It is not
1111 modified in place when resolving overloaded functions.
1112 LEN is the length of the parameter list. */
1114 static struct candidate
*
1115 ideal_candidate (candidates
, n_candidates
, len
)
1116 struct candidate
*candidates
;
1120 struct candidate
*cp
= candidates
+n_candidates
;
1121 int i
, j
= -1, best_code
;
1123 /* For each argument, sort the functions from best to worst for the arg.
1124 For each function that's not best for this arg, set its overall
1125 harshness to EVIL so that other args won't like it. The candidate
1126 list for the last argument is the intersection of all the best-liked
1129 qsort (candidates
, n_candidates
, sizeof (struct candidate
),
1130 (int (*) PROTO((const void *, const void *))) rank_for_overload
);
1131 best_code
= cp
[-1].h
.code
;
1133 /* If they're at least as good as each other, do an arg-by-arg check. */
1134 if (! strictly_better (cp
[-1].h
.code
, cp
[-2].h
.code
))
1139 for (j
= 0; j
< n_candidates
; j
++)
1140 if (! strictly_better (candidates
[j
].h
.code
, best_code
))
1143 qsort (candidates
+j
, n_candidates
-j
, sizeof (struct candidate
),
1144 (int (*) PROTO((const void *, const void *))) rank_for_ideal
);
1145 for (i
= 0; i
< len
; i
++)
1147 if (cp
[-1].harshness
[i
].code
< cp
[-2].harshness
[i
].code
)
1149 else if (cp
[-1].harshness
[i
].code
> cp
[-2].harshness
[i
].code
)
1151 else if (cp
[-1].harshness
[i
].code
& STD_CODE
)
1153 /* If it involves a standard conversion, let the
1154 inheritance lattice be the final arbiter. */
1155 if (cp
[-1].harshness
[i
].distance
> cp
[-2].harshness
[i
].distance
)
1157 else if (cp
[-1].harshness
[i
].distance
< cp
[-2].harshness
[i
].distance
)
1160 else if (cp
[-1].harshness
[i
].code
& PROMO_CODE
)
1162 /* For integral promotions, take into account a finer
1163 granularity for determining which types should be favored
1164 over others in such promotions. */
1165 if (cp
[-1].harshness
[i
].int_penalty
> cp
[-2].harshness
[i
].int_penalty
)
1167 else if (cp
[-1].harshness
[i
].int_penalty
< cp
[-2].harshness
[i
].int_penalty
)
1172 if (! better
|| worse
)
1178 /* Assume that if the class referred to is not in the
1179 current class hierarchy, that it may be remote.
1180 PARENT is assumed to be of aggregate type here. */
1183 may_be_remote (parent
)
1186 if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent
) == 0)
1189 if (current_class_type
== NULL_TREE
)
1192 if (parent
== current_class_type
)
1195 if (UNIQUELY_DERIVED_FROM_P (parent
, current_class_type
))
1201 build_vfield_ref (datum
, type
)
1205 int old_assume_nonnull_objects
= flag_assume_nonnull_objects
;
1207 if (datum
== error_mark_node
)
1208 return error_mark_node
;
1210 /* Vtable references are always made from non-null objects. */
1211 flag_assume_nonnull_objects
= 1;
1212 if (TREE_CODE (TREE_TYPE (datum
)) == REFERENCE_TYPE
)
1213 datum
= convert_from_reference (datum
);
1215 if (! TYPE_USES_COMPLEX_INHERITANCE (type
))
1216 rval
= build (COMPONENT_REF
, TREE_TYPE (CLASSTYPE_VFIELD (type
)),
1217 datum
, CLASSTYPE_VFIELD (type
));
1219 rval
= build_component_ref (datum
, DECL_NAME (CLASSTYPE_VFIELD (type
)), NULL_TREE
, 0);
1220 flag_assume_nonnull_objects
= old_assume_nonnull_objects
;
1225 /* Build a call to a member of an object. I.e., one that overloads
1226 operator ()(), or is a pointer-to-function or pointer-to-method. */
1229 build_field_call (basetype_path
, instance_ptr
, name
, parms
)
1230 tree basetype_path
, instance_ptr
, name
, parms
;
1232 tree field
, instance
;
1234 if (name
== ctor_identifier
|| name
== dtor_identifier
)
1237 if (instance_ptr
== current_class_ptr
)
1239 /* Check to see if we really have a reference to an instance variable
1240 with `operator()()' overloaded. */
1241 field
= IDENTIFIER_CLASS_VALUE (name
);
1243 if (field
== NULL_TREE
)
1245 cp_error ("`this' has no member named `%D'", name
);
1246 return error_mark_node
;
1249 if (TREE_CODE (field
) == FIELD_DECL
)
1251 /* If it's a field, try overloading operator (),
1252 or calling if the field is a pointer-to-function. */
1253 instance
= build_component_ref_1 (current_class_ref
, field
, 0);
1254 if (instance
== error_mark_node
)
1255 return error_mark_node
;
1257 if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1258 && (TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance
))
1259 || flag_ansi_overloading
))
1260 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, instance
, parms
, NULL_TREE
);
1262 if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1264 if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == FUNCTION_TYPE
)
1265 return build_function_call (instance
, parms
);
1266 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == METHOD_TYPE
)
1267 return build_function_call (instance
, tree_cons (NULL_TREE
, current_class_ptr
, parms
));
1273 /* Check to see if this is not really a reference to an instance variable
1274 with `operator()()' overloaded. */
1275 field
= lookup_field (basetype_path
, name
, 1, 0);
1277 /* This can happen if the reference was ambiguous or for access
1279 if (field
== error_mark_node
)
1280 return error_mark_node
;
1285 tree ftype
= TREE_TYPE (field
);
1287 if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
1288 ftype
= TREE_TYPE (ftype
);
1290 if (TYPE_LANG_SPECIFIC (ftype
)
1291 && (TYPE_OVERLOADS_CALL_EXPR (ftype
) || flag_ansi_overloading
))
1293 /* Make the next search for this field very short. */
1294 basetype
= DECL_FIELD_CONTEXT (field
);
1295 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
1297 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1298 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
,
1299 build_component_ref_1 (instance
, field
, 0),
1302 if (TREE_CODE (ftype
) == POINTER_TYPE
)
1304 if (TREE_CODE (TREE_TYPE (ftype
)) == FUNCTION_TYPE
1305 || TREE_CODE (TREE_TYPE (ftype
)) == METHOD_TYPE
)
1307 /* This is a member which is a pointer to function. */
1309 = build_component_ref_1 (build_indirect_ref (instance_ptr
,
1311 field
, LOOKUP_COMPLAIN
);
1312 if (ref
== error_mark_node
)
1313 return error_mark_node
;
1314 return build_function_call (ref
, parms
);
1317 else if (TREE_CODE (ftype
) == METHOD_TYPE
)
1319 error ("invalid call via pointer-to-member function");
1320 return error_mark_node
;
1329 find_scoped_type (type
, inner_name
, inner_types
)
1330 tree type
, inner_name
, inner_types
;
1332 tree tags
= CLASSTYPE_TAGS (type
);
1336 /* The TREE_PURPOSE of an enum tag (which becomes a member of the
1337 enclosing class) is set to the name for the enum type. So, if
1338 inner_name is `bar', and we strike `baz' for `enum bar { baz }',
1339 then this test will be true. */
1340 if (TREE_PURPOSE (tags
) == inner_name
)
1342 if (inner_types
== NULL_TREE
)
1343 return TYPE_MAIN_DECL (TREE_VALUE (tags
));
1344 return resolve_scope_to_name (TREE_VALUE (tags
), inner_types
);
1346 tags
= TREE_CHAIN (tags
);
1349 /* Look for a TYPE_DECL. */
1350 for (tags
= TYPE_FIELDS (type
); tags
; tags
= TREE_CHAIN (tags
))
1351 if (TREE_CODE (tags
) == TYPE_DECL
&& DECL_NAME (tags
) == inner_name
)
1353 /* Code by raeburn. */
1354 if (inner_types
== NULL_TREE
)
1356 return resolve_scope_to_name (TREE_TYPE (tags
), inner_types
);
1362 /* Resolve an expression NAME1::NAME2::...::NAMEn to
1363 the name that names the above nested type. INNER_TYPES
1364 is a chain of nested type names (held together by SCOPE_REFs);
1365 OUTER_TYPE is the type we know to enclose INNER_TYPES.
1366 Returns NULL_TREE if there is an error. */
1369 resolve_scope_to_name (outer_type
, inner_stuff
)
1370 tree outer_type
, inner_stuff
;
1373 tree inner_name
, inner_type
;
1375 if (outer_type
== NULL_TREE
&& current_class_type
!= NULL_TREE
)
1377 /* We first try to look for a nesting in our current class context,
1378 then try any enclosing classes. */
1379 tree type
= current_class_type
;
1381 while (type
&& (TREE_CODE (type
) == RECORD_TYPE
1382 || TREE_CODE (type
) == UNION_TYPE
))
1384 tree rval
= resolve_scope_to_name (type
, inner_stuff
);
1386 if (rval
!= NULL_TREE
)
1388 type
= DECL_CONTEXT (TYPE_MAIN_DECL (type
));
1392 if (TREE_CODE (inner_stuff
) == SCOPE_REF
)
1394 inner_name
= TREE_OPERAND (inner_stuff
, 0);
1395 inner_type
= TREE_OPERAND (inner_stuff
, 1);
1399 inner_name
= inner_stuff
;
1400 inner_type
= NULL_TREE
;
1403 if (outer_type
== NULL_TREE
)
1406 /* If we have something that's already a type by itself,
1408 if (IDENTIFIER_HAS_TYPE_VALUE (inner_name
))
1411 return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name
),
1416 x
= lookup_name (inner_name
, 0);
1418 if (x
&& TREE_CODE (x
) == NAMESPACE_DECL
)
1420 x
= lookup_namespace_name (x
, inner_type
);
1426 if (! IS_AGGR_TYPE (outer_type
))
1429 /* Look for member classes or enums. */
1430 tmp
= find_scoped_type (outer_type
, inner_name
, inner_type
);
1432 /* If it's not a type in this class, then go down into the
1433 base classes and search there. */
1434 if (! tmp
&& TYPE_BINFO (outer_type
))
1436 tree binfos
= TYPE_BINFO_BASETYPES (outer_type
);
1437 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1439 for (i
= 0; i
< n_baselinks
; i
++)
1441 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1442 tmp
= resolve_scope_to_name (BINFO_TYPE (base_binfo
), inner_stuff
);
1452 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
1453 This is how virtual function calls are avoided. */
1456 build_scoped_method_call (exp
, basetype
, name
, parms
)
1457 tree exp
, basetype
, name
, parms
;
1459 /* Because this syntactic form does not allow
1460 a pointer to a base class to be `stolen',
1461 we need not protect the derived->base conversion
1464 @@ But we do have to check access privileges later. */
1466 tree type
= TREE_TYPE (exp
);
1468 if (type
== error_mark_node
1469 || basetype
== error_mark_node
)
1470 return error_mark_node
;
1472 if (processing_template_decl
)
1474 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1476 tree type
= get_aggr_from_typedef (TREE_OPERAND (name
, 0), 1);
1477 name
= build_min_nt (BIT_NOT_EXPR
, type
);
1479 name
= build_min_nt (SCOPE_REF
, basetype
, name
);
1480 return build_min_nt (METHOD_CALL_EXPR
, name
, exp
, parms
, NULL_TREE
);
1483 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1484 type
= TREE_TYPE (type
);
1486 if (TREE_CODE (basetype
) == TREE_VEC
)
1489 basetype
= BINFO_TYPE (binfo
);
1494 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
1495 that explicit ~int is caught in the parser; this deals with typedefs
1496 and template parms. */
1497 if (TREE_CODE (name
) == BIT_NOT_EXPR
&& ! IS_AGGR_TYPE (basetype
))
1499 if (type
!= basetype
)
1500 cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
1501 exp
, basetype
, type
);
1502 name
= TREE_OPERAND (name
, 0);
1503 if (basetype
!= name
&& basetype
!= get_type_value (name
))
1504 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1506 return cp_convert (void_type_node
, exp
);
1509 if (! is_aggr_type (basetype
, 1))
1510 return error_mark_node
;
1512 if (! IS_AGGR_TYPE (type
))
1514 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
1516 return error_mark_node
;
1521 binfo
= get_binfo (basetype
, type
, 1);
1522 if (binfo
== error_mark_node
)
1523 return error_mark_node
;
1525 error_not_base_type (basetype
, type
);
1530 if (TREE_CODE (exp
) == INDIRECT_REF
)
1531 decl
= build_indirect_ref
1532 (convert_pointer_to_real
1533 (binfo
, build_unary_op (ADDR_EXPR
, exp
, 0)), NULL_PTR
);
1535 decl
= build_scoped_ref (exp
, basetype
);
1537 /* Call to a destructor. */
1538 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1540 /* Explicit call to destructor. */
1541 name
= TREE_OPERAND (name
, 0);
1542 if (! (name
== TYPE_MAIN_VARIANT (TREE_TYPE (decl
))
1543 || name
== constructor_name (TREE_TYPE (decl
))
1544 || TREE_TYPE (decl
) == get_type_value (name
)))
1547 ("qualified type `%T' does not match destructor name `~%T'",
1548 TREE_TYPE (decl
), name
);
1549 return error_mark_node
;
1551 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl
)))
1552 return cp_convert (void_type_node
, exp
);
1554 return build_delete (TREE_TYPE (decl
), decl
, integer_two_node
,
1555 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
,
1559 /* Call to a method. */
1560 return build_method_call (decl
, name
, parms
, binfo
,
1561 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1563 return error_mark_node
;
1567 print_candidates (candidates
)
1570 cp_error_at ("candidates are: %D", TREE_VALUE (candidates
));
1571 candidates
= TREE_CHAIN (candidates
);
1575 cp_error_at (" %D", TREE_VALUE (candidates
));
1576 candidates
= TREE_CHAIN (candidates
);
1581 print_n_candidates (candidates
, n
)
1582 struct candidate
*candidates
;
1587 cp_error_at ("candidates are: %D", candidates
[0].function
);
1588 for (i
= 1; i
< n
; i
++)
1589 cp_error_at (" %D", candidates
[i
].function
);
1592 /* We want the address of a function or method. We avoid creating a
1593 pointer-to-member function. */
1596 build_addr_func (function
)
1599 tree type
= TREE_TYPE (function
);
1601 /* We have to do these by hand to avoid real pointer to member
1603 if (TREE_CODE (type
) == METHOD_TYPE
)
1607 type
= build_pointer_type (type
);
1609 if (mark_addressable (function
) == 0)
1610 return error_mark_node
;
1612 addr
= build1 (ADDR_EXPR
, type
, function
);
1614 /* Address of a static or external variable or function counts
1616 if (staticp (function
))
1617 TREE_CONSTANT (addr
) = 1;
1622 function
= default_conversion (function
);
1627 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
1628 POINTER_TYPE to those. Note, pointer to member function types
1629 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
1632 build_call (function
, result_type
, parms
)
1633 tree function
, result_type
, parms
;
1635 int is_constructor
= 0;
1637 function
= build_addr_func (function
);
1639 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
1641 sorry ("unable to call pointer to member function here");
1642 return error_mark_node
;
1645 if (TREE_CODE (function
) == ADDR_EXPR
1646 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
1647 && DECL_CONSTRUCTOR_P (TREE_OPERAND (function
, 0)))
1650 function
= build_nt (CALL_EXPR
, function
, parms
, NULL_TREE
);
1651 TREE_HAS_CONSTRUCTOR (function
) = is_constructor
;
1652 TREE_TYPE (function
) = result_type
;
1653 TREE_SIDE_EFFECTS (function
) = 1;
1659 default_parm_conversions (parms
, last
)
1662 tree parm
, parmtypes
= NULL_TREE
;
1666 for (parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1668 tree t
= TREE_TYPE (TREE_VALUE (parm
));
1670 if (TREE_CODE (t
) == OFFSET_TYPE
1671 || TREE_CODE (t
) == METHOD_TYPE
1672 || TREE_CODE (t
) == FUNCTION_TYPE
)
1674 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
1675 t
= TREE_TYPE (TREE_VALUE (parm
));
1678 if (t
== error_mark_node
)
1679 return error_mark_node
;
1681 *last
= build_tree_list (NULL_TREE
, t
);
1682 parmtypes
= chainon (parmtypes
, *last
);
1689 /* Build something of the form ptr->method (args)
1690 or object.method (args). This can also build
1691 calls to constructors, and find friends.
1693 Member functions always take their class variable
1696 INSTANCE is a class instance.
1698 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
1700 PARMS help to figure out what that NAME really refers to.
1702 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
1703 down to the real instance type to use for access checking. We need this
1704 information to get protected accesses correct. This parameter is used
1705 by build_member_call.
1707 FLAGS is the logical disjunction of zero or more LOOKUP_
1708 flags. See cp-tree.h for more info.
1710 If this is all OK, calls build_function_call with the resolved
1713 This function must also handle being called to perform
1714 initialization, promotion/coercion of arguments, and
1715 instantiation of default parameters.
1717 Note that NAME may refer to an instance variable name. If
1718 `operator()()' is defined for the type of that field, then we return
1722 build_method_call (instance
, name
, parms
, basetype_path
, flags
)
1723 tree instance
, name
, parms
, basetype_path
;
1726 register tree function
, fntype
, value_type
;
1727 register tree basetype
, save_basetype
;
1728 register tree baselink
, result
, parmtypes
;
1731 tree access
= access_public_node
;
1732 tree orig_basetype
= basetype_path
? BINFO_TYPE (basetype_path
) : NULL_TREE
;
1734 /* Range of cases for vtable optimization. */
1735 enum vtable_needs
{ not_needed
, maybe_needed
, unneeded
, needed
};
1736 enum vtable_needs need_vtbl
= not_needed
;
1739 tree save_name
= name
;
1741 tree instance_ptr
= NULL_TREE
;
1742 int all_virtual
= flag_all_virtual
;
1743 int static_call_context
= 0;
1744 tree found_fns
= NULL_TREE
;
1746 /* Keep track of `const' and `volatile' objects. */
1747 int constp
, volatilep
;
1749 #ifdef GATHER_STATISTICS
1750 n_build_method_call
++;
1753 if (instance
== error_mark_node
1754 || name
== error_mark_node
1755 || parms
== error_mark_node
1756 || (instance
!= NULL_TREE
&& TREE_TYPE (instance
) == error_mark_node
))
1757 return error_mark_node
;
1759 if (processing_template_decl
)
1761 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1763 tree type
= get_aggr_from_typedef (TREE_OPERAND (name
, 0), 1);
1764 name
= build_min_nt (BIT_NOT_EXPR
, type
);
1767 return build_min_nt (METHOD_CALL_EXPR
, name
, instance
, parms
, NULL_TREE
);
1770 /* This is the logic that magically deletes the second argument to
1771 operator delete, if it is not needed. */
1772 if (name
== ansi_opname
[(int) DELETE_EXPR
] && list_length (parms
)==2)
1774 tree save_last
= TREE_CHAIN (parms
);
1776 /* get rid of unneeded argument */
1777 TREE_CHAIN (parms
) = NULL_TREE
;
1778 result
= build_method_call (instance
, name
, parms
, basetype_path
,
1779 (LOOKUP_SPECULATIVELY
|flags
)
1781 /* If it finds a match, return it. */
1783 return build_method_call (instance
, name
, parms
, basetype_path
, flags
);
1784 /* If it doesn't work, two argument delete must work */
1785 TREE_CHAIN (parms
) = save_last
;
1787 /* We already know whether it's needed or not for vec delete. */
1788 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
1789 && TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1790 && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance
)))
1791 TREE_CHAIN (parms
) = NULL_TREE
;
1793 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1795 flags
|= LOOKUP_DESTRUCTOR
;
1796 name
= TREE_OPERAND (name
, 0);
1798 error ("destructors take no parameters");
1799 basetype
= TREE_TYPE (instance
);
1800 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1801 basetype
= TREE_TYPE (basetype
);
1802 if (! (name
== basetype
1803 || (IS_AGGR_TYPE (basetype
)
1804 && name
== constructor_name (basetype
))
1805 || basetype
== get_type_value (name
)))
1807 cp_error ("destructor name `~%D' does not match type `%T' of expression",
1809 return cp_convert (void_type_node
, instance
);
1812 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1813 return cp_convert (void_type_node
, instance
);
1814 instance
= default_conversion (instance
);
1815 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1816 return build_delete (build_pointer_type (basetype
),
1817 instance_ptr
, integer_two_node
,
1818 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0);
1821 if (flag_ansi_overloading
)
1822 return build_new_method_call (instance
, name
, parms
, basetype_path
, flags
);
1827 /* Initialize name for error reporting. */
1828 if (IDENTIFIER_OPNAME_P (name
) && ! IDENTIFIER_TYPENAME_P (name
))
1830 char *p
= operator_name_string (name
);
1831 xref_name
= (char *)alloca (strlen (p
) + 10);
1832 sprintf (xref_name
, "operator %s", p
);
1834 else if (TREE_CODE (name
) == SCOPE_REF
)
1835 xref_name
= IDENTIFIER_POINTER (TREE_OPERAND (name
, 1));
1837 xref_name
= IDENTIFIER_POINTER (name
);
1839 GNU_xref_call (current_function_decl
, xref_name
);
1842 if (instance
== NULL_TREE
)
1844 basetype
= NULL_TREE
;
1845 /* Check cases where this is really a call to raise
1847 if (current_class_type
&& TREE_CODE (name
) == IDENTIFIER_NODE
)
1849 basetype
= purpose_member (name
, CLASSTYPE_TAGS (current_class_type
));
1851 basetype
= TREE_VALUE (basetype
);
1853 else if (TREE_CODE (name
) == SCOPE_REF
1854 && TREE_CODE (TREE_OPERAND (name
, 0)) == IDENTIFIER_NODE
)
1856 if (! is_aggr_typedef (TREE_OPERAND (name
, 0), 1))
1857 return error_mark_node
;
1858 basetype
= purpose_member (TREE_OPERAND (name
, 1),
1859 CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name
, 0))));
1861 basetype
= TREE_VALUE (basetype
);
1864 if (basetype
!= NULL_TREE
)
1866 /* call to a constructor... */
1867 else if (basetype_path
)
1869 basetype
= BINFO_TYPE (basetype_path
);
1870 if (name
== TYPE_IDENTIFIER (basetype
))
1871 name
= ctor_identifier
;
1873 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1875 basetype
= IDENTIFIER_TYPE_VALUE (name
);
1876 name
= ctor_identifier
;
1880 tree typedef_name
= lookup_name (name
, 1);
1881 if (typedef_name
&& TREE_CODE (typedef_name
) == TYPE_DECL
)
1883 /* Canonicalize the typedef name. */
1884 basetype
= TREE_TYPE (typedef_name
);
1885 name
= ctor_identifier
;
1889 cp_error ("no constructor named `%T' in scope",
1891 return error_mark_node
;
1895 if (! IS_AGGR_TYPE (basetype
))
1898 if ((flags
& LOOKUP_COMPLAIN
) && basetype
!= error_mark_node
)
1899 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1900 name
, instance
, basetype
);
1902 return error_mark_node
;
1905 else if (instance
== current_class_ref
|| instance
== current_class_ptr
)
1907 /* When doing initialization, we side-effect the TREE_TYPE of
1908 current_class_ref, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */
1909 basetype
= TREE_TYPE (current_class_ref
);
1911 /* Anything manifestly `this' in constructors and destructors
1912 has a known type, so virtual function tables are not needed. */
1913 if (TYPE_VIRTUAL_P (basetype
)
1914 && !(flags
& LOOKUP_NONVIRTUAL
))
1915 need_vtbl
= (dtor_label
|| ctor_label
)
1916 ? unneeded
: maybe_needed
;
1918 /* If `this' is a signature pointer and `name' is not a constructor,
1919 we are calling a signature member function. In that case, set the
1920 `basetype' to the signature type and dereference the `optr' field. */
1921 if (IS_SIGNATURE_POINTER (basetype
)
1922 && TYPE_IDENTIFIER (basetype
) != name
)
1924 basetype
= SIGNATURE_TYPE (basetype
);
1925 instance_ptr
= instance
;
1926 basetype_path
= TYPE_BINFO (basetype
);
1930 instance
= current_class_ref
;
1931 instance_ptr
= current_class_ptr
;
1932 basetype_path
= TYPE_BINFO (current_class_type
);
1934 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1939 else if (TREE_CODE (instance
) == RESULT_DECL
)
1941 basetype
= TREE_TYPE (instance
);
1942 /* Should we ever have to make a virtual function reference
1943 from a RESULT_DECL, know that it must be of fixed type
1944 within the scope of this function. */
1945 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1946 need_vtbl
= maybe_needed
;
1947 instance_ptr
= build1 (ADDR_EXPR
, build_pointer_type (basetype
), instance
);
1951 /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */
1952 tree inst_ptr_basetype
;
1955 = (TREE_CODE (instance
) == INDIRECT_REF
1956 && TREE_CODE (TREE_OPERAND (instance
, 0)) == NOP_EXPR
1957 && TREE_OPERAND (TREE_OPERAND (instance
, 0), 0) == error_mark_node
);
1959 if (TREE_CODE (instance
) == OFFSET_REF
)
1960 instance
= resolve_offset_ref (instance
);
1962 /* the base type of an instance variable is pointer to class */
1963 basetype
= TREE_TYPE (instance
);
1965 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1967 basetype
= TREE_TYPE (basetype
);
1968 if (! IS_AGGR_TYPE (basetype
))
1969 goto non_aggr_error
;
1970 /* Call to convert not needed because we are remaining
1971 within the same type. */
1972 instance_ptr
= build1 (NOP_EXPR
, build_pointer_type (basetype
),
1974 inst_ptr_basetype
= TYPE_MAIN_VARIANT (basetype
);
1978 if (! IS_AGGR_TYPE (basetype
)
1979 && ! (TYPE_LANG_SPECIFIC (basetype
)
1980 && (IS_SIGNATURE_POINTER (basetype
)
1981 || IS_SIGNATURE_REFERENCE (basetype
))))
1982 goto non_aggr_error
;
1984 /* If `instance' is a signature pointer/reference and `name' is
1985 not a constructor, we are calling a signature member function.
1986 In that case set the `basetype' to the signature type. */
1987 if ((IS_SIGNATURE_POINTER (basetype
)
1988 || IS_SIGNATURE_REFERENCE (basetype
))
1989 && TYPE_IDENTIFIER (basetype
) != name
)
1990 basetype
= SIGNATURE_TYPE (basetype
);
1992 basetype
= complete_type (basetype
);
1994 if ((IS_SIGNATURE (basetype
)
1995 && (instance_ptr
= instance
))
1996 || (lvalue_p (instance
)
1997 && (instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0)))
1998 || (instance_ptr
= unary_complex_lvalue (ADDR_EXPR
, instance
)))
2000 if (instance_ptr
== error_mark_node
)
2001 return error_mark_node
;
2003 else if (TREE_CODE (instance
) == NOP_EXPR
2004 || TREE_CODE (instance
) == CONSTRUCTOR
)
2006 /* A cast is not an lvalue. Initialize a fresh temp
2007 with the value we are casting from, and proceed with
2008 that temporary. We can't cast to a reference type,
2009 so that simplifies the initialization to something
2011 tree temp
= get_temp_name (TREE_TYPE (instance
), 0);
2012 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
2013 expand_aggr_init (temp
, instance
, 0, flags
);
2016 store_init_value (temp
, instance
);
2017 expand_decl_init (temp
);
2020 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
2024 if (TREE_CODE (instance
) != CALL_EXPR
)
2025 my_friendly_abort (125);
2026 if (TYPE_NEEDS_CONSTRUCTING (basetype
))
2027 instance
= build_cplus_new (basetype
, instance
);
2030 instance
= get_temp_name (basetype
, 0);
2031 TREE_ADDRESSABLE (instance
) = 1;
2033 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
2035 /* @@ Should we call comp_target_types here? */
2036 if (IS_SIGNATURE (basetype
))
2037 inst_ptr_basetype
= basetype
;
2039 inst_ptr_basetype
= TREE_TYPE (TREE_TYPE (instance_ptr
));
2040 if (TYPE_MAIN_VARIANT (basetype
) == TYPE_MAIN_VARIANT (inst_ptr_basetype
))
2041 basetype
= inst_ptr_basetype
;
2044 instance_ptr
= cp_convert (build_pointer_type (basetype
), instance_ptr
);
2045 if (instance_ptr
== error_mark_node
)
2046 return error_mark_node
;
2050 /* After converting `instance_ptr' above, `inst_ptr_basetype' was
2051 not updated, so we use `basetype' instead. */
2052 if (basetype_path
== NULL_TREE
2053 && IS_SIGNATURE (basetype
))
2054 basetype_path
= TYPE_BINFO (basetype
);
2055 else if (basetype_path
== NULL_TREE
2056 || (BINFO_TYPE (basetype_path
)
2057 != TYPE_MAIN_VARIANT (inst_ptr_basetype
)))
2058 basetype_path
= TYPE_BINFO (inst_ptr_basetype
);
2060 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
2064 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
2066 if (TREE_SIDE_EFFECTS (instance_ptr
))
2068 /* This action is needed because the instance is needed
2069 for providing the base of the virtual function table.
2070 Without using a SAVE_EXPR, the function we are building
2071 may be called twice, or side effects on the instance
2072 variable (such as a post-increment), may happen twice. */
2073 instance_ptr
= save_expr (instance_ptr
);
2074 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2076 else if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
2078 /* This happens when called for operator new (). */
2079 instance
= build_indirect_ref (instance
, NULL_PTR
);
2082 need_vtbl
= maybe_needed
;
2086 if (save_name
== ctor_identifier
)
2087 save_name
= TYPE_IDENTIFIER (basetype
);
2089 if (TYPE_SIZE (complete_type (basetype
)) == 0)
2091 /* This is worth complaining about, I think. */
2092 cp_error ("cannot lookup method in incomplete type `%T'", basetype
);
2093 return error_mark_node
;
2096 save_basetype
= TYPE_MAIN_VARIANT (basetype
);
2098 parmtypes
= default_parm_conversions (parms
, &last
);
2099 if (parmtypes
== error_mark_node
)
2101 return error_mark_node
;
2104 if (instance
&& IS_SIGNATURE (basetype
))
2106 /* @@ Should this be the constp/volatilep flags for the optr field
2107 of the signature pointer? */
2108 constp
= TYPE_READONLY (basetype
);
2109 volatilep
= TYPE_VOLATILE (basetype
);
2110 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2114 /* TREE_READONLY (instance) fails for references. */
2115 constp
= TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2116 volatilep
= TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2117 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2121 /* Raw constructors are always in charge. */
2122 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2123 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2125 flags
|= LOOKUP_HAS_IN_CHARGE
;
2126 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
2127 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
2132 instance_ptr
= build_int_2 (0, 0);
2133 TREE_TYPE (instance_ptr
) = build_pointer_type (basetype
);
2134 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2137 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (instance_ptr
), parmtypes
);
2139 if (last
== NULL_TREE
)
2142 /* Look up function name in the structure type definition. */
2144 /* FIXME Axe most of this now? */
2145 if ((IDENTIFIER_HAS_TYPE_VALUE (name
)
2146 && ! IDENTIFIER_OPNAME_P (name
)
2147 && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name
)))
2148 || name
== constructor_name (basetype
)
2149 || name
== ctor_identifier
)
2151 tree tmp
= NULL_TREE
;
2152 if (IDENTIFIER_TYPE_VALUE (name
) == basetype
2153 || name
== constructor_name (basetype
)
2154 || name
== ctor_identifier
)
2155 tmp
= TYPE_BINFO (basetype
);
2157 tmp
= get_binfo (IDENTIFIER_TYPE_VALUE (name
), basetype
, 0);
2159 if (tmp
!= NULL_TREE
)
2161 name_kind
= "constructor";
2163 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2164 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2166 /* Constructors called for initialization
2167 only are never in charge. */
2170 flags
|= LOOKUP_HAS_IN_CHARGE
;
2171 tmplist
= tree_cons (NULL_TREE
, integer_zero_node
,
2172 TREE_CHAIN (parms
));
2173 TREE_CHAIN (parms
) = tmplist
;
2174 tmplist
= tree_cons (NULL_TREE
, integer_type_node
, TREE_CHAIN (parmtypes
));
2175 TREE_CHAIN (parmtypes
) = tmplist
;
2177 basetype
= BINFO_TYPE (tmp
);
2180 name_kind
= "method";
2183 name_kind
= "method";
2185 if (basetype_path
== NULL_TREE
2186 || BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (basetype
))
2187 basetype_path
= TYPE_BINFO (basetype
);
2188 result
= lookup_fnfields (basetype_path
, name
,
2189 (flags
& LOOKUP_COMPLAIN
));
2190 if (result
== error_mark_node
)
2191 return error_mark_node
;
2193 for (pass
= 0; pass
< 2; pass
++)
2195 struct candidate
*candidates
;
2196 struct candidate
*cp
;
2205 = (struct candidate
*) alloca ((ever_seen
+1)
2206 * sizeof (struct candidate
));
2207 bzero ((char *) candidates
, (ever_seen
+ 1) * sizeof (struct candidate
));
2209 len
= list_length (parms
);
2212 /* First see if a global function has a shot at it. */
2213 if (flags
& LOOKUP_GLOBAL
)
2216 tree parm
= instance_ptr
;
2218 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
)
2219 parm
= convert_from_reference (parm
);
2220 else if (TREE_CODE (TREE_TYPE (parm
)) == POINTER_TYPE
)
2221 parm
= build_indirect_ref (parm
, "friendifying parms (compiler error)");
2223 my_friendly_abort (167);
2225 friend_parms
= tree_cons (NULL_TREE
, parm
, TREE_CHAIN (parms
));
2228 cp
->harshness
= (struct harshness_code
*)
2229 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2231 result
= build_overload_call_real (name
, friend_parms
, 0, cp
, 1);
2233 /* If it turns out to be the one we were actually looking for
2234 (it was probably a friend function), the return the
2236 if (TREE_CODE (result
) == CALL_EXPR
)
2239 while ((cp
->h
.code
& EVIL_CODE
) == 0)
2241 /* non-standard uses: set the field to 0 to indicate
2242 we are using a non-member function. */
2244 if (cp
->harshness
[len
].distance
== 0
2245 && cp
->h
.code
< best
)
2254 /* We have a hit (of sorts). If the parameter list is
2255 "error_mark_node", or some variant thereof, it won't
2256 match any methods. Since we have verified that the is
2257 some method vaguely matching this one (in name at least),
2260 Don't stop for friends, however. */
2261 basetype_path
= TREE_PURPOSE (baselink
);
2263 function
= TREE_VALUE (baselink
);
2264 if (TREE_CODE (basetype_path
) == TREE_LIST
)
2265 basetype_path
= TREE_VALUE (basetype_path
);
2266 basetype
= BINFO_TYPE (basetype_path
);
2268 for (; function
; function
= DECL_CHAIN (function
))
2270 #ifdef GATHER_STATISTICS
2271 n_inner_fields_searched
++;
2275 found_fns
= tree_cons (NULL_TREE
, function
, found_fns
);
2277 /* Not looking for friends here. */
2278 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
2279 && ! DECL_STATIC_FUNCTION_P (function
))
2284 tree these_parms
= parms
;
2286 #ifdef GATHER_STATISTICS
2287 n_inner_fields_searched
++;
2290 cp
->harshness
= (struct harshness_code
*)
2291 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2293 if (DECL_STATIC_FUNCTION_P (function
))
2294 these_parms
= TREE_CHAIN (these_parms
);
2295 compute_conversion_costs (function
, these_parms
, cp
, len
);
2297 if ((cp
->h
.code
& EVIL_CODE
) == 0)
2299 cp
->u
.field
= function
;
2300 cp
->function
= function
;
2301 cp
->basetypes
= basetype_path
;
2303 /* Don't allow non-converting constructors to convert. */
2304 if (flags
& LOOKUP_ONLYCONVERTING
2305 && DECL_LANG_SPECIFIC (function
)
2306 && DECL_NONCONVERTING_P (function
))
2309 /* No "two-level" conversions. */
2310 if (flags
& LOOKUP_NO_CONVERSION
2311 && (cp
->h
.code
& USER_CODE
))
2322 tree igv
= lookup_name_nonclass (name
);
2324 /* No exact match could be found. Now try to find match
2325 using default conversions. */
2326 if ((flags
& LOOKUP_GLOBAL
) && igv
)
2328 if (TREE_CODE (igv
) == FUNCTION_DECL
)
2330 else if (TREE_CODE (igv
) == TREE_LIST
)
2331 ever_seen
+= count_functions (igv
);
2336 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2337 == LOOKUP_SPECULATIVELY
)
2340 TREE_CHAIN (last
) = void_list_node
;
2341 if (flags
& LOOKUP_GLOBAL
)
2342 cp_error ("no global or member function `%D(%A)' defined",
2343 save_name
, parmtypes
);
2345 cp_error ("no member function `%T::%D(%A)' defined",
2346 save_basetype
, save_name
, TREE_CHAIN (parmtypes
));
2347 return error_mark_node
;
2352 if (cp
- candidates
!= 0)
2354 /* Rank from worst to best. Then cp will point to best one.
2355 Private fields have their bits flipped. For unsigned
2356 numbers, this should make them look very large.
2357 If the best alternate has a (signed) negative value,
2358 then all we ever saw were private members. */
2359 if (cp
- candidates
> 1)
2361 int n_candidates
= cp
- candidates
;
2362 extern int warn_synth
;
2363 TREE_VALUE (parms
) = instance_ptr
;
2364 cp
= ideal_candidate (candidates
, n_candidates
, len
);
2365 if (cp
== (struct candidate
*)0)
2367 if (flags
& LOOKUP_COMPLAIN
)
2369 TREE_CHAIN (last
) = void_list_node
;
2370 cp_error ("call of overloaded %s `%D(%A)' is ambiguous",
2371 name_kind
, save_name
, TREE_CHAIN (parmtypes
));
2372 print_n_candidates (candidates
, n_candidates
);
2374 return error_mark_node
;
2376 if (cp
->h
.code
& EVIL_CODE
)
2377 return error_mark_node
;
2379 && DECL_NAME (cp
->function
) == ansi_opname
[MODIFY_EXPR
]
2380 && DECL_ARTIFICIAL (cp
->function
)
2381 && n_candidates
== 2)
2383 cp_warning ("using synthesized `%#D' for copy assignment",
2385 cp_warning_at (" where cfront would use `%#D'",
2386 candidates
->function
);
2389 else if (cp
[-1].h
.code
& EVIL_CODE
)
2391 if (flags
& LOOKUP_COMPLAIN
)
2392 cp_error ("ambiguous type conversion requested for %s `%D'",
2393 name_kind
, save_name
);
2394 return error_mark_node
;
2399 /* The global function was the best, so use it. */
2400 if (cp
->u
.field
== 0)
2402 /* We must convert the instance pointer into a reference type.
2403 Global overloaded functions can only either take
2404 aggregate objects (which come for free from references)
2405 or reference data types anyway. */
2406 TREE_VALUE (parms
) = copy_node (instance_ptr
);
2407 TREE_TYPE (TREE_VALUE (parms
)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2408 return build_function_call (cp
->function
, parms
);
2411 function
= cp
->function
;
2412 basetype_path
= cp
->basetypes
;
2413 if (! DECL_STATIC_FUNCTION_P (function
))
2414 TREE_VALUE (parms
) = cp
->arg
;
2415 goto found_and_maybe_warn
;
2418 if (flags
& (LOOKUP_COMPLAIN
|LOOKUP_SPECULATIVELY
))
2420 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2421 == LOOKUP_SPECULATIVELY
)
2424 if (DECL_STATIC_FUNCTION_P (cp
->function
))
2425 parms
= TREE_CHAIN (parms
);
2428 if (flags
& LOOKUP_SPECULATIVELY
)
2430 if (static_call_context
2431 && TREE_CODE (TREE_TYPE (cp
->function
)) == METHOD_TYPE
)
2432 cp_error ("object missing in call to `%D'", cp
->function
);
2433 else if (ever_seen
> 1)
2435 TREE_CHAIN (last
) = void_list_node
;
2436 cp_error ("no matching function for call to `%T::%D (%A)%V'",
2437 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (instance_ptr
))),
2438 save_name
, TREE_CHAIN (parmtypes
),
2439 TREE_TYPE (TREE_TYPE (instance_ptr
)));
2440 TREE_CHAIN (last
) = NULL_TREE
;
2441 print_candidates (found_fns
);
2444 report_type_mismatch (cp
, parms
, name_kind
);
2445 return error_mark_node
;
2448 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2451 cp_error ("%T has no method named %D", save_basetype
, save_name
);
2452 return error_mark_node
;
2458 found_and_maybe_warn
:
2459 if ((cp
->harshness
[0].code
& CONST_CODE
)
2460 /* 12.1p2: Constructors can be called for const objects. */
2461 && ! DECL_CONSTRUCTOR_P (cp
->function
))
2463 if (flags
& LOOKUP_COMPLAIN
)
2465 cp_error_at ("non-const member function `%D'", cp
->function
);
2466 error ("called for const object at this point in file");
2468 /* Not good enough for a match. */
2470 return error_mark_node
;
2474 /* Silently return error_mark_node. */
2475 return error_mark_node
;
2478 if (flags
& LOOKUP_PROTECT
)
2479 access
= compute_access (basetype_path
, function
);
2481 if (access
== access_private_node
)
2483 if (flags
& LOOKUP_COMPLAIN
)
2485 cp_error_at ("%s `%+#D' is %s", name_kind
, function
,
2486 TREE_PRIVATE (function
) ? "private"
2487 : "from private base class");
2488 error ("within this context");
2490 return error_mark_node
;
2492 else if (access
== access_protected_node
)
2494 if (flags
& LOOKUP_COMPLAIN
)
2496 cp_error_at ("%s `%+#D' %s", name_kind
, function
,
2497 TREE_PROTECTED (function
) ? "is protected"
2498 : "has protected accessibility");
2499 error ("within this context");
2501 return error_mark_node
;
2504 /* From here on down, BASETYPE is the type that INSTANCE_PTR's
2505 type (if it exists) is a pointer to. */
2507 if (DECL_ABSTRACT_VIRTUAL_P (function
)
2508 && instance
== current_class_ref
2509 && DECL_CONSTRUCTOR_P (current_function_decl
)
2510 && ! (flags
& LOOKUP_NONVIRTUAL
)
2511 && value_member (function
, get_abstract_virtuals (basetype
)))
2512 cp_error ("abstract virtual `%#D' called from constructor", function
);
2514 if (IS_SIGNATURE (basetype
))
2516 if (static_call_context
)
2518 cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
2519 basetype
, save_name
);
2520 return error_mark_node
;
2522 return build_signature_method_call (function
, parms
);
2525 function
= DECL_MAIN_VARIANT (function
);
2526 mark_used (function
);
2528 fntype
= TREE_TYPE (function
);
2529 if (TREE_CODE (fntype
) == POINTER_TYPE
)
2530 fntype
= TREE_TYPE (fntype
);
2531 basetype
= DECL_CLASS_CONTEXT (function
);
2533 /* If we are referencing a virtual function from an object
2534 of effectively static type, then there is no need
2535 to go through the virtual function table. */
2536 if (need_vtbl
== maybe_needed
)
2538 int fixed_type
= resolves_to_fixed_type_p (instance
, 0);
2540 if (all_virtual
== 1
2541 && DECL_VINDEX (function
)
2542 && may_be_remote (basetype
))
2544 else if (DECL_VINDEX (function
))
2545 need_vtbl
= fixed_type
? unneeded
: needed
;
2547 need_vtbl
= not_needed
;
2550 if (TREE_CODE (fntype
) == METHOD_TYPE
&& static_call_context
2551 && !DECL_CONSTRUCTOR_P (function
))
2553 /* Let's be nasty to the user now, and give reasonable
2555 instance_ptr
= current_class_ptr
;
2558 if (basetype
!= current_class_type
)
2560 if (basetype
== error_mark_node
)
2561 return error_mark_node
;
2564 if (orig_basetype
!= NULL_TREE
)
2565 error_not_base_type (orig_basetype
, current_class_type
);
2567 error_not_base_type (function
, current_class_type
);
2568 return error_mark_node
;
2572 /* Only allow a static member function to call another static member
2574 else if (DECL_LANG_SPECIFIC (function
)
2575 && !DECL_STATIC_FUNCTION_P (function
))
2577 cp_error ("cannot call member function `%D' without object",
2579 return error_mark_node
;
2583 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2585 if (TYPE_SIZE (complete_type (value_type
)) == 0)
2587 if (flags
& LOOKUP_COMPLAIN
)
2588 incomplete_type_error (0, value_type
);
2589 return error_mark_node
;
2592 if (DECL_STATIC_FUNCTION_P (function
))
2593 parms
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2594 TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
);
2595 else if (need_vtbl
== unneeded
)
2597 int sub_flags
= DECL_CONSTRUCTOR_P (function
) ? flags
: LOOKUP_NORMAL
;
2598 basetype
= TREE_TYPE (instance
);
2599 if (TYPE_METHOD_BASETYPE (TREE_TYPE (function
))
2600 != TYPE_MAIN_VARIANT (basetype
))
2602 basetype
= DECL_CLASS_CONTEXT (function
);
2603 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
2604 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2606 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2607 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, sub_flags
));
2611 if ((flags
& LOOKUP_NONVIRTUAL
) == 0)
2612 basetype
= DECL_CONTEXT (function
);
2614 /* First parm could be integer_zerop with casts like
2615 ((Object*)0)->Object::IsA() */
2616 if (!integer_zerop (TREE_VALUE (parms
)))
2618 /* Since we can't have inheritance with a union, doing get_binfo
2619 on it won't work. We do all the convert_pointer_to_real
2620 stuff to handle MI correctly...for unions, that's not
2621 an issue, so we must short-circuit that extra work here. */
2622 tree tmp
= TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)));
2623 if (tmp
!= NULL_TREE
&& TREE_CODE (tmp
) == UNION_TYPE
)
2624 instance_ptr
= TREE_VALUE (parms
);
2627 tree binfo
= get_binfo (basetype
,
2628 TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
))),
2630 instance_ptr
= convert_pointer_to_real (binfo
, TREE_VALUE (parms
));
2633 = convert_pointer_to (build_type_variant (basetype
,
2637 if (TREE_CODE (instance_ptr
) == COND_EXPR
)
2639 instance_ptr
= save_expr (instance_ptr
);
2640 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2642 else if (TREE_CODE (instance_ptr
) == NOP_EXPR
2643 && TREE_CODE (TREE_OPERAND (instance_ptr
, 0)) == ADDR_EXPR
2644 && TREE_OPERAND (TREE_OPERAND (instance_ptr
, 0), 0) == instance
)
2646 /* The call to `convert_pointer_to' may return error_mark_node. */
2647 else if (instance_ptr
== error_mark_node
)
2648 return instance_ptr
;
2649 else if (instance
== NULL_TREE
2650 || TREE_CODE (instance
) != INDIRECT_REF
2651 || TREE_OPERAND (instance
, 0) != instance_ptr
)
2652 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2654 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2655 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
));
2658 if (parms
== error_mark_node
2659 || (parms
&& TREE_CHAIN (parms
) == error_mark_node
))
2660 return error_mark_node
;
2662 if (need_vtbl
== needed
)
2664 function
= build_vfn_ref (&TREE_VALUE (parms
), instance
,
2665 DECL_VINDEX (function
));
2666 TREE_TYPE (function
) = build_pointer_type (fntype
);
2669 if (TREE_CODE (function
) == FUNCTION_DECL
)
2670 GNU_xref_call (current_function_decl
,
2671 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)));
2673 result
= build_call (function
, value_type
, parms
);
2674 if (IS_AGGR_TYPE (value_type
))
2675 result
= build_cplus_new (value_type
, result
);
2676 result
= convert_from_reference (result
);
2680 /* Similar to `build_method_call', but for overloaded non-member functions.
2681 The name of this function comes through NAME. The name depends
2684 Note that this function must handle simple `C' promotions,
2685 as well as variable numbers of arguments (...), and
2686 default arguments to boot.
2688 If the overloading is successful, we return a tree node which
2689 contains the call to the function.
2691 If overloading produces candidates which are probable, but not definite,
2692 we hold these candidates. If FINAL_CP is non-zero, then we are free
2693 to assume that final_cp points to enough storage for all candidates that
2694 this function might generate. The `harshness' array is preallocated for
2695 the first candidate, but not for subsequent ones.
2697 Note that the DECL_RTL of FUNCTION must be made to agree with this
2698 function's new name. */
2701 build_overload_call_real (fnname
, parms
, flags
, final_cp
, require_complete
)
2704 struct candidate
*final_cp
;
2705 int require_complete
;
2707 /* must check for overloading here */
2708 tree functions
, function
;
2709 tree parmtypes
, last
;
2710 register tree outer
;
2712 int parmlength
= list_length (parms
);
2714 struct candidate
*candidates
, *cp
;
2718 final_cp
[0].h
.code
= 0;
2719 final_cp
[0].h
.distance
= 0;
2720 final_cp
[0].function
= 0;
2722 final_cp
[1].h
.code
= EVIL_CODE
;
2725 parmtypes
= default_parm_conversions (parms
, &last
);
2726 if (parmtypes
== error_mark_node
)
2729 final_cp
->h
.code
= EVIL_CODE
;
2730 return error_mark_node
;
2734 TREE_CHAIN (last
) = void_list_node
;
2736 parmtypes
= void_list_node
;
2738 if (is_overloaded_fn (fnname
))
2741 if (TREE_CODE (fnname
) == TREE_LIST
)
2742 fnname
= TREE_PURPOSE (functions
);
2743 else if (TREE_CODE (fnname
) == FUNCTION_DECL
)
2744 fnname
= DECL_NAME (functions
);
2747 functions
= lookup_name_nonclass (fnname
);
2749 if (functions
== NULL_TREE
)
2751 if (flags
& LOOKUP_SPECULATIVELY
)
2753 if (flags
& LOOKUP_COMPLAIN
)
2754 error ("only member functions apply");
2756 final_cp
->h
.code
= EVIL_CODE
;
2757 return error_mark_node
;
2760 if (TREE_CODE (functions
) == FUNCTION_DECL
&& ! IDENTIFIER_OPNAME_P (fnname
))
2762 functions
= DECL_MAIN_VARIANT (functions
);
2765 /* We are just curious whether this is a viable alternative or
2767 compute_conversion_costs (functions
, parms
, final_cp
, parmlength
);
2771 return build_function_call_real (functions
, parms
, 1, flags
);
2774 if (TREE_CODE (functions
) == TREE_LIST
2775 && TREE_VALUE (functions
) == NULL_TREE
)
2777 if (flags
& LOOKUP_SPECULATIVELY
)
2780 if (flags
& LOOKUP_COMPLAIN
)
2781 cp_error ("function `%D' declared overloaded, but no instances of that function declared",
2782 TREE_PURPOSE (functions
));
2784 final_cp
->h
.code
= EVIL_CODE
;
2785 return error_mark_node
;
2788 length
= count_functions (functions
);
2791 candidates
= final_cp
;
2795 = (struct candidate
*)alloca ((length
+1) * sizeof (struct candidate
));
2796 bzero ((char *) candidates
, (length
+ 1) * sizeof (struct candidate
));
2801 my_friendly_assert (is_overloaded_fn (functions
), 169);
2803 functions
= get_first_fn (functions
);
2805 /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
2806 for (outer
= functions
; outer
; outer
= DECL_CHAIN (outer
))
2808 int template_cost
= 0;
2810 if (TREE_CODE (function
) != FUNCTION_DECL
2811 && ! (TREE_CODE (function
) == TEMPLATE_DECL
2812 && TREE_CODE (DECL_TEMPLATE_RESULT (function
)) == FUNCTION_DECL
))
2814 enum tree_code code
= TREE_CODE (function
);
2815 if (code
== TEMPLATE_DECL
)
2816 code
= TREE_CODE (DECL_TEMPLATE_RESULT (function
));
2817 if (code
== CONST_DECL
)
2819 ("enumeral value `%D' conflicts with function of same name",
2821 else if (code
== VAR_DECL
)
2823 if (TREE_STATIC (function
))
2825 ("variable `%D' conflicts with function of same name",
2829 ("constant field `%D' conflicts with function of same name",
2832 else if (code
== TYPE_DECL
)
2835 my_friendly_abort (2);
2836 error ("at this point in file");
2839 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2841 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function
));
2842 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
2845 i
= type_unification (DECL_TEMPLATE_PARMS (function
), targs
,
2846 TYPE_ARG_TYPES (TREE_TYPE (function
)),
2847 parms
, &template_cost
, 0, 0);
2850 function
= instantiate_template (function
, targs
);
2851 if (function
== error_mark_node
)
2856 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2858 /* Unconverted template -- failed match. */
2859 cp
->function
= function
;
2861 cp
->h
.code
= EVIL_CODE
;
2865 struct candidate
*cp2
;
2867 /* Check that this decl is not the same as a function that's in
2868 the list due to some template instantiation. */
2871 if (cp2
->function
== function
)
2875 if (cp2
->function
== function
)
2878 function
= DECL_MAIN_VARIANT (function
);
2880 /* Can't use alloca here, since result might be
2881 passed to calling function. */
2882 cp
->h_len
= parmlength
;
2883 cp
->harshness
= (struct harshness_code
*)
2884 oballoc ((parmlength
+ 1) * sizeof (struct harshness_code
));
2886 compute_conversion_costs (function
, parms
, cp
, parmlength
);
2888 /* Make sure this is clear as well. */
2889 cp
->h
.int_penalty
+= template_cost
;
2891 if ((cp
[0].h
.code
& EVIL_CODE
) == 0)
2893 cp
[1].h
.code
= EVIL_CODE
;
2899 if (cp
- candidates
)
2901 tree rval
= error_mark_node
;
2904 cp
[0].h
.code
= EVIL_CODE
;
2905 if (cp
- candidates
> 1)
2907 struct candidate
*best_cp
2908 = ideal_candidate (candidates
, cp
- candidates
, parmlength
);
2909 if (best_cp
== (struct candidate
*)0)
2911 if (flags
& LOOKUP_COMPLAIN
)
2913 cp_error ("call of overloaded `%D' is ambiguous", fnname
);
2914 print_n_candidates (candidates
, cp
- candidates
);
2916 return error_mark_node
;
2919 rval
= best_cp
->function
;
2924 if (cp
->h
.code
& EVIL_CODE
)
2926 if (flags
& LOOKUP_COMPLAIN
)
2927 error ("type conversion ambiguous");
2930 rval
= cp
->function
;
2936 return build_function_call_real (rval
, parms
, require_complete
, flags
);
2939 if (flags
& LOOKUP_SPECULATIVELY
)
2942 if (flags
& LOOKUP_COMPLAIN
)
2943 report_type_mismatch (cp
, parms
, "function");
2945 return error_mark_node
;
2948 /* This requires a complete type on the result of the call. */
2951 build_overload_call (fnname
, parms
, flags
)
2955 return build_overload_call_real (fnname
, parms
, flags
, (struct candidate
*)0, 1);
2958 /* New overloading code. */
2960 struct z_candidate
{
2967 struct z_candidate
*next
;
2970 #define IDENTITY_RANK 0
2971 #define EXACT_RANK 1
2972 #define PROMO_RANK 2
2974 #define PBOOL_RANK 4
2976 #define ELLIPSIS_RANK 6
2979 #define ICS_RANK(NODE) \
2980 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
2981 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
2982 : ICS_USER_FLAG (NODE) ? USER_RANK \
2983 : ICS_STD_RANK (NODE))
2985 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
2987 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
2988 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
2989 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
2990 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
2992 #define USER_CONV_FN(NODE) TREE_OPERAND (NODE, 1)
2999 || integer_zerop (t
) && INTEGRAL_TYPE_P (TREE_TYPE (t
)))
3001 /* Remove this eventually. */
3002 if (! pedantic
&& TREE_TYPE (t
) == ptr_type_node
&& integer_zerop (t
))
3008 build_conv (code
, type
, from
)
3009 enum tree_code code
;
3012 tree t
= build1 (code
, type
, from
);
3013 int rank
= ICS_STD_RANK (from
);
3020 if (rank
< STD_RANK
)
3027 if (rank
< EXACT_RANK
)
3033 ICS_STD_RANK (t
) = rank
;
3034 ICS_USER_FLAG (t
) = ICS_USER_FLAG (from
);
3035 ICS_BAD_FLAG (t
) = ICS_BAD_FLAG (from
);
3043 if (TREE_CODE (t
) == REFERENCE_TYPE
)
3052 if (TREE_CODE (t
) == ARRAY_TYPE
)
3054 return TYPE_MAIN_VARIANT (t
);
3057 /* Returns the standard conversion path (see [conv]) from type FROM to type
3058 TO, if any. For proper handling of null pointer constants, you must
3059 also pass the expression EXPR to convert from. */
3062 standard_conversion (to
, from
, expr
)
3063 tree to
, from
, expr
;
3065 enum tree_code fcode
, tcode
;
3069 if (TREE_CODE (to
) == REFERENCE_TYPE
)
3070 to
= TREE_TYPE (to
);
3071 if (TREE_CODE (from
) == REFERENCE_TYPE
)
3074 from
= TREE_TYPE (from
);
3076 to
= strip_top_quals (to
);
3077 from
= strip_top_quals (from
);
3079 fcode
= TREE_CODE (from
);
3080 tcode
= TREE_CODE (to
);
3082 conv
= build1 (IDENTITY_CONV
, from
, expr
);
3084 if (fcode
== FUNCTION_TYPE
)
3086 from
= build_pointer_type (from
);
3087 fcode
= TREE_CODE (from
);
3088 conv
= build_conv (LVALUE_CONV
, from
, conv
);
3090 else if (fcode
== ARRAY_TYPE
)
3092 from
= build_pointer_type (TREE_TYPE (from
));
3093 fcode
= TREE_CODE (from
);
3094 conv
= build_conv (LVALUE_CONV
, from
, conv
);
3096 else if (fromref
|| (expr
&& real_lvalue_p (expr
)))
3097 conv
= build_conv (RVALUE_CONV
, from
, conv
);
3102 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (to
))
3103 && expr
&& null_ptr_cst_p (expr
))
3105 conv
= build_conv (STD_CONV
, to
, conv
);
3107 else if (tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
3109 enum tree_code ufcode
= TREE_CODE (TREE_TYPE (from
));
3110 enum tree_code utcode
= TREE_CODE (TREE_TYPE (to
));
3111 tree nconv
= NULL_TREE
;
3113 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (from
)),
3114 TYPE_MAIN_VARIANT (TREE_TYPE (to
)), 1))
3116 else if (utcode
== VOID_TYPE
&& ufcode
!= OFFSET_TYPE
3117 && ufcode
!= FUNCTION_TYPE
)
3119 from
= build_pointer_type
3120 (cp_build_type_variant (void_type_node
,
3121 TYPE_READONLY (TREE_TYPE (from
)),
3122 TYPE_VOLATILE (TREE_TYPE (from
))));
3123 nconv
= build_conv (PTR_CONV
, from
, conv
);
3125 else if (ufcode
== OFFSET_TYPE
&& utcode
== OFFSET_TYPE
)
3127 tree fbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (from
));
3128 tree tbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (to
));
3130 if (DERIVED_FROM_P (fbase
, tbase
)
3131 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (from
))),
3132 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (to
))),
3135 from
= build_offset_type (tbase
, TREE_TYPE (TREE_TYPE (from
)));
3136 from
= build_pointer_type (from
);
3137 nconv
= build_conv (PMEM_CONV
, from
, conv
);
3140 else if (IS_AGGR_TYPE (TREE_TYPE (from
))
3141 && IS_AGGR_TYPE (TREE_TYPE (to
)))
3143 if (DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
3145 from
= cp_build_type_variant (TREE_TYPE (to
),
3146 TYPE_READONLY (TREE_TYPE (from
)),
3147 TYPE_VOLATILE (TREE_TYPE (from
)));
3148 from
= build_pointer_type (from
);
3149 nconv
= build_conv (PTR_CONV
, from
, conv
);
3153 if (nconv
&& comptypes (from
, to
, 1))
3155 else if (nconv
&& comp_ptr_ttypes (TREE_TYPE (to
), TREE_TYPE (from
)))
3156 conv
= build_conv (QUAL_CONV
, to
, nconv
);
3157 else if (ptr_reasonably_similar (TREE_TYPE (to
), TREE_TYPE (from
)))
3159 conv
= build_conv (PTR_CONV
, to
, conv
);
3160 ICS_BAD_FLAG (conv
) = 1;
3167 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
3169 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
3170 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
3171 tree fbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn
)));
3172 tree tbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn
)));
3174 if (! DERIVED_FROM_P (fbase
, tbase
)
3175 || ! comptypes (TREE_TYPE (fromfn
), TREE_TYPE (tofn
), 1)
3176 || ! compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)),
3177 TREE_CHAIN (TYPE_ARG_TYPES (tofn
)), 1)
3178 || TYPE_READONLY (fbase
) != TYPE_READONLY (tbase
)
3179 || TYPE_VOLATILE (fbase
) != TYPE_VOLATILE (tbase
))
3182 from
= cp_build_type_variant (tbase
, TYPE_READONLY (fbase
),
3183 TYPE_VOLATILE (fbase
));
3184 from
= build_cplus_method_type (from
, TREE_TYPE (fromfn
),
3185 TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)));
3186 from
= build_ptrmemfunc_type (build_pointer_type (from
));
3187 conv
= build_conv (PMEM_CONV
, from
, conv
);
3189 else if (tcode
== BOOLEAN_TYPE
)
3191 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
3192 || fcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (from
)))
3195 conv
= build_conv (STD_CONV
, to
, conv
);
3196 if (fcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (from
)
3197 && ICS_STD_RANK (conv
) < PBOOL_RANK
)
3198 ICS_STD_RANK (conv
) = PBOOL_RANK
;
3200 /* We don't check for ENUMERAL_TYPE here because there are no standard
3201 conversions to enum type. */
3202 else if (tcode
== INTEGER_TYPE
|| tcode
== BOOLEAN_TYPE
3203 || tcode
== REAL_TYPE
)
3205 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
))
3207 conv
= build_conv (STD_CONV
, to
, conv
);
3209 /* Give this a better rank if it's a promotion. */
3210 if (to
== type_promotes_to (from
)
3211 && ICS_STD_RANK (TREE_OPERAND (conv
, 0)) <= PROMO_RANK
)
3212 ICS_STD_RANK (conv
) = PROMO_RANK
;
3214 else if (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
3215 && DERIVED_FROM_P (to
, from
))
3216 conv
= build_conv (BASE_CONV
, to
, conv
);
3223 /* Returns the conversion path from type FROM to reference type TO for
3224 purposes of reference binding. For lvalue binding, either pass a
3225 reference type to FROM or an lvalue expression to EXPR.
3227 Currently does not distinguish in the generated trees between binding to
3228 an lvalue and a temporary. Should it? */
3231 reference_binding (rto
, rfrom
, expr
, flags
)
3232 tree rto
, rfrom
, expr
;
3237 tree to
= TREE_TYPE (rto
);
3241 if (TREE_CODE (from
) == REFERENCE_TYPE
)
3242 from
= TREE_TYPE (from
);
3243 else if (! expr
|| ! real_lvalue_p (expr
))
3246 related
= (TYPE_MAIN_VARIANT (to
) == TYPE_MAIN_VARIANT (from
)
3247 || (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
3248 && DERIVED_FROM_P (to
, from
)));
3250 if (lvalue
&& related
3251 && TYPE_READONLY (to
) >= TYPE_READONLY (from
)
3252 && TYPE_VOLATILE (to
) >= TYPE_VOLATILE (from
))
3254 conv
= build1 (IDENTITY_CONV
, from
, expr
);
3256 if (TYPE_MAIN_VARIANT (to
) == TYPE_MAIN_VARIANT (from
))
3257 conv
= build_conv (REF_BIND
, rto
, conv
);
3260 conv
= build_conv (REF_BIND
, rto
, conv
);
3261 ICS_STD_RANK (conv
) = STD_RANK
;
3269 conv
= standard_conversion (to
, rfrom
, expr
);
3272 conv
= build_conv (REF_BIND
, rto
, conv
);
3274 /* Bind directly to a base subobject of a class rvalue. Do it
3275 after building the conversion for proper handling of ICS_RANK. */
3276 if (TREE_CODE (TREE_OPERAND (conv
, 0)) == BASE_CONV
)
3277 TREE_OPERAND (conv
, 0) = TREE_OPERAND (TREE_OPERAND (conv
, 0), 0);
3280 && ((! (TYPE_READONLY (to
) && ! TYPE_VOLATILE (to
)
3281 && (flags
& LOOKUP_NO_TEMP_BIND
) == 0))
3282 /* If T1 is reference-related to T2, cv1 must be the same
3283 cv-qualification as, or greater cv-qualification than,
3284 cv2; otherwise, the program is ill-formed. */
3286 && (TYPE_READONLY (to
) < TYPE_READONLY (from
)
3287 || TYPE_VOLATILE (to
) < TYPE_VOLATILE (from
)))))
3288 ICS_BAD_FLAG (conv
) = 1;
3294 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
3295 to type TO. The optional expression EXPR may affect the conversion.
3296 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
3300 implicit_conversion (to
, from
, expr
, flags
)
3301 tree to
, from
, expr
;
3305 struct z_candidate
*cand
;
3307 if (expr
&& type_unknown_p (expr
))
3309 expr
= instantiate_type (to
, expr
, 0);
3310 if (expr
== error_mark_node
)
3312 from
= TREE_TYPE (expr
);
3315 if (TREE_CODE (to
) == REFERENCE_TYPE
)
3316 conv
= reference_binding (to
, from
, expr
, flags
);
3318 conv
= standard_conversion (to
, from
, expr
);
3322 else if ((IS_AGGR_TYPE (non_reference (from
))
3323 || IS_AGGR_TYPE (non_reference (to
)))
3324 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
3326 cand
= build_user_type_conversion_1
3327 (to
, expr
, LOOKUP_ONLYCONVERTING
);
3329 conv
= cand
->second_conv
;
3330 if ((! conv
|| ICS_BAD_FLAG (conv
))
3331 && TREE_CODE (to
) == REFERENCE_TYPE
3332 && (flags
& LOOKUP_NO_TEMP_BIND
) == 0)
3334 cand
= build_user_type_conversion_1
3335 (TYPE_MAIN_VARIANT (TREE_TYPE (to
)), expr
, LOOKUP_ONLYCONVERTING
);
3338 if (! TYPE_READONLY (TREE_TYPE (to
))
3339 || TYPE_VOLATILE (TREE_TYPE (to
)))
3340 ICS_BAD_FLAG (cand
->second_conv
) = 1;
3341 if (!conv
|| (ICS_BAD_FLAG (conv
)
3342 > ICS_BAD_FLAG (cand
->second_conv
)))
3343 conv
= build_conv (REF_BIND
, to
, cand
->second_conv
);
3351 /* Create an overload candidate for the function or method FN called with
3352 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
3353 to implicit_conversion. */
3355 static struct z_candidate
*
3356 add_function_candidate (candidates
, fn
, arglist
, flags
)
3357 struct z_candidate
*candidates
;
3361 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
3364 tree parmnode
= parmlist
;
3365 tree argnode
= arglist
;
3367 struct z_candidate
*cand
;
3369 /* The `this' and `in_chrg' arguments to constructors are not considered
3370 in overload resolution. */
3371 if (DECL_CONSTRUCTOR_P (fn
))
3373 parmnode
= TREE_CHAIN (parmnode
);
3374 argnode
= TREE_CHAIN (argnode
);
3375 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
3377 parmnode
= TREE_CHAIN (parmnode
);
3378 argnode
= TREE_CHAIN (argnode
);
3382 len
= list_length (argnode
);
3383 convs
= make_tree_vec (len
);
3385 for (i
= 0; i
< len
; ++i
)
3387 tree arg
= TREE_VALUE (argnode
);
3388 tree argtype
= TREE_TYPE (arg
);
3391 argtype
= cp_build_type_variant
3392 (argtype
, TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
3394 if (parmnode
== void_list_node
)
3397 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
, flags
);
3400 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
3401 ICS_ELLIPSIS_FLAG (t
) = 1;
3404 if (i
== 0 && t
&& TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
3405 && ! DECL_CONSTRUCTOR_P (fn
))
3406 ICS_THIS_FLAG (t
) = 1;
3408 TREE_VEC_ELT (convs
, i
) = t
;
3412 if (ICS_BAD_FLAG (t
))
3416 parmnode
= TREE_CHAIN (parmnode
);
3417 argnode
= TREE_CHAIN (argnode
);
3423 /* Make sure there are default args for the rest of the parms. */
3424 for (; parmnode
&& parmnode
!= void_list_node
;
3425 parmnode
= TREE_CHAIN (parmnode
))
3426 if (! TREE_PURPOSE (parmnode
))
3432 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3435 cand
->convs
= convs
;
3436 cand
->second_conv
= NULL_TREE
;
3437 cand
->viable
= viable
;
3438 cand
->basetype_path
= NULL_TREE
;
3439 cand
->template = NULL_TREE
;
3440 cand
->next
= candidates
;
3445 /* Create an overload candidate for the conversion function FN which will
3446 be invoked for expression OBJ, producing a pointer-to-function which
3447 will in turn be called with the argument list ARGLIST, and add it to
3448 CANDIDATES. FLAGS is passed on to implicit_conversion. */
3450 static struct z_candidate
*
3451 add_conv_candidate (candidates
, fn
, obj
, arglist
)
3452 struct z_candidate
*candidates
;
3453 tree fn
, obj
, arglist
;
3455 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
3456 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (totype
));
3457 int i
, len
= list_length (arglist
) + 1;
3458 tree convs
= make_tree_vec (len
);
3459 tree parmnode
= parmlist
;
3460 tree argnode
= arglist
;
3462 struct z_candidate
*cand
;
3463 int flags
= LOOKUP_NORMAL
;
3465 for (i
= 0; i
< len
; ++i
)
3467 tree arg
= i
== 0 ? obj
: TREE_VALUE (argnode
);
3468 tree argtype
= lvalue_type (arg
);
3472 t
= implicit_conversion (totype
, argtype
, arg
, flags
);
3473 else if (parmnode
== void_list_node
)
3476 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
, flags
);
3479 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
3480 ICS_ELLIPSIS_FLAG (t
) = 1;
3483 TREE_VEC_ELT (convs
, i
) = t
;
3487 if (ICS_BAD_FLAG (t
))
3494 parmnode
= TREE_CHAIN (parmnode
);
3495 argnode
= TREE_CHAIN (argnode
);
3501 for (; parmnode
&& parmnode
!= void_list_node
;
3502 parmnode
= TREE_CHAIN (parmnode
))
3503 if (! TREE_PURPOSE (parmnode
))
3509 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3512 cand
->convs
= convs
;
3513 cand
->second_conv
= NULL_TREE
;
3514 cand
->viable
= viable
;
3515 cand
->basetype_path
= NULL_TREE
;
3516 cand
->template = NULL_TREE
;
3517 cand
->next
= candidates
;
3522 static struct z_candidate
*
3523 build_builtin_candidate (candidates
, fnname
, type1
, type2
,
3524 args
, argtypes
, flags
)
3525 struct z_candidate
*candidates
;
3526 tree fnname
, type1
, type2
, *args
, *argtypes
;
3532 struct z_candidate
*cand
;
3538 convs
= make_tree_vec (args
[2] ? 3 : (args
[1] ? 2 : 1));
3540 for (i
= 0; i
< 2; ++i
)
3545 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
], flags
);
3549 /* We need something for printing the candidate. */
3550 t
= build1 (IDENTITY_CONV
, types
[i
], NULL_TREE
);
3552 else if (ICS_BAD_FLAG (t
))
3554 TREE_VEC_ELT (convs
, i
) = t
;
3557 /* For COND_EXPR we rearranged the arguments; undo that now. */
3560 TREE_VEC_ELT (convs
, 2) = TREE_VEC_ELT (convs
, 1);
3561 TREE_VEC_ELT (convs
, 1) = TREE_VEC_ELT (convs
, 0);
3562 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2], flags
);
3564 TREE_VEC_ELT (convs
, 0) = t
;
3569 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3572 cand
->convs
= convs
;
3573 cand
->second_conv
= NULL_TREE
;
3574 cand
->viable
= viable
;
3575 cand
->basetype_path
= NULL_TREE
;
3576 cand
->template = NULL_TREE
;
3577 cand
->next
= candidates
;
3586 return TYPE_SIZE (complete_type (t
)) != NULL_TREE
;
3589 /* Create any builtin operator overload candidates for the operator in
3590 question given the converted operand types TYPE1 and TYPE2. The other
3591 args are passed through from add_builtin_candidates to
3592 build_builtin_candidate. */
3594 static struct z_candidate
*
3595 add_builtin_candidate (candidates
, code
, code2
, fnname
, type1
, type2
,
3596 args
, argtypes
, flags
)
3597 struct z_candidate
*candidates
;
3598 enum tree_code code
, code2
;
3599 tree fnname
, type1
, type2
, *args
, *argtypes
;
3604 case POSTINCREMENT_EXPR
:
3605 case POSTDECREMENT_EXPR
:
3606 args
[1] = integer_zero_node
;
3607 type2
= integer_type_node
;
3613 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3614 and VQ is either volatile or empty, there exist candidate operator
3615 functions of the form
3616 VQ T& operator++(VQ T&);
3617 T operator++(VQ T&, int);
3618 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
3619 type other than bool, and VQ is either volatile or empty, there exist
3620 candidate operator functions of the form
3621 VQ T& operator--(VQ T&);
3622 T operator--(VQ T&, int);
3623 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
3624 complete object type, and VQ is either volatile or empty, there exist
3625 candidate operator functions of the form
3626 T*VQ& operator++(T*VQ&);
3627 T*VQ& operator--(T*VQ&);
3628 T* operator++(T*VQ&, int);
3629 T* operator--(T*VQ&, int); */
3631 case POSTDECREMENT_EXPR
:
3632 case PREDECREMENT_EXPR
:
3633 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
3635 case POSTINCREMENT_EXPR
:
3636 case PREINCREMENT_EXPR
:
3637 if ((ARITHMETIC_TYPE_P (type1
) && TREE_CODE (type1
) != ENUMERAL_TYPE
)
3638 || TYPE_PTROB_P (type1
))
3640 type1
= build_reference_type (type1
);
3645 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
3646 exist candidate operator functions of the form
3650 8 For every function type T, there exist candidate operator functions of
3652 T& operator*(T*); */
3655 if (TREE_CODE (type1
) == POINTER_TYPE
3656 && (TYPE_PTROB_P (type1
)
3657 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
3661 /* 9 For every type T, there exist candidate operator functions of the form
3664 10For every promoted arithmetic type T, there exist candidate operator
3665 functions of the form
3669 case CONVERT_EXPR
: /* unary + */
3670 if (TREE_CODE (type1
) == POINTER_TYPE
3671 && TREE_CODE (TREE_TYPE (type1
)) != OFFSET_TYPE
)
3674 if (ARITHMETIC_TYPE_P (type1
))
3678 /* 11For every promoted integral type T, there exist candidate operator
3679 functions of the form
3683 if (INTEGRAL_TYPE_P (type1
))
3687 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
3688 is the same type as C2 or is a derived class of C2, T is a complete
3689 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
3690 there exist candidate operator functions of the form
3691 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
3692 where CV12 is the union of CV1 and CV2. */
3695 if (TREE_CODE (type1
) == POINTER_TYPE
3696 && (TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
)))
3698 tree c1
= TREE_TYPE (type1
);
3699 tree c2
= (TYPE_PTRMEMFUNC_P (type2
)
3700 ? TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2
))
3701 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2
)));
3703 if (IS_AGGR_TYPE (c1
) && DERIVED_FROM_P (c2
, c1
)
3704 && (TYPE_PTRMEMFUNC_P (type2
)
3705 || is_complete (TREE_TYPE (TREE_TYPE (type2
)))))
3710 /* 13For every pair of promoted arithmetic types L and R, there exist can-
3711 didate operator functions of the form
3716 bool operator<(L, R);
3717 bool operator>(L, R);
3718 bool operator<=(L, R);
3719 bool operator>=(L, R);
3720 bool operator==(L, R);
3721 bool operator!=(L, R);
3722 where LR is the result of the usual arithmetic conversions between
3725 14For every pair of types T and I, where T is a cv-qualified or cv-
3726 unqualified complete object type and I is a promoted integral type,
3727 there exist candidate operator functions of the form
3728 T* operator+(T*, I);
3729 T& operator[](T*, I);
3730 T* operator-(T*, I);
3731 T* operator+(I, T*);
3732 T& operator[](I, T*);
3734 15For every T, where T is a pointer to complete object type, there exist
3735 candidate operator functions of the form112)
3736 ptrdiff_t operator-(T, T);
3738 16For every pointer type T, there exist candidate operator functions of
3740 bool operator<(T, T);
3741 bool operator>(T, T);
3742 bool operator<=(T, T);
3743 bool operator>=(T, T);
3744 bool operator==(T, T);
3745 bool operator!=(T, T);
3747 17For every pointer to member type T, there exist candidate operator
3748 functions of the form
3749 bool operator==(T, T);
3750 bool operator!=(T, T); */
3753 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
3755 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3757 type2
= ptrdiff_type_node
;
3761 case TRUNC_DIV_EXPR
:
3762 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3768 if (TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
)
3769 || TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
3771 if ((TYPE_PTRMEMFUNC_P (type1
) || TYPE_PTRMEM_P (type1
))
3772 && null_ptr_cst_p (args
[1]))
3777 if ((TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
))
3778 && null_ptr_cst_p (args
[0]))
3789 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
)
3790 || TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3792 if (TYPE_PTR_P (type1
) && null_ptr_cst_p (args
[1]))
3797 if (null_ptr_cst_p (args
[0]) && TYPE_PTR_P (type2
))
3805 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3808 if (INTEGRAL_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
3810 type1
= ptrdiff_type_node
;
3813 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3815 type2
= ptrdiff_type_node
;
3820 /* 18For every pair of promoted integral types L and R, there exist candi-
3821 date operator functions of the form
3828 where LR is the result of the usual arithmetic conversions between
3831 case TRUNC_MOD_EXPR
:
3837 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
3841 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
3842 type, VQ is either volatile or empty, and R is a promoted arithmetic
3843 type, there exist candidate operator functions of the form
3844 VQ L& operator=(VQ L&, R);
3845 VQ L& operator*=(VQ L&, R);
3846 VQ L& operator/=(VQ L&, R);
3847 VQ L& operator+=(VQ L&, R);
3848 VQ L& operator-=(VQ L&, R);
3850 20For every pair T, VQ), where T is any type and VQ is either volatile
3851 or empty, there exist candidate operator functions of the form
3852 T*VQ& operator=(T*VQ&, T*);
3854 21For every pair T, VQ), where T is a pointer to member type and VQ is
3855 either volatile or empty, there exist candidate operator functions of
3857 VQ T& operator=(VQ T&, T);
3859 22For every triple T, VQ, I), where T is a cv-qualified or cv-
3860 unqualified complete object type, VQ is either volatile or empty, and
3861 I is a promoted integral type, there exist candidate operator func-
3863 T*VQ& operator+=(T*VQ&, I);
3864 T*VQ& operator-=(T*VQ&, I);
3866 23For every triple L, VQ, R), where L is an integral or enumeration
3867 type, VQ is either volatile or empty, and R is a promoted integral
3868 type, there exist candidate operator functions of the form
3870 VQ L& operator%=(VQ L&, R);
3871 VQ L& operator<<=(VQ L&, R);
3872 VQ L& operator>>=(VQ L&, R);
3873 VQ L& operator&=(VQ L&, R);
3874 VQ L& operator^=(VQ L&, R);
3875 VQ L& operator|=(VQ L&, R); */
3882 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3884 type2
= ptrdiff_type_node
;
3888 case TRUNC_DIV_EXPR
:
3889 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3893 case TRUNC_MOD_EXPR
:
3899 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
3904 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3906 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
3907 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3908 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
3909 || ((TYPE_PTRMEMFUNC_P (type1
)
3910 || TREE_CODE (type1
) == POINTER_TYPE
)
3911 && null_ptr_cst_p (args
[1])))
3919 my_friendly_abort (367);
3921 type1
= build_reference_type (type1
);
3925 /* Kludge around broken overloading rules whereby
3926 bool ? const char& : enum is ambiguous
3927 (between int and const char&). */
3928 flags
|= LOOKUP_NO_TEMP_BIND
;
3930 /* Extension: Support ?: of enumeral type. Hopefully this will not
3931 be an extension for long. */
3932 if (TREE_CODE (type1
) == ENUMERAL_TYPE
&& type1
== type2
)
3934 else if (TREE_CODE (type1
) == ENUMERAL_TYPE
3935 || TREE_CODE (type2
) == ENUMERAL_TYPE
)
3937 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3939 if (TREE_CODE (type1
) == TREE_CODE (type2
)
3940 && (TREE_CODE (type1
) == REFERENCE_TYPE
3941 || TREE_CODE (type1
) == POINTER_TYPE
3942 || TYPE_PTRMEMFUNC_P (type1
)
3943 || IS_AGGR_TYPE (type1
)))
3945 if (TREE_CODE (type1
) == REFERENCE_TYPE
3946 || TREE_CODE (type2
) == REFERENCE_TYPE
)
3948 if (((TYPE_PTRMEMFUNC_P (type1
) || TREE_CODE (type1
) == POINTER_TYPE
)
3949 && null_ptr_cst_p (args
[1]))
3950 || IS_AGGR_TYPE (type1
))
3955 if (((TYPE_PTRMEMFUNC_P (type2
) || TREE_CODE (type2
) == POINTER_TYPE
)
3956 && null_ptr_cst_p (args
[0]))
3957 || IS_AGGR_TYPE (type2
))
3965 my_friendly_abort (367);
3968 /* If we're dealing with two pointer types, we need candidates
3969 for both of them. */
3970 if (type2
&& type1
!= type2
3971 && TREE_CODE (type1
) == TREE_CODE (type2
)
3972 && (TREE_CODE (type1
) == REFERENCE_TYPE
3973 || (TREE_CODE (type1
) == POINTER_TYPE
3974 && TYPE_PTRMEM_P (type1
) == TYPE_PTRMEM_P (type2
))
3975 || TYPE_PTRMEMFUNC_P (type1
)
3976 || IS_AGGR_TYPE (type1
)))
3978 candidates
= build_builtin_candidate
3979 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
);
3980 return build_builtin_candidate
3981 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
);
3984 return build_builtin_candidate
3985 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
);
3989 type_decays_to (type
)
3992 if (TREE_CODE (type
) == ARRAY_TYPE
)
3993 return build_pointer_type (TREE_TYPE (type
));
3994 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3995 return build_pointer_type (type
);
3999 /* There are three conditions of builtin candidates:
4001 1) bool-taking candidates. These are the same regardless of the input.
4002 2) pointer-pair taking candidates. These are generated for each type
4003 one of the input types converts to.
4004 3) arithmetic candidates. According to the WP, we should generate
4005 all of these, but I'm trying not to... */
4007 static struct z_candidate
*
4008 add_builtin_candidates (candidates
, code
, code2
, fnname
, args
, flags
)
4009 struct z_candidate
*candidates
;
4010 enum tree_code code
, code2
;
4015 tree type
, argtypes
[3], types
[2];
4017 for (i
= 0; i
< 3; ++i
)
4020 argtypes
[i
] = lvalue_type (args
[i
]);
4022 argtypes
[i
] = NULL_TREE
;
4027 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
4028 and VQ is either volatile or empty, there exist candidate operator
4029 functions of the form
4030 VQ T& operator++(VQ T&); */
4032 case POSTINCREMENT_EXPR
:
4033 case PREINCREMENT_EXPR
:
4034 case POSTDECREMENT_EXPR
:
4035 case PREDECREMENT_EXPR
:
4040 /* 24There also exist candidate operator functions of the form
4041 bool operator!(bool);
4042 bool operator&&(bool, bool);
4043 bool operator||(bool, bool); */
4045 case TRUTH_NOT_EXPR
:
4046 return build_builtin_candidate
4047 (candidates
, fnname
, boolean_type_node
,
4048 NULL_TREE
, args
, argtypes
, flags
);
4050 case TRUTH_ORIF_EXPR
:
4051 case TRUTH_ANDIF_EXPR
:
4052 return build_builtin_candidate
4053 (candidates
, fnname
, boolean_type_node
,
4054 boolean_type_node
, args
, argtypes
, flags
);
4065 types
[0] = types
[1] = NULL_TREE
;
4067 for (i
= 0; i
< 2; ++i
)
4071 else if (IS_AGGR_TYPE (argtypes
[i
]))
4073 tree convs
= lookup_conversions (argtypes
[i
]);
4075 if (code
== COND_EXPR
)
4077 if (real_lvalue_p (args
[i
]))
4078 types
[i
] = tree_cons
4079 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
4081 types
[i
] = tree_cons
4082 (NULL_TREE
, TYPE_MAIN_VARIANT (argtypes
[i
]), types
[i
]);
4085 else if (! convs
|| (i
== 0 && code
== MODIFY_EXPR
4086 && code2
== NOP_EXPR
))
4089 for (; convs
; convs
= TREE_CHAIN (convs
))
4091 type
= TREE_TYPE (TREE_TYPE (TREE_VALUE (convs
)));
4094 && (TREE_CODE (type
) != REFERENCE_TYPE
4095 || TYPE_READONLY (TREE_TYPE (type
))))
4098 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
4099 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4101 type
= non_reference (type
);
4102 if (i
!= 0 || ! ref1
)
4104 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
4105 if (code
== COND_EXPR
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
4106 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4107 if (INTEGRAL_TYPE_P (type
))
4108 type
= type_promotes_to (type
);
4111 if (! value_member (type
, types
[i
]))
4112 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4117 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
4118 types
[i
] = tree_cons
4119 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
4120 type
= non_reference (argtypes
[i
]);
4121 if (i
!= 0 || ! ref1
)
4123 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
4124 if (code
== COND_EXPR
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
4125 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4126 if (INTEGRAL_TYPE_P (type
))
4127 type
= type_promotes_to (type
);
4129 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4133 for (; types
[0]; types
[0] = TREE_CHAIN (types
[0]))
4136 for (type
= types
[1]; type
; type
= TREE_CHAIN (type
))
4137 candidates
= add_builtin_candidate
4138 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
4139 TREE_VALUE (type
), args
, argtypes
, flags
);
4141 candidates
= add_builtin_candidate
4142 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
4143 NULL_TREE
, args
, argtypes
, flags
);
4149 static struct z_candidate
*
4150 add_template_candidate (candidates
, tmpl
, arglist
, flags
)
4151 struct z_candidate
*candidates
;
4155 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl
));
4156 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
4157 struct z_candidate
*cand
;
4161 i
= type_unification (DECL_TEMPLATE_PARMS (tmpl
), targs
,
4162 TYPE_ARG_TYPES (TREE_TYPE (tmpl
)),
4163 arglist
, &dummy
, 0, 0);
4167 fn
= instantiate_template (tmpl
, targs
);
4168 if (fn
== error_mark_node
)
4171 cand
= add_function_candidate (candidates
, fn
, arglist
, flags
);
4172 cand
->template = DECL_TEMPLATE_INFO (fn
);
4178 struct z_candidate
*cands
;
4180 for (; cands
; cands
= cands
->next
)
4181 if (pedantic
? cands
->viable
== 1 : cands
->viable
)
4186 static struct z_candidate
*
4187 splice_viable (cands
)
4188 struct z_candidate
*cands
;
4190 struct z_candidate
**p
= &cands
;
4194 if (pedantic
? (*p
)->viable
== 1 : (*p
)->viable
)
4207 /* Fix this to work on non-lvalues. */
4208 if (IS_SIGNATURE_POINTER (TREE_TYPE (obj
))
4209 || IS_SIGNATURE_REFERENCE (TREE_TYPE (obj
)))
4212 return build_unary_op (ADDR_EXPR
, obj
, 0);
4216 print_z_candidates (candidates
)
4217 struct z_candidate
*candidates
;
4219 char *str
= "candidates are:";
4220 for (; candidates
; candidates
= candidates
->next
)
4222 if (TREE_CODE (candidates
->fn
) == IDENTIFIER_NODE
)
4224 if (candidates
->fn
== ansi_opname
[COND_EXPR
])
4225 cp_error ("%s %D(%T, %T, %T) <builtin>", str
, candidates
->fn
,
4226 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)),
4227 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 1)),
4228 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 2)));
4229 else if (TREE_VEC_LENGTH (candidates
->convs
) == 2)
4230 cp_error ("%s %D(%T, %T) <builtin>", str
, candidates
->fn
,
4231 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)),
4232 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 1)));
4234 cp_error ("%s %D(%T) <builtin>", str
, candidates
->fn
,
4235 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)));
4238 cp_error_at ("%s %+D%s", str
, candidates
->fn
,
4239 candidates
->viable
== -1 ? " <near match>" : "");
4244 /* Returns the best overload candidate to perform the requested
4245 conversion. This function is used for three the overloading situations
4246 described in [over.match.copy], [over.match.conv], and [over.match.ref].
4247 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
4248 per [dcl.init.ref], so we ignore temporary bindings. */
4250 static struct z_candidate
*
4251 build_user_type_conversion_1 (totype
, expr
, flags
)
4255 struct z_candidate
*candidates
, *cand
;
4256 tree fromtype
= TREE_TYPE (expr
);
4257 tree ctors
= NULL_TREE
, convs
= NULL_TREE
, *p
;
4260 if (IS_AGGR_TYPE (totype
))
4261 ctors
= lookup_fnfields (TYPE_BINFO (totype
), ctor_identifier
, 0);
4262 if (IS_AGGR_TYPE (fromtype
)
4263 && (! IS_AGGR_TYPE (totype
) || ! DERIVED_FROM_P (totype
, fromtype
)))
4264 convs
= lookup_conversions (fromtype
);
4267 flags
|= LOOKUP_NO_CONVERSION
;
4271 tree t
= build_int_2 (0, 0);
4272 TREE_TYPE (t
) = build_pointer_type (totype
);
4273 args
= build_tree_list (NULL_TREE
, expr
);
4274 if (TYPE_USES_VIRTUAL_BASECLASSES (totype
))
4275 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
4276 args
= tree_cons (NULL_TREE
, t
, args
);
4278 ctors
= TREE_VALUE (ctors
);
4280 for (; ctors
; ctors
= DECL_CHAIN (ctors
))
4282 if (DECL_NONCONVERTING_P (ctors
))
4285 candidates
= add_function_candidate (candidates
, ctors
, args
, flags
);
4286 candidates
->second_conv
= build1 (IDENTITY_CONV
, totype
, NULL_TREE
);
4287 candidates
->basetype_path
= TYPE_BINFO (totype
);
4291 args
= build_tree_list (NULL_TREE
, build_this (expr
));
4293 for (; convs
; convs
= TREE_CHAIN (convs
))
4295 tree fn
= TREE_VALUE (convs
);
4296 int convflags
= LOOKUP_NO_CONVERSION
;
4299 /* If we are called to convert to a reference type, we are trying to
4300 find an lvalue binding, so don't even consider temporaries. If
4301 we don't find an lvalue binding, the caller will try again to
4302 look for a temporary binding. */
4303 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
4304 convflags
|= LOOKUP_NO_TEMP_BIND
;
4306 ics
= implicit_conversion
4307 (totype
, TREE_TYPE (TREE_TYPE (fn
)), 0, convflags
);
4309 if (TREE_CODE (totype
) == REFERENCE_TYPE
&& ics
&& ICS_BAD_FLAG (ics
))
4310 /* ignore the near match. */;
4312 for (; fn
; fn
= DECL_CHAIN (fn
))
4314 candidates
= add_function_candidate (candidates
, fn
, args
, flags
);
4315 candidates
->second_conv
= ics
;
4316 candidates
->basetype_path
= TREE_PURPOSE (convs
);
4317 if (candidates
->viable
== 1 && ICS_BAD_FLAG (ics
))
4318 candidates
->viable
= -1;
4322 if (! any_viable (candidates
))
4325 if (flags
& LOOKUP_COMPLAIN
)
4327 if (candidates
&& ! candidates
->next
)
4328 /* say why this one won't work or try to be loose */;
4330 cp_error ("no viable candidates");
4337 candidates
= splice_viable (candidates
);
4338 cand
= tourney (candidates
);
4342 if (flags
& LOOKUP_COMPLAIN
)
4344 cp_error ("conversion from `%T' to `%T' is ambiguous",
4346 print_z_candidates (candidates
);
4349 cand
= candidates
; /* any one will do */
4350 cand
->second_conv
= build1 (AMBIG_CONV
, totype
, expr
);
4351 ICS_USER_FLAG (cand
->second_conv
) = 1;
4352 ICS_BAD_FLAG (cand
->second_conv
) = 1;
4357 for (p
= &(cand
->second_conv
); TREE_CODE (*p
) != IDENTITY_CONV
; )
4358 p
= &(TREE_OPERAND (*p
, 0));
4362 (DECL_CONSTRUCTOR_P (cand
->fn
)
4363 ? totype
: non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)))),
4364 NULL_TREE
, cand
->fn
, cand
->convs
, cand
->basetype_path
);
4365 ICS_USER_FLAG (cand
->second_conv
) = 1;
4366 if (cand
->viable
== -1)
4367 ICS_BAD_FLAG (cand
->second_conv
) = 1;
4373 build_user_type_conversion (totype
, expr
, flags
)
4377 struct z_candidate
*cand
4378 = build_user_type_conversion_1 (totype
, expr
, flags
);
4382 if (TREE_CODE (cand
->second_conv
) == AMBIG_CONV
)
4383 return error_mark_node
;
4384 return convert_from_reference (convert_like (cand
->second_conv
, expr
));
4389 /* Do any initial processing on the arguments to a function call. */
4396 for (t
= args
; t
; t
= TREE_CHAIN (t
))
4398 if (TREE_VALUE (t
) == error_mark_node
)
4399 return error_mark_node
;
4400 else if (TREE_CODE (TREE_TYPE (TREE_VALUE (t
))) == VOID_TYPE
)
4402 error ("invalid use of void expression");
4403 return error_mark_node
;
4405 else if (TREE_CODE (TREE_VALUE (t
)) == OFFSET_REF
)
4406 TREE_VALUE (t
) = resolve_offset_ref (TREE_VALUE (t
));
4412 build_new_function_call (fn
, args
, obj
)
4415 struct z_candidate
*candidates
= 0, *cand
;
4417 if (obj
== NULL_TREE
&& TREE_CODE (fn
) == TREE_LIST
)
4420 tree templates
= NULL_TREE
;
4422 args
= resolve_args (args
);
4424 if (args
== error_mark_node
)
4425 return error_mark_node
;
4427 for (t
= TREE_VALUE (fn
); t
; t
= DECL_CHAIN (t
))
4429 if (TREE_CODE (t
) == TEMPLATE_DECL
)
4431 templates
= decl_tree_cons (NULL_TREE
, t
, templates
);
4432 candidates
= add_template_candidate
4433 (candidates
, t
, args
, LOOKUP_NORMAL
);
4436 candidates
= add_function_candidate
4437 (candidates
, t
, args
, LOOKUP_NORMAL
);
4440 if (! any_viable (candidates
))
4442 if (candidates
&& ! candidates
->next
)
4443 return build_function_call (candidates
->fn
, args
);
4444 cp_error ("no matching function for call to `%D (%A)'",
4445 TREE_PURPOSE (fn
), args
);
4447 print_z_candidates (candidates
);
4448 return error_mark_node
;
4450 candidates
= splice_viable (candidates
);
4451 cand
= tourney (candidates
);
4455 cp_error ("call of overloaded `%D (%A)' is ambiguous",
4456 TREE_PURPOSE (fn
), args
);
4457 print_z_candidates (candidates
);
4458 return error_mark_node
;
4461 /* Pedantically, it is ill-formed to define a function that could
4462 also be a template instantiation, but we won't implement that
4463 until things settle down. */
4464 if (templates
&& ! cand
->template && ! DECL_INITIAL (cand
->fn
))
4465 add_maybe_template (cand
->fn
, templates
);
4467 return build_over_call (cand
->fn
, cand
->convs
, args
, LOOKUP_NORMAL
);
4470 return build_function_call (fn
, args
);
4474 build_object_call (obj
, args
)
4477 struct z_candidate
*candidates
= 0, *cand
;
4478 tree fns
, convs
, mem_args
;
4479 tree type
= TREE_TYPE (obj
);
4481 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname
[CALL_EXPR
], 0);
4483 args
= resolve_args (args
);
4485 if (args
== error_mark_node
)
4486 return error_mark_node
;
4490 tree fn
= TREE_VALUE (fns
);
4491 mem_args
= tree_cons (NULL_TREE
, build_this (obj
), args
);
4493 for (; fn
; fn
= DECL_CHAIN (fn
))
4495 candidates
= add_function_candidate
4496 (candidates
, fn
, mem_args
, LOOKUP_NORMAL
);
4497 candidates
->basetype_path
= TREE_PURPOSE (fns
);
4501 convs
= lookup_conversions (type
);
4503 for (; convs
; convs
= TREE_CHAIN (convs
))
4505 tree fn
= TREE_VALUE (convs
);
4506 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
4508 if (TREE_CODE (totype
) == POINTER_TYPE
4509 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
4510 for (; fn
; fn
= DECL_CHAIN (fn
))
4512 candidates
= add_conv_candidate (candidates
, fn
, obj
, args
);
4513 candidates
->basetype_path
= TREE_PURPOSE (convs
);
4517 if (! any_viable (candidates
))
4519 cp_error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj
), args
);
4520 print_z_candidates (candidates
);
4521 return error_mark_node
;
4524 candidates
= splice_viable (candidates
);
4525 cand
= tourney (candidates
);
4529 cp_error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj
), args
);
4530 print_z_candidates (candidates
);
4531 return error_mark_node
;
4534 if (DECL_NAME (cand
->fn
) == ansi_opname
[CALL_EXPR
])
4535 return build_over_call (cand
->fn
, cand
->convs
, mem_args
, LOOKUP_NORMAL
);
4537 obj
= convert_like (TREE_VEC_ELT (cand
->convs
, 0), obj
);
4540 return build_function_call (obj
, args
);
4544 op_error (code
, code2
, arg1
, arg2
, arg3
, problem
)
4545 enum tree_code code
, code2
;
4546 tree arg1
, arg2
, arg3
;
4550 = (code
== MODIFY_EXPR
? assignop_tab
[code2
] : opname_tab
[code
]);
4555 cp_error ("%s for `%T ? %T : %T'", problem
,
4556 error_type (arg1
), error_type (arg2
), error_type (arg3
));
4558 case POSTINCREMENT_EXPR
:
4559 case POSTDECREMENT_EXPR
:
4560 cp_error ("%s for `%T%s'", problem
, error_type (arg1
), opname
);
4563 cp_error ("%s for `%T[%T]'", problem
,
4564 error_type (arg1
), error_type (arg2
));
4568 cp_error ("%s for `%T %s %T'", problem
,
4569 error_type (arg1
), opname
, error_type (arg2
));
4571 cp_error ("%s for `%s%T'", problem
, opname
, error_type (arg1
));
4576 build_new_op (code
, flags
, arg1
, arg2
, arg3
)
4577 enum tree_code code
;
4579 tree arg1
, arg2
, arg3
;
4581 struct z_candidate
*candidates
= 0, *cand
;
4582 tree fns
, mem_arglist
, arglist
, fnname
;
4583 enum tree_code code2
= NOP_EXPR
;
4584 tree templates
= NULL_TREE
;
4586 if (arg1
== error_mark_node
4587 || arg2
== error_mark_node
4588 || arg3
== error_mark_node
)
4589 return error_mark_node
;
4591 if (code
== MODIFY_EXPR
)
4593 code2
= TREE_CODE (arg3
);
4595 fnname
= ansi_assopname
[code2
];
4598 fnname
= ansi_opname
[code
];
4607 arglist
= tree_cons (NULL_TREE
, arg2
, arg3
);
4608 if (flags
& LOOKUP_GLOBAL
)
4609 return build_new_function_call
4610 (lookup_name_nonclass (fnname
), arglist
, NULL_TREE
);
4613 rval
= build_method_call
4614 (build_indirect_ref (build1 (NOP_EXPR
, arg1
, error_mark_node
),
4616 fnname
, arglist
, NULL_TREE
, flags
);
4617 if (rval
== error_mark_node
)
4618 /* User might declare fancy operator new, but invoke it
4619 like standard one. */
4622 TREE_TYPE (rval
) = arg1
;
4623 TREE_CALLS_NEW (rval
) = 1;
4627 case VEC_DELETE_EXPR
:
4632 if (flags
& LOOKUP_GLOBAL
)
4633 return build_new_function_call
4634 (lookup_name_nonclass (fnname
),
4635 build_tree_list (NULL_TREE
, arg1
), NULL_TREE
);
4637 arglist
= tree_cons (NULL_TREE
, arg1
, build_tree_list (NULL_TREE
, arg2
));
4639 arg1
= TREE_TYPE (arg1
);
4641 /* This handles the case where we're trying to delete
4646 if (TREE_CODE (TREE_TYPE (arg1
)) == ARRAY_TYPE
)
4648 /* Strip off the pointer and the array. */
4649 arg1
= TREE_TYPE (TREE_TYPE (arg1
));
4651 while (TREE_CODE (arg1
) == ARRAY_TYPE
)
4652 arg1
= (TREE_TYPE (arg1
));
4654 arg1
= build_pointer_type (arg1
);
4658 rval
= build_method_call
4659 (build_indirect_ref (build1 (NOP_EXPR
, arg1
,
4662 fnname
, arglist
, NULL_TREE
, flags
);
4664 /* This can happen when operator delete is protected. */
4665 my_friendly_assert (rval
!= error_mark_node
, 250);
4666 TREE_TYPE (rval
) = void_type_node
;
4672 return build_object_call (arg1
, arg2
);
4675 /* The comma operator can have void args. */
4676 if (TREE_CODE (arg1
) == OFFSET_REF
)
4677 arg1
= resolve_offset_ref (arg1
);
4678 if (arg2
&& TREE_CODE (arg2
) == OFFSET_REF
)
4679 arg2
= resolve_offset_ref (arg2
);
4680 if (arg3
&& TREE_CODE (arg3
) == OFFSET_REF
)
4681 arg3
= resolve_offset_ref (arg3
);
4683 if (code
== COND_EXPR
)
4685 if (arg2
== NULL_TREE
4686 || TREE_CODE (TREE_TYPE (arg2
)) == VOID_TYPE
4687 || TREE_CODE (TREE_TYPE (arg3
)) == VOID_TYPE
4688 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))
4689 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3
))))
4692 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1
))
4693 && (! arg2
|| ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))))
4696 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
4697 arg2
= integer_zero_node
;
4699 fns
= lookup_name_nonclass (fnname
);
4700 /* + Koenig lookup */
4703 arglist
= tree_cons (NULL_TREE
, arg1
, tree_cons
4704 (NULL_TREE
, arg2
, build_tree_list (NULL_TREE
, arg3
)));
4706 arglist
= tree_cons (NULL_TREE
, arg1
, build_tree_list (NULL_TREE
, arg2
));
4708 arglist
= build_tree_list (NULL_TREE
, arg1
);
4710 if (fns
&& TREE_CODE (fns
) == TREE_LIST
)
4711 fns
= TREE_VALUE (fns
);
4712 for (; fns
; fns
= DECL_CHAIN (fns
))
4714 if (TREE_CODE (fns
) == TEMPLATE_DECL
)
4716 templates
= decl_tree_cons (NULL_TREE
, fns
, templates
);
4717 candidates
= add_template_candidate
4718 (candidates
, fns
, arglist
, flags
);
4721 candidates
= add_function_candidate (candidates
, fns
, arglist
, flags
);
4724 if (IS_AGGR_TYPE (TREE_TYPE (arg1
)))
4725 fns
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1
)), fnname
, 0);
4731 tree fn
= TREE_VALUE (fns
);
4732 mem_arglist
= tree_cons (NULL_TREE
, build_this (arg1
), TREE_CHAIN (arglist
));
4733 for (; fn
; fn
= DECL_CHAIN (fn
))
4735 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4736 candidates
= add_function_candidate
4737 (candidates
, fn
, mem_arglist
, flags
);
4739 candidates
= add_function_candidate (candidates
, fn
, arglist
, flags
);
4741 candidates
->basetype_path
= TREE_PURPOSE (fns
);
4748 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
4749 to know about two args; a builtin candidate will always have a first
4750 parameter of type bool. We'll handle that in
4751 build_builtin_candidate. */
4752 if (code
== COND_EXPR
)
4762 args
[2] = NULL_TREE
;
4765 candidates
= add_builtin_candidates
4766 (candidates
, code
, code2
, fnname
, args
, flags
);
4769 if (! any_viable (candidates
))
4773 case POSTINCREMENT_EXPR
:
4774 case POSTDECREMENT_EXPR
:
4775 /* Look for an `operator++ (int)'. If they didn't have
4776 one, then we fall back to the old way of doing things. */
4777 if (flags
& LOOKUP_COMPLAIN
)
4778 cp_pedwarn ("no `%D (int)' declared for postfix `%s', trying prefix operator instead",
4779 fnname
, opname_tab
[code
]);
4780 if (code
== POSTINCREMENT_EXPR
)
4781 code
= PREINCREMENT_EXPR
;
4783 code
= PREDECREMENT_EXPR
;
4784 return build_new_op (code
, flags
, arg1
, NULL_TREE
, NULL_TREE
);
4786 /* The caller will deal with these. */
4792 if (flags
& LOOKUP_COMPLAIN
)
4794 op_error (code
, code2
, arg1
, arg2
, arg3
, "no match");
4795 print_z_candidates (candidates
);
4797 return error_mark_node
;
4799 candidates
= splice_viable (candidates
);
4800 cand
= tourney (candidates
);
4804 if (flags
& LOOKUP_COMPLAIN
)
4806 op_error (code
, code2
, arg1
, arg2
, arg3
, "ambiguous overload");
4807 print_z_candidates (candidates
);
4809 return error_mark_node
;
4812 if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
4814 extern int warn_synth
;
4816 && fnname
== ansi_opname
[MODIFY_EXPR
]
4817 && DECL_ARTIFICIAL (cand
->fn
)
4819 && ! candidates
->next
->next
)
4821 cp_warning ("using synthesized `%#D' for copy assignment",
4823 cp_warning_at (" where cfront would use `%#D'",
4825 ? candidates
->next
->fn
4829 if (DECL_FUNCTION_MEMBER_P (cand
->fn
))
4830 enforce_access (cand
->basetype_path
, cand
->fn
);
4832 /* Pedantically, it is ill-formed to define a function that could
4833 also be a template instantiation, but we won't implement that
4834 until things settle down. */
4835 if (templates
&& ! cand
->template && ! DECL_INITIAL (cand
->fn
)
4836 && TREE_CODE (TREE_TYPE (cand
->fn
)) != METHOD_TYPE
)
4837 add_maybe_template (cand
->fn
, templates
);
4839 return build_over_call
4840 (cand
->fn
, cand
->convs
,
4841 TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
4842 ? mem_arglist
: arglist
,
4846 /* Check for comparison of different enum types. */
4855 if (flag_int_enum_equivalence
== 0
4856 && TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
4857 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
4858 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
4859 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
))))
4861 cp_warning ("comparison between `%#T' and `%#T'",
4862 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4866 arg1
= convert_from_reference
4867 (convert_like (TREE_VEC_ELT (cand
->convs
, 0), arg1
));
4869 arg2
= convert_like (TREE_VEC_ELT (cand
->convs
, 1), arg2
);
4871 arg3
= convert_like (TREE_VEC_ELT (cand
->convs
, 2), arg3
);
4877 return build_modify_expr (arg1
, code2
, arg2
);
4880 return build_indirect_ref (arg1
, "unary *");
4885 case TRUNC_DIV_EXPR
:
4896 case TRUNC_MOD_EXPR
:
4900 case TRUTH_ANDIF_EXPR
:
4901 case TRUTH_ORIF_EXPR
:
4902 return build_binary_op_nodefault (code
, arg1
, arg2
, code
);
4907 case TRUTH_NOT_EXPR
:
4908 case PREINCREMENT_EXPR
:
4909 case POSTINCREMENT_EXPR
:
4910 case PREDECREMENT_EXPR
:
4911 case POSTDECREMENT_EXPR
:
4914 return build_unary_op (code
, arg1
, candidates
!= 0);
4917 return build_array_ref (arg1
, arg2
);
4920 return build_conditional_expr (arg1
, arg2
, arg3
);
4923 return build_m_component_ref
4924 (build_indirect_ref (arg1
, NULL_PTR
), arg2
);
4926 /* The caller will deal with these. */
4933 my_friendly_abort (367);
4938 enforce_access (basetype_path
, function
)
4939 tree basetype_path
, function
;
4941 tree access
= compute_access (basetype_path
, function
);
4943 if (access
== access_private_node
)
4945 cp_error_at ("`%+#D' is %s", function
,
4946 TREE_PRIVATE (function
) ? "private"
4947 : "from private base class");
4948 error ("within this context");
4950 else if (access
== access_protected_node
)
4952 cp_error_at ("`%+#D' %s", function
,
4953 TREE_PROTECTED (function
) ? "is protected"
4954 : "has protected accessibility");
4955 error ("within this context");
4959 /* Perform the conversions in CONVS on the expression EXPR. */
4962 convert_like (convs
, expr
)
4965 if (ICS_BAD_FLAG (convs
)
4966 && TREE_CODE (convs
) != USER_CONV
4967 && TREE_CODE (convs
) != AMBIG_CONV
)
4970 for (; t
; t
= TREE_OPERAND (t
, 0))
4972 if (TREE_CODE (t
) == USER_CONV
)
4974 expr
= convert_like (t
, expr
);
4977 else if (TREE_CODE (t
) == AMBIG_CONV
)
4978 return convert_like (t
, expr
);
4979 else if (TREE_CODE (t
) == IDENTITY_CONV
)
4982 return convert_for_initialization
4983 (NULL_TREE
, TREE_TYPE (convs
), expr
, LOOKUP_NORMAL
,
4984 "conversion", NULL_TREE
, 0);
4987 switch (TREE_CODE (convs
))
4991 tree fn
= TREE_OPERAND (convs
, 1);
4993 enforce_access (TREE_OPERAND (convs
, 3), fn
);
4995 if (DECL_CONSTRUCTOR_P (fn
))
4997 tree t
= build_int_2 (0, 0);
4998 TREE_TYPE (t
) = build_pointer_type (DECL_CONTEXT (fn
));
5000 args
= build_tree_list (NULL_TREE
, expr
);
5001 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
5002 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
5003 args
= tree_cons (NULL_TREE
, t
, args
);
5006 args
= build_this (expr
);
5007 expr
= build_over_call
5008 (TREE_OPERAND (convs
, 1), TREE_OPERAND (convs
, 2),
5009 args
, LOOKUP_NORMAL
);
5011 /* If this is a constructor or a function returning an aggr type,
5012 we need to build up a TARGET_EXPR. */
5013 if (DECL_CONSTRUCTOR_P (fn
))
5014 expr
= build_cplus_new (TREE_TYPE (convs
), expr
);
5019 if (type_unknown_p (expr
))
5020 expr
= instantiate_type (TREE_TYPE (convs
), expr
, 1);
5021 if (TREE_READONLY_DECL_P (expr
))
5022 expr
= decl_constant_value (expr
);
5025 /* Call build_user_type_conversion again for the error. */
5026 return build_user_type_conversion
5027 (TREE_TYPE (convs
), TREE_OPERAND (convs
, 0), LOOKUP_NORMAL
);
5030 expr
= convert_like (TREE_OPERAND (convs
, 0), expr
);
5031 if (expr
== error_mark_node
)
5032 return error_mark_node
;
5034 switch (TREE_CODE (convs
))
5037 if (! IS_AGGR_TYPE (TREE_TYPE (convs
)))
5039 /* else fall through */
5041 return build_user_type_conversion
5042 (TREE_TYPE (convs
), expr
, LOOKUP_NORMAL
);
5044 return convert_to_reference
5045 (TREE_TYPE (convs
), expr
,
5046 CONV_IMPLICIT
, LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
5049 return decay_conversion (expr
);
5051 return ocp_convert (TREE_TYPE (convs
), expr
, CONV_IMPLICIT
,
5052 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
);
5056 convert_default_arg (type
, arg
)
5059 arg
= break_out_target_exprs (arg
);
5061 if (TREE_CODE (arg
) == CONSTRUCTOR
)
5063 arg
= digest_init (type
, arg
, 0);
5064 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
5065 "default argument", 0, 0);
5069 /* This could get clobbered by the following call. */
5070 if (TREE_HAS_CONSTRUCTOR (arg
))
5071 arg
= copy_node (arg
);
5073 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
5074 "default argument", 0, 0);
5075 #ifdef PROMOTE_PROTOTYPES
5076 if ((TREE_CODE (type
) == INTEGER_TYPE
5077 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5078 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
5079 arg
= default_conversion (arg
);
5087 build_over_call (fn
, convs
, args
, flags
)
5088 tree fn
, convs
, args
;
5091 tree converted_args
= NULL_TREE
;
5092 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5093 tree conv
, arg
, val
;
5097 if (args
&& TREE_CODE (args
) != TREE_LIST
)
5098 args
= build_tree_list (NULL_TREE
, args
);
5101 /* The implicit parameters to a constructor are not considered by overload
5102 resolution, and must be of the proper type. */
5103 if (DECL_CONSTRUCTOR_P (fn
))
5105 converted_args
= tree_cons (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
5106 arg
= TREE_CHAIN (arg
);
5107 parm
= TREE_CHAIN (parm
);
5108 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
5110 converted_args
= tree_cons
5111 (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
5112 arg
= TREE_CHAIN (arg
);
5113 parm
= TREE_CHAIN (parm
);
5116 /* Bypass access control for 'this' parameter. */
5117 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
5119 tree parmtype
= TREE_VALUE (parm
);
5120 tree argtype
= TREE_TYPE (TREE_VALUE (arg
));
5121 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs
, i
)))
5123 int dv
= (TYPE_VOLATILE (TREE_TYPE (parmtype
))
5124 < TYPE_VOLATILE (TREE_TYPE (argtype
)));
5125 int dc
= (TYPE_READONLY (TREE_TYPE (parmtype
))
5126 < TYPE_READONLY (TREE_TYPE (argtype
)));
5127 char *p
= (dv
&& dc
? "const and volatile"
5128 : dc
? "const" : dv
? "volatile" : "");
5130 cp_pedwarn ("passing `%T' as `this' argument of `%#D' discards %s",
5131 TREE_TYPE (argtype
), fn
, p
);
5133 converted_args
= tree_cons
5134 (NULL_TREE
, convert_force (TREE_VALUE (parm
), TREE_VALUE (arg
), CONV_C_CAST
),
5136 parm
= TREE_CHAIN (parm
);
5137 arg
= TREE_CHAIN (arg
);
5143 parm
= TREE_CHAIN (parm
), arg
= TREE_CHAIN (arg
), ++i
)
5145 tree type
= TREE_VALUE (parm
);
5147 conv
= TREE_VEC_ELT (convs
, i
);
5148 if (ICS_BAD_FLAG (conv
))
5151 val
= TREE_VALUE (arg
);
5153 for (; t
; t
= TREE_OPERAND (t
, 0))
5155 if (TREE_CODE (t
) == USER_CONV
5156 || TREE_CODE (t
) == AMBIG_CONV
)
5158 val
= convert_like (t
, val
);
5161 else if (TREE_CODE (t
) == IDENTITY_CONV
)
5164 val
= convert_for_initialization
5165 (NULL_TREE
, type
, val
, LOOKUP_NORMAL
,
5166 "argument passing", fn
, i
- is_method
);
5169 val
= convert_like (conv
, TREE_VALUE (arg
));
5171 #ifdef PROMOTE_PROTOTYPES
5172 if ((TREE_CODE (type
) == INTEGER_TYPE
5173 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5174 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
5175 val
= default_conversion (val
);
5177 converted_args
= tree_cons (NULL_TREE
, val
, converted_args
);
5180 /* Default arguments */
5181 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
))
5183 tree arg
= TREE_PURPOSE (parm
);
5185 if (DECL_TEMPLATE_INFO (fn
))
5186 /* This came from a template. Instantiate the default arg here,
5188 arg
= tsubst_expr (arg
,
5189 &TREE_VEC_ELT (DECL_TI_ARGS (fn
), 0),
5190 TREE_VEC_LENGTH (DECL_TI_ARGS (fn
)), NULL_TREE
);
5191 converted_args
= tree_cons
5192 (NULL_TREE
, convert_default_arg (TREE_VALUE (parm
), arg
),
5197 for (; arg
; arg
= TREE_CHAIN (arg
))
5199 val
= TREE_VALUE (arg
);
5201 if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
5202 && (TYPE_PRECISION (TREE_TYPE (val
))
5203 < TYPE_PRECISION (double_type_node
)))
5204 /* Convert `float' to `double'. */
5205 val
= cp_convert (double_type_node
, val
);
5206 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val
))
5207 && ! TYPE_HAS_TRIVIAL_INIT_REF (TREE_TYPE (val
)))
5208 cp_warning ("cannot pass objects of type `%T' through `...'",
5211 /* Convert `short' and `char' to full-size `int'. */
5212 val
= default_conversion (val
);
5214 converted_args
= tree_cons (NULL_TREE
, val
, converted_args
);
5217 converted_args
= nreverse (converted_args
);
5219 /* Avoid actually calling copy constructors and copy assignment operators,
5221 if (DECL_CONSTRUCTOR_P (fn
)
5222 && TREE_VEC_LENGTH (convs
) == 1
5223 && copy_args_p (fn
))
5226 arg
= TREE_VALUE (TREE_CHAIN (converted_args
));
5228 /* Pull out the real argument, disregarding const-correctness. */
5230 while (TREE_CODE (targ
) == NOP_EXPR
5231 || TREE_CODE (targ
) == NON_LVALUE_EXPR
5232 || TREE_CODE (targ
) == CONVERT_EXPR
)
5233 targ
= TREE_OPERAND (targ
, 0);
5234 if (TREE_CODE (targ
) == ADDR_EXPR
)
5236 targ
= TREE_OPERAND (targ
, 0);
5237 if (! comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg
))),
5238 TYPE_MAIN_VARIANT (TREE_TYPE (targ
)), 1))
5247 arg
= build_indirect_ref (arg
, 0);
5249 /* [class.copy]: the copy constructor is implicitly defined even if
5250 the implementation elided its use. */
5251 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn
)))
5254 /* If we're creating a temp and we already have one, don't create a
5255 new one. If we're not creating a temp but we get one, use
5256 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5257 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5258 temp or an INIT_EXPR otherwise. */
5259 if (integer_zerop (TREE_VALUE (args
)))
5261 if (! real_lvalue_p (arg
))
5263 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5265 val
= build (VAR_DECL
, DECL_CONTEXT (fn
));
5266 layout_decl (val
, 0);
5267 val
= build (TARGET_EXPR
, DECL_CONTEXT (fn
), val
, arg
, 0, 0);
5268 TREE_SIDE_EFFECTS (val
) = 1;
5272 else if (! real_lvalue_p (arg
)
5273 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5275 tree to
= stabilize_reference
5276 (build_indirect_ref (TREE_VALUE (args
), 0));
5277 val
= build (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
5278 TREE_SIDE_EFFECTS (val
) = 1;
5279 return build_unary_op (ADDR_EXPR
, val
, 0);
5282 else if (DECL_NAME (fn
) == ansi_opname
[MODIFY_EXPR
]
5284 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn
)))
5286 tree to
= stabilize_reference
5287 (build_indirect_ref (TREE_VALUE (converted_args
), 0));
5288 arg
= build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args
)), 0);
5289 val
= build (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
5290 TREE_SIDE_EFFECTS (val
) = 1;
5296 if (DECL_CONTEXT (fn
) && IS_SIGNATURE (DECL_CONTEXT (fn
)))
5297 return build_signature_method_call (fn
, converted_args
);
5298 else if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
5300 tree t
, *p
= &TREE_VALUE (converted_args
);
5301 tree binfo
= get_binfo
5302 (DECL_CONTEXT (fn
), TREE_TYPE (TREE_TYPE (*p
)), 0);
5303 *p
= convert_pointer_to_real (binfo
, *p
);
5304 if (TREE_SIDE_EFFECTS (*p
))
5305 *p
= save_expr (*p
);
5306 t
= build_pointer_type (TREE_TYPE (fn
));
5307 fn
= build_vfn_ref (p
, build_indirect_ref (*p
, 0), DECL_VINDEX (fn
));
5310 else if (DECL_INLINE (fn
))
5311 fn
= inline_conversion (fn
);
5313 fn
= build_addr_func (fn
);
5315 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))), converted_args
);
5316 if (TREE_TYPE (fn
) == void_type_node
)
5318 if (IS_AGGR_TYPE (TREE_TYPE (fn
)))
5319 fn
= build_cplus_new (TREE_TYPE (fn
), fn
);
5320 return convert_from_reference (require_complete_type (fn
));
5324 build_new_method_call (instance
, name
, args
, basetype_path
, flags
)
5325 tree instance
, name
, args
, basetype_path
;
5328 struct z_candidate
*candidates
= 0, *cand
;
5329 tree basetype
, mem_args
, fns
, instance_ptr
;
5331 tree user_args
= args
;
5333 /* If there is an extra argument for controlling virtual bases,
5334 remove it for error reporting. */
5335 if (flags
& LOOKUP_HAS_IN_CHARGE
)
5336 user_args
= TREE_CHAIN (args
);
5338 args
= resolve_args (args
);
5340 if (args
== error_mark_node
)
5341 return error_mark_node
;
5343 if (instance
== NULL_TREE
)
5344 basetype
= BINFO_TYPE (basetype_path
);
5347 if (TREE_CODE (instance
) == OFFSET_REF
)
5348 instance
= resolve_offset_ref (instance
);
5349 if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
5350 instance
= convert_from_reference (instance
);
5351 basetype
= TREE_TYPE (instance
);
5353 /* XXX this should be handled before we get here. */
5354 if (! IS_AGGR_TYPE (basetype
)
5355 && ! (TYPE_LANG_SPECIFIC (basetype
)
5356 && (IS_SIGNATURE_POINTER (basetype
)
5357 || IS_SIGNATURE_REFERENCE (basetype
))))
5359 if ((flags
& LOOKUP_COMPLAIN
) && basetype
!= error_mark_node
)
5360 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5361 name
, instance
, basetype
);
5363 return error_mark_node
;
5366 /* If `instance' is a signature pointer/reference and `name' is
5367 not a constructor, we are calling a signature member function.
5368 In that case set the `basetype' to the signature type. */
5369 if ((IS_SIGNATURE_POINTER (basetype
)
5370 || IS_SIGNATURE_REFERENCE (basetype
))
5371 && TYPE_IDENTIFIER (basetype
) != name
)
5372 basetype
= SIGNATURE_TYPE (basetype
);
5375 if (basetype_path
== NULL_TREE
)
5376 basetype_path
= TYPE_BINFO (basetype
);
5380 instance_ptr
= build_this (instance
);
5382 /* XXX this should be handled before we get here. */
5383 fns
= build_field_call (basetype_path
, instance_ptr
, name
, args
);
5389 instance_ptr
= build_int_2 (0, 0);
5390 TREE_TYPE (instance_ptr
) = build_pointer_type (basetype
);
5394 = (name
== ctor_identifier
? constructor_name_full (basetype
) : name
);
5396 fns
= lookup_fnfields (basetype_path
, name
, 1);
5398 if (fns
== error_mark_node
)
5399 return error_mark_node
;
5402 tree t
= TREE_VALUE (fns
);
5403 if (name
== ctor_identifier
&& TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
5404 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
5406 flags
|= LOOKUP_HAS_IN_CHARGE
;
5407 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
5409 mem_args
= tree_cons (NULL_TREE
, instance_ptr
, args
);
5410 for (; t
; t
= DECL_CHAIN (t
))
5412 /* We can end up here for copy-init of same or base class. */
5413 if (name
== ctor_identifier
5414 && (flags
& LOOKUP_ONLYCONVERTING
)
5415 && DECL_NONCONVERTING_P (t
))
5417 if (TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)
5418 candidates
= add_function_candidate
5419 (candidates
, t
, mem_args
, flags
);
5421 candidates
= add_function_candidate (candidates
, t
, args
, flags
);
5422 candidates
->basetype_path
= TREE_PURPOSE (fns
);
5426 if (! any_viable (candidates
))
5428 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5429 if (flags
& LOOKUP_SPECULATIVELY
)
5431 cp_error ("no matching function for call to `%T::%D (%A)%V'", basetype
,
5432 pretty_name
, user_args
, TREE_TYPE (TREE_TYPE (instance_ptr
)));
5433 print_z_candidates (candidates
);
5434 return error_mark_node
;
5436 candidates
= splice_viable (candidates
);
5437 cand
= tourney (candidates
);
5441 cp_error ("call of overloaded `%D(%A)' is ambiguous", pretty_name
,
5443 print_z_candidates (candidates
);
5444 return error_mark_node
;
5447 enforce_access (cand
->basetype_path
, cand
->fn
);
5448 if (DECL_ABSTRACT_VIRTUAL_P (cand
->fn
)
5449 && instance
== current_class_ref
5450 && DECL_CONSTRUCTOR_P (current_function_decl
)
5451 && ! (flags
& LOOKUP_NONVIRTUAL
)
5452 && value_member (cand
->fn
, get_abstract_virtuals (basetype
)))
5453 cp_error ("abstract virtual `%#D' called from constructor", cand
->fn
);
5454 if (TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
5455 && TREE_CODE (instance_ptr
) == NOP_EXPR
5456 && TREE_OPERAND (instance_ptr
, 0) == error_mark_node
)
5457 cp_error ("cannot call member function `%D' without object", cand
->fn
);
5459 if (DECL_VINDEX (cand
->fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
5460 && ((instance
== current_class_ref
&& (dtor_label
|| ctor_label
))
5461 || resolves_to_fixed_type_p (instance
, 0)))
5462 flags
|= LOOKUP_NONVIRTUAL
;
5464 return build_over_call
5465 (cand
->fn
, cand
->convs
,
5466 TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
? mem_args
: args
,
5470 /* Compare two implicit conversion sequences that differ only in their
5471 qualification conversion. Subroutine of compare_ics. */
5474 compare_qual (ics1
, ics2
)
5477 tree to1
= TREE_TYPE (ics1
);
5478 tree to2
= TREE_TYPE (ics2
);
5480 to1
= TREE_TYPE (to1
);
5481 to2
= TREE_TYPE (to2
);
5483 if (TREE_CODE (to1
) == OFFSET_TYPE
)
5485 to1
= TREE_TYPE (to1
);
5486 to2
= TREE_TYPE (to2
);
5489 if (TYPE_READONLY (to1
) >= TYPE_READONLY (to2
)
5490 && TYPE_VOLATILE (to1
) > TYPE_VOLATILE (to2
))
5492 else if (TYPE_READONLY (to1
) > TYPE_READONLY (to2
)
5493 && TYPE_VOLATILE (to1
) == TYPE_VOLATILE (to2
))
5495 else if (TYPE_READONLY (to1
) <= TYPE_READONLY (to2
)
5496 && TYPE_VOLATILE (to1
) < TYPE_VOLATILE (to2
))
5498 else if (TYPE_READONLY (to1
) < TYPE_READONLY (to2
)
5499 && TYPE_VOLATILE (to1
) == TYPE_VOLATILE (to2
))
5504 /* Determine whether standard conversion sequence ICS1 is a proper
5505 subsequence of ICS2. We assume that a conversion of the same code
5506 between the same types indicates a subsequence. */
5509 is_subseq (ics1
, ics2
)
5512 for (;; ics2
= TREE_OPERAND (ics2
, 0))
5514 if (TREE_CODE (ics2
) == TREE_CODE (ics1
)
5515 && comptypes (TREE_TYPE (ics2
), TREE_TYPE (ics1
), 1)
5516 && comptypes (TREE_TYPE (TREE_OPERAND (ics2
, 0)),
5517 TREE_TYPE (TREE_OPERAND (ics1
, 0)), 1))
5520 if (TREE_CODE (ics2
) == USER_CONV
5521 || TREE_CODE (ics2
) == AMBIG_CONV
5522 || TREE_CODE (ics2
) == IDENTITY_CONV
)
5527 /* Compare two implicit conversion sequences according to the rules set out in
5528 [over.ics.rank]. Return values:
5530 1: ics1 is better than ics2
5531 -1: ics2 is better than ics1
5532 0: ics1 and ics2 are indistinguishable */
5535 compare_ics (ics1
, ics2
)
5540 if (TREE_CODE (ics1
) == QUAL_CONV
)
5541 main1
= TREE_OPERAND (ics1
, 0);
5545 if (TREE_CODE (ics2
) == QUAL_CONV
)
5546 main2
= TREE_OPERAND (ics2
, 0);
5550 /* Conversions for `this' are PTR_CONVs, but we compare them as though
5551 they were REF_BINDs. */
5552 if (ICS_THIS_FLAG (ics1
))
5555 if (TREE_CODE (t
) == PTR_CONV
)
5556 t
= TREE_OPERAND (t
, 0);
5557 t
= build1 (IDENTITY_CONV
, TREE_TYPE (TREE_TYPE (t
)), NULL_TREE
);
5558 t
= build_conv (REF_BIND
, TREE_TYPE (ics1
), t
);
5559 ICS_STD_RANK (t
) = ICS_STD_RANK (main1
);
5562 if (ICS_THIS_FLAG (ics2
))
5565 if (TREE_CODE (t
) == PTR_CONV
)
5566 t
= TREE_OPERAND (t
, 0);
5567 t
= build1 (IDENTITY_CONV
, TREE_TYPE (TREE_TYPE (t
)), NULL_TREE
);
5568 t
= build_conv (REF_BIND
, TREE_TYPE (ics2
), t
);
5569 ICS_STD_RANK (t
) = ICS_STD_RANK (main2
);
5573 if (ICS_RANK (ics1
) > ICS_RANK (ics2
))
5575 else if (ICS_RANK (ics1
) < ICS_RANK (ics2
))
5578 if (ICS_RANK (ics1
) == BAD_RANK
)
5580 if (ICS_USER_FLAG (ics1
) > ICS_USER_FLAG (ics2
)
5581 || ICS_STD_RANK (ics1
) > ICS_STD_RANK (ics2
))
5583 else if (ICS_USER_FLAG (ics1
) < ICS_USER_FLAG (ics2
)
5584 || ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5587 /* else fall through */
5590 /* User-defined conversion sequence U1 is a better conversion sequence
5591 than another user-defined conversion sequence U2 if they contain the
5592 same user-defined conversion operator or constructor and if the sec-
5593 ond standard conversion sequence of U1 is better than the second
5594 standard conversion sequence of U2. */
5596 if (ICS_USER_FLAG (ics1
))
5600 for (t1
= ics1
; TREE_CODE (t1
) != USER_CONV
; t1
= TREE_OPERAND (t1
, 0))
5601 if (TREE_CODE (t1
) == AMBIG_CONV
)
5603 for (t2
= ics2
; TREE_CODE (t2
) != USER_CONV
; t2
= TREE_OPERAND (t2
, 0))
5604 if (TREE_CODE (t2
) == AMBIG_CONV
)
5607 if (USER_CONV_FN (t1
) != USER_CONV_FN (t2
))
5609 else if (ICS_STD_RANK (ics1
) > ICS_STD_RANK (ics2
))
5611 else if (ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5614 /* else fall through */
5617 #if 0 /* Handled by ranking */
5618 /* A conversion that is not a conversion of a pointer, or pointer to
5619 member, to bool is better than another conversion that is such a
5623 if (TREE_CODE (main1
) != TREE_CODE (main2
))
5625 /* ...if S1 is a proper subsequence of S2 */
5626 if (is_subseq (main1
, main2
))
5628 if (is_subseq (main2
, main1
))
5633 if (TREE_CODE (main1
) == PTR_CONV
|| TREE_CODE (main1
) == PMEM_CONV
5634 || TREE_CODE (main1
) == REF_BIND
|| TREE_CODE (main1
) == BASE_CONV
)
5636 tree to1
= TREE_TYPE (main1
);
5637 tree from1
= TREE_TYPE (TREE_OPERAND (main1
, 0));
5638 tree to2
= TREE_TYPE (main2
);
5639 tree from2
= TREE_TYPE (TREE_OPERAND (main2
, 0));
5642 /* Standard conversion sequence S1 is a better conversion sequence than
5643 standard conversion sequence S2 if...
5645 S1 and S2 differ only in their qualification conversion and they
5646 yield types identical except for cv-qualifiers and S2 adds all the
5647 qualifiers that S1 adds (and in the same places) and S2 adds yet
5648 more cv-qualifiers than S1, or the similar case with reference
5650 if (TREE_CODE (main1
) == REF_BIND
)
5652 if (TYPE_MAIN_VARIANT (TREE_TYPE (to1
))
5653 == TYPE_MAIN_VARIANT (TREE_TYPE (to2
)))
5654 return compare_qual (ics1
, ics2
);
5656 else if (TREE_CODE (main1
) != BASE_CONV
&& from1
== from2
&& to1
== to2
)
5657 return compare_qual (ics1
, ics2
);
5659 if (TYPE_PTRMEMFUNC_P (to1
))
5661 to1
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to1
));
5662 from1
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from1
));
5664 else if (TREE_CODE (main1
) != BASE_CONV
)
5666 to1
= TREE_TYPE (to1
);
5667 if (TREE_CODE (main1
) != REF_BIND
)
5668 from1
= TREE_TYPE (from1
);
5670 if (TREE_CODE (to1
) == OFFSET_TYPE
)
5672 to1
= TYPE_OFFSET_BASETYPE (to1
);
5673 from1
= TYPE_OFFSET_BASETYPE (from1
);
5677 if (TYPE_PTRMEMFUNC_P (to2
))
5679 to2
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to2
));
5680 from2
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from2
));
5682 else if (TREE_CODE (main1
) != BASE_CONV
)
5684 to2
= TREE_TYPE (to2
);
5685 if (TREE_CODE (main1
) != REF_BIND
)
5686 from2
= TREE_TYPE (from2
);
5688 if (TREE_CODE (to2
) == OFFSET_TYPE
)
5690 to2
= TYPE_OFFSET_BASETYPE (to2
);
5691 from2
= TYPE_OFFSET_BASETYPE (from2
);
5695 if (! (IS_AGGR_TYPE (from1
) && IS_AGGR_TYPE (from2
)))
5698 /* The sense of pmem conversions is reversed from that of the other
5700 if (TREE_CODE (main1
) == PMEM_CONV
)
5702 tree t
= from1
; from1
= from2
; from2
= t
;
5703 t
= to1
; to1
= to2
; to2
= t
;
5706 distf
= get_base_distance (from1
, from2
, 0, 0);
5709 distf
= -get_base_distance (from2
, from1
, 0, 0);
5714 /* If class B is derived directly or indirectly from class A,
5715 conver- sion of B* to A* is better than conversion of B* to
5716 void*, and conversion of A* to void* is better than
5717 conversion of B* to void*. */
5719 if (TREE_CODE (to1
) == VOID_TYPE
&& TREE_CODE (to2
) == VOID_TYPE
)
5726 else if (TREE_CODE (to2
) == VOID_TYPE
&& IS_AGGR_TYPE (to1
)
5727 && get_base_distance (to1
, from1
, 0, 0) != -1)
5729 else if (TREE_CODE (to1
) == VOID_TYPE
&& IS_AGGR_TYPE (to2
)
5730 && get_base_distance (to2
, from2
, 0, 0) != -1)
5733 if (! (IS_AGGR_TYPE (to1
) && IS_AGGR_TYPE (to2
)))
5736 /* If class B is derived directly or indirectly from class A and class
5737 C is derived directly or indirectly from B */
5739 distt
= get_base_distance (to1
, to2
, 0, 0);
5742 distt
= -get_base_distance (to2
, to1
, 0, 0);
5747 /* --conversion of C* to B* is better than conversion of C* to A*, */
5755 /* --conversion of B* to A* is better than conversion of C* to A*, */
5756 else if (distt
== 0)
5764 else if (TREE_CODE (TREE_TYPE (main1
)) == POINTER_TYPE
5765 || TYPE_PTRMEMFUNC_P (TREE_TYPE (main1
)))
5767 if (TREE_TYPE (main1
) == TREE_TYPE (main2
))
5768 return compare_qual (ics1
, ics2
);
5770 #if 0 /* This is now handled by making identity better than anything else. */
5771 /* existing practice, not WP-endorsed: const char * -> const char *
5772 is better than char * -> const char *. (jason 6/29/96) */
5773 if (TREE_TYPE (ics1
) == TREE_TYPE (ics2
))
5774 return -compare_qual (main1
, main2
);
5781 /* Compare two candidates for overloading as described in
5782 [over.match.best]. Return values:
5784 1: cand1 is better than cand2
5785 -1: cand2 is better than cand1
5786 0: cand1 and cand2 are indistinguishable */
5789 joust (cand1
, cand2
)
5790 struct z_candidate
*cand1
, *cand2
;
5793 int i
, off1
= 0, off2
= 0, len
;
5795 /* Candidates that involve bad conversions are always worse than those
5797 if (cand1
->viable
> cand2
->viable
)
5799 if (cand1
->viable
< cand2
->viable
)
5802 /* a viable function F1
5803 is defined to be a better function than another viable function F2 if
5804 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5805 ICSi(F2), and then */
5807 /* for some argument j, ICSj(F1) is a better conversion sequence than
5810 /* For comparing static and non-static member functions, we ignore the
5811 implicit object parameter of the non-static function. The WP says to
5812 pretend that the static function has an object parm, but that won't
5813 work with operator overloading. */
5814 len
= TREE_VEC_LENGTH (cand1
->convs
);
5815 if (len
!= TREE_VEC_LENGTH (cand2
->convs
))
5817 if (DECL_STATIC_FUNCTION_P (cand1
->fn
)
5818 && ! DECL_STATIC_FUNCTION_P (cand2
->fn
))
5820 else if (! DECL_STATIC_FUNCTION_P (cand1
->fn
)
5821 && DECL_STATIC_FUNCTION_P (cand2
->fn
))
5827 my_friendly_abort (42);
5830 for (i
= 0; i
< len
; ++i
)
5832 tree t1
= TREE_VEC_ELT (cand1
->convs
, i
+off1
);
5833 tree t2
= TREE_VEC_ELT (cand2
->convs
, i
+off2
);
5834 int comp
= compare_ics (t1
, t2
);
5839 && ICS_RANK (t1
) + ICS_RANK (t2
) == STD_RANK
+ PROMO_RANK
5840 && TREE_CODE (t1
) == STD_CONV
5841 && TREE_CODE (t2
) == STD_CONV
5842 && TREE_CODE (TREE_TYPE (t1
)) == INTEGER_TYPE
5843 && TREE_CODE (TREE_TYPE (t2
)) == INTEGER_TYPE
5844 && (TYPE_PRECISION (TREE_TYPE (t1
))
5845 == TYPE_PRECISION (TREE_TYPE (t2
)))
5846 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t1
, 0)))
5847 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (t1
, 0)))
5850 tree type
= TREE_TYPE (TREE_OPERAND (t1
, 0));
5853 type1
= TREE_TYPE (t1
), type2
= TREE_TYPE (t2
);
5855 type1
= TREE_TYPE (t2
), type2
= TREE_TYPE (t1
);
5857 cp_warning ("`%T' promotes to `%T', not `%T'",
5858 type
, type1
, type2
);
5859 cp_warning (" in call to `%D'", DECL_NAME (cand1
->fn
));
5862 if (winner
&& comp
!= winner
)
5875 F1 is a non-template function and F2 is a template function */
5877 if (! cand1
->template && cand2
->template)
5879 else if (cand1
->template && ! cand2
->template)
5881 else if (cand1
->template && cand2
->template)
5882 winner
= more_specialized
5883 (TI_TEMPLATE (cand1
->template), TI_TEMPLATE (cand2
->template));
5886 the context is an initialization by user-defined conversion (see
5887 _dcl.init_ and _over.match.user_) and the standard conversion
5888 sequence from the return type of F1 to the destination type (i.e.,
5889 the type of the entity being initialized) is a better conversion
5890 sequence than the standard conversion sequence from the return type
5891 of F2 to the destination type. */
5893 if (! winner
&& cand1
->second_conv
)
5894 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
5896 /* If the built-in candidates are the same, arbitrarily pick one. */
5897 if (! winner
&& cand1
->fn
== cand2
->fn
5898 && TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
)
5900 for (i
= 0; i
< len
; ++i
)
5901 if (! comptypes (TREE_TYPE (TREE_VEC_ELT (cand1
->convs
, i
)),
5902 TREE_TYPE (TREE_VEC_ELT (cand2
->convs
, i
)), 1))
5904 if (i
== TREE_VEC_LENGTH (cand1
->convs
))
5907 /* Kludge around broken overloading rules whereby
5908 bool ? void *const & : void *const & is ambiguous. */
5909 /* Huh? Explain the problem better. */
5910 if (cand1
->fn
== ansi_opname
[COND_EXPR
])
5912 tree c1
= TREE_VEC_ELT (cand1
->convs
, 1);
5913 tree c2
= TREE_VEC_ELT (cand2
->convs
, 1);
5914 tree t1
= strip_top_quals (non_reference (TREE_TYPE (c1
)));
5915 tree t2
= strip_top_quals (non_reference (TREE_TYPE (c2
)));
5917 if (comptypes (t1
, t2
, 1))
5919 if (TREE_CODE (c1
) == REF_BIND
&& TREE_CODE (c2
) != REF_BIND
)
5921 if (TREE_CODE (c1
) != REF_BIND
&& TREE_CODE (c2
) == REF_BIND
)
5930 /* Extension: If the worst conversion for one candidate is worse than the
5931 worst conversion for the other, take the first. */
5932 if (! winner
&& ! pedantic
)
5934 int rank1
= IDENTITY_RANK
, rank2
= IDENTITY_RANK
;
5936 for (i
= 0; i
< len
; ++i
)
5938 if (ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
)) > rank1
)
5939 rank1
= ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
));
5940 if (ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
)) > rank2
)
5941 rank2
= ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
));
5953 /* Given a list of candidates for overloading, find the best one, if any.
5954 This algorithm has a worst case of O(2n) (winner is last), and a best
5955 case of O(n/2) (totally ambiguous); much better than a sorting
5958 static struct z_candidate
*
5959 tourney (candidates
)
5960 struct z_candidate
*candidates
;
5962 struct z_candidate
*champ
= candidates
, *challenger
;
5965 /* Walk through the list once, comparing each current champ to the next
5966 candidate, knocking out a candidate or two with each comparison. */
5968 for (challenger
= champ
->next
; challenger
; )
5970 fate
= joust (champ
, challenger
);
5972 challenger
= challenger
->next
;
5977 champ
= challenger
->next
;
5984 challenger
= champ
->next
;
5988 /* Make sure the champ is better than all the candidates it hasn't yet
5989 been compared to. This may do one more comparison than necessary. Oh
5992 for (challenger
= candidates
; challenger
!= champ
;
5993 challenger
= challenger
->next
)
5995 fate
= joust (champ
, challenger
);
6004 can_convert (to
, from
)
6007 if (flag_ansi_overloading
)
6009 tree t
= implicit_conversion (to
, from
, NULL_TREE
, LOOKUP_NORMAL
);
6010 return (t
&& ! ICS_BAD_FLAG (t
));
6014 struct harshness_code h
;
6015 h
= convert_harshness (to
, from
, NULL_TREE
);
6016 return (h
.code
< USER_CODE
) && (h
.distance
>= 0);
6021 can_convert_arg (to
, from
, arg
)
6024 if (flag_ansi_overloading
)
6026 tree t
= implicit_conversion (to
, from
, arg
, LOOKUP_NORMAL
);
6027 return (t
&& ! ICS_BAD_FLAG (t
));
6031 struct harshness_code h
;
6032 h
= convert_harshness (to
, from
, arg
);
6033 return (h
.code
< USER_CODE
) && (h
.distance
>= 0);