1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995 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. */
35 #define obstack_chunk_alloc xmalloc
36 #define obstack_chunk_free free
40 extern int inhibit_warnings
;
41 extern tree ctor_label
, dtor_label
;
43 /* Compute the ease with which a conversion can be performed
44 between an expected and the given type. */
46 static struct harshness_code convert_harshness
PROTO((register tree
, register tree
, tree
));
48 #define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG))
49 #define STD_RETURN(ARG) ((ARG).code = STD_CODE, (ARG))
50 #define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG))
51 #define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG))
52 #define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG))
54 /* Ordering function for overload resolution. Compare two candidates
58 rank_for_overload (x
, y
)
59 struct candidate
*x
, *y
;
61 if (y
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
62 return y
->h
.code
- x
->h
.code
;
63 if (x
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
66 /* This is set by compute_conversion_costs, for calling a non-const
67 member function from a const member function. */
68 if ((y
->harshness
[0].code
& CONST_CODE
) ^ (x
->harshness
[0].code
& CONST_CODE
))
69 return y
->harshness
[0].code
- x
->harshness
[0].code
;
71 if (y
->h
.code
& STD_CODE
)
73 if (x
->h
.code
& STD_CODE
)
74 return y
->h
.distance
- x
->h
.distance
;
77 if (x
->h
.code
& STD_CODE
)
80 return y
->h
.code
- x
->h
.code
;
83 /* Compare two candidates, argument by argument. */
87 struct candidate
*x
, *y
;
91 if (x
->h_len
!= y
->h_len
)
94 for (i
= 0; i
< x
->h_len
; i
++)
96 if (y
->harshness
[i
].code
- x
->harshness
[i
].code
)
97 return y
->harshness
[i
].code
- x
->harshness
[i
].code
;
98 if ((y
->harshness
[i
].code
& STD_CODE
)
99 && (y
->harshness
[i
].distance
- x
->harshness
[i
].distance
))
100 return y
->harshness
[i
].distance
- x
->harshness
[i
].distance
;
102 /* They're both the same code. Now see if we're dealing with an
103 integral promotion that needs a finer grain of accuracy. */
104 if (y
->harshness
[0].code
& PROMO_CODE
105 && (y
->harshness
[i
].int_penalty
^ x
->harshness
[i
].int_penalty
))
106 return y
->harshness
[i
].int_penalty
- x
->harshness
[i
].int_penalty
;
111 /* TYPE is the type we wish to convert to. PARM is the parameter
112 we have to work with. We use a somewhat arbitrary cost function
113 to measure this conversion. */
115 static struct harshness_code
116 convert_harshness (type
, parmtype
, parm
)
117 register tree type
, parmtype
;
120 struct harshness_code h
;
121 register enum tree_code codel
;
122 register enum tree_code coder
;
129 #ifdef GATHER_STATISTICS
130 n_convert_harshness
++;
133 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
136 parm
= convert_from_reference (parm
);
137 parmtype
= TREE_TYPE (parmtype
);
141 lvalue
= lvalue_p (parm
);
145 if (TYPE_PTRMEMFUNC_P (type
))
146 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
147 if (TYPE_PTRMEMFUNC_P (parmtype
))
148 parmtype
= TYPE_PTRMEMFUNC_FN_TYPE (parmtype
);
150 codel
= TREE_CODE (type
);
151 coder
= TREE_CODE (parmtype
);
153 if (TYPE_MAIN_VARIANT (parmtype
) == TYPE_MAIN_VARIANT (type
))
154 return ZERO_RETURN (h
);
156 if (coder
== ERROR_MARK
)
157 return EVIL_RETURN (h
);
159 if (codel
== REFERENCE_TYPE
)
162 int constp
= parm
? TREE_READONLY (parm
) : TYPE_READONLY (parmtype
);
163 int volatilep
= (parm
? TREE_THIS_VOLATILE (parm
)
164 : TYPE_VOLATILE (parmtype
));
165 register tree intype
= TYPE_MAIN_VARIANT (parmtype
);
166 register enum tree_code form
= TREE_CODE (intype
);
169 ttl
= TREE_TYPE (type
);
171 /* Only allow const reference binding if we were given a parm to deal
172 with, since it isn't really a conversion. This is a hack to
173 prevent build_type_conversion from finding this conversion, but
174 still allow overloading to find it. */
175 if (! lvalue
&& ! (parm
&& TYPE_READONLY (ttl
)))
176 return EVIL_RETURN (h
);
178 if ((TYPE_READONLY (ttl
) < constp
)
179 || (TYPE_VOLATILE (ttl
) < volatilep
))
180 return EVIL_RETURN (h
);
182 /* When passing a non-const argument into a const reference, dig it a
183 little, so a non-const reference is preferred over this one. */
184 penalty
= ((TYPE_READONLY (ttl
) > constp
)
185 + (TYPE_VOLATILE (ttl
) > volatilep
));
187 ttl
= TYPE_MAIN_VARIANT (ttl
);
189 if (form
== OFFSET_TYPE
)
191 intype
= TREE_TYPE (intype
);
192 form
= TREE_CODE (intype
);
197 if (TREE_CODE (ttl
) == ARRAY_TYPE
&& TREE_CODE (ttr
) == ARRAY_TYPE
)
199 if (comptypes (ttl
, ttr
, 1))
200 return ZERO_RETURN (h
);
201 return EVIL_RETURN (h
);
204 h
= convert_harshness (ttl
, ttr
, NULL_TREE
);
205 if (penalty
&& h
.code
== 0)
208 h
.int_penalty
= penalty
;
213 if (codel
== POINTER_TYPE
&& fntype_p (parmtype
))
216 struct harshness_code h1
, h2
;
218 /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */
219 type
= TREE_TYPE (type
);
221 if (coder
== POINTER_TYPE
)
223 parmtype
= TREE_TYPE (parmtype
);
224 coder
= TREE_CODE (parmtype
);
227 if (coder
!= TREE_CODE (type
))
228 return EVIL_RETURN (h
);
230 if (type
!= parmtype
&& coder
== METHOD_TYPE
)
232 tree ttl
= TYPE_METHOD_BASETYPE (type
);
233 tree ttr
= TYPE_METHOD_BASETYPE (parmtype
);
235 int b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
238 b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
240 return EVIL_RETURN (h
);
241 h
.distance
= -b_or_d
;
247 type
= build_function_type
248 (TREE_TYPE (type
), TREE_CHAIN (TYPE_ARG_TYPES (type
)));
249 parmtype
= build_function_type
250 (TREE_TYPE (parmtype
), TREE_CHAIN (TYPE_ARG_TYPES (parmtype
)));
253 /* We allow the default conversion between function type
254 and pointer-to-function type for free. */
255 if (comptypes (type
, parmtype
, 1))
259 return EVIL_RETURN (h
);
261 /* Compare return types. */
262 p1
= TREE_TYPE (type
);
263 p2
= TREE_TYPE (parmtype
);
264 h2
= convert_harshness (p1
, p2
, NULL_TREE
);
265 if (h2
.code
& EVIL_CODE
)
268 h1
.code
= TRIVIAL_CODE
;
271 if (h2
.distance
!= 0)
275 /* This only works for pointers. */
276 if (TREE_CODE (p1
) != POINTER_TYPE
277 && TREE_CODE (p1
) != REFERENCE_TYPE
)
278 return EVIL_RETURN (h
);
282 /* Don't die if we happen to be dealing with void*. */
283 if (!IS_AGGR_TYPE (p1
) || !IS_AGGR_TYPE (p2
))
284 return EVIL_RETURN (h
);
286 binfo
= get_binfo (p2
, p1
, 0);
288 binfo
= get_binfo (p1
, p2
, 0);
290 if (! BINFO_OFFSET_ZEROP (binfo
))
293 static int explained
= 0;
295 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p2
, p1
);
297 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p1
, p2
);
300 sorry ("(because pointer values change during conversion)");
302 return EVIL_RETURN (h
);
307 if (h2
.distance
> h1
.distance
)
308 h1
.distance
= h2
.distance
;
310 p1
= TYPE_ARG_TYPES (type
);
311 p2
= TYPE_ARG_TYPES (parmtype
);
312 while (p1
&& TREE_VALUE (p1
) != void_type_node
313 && p2
&& TREE_VALUE (p2
) != void_type_node
)
315 h2
= convert_harshness (TREE_VALUE (p1
), TREE_VALUE (p2
),
317 if (h2
.code
& EVIL_CODE
)
322 /* This only works for pointers and references. */
323 if (TREE_CODE (TREE_VALUE (p1
)) != POINTER_TYPE
324 && TREE_CODE (TREE_VALUE (p1
)) != REFERENCE_TYPE
)
325 return EVIL_RETURN (h
);
326 h2
.distance
= - h2
.distance
;
330 if (h2
.distance
> h1
.distance
)
331 h1
.distance
= h2
.distance
;
332 p1
= TREE_CHAIN (p1
);
333 p2
= TREE_CHAIN (p2
);
340 return EVIL_RETURN (h
);
341 h1
.code
|= ELLIPSIS_CODE
;
346 if (TREE_PURPOSE (p1
) == NULL_TREE
)
347 h1
.code
|= EVIL_CODE
;
351 else if (codel
== POINTER_TYPE
&& coder
== OFFSET_TYPE
)
355 /* Get to the OFFSET_TYPE that this might be. */
356 type
= TREE_TYPE (type
);
358 if (coder
!= TREE_CODE (type
))
359 return EVIL_RETURN (h
);
361 ttl
= TYPE_OFFSET_BASETYPE (type
);
362 ttr
= TYPE_OFFSET_BASETYPE (parmtype
);
368 int b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
371 b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
373 return EVIL_RETURN (h
);
374 h
.distance
= -b_or_d
;
381 /* Now test the OFFSET_TYPE's target compatibility. */
382 type
= TREE_TYPE (type
);
383 parmtype
= TREE_TYPE (parmtype
);
386 if (coder
== UNKNOWN_TYPE
)
388 if (codel
== FUNCTION_TYPE
389 || codel
== METHOD_TYPE
390 || (codel
== POINTER_TYPE
391 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
392 || TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)))
393 return TRIVIAL_RETURN (h
);
394 return EVIL_RETURN (h
);
397 if (coder
== VOID_TYPE
)
398 return EVIL_RETURN (h
);
400 if (codel
== BOOLEAN_TYPE
)
402 if (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
)
403 return STD_RETURN (h
);
404 else if (coder
== POINTER_TYPE
|| coder
== OFFSET_TYPE
)
406 /* Make this worse than any conversion to another pointer.
407 FIXME this is how I think the language should work, but it may not
408 end up being how the language is standardized (jason 1/30/95). */
410 return STD_RETURN (h
);
412 return EVIL_RETURN (h
);
415 if (INTEGRAL_CODE_P (codel
))
417 /* Control equivalence of ints an enums. */
419 if (codel
== ENUMERAL_TYPE
420 && flag_int_enum_equivalence
== 0)
422 /* Enums can be converted to ints, but not vice-versa. */
423 if (coder
!= ENUMERAL_TYPE
424 || TYPE_MAIN_VARIANT (type
) != TYPE_MAIN_VARIANT (parmtype
))
425 return EVIL_RETURN (h
);
428 /* else enums and ints (almost) freely interconvert. */
430 if (INTEGRAL_CODE_P (coder
))
432 if (TYPE_MAIN_VARIANT (type
)
433 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
442 else if (coder
== REAL_TYPE
)
450 if (codel
== REAL_TYPE
)
452 if (coder
== REAL_TYPE
)
454 if (TYPE_MAIN_VARIANT (type
)
455 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
462 else if (INTEGRAL_CODE_P (coder
))
470 /* Convert arrays which have not previously been converted. */
471 if (coder
== ARRAY_TYPE
)
473 coder
= POINTER_TYPE
;
476 parm
= decay_conversion (parm
);
477 parmtype
= TREE_TYPE (parm
);
480 parmtype
= build_pointer_type (TREE_TYPE (parmtype
));
483 /* Conversions among pointers */
484 if (codel
== POINTER_TYPE
&& coder
== POINTER_TYPE
)
486 register tree ttl
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
487 register tree ttr
= TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
));
488 int penalty
= 4 * (ttl
!= ttr
);
490 /* Anything converts to void *. Since this may be `const void *'
491 (etc.) use VOID_TYPE instead of void_type_node. Otherwise, the
492 targets must be the same, except that we do allow (at some cost)
493 conversion between signed and unsigned pointer types. */
495 if ((TREE_CODE (ttl
) == METHOD_TYPE
496 || TREE_CODE (ttl
) == FUNCTION_TYPE
)
497 && TREE_CODE (ttl
) == TREE_CODE (ttr
))
499 if (comptypes (ttl
, ttr
, -1))
501 h
.code
= penalty
? STD_CODE
: 0;
510 if (TREE_CODE (ttl
) != VOID_TYPE
511 && (TREE_CODE (ttr
) != VOID_TYPE
|| !parm
|| !null_ptr_cst_p (parm
)))
513 if (comp_target_types (type
, parmtype
, 1) <= 0)
514 return EVIL_RETURN (h
);
517 if (!(TREE_CODE (ttl
) == VOID_TYPE
518 || TREE_CODE (ttr
) == VOID_TYPE
519 || (TREE_UNSIGNED (ttl
) ^ TREE_UNSIGNED (ttr
)
520 && (ttl
= unsigned_type (ttl
),
521 ttr
= unsigned_type (ttr
),
523 || (comp_target_types (ttl
, ttr
, 0) > 0)))
524 return EVIL_RETURN (h
);
529 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
532 /* Note conversion from `T*' to `const T*',
533 or `T*' to `volatile T*'. */
534 if ((TYPE_READONLY (tmp1
) < TREE_READONLY (tmp2
))
535 || (TYPE_VOLATILE (tmp1
) < TYPE_VOLATILE (tmp2
)))
537 else if ((TYPE_READONLY (tmp1
) != TREE_READONLY (tmp2
))
538 || (TYPE_VOLATILE (tmp1
) != TYPE_VOLATILE (tmp2
)))
546 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
548 int b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
551 b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
553 return EVIL_RETURN (h
);
554 h
.distance
= -b_or_d
;
562 /* If converting from a `class*' to a `void*', make it
563 less favorable than any inheritance relationship. */
564 if (TREE_CODE (ttl
) == VOID_TYPE
&& IS_AGGR_TYPE (ttr
))
567 h
.distance
= CLASSTYPE_MAX_DEPTH (ttr
)+1;
571 h
.code
= penalty
? STD_CODE
: PROMO_CODE
;
572 /* Catch things like `const char *' -> `const void *'
573 vs `const char *' -> `void *'. */
576 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
577 if ((TYPE_READONLY (tmp1
) < TREE_READONLY (tmp2
))
578 || (TYPE_VOLATILE (tmp1
) < TYPE_VOLATILE (tmp2
)))
580 else if ((TYPE_READONLY (tmp1
) > TREE_READONLY (tmp2
))
581 || (TYPE_VOLATILE (tmp1
) > TYPE_VOLATILE (tmp2
)))
587 if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
589 /* This is not a bad match, but don't let it beat
590 integer-enum combinations. */
591 if (parm
&& integer_zerop (parm
))
599 /* C++: Since the `this' parameter of a signature member function
600 is represented as a signature pointer to handle default implementations
601 correctly, we can have the case that `type' is a signature pointer
602 while `parmtype' is a pointer to a signature table. We don't really
603 do any conversions in this case, so just return 0. */
605 if (codel
== RECORD_TYPE
&& coder
== POINTER_TYPE
606 && IS_SIGNATURE_POINTER (type
) && IS_SIGNATURE (TREE_TYPE (parmtype
)))
607 return ZERO_RETURN (h
);
609 if (codel
== RECORD_TYPE
&& coder
== RECORD_TYPE
)
611 int b_or_d
= get_base_distance (type
, parmtype
, 0, (tree
*)0);
614 b_or_d
= get_base_distance (parmtype
, type
, 0, (tree
*)0);
616 return EVIL_RETURN (h
);
617 h
.distance
= -b_or_d
;
624 return EVIL_RETURN (h
);
627 /* A clone of build_type_conversion for checking user-defined conversions in
628 overload resolution. */
631 user_harshness (type
, parmtype
)
632 register tree type
, parmtype
;
635 tree winner
= NULL_TREE
;
639 tree typename
= build_typename_overload (type
);
640 if (lookup_fnfields (TYPE_BINFO (parmtype
), typename
, 0))
644 for (conv
= lookup_conversions (parmtype
); conv
; conv
= TREE_CHAIN (conv
))
646 struct harshness_code tmp
;
647 tree cand
= TREE_VALUE (conv
);
649 if (winner
&& winner
== cand
)
652 tmp
= convert_harshness (type
, TREE_TYPE (TREE_TYPE (cand
)), NULL_TREE
);
653 if ((tmp
.code
< USER_CODE
) && (tmp
.distance
>= 0))
671 #ifdef DEBUG_MATCHING
674 struct harshness_code
*h
;
676 static char buf
[1024];
679 bzero (buf
, 1024 * sizeof (char));
680 strcat (buf
, "codes=[");
681 if (h
->code
& EVIL_CODE
)
682 strcat (buf
, "EVIL");
683 if (h
->code
& CONST_CODE
)
684 strcat (buf
, " CONST");
685 if (h
->code
& ELLIPSIS_CODE
)
686 strcat (buf
, " ELLIPSIS");
687 if (h
->code
& USER_CODE
)
688 strcat (buf
, " USER");
689 if (h
->code
& STD_CODE
)
690 strcat (buf
, " STD");
691 if (h
->code
& PROMO_CODE
)
692 strcat (buf
, " PROMO");
693 if (h
->code
& QUAL_CODE
)
694 strcat (buf
, " QUAL");
695 if (h
->code
& TRIVIAL_CODE
)
696 strcat (buf
, " TRIVIAL");
700 sprintf (tmp
, "] distance=%d int_penalty=%d", h
->distance
, h
->int_penalty
);
708 /* Algorithm: For each argument, calculate how difficult it is to
709 make FUNCTION accept that argument. If we can easily tell that
710 FUNCTION won't be acceptable to one of the arguments, then we
711 don't need to compute the ease of converting the other arguments,
712 since it will never show up in the intersection of all arguments'
715 Conversions between builtin and user-defined types are allowed, but
716 no function involving such a conversion is preferred to one which
717 does not require such a conversion. Furthermore, such conversions
721 compute_conversion_costs (function
, tta_in
, cp
, arglen
)
724 struct candidate
*cp
;
727 tree ttf_in
= TYPE_ARG_TYPES (TREE_TYPE (function
));
731 /* Start out with no strikes against. */
732 int evil_strikes
= 0;
733 int ellipsis_strikes
= 0;
734 int user_strikes
= 0;
735 int b_or_d_strikes
= 0;
736 int easy_strikes
= 0;
738 int strike_index
= 0, win
;
739 struct harshness_code lose
;
740 extern int cp_silent
;
742 #ifdef GATHER_STATISTICS
743 n_compute_conversion_costs
++;
746 #ifndef DEBUG_MATCHING
747 /* We don't emit any warnings or errors while trying out each candidate. */
751 cp
->function
= function
;
752 cp
->arg
= tta
? TREE_VALUE (tta
) : NULL_TREE
;
753 cp
->u
.bad_arg
= 0; /* optimistic! */
757 cp
->h
.int_penalty
= 0;
758 bzero ((char *) cp
->harshness
,
759 (cp
->h_len
+ 1) * sizeof (struct harshness_code
));
763 struct harshness_code h
;
765 if (ttf
== void_list_node
)
768 if (type_unknown_p (TREE_VALUE (tta
)))
770 /* Must perform some instantiation here. */
771 tree rhs
= TREE_VALUE (tta
);
772 tree lhstype
= TREE_VALUE (ttf
);
774 /* Keep quiet about possible contravariance violations. */
775 int old_inhibit_warnings
= inhibit_warnings
;
776 inhibit_warnings
= 1;
778 /* @@ This is to undo what `grokdeclarator' does to
779 parameter types. It really should go through
780 something more general. */
782 TREE_TYPE (tta
) = unknown_type_node
;
783 rhs
= instantiate_type (lhstype
, rhs
, 0);
784 inhibit_warnings
= old_inhibit_warnings
;
786 if (TREE_CODE (rhs
) == ERROR_MARK
)
789 h
= convert_harshness (lhstype
, TREE_TYPE (rhs
), rhs
);
793 #ifdef DEBUG_MATCHING
794 static tree old_function
= NULL_TREE
;
796 if (!old_function
|| function
!= old_function
)
798 cp_error ("trying %D", function
);
799 old_function
= function
;
802 cp_error (" doing (%T) %E against arg %T",
803 TREE_TYPE (TREE_VALUE (tta
)), TREE_VALUE (tta
),
807 h
= convert_harshness (TREE_VALUE (ttf
),
808 TREE_TYPE (TREE_VALUE (tta
)),
811 #ifdef DEBUG_MATCHING
812 cp_error (" evaluated %s", print_harshness (&h
));
816 cp
->harshness
[strike_index
] = h
;
817 if ((h
.code
& EVIL_CODE
)
818 || ((h
.code
& STD_CODE
) && h
.distance
< 0))
820 cp
->u
.bad_arg
= strike_index
;
823 else if (h
.code
& ELLIPSIS_CODE
)
824 ellipsis_strikes
+= 1;
826 /* This is never set by `convert_harshness'. */
827 else if (h
.code
& USER_CODE
)
834 if ((h
.code
& STD_CODE
) && h
.distance
)
836 if (h
.distance
> b_or_d_strikes
)
837 b_or_d_strikes
= h
.distance
;
840 easy_strikes
+= (h
.code
& (STD_CODE
|PROMO_CODE
|TRIVIAL_CODE
));
841 cp
->h
.code
|= h
.code
;
842 /* Make sure we communicate this. */
843 cp
->h
.int_penalty
+= h
.int_penalty
;
846 ttf
= TREE_CHAIN (ttf
);
847 tta
= TREE_CHAIN (tta
);
853 /* ran out of formals, and parmlist is fixed size. */
854 if (ttf
/* == void_type_node */)
856 cp
->h
.code
= EVIL_CODE
;
863 struct harshness_code h
;
864 int l
= list_length (tta
);
865 ellipsis_strikes
+= l
;
866 h
.code
= ELLIPSIS_CODE
;
870 cp
->harshness
[strike_index
++] = h
;
873 else if (ttf
&& ttf
!= void_list_node
)
875 /* ran out of actuals, and no defaults. */
876 if (TREE_PURPOSE (ttf
) == NULL_TREE
)
878 cp
->h
.code
= EVIL_CODE
;
883 /* Store index of first default. */
884 cp
->harshness
[arglen
].distance
= strike_index
+1;
887 cp
->harshness
[arglen
].distance
= 0;
889 /* Argument list lengths work out, so don't need to check them again. */
892 /* We do not check for derived->base conversions here, since in
893 no case would they give evil strike counts, unless such conversions
894 are somehow ambiguous. */
896 /* See if any user-defined conversions apply.
897 But make sure that we do not loop. */
898 static int dont_convert_types
= 0;
900 if (dont_convert_types
)
902 cp
->h
.code
= EVIL_CODE
;
907 win
= 0; /* Only get one chance to win. */
908 ttf
= TYPE_ARG_TYPES (TREE_TYPE (function
));
915 if (ttf
== void_list_node
)
918 lose
= cp
->harshness
[strike_index
];
919 if ((lose
.code
& EVIL_CODE
)
920 || ((lose
.code
& STD_CODE
) && lose
.distance
< 0))
922 tree actual_type
= TREE_TYPE (TREE_VALUE (tta
));
923 tree formal_type
= TREE_VALUE (ttf
);
924 int extra_conversions
= 0;
926 dont_convert_types
= 1;
928 if (TREE_CODE (formal_type
) == REFERENCE_TYPE
)
929 formal_type
= TREE_TYPE (formal_type
);
930 if (TREE_CODE (actual_type
) == REFERENCE_TYPE
)
931 actual_type
= TREE_TYPE (actual_type
);
933 if (formal_type
!= error_mark_node
934 && actual_type
!= error_mark_node
)
936 formal_type
= complete_type (TYPE_MAIN_VARIANT (formal_type
));
937 actual_type
= complete_type (TYPE_MAIN_VARIANT (actual_type
));
939 if (TYPE_HAS_CONSTRUCTOR (formal_type
))
941 /* If it has a constructor for this type,
943 /* @@ There is no way to save this result yet, so
944 success is a NULL_TREE for now. */
945 if (convert_to_aggr (formal_type
, TREE_VALUE (tta
), 0, 1)
949 if (TYPE_LANG_SPECIFIC (actual_type
)
950 && TYPE_HAS_CONVERSION (actual_type
))
952 int extra
= user_harshness (formal_type
, actual_type
);
954 if (extra
== EVIL_CODE
)
959 extra_conversions
= extra
;
963 dont_convert_types
= 0;
968 cp
->harshness
[strike_index
].code
969 = USER_CODE
| (extra_conversions
? STD_CODE
: 0);
974 if (cp
->u
.bad_arg
> strike_index
)
975 cp
->u
.bad_arg
= strike_index
;
977 evil_strikes
= win
? 2 : 1;
982 ttf
= TREE_CHAIN (ttf
);
983 tta
= TREE_CHAIN (tta
);
988 /* Const member functions get a small penalty because defaulting
989 to const is less useful than defaulting to non-const. */
990 /* This is bogus, it does not correspond to anything in the ARM.
991 This code will be fixed when this entire section is rewritten
992 to conform to the ARM. (mrs) */
993 if (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
995 tree this_parm
= TREE_VALUE (ttf_in
);
997 if (TREE_CODE (this_parm
) == RECORD_TYPE
/* Is `this' a sig ptr? */
998 ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm
))))
999 : TYPE_READONLY (TREE_TYPE (this_parm
)))
1001 cp
->harshness
[0].code
|= TRIVIAL_CODE
;
1006 /* Calling a non-const member function from a const member function
1007 is probably invalid, but for now we let it only draw a warning.
1008 We indicate that such a mismatch has occurred by setting the
1009 harshness to a maximum value. */
1010 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in
))) == POINTER_TYPE
1011 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in
))))))
1012 cp
->harshness
[0].code
|= CONST_CODE
;
1017 cp
->h
.code
= EVIL_CODE
;
1018 if (ellipsis_strikes
)
1019 cp
->h
.code
|= ELLIPSIS_CODE
;
1021 cp
->h
.code
|= USER_CODE
;
1023 #ifdef DEBUG_MATCHING
1024 cp_error ("final eval %s", print_harshness (&cp
->h
));
1028 /* Subroutine of ideal_candidate. See if X or Y is a better match
1032 strictly_better (x
, y
)
1033 unsigned short x
, y
;
1041 if (xor >= x
|| xor >= y
)
1046 /* When one of several possible overloaded functions and/or methods
1047 can be called, choose the best candidate for overloading.
1049 BASETYPE is the context from which we start method resolution
1050 or NULL if we are comparing overloaded functions.
1051 CANDIDATES is the array of candidates we have to choose from.
1052 N_CANDIDATES is the length of CANDIDATES.
1053 PARMS is a TREE_LIST of parameters to the function we'll ultimately
1054 choose. It is modified in place when resolving methods. It is not
1055 modified in place when resolving overloaded functions.
1056 LEN is the length of the parameter list. */
1058 static struct candidate
*
1059 ideal_candidate (candidates
, n_candidates
, len
)
1060 struct candidate
*candidates
;
1064 struct candidate
*cp
= candidates
+n_candidates
;
1065 int i
, j
= -1, best_code
;
1067 /* For each argument, sort the functions from best to worst for the arg.
1068 For each function that's not best for this arg, set its overall
1069 harshness to EVIL so that other args won't like it. The candidate
1070 list for the last argument is the intersection of all the best-liked
1073 qsort (candidates
, n_candidates
, sizeof (struct candidate
),
1075 best_code
= cp
[-1].h
.code
;
1077 /* If they're at least as good as each other, do an arg-by-arg check. */
1078 if (! strictly_better (cp
[-1].h
.code
, cp
[-2].h
.code
))
1083 for (j
= 0; j
< n_candidates
; j
++)
1084 if (! strictly_better (candidates
[j
].h
.code
, best_code
))
1087 qsort (candidates
+j
, n_candidates
-j
, sizeof (struct candidate
),
1089 for (i
= 0; i
< len
; i
++)
1091 if (cp
[-1].harshness
[i
].code
< cp
[-2].harshness
[i
].code
)
1093 else if (cp
[-1].harshness
[i
].code
> cp
[-2].harshness
[i
].code
)
1095 else if (cp
[-1].harshness
[i
].code
& STD_CODE
)
1097 /* If it involves a standard conversion, let the
1098 inheritance lattice be the final arbiter. */
1099 if (cp
[-1].harshness
[i
].distance
> cp
[-2].harshness
[i
].distance
)
1101 else if (cp
[-1].harshness
[i
].distance
< cp
[-2].harshness
[i
].distance
)
1104 else if (cp
[-1].harshness
[i
].code
& PROMO_CODE
)
1106 /* For integral promotions, take into account a finer
1107 granularity for determining which types should be favored
1108 over others in such promotions. */
1109 if (cp
[-1].harshness
[i
].int_penalty
> cp
[-2].harshness
[i
].int_penalty
)
1111 else if (cp
[-1].harshness
[i
].int_penalty
< cp
[-2].harshness
[i
].int_penalty
)
1116 if (! better
|| worse
)
1122 /* Assume that if the class referred to is not in the
1123 current class hierarchy, that it may be remote.
1124 PARENT is assumed to be of aggregate type here. */
1127 may_be_remote (parent
)
1130 if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent
) == 0)
1133 if (current_class_type
== NULL_TREE
)
1136 if (parent
== current_class_type
)
1139 if (UNIQUELY_DERIVED_FROM_P (parent
, current_class_type
))
1145 build_vfield_ref (datum
, type
)
1149 int old_assume_nonnull_objects
= flag_assume_nonnull_objects
;
1151 if (datum
== error_mark_node
)
1152 return error_mark_node
;
1154 /* Vtable references are always made from non-null objects. */
1155 flag_assume_nonnull_objects
= 1;
1156 if (TREE_CODE (TREE_TYPE (datum
)) == REFERENCE_TYPE
)
1157 datum
= convert_from_reference (datum
);
1159 if (! TYPE_USES_COMPLEX_INHERITANCE (type
))
1160 rval
= build (COMPONENT_REF
, TREE_TYPE (CLASSTYPE_VFIELD (type
)),
1161 datum
, CLASSTYPE_VFIELD (type
));
1163 rval
= build_component_ref (datum
, DECL_NAME (CLASSTYPE_VFIELD (type
)), NULL_TREE
, 0);
1164 flag_assume_nonnull_objects
= old_assume_nonnull_objects
;
1169 /* Build a call to a member of an object. I.e., one that overloads
1170 operator ()(), or is a pointer-to-function or pointer-to-method. */
1173 build_field_call (basetype_path
, instance_ptr
, name
, parms
)
1174 tree basetype_path
, instance_ptr
, name
, parms
;
1176 tree field
, instance
;
1178 if (instance_ptr
== current_class_ptr
)
1180 /* Check to see if we really have a reference to an instance variable
1181 with `operator()()' overloaded. */
1182 field
= IDENTIFIER_CLASS_VALUE (name
);
1184 if (field
== NULL_TREE
)
1186 cp_error ("`this' has no member named `%D'", name
);
1187 return error_mark_node
;
1190 if (TREE_CODE (field
) == FIELD_DECL
)
1192 /* If it's a field, try overloading operator (),
1193 or calling if the field is a pointer-to-function. */
1194 instance
= build_component_ref_1 (current_class_ref
, field
, 0);
1195 if (instance
== error_mark_node
)
1196 return error_mark_node
;
1198 if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1199 && (TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance
))
1200 || flag_ansi_overloading
))
1201 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, instance
, parms
, NULL_TREE
);
1203 if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1205 if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == FUNCTION_TYPE
)
1206 return build_function_call (instance
, parms
);
1207 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == METHOD_TYPE
)
1208 return build_function_call (instance
, tree_cons (NULL_TREE
, current_class_ptr
, parms
));
1214 /* Check to see if this is not really a reference to an instance variable
1215 with `operator()()' overloaded. */
1216 field
= lookup_field (basetype_path
, name
, 1, 0);
1218 /* This can happen if the reference was ambiguous or for access
1220 if (field
== error_mark_node
)
1221 return error_mark_node
;
1226 tree ftype
= TREE_TYPE (field
);
1228 if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
1229 ftype
= TREE_TYPE (ftype
);
1231 if (TYPE_LANG_SPECIFIC (ftype
)
1232 && (TYPE_OVERLOADS_CALL_EXPR (ftype
) || flag_ansi_overloading
))
1234 /* Make the next search for this field very short. */
1235 basetype
= DECL_FIELD_CONTEXT (field
);
1236 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
1238 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1239 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
,
1240 build_component_ref_1 (instance
, field
, 0),
1243 if (TREE_CODE (ftype
) == POINTER_TYPE
)
1245 if (TREE_CODE (TREE_TYPE (ftype
)) == FUNCTION_TYPE
1246 || TREE_CODE (TREE_TYPE (ftype
)) == METHOD_TYPE
)
1248 /* This is a member which is a pointer to function. */
1250 = build_component_ref_1 (build_indirect_ref (instance_ptr
,
1252 field
, LOOKUP_COMPLAIN
);
1253 if (ref
== error_mark_node
)
1254 return error_mark_node
;
1255 return build_function_call (ref
, parms
);
1258 else if (TREE_CODE (ftype
) == METHOD_TYPE
)
1260 error ("invalid call via pointer-to-member function");
1261 return error_mark_node
;
1270 find_scoped_type (type
, inner_name
, inner_types
)
1271 tree type
, inner_name
, inner_types
;
1273 tree tags
= CLASSTYPE_TAGS (type
);
1277 /* The TREE_PURPOSE of an enum tag (which becomes a member of the
1278 enclosing class) is set to the name for the enum type. So, if
1279 inner_name is `bar', and we strike `baz' for `enum bar { baz }',
1280 then this test will be true. */
1281 if (TREE_PURPOSE (tags
) == inner_name
)
1283 if (inner_types
== NULL_TREE
)
1284 return TYPE_NAME (TREE_VALUE (tags
));
1285 return resolve_scope_to_name (TREE_VALUE (tags
), inner_types
);
1287 tags
= TREE_CHAIN (tags
);
1290 /* Look for a TYPE_DECL. */
1291 for (tags
= TYPE_FIELDS (type
); tags
; tags
= TREE_CHAIN (tags
))
1292 if (TREE_CODE (tags
) == TYPE_DECL
&& DECL_NAME (tags
) == inner_name
)
1294 /* Code by raeburn. */
1295 if (inner_types
== NULL_TREE
)
1297 return resolve_scope_to_name (TREE_TYPE (tags
), inner_types
);
1303 /* Resolve an expression NAME1::NAME2::...::NAMEn to
1304 the name that names the above nested type. INNER_TYPES
1305 is a chain of nested type names (held together by SCOPE_REFs);
1306 OUTER_TYPE is the type we know to enclose INNER_TYPES.
1307 Returns NULL_TREE if there is an error. */
1310 resolve_scope_to_name (outer_type
, inner_stuff
)
1311 tree outer_type
, inner_stuff
;
1314 tree inner_name
, inner_type
;
1316 if (outer_type
== NULL_TREE
&& current_class_type
!= NULL_TREE
)
1318 /* We first try to look for a nesting in our current class context,
1319 then try any enclosing classes. */
1320 tree type
= current_class_type
;
1322 while (type
&& (TREE_CODE (type
) == RECORD_TYPE
1323 || TREE_CODE (type
) == UNION_TYPE
))
1325 tree rval
= resolve_scope_to_name (type
, inner_stuff
);
1327 if (rval
!= NULL_TREE
)
1329 type
= DECL_CONTEXT (TYPE_NAME (type
));
1333 if (TREE_CODE (inner_stuff
) == SCOPE_REF
)
1335 inner_name
= TREE_OPERAND (inner_stuff
, 0);
1336 inner_type
= TREE_OPERAND (inner_stuff
, 1);
1340 inner_name
= inner_stuff
;
1341 inner_type
= NULL_TREE
;
1344 if (outer_type
== NULL_TREE
)
1347 /* If we have something that's already a type by itself,
1349 if (IDENTIFIER_HAS_TYPE_VALUE (inner_name
))
1352 return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name
),
1357 x
= lookup_name (inner_name
, 0);
1359 if (x
&& TREE_CODE (x
) == NAMESPACE_DECL
)
1361 x
= lookup_namespace_name (x
, inner_type
);
1367 if (! IS_AGGR_TYPE (outer_type
))
1370 /* Look for member classes or enums. */
1371 tmp
= find_scoped_type (outer_type
, inner_name
, inner_type
);
1373 /* If it's not a type in this class, then go down into the
1374 base classes and search there. */
1375 if (! tmp
&& TYPE_BINFO (outer_type
))
1377 tree binfos
= TYPE_BINFO_BASETYPES (outer_type
);
1378 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1380 for (i
= 0; i
< n_baselinks
; i
++)
1382 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1383 tmp
= resolve_scope_to_name (BINFO_TYPE (base_binfo
), inner_stuff
);
1393 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
1394 This is how virtual function calls are avoided. */
1397 build_scoped_method_call (exp
, basetype
, name
, parms
)
1398 tree exp
, basetype
, name
, parms
;
1400 /* Because this syntactic form does not allow
1401 a pointer to a base class to be `stolen',
1402 we need not protect the derived->base conversion
1405 @@ But we do have to check access privileges later. */
1407 tree type
= TREE_TYPE (exp
);
1409 if (type
== error_mark_node
1410 || basetype
== error_mark_node
)
1411 return error_mark_node
;
1413 if (processing_template_decl
)
1415 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1417 tree type
= get_aggr_from_typedef (TREE_OPERAND (name
, 0), 1);
1418 name
= build_min_nt (BIT_NOT_EXPR
, type
);
1420 name
= build_min_nt (SCOPE_REF
, basetype
, name
);
1421 return build_min_nt (METHOD_CALL_EXPR
, name
, exp
, parms
, NULL_TREE
);
1424 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1425 type
= TREE_TYPE (type
);
1427 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
1428 that explicit ~int is caught in the parser; this deals with typedefs
1429 and template parms. */
1430 if (TREE_CODE (name
) == BIT_NOT_EXPR
&& ! IS_AGGR_TYPE (basetype
))
1432 if (type
!= basetype
)
1433 cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
1434 exp
, basetype
, type
);
1435 name
= TREE_OPERAND (name
, 0);
1436 if (basetype
!= name
&& basetype
!= get_type_value (name
))
1437 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1439 return convert (void_type_node
, exp
);
1442 if (! is_aggr_type (basetype
, 1))
1443 return error_mark_node
;
1445 if (! IS_AGGR_TYPE (type
))
1447 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
1449 return error_mark_node
;
1452 if ((binfo
= binfo_or_else (basetype
, type
)))
1454 if (binfo
== error_mark_node
)
1455 return error_mark_node
;
1456 if (TREE_CODE (exp
) == INDIRECT_REF
)
1457 decl
= build_indirect_ref (convert_pointer_to (binfo
,
1458 build_unary_op (ADDR_EXPR
, exp
, 0)), NULL_PTR
);
1460 decl
= build_scoped_ref (exp
, basetype
);
1462 /* Call to a destructor. */
1463 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1465 /* Explicit call to destructor. */
1466 name
= TREE_OPERAND (name
, 0);
1467 if (! (name
== TYPE_MAIN_VARIANT (TREE_TYPE (decl
))
1468 || name
== constructor_name (TREE_TYPE (decl
))
1469 || TREE_TYPE (decl
) == get_type_value (name
)))
1472 ("qualified type `%T' does not match destructor name `~%T'",
1473 TREE_TYPE (decl
), name
);
1474 return error_mark_node
;
1476 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl
)))
1477 return convert (void_type_node
, exp
);
1479 return build_delete (TREE_TYPE (decl
), decl
, integer_two_node
,
1480 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
,
1484 /* Call to a method. */
1485 return build_method_call (decl
, name
, parms
, binfo
,
1486 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1488 return error_mark_node
;
1492 print_candidates (candidates
)
1495 cp_error_at ("candidates are: %D", TREE_VALUE (candidates
));
1496 candidates
= TREE_CHAIN (candidates
);
1500 cp_error_at (" %D", TREE_VALUE (candidates
));
1501 candidates
= TREE_CHAIN (candidates
);
1506 print_n_candidates (candidates
, n
)
1507 struct candidate
*candidates
;
1512 cp_error_at ("candidates are: %D", candidates
[0].function
);
1513 for (i
= 1; i
< n
; i
++)
1514 cp_error_at (" %D", candidates
[i
].function
);
1517 /* We want the address of a function or method. We avoid creating a
1518 pointer-to-member function. */
1521 build_addr_func (function
)
1524 tree type
= TREE_TYPE (function
);
1526 /* We have to do these by hand to avoid real pointer to member
1528 if (TREE_CODE (type
) == METHOD_TYPE
)
1532 type
= build_pointer_type (type
);
1534 if (mark_addressable (function
) == 0)
1535 return error_mark_node
;
1537 addr
= build1 (ADDR_EXPR
, type
, function
);
1539 /* Address of a static or external variable or function counts
1541 if (staticp (function
))
1542 TREE_CONSTANT (addr
) = 1;
1547 function
= default_conversion (function
);
1552 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
1553 POINTER_TYPE to those. Note, pointer to member function types
1554 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
1557 build_call (function
, result_type
, parms
)
1558 tree function
, result_type
, parms
;
1560 int is_constructor
= 0;
1562 function
= build_addr_func (function
);
1564 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
1566 sorry ("unable to call pointer to member function here");
1567 return error_mark_node
;
1570 if (TREE_CODE (function
) == ADDR_EXPR
1571 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
1572 && DECL_CONSTRUCTOR_P (TREE_OPERAND (function
, 0)))
1575 function
= build_nt (CALL_EXPR
, function
, parms
, NULL_TREE
);
1576 TREE_HAS_CONSTRUCTOR (function
) = is_constructor
;
1577 TREE_TYPE (function
) = result_type
;
1578 TREE_SIDE_EFFECTS (function
) = 1;
1584 default_parm_conversions (parms
, last
)
1587 tree parm
, parmtypes
= NULL_TREE
;
1591 for (parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1593 tree t
= TREE_TYPE (TREE_VALUE (parm
));
1595 if (TREE_CODE (t
) == OFFSET_TYPE
1596 || TREE_CODE (t
) == METHOD_TYPE
1597 || TREE_CODE (t
) == FUNCTION_TYPE
)
1599 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
1600 t
= TREE_TYPE (TREE_VALUE (parm
));
1603 if (t
== error_mark_node
)
1604 return error_mark_node
;
1606 *last
= build_tree_list (NULL_TREE
, t
);
1607 parmtypes
= chainon (parmtypes
, *last
);
1614 /* Build something of the form ptr->method (args)
1615 or object.method (args). This can also build
1616 calls to constructors, and find friends.
1618 Member functions always take their class variable
1621 INSTANCE is a class instance.
1623 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
1625 PARMS help to figure out what that NAME really refers to.
1627 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
1628 down to the real instance type to use for access checking. We need this
1629 information to get protected accesses correct. This parameter is used
1630 by build_member_call.
1632 FLAGS is the logical disjunction of zero or more LOOKUP_
1633 flags. See cp-tree.h for more info.
1635 If this is all OK, calls build_function_call with the resolved
1638 This function must also handle being called to perform
1639 initialization, promotion/coercion of arguments, and
1640 instantiation of default parameters.
1642 Note that NAME may refer to an instance variable name. If
1643 `operator()()' is defined for the type of that field, then we return
1647 build_method_call (instance
, name
, parms
, basetype_path
, flags
)
1648 tree instance
, name
, parms
, basetype_path
;
1651 register tree function
, fntype
, value_type
;
1652 register tree basetype
, save_basetype
;
1653 register tree baselink
, result
, parmtypes
, parm
;
1656 tree access
= access_public_node
;
1657 tree orig_basetype
= basetype_path
? BINFO_TYPE (basetype_path
) : NULL_TREE
;
1659 /* Range of cases for vtable optimization. */
1660 enum vtable_needs
{ not_needed
, maybe_needed
, unneeded
, needed
};
1661 enum vtable_needs need_vtbl
= not_needed
;
1664 tree save_name
= name
;
1666 tree instance_ptr
= NULL_TREE
;
1667 int all_virtual
= flag_all_virtual
;
1668 int static_call_context
= 0;
1669 tree found_fns
= NULL_TREE
;
1671 /* Keep track of `const' and `volatile' objects. */
1672 int constp
, volatilep
;
1674 #ifdef GATHER_STATISTICS
1675 n_build_method_call
++;
1678 if (instance
== error_mark_node
1679 || name
== error_mark_node
1680 || parms
== error_mark_node
1681 || (instance
!= NULL_TREE
&& TREE_TYPE (instance
) == error_mark_node
))
1682 return error_mark_node
;
1684 if (processing_template_decl
)
1686 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1688 tree type
= get_aggr_from_typedef (TREE_OPERAND (name
, 0), 1);
1689 name
= build_min_nt (BIT_NOT_EXPR
, type
);
1692 return build_min_nt (METHOD_CALL_EXPR
, name
, instance
, parms
, NULL_TREE
);
1695 /* This is the logic that magically deletes the second argument to
1696 operator delete, if it is not needed. */
1697 if (name
== ansi_opname
[(int) DELETE_EXPR
] && list_length (parms
)==2)
1699 tree save_last
= TREE_CHAIN (parms
);
1701 /* get rid of unneeded argument */
1702 TREE_CHAIN (parms
) = NULL_TREE
;
1703 result
= build_method_call (instance
, name
, parms
, basetype_path
,
1704 (LOOKUP_SPECULATIVELY
|flags
)
1706 /* If it finds a match, return it. */
1708 return build_method_call (instance
, name
, parms
, basetype_path
, flags
);
1709 /* If it doesn't work, two argument delete must work */
1710 TREE_CHAIN (parms
) = save_last
;
1712 /* We already know whether it's needed or not for vec delete. */
1713 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
1714 && TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1715 && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance
)))
1716 TREE_CHAIN (parms
) = NULL_TREE
;
1718 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1720 flags
|= LOOKUP_DESTRUCTOR
;
1721 name
= TREE_OPERAND (name
, 0);
1723 error ("destructors take no parameters");
1724 basetype
= TREE_TYPE (instance
);
1725 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1726 basetype
= TREE_TYPE (basetype
);
1727 if (! (name
== basetype
1728 || (IS_AGGR_TYPE (basetype
)
1729 && name
== constructor_name (basetype
))
1730 || basetype
== get_type_value (name
)))
1732 cp_error ("destructor name `~%D' does not match type `%T' of expression",
1734 return convert (void_type_node
, instance
);
1737 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1738 return convert (void_type_node
, instance
);
1739 instance
= default_conversion (instance
);
1740 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1741 return build_delete (build_pointer_type (basetype
),
1742 instance_ptr
, integer_two_node
,
1743 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0);
1746 if (flag_ansi_overloading
)
1747 return build_new_method_call (instance
, name
, parms
, basetype_path
, flags
);
1752 /* Initialize name for error reporting. */
1753 if (IDENTIFIER_OPNAME_P (name
) && ! IDENTIFIER_TYPENAME_P (name
))
1755 char *p
= operator_name_string (name
);
1756 xref_name
= (char *)alloca (strlen (p
) + 10);
1757 sprintf (xref_name
, "operator %s", p
);
1759 else if (TREE_CODE (name
) == SCOPE_REF
)
1760 xref_name
= IDENTIFIER_POINTER (TREE_OPERAND (name
, 1));
1762 xref_name
= IDENTIFIER_POINTER (name
);
1764 GNU_xref_call (current_function_decl
, xref_name
);
1767 if (instance
== NULL_TREE
)
1769 basetype
= NULL_TREE
;
1770 /* Check cases where this is really a call to raise
1772 if (current_class_type
&& TREE_CODE (name
) == IDENTIFIER_NODE
)
1774 basetype
= purpose_member (name
, CLASSTYPE_TAGS (current_class_type
));
1776 basetype
= TREE_VALUE (basetype
);
1778 else if (TREE_CODE (name
) == SCOPE_REF
1779 && TREE_CODE (TREE_OPERAND (name
, 0)) == IDENTIFIER_NODE
)
1781 if (! is_aggr_typedef (TREE_OPERAND (name
, 0), 1))
1782 return error_mark_node
;
1783 basetype
= purpose_member (TREE_OPERAND (name
, 1),
1784 CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name
, 0))));
1786 basetype
= TREE_VALUE (basetype
);
1789 if (basetype
!= NULL_TREE
)
1791 /* call to a constructor... */
1792 else if (basetype_path
)
1794 basetype
= BINFO_TYPE (basetype_path
);
1795 if (name
== TYPE_IDENTIFIER (basetype
))
1796 name
= ctor_identifier
;
1798 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1800 basetype
= IDENTIFIER_TYPE_VALUE (name
);
1801 name
= ctor_identifier
;
1805 tree typedef_name
= lookup_name (name
, 1);
1806 if (typedef_name
&& TREE_CODE (typedef_name
) == TYPE_DECL
)
1808 /* Canonicalize the typedef name. */
1809 basetype
= TREE_TYPE (typedef_name
);
1810 name
= ctor_identifier
;
1814 cp_error ("no constructor named `%T' in scope",
1816 return error_mark_node
;
1820 if (! IS_AGGR_TYPE (basetype
))
1823 if ((flags
& LOOKUP_COMPLAIN
) && TREE_CODE (basetype
) != ERROR_MARK
)
1824 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1825 name
, instance
, basetype
);
1827 return error_mark_node
;
1830 else if (instance
== current_class_ref
|| instance
== current_class_ptr
)
1832 /* When doing initialization, we side-effect the TREE_TYPE of
1833 current_class_ref, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */
1834 basetype
= TREE_TYPE (current_class_ref
);
1836 /* Anything manifestly `this' in constructors and destructors
1837 has a known type, so virtual function tables are not needed. */
1838 if (TYPE_VIRTUAL_P (basetype
)
1839 && !(flags
& LOOKUP_NONVIRTUAL
))
1840 need_vtbl
= (dtor_label
|| ctor_label
)
1841 ? unneeded
: maybe_needed
;
1843 /* If `this' is a signature pointer and `name' is not a constructor,
1844 we are calling a signature member function. In that case, set the
1845 `basetype' to the signature type and dereference the `optr' field. */
1846 if (IS_SIGNATURE_POINTER (basetype
)
1847 && TYPE_IDENTIFIER (basetype
) != name
)
1849 basetype
= SIGNATURE_TYPE (basetype
);
1850 instance_ptr
= instance
;
1851 basetype_path
= TYPE_BINFO (basetype
);
1855 instance
= current_class_ref
;
1856 instance_ptr
= current_class_ptr
;
1857 basetype_path
= TYPE_BINFO (current_class_type
);
1859 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1864 else if (TREE_CODE (instance
) == RESULT_DECL
)
1866 basetype
= TREE_TYPE (instance
);
1867 /* Should we ever have to make a virtual function reference
1868 from a RESULT_DECL, know that it must be of fixed type
1869 within the scope of this function. */
1870 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1871 need_vtbl
= maybe_needed
;
1872 instance_ptr
= build1 (ADDR_EXPR
, build_pointer_type (basetype
), instance
);
1876 /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */
1877 tree inst_ptr_basetype
;
1879 static_call_context
=
1880 (TREE_CODE (instance
) == INDIRECT_REF
1881 && TREE_CODE (TREE_OPERAND (instance
, 0)) == NOP_EXPR
1882 && TREE_OPERAND (TREE_OPERAND (instance
, 0), 0) == error_mark_node
);
1884 if (TREE_CODE (instance
) == OFFSET_REF
)
1885 instance
= resolve_offset_ref (instance
);
1887 /* the base type of an instance variable is pointer to class */
1888 basetype
= TREE_TYPE (instance
);
1890 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1892 basetype
= TREE_TYPE (basetype
);
1893 if (! IS_AGGR_TYPE (basetype
))
1894 goto non_aggr_error
;
1895 /* Call to convert not needed because we are remaining
1896 within the same type. */
1897 instance_ptr
= build1 (NOP_EXPR
, build_pointer_type (basetype
),
1899 inst_ptr_basetype
= TYPE_MAIN_VARIANT (basetype
);
1903 if (! IS_AGGR_TYPE (basetype
)
1904 && ! (TYPE_LANG_SPECIFIC (basetype
)
1905 && (IS_SIGNATURE_POINTER (basetype
)
1906 || IS_SIGNATURE_REFERENCE (basetype
))))
1907 goto non_aggr_error
;
1909 /* If `instance' is a signature pointer/reference and `name' is
1910 not a constructor, we are calling a signature member function.
1911 In that case set the `basetype' to the signature type. */
1912 if ((IS_SIGNATURE_POINTER (basetype
)
1913 || IS_SIGNATURE_REFERENCE (basetype
))
1914 && TYPE_IDENTIFIER (basetype
) != name
)
1915 basetype
= SIGNATURE_TYPE (basetype
);
1917 basetype
= complete_type (basetype
);
1919 if ((IS_SIGNATURE (basetype
)
1920 && (instance_ptr
= instance
))
1921 || (lvalue_p (instance
)
1922 && (instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0)))
1923 || (instance_ptr
= unary_complex_lvalue (ADDR_EXPR
, instance
)))
1925 if (instance_ptr
== error_mark_node
)
1926 return error_mark_node
;
1928 else if (TREE_CODE (instance
) == NOP_EXPR
1929 || TREE_CODE (instance
) == CONSTRUCTOR
)
1931 /* A cast is not an lvalue. Initialize a fresh temp
1932 with the value we are casting from, and proceed with
1933 that temporary. We can't cast to a reference type,
1934 so that simplifies the initialization to something
1936 tree temp
= get_temp_name (TREE_TYPE (instance
), 0);
1937 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
1938 expand_aggr_init (temp
, instance
, 0, flags
);
1941 store_init_value (temp
, instance
);
1942 expand_decl_init (temp
);
1945 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1949 if (TREE_CODE (instance
) != CALL_EXPR
)
1950 my_friendly_abort (125);
1951 if (TYPE_NEEDS_CONSTRUCTING (basetype
))
1952 instance
= build_cplus_new (basetype
, instance
);
1955 instance
= get_temp_name (basetype
, 0);
1956 TREE_ADDRESSABLE (instance
) = 1;
1958 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1960 /* @@ Should we call comp_target_types here? */
1961 if (IS_SIGNATURE (basetype
))
1962 inst_ptr_basetype
= basetype
;
1964 inst_ptr_basetype
= TREE_TYPE (TREE_TYPE (instance_ptr
));
1965 if (TYPE_MAIN_VARIANT (basetype
) == TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1966 basetype
= inst_ptr_basetype
;
1969 instance_ptr
= convert (build_pointer_type (basetype
), instance_ptr
);
1970 if (instance_ptr
== error_mark_node
)
1971 return error_mark_node
;
1975 /* After converting `instance_ptr' above, `inst_ptr_basetype' was
1976 not updated, so we use `basetype' instead. */
1977 if (basetype_path
== NULL_TREE
1978 && IS_SIGNATURE (basetype
))
1979 basetype_path
= TYPE_BINFO (basetype
);
1980 else if (basetype_path
== NULL_TREE
||
1981 BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1982 basetype_path
= TYPE_BINFO (inst_ptr_basetype
);
1984 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1988 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1990 if (TREE_SIDE_EFFECTS (instance_ptr
))
1992 /* This action is needed because the instance is needed
1993 for providing the base of the virtual function table.
1994 Without using a SAVE_EXPR, the function we are building
1995 may be called twice, or side effects on the instance
1996 variable (such as a post-increment), may happen twice. */
1997 instance_ptr
= save_expr (instance_ptr
);
1998 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2000 else if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
2002 /* This happens when called for operator new (). */
2003 instance
= build_indirect_ref (instance
, NULL_PTR
);
2006 need_vtbl
= maybe_needed
;
2010 if (save_name
== ctor_identifier
)
2011 save_name
= TYPE_IDENTIFIER (basetype
);
2013 if (TYPE_SIZE (complete_type (basetype
)) == 0)
2015 /* This is worth complaining about, I think. */
2016 cp_error ("cannot lookup method in incomplete type `%T'", basetype
);
2017 return error_mark_node
;
2020 save_basetype
= TYPE_MAIN_VARIANT (basetype
);
2022 parmtypes
= default_parm_conversions (parms
, &last
);
2023 if (parmtypes
== error_mark_node
)
2025 return error_mark_node
;
2028 if (instance
&& IS_SIGNATURE (basetype
))
2030 /* @@ Should this be the constp/volatilep flags for the optr field
2031 of the signature pointer? */
2032 constp
= TYPE_READONLY (basetype
);
2033 volatilep
= TYPE_VOLATILE (basetype
);
2034 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2038 /* TREE_READONLY (instance) fails for references. */
2039 constp
= TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2040 volatilep
= TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2041 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2045 /* Raw constructors are always in charge. */
2046 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2047 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2049 flags
|= LOOKUP_HAS_IN_CHARGE
;
2050 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
2051 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
2056 instance_ptr
= build_int_2 (0, 0);
2057 TREE_TYPE (instance_ptr
) = build_pointer_type (basetype
);
2058 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2061 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (instance_ptr
), parmtypes
);
2063 if (last
== NULL_TREE
)
2066 /* Look up function name in the structure type definition. */
2068 /* FIXME Axe most of this now? */
2069 if ((IDENTIFIER_HAS_TYPE_VALUE (name
)
2070 && ! IDENTIFIER_OPNAME_P (name
)
2071 && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name
)))
2072 || name
== constructor_name (basetype
)
2073 || name
== ctor_identifier
)
2075 tree tmp
= NULL_TREE
;
2076 if (IDENTIFIER_TYPE_VALUE (name
) == basetype
2077 || name
== constructor_name (basetype
)
2078 || name
== ctor_identifier
)
2079 tmp
= TYPE_BINFO (basetype
);
2081 tmp
= get_binfo (IDENTIFIER_TYPE_VALUE (name
), basetype
, 0);
2083 if (tmp
!= NULL_TREE
)
2085 name_kind
= "constructor";
2087 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2088 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2090 /* Constructors called for initialization
2091 only are never in charge. */
2094 flags
|= LOOKUP_HAS_IN_CHARGE
;
2095 tmplist
= tree_cons (NULL_TREE
, integer_zero_node
,
2096 TREE_CHAIN (parms
));
2097 TREE_CHAIN (parms
) = tmplist
;
2098 tmplist
= tree_cons (NULL_TREE
, integer_type_node
, TREE_CHAIN (parmtypes
));
2099 TREE_CHAIN (parmtypes
) = tmplist
;
2101 basetype
= BINFO_TYPE (tmp
);
2104 name_kind
= "method";
2107 name_kind
= "method";
2109 if (basetype_path
== NULL_TREE
2110 || BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (basetype
))
2111 basetype_path
= TYPE_BINFO (basetype
);
2112 result
= lookup_fnfields (basetype_path
, name
,
2113 (flags
& LOOKUP_COMPLAIN
));
2114 if (result
== error_mark_node
)
2115 return error_mark_node
;
2117 for (pass
= 0; pass
< 2; pass
++)
2119 struct candidate
*candidates
;
2120 struct candidate
*cp
;
2129 = (struct candidate
*) alloca ((ever_seen
+1)
2130 * sizeof (struct candidate
));
2131 bzero ((char *) candidates
, (ever_seen
+ 1) * sizeof (struct candidate
));
2133 len
= list_length (parms
);
2136 /* First see if a global function has a shot at it. */
2137 if (flags
& LOOKUP_GLOBAL
)
2140 tree parm
= instance_ptr
;
2142 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
)
2143 parm
= convert_from_reference (parm
);
2144 else if (TREE_CODE (TREE_TYPE (parm
)) == POINTER_TYPE
)
2145 parm
= build_indirect_ref (parm
, "friendifying parms (compiler error)");
2147 my_friendly_abort (167);
2149 friend_parms
= tree_cons (NULL_TREE
, parm
, TREE_CHAIN (parms
));
2152 cp
->harshness
= (struct harshness_code
*)
2153 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2155 result
= build_overload_call_real (name
, friend_parms
, 0, cp
, 1);
2157 /* If it turns out to be the one we were actually looking for
2158 (it was probably a friend function), the return the
2160 if (TREE_CODE (result
) == CALL_EXPR
)
2163 while ((cp
->h
.code
& EVIL_CODE
) == 0)
2165 /* non-standard uses: set the field to 0 to indicate
2166 we are using a non-member function. */
2168 if (cp
->harshness
[len
].distance
== 0
2169 && cp
->h
.code
< best
)
2178 /* We have a hit (of sorts). If the parameter list is
2179 "error_mark_node", or some variant thereof, it won't
2180 match any methods. Since we have verified that the is
2181 some method vaguely matching this one (in name at least),
2184 Don't stop for friends, however. */
2185 basetype_path
= TREE_PURPOSE (baselink
);
2187 function
= TREE_VALUE (baselink
);
2188 if (TREE_CODE (basetype_path
) == TREE_LIST
)
2189 basetype_path
= TREE_VALUE (basetype_path
);
2190 basetype
= BINFO_TYPE (basetype_path
);
2192 for (; function
; function
= DECL_CHAIN (function
))
2194 #ifdef GATHER_STATISTICS
2195 n_inner_fields_searched
++;
2199 found_fns
= tree_cons (NULL_TREE
, function
, found_fns
);
2201 /* Not looking for friends here. */
2202 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
2203 && ! DECL_STATIC_FUNCTION_P (function
))
2208 tree these_parms
= parms
;
2210 #ifdef GATHER_STATISTICS
2211 n_inner_fields_searched
++;
2214 cp
->harshness
= (struct harshness_code
*)
2215 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2217 if (DECL_STATIC_FUNCTION_P (function
))
2218 these_parms
= TREE_CHAIN (these_parms
);
2219 compute_conversion_costs (function
, these_parms
, cp
, len
);
2221 if ((cp
->h
.code
& EVIL_CODE
) == 0)
2223 cp
->u
.field
= function
;
2224 cp
->function
= function
;
2225 cp
->basetypes
= basetype_path
;
2227 /* Don't allow non-converting constructors to convert. */
2228 if (flags
& LOOKUP_ONLYCONVERTING
2229 && DECL_LANG_SPECIFIC (function
)
2230 && DECL_NONCONVERTING_P (function
))
2233 /* No "two-level" conversions. */
2234 if (flags
& LOOKUP_NO_CONVERSION
2235 && (cp
->h
.code
& USER_CODE
))
2246 tree igv
= lookup_name_nonclass (name
);
2248 /* No exact match could be found. Now try to find match
2249 using default conversions. */
2250 if ((flags
& LOOKUP_GLOBAL
) && igv
)
2252 if (TREE_CODE (igv
) == FUNCTION_DECL
)
2254 else if (TREE_CODE (igv
) == TREE_LIST
)
2255 ever_seen
+= count_functions (igv
);
2260 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2261 == LOOKUP_SPECULATIVELY
)
2264 TREE_CHAIN (last
) = void_list_node
;
2265 if (flags
& LOOKUP_GLOBAL
)
2266 cp_error ("no global or member function `%D(%A)' defined",
2267 save_name
, parmtypes
);
2269 cp_error ("no member function `%T::%D(%A)' defined",
2270 save_basetype
, save_name
, TREE_CHAIN (parmtypes
));
2271 return error_mark_node
;
2276 if (cp
- candidates
!= 0)
2278 /* Rank from worst to best. Then cp will point to best one.
2279 Private fields have their bits flipped. For unsigned
2280 numbers, this should make them look very large.
2281 If the best alternate has a (signed) negative value,
2282 then all we ever saw were private members. */
2283 if (cp
- candidates
> 1)
2285 int n_candidates
= cp
- candidates
;
2286 extern int warn_synth
;
2287 TREE_VALUE (parms
) = instance_ptr
;
2288 cp
= ideal_candidate (candidates
, n_candidates
, len
);
2289 if (cp
== (struct candidate
*)0)
2291 if (flags
& LOOKUP_COMPLAIN
)
2293 TREE_CHAIN (last
) = void_list_node
;
2294 cp_error ("call of overloaded %s `%D(%A)' is ambiguous",
2295 name_kind
, save_name
, TREE_CHAIN (parmtypes
));
2296 print_n_candidates (candidates
, n_candidates
);
2298 return error_mark_node
;
2300 if (cp
->h
.code
& EVIL_CODE
)
2301 return error_mark_node
;
2303 && DECL_NAME (cp
->function
) == ansi_opname
[MODIFY_EXPR
]
2304 && DECL_ARTIFICIAL (cp
->function
)
2305 && n_candidates
== 2)
2307 cp_warning ("using synthesized `%#D' for copy assignment",
2309 cp_warning_at (" where cfront would use `%#D'",
2310 candidates
->function
);
2313 else if (cp
[-1].h
.code
& EVIL_CODE
)
2315 if (flags
& LOOKUP_COMPLAIN
)
2316 cp_error ("ambiguous type conversion requested for %s `%D'",
2317 name_kind
, save_name
);
2318 return error_mark_node
;
2323 /* The global function was the best, so use it. */
2324 if (cp
->u
.field
== 0)
2326 /* We must convert the instance pointer into a reference type.
2327 Global overloaded functions can only either take
2328 aggregate objects (which come for free from references)
2329 or reference data types anyway. */
2330 TREE_VALUE (parms
) = copy_node (instance_ptr
);
2331 TREE_TYPE (TREE_VALUE (parms
)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2332 return build_function_call (cp
->function
, parms
);
2335 function
= cp
->function
;
2336 basetype_path
= cp
->basetypes
;
2337 if (! DECL_STATIC_FUNCTION_P (function
))
2338 TREE_VALUE (parms
) = cp
->arg
;
2339 goto found_and_maybe_warn
;
2342 if (flags
& (LOOKUP_COMPLAIN
|LOOKUP_SPECULATIVELY
))
2344 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2345 == LOOKUP_SPECULATIVELY
)
2348 if (DECL_STATIC_FUNCTION_P (cp
->function
))
2349 parms
= TREE_CHAIN (parms
);
2352 if (flags
& LOOKUP_SPECULATIVELY
)
2354 if (static_call_context
2355 && TREE_CODE (TREE_TYPE (cp
->function
)) == METHOD_TYPE
)
2356 cp_error ("object missing in call to `%D'", cp
->function
);
2357 else if (ever_seen
> 1)
2359 TREE_CHAIN (last
) = void_list_node
;
2360 cp_error ("no matching function for call to `%T::%D (%A)%V'",
2361 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (instance_ptr
))),
2362 save_name
, TREE_CHAIN (parmtypes
),
2363 TREE_TYPE (TREE_TYPE (instance_ptr
)));
2364 TREE_CHAIN (last
) = NULL_TREE
;
2365 print_candidates (found_fns
);
2368 report_type_mismatch (cp
, parms
, name_kind
);
2369 return error_mark_node
;
2372 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2375 cp_error ("%T has no method named %D", save_basetype
, save_name
);
2376 return error_mark_node
;
2382 found_and_maybe_warn
:
2383 if ((cp
->harshness
[0].code
& CONST_CODE
)
2384 /* 12.1p2: Constructors can be called for const objects. */
2385 && ! DECL_CONSTRUCTOR_P (cp
->function
))
2387 if (flags
& LOOKUP_COMPLAIN
)
2389 cp_error_at ("non-const member function `%D'", cp
->function
);
2390 error ("called for const object at this point in file");
2392 /* Not good enough for a match. */
2394 return error_mark_node
;
2398 /* Silently return error_mark_node. */
2399 return error_mark_node
;
2402 if (flags
& LOOKUP_PROTECT
)
2403 access
= compute_access (basetype_path
, function
);
2405 if (access
== access_private_node
)
2407 if (flags
& LOOKUP_COMPLAIN
)
2409 cp_error_at ("%s `%+#D' is %s", name_kind
, function
,
2410 TREE_PRIVATE (function
) ? "private"
2411 : "from private base class");
2412 error ("within this context");
2414 return error_mark_node
;
2416 else if (access
== access_protected_node
)
2418 if (flags
& LOOKUP_COMPLAIN
)
2420 cp_error_at ("%s `%+#D' %s", name_kind
, function
,
2421 TREE_PROTECTED (function
) ? "is protected"
2422 : "has protected accessibility");
2423 error ("within this context");
2425 return error_mark_node
;
2428 /* From here on down, BASETYPE is the type that INSTANCE_PTR's
2429 type (if it exists) is a pointer to. */
2431 if (DECL_ABSTRACT_VIRTUAL_P (function
)
2432 && instance
== current_class_ref
2433 && DECL_CONSTRUCTOR_P (current_function_decl
)
2434 && ! (flags
& LOOKUP_NONVIRTUAL
)
2435 && value_member (function
, get_abstract_virtuals (basetype
)))
2436 cp_error ("abstract virtual `%#D' called from constructor", function
);
2438 if (IS_SIGNATURE (basetype
))
2440 if (static_call_context
)
2442 cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
2443 basetype
, save_name
);
2444 return error_mark_node
;
2446 return build_signature_method_call (function
, parms
);
2449 function
= DECL_MAIN_VARIANT (function
);
2450 mark_used (function
);
2452 fntype
= TREE_TYPE (function
);
2453 if (TREE_CODE (fntype
) == POINTER_TYPE
)
2454 fntype
= TREE_TYPE (fntype
);
2455 basetype
= DECL_CLASS_CONTEXT (function
);
2457 /* If we are referencing a virtual function from an object
2458 of effectively static type, then there is no need
2459 to go through the virtual function table. */
2460 if (need_vtbl
== maybe_needed
)
2462 int fixed_type
= resolves_to_fixed_type_p (instance
, 0);
2464 if (all_virtual
== 1
2465 && DECL_VINDEX (function
)
2466 && may_be_remote (basetype
))
2468 else if (DECL_VINDEX (function
))
2469 need_vtbl
= fixed_type
? unneeded
: needed
;
2471 need_vtbl
= not_needed
;
2474 if (TREE_CODE (fntype
) == METHOD_TYPE
&& static_call_context
2475 && !DECL_CONSTRUCTOR_P (function
))
2477 /* Let's be nasty to the user now, and give reasonable
2479 instance_ptr
= current_class_ptr
;
2482 if (basetype
!= current_class_type
)
2484 if (basetype
== error_mark_node
)
2485 return error_mark_node
;
2488 if (orig_basetype
!= NULL_TREE
)
2489 error_not_base_type (orig_basetype
, current_class_type
);
2491 error_not_base_type (function
, current_class_type
);
2492 return error_mark_node
;
2496 /* Only allow a static member function to call another static member
2498 else if (DECL_LANG_SPECIFIC (function
)
2499 && !DECL_STATIC_FUNCTION_P (function
))
2501 cp_error ("cannot call member function `%D' without object",
2503 return error_mark_node
;
2507 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2509 if (TYPE_SIZE (complete_type (value_type
)) == 0)
2511 if (flags
& LOOKUP_COMPLAIN
)
2512 incomplete_type_error (0, value_type
);
2513 return error_mark_node
;
2516 if (DECL_STATIC_FUNCTION_P (function
))
2517 parms
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2518 TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
);
2519 else if (need_vtbl
== unneeded
)
2521 int sub_flags
= DECL_CONSTRUCTOR_P (function
) ? flags
: LOOKUP_NORMAL
;
2522 basetype
= TREE_TYPE (instance
);
2523 if (TYPE_METHOD_BASETYPE (TREE_TYPE (function
))
2524 != TYPE_MAIN_VARIANT (basetype
))
2526 basetype
= DECL_CLASS_CONTEXT (function
);
2527 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
2528 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2530 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2531 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, sub_flags
));
2535 if ((flags
& LOOKUP_NONVIRTUAL
) == 0)
2536 basetype
= DECL_CONTEXT (function
);
2538 /* First parm could be integer_zerop with casts like
2539 ((Object*)0)->Object::IsA() */
2540 if (!integer_zerop (TREE_VALUE (parms
)))
2542 /* Since we can't have inheritance with a union, doing get_binfo
2543 on it won't work. We do all the convert_pointer_to_real
2544 stuff to handle MI correctly...for unions, that's not
2545 an issue, so we must short-circuit that extra work here. */
2546 tree tmp
= TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)));
2547 if (tmp
!= NULL_TREE
&& TREE_CODE (tmp
) == UNION_TYPE
)
2548 instance_ptr
= TREE_VALUE (parms
);
2551 tree binfo
= get_binfo (basetype
,
2552 TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
))),
2554 instance_ptr
= convert_pointer_to_real (binfo
, TREE_VALUE (parms
));
2557 = convert_pointer_to (build_type_variant (basetype
,
2561 if (TREE_CODE (instance_ptr
) == COND_EXPR
)
2563 instance_ptr
= save_expr (instance_ptr
);
2564 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2566 else if (TREE_CODE (instance_ptr
) == NOP_EXPR
2567 && TREE_CODE (TREE_OPERAND (instance_ptr
, 0)) == ADDR_EXPR
2568 && TREE_OPERAND (TREE_OPERAND (instance_ptr
, 0), 0) == instance
)
2570 /* The call to `convert_pointer_to' may return error_mark_node. */
2571 else if (TREE_CODE (instance_ptr
) == ERROR_MARK
)
2572 return instance_ptr
;
2573 else if (instance
== NULL_TREE
2574 || TREE_CODE (instance
) != INDIRECT_REF
2575 || TREE_OPERAND (instance
, 0) != instance_ptr
)
2576 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2578 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2579 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
));
2582 if (parms
== error_mark_node
2583 || (parms
&& TREE_CHAIN (parms
) == error_mark_node
))
2584 return error_mark_node
;
2586 if (need_vtbl
== needed
)
2588 function
= build_vfn_ref (&TREE_VALUE (parms
), instance
,
2589 DECL_VINDEX (function
));
2590 TREE_TYPE (function
) = build_pointer_type (fntype
);
2593 if (TREE_CODE (function
) == FUNCTION_DECL
)
2594 GNU_xref_call (current_function_decl
,
2595 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)));
2597 result
= build_call (function
, value_type
, parms
);
2598 if (IS_AGGR_TYPE (value_type
))
2599 result
= build_cplus_new (value_type
, result
);
2600 result
= convert_from_reference (result
);
2604 /* Similar to `build_method_call', but for overloaded non-member functions.
2605 The name of this function comes through NAME. The name depends
2608 Note that this function must handle simple `C' promotions,
2609 as well as variable numbers of arguments (...), and
2610 default arguments to boot.
2612 If the overloading is successful, we return a tree node which
2613 contains the call to the function.
2615 If overloading produces candidates which are probable, but not definite,
2616 we hold these candidates. If FINAL_CP is non-zero, then we are free
2617 to assume that final_cp points to enough storage for all candidates that
2618 this function might generate. The `harshness' array is preallocated for
2619 the first candidate, but not for subsequent ones.
2621 Note that the DECL_RTL of FUNCTION must be made to agree with this
2622 function's new name. */
2625 build_overload_call_real (fnname
, parms
, flags
, final_cp
, require_complete
)
2628 struct candidate
*final_cp
;
2629 int require_complete
;
2631 /* must check for overloading here */
2632 tree functions
, function
, parm
;
2633 tree parmtypes
, last
;
2634 register tree outer
;
2636 int parmlength
= list_length (parms
);
2638 struct candidate
*candidates
, *cp
;
2642 final_cp
[0].h
.code
= 0;
2643 final_cp
[0].h
.distance
= 0;
2644 final_cp
[0].function
= 0;
2646 final_cp
[1].h
.code
= EVIL_CODE
;
2649 parmtypes
= default_parm_conversions (parms
, &last
);
2650 if (parmtypes
== error_mark_node
)
2653 final_cp
->h
.code
= EVIL_CODE
;
2654 return error_mark_node
;
2658 TREE_CHAIN (last
) = void_list_node
;
2660 parmtypes
= void_list_node
;
2662 if (is_overloaded_fn (fnname
))
2665 if (TREE_CODE (fnname
) == TREE_LIST
)
2666 fnname
= TREE_PURPOSE (functions
);
2667 else if (TREE_CODE (fnname
) == FUNCTION_DECL
)
2668 fnname
= DECL_NAME (functions
);
2671 functions
= lookup_name_nonclass (fnname
);
2673 if (functions
== NULL_TREE
)
2675 if (flags
& LOOKUP_SPECULATIVELY
)
2677 if (flags
& LOOKUP_COMPLAIN
)
2678 error ("only member functions apply");
2680 final_cp
->h
.code
= EVIL_CODE
;
2681 return error_mark_node
;
2684 if (TREE_CODE (functions
) == FUNCTION_DECL
&& ! IDENTIFIER_OPNAME_P (fnname
))
2686 functions
= DECL_MAIN_VARIANT (functions
);
2689 /* We are just curious whether this is a viable alternative or
2691 compute_conversion_costs (functions
, parms
, final_cp
, parmlength
);
2695 return build_function_call_real (functions
, parms
, 1, flags
);
2698 if (TREE_CODE (functions
) == TREE_LIST
2699 && TREE_VALUE (functions
) == NULL_TREE
)
2701 if (flags
& LOOKUP_SPECULATIVELY
)
2704 if (flags
& LOOKUP_COMPLAIN
)
2705 cp_error ("function `%D' declared overloaded, but no instances of that function declared",
2706 TREE_PURPOSE (functions
));
2708 final_cp
->h
.code
= EVIL_CODE
;
2709 return error_mark_node
;
2712 length
= count_functions (functions
);
2715 candidates
= final_cp
;
2719 = (struct candidate
*)alloca ((length
+1) * sizeof (struct candidate
));
2720 bzero ((char *) candidates
, (length
+ 1) * sizeof (struct candidate
));
2725 my_friendly_assert (is_overloaded_fn (functions
), 169);
2727 functions
= get_first_fn (functions
);
2729 /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
2730 for (outer
= functions
; outer
; outer
= DECL_CHAIN (outer
))
2732 int template_cost
= 0;
2734 if (TREE_CODE (function
) != FUNCTION_DECL
2735 && ! (TREE_CODE (function
) == TEMPLATE_DECL
2736 && TREE_CODE (DECL_TEMPLATE_RESULT (function
)) == FUNCTION_DECL
))
2738 enum tree_code code
= TREE_CODE (function
);
2739 if (code
== TEMPLATE_DECL
)
2740 code
= TREE_CODE (DECL_TEMPLATE_RESULT (function
));
2741 if (code
== CONST_DECL
)
2743 ("enumeral value `%D' conflicts with function of same name",
2745 else if (code
== VAR_DECL
)
2747 if (TREE_STATIC (function
))
2749 ("variable `%D' conflicts with function of same name",
2753 ("constant field `%D' conflicts with function of same name",
2756 else if (code
== TYPE_DECL
)
2759 my_friendly_abort (2);
2760 error ("at this point in file");
2763 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2765 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function
));
2766 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
2769 i
= type_unification (DECL_TEMPLATE_PARMS (function
), targs
,
2770 TYPE_ARG_TYPES (TREE_TYPE (function
)),
2771 parms
, &template_cost
, 0, 0);
2774 function
= instantiate_template (function
, targs
);
2775 if (function
== error_mark_node
)
2780 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2782 /* Unconverted template -- failed match. */
2783 cp
->function
= function
;
2785 cp
->h
.code
= EVIL_CODE
;
2789 struct candidate
*cp2
;
2791 /* Check that this decl is not the same as a function that's in
2792 the list due to some template instantiation. */
2795 if (cp2
->function
== function
)
2799 if (cp2
->function
== function
)
2802 function
= DECL_MAIN_VARIANT (function
);
2804 /* Can't use alloca here, since result might be
2805 passed to calling function. */
2806 cp
->h_len
= parmlength
;
2807 cp
->harshness
= (struct harshness_code
*)
2808 oballoc ((parmlength
+ 1) * sizeof (struct harshness_code
));
2810 compute_conversion_costs (function
, parms
, cp
, parmlength
);
2812 /* Make sure this is clear as well. */
2813 cp
->h
.int_penalty
+= template_cost
;
2815 if ((cp
[0].h
.code
& EVIL_CODE
) == 0)
2817 cp
[1].h
.code
= EVIL_CODE
;
2823 if (cp
- candidates
)
2825 tree rval
= error_mark_node
;
2828 cp
[0].h
.code
= EVIL_CODE
;
2829 if (cp
- candidates
> 1)
2831 struct candidate
*best_cp
2832 = ideal_candidate (candidates
, cp
- candidates
, parmlength
);
2833 if (best_cp
== (struct candidate
*)0)
2835 if (flags
& LOOKUP_COMPLAIN
)
2837 cp_error ("call of overloaded `%D' is ambiguous", fnname
);
2838 print_n_candidates (candidates
, cp
- candidates
);
2840 return error_mark_node
;
2843 rval
= best_cp
->function
;
2848 if (cp
->h
.code
& EVIL_CODE
)
2850 if (flags
& LOOKUP_COMPLAIN
)
2851 error ("type conversion ambiguous");
2854 rval
= cp
->function
;
2860 return build_function_call_real (rval
, parms
, require_complete
, flags
);
2863 if (flags
& LOOKUP_SPECULATIVELY
)
2866 if (flags
& LOOKUP_COMPLAIN
)
2867 report_type_mismatch (cp
, parms
, "function",
2868 decl_as_string (cp
->function
, 1));
2870 return error_mark_node
;
2873 /* This requires a complete type on the result of the call. */
2876 build_overload_call (fnname
, parms
, flags
)
2880 return build_overload_call_real (fnname
, parms
, flags
, (struct candidate
*)0, 1);
2883 /* New overloading code. */
2885 struct z_candidate
{
2892 struct z_candidate
*next
;
2895 #define IDENTITY_RANK 0
2896 #define EXACT_RANK 1
2897 #define PROMO_RANK 2
2899 #define PBOOL_RANK 4
2901 #define ELLIPSIS_RANK 6
2904 #define ICS_RANK(NODE) \
2905 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
2906 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
2907 : ICS_USER_FLAG (NODE) ? USER_RANK \
2908 : ICS_STD_RANK (NODE))
2910 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
2912 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
2913 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
2914 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
2915 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
2917 #define USER_CONV_FN(NODE) TREE_OPERAND (NODE, 1)
2919 static struct z_candidate
* build_user_type_conversion_1 ();
2920 static tree
convert_like ();
2921 static tree
build_over_call ();
2922 static struct z_candidate
* tourney ();
2923 static void enforce_access ();
2930 || integer_zerop (t
) && INTEGRAL_TYPE_P (TREE_TYPE (t
)))
2932 /* Remove this eventually. */
2933 if (! pedantic
&& TREE_TYPE (t
) == ptr_type_node
&& integer_zerop (t
))
2939 build_conv (code
, type
, from
)
2940 enum tree_code code
;
2943 tree t
= build1 (code
, type
, from
);
2944 int rank
= ICS_STD_RANK (from
);
2951 if (rank
< STD_RANK
)
2958 if (rank
< EXACT_RANK
)
2964 ICS_STD_RANK (t
) = rank
;
2965 ICS_USER_FLAG (t
) = ICS_USER_FLAG (from
);
2966 ICS_BAD_FLAG (t
) = ICS_BAD_FLAG (from
);
2974 if (TREE_CODE (t
) == REFERENCE_TYPE
)
2979 /* Returns the standard conversion path (see [conv]) from type FROM to type
2980 TO, if any. For proper handling of null pointer constants, you must
2981 also pass the expression EXPR to convert from. */
2984 standard_conversion (to
, from
, expr
)
2985 tree to
, from
, expr
;
2987 enum tree_code fcode
, tcode
;
2990 fcode
= TREE_CODE (from
);
2991 tcode
= TREE_CODE (to
);
2993 conv
= build1 (IDENTITY_CONV
, from
, expr
);
2998 if (fcode
== FUNCTION_TYPE
)
3000 from
= build_pointer_type (from
);
3001 fcode
= TREE_CODE (from
);
3002 conv
= build_conv (LVALUE_CONV
, from
, conv
);
3004 else if (fcode
== ARRAY_TYPE
)
3006 from
= build_pointer_type (TREE_TYPE (from
));
3007 fcode
= TREE_CODE (from
);
3008 conv
= build_conv (LVALUE_CONV
, from
, conv
);
3011 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (to
))
3012 && expr
&& null_ptr_cst_p (expr
))
3014 conv
= build_conv (STD_CONV
, to
, conv
);
3016 else if (tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
3018 enum tree_code ufcode
= TREE_CODE (TREE_TYPE (from
));
3019 enum tree_code utcode
= TREE_CODE (TREE_TYPE (to
));
3020 tree nconv
= NULL_TREE
;
3022 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (from
)),
3023 TYPE_MAIN_VARIANT (TREE_TYPE (to
)), 1))
3025 else if (utcode
== VOID_TYPE
&& ufcode
!= OFFSET_TYPE
3026 && ufcode
!= FUNCTION_TYPE
)
3028 from
= build_pointer_type
3029 (cp_build_type_variant (void_type_node
,
3030 TYPE_READONLY (TREE_TYPE (from
)),
3031 TYPE_VOLATILE (TREE_TYPE (from
))));
3032 nconv
= build_conv (PTR_CONV
, from
, conv
);
3034 else if (ufcode
== OFFSET_TYPE
&& utcode
== OFFSET_TYPE
)
3036 tree fbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (from
));
3037 tree tbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (to
));
3039 if (DERIVED_FROM_P (fbase
, tbase
)
3040 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (from
))),
3041 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (to
))),
3044 from
= build_offset_type (tbase
, TREE_TYPE (TREE_TYPE (from
)));
3045 from
= build_pointer_type (from
);
3046 nconv
= build_conv (PMEM_CONV
, from
, conv
);
3049 else if (IS_AGGR_TYPE (TREE_TYPE (from
))
3050 && IS_AGGR_TYPE (TREE_TYPE (to
)))
3052 if (DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
3054 from
= cp_build_type_variant (TREE_TYPE (to
),
3055 TYPE_READONLY (TREE_TYPE (from
)),
3056 TYPE_VOLATILE (TREE_TYPE (from
)));
3057 from
= build_pointer_type (from
);
3058 nconv
= build_conv (PTR_CONV
, from
, conv
);
3062 if (nconv
&& comptypes (from
, to
, 1))
3064 else if (nconv
&& comp_ptr_ttypes (TREE_TYPE (to
), TREE_TYPE (from
)))
3065 conv
= build_conv (QUAL_CONV
, to
, nconv
);
3066 else if (ptr_reasonably_similar (TREE_TYPE (to
), TREE_TYPE (from
)))
3068 conv
= build_conv (PTR_CONV
, to
, conv
);
3069 ICS_BAD_FLAG (conv
) = 1;
3076 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
3078 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
3079 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
3080 tree fbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn
)));
3081 tree tbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn
)));
3083 if (! DERIVED_FROM_P (fbase
, tbase
)
3084 || ! comptypes (TREE_TYPE (fromfn
), TREE_TYPE (tofn
), 1)
3085 || ! compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)),
3086 TREE_CHAIN (TYPE_ARG_TYPES (tofn
)), 1)
3087 || TYPE_READONLY (fbase
) != TYPE_READONLY (tbase
)
3088 || TYPE_VOLATILE (fbase
) != TYPE_VOLATILE (tbase
))
3091 from
= cp_build_type_variant (tbase
, TYPE_READONLY (fbase
),
3092 TYPE_VOLATILE (fbase
));
3093 from
= build_cplus_method_type (from
, TREE_TYPE (fromfn
),
3094 TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)));
3095 from
= build_ptrmemfunc_type (build_pointer_type (from
));
3096 conv
= build_conv (PMEM_CONV
, from
, conv
);
3098 else if (tcode
== BOOLEAN_TYPE
)
3100 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
3101 || fcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (from
)))
3104 conv
= build_conv (STD_CONV
, to
, conv
);
3105 if (fcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (from
)
3106 && ICS_STD_RANK (conv
) < PBOOL_RANK
)
3107 ICS_STD_RANK (conv
) = PBOOL_RANK
;
3109 /* We don't check for ENUMERAL_TYPE here because there are no standard
3110 conversions to enum type. */
3111 else if (tcode
== INTEGER_TYPE
|| tcode
== BOOLEAN_TYPE
3112 || tcode
== REAL_TYPE
)
3114 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
))
3116 conv
= build_conv (STD_CONV
, to
, conv
);
3118 /* Give this a better rank if it's a promotion. */
3119 if (to
== type_promotes_to (from
)
3120 && ICS_STD_RANK (TREE_OPERAND (conv
, 0)) <= PROMO_RANK
)
3121 ICS_STD_RANK (conv
) = PROMO_RANK
;
3123 else if (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
3124 && DERIVED_FROM_P (to
, from
))
3125 conv
= build_conv (BASE_CONV
, to
, conv
);
3136 if (TREE_CODE (t
) == ARRAY_TYPE
)
3138 return TYPE_MAIN_VARIANT (t
);
3141 /* Returns the conversion path from type FROM to reference type TO for
3142 purposes of reference binding. For lvalue binding, either pass a
3143 reference type to FROM or an lvalue expression to EXPR.
3145 Currently does not distinguish in the generated trees between binding to
3146 an lvalue and a temporary. Should it? */
3149 reference_binding (rto
, from
, expr
, flags
)
3150 tree rto
, from
, expr
;
3155 tree to
= TREE_TYPE (rto
);
3157 if (TREE_CODE (from
) == REFERENCE_TYPE
)
3158 from
= TREE_TYPE (from
);
3159 else if (! expr
|| ! real_lvalue_p (expr
))
3163 && TYPE_READONLY (to
) >= TYPE_READONLY (from
)
3164 && TYPE_VOLATILE (to
) >= TYPE_VOLATILE (from
))
3166 conv
= build1 (IDENTITY_CONV
, from
, expr
);
3168 if (TYPE_MAIN_VARIANT (to
) == TYPE_MAIN_VARIANT (from
))
3169 conv
= build_conv (REF_BIND
, rto
, conv
);
3170 else if (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
3171 && DERIVED_FROM_P (to
, from
))
3173 conv
= build_conv (REF_BIND
, rto
, conv
);
3174 ICS_STD_RANK (conv
) = STD_RANK
;
3184 conv
= standard_conversion
3185 (TYPE_MAIN_VARIANT (to
), strip_top_quals (from
), expr
);
3188 conv
= build_conv (REF_BIND
, rto
, conv
);
3190 /* Bind directly to a base subobject of a class rvalue. */
3191 if (TREE_CODE (TREE_OPERAND (conv
, 0)) == BASE_CONV
)
3192 TREE_OPERAND (conv
, 0) = TREE_OPERAND (TREE_OPERAND (conv
, 0), 0);
3194 if (conv
&& ! (TYPE_READONLY (to
) && ! TYPE_VOLATILE (to
)
3195 && (flags
& LOOKUP_NO_TEMP_BIND
) == 0))
3196 ICS_BAD_FLAG (conv
) = 1;
3202 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
3203 to type TO. The optional expression EXPR may affect the conversion.
3204 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
3208 implicit_conversion (to
, from
, expr
, flags
)
3209 tree to
, from
, expr
;
3213 struct z_candidate
*cand
;
3215 if (expr
&& type_unknown_p (expr
))
3217 expr
= instantiate_type (to
, expr
, 0);
3218 if (expr
== error_mark_node
)
3220 from
= TREE_TYPE (expr
);
3223 if (TREE_CODE (to
) == REFERENCE_TYPE
)
3224 conv
= reference_binding (to
, from
, expr
, flags
);
3226 conv
= standard_conversion
3227 (TYPE_MAIN_VARIANT (non_reference (to
)),
3228 strip_top_quals (non_reference (from
)), expr
);
3232 if (TREE_CODE (conv
) == IDENTITY_CONV
&& IS_AGGR_TYPE (to
)
3233 && (TREE_CODE (from
) == REFERENCE_TYPE
|| (expr
&& real_lvalue_p (expr
))))
3234 conv
= build_conv (RVALUE_CONV
, to
, conv
);
3236 else if ((IS_AGGR_TYPE (non_reference (from
))
3237 || IS_AGGR_TYPE (non_reference (to
)))
3238 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
3240 if (TREE_CODE (to
) == REFERENCE_TYPE
3241 && TYPE_READONLY (TREE_TYPE (to
))
3242 && ! TYPE_VOLATILE (TREE_TYPE (to
))
3243 && (flags
& LOOKUP_NO_TEMP_BIND
) == 0)
3245 cand
= build_user_type_conversion_1
3246 (TYPE_MAIN_VARIANT (TREE_TYPE (to
)), expr
, LOOKUP_ONLYCONVERTING
);
3248 conv
= build_conv (REF_BIND
, to
, cand
->second_conv
);
3252 cand
= build_user_type_conversion_1
3253 (to
, expr
, LOOKUP_ONLYCONVERTING
);
3255 conv
= cand
->second_conv
;
3262 /* Create an overload candidate for the function or method FN called with
3263 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
3264 to implicit_conversion. */
3266 static struct z_candidate
*
3267 add_function_candidate (candidates
, fn
, arglist
, flags
)
3268 struct z_candidate
*candidates
;
3272 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
3275 tree parmnode
= parmlist
;
3276 tree argnode
= arglist
;
3278 struct z_candidate
*cand
;
3280 /* The `this' and `in_chrg' arguments to constructors are not considered
3281 in overload resolution. */
3282 if (DECL_CONSTRUCTOR_P (fn
))
3284 parmnode
= TREE_CHAIN (parmnode
);
3285 argnode
= TREE_CHAIN (argnode
);
3286 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
3288 parmnode
= TREE_CHAIN (parmnode
);
3289 argnode
= TREE_CHAIN (argnode
);
3293 len
= list_length (argnode
);
3294 convs
= make_tree_vec (len
);
3296 for (i
= 0; i
< len
; ++i
)
3298 tree arg
= TREE_VALUE (argnode
);
3299 tree argtype
= TREE_TYPE (arg
);
3302 argtype
= cp_build_type_variant
3303 (argtype
, TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
3305 if (parmnode
== void_list_node
)
3308 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
, flags
);
3311 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
3312 ICS_ELLIPSIS_FLAG (t
) = 1;
3315 if (i
== 0 && t
&& TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
3316 && ! DECL_CONSTRUCTOR_P (fn
))
3317 ICS_THIS_FLAG (t
) = 1;
3319 TREE_VEC_ELT (convs
, i
) = t
;
3323 if (ICS_BAD_FLAG (t
))
3327 parmnode
= TREE_CHAIN (parmnode
);
3328 argnode
= TREE_CHAIN (argnode
);
3334 /* Make sure there are default args for the rest of the parms. */
3335 for (; parmnode
&& parmnode
!= void_list_node
;
3336 parmnode
= TREE_CHAIN (parmnode
))
3337 if (! TREE_PURPOSE (parmnode
))
3343 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3346 cand
->convs
= convs
;
3347 cand
->second_conv
= NULL_TREE
;
3348 cand
->viable
= viable
;
3349 cand
->basetype_path
= NULL_TREE
;
3350 cand
->template = NULL_TREE
;
3351 cand
->next
= candidates
;
3356 /* Create an overload candidate for the conversion function FN which will
3357 be invoked for expression OBJ, producing a pointer-to-function which
3358 will in turn be called with the argument list ARGLIST, and add it to
3359 CANDIDATES. FLAGS is passed on to implicit_conversion. */
3361 static struct z_candidate
*
3362 add_conv_candidate (candidates
, fn
, obj
, arglist
)
3363 struct z_candidate
*candidates
;
3364 tree fn
, obj
, arglist
;
3366 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
3367 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (totype
));
3368 int i
, len
= list_length (arglist
) + 1;
3369 tree convs
= make_tree_vec (len
);
3370 tree parmnode
= parmlist
;
3371 tree argnode
= arglist
;
3373 struct z_candidate
*cand
;
3374 int flags
= LOOKUP_NORMAL
;
3376 for (i
= 0; i
< len
; ++i
)
3378 tree arg
= i
== 0 ? obj
: TREE_VALUE (argnode
);
3379 tree argtype
= lvalue_type (arg
);
3383 t
= implicit_conversion (totype
, argtype
, arg
, flags
);
3384 else if (parmnode
== void_list_node
)
3387 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
, flags
);
3390 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
3391 ICS_ELLIPSIS_FLAG (t
) = 1;
3394 TREE_VEC_ELT (convs
, i
) = t
;
3398 if (ICS_BAD_FLAG (t
))
3405 parmnode
= TREE_CHAIN (parmnode
);
3406 argnode
= TREE_CHAIN (argnode
);
3412 for (; parmnode
&& parmnode
!= void_list_node
;
3413 parmnode
= TREE_CHAIN (parmnode
))
3414 if (! TREE_PURPOSE (parmnode
))
3420 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3423 cand
->convs
= convs
;
3424 cand
->second_conv
= NULL_TREE
;
3425 cand
->viable
= viable
;
3426 cand
->basetype_path
= NULL_TREE
;
3427 cand
->template = NULL_TREE
;
3428 cand
->next
= candidates
;
3433 static struct z_candidate
*
3434 build_builtin_candidate (candidates
, fnname
, type1
, type2
,
3435 args
, argtypes
, flags
)
3436 struct z_candidate
*candidates
;
3437 tree fnname
, type1
, type2
, *args
, *argtypes
;
3443 struct z_candidate
*cand
;
3449 convs
= make_tree_vec (args
[2] ? 3 : (args
[1] ? 2 : 1));
3451 for (i
= 0; i
< 2; ++i
)
3456 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
], flags
);
3460 /* We need something for printing the candidate. */
3461 t
= build1 (IDENTITY_CONV
, types
[i
], NULL_TREE
);
3463 else if (ICS_BAD_FLAG (t
))
3465 TREE_VEC_ELT (convs
, i
) = t
;
3468 /* For COND_EXPR we rearranged the arguments; undo that now. */
3471 TREE_VEC_ELT (convs
, 2) = TREE_VEC_ELT (convs
, 1);
3472 TREE_VEC_ELT (convs
, 1) = TREE_VEC_ELT (convs
, 0);
3473 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2], flags
);
3475 TREE_VEC_ELT (convs
, 0) = t
;
3480 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3483 cand
->convs
= convs
;
3484 cand
->second_conv
= NULL_TREE
;
3485 cand
->viable
= viable
;
3486 cand
->basetype_path
= NULL_TREE
;
3487 cand
->template = NULL_TREE
;
3488 cand
->next
= candidates
;
3497 return TYPE_SIZE (complete_type (t
)) != NULL_TREE
;
3500 /* Create any builtin operator overload candidates for the operator in
3501 question given the converted operand types TYPE1 and TYPE2. The other
3502 args are passed through from add_builtin_candidates to
3503 build_builtin_candidate. */
3505 static struct z_candidate
*
3506 add_builtin_candidate (candidates
, code
, code2
, fnname
, type1
, type2
,
3507 args
, argtypes
, flags
)
3508 struct z_candidate
*candidates
;
3509 enum tree_code code
, code2
;
3510 tree fnname
, type1
, type2
, *args
, *argtypes
;
3515 case POSTINCREMENT_EXPR
:
3516 case POSTDECREMENT_EXPR
:
3517 args
[1] = integer_zero_node
;
3518 type2
= integer_type_node
;
3524 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3525 and VQ is either volatile or empty, there exist candidate operator
3526 functions of the form
3527 VQ T& operator++(VQ T&);
3528 T operator++(VQ T&, int);
3529 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
3530 type other than bool, and VQ is either volatile or empty, there exist
3531 candidate operator functions of the form
3532 VQ T& operator--(VQ T&);
3533 T operator--(VQ T&, int);
3534 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
3535 complete object type, and VQ is either volatile or empty, there exist
3536 candidate operator functions of the form
3537 T*VQ& operator++(T*VQ&);
3538 T*VQ& operator--(T*VQ&);
3539 T* operator++(T*VQ&, int);
3540 T* operator--(T*VQ&, int); */
3542 case POSTDECREMENT_EXPR
:
3543 case PREDECREMENT_EXPR
:
3544 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
3546 case POSTINCREMENT_EXPR
:
3547 case PREINCREMENT_EXPR
:
3548 if ((ARITHMETIC_TYPE_P (type1
) && TREE_CODE (type1
) != ENUMERAL_TYPE
)
3549 || TYPE_PTROB_P (type1
))
3551 type1
= build_reference_type (type1
);
3556 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
3557 exist candidate operator functions of the form
3561 8 For every function type T, there exist candidate operator functions of
3563 T& operator*(T*); */
3566 if (TREE_CODE (type1
) == POINTER_TYPE
3567 && (TYPE_PTROB_P (type1
)
3568 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
3572 /* 9 For every type T, there exist candidate operator functions of the form
3575 10For every promoted arithmetic type T, there exist candidate operator
3576 functions of the form
3580 case CONVERT_EXPR
: /* unary + */
3581 if (TREE_CODE (type1
) == POINTER_TYPE
3582 && TREE_CODE (TREE_TYPE (type1
)) != OFFSET_TYPE
)
3585 if (ARITHMETIC_TYPE_P (type1
))
3589 /* 11For every promoted integral type T, there exist candidate operator
3590 functions of the form
3594 if (INTEGRAL_TYPE_P (type1
))
3598 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
3599 is the same type as C2 or is a derived class of C2, T is a complete
3600 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
3601 there exist candidate operator functions of the form
3602 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
3603 where CV12 is the union of CV1 and CV2. */
3606 if (TREE_CODE (type1
) == POINTER_TYPE
3607 && (TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
)))
3609 tree c1
= TREE_TYPE (type1
);
3610 tree c2
= (TYPE_PTRMEMFUNC_P (type2
)
3611 ? TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2
))
3612 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2
)));
3614 if (IS_AGGR_TYPE (c1
) && DERIVED_FROM_P (c2
, c1
)
3615 && (TYPE_PTRMEMFUNC_P (type2
)
3616 || is_complete (TREE_TYPE (TREE_TYPE (type2
)))))
3621 /* 13For every pair of promoted arithmetic types L and R, there exist can-
3622 didate operator functions of the form
3627 bool operator<(L, R);
3628 bool operator>(L, R);
3629 bool operator<=(L, R);
3630 bool operator>=(L, R);
3631 bool operator==(L, R);
3632 bool operator!=(L, R);
3633 where LR is the result of the usual arithmetic conversions between
3636 14For every pair of types T and I, where T is a cv-qualified or cv-
3637 unqualified complete object type and I is a promoted integral type,
3638 there exist candidate operator functions of the form
3639 T* operator+(T*, I);
3640 T& operator[](T*, I);
3641 T* operator-(T*, I);
3642 T* operator+(I, T*);
3643 T& operator[](I, T*);
3645 15For every T, where T is a pointer to complete object type, there exist
3646 candidate operator functions of the form112)
3647 ptrdiff_t operator-(T, T);
3649 16For every pointer type T, there exist candidate operator functions of
3651 bool operator<(T, T);
3652 bool operator>(T, T);
3653 bool operator<=(T, T);
3654 bool operator>=(T, T);
3655 bool operator==(T, T);
3656 bool operator!=(T, T);
3658 17For every pointer to member type T, there exist candidate operator
3659 functions of the form
3660 bool operator==(T, T);
3661 bool operator!=(T, T); */
3664 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
3666 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3668 type2
= ptrdiff_type_node
;
3672 case TRUNC_DIV_EXPR
:
3673 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3679 if (TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
)
3680 || TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
3682 if ((TYPE_PTRMEMFUNC_P (type1
) || TYPE_PTRMEM_P (type1
))
3683 && null_ptr_cst_p (args
[1]))
3688 if ((TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
))
3689 && null_ptr_cst_p (args
[0]))
3700 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
)
3701 || TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3703 if (TYPE_PTR_P (type1
) && null_ptr_cst_p (args
[1]))
3708 if (null_ptr_cst_p (args
[0]) && TYPE_PTR_P (type2
))
3716 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3719 if (INTEGRAL_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
3721 type1
= ptrdiff_type_node
;
3724 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3726 type2
= ptrdiff_type_node
;
3731 /* 18For every pair of promoted integral types L and R, there exist candi-
3732 date operator functions of the form
3739 where LR is the result of the usual arithmetic conversions between
3742 case TRUNC_MOD_EXPR
:
3748 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
3752 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
3753 type, VQ is either volatile or empty, and R is a promoted arithmetic
3754 type, there exist candidate operator functions of the form
3755 VQ L& operator=(VQ L&, R);
3756 VQ L& operator*=(VQ L&, R);
3757 VQ L& operator/=(VQ L&, R);
3758 VQ L& operator+=(VQ L&, R);
3759 VQ L& operator-=(VQ L&, R);
3761 20For every pair T, VQ), where T is any type and VQ is either volatile
3762 or empty, there exist candidate operator functions of the form
3763 T*VQ& operator=(T*VQ&, T*);
3765 21For every pair T, VQ), where T is a pointer to member type and VQ is
3766 either volatile or empty, there exist candidate operator functions of
3768 VQ T& operator=(VQ T&, T);
3770 22For every triple T, VQ, I), where T is a cv-qualified or cv-
3771 unqualified complete object type, VQ is either volatile or empty, and
3772 I is a promoted integral type, there exist candidate operator func-
3774 T*VQ& operator+=(T*VQ&, I);
3775 T*VQ& operator-=(T*VQ&, I);
3777 23For every triple L, VQ, R), where L is an integral or enumeration
3778 type, VQ is either volatile or empty, and R is a promoted integral
3779 type, there exist candidate operator functions of the form
3781 VQ L& operator%=(VQ L&, R);
3782 VQ L& operator<<=(VQ L&, R);
3783 VQ L& operator>>=(VQ L&, R);
3784 VQ L& operator&=(VQ L&, R);
3785 VQ L& operator^=(VQ L&, R);
3786 VQ L& operator|=(VQ L&, R); */
3793 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3795 type2
= ptrdiff_type_node
;
3799 case TRUNC_DIV_EXPR
:
3800 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3804 case TRUNC_MOD_EXPR
:
3810 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
3815 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3817 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
3818 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3819 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
3820 || ((TYPE_PTRMEMFUNC_P (type1
)
3821 || TREE_CODE (type1
) == POINTER_TYPE
)
3822 && null_ptr_cst_p (args
[1])))
3830 my_friendly_abort (367);
3832 type1
= build_reference_type (type1
);
3836 /* Kludge around broken overloading rules whereby
3837 bool ? const char& : enum is ambiguous. */
3838 flags
|= LOOKUP_NO_TEMP_BIND
;
3839 if (TREE_CODE (type1
) == ENUMERAL_TYPE
&& type1
== type2
)
3841 else if (TREE_CODE (type1
) == ENUMERAL_TYPE
3842 || TREE_CODE (type2
) == ENUMERAL_TYPE
)
3844 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3846 if (TREE_CODE (type1
) == TREE_CODE (type2
)
3847 && (TREE_CODE (type1
) == REFERENCE_TYPE
3848 || TREE_CODE (type1
) == POINTER_TYPE
3849 || TYPE_PTRMEMFUNC_P (type1
)
3850 || IS_AGGR_TYPE (type1
)))
3852 if (TREE_CODE (type1
) == REFERENCE_TYPE
3853 || TREE_CODE (type2
) == REFERENCE_TYPE
)
3855 if (((TYPE_PTRMEMFUNC_P (type1
) || TREE_CODE (type1
) == POINTER_TYPE
)
3856 && null_ptr_cst_p (args
[1]))
3857 || IS_AGGR_TYPE (type1
))
3862 if (((TYPE_PTRMEMFUNC_P (type2
) || TREE_CODE (type2
) == POINTER_TYPE
)
3863 && null_ptr_cst_p (args
[0]))
3864 || IS_AGGR_TYPE (type2
))
3872 my_friendly_abort (367);
3875 /* If we're dealing with two pointer types, we need candidates
3876 for both of them. */
3877 if (type2
&& type1
!= type2
3878 && TREE_CODE (type1
) == TREE_CODE (type2
)
3879 && (TREE_CODE (type1
) == REFERENCE_TYPE
3880 || (TREE_CODE (type1
) == POINTER_TYPE
3881 && TYPE_PTRMEM_P (type1
) == TYPE_PTRMEM_P (type2
))
3882 || TYPE_PTRMEMFUNC_P (type1
)
3883 || IS_AGGR_TYPE (type1
)))
3885 candidates
= build_builtin_candidate
3886 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
);
3887 return build_builtin_candidate
3888 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
);
3891 return build_builtin_candidate
3892 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
);
3896 type_decays_to (type
)
3899 if (TREE_CODE (type
) == ARRAY_TYPE
)
3900 return build_pointer_type (TREE_TYPE (type
));
3901 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3902 return build_pointer_type (type
);
3906 /* There are three conditions of builtin candidates:
3908 1) bool-taking candidates. These are the same regardless of the input.
3909 2) pointer-pair taking candidates. These are generated for each type
3910 one of the input types converts to.
3911 3) arithmetic candidates. According to the WP, we should generate
3912 all of these, but I'm trying not to... */
3914 static struct z_candidate
*
3915 add_builtin_candidates (candidates
, code
, code2
, fnname
, args
, flags
)
3916 struct z_candidate
*candidates
;
3917 enum tree_code code
, code2
;
3922 tree type
, argtypes
[3], types
[2];
3924 for (i
= 0; i
< 3; ++i
)
3927 argtypes
[i
] = lvalue_type (args
[i
]);
3929 argtypes
[i
] = NULL_TREE
;
3934 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3935 and VQ is either volatile or empty, there exist candidate operator
3936 functions of the form
3937 VQ T& operator++(VQ T&); */
3939 case POSTINCREMENT_EXPR
:
3940 case PREINCREMENT_EXPR
:
3941 case POSTDECREMENT_EXPR
:
3942 case PREDECREMENT_EXPR
:
3947 /* 24There also exist candidate operator functions of the form
3948 bool operator!(bool);
3949 bool operator&&(bool, bool);
3950 bool operator||(bool, bool); */
3952 case TRUTH_NOT_EXPR
:
3953 return build_builtin_candidate
3954 (candidates
, fnname
, boolean_type_node
,
3955 NULL_TREE
, args
, argtypes
, flags
);
3957 case TRUTH_ORIF_EXPR
:
3958 case TRUTH_ANDIF_EXPR
:
3959 return build_builtin_candidate
3960 (candidates
, fnname
, boolean_type_node
,
3961 boolean_type_node
, args
, argtypes
, flags
);
3972 types
[0] = types
[1] = NULL_TREE
;
3974 for (i
= 0; i
< 2; ++i
)
3978 else if (IS_AGGR_TYPE (argtypes
[i
]))
3980 tree convs
= lookup_conversions (argtypes
[i
]);
3982 if (code
== COND_EXPR
)
3984 if (real_lvalue_p (args
[i
]))
3985 types
[i
] = tree_cons
3986 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
3988 types
[i
] = tree_cons
3989 (NULL_TREE
, TYPE_MAIN_VARIANT (argtypes
[i
]), types
[i
]);
3992 else if (! convs
|| (i
== 0 && code
== MODIFY_EXPR
3993 && code2
== NOP_EXPR
))
3996 for (; convs
; convs
= TREE_CHAIN (convs
))
3998 type
= TREE_TYPE (TREE_TYPE (TREE_VALUE (convs
)));
4001 && (TREE_CODE (type
) != REFERENCE_TYPE
4002 || TYPE_READONLY (TREE_TYPE (type
))))
4005 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
4006 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4008 type
= non_reference (type
);
4009 if (i
!= 0 || ! ref1
)
4011 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
4012 if (code
== COND_EXPR
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
4013 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4014 if (INTEGRAL_TYPE_P (type
))
4015 type
= type_promotes_to (type
);
4018 if (! value_member (type
, types
[i
]))
4019 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4024 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
4025 types
[i
] = tree_cons
4026 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
4027 type
= non_reference (argtypes
[i
]);
4028 if (i
!= 0 || ! ref1
)
4030 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
4031 if (code
== COND_EXPR
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
4032 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4033 if (INTEGRAL_TYPE_P (type
))
4034 type
= type_promotes_to (type
);
4036 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4040 for (; types
[0]; types
[0] = TREE_CHAIN (types
[0]))
4043 for (type
= types
[1]; type
; type
= TREE_CHAIN (type
))
4044 candidates
= add_builtin_candidate
4045 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
4046 TREE_VALUE (type
), args
, argtypes
, flags
);
4048 candidates
= add_builtin_candidate
4049 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
4050 NULL_TREE
, args
, argtypes
, flags
);
4056 static struct z_candidate
*
4057 add_template_candidate (candidates
, tmpl
, arglist
, flags
)
4058 struct z_candidate
*candidates
;
4062 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl
));
4063 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
4064 struct z_candidate
*cand
;
4068 i
= type_unification (DECL_TEMPLATE_PARMS (tmpl
), targs
,
4069 TYPE_ARG_TYPES (TREE_TYPE (tmpl
)),
4070 arglist
, &dummy
, 0, 0);
4074 fn
= instantiate_template (tmpl
, targs
);
4075 if (fn
== error_mark_node
)
4078 cand
= add_function_candidate (candidates
, fn
, arglist
, flags
);
4079 cand
->template = DECL_TEMPLATE_INFO (fn
);
4085 struct z_candidate
*cands
;
4087 for (; cands
; cands
= cands
->next
)
4088 if (pedantic
? cands
->viable
== 1 : cands
->viable
)
4093 static struct z_candidate
*
4094 splice_viable (cands
)
4095 struct z_candidate
*cands
;
4097 struct z_candidate
**p
= &cands
;
4101 if (pedantic
? (*p
)->viable
== 1 : (*p
)->viable
)
4114 /* Fix this to work on non-lvalues. */
4115 if (IS_SIGNATURE_POINTER (TREE_TYPE (obj
))
4116 || IS_SIGNATURE_REFERENCE (TREE_TYPE (obj
)))
4119 return build_unary_op (ADDR_EXPR
, obj
, 0);
4123 print_z_candidates (candidates
)
4124 struct z_candidate
*candidates
;
4126 char *str
= "candidates are:";
4127 for (; candidates
; candidates
= candidates
->next
)
4129 if (TREE_CODE (candidates
->fn
) == IDENTIFIER_NODE
)
4131 if (candidates
->fn
== ansi_opname
[COND_EXPR
])
4132 cp_error ("%s %D(%T, %T, %T) <builtin>", str
, candidates
->fn
,
4133 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)),
4134 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 1)),
4135 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 2)));
4136 else if (TREE_VEC_LENGTH (candidates
->convs
) == 2)
4137 cp_error ("%s %D(%T, %T) <builtin>", str
, candidates
->fn
,
4138 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)),
4139 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 1)));
4141 cp_error ("%s %D(%T) <builtin>", str
, candidates
->fn
,
4142 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)));
4145 cp_error_at ("%s %+D%s", str
, candidates
->fn
,
4146 candidates
->viable
== -1 ? " <near match>" : "");
4151 /* Returns the best overload candidate to perform the requested
4154 static struct z_candidate
*
4155 build_user_type_conversion_1 (totype
, expr
, flags
)
4159 struct z_candidate
*candidates
, *cand
;
4160 tree fromtype
= TREE_TYPE (expr
);
4161 tree ctors
= NULL_TREE
, convs
= NULL_TREE
, *p
;
4164 if (IS_AGGR_TYPE (totype
))
4165 ctors
= lookup_fnfields (TYPE_BINFO (totype
), ctor_identifier
, 0);
4166 if (IS_AGGR_TYPE (fromtype
)
4167 && (! IS_AGGR_TYPE (totype
) || ! DERIVED_FROM_P (totype
, fromtype
)))
4168 convs
= lookup_conversions (fromtype
);
4171 flags
|= LOOKUP_NO_CONVERSION
;
4175 tree t
= build_int_2 (0, 0);
4176 TREE_TYPE (t
) = build_pointer_type (totype
);
4177 args
= build_tree_list (NULL_TREE
, expr
);
4178 if (TYPE_USES_VIRTUAL_BASECLASSES (totype
))
4179 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
4180 args
= tree_cons (NULL_TREE
, t
, args
);
4182 ctors
= TREE_VALUE (ctors
);
4184 for (; ctors
; ctors
= DECL_CHAIN (ctors
))
4186 if (DECL_NONCONVERTING_P (ctors
))
4189 candidates
= add_function_candidate (candidates
, ctors
, args
, flags
);
4190 candidates
->second_conv
= build1 (IDENTITY_CONV
, totype
, NULL_TREE
);
4191 candidates
->basetype_path
= TYPE_BINFO (totype
);
4195 args
= build_tree_list (NULL_TREE
, build_this (expr
));
4197 for (; convs
; convs
= TREE_CHAIN (convs
))
4199 tree fn
= TREE_VALUE (convs
);
4200 tree ics
= implicit_conversion
4201 (totype
, TREE_TYPE (TREE_TYPE (fn
)), 0, LOOKUP_NO_CONVERSION
);
4203 for (; fn
; fn
= DECL_CHAIN (fn
))
4205 candidates
= add_function_candidate (candidates
, fn
, args
, flags
);
4206 candidates
->second_conv
= ics
;
4207 candidates
->basetype_path
= TREE_PURPOSE (convs
);
4208 if (candidates
->viable
== 1 && ICS_BAD_FLAG (ics
))
4209 candidates
->viable
= -1;
4213 if (! any_viable (candidates
))
4216 if (flags
& LOOKUP_COMPLAIN
)
4218 if (candidates
&& ! candidates
->next
)
4219 /* say why this one won't work or try to be loose */;
4221 cp_error ("no viable candidates");
4228 candidates
= splice_viable (candidates
);
4229 cand
= tourney (candidates
, totype
);
4233 if (flags
& LOOKUP_COMPLAIN
)
4235 cp_error ("conversion from `%T' to `%T' is ambiguous",
4237 print_z_candidates (candidates
);
4240 cand
= candidates
; /* any one will do */
4241 cand
->second_conv
= build1 (AMBIG_CONV
, totype
, expr
);
4242 ICS_USER_FLAG (cand
->second_conv
) = 1;
4247 for (p
= &(cand
->second_conv
); TREE_CODE (*p
) != IDENTITY_CONV
; )
4248 p
= &(TREE_OPERAND (*p
, 0));
4252 (DECL_CONSTRUCTOR_P (cand
->fn
)
4253 ? totype
: non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)))),
4254 NULL_TREE
, cand
->fn
, cand
->convs
, cand
->basetype_path
);
4255 ICS_USER_FLAG (cand
->second_conv
) = 1;
4256 if (cand
->viable
== -1)
4257 ICS_BAD_FLAG (cand
->second_conv
) = 1;
4263 build_user_type_conversion (totype
, expr
, flags
)
4267 struct z_candidate
*cand
4268 = build_user_type_conversion_1 (totype
, expr
, flags
);
4272 if (TREE_CODE (cand
->second_conv
) == AMBIG_CONV
)
4273 return error_mark_node
;
4274 return convert_from_reference (convert_like (cand
->second_conv
, expr
));
4280 build_new_function_call (fn
, args
, obj
)
4283 struct z_candidate
*candidates
= 0, *cand
;
4285 if (obj
== NULL_TREE
&& TREE_CODE (fn
) == TREE_LIST
)
4288 tree templates
= NULL_TREE
;
4290 for (t
= args
; t
; t
= TREE_CHAIN (t
))
4291 if (TREE_VALUE (t
) == error_mark_node
)
4292 return error_mark_node
;
4294 for (t
= TREE_VALUE (fn
); t
; t
= DECL_CHAIN (t
))
4296 if (TREE_CODE (t
) == TEMPLATE_DECL
)
4298 templates
= decl_tree_cons (NULL_TREE
, t
, templates
);
4299 candidates
= add_template_candidate
4300 (candidates
, t
, args
, LOOKUP_NORMAL
);
4303 candidates
= add_function_candidate
4304 (candidates
, t
, args
, LOOKUP_NORMAL
);
4307 if (! any_viable (candidates
))
4309 if (candidates
&& ! candidates
->next
)
4310 return build_function_call (candidates
->fn
, args
);
4312 cp_error ("no matching function for call to `%D (%A)'",
4313 TREE_PURPOSE (fn
), args
);
4314 return error_mark_node
;
4316 candidates
= splice_viable (candidates
);
4317 cand
= tourney (candidates
, NULL_TREE
);
4321 cp_error ("call of overloaded `%D (%A)' is ambiguous",
4322 TREE_PURPOSE (fn
), args
);
4323 print_z_candidates (candidates
);
4324 return error_mark_node
;
4327 /* Pedantically, it is ill-formed to define a function that could
4328 also be a template instantiation, but we won't implement that
4329 until things settle down. */
4330 if (templates
&& ! cand
->template && ! DECL_INITIAL (cand
->fn
))
4331 add_maybe_template (cand
->fn
, templates
);
4333 return build_over_call (cand
->fn
, cand
->convs
, args
, LOOKUP_NORMAL
);
4336 return build_function_call (fn
, args
);
4340 build_object_call (obj
, args
)
4343 struct z_candidate
*candidates
= 0, *cand
;
4344 tree fns
, convs
, mem_args
, *p
;
4345 enum tree_code code2
= NOP_EXPR
;
4346 tree type
= TREE_TYPE (obj
);
4348 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname
[CALL_EXPR
], 0);
4352 tree fn
= TREE_VALUE (fns
);
4353 mem_args
= tree_cons (NULL_TREE
, build_this (obj
), args
);
4355 for (; fn
; fn
= DECL_CHAIN (fn
))
4357 candidates
= add_function_candidate
4358 (candidates
, fn
, mem_args
, LOOKUP_NORMAL
);
4359 candidates
->basetype_path
= TREE_PURPOSE (fns
);
4363 convs
= lookup_conversions (type
);
4365 for (; convs
; convs
= TREE_CHAIN (convs
))
4367 tree fn
= TREE_VALUE (convs
);
4368 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
4370 if (TREE_CODE (totype
) == POINTER_TYPE
4371 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
4372 for (; fn
; fn
= DECL_CHAIN (fn
))
4374 candidates
= add_conv_candidate (candidates
, fn
, obj
, args
);
4375 candidates
->basetype_path
= TREE_PURPOSE (convs
);
4379 if (! any_viable (candidates
))
4381 cp_error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj
), args
);
4382 print_z_candidates (candidates
);
4383 return error_mark_node
;
4386 candidates
= splice_viable (candidates
);
4387 cand
= tourney (candidates
, NULL_TREE
);
4391 cp_error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj
), args
);
4392 print_z_candidates (candidates
);
4393 return error_mark_node
;
4396 if (DECL_NAME (cand
->fn
) == ansi_opname
[CALL_EXPR
])
4397 return build_over_call (cand
->fn
, cand
->convs
, mem_args
, LOOKUP_NORMAL
);
4399 obj
= convert_like (TREE_VEC_ELT (cand
->convs
, 0), obj
);
4402 return build_function_call (obj
, args
);
4406 op_error (code
, code2
, arg1
, arg2
, arg3
, problem
)
4407 enum tree_code code
, code2
;
4408 tree arg1
, arg2
, arg3
;
4412 = (code
== MODIFY_EXPR
? assignop_tab
[code2
] : opname_tab
[code
]);
4417 cp_error ("%s for `%T ? %T : %T'", problem
,
4418 error_type (arg1
), error_type (arg2
), error_type (arg3
));
4420 case POSTINCREMENT_EXPR
:
4421 case POSTDECREMENT_EXPR
:
4422 cp_error ("%s for `%T%s'", problem
, error_type (arg1
), opname
);
4425 cp_error ("%s for `%T[%T]'", problem
,
4426 error_type (arg1
), error_type (arg2
));
4430 cp_error ("%s for `%T %s %T'", problem
,
4431 error_type (arg1
), opname
, error_type (arg2
));
4433 cp_error ("%s for `%s%T'", problem
, opname
, error_type (arg1
));
4438 build_new_op (code
, flags
, arg1
, arg2
, arg3
)
4439 enum tree_code code
;
4441 tree arg1
, arg2
, arg3
;
4443 struct z_candidate
*candidates
= 0, *cand
;
4444 tree fns
, mem_arglist
, arglist
, fnname
, *p
;
4445 enum tree_code code2
= NOP_EXPR
;
4446 tree templates
= NULL_TREE
;
4448 if (arg1
== error_mark_node
4449 || arg2
== error_mark_node
4450 || arg3
== error_mark_node
)
4451 return error_mark_node
;
4453 if (code
== MODIFY_EXPR
)
4455 code2
= TREE_CODE (arg3
);
4457 fnname
= ansi_assopname
[code2
];
4460 fnname
= ansi_opname
[code
];
4469 arglist
= tree_cons (NULL_TREE
, arg2
, arg3
);
4470 if (flags
& LOOKUP_GLOBAL
)
4471 return build_new_function_call
4472 (lookup_name_nonclass (fnname
), arglist
, NULL_TREE
);
4475 rval
= build_method_call
4476 (build_indirect_ref (build1 (NOP_EXPR
, arg1
, error_mark_node
),
4478 fnname
, arglist
, NULL_TREE
, flags
);
4479 if (rval
== error_mark_node
)
4480 /* User might declare fancy operator new, but invoke it
4481 like standard one. */
4484 TREE_TYPE (rval
) = arg1
;
4485 TREE_CALLS_NEW (rval
) = 1;
4489 case VEC_DELETE_EXPR
:
4494 if (flags
& LOOKUP_GLOBAL
)
4495 return build_new_function_call
4496 (lookup_name_nonclass (fnname
),
4497 build_tree_list (NULL_TREE
, arg1
), NULL_TREE
);
4499 arglist
= tree_cons (NULL_TREE
, arg1
, build_tree_list (NULL_TREE
, arg2
));
4501 arg1
= TREE_TYPE (arg1
);
4503 /* This handles the case where we're trying to delete
4508 if (TREE_CODE (TREE_TYPE (arg1
)) == ARRAY_TYPE
)
4510 /* Strip off the pointer and the array. */
4511 arg1
= TREE_TYPE (TREE_TYPE (arg1
));
4513 while (TREE_CODE (arg1
) == ARRAY_TYPE
)
4514 arg1
= (TREE_TYPE (arg1
));
4516 arg1
= build_pointer_type (arg1
);
4520 rval
= build_method_call
4521 (build_indirect_ref (build1 (NOP_EXPR
, arg1
,
4524 fnname
, arglist
, NULL_TREE
, flags
);
4526 /* This can happen when operator delete is protected. */
4527 my_friendly_assert (rval
!= error_mark_node
, 250);
4528 TREE_TYPE (rval
) = void_type_node
;
4534 return build_object_call (arg1
, arg2
);
4537 /* The comma operator can have void args. */
4538 if (TREE_CODE (arg1
) == OFFSET_REF
)
4539 arg1
= resolve_offset_ref (arg1
);
4540 if (arg2
&& TREE_CODE (arg2
) == OFFSET_REF
)
4541 arg2
= resolve_offset_ref (arg2
);
4542 if (arg3
&& TREE_CODE (arg3
) == OFFSET_REF
)
4543 arg3
= resolve_offset_ref (arg3
);
4545 if (code
== COND_EXPR
)
4547 if (TREE_CODE (TREE_TYPE (arg2
)) == VOID_TYPE
4548 || TREE_CODE (TREE_TYPE (arg3
)) == VOID_TYPE
4549 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))
4550 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3
))))
4553 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1
))
4554 && (! arg2
|| ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))))
4557 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
4558 arg2
= integer_zero_node
;
4560 fns
= lookup_name_nonclass (fnname
);
4561 /* + Koenig lookup */
4564 arglist
= tree_cons (NULL_TREE
, arg1
, tree_cons
4565 (NULL_TREE
, arg2
, build_tree_list (NULL_TREE
, arg3
)));
4567 arglist
= tree_cons (NULL_TREE
, arg1
, build_tree_list (NULL_TREE
, arg2
));
4569 arglist
= build_tree_list (NULL_TREE
, arg1
);
4571 if (fns
&& TREE_CODE (fns
) == TREE_LIST
)
4572 fns
= TREE_VALUE (fns
);
4573 for (; fns
; fns
= DECL_CHAIN (fns
))
4575 if (TREE_CODE (fns
) == TEMPLATE_DECL
)
4577 templates
= decl_tree_cons (NULL_TREE
, fns
, templates
);
4578 candidates
= add_template_candidate
4579 (candidates
, fns
, arglist
, flags
);
4582 candidates
= add_function_candidate (candidates
, fns
, arglist
, flags
);
4585 if (IS_AGGR_TYPE (TREE_TYPE (arg1
)))
4586 fns
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1
)), fnname
, 0);
4592 tree fn
= TREE_VALUE (fns
);
4593 mem_arglist
= tree_cons (NULL_TREE
, build_this (arg1
), TREE_CHAIN (arglist
));
4594 for (; fn
; fn
= DECL_CHAIN (fn
))
4596 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4597 candidates
= add_function_candidate
4598 (candidates
, fn
, mem_arglist
, flags
);
4600 candidates
= add_function_candidate (candidates
, fn
, arglist
, flags
);
4602 candidates
->basetype_path
= TREE_PURPOSE (fns
);
4609 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
4610 to know about two args; a builtin candidate will always have a first
4611 parameter of type bool. We'll handle that in
4612 build_builtin_candidate. */
4613 if (code
== COND_EXPR
)
4623 args
[2] = NULL_TREE
;
4626 candidates
= add_builtin_candidates
4627 (candidates
, code
, code2
, fnname
, args
, flags
);
4630 if (! any_viable (candidates
))
4634 case POSTINCREMENT_EXPR
:
4635 case POSTDECREMENT_EXPR
:
4636 /* Look for an `operator++ (int)'. If they didn't have
4637 one, then we fall back to the old way of doing things. */
4638 if (flags
& LOOKUP_COMPLAIN
)
4639 cp_pedwarn ("no `%D (int)' declared for postfix `%s', trying prefix operator instead",
4640 fnname
, opname_tab
[code
]);
4641 if (code
== POSTINCREMENT_EXPR
)
4642 code
= PREINCREMENT_EXPR
;
4644 code
= PREDECREMENT_EXPR
;
4645 return build_new_op (code
, flags
, arg1
, NULL_TREE
, NULL_TREE
);
4647 /* The caller will deal with these. */
4653 if (flags
& LOOKUP_COMPLAIN
)
4655 op_error (code
, code2
, arg1
, arg2
, arg3
, "no match");
4656 print_z_candidates (candidates
);
4658 return error_mark_node
;
4660 candidates
= splice_viable (candidates
);
4661 cand
= tourney (candidates
, NULL_TREE
);
4665 if (flags
& LOOKUP_COMPLAIN
)
4667 op_error (code
, code2
, arg1
, arg2
, arg3
, "ambiguous overload");
4668 print_z_candidates (candidates
);
4670 return error_mark_node
;
4673 if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
4675 extern int warn_synth
;
4677 && fnname
== ansi_opname
[MODIFY_EXPR
]
4678 && DECL_ARTIFICIAL (cand
->fn
)
4680 && ! candidates
->next
->next
)
4682 cp_warning ("using synthesized `%#D' for copy assignment",
4684 cp_warning_at (" where cfront would use `%#D'",
4686 ? candidates
->next
->fn
4690 if (DECL_FUNCTION_MEMBER_P (cand
->fn
))
4691 enforce_access (cand
->basetype_path
, cand
->fn
);
4693 /* Pedantically, it is ill-formed to define a function that could
4694 also be a template instantiation, but we won't implement that
4695 until things settle down. */
4696 if (templates
&& ! cand
->template && ! DECL_INITIAL (cand
->fn
)
4697 && TREE_CODE (TREE_TYPE (cand
->fn
)) != METHOD_TYPE
)
4698 add_maybe_template (cand
->fn
, templates
);
4700 return build_over_call
4701 (cand
->fn
, cand
->convs
,
4702 TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
4703 ? mem_arglist
: arglist
,
4707 /* Check for comparison of different enum types. */
4716 if (flag_int_enum_equivalence
== 0
4717 && TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
4718 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
4719 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
4720 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
))))
4722 cp_warning ("comparison between `%#T' and `%#T'",
4723 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4727 arg1
= convert_from_reference
4728 (convert_like (TREE_VEC_ELT (cand
->convs
, 0), arg1
));
4730 arg2
= convert_like (TREE_VEC_ELT (cand
->convs
, 1), arg2
);
4732 arg3
= convert_like (TREE_VEC_ELT (cand
->convs
, 2), arg3
);
4738 return build_modify_expr (arg1
, code2
, arg2
);
4741 return build_indirect_ref (arg1
, "unary *");
4746 case TRUNC_DIV_EXPR
:
4757 case TRUNC_MOD_EXPR
:
4761 case TRUTH_ANDIF_EXPR
:
4762 case TRUTH_ORIF_EXPR
:
4763 return build_binary_op_nodefault (code
, arg1
, arg2
, code
);
4768 case TRUTH_NOT_EXPR
:
4769 case PREINCREMENT_EXPR
:
4770 case POSTINCREMENT_EXPR
:
4771 case PREDECREMENT_EXPR
:
4772 case POSTDECREMENT_EXPR
:
4773 return build_unary_op (code
, arg1
, candidates
!= 0);
4776 return build_array_ref (arg1
, arg2
);
4779 return build_conditional_expr (arg1
, arg2
, arg3
);
4782 return build_m_component_ref
4783 (build_indirect_ref (arg1
, NULL_PTR
), arg2
);
4785 /* The caller will deal with these. */
4792 my_friendly_abort (367);
4797 enforce_access (basetype_path
, function
)
4798 tree basetype_path
, function
;
4800 tree access
= compute_access (basetype_path
, function
);
4802 if (access
== access_private_node
)
4804 cp_error_at ("`%+#D' is %s", function
,
4805 TREE_PRIVATE (function
) ? "private"
4806 : "from private base class");
4807 error ("within this context");
4809 else if (access
== access_protected_node
)
4811 cp_error_at ("`%+#D' %s", function
,
4812 TREE_PROTECTED (function
) ? "is protected"
4813 : "has protected accessibility");
4814 error ("within this context");
4818 /* Perform the conversions in CONVS on the expression EXPR. */
4821 convert_like (convs
, expr
)
4824 if (ICS_BAD_FLAG (convs
))
4827 for (; t
; t
= TREE_OPERAND (t
, 0))
4829 if (TREE_CODE (t
) == USER_CONV
)
4831 expr
= convert_like (t
, expr
);
4834 else if (TREE_CODE (t
) == AMBIG_CONV
)
4835 return convert_like (t
, expr
);
4836 else if (TREE_CODE (t
) == IDENTITY_CONV
)
4839 return convert_for_initialization
4840 (NULL_TREE
, TREE_TYPE (convs
), expr
, LOOKUP_NORMAL
,
4841 "conversion", NULL_TREE
, 0);
4844 switch (TREE_CODE (convs
))
4848 tree fn
= TREE_OPERAND (convs
, 1);
4850 enforce_access (TREE_OPERAND (convs
, 3), fn
);
4852 if (DECL_CONSTRUCTOR_P (fn
))
4854 tree t
= build_int_2 (0, 0);
4855 TREE_TYPE (t
) = build_pointer_type (DECL_CONTEXT (fn
));
4857 args
= build_tree_list (NULL_TREE
, expr
);
4858 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
4859 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
4860 args
= tree_cons (NULL_TREE
, t
, args
);
4863 args
= build_this (expr
);
4864 expr
= build_over_call
4865 (TREE_OPERAND (convs
, 1), TREE_OPERAND (convs
, 2),
4866 args
, LOOKUP_NORMAL
);
4868 /* If this is a constructor or a function returning an aggr type,
4869 we need to build up a TARGET_EXPR. */
4870 if (DECL_CONSTRUCTOR_P (fn
))
4871 expr
= build_cplus_new (TREE_TYPE (convs
), expr
);
4876 if (type_unknown_p (expr
))
4877 expr
= instantiate_type (TREE_TYPE (convs
), expr
, 1);
4878 if (TREE_READONLY_DECL_P (expr
))
4879 expr
= decl_constant_value (expr
);
4882 /* Call build_user_type_conversion again for the error. */
4883 return build_user_type_conversion
4884 (TREE_TYPE (convs
), TREE_OPERAND (convs
, 0), LOOKUP_NORMAL
);
4887 expr
= convert_like (TREE_OPERAND (convs
, 0), expr
);
4888 if (expr
== error_mark_node
)
4889 return error_mark_node
;
4891 switch (TREE_CODE (convs
))
4895 return build_user_type_conversion
4896 (TREE_TYPE (convs
), expr
, LOOKUP_NORMAL
);
4898 return convert_to_reference
4899 (TREE_TYPE (convs
), expr
,
4900 CONV_IMPLICIT
, LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
4903 return decay_conversion (expr
);
4905 return cp_convert (TREE_TYPE (convs
), expr
, CONV_IMPLICIT
,
4906 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
);
4910 convert_default_arg (type
, arg
)
4913 arg
= break_out_target_exprs (arg
);
4915 if (TREE_CODE (arg
) == CONSTRUCTOR
)
4917 arg
= digest_init (type
, arg
, 0);
4918 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4919 "default argument", 0, 0);
4923 /* This could get clobbered by the following call. */
4924 if (TREE_HAS_CONSTRUCTOR (arg
))
4925 arg
= copy_node (arg
);
4927 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4928 "default argument", 0, 0);
4929 #ifdef PROMOTE_PROTOTYPES
4930 if ((TREE_CODE (type
) == INTEGER_TYPE
4931 || TREE_CODE (type
) == ENUMERAL_TYPE
)
4932 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
4933 arg
= default_conversion (arg
);
4941 build_over_call (fn
, convs
, args
, flags
)
4942 tree fn
, convs
, args
;
4945 tree converted_args
= NULL_TREE
;
4946 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
4947 tree conv
, arg
, val
;
4951 if (args
&& TREE_CODE (args
) != TREE_LIST
)
4952 args
= build_tree_list (NULL_TREE
, args
);
4955 /* The implicit parameters to a constructor are not considered by overload
4956 resolution, and must be of the proper type. */
4957 if (DECL_CONSTRUCTOR_P (fn
))
4959 converted_args
= tree_cons (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
4960 arg
= TREE_CHAIN (arg
);
4961 parm
= TREE_CHAIN (parm
);
4962 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
4964 converted_args
= tree_cons
4965 (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
4966 arg
= TREE_CHAIN (arg
);
4967 parm
= TREE_CHAIN (parm
);
4970 /* Bypass access control for 'this' parameter. */
4971 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4973 tree parmtype
= TREE_VALUE (parm
);
4974 tree argtype
= TREE_TYPE (TREE_VALUE (arg
));
4975 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs
, i
)))
4977 int dv
= (TYPE_VOLATILE (TREE_TYPE (parmtype
))
4978 < TYPE_VOLATILE (TREE_TYPE (argtype
)));
4979 int dc
= (TYPE_READONLY (TREE_TYPE (parmtype
))
4980 < TYPE_READONLY (TREE_TYPE (argtype
)));
4981 char *p
= (dv
&& dc
? "const and volatile" :
4982 dc
? "const" : dv
? "volatile" : "");
4984 cp_pedwarn ("passing `%T' as `this' argument of `%#D' discards %s",
4985 TREE_TYPE (argtype
), fn
, p
);
4987 converted_args
= tree_cons
4988 (NULL_TREE
, convert_force (TREE_VALUE (parm
), TREE_VALUE (arg
), CONV_C_CAST
),
4990 parm
= TREE_CHAIN (parm
);
4991 arg
= TREE_CHAIN (arg
);
4996 for (; conv
= TREE_VEC_ELT (convs
, i
), arg
&& parm
;
4997 parm
= TREE_CHAIN (parm
), arg
= TREE_CHAIN (arg
), ++i
)
4999 tree type
= TREE_VALUE (parm
);
5001 if (ICS_BAD_FLAG (conv
))
5004 val
= TREE_VALUE (arg
);
5006 for (; t
; t
= TREE_OPERAND (t
, 0))
5008 if (TREE_CODE (t
) == USER_CONV
5009 || TREE_CODE (t
) == AMBIG_CONV
)
5011 val
= convert_like (t
, val
);
5014 else if (TREE_CODE (t
) == IDENTITY_CONV
)
5017 val
= convert_for_initialization
5018 (NULL_TREE
, type
, val
, LOOKUP_NORMAL
,
5019 "argument passing", fn
, i
- is_method
);
5022 val
= convert_like (conv
, TREE_VALUE (arg
));
5024 #ifdef PROMOTE_PROTOTYPES
5025 if ((TREE_CODE (type
) == INTEGER_TYPE
5026 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5027 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
5028 val
= default_conversion (val
);
5030 converted_args
= tree_cons (NULL_TREE
, val
, converted_args
);
5033 /* Default arguments */
5034 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
))
5035 converted_args
= tree_cons
5037 convert_default_arg (TREE_VALUE (parm
), TREE_PURPOSE (parm
)),
5041 for (; arg
; arg
= TREE_CHAIN (arg
))
5043 val
= TREE_VALUE (arg
);
5045 if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
5046 && (TYPE_PRECISION (TREE_TYPE (val
))
5047 < TYPE_PRECISION (double_type_node
)))
5048 /* Convert `float' to `double'. */
5049 val
= convert (double_type_node
, val
);
5050 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val
))
5051 && ! TYPE_HAS_TRIVIAL_INIT_REF (TREE_TYPE (val
)))
5052 cp_warning ("cannot pass objects of type `%T' through `...'",
5055 /* Convert `short' and `char' to full-size `int'. */
5056 val
= default_conversion (val
);
5058 converted_args
= tree_cons (NULL_TREE
, val
, converted_args
);
5061 converted_args
= nreverse (converted_args
);
5063 /* Avoid actually calling copy constructors and copy assignment operators,
5065 if (DECL_CONSTRUCTOR_P (fn
)
5066 && TREE_VEC_LENGTH (convs
) == 1
5067 && copy_args_p (fn
))
5069 tree targ
= NULL_TREE
;
5070 arg
= TREE_VALUE (TREE_CHAIN (converted_args
));
5072 /* Pull out the real argument, disregarding const-correctness. */
5073 if (TREE_CODE (arg
) == ADDR_EXPR
)
5075 targ
= TREE_OPERAND (arg
, 0);
5076 if (! comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg
))),
5077 TYPE_MAIN_VARIANT (TREE_TYPE (targ
)), 1))
5084 arg
= build_indirect_ref (arg
, 0);
5086 /* If we're creating a temp and we already have one, don't create a
5087 new one. If we're not creating a temp but we get one, use
5088 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5089 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5090 temp or an INIT_EXPR otherwise. */
5091 if (integer_zerop (TREE_VALUE (args
)))
5093 if (! real_lvalue_p (arg
))
5095 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5097 val
= build (VAR_DECL
, DECL_CONTEXT (fn
));
5098 layout_decl (val
, 0);
5099 val
= build (TARGET_EXPR
, DECL_CONTEXT (fn
), val
, arg
, 0, 0);
5100 TREE_SIDE_EFFECTS (val
) = 1;
5104 else if (! real_lvalue_p (arg
)
5105 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5107 tree to
= stabilize_reference
5108 (build_indirect_ref (TREE_VALUE (args
), 0));
5109 val
= build (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
5110 TREE_SIDE_EFFECTS (val
) = 1;
5111 return build_unary_op (ADDR_EXPR
, val
, 0);
5114 else if (DECL_NAME (fn
) == ansi_opname
[MODIFY_EXPR
]
5116 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn
)))
5118 tree to
= stabilize_reference
5119 (build_indirect_ref (TREE_VALUE (converted_args
), 0));
5120 arg
= build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args
)), 0);
5121 val
= build (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
5122 TREE_SIDE_EFFECTS (val
) = 1;
5128 if (DECL_CONTEXT (fn
) && IS_SIGNATURE (DECL_CONTEXT (fn
)))
5129 return build_signature_method_call (fn
, converted_args
);
5130 else if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
5132 tree t
, *p
= &TREE_VALUE (converted_args
);
5133 tree binfo
= get_binfo
5134 (DECL_CONTEXT (fn
), TREE_TYPE (TREE_TYPE (*p
)), 0);
5135 *p
= convert_pointer_to_real (binfo
, *p
);
5136 if (TREE_SIDE_EFFECTS (*p
))
5137 *p
= save_expr (*p
);
5138 t
= build_pointer_type (TREE_TYPE (fn
));
5139 fn
= build_vfn_ref (p
, build_indirect_ref (*p
, 0), DECL_VINDEX (fn
));
5142 else if (DECL_INLINE (fn
))
5143 fn
= inline_conversion (fn
);
5145 fn
= build_addr_func (fn
);
5147 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))), converted_args
);
5148 if (TREE_TYPE (fn
) == void_type_node
)
5150 if (IS_AGGR_TYPE (TREE_TYPE (fn
)))
5151 fn
= build_cplus_new (TREE_TYPE (fn
), fn
);
5152 return convert_from_reference (require_complete_type (fn
));
5156 build_new_method_call (instance
, name
, args
, basetype_path
, flags
)
5157 tree instance
, name
, args
, basetype_path
;
5160 struct z_candidate
*candidates
= 0, *cand
;
5161 tree basetype
, mem_args
, fns
, instance_ptr
;
5164 for (fns
= args
; fns
; fns
= TREE_CHAIN (fns
))
5165 if (TREE_VALUE (fns
) == error_mark_node
)
5166 return error_mark_node
;
5168 if (instance
== NULL_TREE
)
5169 basetype
= BINFO_TYPE (basetype_path
);
5172 if (TREE_CODE (instance
) == OFFSET_REF
)
5173 instance
= resolve_offset_ref (instance
);
5174 if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
5175 instance
= convert_from_reference (instance
);
5176 basetype
= TREE_TYPE (instance
);
5178 /* XXX this should be handled before we get here. */
5179 if (! IS_AGGR_TYPE (basetype
)
5180 && ! (TYPE_LANG_SPECIFIC (basetype
)
5181 && (IS_SIGNATURE_POINTER (basetype
)
5182 || IS_SIGNATURE_REFERENCE (basetype
))))
5184 if ((flags
& LOOKUP_COMPLAIN
) && basetype
!= error_mark_node
)
5185 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5186 name
, instance
, basetype
);
5188 return error_mark_node
;
5191 /* If `instance' is a signature pointer/reference and `name' is
5192 not a constructor, we are calling a signature member function.
5193 In that case set the `basetype' to the signature type. */
5194 if ((IS_SIGNATURE_POINTER (basetype
)
5195 || IS_SIGNATURE_REFERENCE (basetype
))
5196 && TYPE_IDENTIFIER (basetype
) != name
)
5197 basetype
= SIGNATURE_TYPE (basetype
);
5200 if (basetype_path
== NULL_TREE
)
5201 basetype_path
= TYPE_BINFO (basetype
);
5205 instance_ptr
= build_this (instance
);
5207 /* XXX this should be handled before we get here. */
5208 fns
= build_field_call (basetype_path
, instance_ptr
, name
, args
);
5214 instance_ptr
= build_int_2 (0, 0);
5215 TREE_TYPE (instance_ptr
) = build_pointer_type (basetype
);
5219 (name
== ctor_identifier
? constructor_name_full (basetype
) : name
);
5221 fns
= lookup_fnfields (basetype_path
, name
, 1);
5223 if (fns
== error_mark_node
)
5224 return error_mark_node
;
5227 tree t
= TREE_VALUE (fns
);
5228 if (name
== ctor_identifier
&& TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
5229 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
5231 flags
|= LOOKUP_HAS_IN_CHARGE
;
5232 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
5234 mem_args
= tree_cons (NULL_TREE
, instance_ptr
, args
);
5235 for (; t
; t
= DECL_CHAIN (t
))
5237 /* We can end up here for copy-init of same or base class. */
5238 if (name
== ctor_identifier
5239 && (flags
& LOOKUP_ONLYCONVERTING
)
5240 && DECL_NONCONVERTING_P (t
))
5242 if (TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)
5243 candidates
= add_function_candidate
5244 (candidates
, t
, mem_args
, flags
);
5246 candidates
= add_function_candidate (candidates
, t
, args
, flags
);
5247 candidates
->basetype_path
= TREE_PURPOSE (fns
);
5251 if (! any_viable (candidates
))
5253 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5254 if (flags
& LOOKUP_SPECULATIVELY
)
5256 cp_error ("no matching function for call to `%T::%D (%A)%V'", basetype
,
5257 pretty_name
, args
, TREE_TYPE (TREE_TYPE (instance_ptr
)));
5258 print_z_candidates (candidates
);
5259 return error_mark_node
;
5261 candidates
= splice_viable (candidates
);
5262 cand
= tourney (candidates
, NULL_TREE
);
5266 cp_error ("call of overloaded `%D(%A)' is ambiguous", pretty_name
, args
);
5267 print_z_candidates (candidates
);
5268 return error_mark_node
;
5271 enforce_access (cand
->basetype_path
, cand
->fn
);
5272 if (DECL_ABSTRACT_VIRTUAL_P (cand
->fn
)
5273 && instance
== current_class_ref
5274 && DECL_CONSTRUCTOR_P (current_function_decl
)
5275 && ! (flags
& LOOKUP_NONVIRTUAL
)
5276 && value_member (cand
->fn
, get_abstract_virtuals (basetype
)))
5277 cp_error ("abstract virtual `%#D' called from constructor", cand
->fn
);
5278 if (TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
5279 && TREE_CODE (instance_ptr
) == NOP_EXPR
5280 && TREE_OPERAND (instance_ptr
, 0) == error_mark_node
)
5281 cp_error ("cannot call member function `%D' without object", cand
->fn
);
5283 if (DECL_VINDEX (cand
->fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
5284 && ((instance
== current_class_ref
&& (dtor_label
|| ctor_label
))
5285 || resolves_to_fixed_type_p (instance
, 0)))
5286 flags
|= LOOKUP_NONVIRTUAL
;
5288 return build_over_call
5289 (cand
->fn
, cand
->convs
,
5290 TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
? mem_args
: args
,
5294 /* Compare two implicit conversion sequences that differ only in their
5295 qualification conversion. Subroutine of compare_ics. */
5298 compare_qual (ics1
, ics2
)
5301 tree to1
= TREE_TYPE (ics1
);
5302 tree to2
= TREE_TYPE (ics2
);
5304 to1
= TREE_TYPE (to1
);
5305 to2
= TREE_TYPE (to2
);
5307 if (TREE_CODE (to1
) == OFFSET_TYPE
)
5309 to1
= TREE_TYPE (to1
);
5310 to2
= TREE_TYPE (to2
);
5313 if (TYPE_READONLY (to1
) >= TYPE_READONLY (to2
)
5314 && TYPE_VOLATILE (to1
) > TYPE_VOLATILE (to2
))
5316 else if (TYPE_READONLY (to1
) > TYPE_READONLY (to2
)
5317 && TYPE_VOLATILE (to1
) == TYPE_VOLATILE (to2
))
5319 else if (TYPE_READONLY (to1
) <= TYPE_READONLY (to2
)
5320 && TYPE_VOLATILE (to1
) < TYPE_VOLATILE (to2
))
5322 else if (TYPE_READONLY (to1
) < TYPE_READONLY (to2
)
5323 && TYPE_VOLATILE (to1
) == TYPE_VOLATILE (to2
))
5328 /* Compare two implicit conversion sequences according to the rules set out in
5329 [over.ics.rank]. Return values:
5331 1: ics1 is better than ics2
5332 -1: ics2 is better than ics1
5333 0: ics1 and ics2 are indistinguishable */
5336 compare_ics (ics1
, ics2
)
5341 if (TREE_CODE (ics1
) == QUAL_CONV
)
5342 main1
= TREE_OPERAND (ics1
, 0);
5346 if (TREE_CODE (ics2
) == QUAL_CONV
)
5347 main2
= TREE_OPERAND (ics2
, 0);
5351 /* Conversions for `this' are PTR_CONVs, but we compare them as though
5352 they were REF_BINDs. */
5353 if (ICS_THIS_FLAG (ics1
))
5355 ics1
= build_conv (REF_BIND
, TREE_TYPE (ics1
), main1
);
5356 TREE_OPERAND (ics1
, 0) = TREE_OPERAND (main1
, 0);
5359 if (ICS_THIS_FLAG (ics2
))
5361 ics2
= build_conv (REF_BIND
, TREE_TYPE (ics2
), main2
);
5362 TREE_OPERAND (ics2
, 0) = TREE_OPERAND (main2
, 0);
5366 if (ICS_RANK (ics1
) > ICS_RANK (ics2
))
5368 else if (ICS_RANK (ics1
) < ICS_RANK (ics2
))
5371 if (ICS_RANK (ics1
) == BAD_RANK
)
5373 if (ICS_USER_FLAG (ics1
) > ICS_USER_FLAG (ics2
)
5374 || ICS_STD_RANK (ics1
) > ICS_STD_RANK (ics2
))
5376 else if (ICS_USER_FLAG (ics1
) < ICS_USER_FLAG (ics2
)
5377 || ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5380 /* else fall through */
5383 /* User-defined conversion sequence U1 is a better conversion sequence
5384 than another user-defined conversion sequence U2 if they contain the
5385 same user-defined conversion operator or constructor and if the sec-
5386 ond standard conversion sequence of U1 is better than the second
5387 standard conversion sequence of U2. */
5389 if (ICS_USER_FLAG (ics1
))
5393 for (t1
= ics1
; TREE_CODE (t1
) != USER_CONV
; t1
= TREE_OPERAND (t1
, 0))
5394 if (TREE_CODE (t1
) == AMBIG_CONV
)
5396 for (t2
= ics2
; TREE_CODE (t2
) != USER_CONV
; t2
= TREE_OPERAND (t2
, 0))
5397 if (TREE_CODE (t2
) == AMBIG_CONV
)
5400 if (USER_CONV_FN (t1
) != USER_CONV_FN (t2
))
5402 else if (ICS_STD_RANK (ics1
) > ICS_STD_RANK (ics2
))
5404 else if (ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5407 /* else fall through */
5410 #if 0 /* Handled by ranking */
5411 /* A conversion that is not a conversion of a pointer, or pointer to
5412 member, to bool is better than another conversion that is such a
5416 if (TREE_CODE (main1
) != TREE_CODE (main2
))
5419 if (TREE_CODE (main1
) == PTR_CONV
|| TREE_CODE (main1
) == PMEM_CONV
5420 || TREE_CODE (main1
) == REF_BIND
|| TREE_CODE (main1
) == BASE_CONV
)
5422 tree to1
= TREE_TYPE (main1
);
5423 tree from1
= TREE_TYPE (TREE_OPERAND (main1
, 0));
5424 tree to2
= TREE_TYPE (main2
);
5425 tree from2
= TREE_TYPE (TREE_OPERAND (main2
, 0));
5428 /* Standard conversion sequence S1 is a better conversion sequence than
5429 standard conversion sequence S2 if...
5431 S1 and S2 differ only in their qualification conversion and they
5432 yield types identical except for cv-qualifiers and S2 adds all the
5433 qualifiers that S1 adds (and in the same places) and S2 adds yet
5434 more cv-qualifiers than S1, or the similar case with reference
5436 if (TREE_CODE (main1
) == REF_BIND
)
5438 if (TYPE_MAIN_VARIANT (TREE_TYPE (to1
))
5439 == TYPE_MAIN_VARIANT (TREE_TYPE (to2
)))
5440 return compare_qual (ics1
, ics2
);
5442 else if (TREE_CODE (main1
) != BASE_CONV
&& from1
== from2
&& to1
== to2
)
5443 return compare_qual (ics1
, ics2
);
5445 if (TYPE_PTRMEMFUNC_P (to1
))
5447 to1
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to1
));
5448 from1
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from1
));
5450 else if (TREE_CODE (main1
) != BASE_CONV
)
5452 to1
= TREE_TYPE (to1
);
5453 if (TREE_CODE (main1
) != REF_BIND
)
5454 from1
= TREE_TYPE (from1
);
5456 if (TREE_CODE (to1
) == OFFSET_TYPE
)
5458 to1
= TYPE_OFFSET_BASETYPE (to1
);
5459 from1
= TYPE_OFFSET_BASETYPE (from1
);
5463 if (TYPE_PTRMEMFUNC_P (to2
))
5465 to2
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to2
));
5466 from2
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from2
));
5468 else if (TREE_CODE (main1
) != BASE_CONV
)
5470 to2
= TREE_TYPE (to2
);
5471 if (TREE_CODE (main1
) != REF_BIND
)
5472 from2
= TREE_TYPE (from2
);
5474 if (TREE_CODE (to2
) == OFFSET_TYPE
)
5476 to2
= TYPE_OFFSET_BASETYPE (to2
);
5477 from2
= TYPE_OFFSET_BASETYPE (from2
);
5481 if (! (IS_AGGR_TYPE (from1
) && IS_AGGR_TYPE (from2
)))
5484 /* The sense of pmem conversions is reversed from that of the other
5486 if (TREE_CODE (main1
) == PMEM_CONV
)
5488 tree t
= from1
; from1
= from2
; from2
= t
;
5489 t
= to1
; to1
= to2
; to2
= t
;
5492 distf
= get_base_distance (from1
, from2
, 0, 0);
5495 distf
= -get_base_distance (from2
, from1
, 0, 0);
5500 /* If class B is derived directly or indirectly from class A,
5501 conver- sion of B* to A* is better than conversion of B* to
5502 void*, and conversion of A* to void* is better than
5503 conversion of B* to void*. */
5505 if (TREE_CODE (to1
) == VOID_TYPE
&& TREE_CODE (to2
) == VOID_TYPE
)
5512 else if (TREE_CODE (to2
) == VOID_TYPE
&& IS_AGGR_TYPE (to1
)
5513 && get_base_distance (to1
, from1
, 0, 0) != -1)
5515 else if (TREE_CODE (to1
) == VOID_TYPE
&& IS_AGGR_TYPE (to2
)
5516 && get_base_distance (to2
, from2
, 0, 0) != -1)
5519 if (! (IS_AGGR_TYPE (to1
) && IS_AGGR_TYPE (to2
)))
5522 /* If class B is derived directly or indirectly from class A and class
5523 C is derived directly or indirectly from B */
5525 distt
= get_base_distance (to1
, to2
, 0, 0);
5528 distt
= -get_base_distance (to2
, to1
, 0, 0);
5533 /* --conversion of C* to B* is better than conversion of C* to A*, */
5541 /* --conversion of B* to A* is better than conversion of C* to A*, */
5542 else if (distt
== 0)
5550 else if (TREE_CODE (TREE_TYPE (main1
)) == POINTER_TYPE
5551 || TYPE_PTRMEMFUNC_P (TREE_TYPE (main1
)))
5553 if (TREE_TYPE (main1
) == TREE_TYPE (main2
))
5554 return compare_qual (ics1
, ics2
);
5556 #if 0 /* This is now handled by making identity better than anything else. */
5557 /* existing practice, not WP-endorsed: const char * -> const char *
5558 is better than char * -> const char *. (jason 6/29/96) */
5559 if (TREE_TYPE (ics1
) == TREE_TYPE (ics2
))
5560 return -compare_qual (main1
, main2
);
5567 /* Compare two candidates for overloading as described in
5568 [over.match.best]. Return values:
5570 1: cand1 is better than cand2
5571 -1: cand2 is better than cand1
5572 0: cand1 and cand2 are indistinguishable */
5575 joust (cand1
, cand2
)
5576 struct z_candidate
*cand1
, *cand2
;
5579 int i
, off1
= 0, off2
= 0, len
;
5581 /* Candidates that involve bad conversions are always worse than those
5583 if (cand1
->viable
> cand2
->viable
)
5585 if (cand1
->viable
< cand2
->viable
)
5588 /* a viable function F1
5589 is defined to be a better function than another viable function F2 if
5590 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5591 ICSi(F2), and then */
5593 /* for some argument j, ICSj(F1) is a better conversion sequence than
5596 /* For comparing static and non-static member functions, we ignore the
5597 implicit object parameter of the non-static function. The WP says to
5598 pretend that the static function has an object parm, but that won't
5599 work with operator overloading. */
5600 len
= TREE_VEC_LENGTH (cand1
->convs
);
5601 if (len
!= TREE_VEC_LENGTH (cand2
->convs
))
5603 if (DECL_STATIC_FUNCTION_P (cand1
->fn
)
5604 && ! DECL_STATIC_FUNCTION_P (cand2
->fn
))
5606 else if (! DECL_STATIC_FUNCTION_P (cand1
->fn
)
5607 && DECL_STATIC_FUNCTION_P (cand2
->fn
))
5613 my_friendly_abort (42);
5616 for (i
= 0; i
< len
; ++i
)
5618 int comp
= compare_ics (TREE_VEC_ELT (cand1
->convs
, i
+off1
),
5619 TREE_VEC_ELT (cand2
->convs
, i
+off2
));
5623 if (winner
&& comp
!= winner
)
5636 F1 is a non-template function and F2 is a template function */
5638 if (! cand1
->template && cand2
->template)
5640 else if (cand1
->template && ! cand2
->template)
5642 else if (cand1
->template && cand2
->template)
5643 winner
= more_specialized
5644 (TI_TEMPLATE (cand1
->template), TI_TEMPLATE (cand2
->template));
5647 the context is an initialization by user-defined conversion (see
5648 _dcl.init_ and _over.match.user_) and the standard conversion
5649 sequence from the return type of F1 to the destination type (i.e.,
5650 the type of the entity being initialized) is a better conversion
5651 sequence than the standard conversion sequence from the return type
5652 of F2 to the destination type. */
5654 if (! winner
&& cand1
->second_conv
)
5655 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
5657 /* If the built-in candidates are the same, arbitrarily pick one. */
5658 if (! winner
&& cand1
->fn
== cand2
->fn
5659 && TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
)
5661 for (i
= 0; i
< len
; ++i
)
5662 if (! comptypes (TREE_TYPE (TREE_VEC_ELT (cand1
->convs
, i
)),
5663 TREE_TYPE (TREE_VEC_ELT (cand2
->convs
, i
)), 1))
5665 if (i
== TREE_VEC_LENGTH (cand1
->convs
))
5667 /* Kludge around broken overloading rules whereby
5668 bool ? void *const & : void *const & is ambiguous. */
5669 if (cand1
->fn
== ansi_opname
[COND_EXPR
])
5671 tree c1
= TREE_VEC_ELT (cand1
->convs
, 1);
5672 tree c2
= TREE_VEC_ELT (cand2
->convs
, 1);
5673 tree t1
= strip_top_quals (non_reference (TREE_TYPE (c1
)));
5674 tree t2
= strip_top_quals (non_reference (TREE_TYPE (c2
)));
5676 if (comptypes (t1
, t2
, 1))
5678 if (TREE_CODE (c1
) == REF_BIND
&& TREE_CODE (c2
) != REF_BIND
)
5680 if (TREE_CODE (c1
) != REF_BIND
&& TREE_CODE (c2
) == REF_BIND
)
5688 /* Extension: If the worst conversion for one candidate is worse than the
5689 worst conversion for the other, take the first. */
5690 if (! winner
&& ! pedantic
)
5692 int rank1
= IDENTITY_RANK
, rank2
= IDENTITY_RANK
;
5694 for (i
= 0; i
< len
; ++i
)
5696 if (ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
)) > rank1
)
5697 rank1
= ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
));
5698 if (ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
)) > rank2
)
5699 rank2
= ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
));
5711 /* Given a list of candidates for overloading, find the best one, if any.
5712 This algorithm has a worst case of O(2n) (winner is last), and a best
5713 case of O(n/2) (totally ambiguous); much better than a sorting
5716 static struct z_candidate
*
5717 tourney (candidates
)
5718 struct z_candidate
*candidates
;
5720 struct z_candidate
*champ
= candidates
, *challenger
;
5723 /* Walk through the list once, comparing each current champ to the next
5724 candidate, knocking out a candidate or two with each comparison. */
5726 for (challenger
= champ
->next
; challenger
; )
5728 fate
= joust (champ
, challenger
);
5730 challenger
= challenger
->next
;
5735 champ
= challenger
->next
;
5742 challenger
= champ
->next
;
5746 /* Make sure the champ is better than all the candidates it hasn't yet
5747 been compared to. This may do one more comparison than necessary. Oh
5750 for (challenger
= candidates
; challenger
!= champ
;
5751 challenger
= challenger
->next
)
5753 fate
= joust (champ
, challenger
);
5762 can_convert (to
, from
)
5765 if (flag_ansi_overloading
)
5767 tree t
= implicit_conversion (to
, from
, NULL_TREE
, LOOKUP_NORMAL
);
5768 return (t
&& ! ICS_BAD_FLAG (t
));
5772 struct harshness_code h
;
5773 h
= convert_harshness (to
, from
, NULL_TREE
);
5774 return (h
.code
< USER_CODE
) && (h
.distance
>= 0);
5779 can_convert_arg (to
, from
, arg
)
5782 if (flag_ansi_overloading
)
5784 tree t
= implicit_conversion (to
, from
, arg
, LOOKUP_NORMAL
);
5785 return (t
&& ! ICS_BAD_FLAG (t
));
5789 struct harshness_code h
;
5790 h
= convert_harshness (to
, from
, arg
);
5791 return (h
.code
< USER_CODE
) && (h
.distance
>= 0);