1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 hacked by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* High-level class interface. */
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
));
47 static tree build_new_method_call
PROTO((tree
, tree
, tree
, tree
, int));
49 #define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG))
50 #define STD_RETURN(ARG) ((ARG).code = STD_CODE, (ARG))
51 #define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG))
52 #define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG))
53 #define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG))
55 /* Ordering function for overload resolution. Compare two candidates
59 rank_for_overload (x
, y
)
60 struct candidate
*x
, *y
;
62 if (y
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
63 return y
->h
.code
- x
->h
.code
;
64 if (x
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
67 /* This is set by compute_conversion_costs, for calling a non-const
68 member function from a const member function. */
69 if ((y
->harshness
[0].code
& CONST_CODE
) ^ (x
->harshness
[0].code
& CONST_CODE
))
70 return y
->harshness
[0].code
- x
->harshness
[0].code
;
72 if (y
->h
.code
& STD_CODE
)
74 if (x
->h
.code
& STD_CODE
)
75 return y
->h
.distance
- x
->h
.distance
;
78 if (x
->h
.code
& STD_CODE
)
81 return y
->h
.code
- x
->h
.code
;
84 /* Compare two candidates, argument by argument. */
88 struct candidate
*x
, *y
;
92 if (x
->h_len
!= y
->h_len
)
95 for (i
= 0; i
< x
->h_len
; i
++)
97 if (y
->harshness
[i
].code
- x
->harshness
[i
].code
)
98 return y
->harshness
[i
].code
- x
->harshness
[i
].code
;
99 if ((y
->harshness
[i
].code
& STD_CODE
)
100 && (y
->harshness
[i
].distance
- x
->harshness
[i
].distance
))
101 return y
->harshness
[i
].distance
- x
->harshness
[i
].distance
;
103 /* They're both the same code. Now see if we're dealing with an
104 integral promotion that needs a finer grain of accuracy. */
105 if (y
->harshness
[0].code
& PROMO_CODE
106 && (y
->harshness
[i
].int_penalty
^ x
->harshness
[i
].int_penalty
))
107 return y
->harshness
[i
].int_penalty
- x
->harshness
[i
].int_penalty
;
112 /* TYPE is the type we wish to convert to. PARM is the parameter
113 we have to work with. We use a somewhat arbitrary cost function
114 to measure this conversion. */
116 static struct harshness_code
117 convert_harshness (type
, parmtype
, parm
)
118 register tree type
, parmtype
;
121 struct harshness_code h
;
122 register enum tree_code codel
;
123 register enum tree_code coder
;
130 #ifdef GATHER_STATISTICS
131 n_convert_harshness
++;
134 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
137 parm
= convert_from_reference (parm
);
138 parmtype
= TREE_TYPE (parmtype
);
142 lvalue
= lvalue_p (parm
);
146 if (TYPE_PTRMEMFUNC_P (type
))
147 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
148 if (TYPE_PTRMEMFUNC_P (parmtype
))
149 parmtype
= TYPE_PTRMEMFUNC_FN_TYPE (parmtype
);
151 codel
= TREE_CODE (type
);
152 coder
= TREE_CODE (parmtype
);
154 if (TYPE_MAIN_VARIANT (parmtype
) == TYPE_MAIN_VARIANT (type
))
155 return ZERO_RETURN (h
);
157 if (coder
== ERROR_MARK
)
158 return EVIL_RETURN (h
);
160 if (codel
== REFERENCE_TYPE
)
163 int constp
= parm
? TREE_READONLY (parm
) : TYPE_READONLY (parmtype
);
164 int volatilep
= (parm
? TREE_THIS_VOLATILE (parm
)
165 : TYPE_VOLATILE (parmtype
));
166 register tree intype
= TYPE_MAIN_VARIANT (parmtype
);
167 register enum tree_code form
= TREE_CODE (intype
);
170 ttl
= TREE_TYPE (type
);
172 /* Only allow const reference binding if we were given a parm to deal
173 with, since it isn't really a conversion. This is a hack to
174 prevent build_type_conversion from finding this conversion, but
175 still allow overloading to find it. */
176 if (! lvalue
&& ! (parm
&& TYPE_READONLY (ttl
)))
177 return EVIL_RETURN (h
);
179 if ((TYPE_READONLY (ttl
) < constp
)
180 || (TYPE_VOLATILE (ttl
) < volatilep
))
181 return EVIL_RETURN (h
);
183 /* When passing a non-const argument into a const reference, dig it a
184 little, so a non-const reference is preferred over this one. */
185 penalty
= ((TYPE_READONLY (ttl
) > constp
)
186 + (TYPE_VOLATILE (ttl
) > volatilep
));
188 ttl
= TYPE_MAIN_VARIANT (ttl
);
190 if (form
== OFFSET_TYPE
)
192 intype
= TREE_TYPE (intype
);
193 form
= TREE_CODE (intype
);
198 if (TREE_CODE (ttl
) == ARRAY_TYPE
&& TREE_CODE (ttr
) == ARRAY_TYPE
)
200 if (comptypes (ttl
, ttr
, 1))
201 return ZERO_RETURN (h
);
202 return EVIL_RETURN (h
);
205 h
= convert_harshness (ttl
, ttr
, NULL_TREE
);
206 if (penalty
&& h
.code
== 0)
209 h
.int_penalty
= penalty
;
214 if (codel
== POINTER_TYPE
&& fntype_p (parmtype
))
217 struct harshness_code h1
, h2
;
219 /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */
220 type
= TREE_TYPE (type
);
222 if (coder
== POINTER_TYPE
)
224 parmtype
= TREE_TYPE (parmtype
);
225 coder
= TREE_CODE (parmtype
);
228 if (coder
!= TREE_CODE (type
))
229 return EVIL_RETURN (h
);
231 if (type
!= parmtype
&& coder
== METHOD_TYPE
)
233 tree ttl
= TYPE_METHOD_BASETYPE (type
);
234 tree ttr
= TYPE_METHOD_BASETYPE (parmtype
);
236 int b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
239 b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
241 return EVIL_RETURN (h
);
242 h
.distance
= -b_or_d
;
248 type
= build_function_type
249 (TREE_TYPE (type
), TREE_CHAIN (TYPE_ARG_TYPES (type
)));
250 parmtype
= build_function_type
251 (TREE_TYPE (parmtype
), TREE_CHAIN (TYPE_ARG_TYPES (parmtype
)));
254 /* We allow the default conversion between function type
255 and pointer-to-function type for free. */
256 if (comptypes (type
, parmtype
, 1))
260 return EVIL_RETURN (h
);
262 /* Compare return types. */
263 p1
= TREE_TYPE (type
);
264 p2
= TREE_TYPE (parmtype
);
265 h2
= convert_harshness (p1
, p2
, NULL_TREE
);
266 if (h2
.code
& EVIL_CODE
)
269 h1
.code
= TRIVIAL_CODE
;
272 if (h2
.distance
!= 0)
276 /* This only works for pointers. */
277 if (TREE_CODE (p1
) != POINTER_TYPE
278 && TREE_CODE (p1
) != REFERENCE_TYPE
)
279 return EVIL_RETURN (h
);
283 /* Don't die if we happen to be dealing with void*. */
284 if (!IS_AGGR_TYPE (p1
) || !IS_AGGR_TYPE (p2
))
285 return EVIL_RETURN (h
);
287 binfo
= get_binfo (p2
, p1
, 0);
289 binfo
= get_binfo (p1
, p2
, 0);
291 if (! BINFO_OFFSET_ZEROP (binfo
))
294 static int explained
= 0;
296 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p2
, p1
);
298 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p1
, p2
);
301 sorry ("(because pointer values change during conversion)");
303 return EVIL_RETURN (h
);
308 if (h2
.distance
> h1
.distance
)
309 h1
.distance
= h2
.distance
;
311 p1
= TYPE_ARG_TYPES (type
);
312 p2
= TYPE_ARG_TYPES (parmtype
);
313 while (p1
&& TREE_VALUE (p1
) != void_type_node
314 && p2
&& TREE_VALUE (p2
) != void_type_node
)
316 h2
= convert_harshness (TREE_VALUE (p1
), TREE_VALUE (p2
),
318 if (h2
.code
& EVIL_CODE
)
323 /* This only works for pointers and references. */
324 if (TREE_CODE (TREE_VALUE (p1
)) != POINTER_TYPE
325 && TREE_CODE (TREE_VALUE (p1
)) != REFERENCE_TYPE
)
326 return EVIL_RETURN (h
);
327 h2
.distance
= - h2
.distance
;
331 if (h2
.distance
> h1
.distance
)
332 h1
.distance
= h2
.distance
;
333 p1
= TREE_CHAIN (p1
);
334 p2
= TREE_CHAIN (p2
);
341 return EVIL_RETURN (h
);
342 h1
.code
|= ELLIPSIS_CODE
;
347 if (TREE_PURPOSE (p1
) == NULL_TREE
)
348 h1
.code
|= EVIL_CODE
;
352 else if (codel
== POINTER_TYPE
&& coder
== OFFSET_TYPE
)
356 /* Get to the OFFSET_TYPE that this might be. */
357 type
= TREE_TYPE (type
);
359 if (coder
!= TREE_CODE (type
))
360 return EVIL_RETURN (h
);
362 ttl
= TYPE_OFFSET_BASETYPE (type
);
363 ttr
= TYPE_OFFSET_BASETYPE (parmtype
);
369 int b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
372 b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
374 return EVIL_RETURN (h
);
375 h
.distance
= -b_or_d
;
382 /* Now test the OFFSET_TYPE's target compatibility. */
383 type
= TREE_TYPE (type
);
384 parmtype
= TREE_TYPE (parmtype
);
387 if (coder
== UNKNOWN_TYPE
)
389 if (codel
== FUNCTION_TYPE
390 || codel
== METHOD_TYPE
391 || (codel
== POINTER_TYPE
392 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
393 || TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)))
394 return TRIVIAL_RETURN (h
);
395 return EVIL_RETURN (h
);
398 if (coder
== VOID_TYPE
)
399 return EVIL_RETURN (h
);
401 if (codel
== BOOLEAN_TYPE
)
403 if (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
)
404 return STD_RETURN (h
);
405 else if (coder
== POINTER_TYPE
|| coder
== OFFSET_TYPE
)
407 /* Make this worse than any conversion to another pointer.
408 FIXME this is how I think the language should work, but it may not
409 end up being how the language is standardized (jason 1/30/95). */
411 return STD_RETURN (h
);
413 return EVIL_RETURN (h
);
416 if (INTEGRAL_CODE_P (codel
))
418 /* Control equivalence of ints an enums. */
420 if (codel
== ENUMERAL_TYPE
421 && flag_int_enum_equivalence
== 0)
423 /* Enums can be converted to ints, but not vice-versa. */
424 if (coder
!= ENUMERAL_TYPE
425 || TYPE_MAIN_VARIANT (type
) != TYPE_MAIN_VARIANT (parmtype
))
426 return EVIL_RETURN (h
);
429 /* else enums and ints (almost) freely interconvert. */
431 if (INTEGRAL_CODE_P (coder
))
433 if (TYPE_MAIN_VARIANT (type
)
434 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
443 else if (coder
== REAL_TYPE
)
451 if (codel
== REAL_TYPE
)
453 if (coder
== REAL_TYPE
)
455 if (TYPE_MAIN_VARIANT (type
)
456 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
463 else if (INTEGRAL_CODE_P (coder
))
471 /* Convert arrays which have not previously been converted. */
472 if (coder
== ARRAY_TYPE
)
474 coder
= POINTER_TYPE
;
477 parm
= decay_conversion (parm
);
478 parmtype
= TREE_TYPE (parm
);
481 parmtype
= build_pointer_type (TREE_TYPE (parmtype
));
484 /* Conversions among pointers */
485 if (codel
== POINTER_TYPE
&& coder
== POINTER_TYPE
)
487 register tree ttl
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
488 register tree ttr
= TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
));
489 int penalty
= 4 * (ttl
!= ttr
);
491 /* Anything converts to void *. Since this may be `const void *'
492 (etc.) use VOID_TYPE instead of void_type_node. Otherwise, the
493 targets must be the same, except that we do allow (at some cost)
494 conversion between signed and unsigned pointer types. */
496 if ((TREE_CODE (ttl
) == METHOD_TYPE
497 || TREE_CODE (ttl
) == FUNCTION_TYPE
)
498 && TREE_CODE (ttl
) == TREE_CODE (ttr
))
500 if (comptypes (ttl
, ttr
, -1))
502 h
.code
= penalty
? STD_CODE
: 0;
511 if (TREE_CODE (ttl
) != VOID_TYPE
512 && (TREE_CODE (ttr
) != VOID_TYPE
|| !parm
|| !null_ptr_cst_p (parm
)))
514 if (comp_target_types (type
, parmtype
, 1) <= 0)
515 return EVIL_RETURN (h
);
518 if (!(TREE_CODE (ttl
) == VOID_TYPE
519 || TREE_CODE (ttr
) == VOID_TYPE
520 || (TREE_UNSIGNED (ttl
) ^ TREE_UNSIGNED (ttr
)
521 && (ttl
= unsigned_type (ttl
),
522 ttr
= unsigned_type (ttr
),
524 || (comp_target_types (ttl
, ttr
, 0) > 0)))
525 return EVIL_RETURN (h
);
530 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
533 /* Note conversion from `T*' to `const T*',
534 or `T*' to `volatile T*'. */
535 if ((TYPE_READONLY (tmp1
) < TREE_READONLY (tmp2
))
536 || (TYPE_VOLATILE (tmp1
) < TYPE_VOLATILE (tmp2
)))
538 else if ((TYPE_READONLY (tmp1
) != TREE_READONLY (tmp2
))
539 || (TYPE_VOLATILE (tmp1
) != TYPE_VOLATILE (tmp2
)))
547 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
549 int b_or_d
= get_base_distance (ttl
, ttr
, 0, (tree
*)0);
552 b_or_d
= get_base_distance (ttr
, ttl
, 0, (tree
*)0);
554 return EVIL_RETURN (h
);
555 h
.distance
= -b_or_d
;
563 /* If converting from a `class*' to a `void*', make it
564 less favorable than any inheritance relationship. */
565 if (TREE_CODE (ttl
) == VOID_TYPE
&& IS_AGGR_TYPE (ttr
))
568 h
.distance
= CLASSTYPE_MAX_DEPTH (ttr
)+1;
572 h
.code
= penalty
? STD_CODE
: PROMO_CODE
;
573 /* Catch things like `const char *' -> `const void *'
574 vs `const char *' -> `void *'. */
577 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
578 if ((TYPE_READONLY (tmp1
) < TREE_READONLY (tmp2
))
579 || (TYPE_VOLATILE (tmp1
) < TYPE_VOLATILE (tmp2
)))
581 else if ((TYPE_READONLY (tmp1
) > TREE_READONLY (tmp2
))
582 || (TYPE_VOLATILE (tmp1
) > TYPE_VOLATILE (tmp2
)))
588 if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
590 /* This is not a bad match, but don't let it beat
591 integer-enum combinations. */
592 if (parm
&& integer_zerop (parm
))
600 /* C++: Since the `this' parameter of a signature member function
601 is represented as a signature pointer to handle default implementations
602 correctly, we can have the case that `type' is a signature pointer
603 while `parmtype' is a pointer to a signature table. We don't really
604 do any conversions in this case, so just return 0. */
606 if (codel
== RECORD_TYPE
&& coder
== POINTER_TYPE
607 && IS_SIGNATURE_POINTER (type
) && IS_SIGNATURE (TREE_TYPE (parmtype
)))
608 return ZERO_RETURN (h
);
610 if (codel
== RECORD_TYPE
&& coder
== RECORD_TYPE
)
612 int b_or_d
= get_base_distance (type
, parmtype
, 0, (tree
*)0);
615 b_or_d
= get_base_distance (parmtype
, type
, 0, (tree
*)0);
617 return EVIL_RETURN (h
);
618 h
.distance
= -b_or_d
;
625 return EVIL_RETURN (h
);
628 /* A clone of build_type_conversion for checking user-defined conversions in
629 overload resolution. */
632 user_harshness (type
, parmtype
)
633 register tree type
, parmtype
;
636 tree winner
= NULL_TREE
;
640 tree typename
= build_typename_overload (type
);
641 if (lookup_fnfields (TYPE_BINFO (parmtype
), typename
, 0))
645 for (conv
= lookup_conversions (parmtype
); conv
; conv
= TREE_CHAIN (conv
))
647 struct harshness_code tmp
;
648 tree cand
= TREE_VALUE (conv
);
650 if (winner
&& winner
== cand
)
653 tmp
= convert_harshness (type
, TREE_TYPE (TREE_TYPE (cand
)), NULL_TREE
);
654 if ((tmp
.code
< USER_CODE
) && (tmp
.distance
>= 0))
672 #ifdef DEBUG_MATCHING
675 struct harshness_code
*h
;
677 static char buf
[1024];
680 bzero (buf
, 1024 * sizeof (char));
681 strcat (buf
, "codes=[");
682 if (h
->code
& EVIL_CODE
)
683 strcat (buf
, "EVIL");
684 if (h
->code
& CONST_CODE
)
685 strcat (buf
, " CONST");
686 if (h
->code
& ELLIPSIS_CODE
)
687 strcat (buf
, " ELLIPSIS");
688 if (h
->code
& USER_CODE
)
689 strcat (buf
, " USER");
690 if (h
->code
& STD_CODE
)
691 strcat (buf
, " STD");
692 if (h
->code
& PROMO_CODE
)
693 strcat (buf
, " PROMO");
694 if (h
->code
& QUAL_CODE
)
695 strcat (buf
, " QUAL");
696 if (h
->code
& TRIVIAL_CODE
)
697 strcat (buf
, " TRIVIAL");
701 sprintf (tmp
, "] distance=%d int_penalty=%d", h
->distance
, h
->int_penalty
);
709 /* Algorithm: For each argument, calculate how difficult it is to
710 make FUNCTION accept that argument. If we can easily tell that
711 FUNCTION won't be acceptable to one of the arguments, then we
712 don't need to compute the ease of converting the other arguments,
713 since it will never show up in the intersection of all arguments'
716 Conversions between builtin and user-defined types are allowed, but
717 no function involving such a conversion is preferred to one which
718 does not require such a conversion. Furthermore, such conversions
722 compute_conversion_costs (function
, tta_in
, cp
, arglen
)
725 struct candidate
*cp
;
728 tree ttf_in
= TYPE_ARG_TYPES (TREE_TYPE (function
));
732 /* Start out with no strikes against. */
733 int evil_strikes
= 0;
734 int ellipsis_strikes
= 0;
735 int user_strikes
= 0;
736 int b_or_d_strikes
= 0;
737 int easy_strikes
= 0;
739 int strike_index
= 0, win
;
740 struct harshness_code lose
;
741 extern int cp_silent
;
743 #ifdef GATHER_STATISTICS
744 n_compute_conversion_costs
++;
747 #ifndef DEBUG_MATCHING
748 /* We don't emit any warnings or errors while trying out each candidate. */
752 cp
->function
= function
;
753 cp
->arg
= tta
? TREE_VALUE (tta
) : NULL_TREE
;
754 cp
->u
.bad_arg
= 0; /* optimistic! */
758 cp
->h
.int_penalty
= 0;
759 bzero ((char *) cp
->harshness
,
760 (cp
->h_len
+ 1) * sizeof (struct harshness_code
));
764 struct harshness_code h
;
766 if (ttf
== void_list_node
)
769 if (type_unknown_p (TREE_VALUE (tta
)))
771 /* Must perform some instantiation here. */
772 tree rhs
= TREE_VALUE (tta
);
773 tree lhstype
= TREE_VALUE (ttf
);
775 /* Keep quiet about possible contravariance violations. */
776 int old_inhibit_warnings
= inhibit_warnings
;
777 inhibit_warnings
= 1;
779 /* @@ This is to undo what `grokdeclarator' does to
780 parameter types. It really should go through
781 something more general. */
783 TREE_TYPE (tta
) = unknown_type_node
;
784 rhs
= instantiate_type (lhstype
, rhs
, 0);
785 inhibit_warnings
= old_inhibit_warnings
;
787 if (TREE_CODE (rhs
) == ERROR_MARK
)
790 h
= convert_harshness (lhstype
, TREE_TYPE (rhs
), rhs
);
794 #ifdef DEBUG_MATCHING
795 static tree old_function
= NULL_TREE
;
797 if (!old_function
|| function
!= old_function
)
799 cp_error ("trying %D", function
);
800 old_function
= function
;
803 cp_error (" doing (%T) %E against arg %T",
804 TREE_TYPE (TREE_VALUE (tta
)), TREE_VALUE (tta
),
808 h
= convert_harshness (TREE_VALUE (ttf
),
809 TREE_TYPE (TREE_VALUE (tta
)),
812 #ifdef DEBUG_MATCHING
813 cp_error (" evaluated %s", print_harshness (&h
));
817 cp
->harshness
[strike_index
] = h
;
818 if ((h
.code
& EVIL_CODE
)
819 || ((h
.code
& STD_CODE
) && h
.distance
< 0))
821 cp
->u
.bad_arg
= strike_index
;
824 else if (h
.code
& ELLIPSIS_CODE
)
825 ellipsis_strikes
+= 1;
827 /* This is never set by `convert_harshness'. */
828 else if (h
.code
& USER_CODE
)
835 if ((h
.code
& STD_CODE
) && h
.distance
)
837 if (h
.distance
> b_or_d_strikes
)
838 b_or_d_strikes
= h
.distance
;
841 easy_strikes
+= (h
.code
& (STD_CODE
|PROMO_CODE
|TRIVIAL_CODE
));
842 cp
->h
.code
|= h
.code
;
843 /* Make sure we communicate this. */
844 cp
->h
.int_penalty
+= h
.int_penalty
;
847 ttf
= TREE_CHAIN (ttf
);
848 tta
= TREE_CHAIN (tta
);
854 /* ran out of formals, and parmlist is fixed size. */
855 if (ttf
/* == void_type_node */)
857 cp
->h
.code
= EVIL_CODE
;
864 struct harshness_code h
;
865 int l
= list_length (tta
);
866 ellipsis_strikes
+= l
;
867 h
.code
= ELLIPSIS_CODE
;
871 cp
->harshness
[strike_index
++] = h
;
874 else if (ttf
&& ttf
!= void_list_node
)
876 /* ran out of actuals, and no defaults. */
877 if (TREE_PURPOSE (ttf
) == NULL_TREE
)
879 cp
->h
.code
= EVIL_CODE
;
884 /* Store index of first default. */
885 cp
->harshness
[arglen
].distance
= strike_index
+1;
888 cp
->harshness
[arglen
].distance
= 0;
890 /* Argument list lengths work out, so don't need to check them again. */
893 /* We do not check for derived->base conversions here, since in
894 no case would they give evil strike counts, unless such conversions
895 are somehow ambiguous. */
897 /* See if any user-defined conversions apply.
898 But make sure that we do not loop. */
899 static int dont_convert_types
= 0;
901 if (dont_convert_types
)
903 cp
->h
.code
= EVIL_CODE
;
908 win
= 0; /* Only get one chance to win. */
909 ttf
= TYPE_ARG_TYPES (TREE_TYPE (function
));
916 if (ttf
== void_list_node
)
919 lose
= cp
->harshness
[strike_index
];
920 if ((lose
.code
& EVIL_CODE
)
921 || ((lose
.code
& STD_CODE
) && lose
.distance
< 0))
923 tree actual_type
= TREE_TYPE (TREE_VALUE (tta
));
924 tree formal_type
= TREE_VALUE (ttf
);
925 int extra_conversions
= 0;
927 dont_convert_types
= 1;
929 if (TREE_CODE (formal_type
) == REFERENCE_TYPE
)
930 formal_type
= TREE_TYPE (formal_type
);
931 if (TREE_CODE (actual_type
) == REFERENCE_TYPE
)
932 actual_type
= TREE_TYPE (actual_type
);
934 if (formal_type
!= error_mark_node
935 && actual_type
!= error_mark_node
)
937 formal_type
= complete_type (TYPE_MAIN_VARIANT (formal_type
));
938 actual_type
= complete_type (TYPE_MAIN_VARIANT (actual_type
));
940 if (TYPE_HAS_CONSTRUCTOR (formal_type
))
942 /* If it has a constructor for this type,
944 /* @@ There is no way to save this result yet, so
945 success is a NULL_TREE for now. */
946 if (convert_to_aggr (formal_type
, TREE_VALUE (tta
), 0, 1)
950 if (TYPE_LANG_SPECIFIC (actual_type
)
951 && TYPE_HAS_CONVERSION (actual_type
))
953 int extra
= user_harshness (formal_type
, actual_type
);
955 if (extra
== EVIL_CODE
)
960 extra_conversions
= extra
;
964 dont_convert_types
= 0;
969 cp
->harshness
[strike_index
].code
970 = USER_CODE
| (extra_conversions
? STD_CODE
: 0);
975 if (cp
->u
.bad_arg
> strike_index
)
976 cp
->u
.bad_arg
= strike_index
;
978 evil_strikes
= win
? 2 : 1;
983 ttf
= TREE_CHAIN (ttf
);
984 tta
= TREE_CHAIN (tta
);
989 /* Const member functions get a small penalty because defaulting
990 to const is less useful than defaulting to non-const. */
991 /* This is bogus, it does not correspond to anything in the ARM.
992 This code will be fixed when this entire section is rewritten
993 to conform to the ARM. (mrs) */
994 if (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
996 tree this_parm
= TREE_VALUE (ttf_in
);
998 if (TREE_CODE (this_parm
) == RECORD_TYPE
/* Is `this' a sig ptr? */
999 ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm
))))
1000 : TYPE_READONLY (TREE_TYPE (this_parm
)))
1002 cp
->harshness
[0].code
|= TRIVIAL_CODE
;
1007 /* Calling a non-const member function from a const member function
1008 is probably invalid, but for now we let it only draw a warning.
1009 We indicate that such a mismatch has occurred by setting the
1010 harshness to a maximum value. */
1011 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in
))) == POINTER_TYPE
1012 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in
))))))
1013 cp
->harshness
[0].code
|= CONST_CODE
;
1018 cp
->h
.code
= EVIL_CODE
;
1019 if (ellipsis_strikes
)
1020 cp
->h
.code
|= ELLIPSIS_CODE
;
1022 cp
->h
.code
|= USER_CODE
;
1024 #ifdef DEBUG_MATCHING
1025 cp_error ("final eval %s", print_harshness (&cp
->h
));
1029 /* Subroutine of ideal_candidate. See if X or Y is a better match
1033 strictly_better (x
, y
)
1034 unsigned short x
, y
;
1042 if (xor >= x
|| xor >= y
)
1047 /* When one of several possible overloaded functions and/or methods
1048 can be called, choose the best candidate for overloading.
1050 BASETYPE is the context from which we start method resolution
1051 or NULL if we are comparing overloaded functions.
1052 CANDIDATES is the array of candidates we have to choose from.
1053 N_CANDIDATES is the length of CANDIDATES.
1054 PARMS is a TREE_LIST of parameters to the function we'll ultimately
1055 choose. It is modified in place when resolving methods. It is not
1056 modified in place when resolving overloaded functions.
1057 LEN is the length of the parameter list. */
1059 static struct candidate
*
1060 ideal_candidate (candidates
, n_candidates
, len
)
1061 struct candidate
*candidates
;
1065 struct candidate
*cp
= candidates
+n_candidates
;
1066 int i
, j
= -1, best_code
;
1068 /* For each argument, sort the functions from best to worst for the arg.
1069 For each function that's not best for this arg, set its overall
1070 harshness to EVIL so that other args won't like it. The candidate
1071 list for the last argument is the intersection of all the best-liked
1074 qsort (candidates
, n_candidates
, sizeof (struct candidate
),
1076 best_code
= cp
[-1].h
.code
;
1078 /* If they're at least as good as each other, do an arg-by-arg check. */
1079 if (! strictly_better (cp
[-1].h
.code
, cp
[-2].h
.code
))
1084 for (j
= 0; j
< n_candidates
; j
++)
1085 if (! strictly_better (candidates
[j
].h
.code
, best_code
))
1088 qsort (candidates
+j
, n_candidates
-j
, sizeof (struct candidate
),
1090 for (i
= 0; i
< len
; i
++)
1092 if (cp
[-1].harshness
[i
].code
< cp
[-2].harshness
[i
].code
)
1094 else if (cp
[-1].harshness
[i
].code
> cp
[-2].harshness
[i
].code
)
1096 else if (cp
[-1].harshness
[i
].code
& STD_CODE
)
1098 /* If it involves a standard conversion, let the
1099 inheritance lattice be the final arbiter. */
1100 if (cp
[-1].harshness
[i
].distance
> cp
[-2].harshness
[i
].distance
)
1102 else if (cp
[-1].harshness
[i
].distance
< cp
[-2].harshness
[i
].distance
)
1105 else if (cp
[-1].harshness
[i
].code
& PROMO_CODE
)
1107 /* For integral promotions, take into account a finer
1108 granularity for determining which types should be favored
1109 over others in such promotions. */
1110 if (cp
[-1].harshness
[i
].int_penalty
> cp
[-2].harshness
[i
].int_penalty
)
1112 else if (cp
[-1].harshness
[i
].int_penalty
< cp
[-2].harshness
[i
].int_penalty
)
1117 if (! better
|| worse
)
1123 /* Assume that if the class referred to is not in the
1124 current class hierarchy, that it may be remote.
1125 PARENT is assumed to be of aggregate type here. */
1128 may_be_remote (parent
)
1131 if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent
) == 0)
1134 if (current_class_type
== NULL_TREE
)
1137 if (parent
== current_class_type
)
1140 if (UNIQUELY_DERIVED_FROM_P (parent
, current_class_type
))
1146 build_vfield_ref (datum
, type
)
1150 int old_assume_nonnull_objects
= flag_assume_nonnull_objects
;
1152 if (datum
== error_mark_node
)
1153 return error_mark_node
;
1155 /* Vtable references are always made from non-null objects. */
1156 flag_assume_nonnull_objects
= 1;
1157 if (TREE_CODE (TREE_TYPE (datum
)) == REFERENCE_TYPE
)
1158 datum
= convert_from_reference (datum
);
1160 if (! TYPE_USES_COMPLEX_INHERITANCE (type
))
1161 rval
= build (COMPONENT_REF
, TREE_TYPE (CLASSTYPE_VFIELD (type
)),
1162 datum
, CLASSTYPE_VFIELD (type
));
1164 rval
= build_component_ref (datum
, DECL_NAME (CLASSTYPE_VFIELD (type
)), NULL_TREE
, 0);
1165 flag_assume_nonnull_objects
= old_assume_nonnull_objects
;
1170 /* Build a call to a member of an object. I.e., one that overloads
1171 operator ()(), or is a pointer-to-function or pointer-to-method. */
1174 build_field_call (basetype_path
, instance_ptr
, name
, parms
)
1175 tree basetype_path
, instance_ptr
, name
, parms
;
1177 tree field
, instance
;
1179 if (name
== ctor_identifier
|| name
== dtor_identifier
)
1182 if (instance_ptr
== current_class_ptr
)
1184 /* Check to see if we really have a reference to an instance variable
1185 with `operator()()' overloaded. */
1186 field
= IDENTIFIER_CLASS_VALUE (name
);
1188 if (field
== NULL_TREE
)
1190 cp_error ("`this' has no member named `%D'", name
);
1191 return error_mark_node
;
1194 if (TREE_CODE (field
) == FIELD_DECL
)
1196 /* If it's a field, try overloading operator (),
1197 or calling if the field is a pointer-to-function. */
1198 instance
= build_component_ref_1 (current_class_ref
, field
, 0);
1199 if (instance
== error_mark_node
)
1200 return error_mark_node
;
1202 if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1203 && (TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance
))
1204 || flag_ansi_overloading
))
1205 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, instance
, parms
, NULL_TREE
);
1207 if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1209 if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == FUNCTION_TYPE
)
1210 return build_function_call (instance
, parms
);
1211 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == METHOD_TYPE
)
1212 return build_function_call (instance
, tree_cons (NULL_TREE
, current_class_ptr
, parms
));
1218 /* Check to see if this is not really a reference to an instance variable
1219 with `operator()()' overloaded. */
1220 field
= lookup_field (basetype_path
, name
, 1, 0);
1222 /* This can happen if the reference was ambiguous or for access
1224 if (field
== error_mark_node
)
1225 return error_mark_node
;
1230 tree ftype
= TREE_TYPE (field
);
1232 if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
1233 ftype
= TREE_TYPE (ftype
);
1235 if (TYPE_LANG_SPECIFIC (ftype
)
1236 && (TYPE_OVERLOADS_CALL_EXPR (ftype
) || flag_ansi_overloading
))
1238 /* Make the next search for this field very short. */
1239 basetype
= DECL_FIELD_CONTEXT (field
);
1240 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
1242 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1243 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
,
1244 build_component_ref_1 (instance
, field
, 0),
1247 if (TREE_CODE (ftype
) == POINTER_TYPE
)
1249 if (TREE_CODE (TREE_TYPE (ftype
)) == FUNCTION_TYPE
1250 || TREE_CODE (TREE_TYPE (ftype
)) == METHOD_TYPE
)
1252 /* This is a member which is a pointer to function. */
1254 = build_component_ref_1 (build_indirect_ref (instance_ptr
,
1256 field
, LOOKUP_COMPLAIN
);
1257 if (ref
== error_mark_node
)
1258 return error_mark_node
;
1259 return build_function_call (ref
, parms
);
1262 else if (TREE_CODE (ftype
) == METHOD_TYPE
)
1264 error ("invalid call via pointer-to-member function");
1265 return error_mark_node
;
1274 find_scoped_type (type
, inner_name
, inner_types
)
1275 tree type
, inner_name
, inner_types
;
1277 tree tags
= CLASSTYPE_TAGS (type
);
1281 /* The TREE_PURPOSE of an enum tag (which becomes a member of the
1282 enclosing class) is set to the name for the enum type. So, if
1283 inner_name is `bar', and we strike `baz' for `enum bar { baz }',
1284 then this test will be true. */
1285 if (TREE_PURPOSE (tags
) == inner_name
)
1287 if (inner_types
== NULL_TREE
)
1288 return TYPE_MAIN_DECL (TREE_VALUE (tags
));
1289 return resolve_scope_to_name (TREE_VALUE (tags
), inner_types
);
1291 tags
= TREE_CHAIN (tags
);
1294 /* Look for a TYPE_DECL. */
1295 for (tags
= TYPE_FIELDS (type
); tags
; tags
= TREE_CHAIN (tags
))
1296 if (TREE_CODE (tags
) == TYPE_DECL
&& DECL_NAME (tags
) == inner_name
)
1298 /* Code by raeburn. */
1299 if (inner_types
== NULL_TREE
)
1301 return resolve_scope_to_name (TREE_TYPE (tags
), inner_types
);
1307 /* Resolve an expression NAME1::NAME2::...::NAMEn to
1308 the name that names the above nested type. INNER_TYPES
1309 is a chain of nested type names (held together by SCOPE_REFs);
1310 OUTER_TYPE is the type we know to enclose INNER_TYPES.
1311 Returns NULL_TREE if there is an error. */
1314 resolve_scope_to_name (outer_type
, inner_stuff
)
1315 tree outer_type
, inner_stuff
;
1318 tree inner_name
, inner_type
;
1320 if (outer_type
== NULL_TREE
&& current_class_type
!= NULL_TREE
)
1322 /* We first try to look for a nesting in our current class context,
1323 then try any enclosing classes. */
1324 tree type
= current_class_type
;
1326 while (type
&& (TREE_CODE (type
) == RECORD_TYPE
1327 || TREE_CODE (type
) == UNION_TYPE
))
1329 tree rval
= resolve_scope_to_name (type
, inner_stuff
);
1331 if (rval
!= NULL_TREE
)
1333 type
= DECL_CONTEXT (TYPE_MAIN_DECL (type
));
1337 if (TREE_CODE (inner_stuff
) == SCOPE_REF
)
1339 inner_name
= TREE_OPERAND (inner_stuff
, 0);
1340 inner_type
= TREE_OPERAND (inner_stuff
, 1);
1344 inner_name
= inner_stuff
;
1345 inner_type
= NULL_TREE
;
1348 if (outer_type
== NULL_TREE
)
1351 /* If we have something that's already a type by itself,
1353 if (IDENTIFIER_HAS_TYPE_VALUE (inner_name
))
1356 return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name
),
1361 x
= lookup_name (inner_name
, 0);
1363 if (x
&& TREE_CODE (x
) == NAMESPACE_DECL
)
1365 x
= lookup_namespace_name (x
, inner_type
);
1371 if (! IS_AGGR_TYPE (outer_type
))
1374 /* Look for member classes or enums. */
1375 tmp
= find_scoped_type (outer_type
, inner_name
, inner_type
);
1377 /* If it's not a type in this class, then go down into the
1378 base classes and search there. */
1379 if (! tmp
&& TYPE_BINFO (outer_type
))
1381 tree binfos
= TYPE_BINFO_BASETYPES (outer_type
);
1382 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1384 for (i
= 0; i
< n_baselinks
; i
++)
1386 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1387 tmp
= resolve_scope_to_name (BINFO_TYPE (base_binfo
), inner_stuff
);
1397 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
1398 This is how virtual function calls are avoided. */
1401 build_scoped_method_call (exp
, basetype
, name
, parms
)
1402 tree exp
, basetype
, name
, parms
;
1404 /* Because this syntactic form does not allow
1405 a pointer to a base class to be `stolen',
1406 we need not protect the derived->base conversion
1409 @@ But we do have to check access privileges later. */
1411 tree type
= TREE_TYPE (exp
);
1413 if (type
== error_mark_node
1414 || basetype
== error_mark_node
)
1415 return error_mark_node
;
1417 if (processing_template_decl
)
1419 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1421 tree type
= get_aggr_from_typedef (TREE_OPERAND (name
, 0), 1);
1422 name
= build_min_nt (BIT_NOT_EXPR
, type
);
1424 name
= build_min_nt (SCOPE_REF
, basetype
, name
);
1425 return build_min_nt (METHOD_CALL_EXPR
, name
, exp
, parms
, NULL_TREE
);
1428 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1429 type
= TREE_TYPE (type
);
1431 if (TREE_CODE (basetype
) == TREE_VEC
)
1434 basetype
= BINFO_TYPE (binfo
);
1439 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
1440 that explicit ~int is caught in the parser; this deals with typedefs
1441 and template parms. */
1442 if (TREE_CODE (name
) == BIT_NOT_EXPR
&& ! IS_AGGR_TYPE (basetype
))
1444 if (type
!= basetype
)
1445 cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
1446 exp
, basetype
, type
);
1447 name
= TREE_OPERAND (name
, 0);
1448 if (basetype
!= name
&& basetype
!= get_type_value (name
))
1449 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1451 return cp_convert (void_type_node
, exp
);
1454 if (! is_aggr_type (basetype
, 1))
1455 return error_mark_node
;
1457 if (! IS_AGGR_TYPE (type
))
1459 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
1461 return error_mark_node
;
1466 binfo
= get_binfo (basetype
, type
, 1);
1467 if (binfo
== error_mark_node
)
1468 return error_mark_node
;
1470 error_not_base_type (basetype
, type
);
1475 if (TREE_CODE (exp
) == INDIRECT_REF
)
1476 decl
= build_indirect_ref
1477 (convert_pointer_to_real
1478 (binfo
, build_unary_op (ADDR_EXPR
, exp
, 0)), NULL_PTR
);
1480 decl
= build_scoped_ref (exp
, basetype
);
1482 /* Call to a destructor. */
1483 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1485 /* Explicit call to destructor. */
1486 name
= TREE_OPERAND (name
, 0);
1487 if (! (name
== TYPE_MAIN_VARIANT (TREE_TYPE (decl
))
1488 || name
== constructor_name (TREE_TYPE (decl
))
1489 || TREE_TYPE (decl
) == get_type_value (name
)))
1492 ("qualified type `%T' does not match destructor name `~%T'",
1493 TREE_TYPE (decl
), name
);
1494 return error_mark_node
;
1496 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl
)))
1497 return cp_convert (void_type_node
, exp
);
1499 return build_delete (TREE_TYPE (decl
), decl
, integer_two_node
,
1500 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
,
1504 /* Call to a method. */
1505 return build_method_call (decl
, name
, parms
, binfo
,
1506 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1508 return error_mark_node
;
1512 print_candidates (candidates
)
1515 cp_error_at ("candidates are: %D", TREE_VALUE (candidates
));
1516 candidates
= TREE_CHAIN (candidates
);
1520 cp_error_at (" %D", TREE_VALUE (candidates
));
1521 candidates
= TREE_CHAIN (candidates
);
1526 print_n_candidates (candidates
, n
)
1527 struct candidate
*candidates
;
1532 cp_error_at ("candidates are: %D", candidates
[0].function
);
1533 for (i
= 1; i
< n
; i
++)
1534 cp_error_at (" %D", candidates
[i
].function
);
1537 /* We want the address of a function or method. We avoid creating a
1538 pointer-to-member function. */
1541 build_addr_func (function
)
1544 tree type
= TREE_TYPE (function
);
1546 /* We have to do these by hand to avoid real pointer to member
1548 if (TREE_CODE (type
) == METHOD_TYPE
)
1552 type
= build_pointer_type (type
);
1554 if (mark_addressable (function
) == 0)
1555 return error_mark_node
;
1557 addr
= build1 (ADDR_EXPR
, type
, function
);
1559 /* Address of a static or external variable or function counts
1561 if (staticp (function
))
1562 TREE_CONSTANT (addr
) = 1;
1567 function
= default_conversion (function
);
1572 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
1573 POINTER_TYPE to those. Note, pointer to member function types
1574 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
1577 build_call (function
, result_type
, parms
)
1578 tree function
, result_type
, parms
;
1580 int is_constructor
= 0;
1582 function
= build_addr_func (function
);
1584 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
1586 sorry ("unable to call pointer to member function here");
1587 return error_mark_node
;
1590 if (TREE_CODE (function
) == ADDR_EXPR
1591 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
1592 && DECL_CONSTRUCTOR_P (TREE_OPERAND (function
, 0)))
1595 function
= build_nt (CALL_EXPR
, function
, parms
, NULL_TREE
);
1596 TREE_HAS_CONSTRUCTOR (function
) = is_constructor
;
1597 TREE_TYPE (function
) = result_type
;
1598 TREE_SIDE_EFFECTS (function
) = 1;
1604 default_parm_conversions (parms
, last
)
1607 tree parm
, parmtypes
= NULL_TREE
;
1611 for (parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1613 tree t
= TREE_TYPE (TREE_VALUE (parm
));
1615 if (TREE_CODE (t
) == OFFSET_TYPE
1616 || TREE_CODE (t
) == METHOD_TYPE
1617 || TREE_CODE (t
) == FUNCTION_TYPE
)
1619 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
1620 t
= TREE_TYPE (TREE_VALUE (parm
));
1623 if (t
== error_mark_node
)
1624 return error_mark_node
;
1626 *last
= build_tree_list (NULL_TREE
, t
);
1627 parmtypes
= chainon (parmtypes
, *last
);
1634 /* Build something of the form ptr->method (args)
1635 or object.method (args). This can also build
1636 calls to constructors, and find friends.
1638 Member functions always take their class variable
1641 INSTANCE is a class instance.
1643 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
1645 PARMS help to figure out what that NAME really refers to.
1647 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
1648 down to the real instance type to use for access checking. We need this
1649 information to get protected accesses correct. This parameter is used
1650 by build_member_call.
1652 FLAGS is the logical disjunction of zero or more LOOKUP_
1653 flags. See cp-tree.h for more info.
1655 If this is all OK, calls build_function_call with the resolved
1658 This function must also handle being called to perform
1659 initialization, promotion/coercion of arguments, and
1660 instantiation of default parameters.
1662 Note that NAME may refer to an instance variable name. If
1663 `operator()()' is defined for the type of that field, then we return
1667 build_method_call (instance
, name
, parms
, basetype_path
, flags
)
1668 tree instance
, name
, parms
, basetype_path
;
1671 register tree function
, fntype
, value_type
;
1672 register tree basetype
, save_basetype
;
1673 register tree baselink
, result
, parmtypes
;
1676 tree access
= access_public_node
;
1677 tree orig_basetype
= basetype_path
? BINFO_TYPE (basetype_path
) : NULL_TREE
;
1679 /* Range of cases for vtable optimization. */
1680 enum vtable_needs
{ not_needed
, maybe_needed
, unneeded
, needed
};
1681 enum vtable_needs need_vtbl
= not_needed
;
1684 tree save_name
= name
;
1686 tree instance_ptr
= NULL_TREE
;
1687 int all_virtual
= flag_all_virtual
;
1688 int static_call_context
= 0;
1689 tree found_fns
= NULL_TREE
;
1691 /* Keep track of `const' and `volatile' objects. */
1692 int constp
, volatilep
;
1694 #ifdef GATHER_STATISTICS
1695 n_build_method_call
++;
1698 if (instance
== error_mark_node
1699 || name
== error_mark_node
1700 || parms
== error_mark_node
1701 || (instance
!= NULL_TREE
&& TREE_TYPE (instance
) == error_mark_node
))
1702 return error_mark_node
;
1704 if (processing_template_decl
)
1706 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1708 tree type
= get_aggr_from_typedef (TREE_OPERAND (name
, 0), 1);
1709 name
= build_min_nt (BIT_NOT_EXPR
, type
);
1712 return build_min_nt (METHOD_CALL_EXPR
, name
, instance
, parms
, NULL_TREE
);
1715 /* This is the logic that magically deletes the second argument to
1716 operator delete, if it is not needed. */
1717 if (name
== ansi_opname
[(int) DELETE_EXPR
] && list_length (parms
)==2)
1719 tree save_last
= TREE_CHAIN (parms
);
1721 /* get rid of unneeded argument */
1722 TREE_CHAIN (parms
) = NULL_TREE
;
1723 result
= build_method_call (instance
, name
, parms
, basetype_path
,
1724 (LOOKUP_SPECULATIVELY
|flags
)
1726 /* If it finds a match, return it. */
1728 return build_method_call (instance
, name
, parms
, basetype_path
, flags
);
1729 /* If it doesn't work, two argument delete must work */
1730 TREE_CHAIN (parms
) = save_last
;
1732 /* We already know whether it's needed or not for vec delete. */
1733 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
1734 && TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1735 && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance
)))
1736 TREE_CHAIN (parms
) = NULL_TREE
;
1738 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1740 flags
|= LOOKUP_DESTRUCTOR
;
1741 name
= TREE_OPERAND (name
, 0);
1743 error ("destructors take no parameters");
1744 basetype
= TREE_TYPE (instance
);
1745 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1746 basetype
= TREE_TYPE (basetype
);
1747 if (! (name
== basetype
1748 || (IS_AGGR_TYPE (basetype
)
1749 && name
== constructor_name (basetype
))
1750 || basetype
== get_type_value (name
)))
1752 cp_error ("destructor name `~%D' does not match type `%T' of expression",
1754 return cp_convert (void_type_node
, instance
);
1757 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1758 return cp_convert (void_type_node
, instance
);
1759 instance
= default_conversion (instance
);
1760 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1761 return build_delete (build_pointer_type (basetype
),
1762 instance_ptr
, integer_two_node
,
1763 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0);
1766 if (flag_ansi_overloading
)
1767 return build_new_method_call (instance
, name
, parms
, basetype_path
, flags
);
1772 /* Initialize name for error reporting. */
1773 if (IDENTIFIER_OPNAME_P (name
) && ! IDENTIFIER_TYPENAME_P (name
))
1775 char *p
= operator_name_string (name
);
1776 xref_name
= (char *)alloca (strlen (p
) + 10);
1777 sprintf (xref_name
, "operator %s", p
);
1779 else if (TREE_CODE (name
) == SCOPE_REF
)
1780 xref_name
= IDENTIFIER_POINTER (TREE_OPERAND (name
, 1));
1782 xref_name
= IDENTIFIER_POINTER (name
);
1784 GNU_xref_call (current_function_decl
, xref_name
);
1787 if (instance
== NULL_TREE
)
1789 basetype
= NULL_TREE
;
1790 /* Check cases where this is really a call to raise
1792 if (current_class_type
&& TREE_CODE (name
) == IDENTIFIER_NODE
)
1794 basetype
= purpose_member (name
, CLASSTYPE_TAGS (current_class_type
));
1796 basetype
= TREE_VALUE (basetype
);
1798 else if (TREE_CODE (name
) == SCOPE_REF
1799 && TREE_CODE (TREE_OPERAND (name
, 0)) == IDENTIFIER_NODE
)
1801 if (! is_aggr_typedef (TREE_OPERAND (name
, 0), 1))
1802 return error_mark_node
;
1803 basetype
= purpose_member (TREE_OPERAND (name
, 1),
1804 CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name
, 0))));
1806 basetype
= TREE_VALUE (basetype
);
1809 if (basetype
!= NULL_TREE
)
1811 /* call to a constructor... */
1812 else if (basetype_path
)
1814 basetype
= BINFO_TYPE (basetype_path
);
1815 if (name
== TYPE_IDENTIFIER (basetype
))
1816 name
= ctor_identifier
;
1818 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1820 basetype
= IDENTIFIER_TYPE_VALUE (name
);
1821 name
= ctor_identifier
;
1825 tree typedef_name
= lookup_name (name
, 1);
1826 if (typedef_name
&& TREE_CODE (typedef_name
) == TYPE_DECL
)
1828 /* Canonicalize the typedef name. */
1829 basetype
= TREE_TYPE (typedef_name
);
1830 name
= ctor_identifier
;
1834 cp_error ("no constructor named `%T' in scope",
1836 return error_mark_node
;
1840 if (! IS_AGGR_TYPE (basetype
))
1843 if ((flags
& LOOKUP_COMPLAIN
) && basetype
!= error_mark_node
)
1844 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1845 name
, instance
, basetype
);
1847 return error_mark_node
;
1850 else if (instance
== current_class_ref
|| instance
== current_class_ptr
)
1852 /* When doing initialization, we side-effect the TREE_TYPE of
1853 current_class_ref, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */
1854 basetype
= TREE_TYPE (current_class_ref
);
1856 /* Anything manifestly `this' in constructors and destructors
1857 has a known type, so virtual function tables are not needed. */
1858 if (TYPE_VIRTUAL_P (basetype
)
1859 && !(flags
& LOOKUP_NONVIRTUAL
))
1860 need_vtbl
= (dtor_label
|| ctor_label
)
1861 ? unneeded
: maybe_needed
;
1863 /* If `this' is a signature pointer and `name' is not a constructor,
1864 we are calling a signature member function. In that case, set the
1865 `basetype' to the signature type and dereference the `optr' field. */
1866 if (IS_SIGNATURE_POINTER (basetype
)
1867 && TYPE_IDENTIFIER (basetype
) != name
)
1869 basetype
= SIGNATURE_TYPE (basetype
);
1870 instance_ptr
= instance
;
1871 basetype_path
= TYPE_BINFO (basetype
);
1875 instance
= current_class_ref
;
1876 instance_ptr
= current_class_ptr
;
1877 basetype_path
= TYPE_BINFO (current_class_type
);
1879 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1884 else if (TREE_CODE (instance
) == RESULT_DECL
)
1886 basetype
= TREE_TYPE (instance
);
1887 /* Should we ever have to make a virtual function reference
1888 from a RESULT_DECL, know that it must be of fixed type
1889 within the scope of this function. */
1890 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1891 need_vtbl
= maybe_needed
;
1892 instance_ptr
= build1 (ADDR_EXPR
, build_pointer_type (basetype
), instance
);
1896 /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */
1897 tree inst_ptr_basetype
;
1900 = (TREE_CODE (instance
) == INDIRECT_REF
1901 && TREE_CODE (TREE_OPERAND (instance
, 0)) == NOP_EXPR
1902 && TREE_OPERAND (TREE_OPERAND (instance
, 0), 0) == error_mark_node
);
1904 if (TREE_CODE (instance
) == OFFSET_REF
)
1905 instance
= resolve_offset_ref (instance
);
1907 /* the base type of an instance variable is pointer to class */
1908 basetype
= TREE_TYPE (instance
);
1910 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1912 basetype
= TREE_TYPE (basetype
);
1913 if (! IS_AGGR_TYPE (basetype
))
1914 goto non_aggr_error
;
1915 /* Call to convert not needed because we are remaining
1916 within the same type. */
1917 instance_ptr
= build1 (NOP_EXPR
, build_pointer_type (basetype
),
1919 inst_ptr_basetype
= TYPE_MAIN_VARIANT (basetype
);
1923 if (! IS_AGGR_TYPE (basetype
)
1924 && ! (TYPE_LANG_SPECIFIC (basetype
)
1925 && (IS_SIGNATURE_POINTER (basetype
)
1926 || IS_SIGNATURE_REFERENCE (basetype
))))
1927 goto non_aggr_error
;
1929 /* If `instance' is a signature pointer/reference and `name' is
1930 not a constructor, we are calling a signature member function.
1931 In that case set the `basetype' to the signature type. */
1932 if ((IS_SIGNATURE_POINTER (basetype
)
1933 || IS_SIGNATURE_REFERENCE (basetype
))
1934 && TYPE_IDENTIFIER (basetype
) != name
)
1935 basetype
= SIGNATURE_TYPE (basetype
);
1937 basetype
= complete_type (basetype
);
1939 if ((IS_SIGNATURE (basetype
)
1940 && (instance_ptr
= instance
))
1941 || (lvalue_p (instance
)
1942 && (instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0)))
1943 || (instance_ptr
= unary_complex_lvalue (ADDR_EXPR
, instance
)))
1945 if (instance_ptr
== error_mark_node
)
1946 return error_mark_node
;
1948 else if (TREE_CODE (instance
) == NOP_EXPR
1949 || TREE_CODE (instance
) == CONSTRUCTOR
)
1951 /* A cast is not an lvalue. Initialize a fresh temp
1952 with the value we are casting from, and proceed with
1953 that temporary. We can't cast to a reference type,
1954 so that simplifies the initialization to something
1956 tree temp
= get_temp_name (TREE_TYPE (instance
), 0);
1957 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
1958 expand_aggr_init (temp
, instance
, 0, flags
);
1961 store_init_value (temp
, instance
);
1962 expand_decl_init (temp
);
1965 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1969 if (TREE_CODE (instance
) != CALL_EXPR
)
1970 my_friendly_abort (125);
1971 if (TYPE_NEEDS_CONSTRUCTING (basetype
))
1972 instance
= build_cplus_new (basetype
, instance
);
1975 instance
= get_temp_name (basetype
, 0);
1976 TREE_ADDRESSABLE (instance
) = 1;
1978 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1980 /* @@ Should we call comp_target_types here? */
1981 if (IS_SIGNATURE (basetype
))
1982 inst_ptr_basetype
= basetype
;
1984 inst_ptr_basetype
= TREE_TYPE (TREE_TYPE (instance_ptr
));
1985 if (TYPE_MAIN_VARIANT (basetype
) == TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1986 basetype
= inst_ptr_basetype
;
1989 instance_ptr
= cp_convert (build_pointer_type (basetype
), instance_ptr
);
1990 if (instance_ptr
== error_mark_node
)
1991 return error_mark_node
;
1995 /* After converting `instance_ptr' above, `inst_ptr_basetype' was
1996 not updated, so we use `basetype' instead. */
1997 if (basetype_path
== NULL_TREE
1998 && IS_SIGNATURE (basetype
))
1999 basetype_path
= TYPE_BINFO (basetype
);
2000 else if (basetype_path
== NULL_TREE
2001 || (BINFO_TYPE (basetype_path
)
2002 != TYPE_MAIN_VARIANT (inst_ptr_basetype
)))
2003 basetype_path
= TYPE_BINFO (inst_ptr_basetype
);
2005 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
2009 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
2011 if (TREE_SIDE_EFFECTS (instance_ptr
))
2013 /* This action is needed because the instance is needed
2014 for providing the base of the virtual function table.
2015 Without using a SAVE_EXPR, the function we are building
2016 may be called twice, or side effects on the instance
2017 variable (such as a post-increment), may happen twice. */
2018 instance_ptr
= save_expr (instance_ptr
);
2019 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2021 else if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
2023 /* This happens when called for operator new (). */
2024 instance
= build_indirect_ref (instance
, NULL_PTR
);
2027 need_vtbl
= maybe_needed
;
2031 if (save_name
== ctor_identifier
)
2032 save_name
= TYPE_IDENTIFIER (basetype
);
2034 if (TYPE_SIZE (complete_type (basetype
)) == 0)
2036 /* This is worth complaining about, I think. */
2037 cp_error ("cannot lookup method in incomplete type `%T'", basetype
);
2038 return error_mark_node
;
2041 save_basetype
= TYPE_MAIN_VARIANT (basetype
);
2043 parmtypes
= default_parm_conversions (parms
, &last
);
2044 if (parmtypes
== error_mark_node
)
2046 return error_mark_node
;
2049 if (instance
&& IS_SIGNATURE (basetype
))
2051 /* @@ Should this be the constp/volatilep flags for the optr field
2052 of the signature pointer? */
2053 constp
= TYPE_READONLY (basetype
);
2054 volatilep
= TYPE_VOLATILE (basetype
);
2055 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2059 /* TREE_READONLY (instance) fails for references. */
2060 constp
= TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2061 volatilep
= TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2062 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2066 /* Raw constructors are always in charge. */
2067 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2068 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2070 flags
|= LOOKUP_HAS_IN_CHARGE
;
2071 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
2072 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
2077 instance_ptr
= build_int_2 (0, 0);
2078 TREE_TYPE (instance_ptr
) = build_pointer_type (basetype
);
2079 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2082 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (instance_ptr
), parmtypes
);
2084 if (last
== NULL_TREE
)
2087 /* Look up function name in the structure type definition. */
2089 /* FIXME Axe most of this now? */
2090 if ((IDENTIFIER_HAS_TYPE_VALUE (name
)
2091 && ! IDENTIFIER_OPNAME_P (name
)
2092 && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name
)))
2093 || name
== constructor_name (basetype
)
2094 || name
== ctor_identifier
)
2096 tree tmp
= NULL_TREE
;
2097 if (IDENTIFIER_TYPE_VALUE (name
) == basetype
2098 || name
== constructor_name (basetype
)
2099 || name
== ctor_identifier
)
2100 tmp
= TYPE_BINFO (basetype
);
2102 tmp
= get_binfo (IDENTIFIER_TYPE_VALUE (name
), basetype
, 0);
2104 if (tmp
!= NULL_TREE
)
2106 name_kind
= "constructor";
2108 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2109 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2111 /* Constructors called for initialization
2112 only are never in charge. */
2115 flags
|= LOOKUP_HAS_IN_CHARGE
;
2116 tmplist
= tree_cons (NULL_TREE
, integer_zero_node
,
2117 TREE_CHAIN (parms
));
2118 TREE_CHAIN (parms
) = tmplist
;
2119 tmplist
= tree_cons (NULL_TREE
, integer_type_node
, TREE_CHAIN (parmtypes
));
2120 TREE_CHAIN (parmtypes
) = tmplist
;
2122 basetype
= BINFO_TYPE (tmp
);
2125 name_kind
= "method";
2128 name_kind
= "method";
2130 if (basetype_path
== NULL_TREE
2131 || BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (basetype
))
2132 basetype_path
= TYPE_BINFO (basetype
);
2133 result
= lookup_fnfields (basetype_path
, name
,
2134 (flags
& LOOKUP_COMPLAIN
));
2135 if (result
== error_mark_node
)
2136 return error_mark_node
;
2138 for (pass
= 0; pass
< 2; pass
++)
2140 struct candidate
*candidates
;
2141 struct candidate
*cp
;
2150 = (struct candidate
*) alloca ((ever_seen
+1)
2151 * sizeof (struct candidate
));
2152 bzero ((char *) candidates
, (ever_seen
+ 1) * sizeof (struct candidate
));
2154 len
= list_length (parms
);
2157 /* First see if a global function has a shot at it. */
2158 if (flags
& LOOKUP_GLOBAL
)
2161 tree parm
= instance_ptr
;
2163 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
)
2164 parm
= convert_from_reference (parm
);
2165 else if (TREE_CODE (TREE_TYPE (parm
)) == POINTER_TYPE
)
2166 parm
= build_indirect_ref (parm
, "friendifying parms (compiler error)");
2168 my_friendly_abort (167);
2170 friend_parms
= tree_cons (NULL_TREE
, parm
, TREE_CHAIN (parms
));
2173 cp
->harshness
= (struct harshness_code
*)
2174 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2176 result
= build_overload_call_real (name
, friend_parms
, 0, cp
, 1);
2178 /* If it turns out to be the one we were actually looking for
2179 (it was probably a friend function), the return the
2181 if (TREE_CODE (result
) == CALL_EXPR
)
2184 while ((cp
->h
.code
& EVIL_CODE
) == 0)
2186 /* non-standard uses: set the field to 0 to indicate
2187 we are using a non-member function. */
2189 if (cp
->harshness
[len
].distance
== 0
2190 && cp
->h
.code
< best
)
2199 /* We have a hit (of sorts). If the parameter list is
2200 "error_mark_node", or some variant thereof, it won't
2201 match any methods. Since we have verified that the is
2202 some method vaguely matching this one (in name at least),
2205 Don't stop for friends, however. */
2206 basetype_path
= TREE_PURPOSE (baselink
);
2208 function
= TREE_VALUE (baselink
);
2209 if (TREE_CODE (basetype_path
) == TREE_LIST
)
2210 basetype_path
= TREE_VALUE (basetype_path
);
2211 basetype
= BINFO_TYPE (basetype_path
);
2213 for (; function
; function
= DECL_CHAIN (function
))
2215 #ifdef GATHER_STATISTICS
2216 n_inner_fields_searched
++;
2220 found_fns
= tree_cons (NULL_TREE
, function
, found_fns
);
2222 /* Not looking for friends here. */
2223 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
2224 && ! DECL_STATIC_FUNCTION_P (function
))
2229 tree these_parms
= parms
;
2231 #ifdef GATHER_STATISTICS
2232 n_inner_fields_searched
++;
2235 cp
->harshness
= (struct harshness_code
*)
2236 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2238 if (DECL_STATIC_FUNCTION_P (function
))
2239 these_parms
= TREE_CHAIN (these_parms
);
2240 compute_conversion_costs (function
, these_parms
, cp
, len
);
2242 if ((cp
->h
.code
& EVIL_CODE
) == 0)
2244 cp
->u
.field
= function
;
2245 cp
->function
= function
;
2246 cp
->basetypes
= basetype_path
;
2248 /* Don't allow non-converting constructors to convert. */
2249 if (flags
& LOOKUP_ONLYCONVERTING
2250 && DECL_LANG_SPECIFIC (function
)
2251 && DECL_NONCONVERTING_P (function
))
2254 /* No "two-level" conversions. */
2255 if (flags
& LOOKUP_NO_CONVERSION
2256 && (cp
->h
.code
& USER_CODE
))
2267 tree igv
= lookup_name_nonclass (name
);
2269 /* No exact match could be found. Now try to find match
2270 using default conversions. */
2271 if ((flags
& LOOKUP_GLOBAL
) && igv
)
2273 if (TREE_CODE (igv
) == FUNCTION_DECL
)
2275 else if (TREE_CODE (igv
) == TREE_LIST
)
2276 ever_seen
+= count_functions (igv
);
2281 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2282 == LOOKUP_SPECULATIVELY
)
2285 TREE_CHAIN (last
) = void_list_node
;
2286 if (flags
& LOOKUP_GLOBAL
)
2287 cp_error ("no global or member function `%D(%A)' defined",
2288 save_name
, parmtypes
);
2290 cp_error ("no member function `%T::%D(%A)' defined",
2291 save_basetype
, save_name
, TREE_CHAIN (parmtypes
));
2292 return error_mark_node
;
2297 if (cp
- candidates
!= 0)
2299 /* Rank from worst to best. Then cp will point to best one.
2300 Private fields have their bits flipped. For unsigned
2301 numbers, this should make them look very large.
2302 If the best alternate has a (signed) negative value,
2303 then all we ever saw were private members. */
2304 if (cp
- candidates
> 1)
2306 int n_candidates
= cp
- candidates
;
2307 extern int warn_synth
;
2308 TREE_VALUE (parms
) = instance_ptr
;
2309 cp
= ideal_candidate (candidates
, n_candidates
, len
);
2310 if (cp
== (struct candidate
*)0)
2312 if (flags
& LOOKUP_COMPLAIN
)
2314 TREE_CHAIN (last
) = void_list_node
;
2315 cp_error ("call of overloaded %s `%D(%A)' is ambiguous",
2316 name_kind
, save_name
, TREE_CHAIN (parmtypes
));
2317 print_n_candidates (candidates
, n_candidates
);
2319 return error_mark_node
;
2321 if (cp
->h
.code
& EVIL_CODE
)
2322 return error_mark_node
;
2324 && DECL_NAME (cp
->function
) == ansi_opname
[MODIFY_EXPR
]
2325 && DECL_ARTIFICIAL (cp
->function
)
2326 && n_candidates
== 2)
2328 cp_warning ("using synthesized `%#D' for copy assignment",
2330 cp_warning_at (" where cfront would use `%#D'",
2331 candidates
->function
);
2334 else if (cp
[-1].h
.code
& EVIL_CODE
)
2336 if (flags
& LOOKUP_COMPLAIN
)
2337 cp_error ("ambiguous type conversion requested for %s `%D'",
2338 name_kind
, save_name
);
2339 return error_mark_node
;
2344 /* The global function was the best, so use it. */
2345 if (cp
->u
.field
== 0)
2347 /* We must convert the instance pointer into a reference type.
2348 Global overloaded functions can only either take
2349 aggregate objects (which come for free from references)
2350 or reference data types anyway. */
2351 TREE_VALUE (parms
) = copy_node (instance_ptr
);
2352 TREE_TYPE (TREE_VALUE (parms
)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2353 return build_function_call (cp
->function
, parms
);
2356 function
= cp
->function
;
2357 basetype_path
= cp
->basetypes
;
2358 if (! DECL_STATIC_FUNCTION_P (function
))
2359 TREE_VALUE (parms
) = cp
->arg
;
2360 goto found_and_maybe_warn
;
2363 if (flags
& (LOOKUP_COMPLAIN
|LOOKUP_SPECULATIVELY
))
2365 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2366 == LOOKUP_SPECULATIVELY
)
2369 if (DECL_STATIC_FUNCTION_P (cp
->function
))
2370 parms
= TREE_CHAIN (parms
);
2373 if (flags
& LOOKUP_SPECULATIVELY
)
2375 if (static_call_context
2376 && TREE_CODE (TREE_TYPE (cp
->function
)) == METHOD_TYPE
)
2377 cp_error ("object missing in call to `%D'", cp
->function
);
2378 else if (ever_seen
> 1)
2380 TREE_CHAIN (last
) = void_list_node
;
2381 cp_error ("no matching function for call to `%T::%D (%A)%V'",
2382 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (instance_ptr
))),
2383 save_name
, TREE_CHAIN (parmtypes
),
2384 TREE_TYPE (TREE_TYPE (instance_ptr
)));
2385 TREE_CHAIN (last
) = NULL_TREE
;
2386 print_candidates (found_fns
);
2389 report_type_mismatch (cp
, parms
, name_kind
);
2390 return error_mark_node
;
2393 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2396 cp_error ("%T has no method named %D", save_basetype
, save_name
);
2397 return error_mark_node
;
2403 found_and_maybe_warn
:
2404 if ((cp
->harshness
[0].code
& CONST_CODE
)
2405 /* 12.1p2: Constructors can be called for const objects. */
2406 && ! DECL_CONSTRUCTOR_P (cp
->function
))
2408 if (flags
& LOOKUP_COMPLAIN
)
2410 cp_error_at ("non-const member function `%D'", cp
->function
);
2411 error ("called for const object at this point in file");
2413 /* Not good enough for a match. */
2415 return error_mark_node
;
2419 /* Silently return error_mark_node. */
2420 return error_mark_node
;
2423 if (flags
& LOOKUP_PROTECT
)
2424 access
= compute_access (basetype_path
, function
);
2426 if (access
== access_private_node
)
2428 if (flags
& LOOKUP_COMPLAIN
)
2430 cp_error_at ("%s `%+#D' is %s", name_kind
, function
,
2431 TREE_PRIVATE (function
) ? "private"
2432 : "from private base class");
2433 error ("within this context");
2435 return error_mark_node
;
2437 else if (access
== access_protected_node
)
2439 if (flags
& LOOKUP_COMPLAIN
)
2441 cp_error_at ("%s `%+#D' %s", name_kind
, function
,
2442 TREE_PROTECTED (function
) ? "is protected"
2443 : "has protected accessibility");
2444 error ("within this context");
2446 return error_mark_node
;
2449 /* From here on down, BASETYPE is the type that INSTANCE_PTR's
2450 type (if it exists) is a pointer to. */
2452 if (DECL_ABSTRACT_VIRTUAL_P (function
)
2453 && instance
== current_class_ref
2454 && DECL_CONSTRUCTOR_P (current_function_decl
)
2455 && ! (flags
& LOOKUP_NONVIRTUAL
)
2456 && value_member (function
, get_abstract_virtuals (basetype
)))
2457 cp_error ("abstract virtual `%#D' called from constructor", function
);
2459 if (IS_SIGNATURE (basetype
))
2461 if (static_call_context
)
2463 cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
2464 basetype
, save_name
);
2465 return error_mark_node
;
2467 return build_signature_method_call (function
, parms
);
2470 function
= DECL_MAIN_VARIANT (function
);
2471 mark_used (function
);
2473 fntype
= TREE_TYPE (function
);
2474 if (TREE_CODE (fntype
) == POINTER_TYPE
)
2475 fntype
= TREE_TYPE (fntype
);
2476 basetype
= DECL_CLASS_CONTEXT (function
);
2478 /* If we are referencing a virtual function from an object
2479 of effectively static type, then there is no need
2480 to go through the virtual function table. */
2481 if (need_vtbl
== maybe_needed
)
2483 int fixed_type
= resolves_to_fixed_type_p (instance
, 0);
2485 if (all_virtual
== 1
2486 && DECL_VINDEX (function
)
2487 && may_be_remote (basetype
))
2489 else if (DECL_VINDEX (function
))
2490 need_vtbl
= fixed_type
? unneeded
: needed
;
2492 need_vtbl
= not_needed
;
2495 if (TREE_CODE (fntype
) == METHOD_TYPE
&& static_call_context
2496 && !DECL_CONSTRUCTOR_P (function
))
2498 /* Let's be nasty to the user now, and give reasonable
2500 instance_ptr
= current_class_ptr
;
2503 if (basetype
!= current_class_type
)
2505 if (basetype
== error_mark_node
)
2506 return error_mark_node
;
2509 if (orig_basetype
!= NULL_TREE
)
2510 error_not_base_type (orig_basetype
, current_class_type
);
2512 error_not_base_type (function
, current_class_type
);
2513 return error_mark_node
;
2517 /* Only allow a static member function to call another static member
2519 else if (DECL_LANG_SPECIFIC (function
)
2520 && !DECL_STATIC_FUNCTION_P (function
))
2522 cp_error ("cannot call member function `%D' without object",
2524 return error_mark_node
;
2528 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2530 if (TYPE_SIZE (complete_type (value_type
)) == 0)
2532 if (flags
& LOOKUP_COMPLAIN
)
2533 incomplete_type_error (0, value_type
);
2534 return error_mark_node
;
2537 if (DECL_STATIC_FUNCTION_P (function
))
2538 parms
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2539 TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
);
2540 else if (need_vtbl
== unneeded
)
2542 int sub_flags
= DECL_CONSTRUCTOR_P (function
) ? flags
: LOOKUP_NORMAL
;
2543 basetype
= TREE_TYPE (instance
);
2544 if (TYPE_METHOD_BASETYPE (TREE_TYPE (function
))
2545 != TYPE_MAIN_VARIANT (basetype
))
2547 basetype
= DECL_CLASS_CONTEXT (function
);
2548 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
2549 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2551 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2552 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, sub_flags
));
2556 if ((flags
& LOOKUP_NONVIRTUAL
) == 0)
2557 basetype
= DECL_CONTEXT (function
);
2559 /* First parm could be integer_zerop with casts like
2560 ((Object*)0)->Object::IsA() */
2561 if (!integer_zerop (TREE_VALUE (parms
)))
2563 /* Since we can't have inheritance with a union, doing get_binfo
2564 on it won't work. We do all the convert_pointer_to_real
2565 stuff to handle MI correctly...for unions, that's not
2566 an issue, so we must short-circuit that extra work here. */
2567 tree tmp
= TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)));
2568 if (tmp
!= NULL_TREE
&& TREE_CODE (tmp
) == UNION_TYPE
)
2569 instance_ptr
= TREE_VALUE (parms
);
2572 tree binfo
= get_binfo (basetype
,
2573 TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
))),
2575 instance_ptr
= convert_pointer_to_real (binfo
, TREE_VALUE (parms
));
2578 = convert_pointer_to (build_type_variant (basetype
,
2582 if (TREE_CODE (instance_ptr
) == COND_EXPR
)
2584 instance_ptr
= save_expr (instance_ptr
);
2585 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2587 else if (TREE_CODE (instance_ptr
) == NOP_EXPR
2588 && TREE_CODE (TREE_OPERAND (instance_ptr
, 0)) == ADDR_EXPR
2589 && TREE_OPERAND (TREE_OPERAND (instance_ptr
, 0), 0) == instance
)
2591 /* The call to `convert_pointer_to' may return error_mark_node. */
2592 else if (instance_ptr
== error_mark_node
)
2593 return instance_ptr
;
2594 else if (instance
== NULL_TREE
2595 || TREE_CODE (instance
) != INDIRECT_REF
2596 || TREE_OPERAND (instance
, 0) != instance_ptr
)
2597 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2599 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2600 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
));
2603 if (parms
== error_mark_node
2604 || (parms
&& TREE_CHAIN (parms
) == error_mark_node
))
2605 return error_mark_node
;
2607 if (need_vtbl
== needed
)
2609 function
= build_vfn_ref (&TREE_VALUE (parms
), instance
,
2610 DECL_VINDEX (function
));
2611 TREE_TYPE (function
) = build_pointer_type (fntype
);
2614 if (TREE_CODE (function
) == FUNCTION_DECL
)
2615 GNU_xref_call (current_function_decl
,
2616 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)));
2618 result
= build_call (function
, value_type
, parms
);
2619 if (IS_AGGR_TYPE (value_type
))
2620 result
= build_cplus_new (value_type
, result
);
2621 result
= convert_from_reference (result
);
2625 /* Similar to `build_method_call', but for overloaded non-member functions.
2626 The name of this function comes through NAME. The name depends
2629 Note that this function must handle simple `C' promotions,
2630 as well as variable numbers of arguments (...), and
2631 default arguments to boot.
2633 If the overloading is successful, we return a tree node which
2634 contains the call to the function.
2636 If overloading produces candidates which are probable, but not definite,
2637 we hold these candidates. If FINAL_CP is non-zero, then we are free
2638 to assume that final_cp points to enough storage for all candidates that
2639 this function might generate. The `harshness' array is preallocated for
2640 the first candidate, but not for subsequent ones.
2642 Note that the DECL_RTL of FUNCTION must be made to agree with this
2643 function's new name. */
2646 build_overload_call_real (fnname
, parms
, flags
, final_cp
, require_complete
)
2649 struct candidate
*final_cp
;
2650 int require_complete
;
2652 /* must check for overloading here */
2653 tree functions
, function
;
2654 tree parmtypes
, last
;
2655 register tree outer
;
2657 int parmlength
= list_length (parms
);
2659 struct candidate
*candidates
, *cp
;
2663 final_cp
[0].h
.code
= 0;
2664 final_cp
[0].h
.distance
= 0;
2665 final_cp
[0].function
= 0;
2667 final_cp
[1].h
.code
= EVIL_CODE
;
2670 parmtypes
= default_parm_conversions (parms
, &last
);
2671 if (parmtypes
== error_mark_node
)
2674 final_cp
->h
.code
= EVIL_CODE
;
2675 return error_mark_node
;
2679 TREE_CHAIN (last
) = void_list_node
;
2681 parmtypes
= void_list_node
;
2683 if (is_overloaded_fn (fnname
))
2686 if (TREE_CODE (fnname
) == TREE_LIST
)
2687 fnname
= TREE_PURPOSE (functions
);
2688 else if (TREE_CODE (fnname
) == FUNCTION_DECL
)
2689 fnname
= DECL_NAME (functions
);
2692 functions
= lookup_name_nonclass (fnname
);
2694 if (functions
== NULL_TREE
)
2696 if (flags
& LOOKUP_SPECULATIVELY
)
2698 if (flags
& LOOKUP_COMPLAIN
)
2699 error ("only member functions apply");
2701 final_cp
->h
.code
= EVIL_CODE
;
2702 return error_mark_node
;
2705 if (TREE_CODE (functions
) == FUNCTION_DECL
&& ! IDENTIFIER_OPNAME_P (fnname
))
2707 functions
= DECL_MAIN_VARIANT (functions
);
2710 /* We are just curious whether this is a viable alternative or
2712 compute_conversion_costs (functions
, parms
, final_cp
, parmlength
);
2716 return build_function_call_real (functions
, parms
, 1, flags
);
2719 if (TREE_CODE (functions
) == TREE_LIST
2720 && TREE_VALUE (functions
) == NULL_TREE
)
2722 if (flags
& LOOKUP_SPECULATIVELY
)
2725 if (flags
& LOOKUP_COMPLAIN
)
2726 cp_error ("function `%D' declared overloaded, but no instances of that function declared",
2727 TREE_PURPOSE (functions
));
2729 final_cp
->h
.code
= EVIL_CODE
;
2730 return error_mark_node
;
2733 length
= count_functions (functions
);
2736 candidates
= final_cp
;
2740 = (struct candidate
*)alloca ((length
+1) * sizeof (struct candidate
));
2741 bzero ((char *) candidates
, (length
+ 1) * sizeof (struct candidate
));
2746 my_friendly_assert (is_overloaded_fn (functions
), 169);
2748 functions
= get_first_fn (functions
);
2750 /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
2751 for (outer
= functions
; outer
; outer
= DECL_CHAIN (outer
))
2753 int template_cost
= 0;
2755 if (TREE_CODE (function
) != FUNCTION_DECL
2756 && ! (TREE_CODE (function
) == TEMPLATE_DECL
2757 && TREE_CODE (DECL_TEMPLATE_RESULT (function
)) == FUNCTION_DECL
))
2759 enum tree_code code
= TREE_CODE (function
);
2760 if (code
== TEMPLATE_DECL
)
2761 code
= TREE_CODE (DECL_TEMPLATE_RESULT (function
));
2762 if (code
== CONST_DECL
)
2764 ("enumeral value `%D' conflicts with function of same name",
2766 else if (code
== VAR_DECL
)
2768 if (TREE_STATIC (function
))
2770 ("variable `%D' conflicts with function of same name",
2774 ("constant field `%D' conflicts with function of same name",
2777 else if (code
== TYPE_DECL
)
2780 my_friendly_abort (2);
2781 error ("at this point in file");
2784 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2786 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function
));
2787 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
2790 i
= type_unification (DECL_TEMPLATE_PARMS (function
), targs
,
2791 TYPE_ARG_TYPES (TREE_TYPE (function
)),
2792 parms
, &template_cost
, 0, 0);
2795 function
= instantiate_template (function
, targs
);
2796 if (function
== error_mark_node
)
2801 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2803 /* Unconverted template -- failed match. */
2804 cp
->function
= function
;
2806 cp
->h
.code
= EVIL_CODE
;
2810 struct candidate
*cp2
;
2812 /* Check that this decl is not the same as a function that's in
2813 the list due to some template instantiation. */
2816 if (cp2
->function
== function
)
2820 if (cp2
->function
== function
)
2823 function
= DECL_MAIN_VARIANT (function
);
2825 /* Can't use alloca here, since result might be
2826 passed to calling function. */
2827 cp
->h_len
= parmlength
;
2828 cp
->harshness
= (struct harshness_code
*)
2829 oballoc ((parmlength
+ 1) * sizeof (struct harshness_code
));
2831 compute_conversion_costs (function
, parms
, cp
, parmlength
);
2833 /* Make sure this is clear as well. */
2834 cp
->h
.int_penalty
+= template_cost
;
2836 if ((cp
[0].h
.code
& EVIL_CODE
) == 0)
2838 cp
[1].h
.code
= EVIL_CODE
;
2844 if (cp
- candidates
)
2846 tree rval
= error_mark_node
;
2849 cp
[0].h
.code
= EVIL_CODE
;
2850 if (cp
- candidates
> 1)
2852 struct candidate
*best_cp
2853 = ideal_candidate (candidates
, cp
- candidates
, parmlength
);
2854 if (best_cp
== (struct candidate
*)0)
2856 if (flags
& LOOKUP_COMPLAIN
)
2858 cp_error ("call of overloaded `%D' is ambiguous", fnname
);
2859 print_n_candidates (candidates
, cp
- candidates
);
2861 return error_mark_node
;
2864 rval
= best_cp
->function
;
2869 if (cp
->h
.code
& EVIL_CODE
)
2871 if (flags
& LOOKUP_COMPLAIN
)
2872 error ("type conversion ambiguous");
2875 rval
= cp
->function
;
2881 return build_function_call_real (rval
, parms
, require_complete
, flags
);
2884 if (flags
& LOOKUP_SPECULATIVELY
)
2887 if (flags
& LOOKUP_COMPLAIN
)
2888 report_type_mismatch (cp
, parms
, "function",
2889 decl_as_string (cp
->function
, 1));
2891 return error_mark_node
;
2894 /* This requires a complete type on the result of the call. */
2897 build_overload_call (fnname
, parms
, flags
)
2901 return build_overload_call_real (fnname
, parms
, flags
, (struct candidate
*)0, 1);
2904 /* New overloading code. */
2906 struct z_candidate
{
2913 struct z_candidate
*next
;
2916 #define IDENTITY_RANK 0
2917 #define EXACT_RANK 1
2918 #define PROMO_RANK 2
2920 #define PBOOL_RANK 4
2922 #define ELLIPSIS_RANK 6
2925 #define ICS_RANK(NODE) \
2926 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
2927 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
2928 : ICS_USER_FLAG (NODE) ? USER_RANK \
2929 : ICS_STD_RANK (NODE))
2931 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
2933 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
2934 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
2935 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
2936 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
2938 #define USER_CONV_FN(NODE) TREE_OPERAND (NODE, 1)
2940 static struct z_candidate
* build_user_type_conversion_1 ();
2941 static tree
convert_like ();
2942 static tree
build_over_call ();
2943 static struct z_candidate
* tourney ();
2944 static void enforce_access ();
2951 || integer_zerop (t
) && INTEGRAL_TYPE_P (TREE_TYPE (t
)))
2953 /* Remove this eventually. */
2954 if (! pedantic
&& TREE_TYPE (t
) == ptr_type_node
&& integer_zerop (t
))
2960 build_conv (code
, type
, from
)
2961 enum tree_code code
;
2964 tree t
= build1 (code
, type
, from
);
2965 int rank
= ICS_STD_RANK (from
);
2972 if (rank
< STD_RANK
)
2979 if (rank
< EXACT_RANK
)
2985 ICS_STD_RANK (t
) = rank
;
2986 ICS_USER_FLAG (t
) = ICS_USER_FLAG (from
);
2987 ICS_BAD_FLAG (t
) = ICS_BAD_FLAG (from
);
2995 if (TREE_CODE (t
) == REFERENCE_TYPE
)
3004 if (TREE_CODE (t
) == ARRAY_TYPE
)
3006 return TYPE_MAIN_VARIANT (t
);
3009 /* Returns the standard conversion path (see [conv]) from type FROM to type
3010 TO, if any. For proper handling of null pointer constants, you must
3011 also pass the expression EXPR to convert from. */
3014 standard_conversion (to
, from
, expr
)
3015 tree to
, from
, expr
;
3017 enum tree_code fcode
, tcode
;
3021 if (TREE_CODE (to
) == REFERENCE_TYPE
)
3022 to
= TREE_TYPE (to
);
3023 if (TREE_CODE (from
) == REFERENCE_TYPE
)
3026 from
= TREE_TYPE (from
);
3028 to
= strip_top_quals (to
);
3029 from
= strip_top_quals (from
);
3031 fcode
= TREE_CODE (from
);
3032 tcode
= TREE_CODE (to
);
3034 conv
= build1 (IDENTITY_CONV
, from
, expr
);
3036 if (fcode
== FUNCTION_TYPE
)
3038 from
= build_pointer_type (from
);
3039 fcode
= TREE_CODE (from
);
3040 conv
= build_conv (LVALUE_CONV
, from
, conv
);
3042 else if (fcode
== ARRAY_TYPE
)
3044 from
= build_pointer_type (TREE_TYPE (from
));
3045 fcode
= TREE_CODE (from
);
3046 conv
= build_conv (LVALUE_CONV
, from
, conv
);
3048 else if (fromref
|| (expr
&& real_lvalue_p (expr
)))
3049 conv
= build_conv (RVALUE_CONV
, from
, conv
);
3054 if ((tcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (to
))
3055 && expr
&& null_ptr_cst_p (expr
))
3057 conv
= build_conv (STD_CONV
, to
, conv
);
3059 else if (tcode
== POINTER_TYPE
&& fcode
== POINTER_TYPE
)
3061 enum tree_code ufcode
= TREE_CODE (TREE_TYPE (from
));
3062 enum tree_code utcode
= TREE_CODE (TREE_TYPE (to
));
3063 tree nconv
= NULL_TREE
;
3065 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (from
)),
3066 TYPE_MAIN_VARIANT (TREE_TYPE (to
)), 1))
3068 else if (utcode
== VOID_TYPE
&& ufcode
!= OFFSET_TYPE
3069 && ufcode
!= FUNCTION_TYPE
)
3071 from
= build_pointer_type
3072 (cp_build_type_variant (void_type_node
,
3073 TYPE_READONLY (TREE_TYPE (from
)),
3074 TYPE_VOLATILE (TREE_TYPE (from
))));
3075 nconv
= build_conv (PTR_CONV
, from
, conv
);
3077 else if (ufcode
== OFFSET_TYPE
&& utcode
== OFFSET_TYPE
)
3079 tree fbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (from
));
3080 tree tbase
= TYPE_OFFSET_BASETYPE (TREE_TYPE (to
));
3082 if (DERIVED_FROM_P (fbase
, tbase
)
3083 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (from
))),
3084 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (to
))),
3087 from
= build_offset_type (tbase
, TREE_TYPE (TREE_TYPE (from
)));
3088 from
= build_pointer_type (from
);
3089 nconv
= build_conv (PMEM_CONV
, from
, conv
);
3092 else if (IS_AGGR_TYPE (TREE_TYPE (from
))
3093 && IS_AGGR_TYPE (TREE_TYPE (to
)))
3095 if (DERIVED_FROM_P (TREE_TYPE (to
), TREE_TYPE (from
)))
3097 from
= cp_build_type_variant (TREE_TYPE (to
),
3098 TYPE_READONLY (TREE_TYPE (from
)),
3099 TYPE_VOLATILE (TREE_TYPE (from
)));
3100 from
= build_pointer_type (from
);
3101 nconv
= build_conv (PTR_CONV
, from
, conv
);
3105 if (nconv
&& comptypes (from
, to
, 1))
3107 else if (nconv
&& comp_ptr_ttypes (TREE_TYPE (to
), TREE_TYPE (from
)))
3108 conv
= build_conv (QUAL_CONV
, to
, nconv
);
3109 else if (ptr_reasonably_similar (TREE_TYPE (to
), TREE_TYPE (from
)))
3111 conv
= build_conv (PTR_CONV
, to
, conv
);
3112 ICS_BAD_FLAG (conv
) = 1;
3119 else if (TYPE_PTRMEMFUNC_P (to
) && TYPE_PTRMEMFUNC_P (from
))
3121 tree fromfn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from
));
3122 tree tofn
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to
));
3123 tree fbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn
)));
3124 tree tbase
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn
)));
3126 if (! DERIVED_FROM_P (fbase
, tbase
)
3127 || ! comptypes (TREE_TYPE (fromfn
), TREE_TYPE (tofn
), 1)
3128 || ! compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)),
3129 TREE_CHAIN (TYPE_ARG_TYPES (tofn
)), 1)
3130 || TYPE_READONLY (fbase
) != TYPE_READONLY (tbase
)
3131 || TYPE_VOLATILE (fbase
) != TYPE_VOLATILE (tbase
))
3134 from
= cp_build_type_variant (tbase
, TYPE_READONLY (fbase
),
3135 TYPE_VOLATILE (fbase
));
3136 from
= build_cplus_method_type (from
, TREE_TYPE (fromfn
),
3137 TREE_CHAIN (TYPE_ARG_TYPES (fromfn
)));
3138 from
= build_ptrmemfunc_type (build_pointer_type (from
));
3139 conv
= build_conv (PMEM_CONV
, from
, conv
);
3141 else if (tcode
== BOOLEAN_TYPE
)
3143 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
3144 || fcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (from
)))
3147 conv
= build_conv (STD_CONV
, to
, conv
);
3148 if (fcode
== POINTER_TYPE
|| TYPE_PTRMEMFUNC_P (from
)
3149 && ICS_STD_RANK (conv
) < PBOOL_RANK
)
3150 ICS_STD_RANK (conv
) = PBOOL_RANK
;
3152 /* We don't check for ENUMERAL_TYPE here because there are no standard
3153 conversions to enum type. */
3154 else if (tcode
== INTEGER_TYPE
|| tcode
== BOOLEAN_TYPE
3155 || tcode
== REAL_TYPE
)
3157 if (! (INTEGRAL_CODE_P (fcode
) || fcode
== REAL_TYPE
))
3159 conv
= build_conv (STD_CONV
, to
, conv
);
3161 /* Give this a better rank if it's a promotion. */
3162 if (to
== type_promotes_to (from
)
3163 && ICS_STD_RANK (TREE_OPERAND (conv
, 0)) <= PROMO_RANK
)
3164 ICS_STD_RANK (conv
) = PROMO_RANK
;
3166 else if (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
3167 && DERIVED_FROM_P (to
, from
))
3168 conv
= build_conv (BASE_CONV
, to
, conv
);
3175 /* Returns the conversion path from type FROM to reference type TO for
3176 purposes of reference binding. For lvalue binding, either pass a
3177 reference type to FROM or an lvalue expression to EXPR.
3179 Currently does not distinguish in the generated trees between binding to
3180 an lvalue and a temporary. Should it? */
3183 reference_binding (rto
, rfrom
, expr
, flags
)
3184 tree rto
, rfrom
, expr
;
3189 tree to
= TREE_TYPE (rto
);
3193 if (TREE_CODE (from
) == REFERENCE_TYPE
)
3194 from
= TREE_TYPE (from
);
3195 else if (! expr
|| ! real_lvalue_p (expr
))
3198 related
= (TYPE_MAIN_VARIANT (to
) == TYPE_MAIN_VARIANT (from
)
3199 || (IS_AGGR_TYPE (to
) && IS_AGGR_TYPE (from
)
3200 && DERIVED_FROM_P (to
, from
)));
3202 if (lvalue
&& related
3203 && TYPE_READONLY (to
) >= TYPE_READONLY (from
)
3204 && TYPE_VOLATILE (to
) >= TYPE_VOLATILE (from
))
3206 conv
= build1 (IDENTITY_CONV
, from
, expr
);
3208 if (TYPE_MAIN_VARIANT (to
) == TYPE_MAIN_VARIANT (from
))
3209 conv
= build_conv (REF_BIND
, rto
, conv
);
3212 conv
= build_conv (REF_BIND
, rto
, conv
);
3213 ICS_STD_RANK (conv
) = STD_RANK
;
3221 conv
= standard_conversion (to
, rfrom
, expr
);
3224 conv
= build_conv (REF_BIND
, rto
, conv
);
3226 /* Bind directly to a base subobject of a class rvalue. Do it
3227 after building the conversion for proper handling of ICS_RANK. */
3228 if (TREE_CODE (TREE_OPERAND (conv
, 0)) == BASE_CONV
)
3229 TREE_OPERAND (conv
, 0) = TREE_OPERAND (TREE_OPERAND (conv
, 0), 0);
3232 && ((! (TYPE_READONLY (to
) && ! TYPE_VOLATILE (to
)
3233 && (flags
& LOOKUP_NO_TEMP_BIND
) == 0))
3234 /* If T1 is reference-related to T2, cv1 must be the same
3235 cv-qualification as, or greater cv-qualification than,
3236 cv2; otherwise, the program is ill-formed. */
3238 && (TYPE_READONLY (to
) < TYPE_READONLY (from
)
3239 || TYPE_VOLATILE (to
) < TYPE_VOLATILE (from
)))))
3240 ICS_BAD_FLAG (conv
) = 1;
3246 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
3247 to type TO. The optional expression EXPR may affect the conversion.
3248 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
3252 implicit_conversion (to
, from
, expr
, flags
)
3253 tree to
, from
, expr
;
3257 struct z_candidate
*cand
;
3259 if (expr
&& type_unknown_p (expr
))
3261 expr
= instantiate_type (to
, expr
, 0);
3262 if (expr
== error_mark_node
)
3264 from
= TREE_TYPE (expr
);
3267 if (TREE_CODE (to
) == REFERENCE_TYPE
)
3268 conv
= reference_binding (to
, from
, expr
, flags
);
3270 conv
= standard_conversion (to
, from
, expr
);
3274 else if ((IS_AGGR_TYPE (non_reference (from
))
3275 || IS_AGGR_TYPE (non_reference (to
)))
3276 && (flags
& LOOKUP_NO_CONVERSION
) == 0)
3278 cand
= build_user_type_conversion_1
3279 (to
, expr
, LOOKUP_ONLYCONVERTING
);
3281 conv
= cand
->second_conv
;
3282 if ((! conv
|| ICS_BAD_FLAG (conv
))
3283 && TREE_CODE (to
) == REFERENCE_TYPE
3284 && (flags
& LOOKUP_NO_TEMP_BIND
) == 0)
3286 cand
= build_user_type_conversion_1
3287 (TYPE_MAIN_VARIANT (TREE_TYPE (to
)), expr
, LOOKUP_ONLYCONVERTING
);
3290 if (! TYPE_READONLY (TREE_TYPE (to
))
3291 || TYPE_VOLATILE (TREE_TYPE (to
)))
3292 ICS_BAD_FLAG (cand
->second_conv
) = 1;
3293 if (!conv
|| (ICS_BAD_FLAG (conv
)
3294 > ICS_BAD_FLAG (cand
->second_conv
)))
3295 conv
= build_conv (REF_BIND
, to
, cand
->second_conv
);
3303 /* Create an overload candidate for the function or method FN called with
3304 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
3305 to implicit_conversion. */
3307 static struct z_candidate
*
3308 add_function_candidate (candidates
, fn
, arglist
, flags
)
3309 struct z_candidate
*candidates
;
3313 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
3316 tree parmnode
= parmlist
;
3317 tree argnode
= arglist
;
3319 struct z_candidate
*cand
;
3321 /* The `this' and `in_chrg' arguments to constructors are not considered
3322 in overload resolution. */
3323 if (DECL_CONSTRUCTOR_P (fn
))
3325 parmnode
= TREE_CHAIN (parmnode
);
3326 argnode
= TREE_CHAIN (argnode
);
3327 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
3329 parmnode
= TREE_CHAIN (parmnode
);
3330 argnode
= TREE_CHAIN (argnode
);
3334 len
= list_length (argnode
);
3335 convs
= make_tree_vec (len
);
3337 for (i
= 0; i
< len
; ++i
)
3339 tree arg
= TREE_VALUE (argnode
);
3340 tree argtype
= TREE_TYPE (arg
);
3343 argtype
= cp_build_type_variant
3344 (argtype
, TREE_READONLY (arg
), TREE_THIS_VOLATILE (arg
));
3346 if (parmnode
== void_list_node
)
3349 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
, flags
);
3352 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
3353 ICS_ELLIPSIS_FLAG (t
) = 1;
3356 if (i
== 0 && t
&& TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
3357 && ! DECL_CONSTRUCTOR_P (fn
))
3358 ICS_THIS_FLAG (t
) = 1;
3360 TREE_VEC_ELT (convs
, i
) = t
;
3364 if (ICS_BAD_FLAG (t
))
3368 parmnode
= TREE_CHAIN (parmnode
);
3369 argnode
= TREE_CHAIN (argnode
);
3375 /* Make sure there are default args for the rest of the parms. */
3376 for (; parmnode
&& parmnode
!= void_list_node
;
3377 parmnode
= TREE_CHAIN (parmnode
))
3378 if (! TREE_PURPOSE (parmnode
))
3384 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3387 cand
->convs
= convs
;
3388 cand
->second_conv
= NULL_TREE
;
3389 cand
->viable
= viable
;
3390 cand
->basetype_path
= NULL_TREE
;
3391 cand
->template = NULL_TREE
;
3392 cand
->next
= candidates
;
3397 /* Create an overload candidate for the conversion function FN which will
3398 be invoked for expression OBJ, producing a pointer-to-function which
3399 will in turn be called with the argument list ARGLIST, and add it to
3400 CANDIDATES. FLAGS is passed on to implicit_conversion. */
3402 static struct z_candidate
*
3403 add_conv_candidate (candidates
, fn
, obj
, arglist
)
3404 struct z_candidate
*candidates
;
3405 tree fn
, obj
, arglist
;
3407 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
3408 tree parmlist
= TYPE_ARG_TYPES (TREE_TYPE (totype
));
3409 int i
, len
= list_length (arglist
) + 1;
3410 tree convs
= make_tree_vec (len
);
3411 tree parmnode
= parmlist
;
3412 tree argnode
= arglist
;
3414 struct z_candidate
*cand
;
3415 int flags
= LOOKUP_NORMAL
;
3417 for (i
= 0; i
< len
; ++i
)
3419 tree arg
= i
== 0 ? obj
: TREE_VALUE (argnode
);
3420 tree argtype
= lvalue_type (arg
);
3424 t
= implicit_conversion (totype
, argtype
, arg
, flags
);
3425 else if (parmnode
== void_list_node
)
3428 t
= implicit_conversion (TREE_VALUE (parmnode
), argtype
, arg
, flags
);
3431 t
= build1 (IDENTITY_CONV
, argtype
, arg
);
3432 ICS_ELLIPSIS_FLAG (t
) = 1;
3435 TREE_VEC_ELT (convs
, i
) = t
;
3439 if (ICS_BAD_FLAG (t
))
3446 parmnode
= TREE_CHAIN (parmnode
);
3447 argnode
= TREE_CHAIN (argnode
);
3453 for (; parmnode
&& parmnode
!= void_list_node
;
3454 parmnode
= TREE_CHAIN (parmnode
))
3455 if (! TREE_PURPOSE (parmnode
))
3461 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3464 cand
->convs
= convs
;
3465 cand
->second_conv
= NULL_TREE
;
3466 cand
->viable
= viable
;
3467 cand
->basetype_path
= NULL_TREE
;
3468 cand
->template = NULL_TREE
;
3469 cand
->next
= candidates
;
3474 static struct z_candidate
*
3475 build_builtin_candidate (candidates
, fnname
, type1
, type2
,
3476 args
, argtypes
, flags
)
3477 struct z_candidate
*candidates
;
3478 tree fnname
, type1
, type2
, *args
, *argtypes
;
3484 struct z_candidate
*cand
;
3490 convs
= make_tree_vec (args
[2] ? 3 : (args
[1] ? 2 : 1));
3492 for (i
= 0; i
< 2; ++i
)
3497 t
= implicit_conversion (types
[i
], argtypes
[i
], args
[i
], flags
);
3501 /* We need something for printing the candidate. */
3502 t
= build1 (IDENTITY_CONV
, types
[i
], NULL_TREE
);
3504 else if (ICS_BAD_FLAG (t
))
3506 TREE_VEC_ELT (convs
, i
) = t
;
3509 /* For COND_EXPR we rearranged the arguments; undo that now. */
3512 TREE_VEC_ELT (convs
, 2) = TREE_VEC_ELT (convs
, 1);
3513 TREE_VEC_ELT (convs
, 1) = TREE_VEC_ELT (convs
, 0);
3514 t
= implicit_conversion (boolean_type_node
, argtypes
[2], args
[2], flags
);
3516 TREE_VEC_ELT (convs
, 0) = t
;
3521 cand
= (struct z_candidate
*) oballoc (sizeof (struct z_candidate
));
3524 cand
->convs
= convs
;
3525 cand
->second_conv
= NULL_TREE
;
3526 cand
->viable
= viable
;
3527 cand
->basetype_path
= NULL_TREE
;
3528 cand
->template = NULL_TREE
;
3529 cand
->next
= candidates
;
3538 return TYPE_SIZE (complete_type (t
)) != NULL_TREE
;
3541 /* Create any builtin operator overload candidates for the operator in
3542 question given the converted operand types TYPE1 and TYPE2. The other
3543 args are passed through from add_builtin_candidates to
3544 build_builtin_candidate. */
3546 static struct z_candidate
*
3547 add_builtin_candidate (candidates
, code
, code2
, fnname
, type1
, type2
,
3548 args
, argtypes
, flags
)
3549 struct z_candidate
*candidates
;
3550 enum tree_code code
, code2
;
3551 tree fnname
, type1
, type2
, *args
, *argtypes
;
3556 case POSTINCREMENT_EXPR
:
3557 case POSTDECREMENT_EXPR
:
3558 args
[1] = integer_zero_node
;
3559 type2
= integer_type_node
;
3565 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3566 and VQ is either volatile or empty, there exist candidate operator
3567 functions of the form
3568 VQ T& operator++(VQ T&);
3569 T operator++(VQ T&, int);
3570 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
3571 type other than bool, and VQ is either volatile or empty, there exist
3572 candidate operator functions of the form
3573 VQ T& operator--(VQ T&);
3574 T operator--(VQ T&, int);
3575 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
3576 complete object type, and VQ is either volatile or empty, there exist
3577 candidate operator functions of the form
3578 T*VQ& operator++(T*VQ&);
3579 T*VQ& operator--(T*VQ&);
3580 T* operator++(T*VQ&, int);
3581 T* operator--(T*VQ&, int); */
3583 case POSTDECREMENT_EXPR
:
3584 case PREDECREMENT_EXPR
:
3585 if (TREE_CODE (type1
) == BOOLEAN_TYPE
)
3587 case POSTINCREMENT_EXPR
:
3588 case PREINCREMENT_EXPR
:
3589 if ((ARITHMETIC_TYPE_P (type1
) && TREE_CODE (type1
) != ENUMERAL_TYPE
)
3590 || TYPE_PTROB_P (type1
))
3592 type1
= build_reference_type (type1
);
3597 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
3598 exist candidate operator functions of the form
3602 8 For every function type T, there exist candidate operator functions of
3604 T& operator*(T*); */
3607 if (TREE_CODE (type1
) == POINTER_TYPE
3608 && (TYPE_PTROB_P (type1
)
3609 || TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
))
3613 /* 9 For every type T, there exist candidate operator functions of the form
3616 10For every promoted arithmetic type T, there exist candidate operator
3617 functions of the form
3621 case CONVERT_EXPR
: /* unary + */
3622 if (TREE_CODE (type1
) == POINTER_TYPE
3623 && TREE_CODE (TREE_TYPE (type1
)) != OFFSET_TYPE
)
3626 if (ARITHMETIC_TYPE_P (type1
))
3630 /* 11For every promoted integral type T, there exist candidate operator
3631 functions of the form
3635 if (INTEGRAL_TYPE_P (type1
))
3639 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
3640 is the same type as C2 or is a derived class of C2, T is a complete
3641 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
3642 there exist candidate operator functions of the form
3643 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
3644 where CV12 is the union of CV1 and CV2. */
3647 if (TREE_CODE (type1
) == POINTER_TYPE
3648 && (TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
)))
3650 tree c1
= TREE_TYPE (type1
);
3651 tree c2
= (TYPE_PTRMEMFUNC_P (type2
)
3652 ? TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2
))
3653 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2
)));
3655 if (IS_AGGR_TYPE (c1
) && DERIVED_FROM_P (c2
, c1
)
3656 && (TYPE_PTRMEMFUNC_P (type2
)
3657 || is_complete (TREE_TYPE (TREE_TYPE (type2
)))))
3662 /* 13For every pair of promoted arithmetic types L and R, there exist can-
3663 didate operator functions of the form
3668 bool operator<(L, R);
3669 bool operator>(L, R);
3670 bool operator<=(L, R);
3671 bool operator>=(L, R);
3672 bool operator==(L, R);
3673 bool operator!=(L, R);
3674 where LR is the result of the usual arithmetic conversions between
3677 14For every pair of types T and I, where T is a cv-qualified or cv-
3678 unqualified complete object type and I is a promoted integral type,
3679 there exist candidate operator functions of the form
3680 T* operator+(T*, I);
3681 T& operator[](T*, I);
3682 T* operator-(T*, I);
3683 T* operator+(I, T*);
3684 T& operator[](I, T*);
3686 15For every T, where T is a pointer to complete object type, there exist
3687 candidate operator functions of the form112)
3688 ptrdiff_t operator-(T, T);
3690 16For every pointer type T, there exist candidate operator functions of
3692 bool operator<(T, T);
3693 bool operator>(T, T);
3694 bool operator<=(T, T);
3695 bool operator>=(T, T);
3696 bool operator==(T, T);
3697 bool operator!=(T, T);
3699 17For every pointer to member type T, there exist candidate operator
3700 functions of the form
3701 bool operator==(T, T);
3702 bool operator!=(T, T); */
3705 if (TYPE_PTROB_P (type1
) && TYPE_PTROB_P (type2
))
3707 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3709 type2
= ptrdiff_type_node
;
3713 case TRUNC_DIV_EXPR
:
3714 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3720 if (TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
)
3721 || TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
3723 if ((TYPE_PTRMEMFUNC_P (type1
) || TYPE_PTRMEM_P (type1
))
3724 && null_ptr_cst_p (args
[1]))
3729 if ((TYPE_PTRMEMFUNC_P (type2
) || TYPE_PTRMEM_P (type2
))
3730 && null_ptr_cst_p (args
[0]))
3741 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
)
3742 || TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3744 if (TYPE_PTR_P (type1
) && null_ptr_cst_p (args
[1]))
3749 if (null_ptr_cst_p (args
[0]) && TYPE_PTR_P (type2
))
3757 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3760 if (INTEGRAL_TYPE_P (type1
) && TYPE_PTROB_P (type2
))
3762 type1
= ptrdiff_type_node
;
3765 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3767 type2
= ptrdiff_type_node
;
3772 /* 18For every pair of promoted integral types L and R, there exist candi-
3773 date operator functions of the form
3780 where LR is the result of the usual arithmetic conversions between
3783 case TRUNC_MOD_EXPR
:
3789 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
3793 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
3794 type, VQ is either volatile or empty, and R is a promoted arithmetic
3795 type, there exist candidate operator functions of the form
3796 VQ L& operator=(VQ L&, R);
3797 VQ L& operator*=(VQ L&, R);
3798 VQ L& operator/=(VQ L&, R);
3799 VQ L& operator+=(VQ L&, R);
3800 VQ L& operator-=(VQ L&, R);
3802 20For every pair T, VQ), where T is any type and VQ is either volatile
3803 or empty, there exist candidate operator functions of the form
3804 T*VQ& operator=(T*VQ&, T*);
3806 21For every pair T, VQ), where T is a pointer to member type and VQ is
3807 either volatile or empty, there exist candidate operator functions of
3809 VQ T& operator=(VQ T&, T);
3811 22For every triple T, VQ, I), where T is a cv-qualified or cv-
3812 unqualified complete object type, VQ is either volatile or empty, and
3813 I is a promoted integral type, there exist candidate operator func-
3815 T*VQ& operator+=(T*VQ&, I);
3816 T*VQ& operator-=(T*VQ&, I);
3818 23For every triple L, VQ, R), where L is an integral or enumeration
3819 type, VQ is either volatile or empty, and R is a promoted integral
3820 type, there exist candidate operator functions of the form
3822 VQ L& operator%=(VQ L&, R);
3823 VQ L& operator<<=(VQ L&, R);
3824 VQ L& operator>>=(VQ L&, R);
3825 VQ L& operator&=(VQ L&, R);
3826 VQ L& operator^=(VQ L&, R);
3827 VQ L& operator|=(VQ L&, R); */
3834 if (TYPE_PTROB_P (type1
) && INTEGRAL_TYPE_P (type2
))
3836 type2
= ptrdiff_type_node
;
3840 case TRUNC_DIV_EXPR
:
3841 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3845 case TRUNC_MOD_EXPR
:
3851 if (INTEGRAL_TYPE_P (type1
) && INTEGRAL_TYPE_P (type2
))
3856 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3858 if ((TYPE_PTRMEMFUNC_P (type1
) && TYPE_PTRMEMFUNC_P (type2
))
3859 || (TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
3860 || (TYPE_PTRMEM_P (type1
) && TYPE_PTRMEM_P (type2
))
3861 || ((TYPE_PTRMEMFUNC_P (type1
)
3862 || TREE_CODE (type1
) == POINTER_TYPE
)
3863 && null_ptr_cst_p (args
[1])))
3871 my_friendly_abort (367);
3873 type1
= build_reference_type (type1
);
3877 /* Kludge around broken overloading rules whereby
3878 bool ? const char& : enum is ambiguous
3879 (between int and const char&). */
3880 flags
|= LOOKUP_NO_TEMP_BIND
;
3882 /* Extension: Support ?: of enumeral type. Hopefully this will not
3883 be an extension for long. */
3884 if (TREE_CODE (type1
) == ENUMERAL_TYPE
&& type1
== type2
)
3886 else if (TREE_CODE (type1
) == ENUMERAL_TYPE
3887 || TREE_CODE (type2
) == ENUMERAL_TYPE
)
3889 if (ARITHMETIC_TYPE_P (type1
) && ARITHMETIC_TYPE_P (type2
))
3891 if (TREE_CODE (type1
) == TREE_CODE (type2
)
3892 && (TREE_CODE (type1
) == REFERENCE_TYPE
3893 || TREE_CODE (type1
) == POINTER_TYPE
3894 || TYPE_PTRMEMFUNC_P (type1
)
3895 || IS_AGGR_TYPE (type1
)))
3897 if (TREE_CODE (type1
) == REFERENCE_TYPE
3898 || TREE_CODE (type2
) == REFERENCE_TYPE
)
3900 if (((TYPE_PTRMEMFUNC_P (type1
) || TREE_CODE (type1
) == POINTER_TYPE
)
3901 && null_ptr_cst_p (args
[1]))
3902 || IS_AGGR_TYPE (type1
))
3907 if (((TYPE_PTRMEMFUNC_P (type2
) || TREE_CODE (type2
) == POINTER_TYPE
)
3908 && null_ptr_cst_p (args
[0]))
3909 || IS_AGGR_TYPE (type2
))
3917 my_friendly_abort (367);
3920 /* If we're dealing with two pointer types, we need candidates
3921 for both of them. */
3922 if (type2
&& type1
!= type2
3923 && TREE_CODE (type1
) == TREE_CODE (type2
)
3924 && (TREE_CODE (type1
) == REFERENCE_TYPE
3925 || (TREE_CODE (type1
) == POINTER_TYPE
3926 && TYPE_PTRMEM_P (type1
) == TYPE_PTRMEM_P (type2
))
3927 || TYPE_PTRMEMFUNC_P (type1
)
3928 || IS_AGGR_TYPE (type1
)))
3930 candidates
= build_builtin_candidate
3931 (candidates
, fnname
, type1
, type1
, args
, argtypes
, flags
);
3932 return build_builtin_candidate
3933 (candidates
, fnname
, type2
, type2
, args
, argtypes
, flags
);
3936 return build_builtin_candidate
3937 (candidates
, fnname
, type1
, type2
, args
, argtypes
, flags
);
3941 type_decays_to (type
)
3944 if (TREE_CODE (type
) == ARRAY_TYPE
)
3945 return build_pointer_type (TREE_TYPE (type
));
3946 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3947 return build_pointer_type (type
);
3951 /* There are three conditions of builtin candidates:
3953 1) bool-taking candidates. These are the same regardless of the input.
3954 2) pointer-pair taking candidates. These are generated for each type
3955 one of the input types converts to.
3956 3) arithmetic candidates. According to the WP, we should generate
3957 all of these, but I'm trying not to... */
3959 static struct z_candidate
*
3960 add_builtin_candidates (candidates
, code
, code2
, fnname
, args
, flags
)
3961 struct z_candidate
*candidates
;
3962 enum tree_code code
, code2
;
3967 tree type
, argtypes
[3], types
[2];
3969 for (i
= 0; i
< 3; ++i
)
3972 argtypes
[i
] = lvalue_type (args
[i
]);
3974 argtypes
[i
] = NULL_TREE
;
3979 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3980 and VQ is either volatile or empty, there exist candidate operator
3981 functions of the form
3982 VQ T& operator++(VQ T&); */
3984 case POSTINCREMENT_EXPR
:
3985 case PREINCREMENT_EXPR
:
3986 case POSTDECREMENT_EXPR
:
3987 case PREDECREMENT_EXPR
:
3992 /* 24There also exist candidate operator functions of the form
3993 bool operator!(bool);
3994 bool operator&&(bool, bool);
3995 bool operator||(bool, bool); */
3997 case TRUTH_NOT_EXPR
:
3998 return build_builtin_candidate
3999 (candidates
, fnname
, boolean_type_node
,
4000 NULL_TREE
, args
, argtypes
, flags
);
4002 case TRUTH_ORIF_EXPR
:
4003 case TRUTH_ANDIF_EXPR
:
4004 return build_builtin_candidate
4005 (candidates
, fnname
, boolean_type_node
,
4006 boolean_type_node
, args
, argtypes
, flags
);
4017 types
[0] = types
[1] = NULL_TREE
;
4019 for (i
= 0; i
< 2; ++i
)
4023 else if (IS_AGGR_TYPE (argtypes
[i
]))
4025 tree convs
= lookup_conversions (argtypes
[i
]);
4027 if (code
== COND_EXPR
)
4029 if (real_lvalue_p (args
[i
]))
4030 types
[i
] = tree_cons
4031 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
4033 types
[i
] = tree_cons
4034 (NULL_TREE
, TYPE_MAIN_VARIANT (argtypes
[i
]), types
[i
]);
4037 else if (! convs
|| (i
== 0 && code
== MODIFY_EXPR
4038 && code2
== NOP_EXPR
))
4041 for (; convs
; convs
= TREE_CHAIN (convs
))
4043 type
= TREE_TYPE (TREE_TYPE (TREE_VALUE (convs
)));
4046 && (TREE_CODE (type
) != REFERENCE_TYPE
4047 || TYPE_READONLY (TREE_TYPE (type
))))
4050 if (code
== COND_EXPR
&& TREE_CODE (type
) == REFERENCE_TYPE
)
4051 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4053 type
= non_reference (type
);
4054 if (i
!= 0 || ! ref1
)
4056 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
4057 if (code
== COND_EXPR
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
4058 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4059 if (INTEGRAL_TYPE_P (type
))
4060 type
= type_promotes_to (type
);
4063 if (! value_member (type
, types
[i
]))
4064 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4069 if (code
== COND_EXPR
&& real_lvalue_p (args
[i
]))
4070 types
[i
] = tree_cons
4071 (NULL_TREE
, build_reference_type (argtypes
[i
]), types
[i
]);
4072 type
= non_reference (argtypes
[i
]);
4073 if (i
!= 0 || ! ref1
)
4075 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
4076 if (code
== COND_EXPR
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
4077 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4078 if (INTEGRAL_TYPE_P (type
))
4079 type
= type_promotes_to (type
);
4081 types
[i
] = tree_cons (NULL_TREE
, type
, types
[i
]);
4085 for (; types
[0]; types
[0] = TREE_CHAIN (types
[0]))
4088 for (type
= types
[1]; type
; type
= TREE_CHAIN (type
))
4089 candidates
= add_builtin_candidate
4090 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
4091 TREE_VALUE (type
), args
, argtypes
, flags
);
4093 candidates
= add_builtin_candidate
4094 (candidates
, code
, code2
, fnname
, TREE_VALUE (types
[0]),
4095 NULL_TREE
, args
, argtypes
, flags
);
4101 static struct z_candidate
*
4102 add_template_candidate (candidates
, tmpl
, arglist
, flags
)
4103 struct z_candidate
*candidates
;
4107 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl
));
4108 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
4109 struct z_candidate
*cand
;
4113 i
= type_unification (DECL_TEMPLATE_PARMS (tmpl
), targs
,
4114 TYPE_ARG_TYPES (TREE_TYPE (tmpl
)),
4115 arglist
, &dummy
, 0, 0);
4119 fn
= instantiate_template (tmpl
, targs
);
4120 if (fn
== error_mark_node
)
4123 cand
= add_function_candidate (candidates
, fn
, arglist
, flags
);
4124 cand
->template = DECL_TEMPLATE_INFO (fn
);
4130 struct z_candidate
*cands
;
4132 for (; cands
; cands
= cands
->next
)
4133 if (pedantic
? cands
->viable
== 1 : cands
->viable
)
4138 static struct z_candidate
*
4139 splice_viable (cands
)
4140 struct z_candidate
*cands
;
4142 struct z_candidate
**p
= &cands
;
4146 if (pedantic
? (*p
)->viable
== 1 : (*p
)->viable
)
4159 /* Fix this to work on non-lvalues. */
4160 if (IS_SIGNATURE_POINTER (TREE_TYPE (obj
))
4161 || IS_SIGNATURE_REFERENCE (TREE_TYPE (obj
)))
4164 return build_unary_op (ADDR_EXPR
, obj
, 0);
4168 print_z_candidates (candidates
)
4169 struct z_candidate
*candidates
;
4171 char *str
= "candidates are:";
4172 for (; candidates
; candidates
= candidates
->next
)
4174 if (TREE_CODE (candidates
->fn
) == IDENTIFIER_NODE
)
4176 if (candidates
->fn
== ansi_opname
[COND_EXPR
])
4177 cp_error ("%s %D(%T, %T, %T) <builtin>", str
, candidates
->fn
,
4178 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)),
4179 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 1)),
4180 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 2)));
4181 else if (TREE_VEC_LENGTH (candidates
->convs
) == 2)
4182 cp_error ("%s %D(%T, %T) <builtin>", str
, candidates
->fn
,
4183 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)),
4184 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 1)));
4186 cp_error ("%s %D(%T) <builtin>", str
, candidates
->fn
,
4187 TREE_TYPE (TREE_VEC_ELT (candidates
->convs
, 0)));
4190 cp_error_at ("%s %+D%s", str
, candidates
->fn
,
4191 candidates
->viable
== -1 ? " <near match>" : "");
4196 /* Returns the best overload candidate to perform the requested
4197 conversion. This function is used for three the overloading situations
4198 described in [over.match.copy], [over.match.conv], and [over.match.ref].
4199 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
4200 per [dcl.init.ref], so we ignore temporary bindings. */
4202 static struct z_candidate
*
4203 build_user_type_conversion_1 (totype
, expr
, flags
)
4207 struct z_candidate
*candidates
, *cand
;
4208 tree fromtype
= TREE_TYPE (expr
);
4209 tree ctors
= NULL_TREE
, convs
= NULL_TREE
, *p
;
4212 if (IS_AGGR_TYPE (totype
))
4213 ctors
= lookup_fnfields (TYPE_BINFO (totype
), ctor_identifier
, 0);
4214 if (IS_AGGR_TYPE (fromtype
)
4215 && (! IS_AGGR_TYPE (totype
) || ! DERIVED_FROM_P (totype
, fromtype
)))
4216 convs
= lookup_conversions (fromtype
);
4219 flags
|= LOOKUP_NO_CONVERSION
;
4223 tree t
= build_int_2 (0, 0);
4224 TREE_TYPE (t
) = build_pointer_type (totype
);
4225 args
= build_tree_list (NULL_TREE
, expr
);
4226 if (TYPE_USES_VIRTUAL_BASECLASSES (totype
))
4227 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
4228 args
= tree_cons (NULL_TREE
, t
, args
);
4230 ctors
= TREE_VALUE (ctors
);
4232 for (; ctors
; ctors
= DECL_CHAIN (ctors
))
4234 if (DECL_NONCONVERTING_P (ctors
))
4237 candidates
= add_function_candidate (candidates
, ctors
, args
, flags
);
4238 candidates
->second_conv
= build1 (IDENTITY_CONV
, totype
, NULL_TREE
);
4239 candidates
->basetype_path
= TYPE_BINFO (totype
);
4243 args
= build_tree_list (NULL_TREE
, build_this (expr
));
4245 for (; convs
; convs
= TREE_CHAIN (convs
))
4247 tree fn
= TREE_VALUE (convs
);
4248 int convflags
= LOOKUP_NO_CONVERSION
;
4251 /* If we are called to convert to a reference type, we are trying to
4252 find an lvalue binding, so don't even consider temporaries. If
4253 we don't find an lvalue binding, the caller will try again to
4254 look for a temporary binding. */
4255 if (TREE_CODE (totype
) == REFERENCE_TYPE
)
4256 convflags
|= LOOKUP_NO_TEMP_BIND
;
4258 ics
= implicit_conversion
4259 (totype
, TREE_TYPE (TREE_TYPE (fn
)), 0, convflags
);
4261 if (TREE_CODE (totype
) == REFERENCE_TYPE
&& ics
&& ICS_BAD_FLAG (ics
))
4262 /* ignore the near match. */;
4264 for (; fn
; fn
= DECL_CHAIN (fn
))
4266 candidates
= add_function_candidate (candidates
, fn
, args
, flags
);
4267 candidates
->second_conv
= ics
;
4268 candidates
->basetype_path
= TREE_PURPOSE (convs
);
4269 if (candidates
->viable
== 1 && ICS_BAD_FLAG (ics
))
4270 candidates
->viable
= -1;
4274 if (! any_viable (candidates
))
4277 if (flags
& LOOKUP_COMPLAIN
)
4279 if (candidates
&& ! candidates
->next
)
4280 /* say why this one won't work or try to be loose */;
4282 cp_error ("no viable candidates");
4289 candidates
= splice_viable (candidates
);
4290 cand
= tourney (candidates
, totype
);
4294 if (flags
& LOOKUP_COMPLAIN
)
4296 cp_error ("conversion from `%T' to `%T' is ambiguous",
4298 print_z_candidates (candidates
);
4301 cand
= candidates
; /* any one will do */
4302 cand
->second_conv
= build1 (AMBIG_CONV
, totype
, expr
);
4303 ICS_USER_FLAG (cand
->second_conv
) = 1;
4304 ICS_BAD_FLAG (cand
->second_conv
) = 1;
4309 for (p
= &(cand
->second_conv
); TREE_CODE (*p
) != IDENTITY_CONV
; )
4310 p
= &(TREE_OPERAND (*p
, 0));
4314 (DECL_CONSTRUCTOR_P (cand
->fn
)
4315 ? totype
: non_reference (TREE_TYPE (TREE_TYPE (cand
->fn
)))),
4316 NULL_TREE
, cand
->fn
, cand
->convs
, cand
->basetype_path
);
4317 ICS_USER_FLAG (cand
->second_conv
) = 1;
4318 if (cand
->viable
== -1)
4319 ICS_BAD_FLAG (cand
->second_conv
) = 1;
4325 build_user_type_conversion (totype
, expr
, flags
)
4329 struct z_candidate
*cand
4330 = build_user_type_conversion_1 (totype
, expr
, flags
);
4334 if (TREE_CODE (cand
->second_conv
) == AMBIG_CONV
)
4335 return error_mark_node
;
4336 return convert_from_reference (convert_like (cand
->second_conv
, expr
));
4342 build_new_function_call (fn
, args
, obj
)
4345 struct z_candidate
*candidates
= 0, *cand
;
4347 if (obj
== NULL_TREE
&& TREE_CODE (fn
) == TREE_LIST
)
4350 tree templates
= NULL_TREE
;
4352 for (t
= args
; t
; t
= TREE_CHAIN (t
))
4354 if (TREE_VALUE (t
) == error_mark_node
)
4355 return error_mark_node
;
4356 else if (TREE_CODE (TREE_TYPE (TREE_VALUE (t
))) == VOID_TYPE
)
4358 error ("invalid use of void expression");
4359 return error_mark_node
;
4363 for (t
= TREE_VALUE (fn
); t
; t
= DECL_CHAIN (t
))
4365 if (TREE_CODE (t
) == TEMPLATE_DECL
)
4367 templates
= decl_tree_cons (NULL_TREE
, t
, templates
);
4368 candidates
= add_template_candidate
4369 (candidates
, t
, args
, LOOKUP_NORMAL
);
4372 candidates
= add_function_candidate
4373 (candidates
, t
, args
, LOOKUP_NORMAL
);
4376 if (! any_viable (candidates
))
4378 if (candidates
&& ! candidates
->next
)
4379 return build_function_call (candidates
->fn
, args
);
4380 cp_error ("no matching function for call to `%D (%A)'",
4381 TREE_PURPOSE (fn
), args
);
4383 print_z_candidates (candidates
);
4384 return error_mark_node
;
4386 candidates
= splice_viable (candidates
);
4387 cand
= tourney (candidates
, NULL_TREE
);
4391 cp_error ("call of overloaded `%D (%A)' is ambiguous",
4392 TREE_PURPOSE (fn
), args
);
4393 print_z_candidates (candidates
);
4394 return error_mark_node
;
4397 /* Pedantically, it is ill-formed to define a function that could
4398 also be a template instantiation, but we won't implement that
4399 until things settle down. */
4400 if (templates
&& ! cand
->template && ! DECL_INITIAL (cand
->fn
))
4401 add_maybe_template (cand
->fn
, templates
);
4403 return build_over_call (cand
->fn
, cand
->convs
, args
, LOOKUP_NORMAL
);
4406 return build_function_call (fn
, args
);
4410 build_object_call (obj
, args
)
4413 struct z_candidate
*candidates
= 0, *cand
;
4414 tree fns
, convs
, mem_args
;
4415 tree type
= TREE_TYPE (obj
);
4417 fns
= lookup_fnfields (TYPE_BINFO (type
), ansi_opname
[CALL_EXPR
], 0);
4421 tree fn
= TREE_VALUE (fns
);
4422 mem_args
= tree_cons (NULL_TREE
, build_this (obj
), args
);
4424 for (; fn
; fn
= DECL_CHAIN (fn
))
4426 candidates
= add_function_candidate
4427 (candidates
, fn
, mem_args
, LOOKUP_NORMAL
);
4428 candidates
->basetype_path
= TREE_PURPOSE (fns
);
4432 convs
= lookup_conversions (type
);
4434 for (; convs
; convs
= TREE_CHAIN (convs
))
4436 tree fn
= TREE_VALUE (convs
);
4437 tree totype
= TREE_TYPE (TREE_TYPE (fn
));
4439 if (TREE_CODE (totype
) == POINTER_TYPE
4440 && TREE_CODE (TREE_TYPE (totype
)) == FUNCTION_TYPE
)
4441 for (; fn
; fn
= DECL_CHAIN (fn
))
4443 candidates
= add_conv_candidate (candidates
, fn
, obj
, args
);
4444 candidates
->basetype_path
= TREE_PURPOSE (convs
);
4448 if (! any_viable (candidates
))
4450 cp_error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj
), args
);
4451 print_z_candidates (candidates
);
4452 return error_mark_node
;
4455 candidates
= splice_viable (candidates
);
4456 cand
= tourney (candidates
, NULL_TREE
);
4460 cp_error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj
), args
);
4461 print_z_candidates (candidates
);
4462 return error_mark_node
;
4465 if (DECL_NAME (cand
->fn
) == ansi_opname
[CALL_EXPR
])
4466 return build_over_call (cand
->fn
, cand
->convs
, mem_args
, LOOKUP_NORMAL
);
4468 obj
= convert_like (TREE_VEC_ELT (cand
->convs
, 0), obj
);
4471 return build_function_call (obj
, args
);
4475 op_error (code
, code2
, arg1
, arg2
, arg3
, problem
)
4476 enum tree_code code
, code2
;
4477 tree arg1
, arg2
, arg3
;
4481 = (code
== MODIFY_EXPR
? assignop_tab
[code2
] : opname_tab
[code
]);
4486 cp_error ("%s for `%T ? %T : %T'", problem
,
4487 error_type (arg1
), error_type (arg2
), error_type (arg3
));
4489 case POSTINCREMENT_EXPR
:
4490 case POSTDECREMENT_EXPR
:
4491 cp_error ("%s for `%T%s'", problem
, error_type (arg1
), opname
);
4494 cp_error ("%s for `%T[%T]'", problem
,
4495 error_type (arg1
), error_type (arg2
));
4499 cp_error ("%s for `%T %s %T'", problem
,
4500 error_type (arg1
), opname
, error_type (arg2
));
4502 cp_error ("%s for `%s%T'", problem
, opname
, error_type (arg1
));
4507 build_new_op (code
, flags
, arg1
, arg2
, arg3
)
4508 enum tree_code code
;
4510 tree arg1
, arg2
, arg3
;
4512 struct z_candidate
*candidates
= 0, *cand
;
4513 tree fns
, mem_arglist
, arglist
, fnname
;
4514 enum tree_code code2
= NOP_EXPR
;
4515 tree templates
= NULL_TREE
;
4517 if (arg1
== error_mark_node
4518 || arg2
== error_mark_node
4519 || arg3
== error_mark_node
)
4520 return error_mark_node
;
4522 if (code
== MODIFY_EXPR
)
4524 code2
= TREE_CODE (arg3
);
4526 fnname
= ansi_assopname
[code2
];
4529 fnname
= ansi_opname
[code
];
4538 arglist
= tree_cons (NULL_TREE
, arg2
, arg3
);
4539 if (flags
& LOOKUP_GLOBAL
)
4540 return build_new_function_call
4541 (lookup_name_nonclass (fnname
), arglist
, NULL_TREE
);
4544 rval
= build_method_call
4545 (build_indirect_ref (build1 (NOP_EXPR
, arg1
, error_mark_node
),
4547 fnname
, arglist
, NULL_TREE
, flags
);
4548 if (rval
== error_mark_node
)
4549 /* User might declare fancy operator new, but invoke it
4550 like standard one. */
4553 TREE_TYPE (rval
) = arg1
;
4554 TREE_CALLS_NEW (rval
) = 1;
4558 case VEC_DELETE_EXPR
:
4563 if (flags
& LOOKUP_GLOBAL
)
4564 return build_new_function_call
4565 (lookup_name_nonclass (fnname
),
4566 build_tree_list (NULL_TREE
, arg1
), NULL_TREE
);
4568 arglist
= tree_cons (NULL_TREE
, arg1
, build_tree_list (NULL_TREE
, arg2
));
4570 arg1
= TREE_TYPE (arg1
);
4572 /* This handles the case where we're trying to delete
4577 if (TREE_CODE (TREE_TYPE (arg1
)) == ARRAY_TYPE
)
4579 /* Strip off the pointer and the array. */
4580 arg1
= TREE_TYPE (TREE_TYPE (arg1
));
4582 while (TREE_CODE (arg1
) == ARRAY_TYPE
)
4583 arg1
= (TREE_TYPE (arg1
));
4585 arg1
= build_pointer_type (arg1
);
4589 rval
= build_method_call
4590 (build_indirect_ref (build1 (NOP_EXPR
, arg1
,
4593 fnname
, arglist
, NULL_TREE
, flags
);
4595 /* This can happen when operator delete is protected. */
4596 my_friendly_assert (rval
!= error_mark_node
, 250);
4597 TREE_TYPE (rval
) = void_type_node
;
4603 return build_object_call (arg1
, arg2
);
4606 /* The comma operator can have void args. */
4607 if (TREE_CODE (arg1
) == OFFSET_REF
)
4608 arg1
= resolve_offset_ref (arg1
);
4609 if (arg2
&& TREE_CODE (arg2
) == OFFSET_REF
)
4610 arg2
= resolve_offset_ref (arg2
);
4611 if (arg3
&& TREE_CODE (arg3
) == OFFSET_REF
)
4612 arg3
= resolve_offset_ref (arg3
);
4614 if (code
== COND_EXPR
)
4616 if (arg2
== NULL_TREE
4617 || TREE_CODE (TREE_TYPE (arg2
)) == VOID_TYPE
4618 || TREE_CODE (TREE_TYPE (arg3
)) == VOID_TYPE
4619 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))
4620 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3
))))
4623 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1
))
4624 && (! arg2
|| ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2
))))
4627 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
4628 arg2
= integer_zero_node
;
4630 fns
= lookup_name_nonclass (fnname
);
4631 /* + Koenig lookup */
4634 arglist
= tree_cons (NULL_TREE
, arg1
, tree_cons
4635 (NULL_TREE
, arg2
, build_tree_list (NULL_TREE
, arg3
)));
4637 arglist
= tree_cons (NULL_TREE
, arg1
, build_tree_list (NULL_TREE
, arg2
));
4639 arglist
= build_tree_list (NULL_TREE
, arg1
);
4641 if (fns
&& TREE_CODE (fns
) == TREE_LIST
)
4642 fns
= TREE_VALUE (fns
);
4643 for (; fns
; fns
= DECL_CHAIN (fns
))
4645 if (TREE_CODE (fns
) == TEMPLATE_DECL
)
4647 templates
= decl_tree_cons (NULL_TREE
, fns
, templates
);
4648 candidates
= add_template_candidate
4649 (candidates
, fns
, arglist
, flags
);
4652 candidates
= add_function_candidate (candidates
, fns
, arglist
, flags
);
4655 if (IS_AGGR_TYPE (TREE_TYPE (arg1
)))
4656 fns
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1
)), fnname
, 0);
4662 tree fn
= TREE_VALUE (fns
);
4663 mem_arglist
= tree_cons (NULL_TREE
, build_this (arg1
), TREE_CHAIN (arglist
));
4664 for (; fn
; fn
= DECL_CHAIN (fn
))
4666 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4667 candidates
= add_function_candidate
4668 (candidates
, fn
, mem_arglist
, flags
);
4670 candidates
= add_function_candidate (candidates
, fn
, arglist
, flags
);
4672 candidates
->basetype_path
= TREE_PURPOSE (fns
);
4679 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
4680 to know about two args; a builtin candidate will always have a first
4681 parameter of type bool. We'll handle that in
4682 build_builtin_candidate. */
4683 if (code
== COND_EXPR
)
4693 args
[2] = NULL_TREE
;
4696 candidates
= add_builtin_candidates
4697 (candidates
, code
, code2
, fnname
, args
, flags
);
4700 if (! any_viable (candidates
))
4704 case POSTINCREMENT_EXPR
:
4705 case POSTDECREMENT_EXPR
:
4706 /* Look for an `operator++ (int)'. If they didn't have
4707 one, then we fall back to the old way of doing things. */
4708 if (flags
& LOOKUP_COMPLAIN
)
4709 cp_pedwarn ("no `%D (int)' declared for postfix `%s', trying prefix operator instead",
4710 fnname
, opname_tab
[code
]);
4711 if (code
== POSTINCREMENT_EXPR
)
4712 code
= PREINCREMENT_EXPR
;
4714 code
= PREDECREMENT_EXPR
;
4715 return build_new_op (code
, flags
, arg1
, NULL_TREE
, NULL_TREE
);
4717 /* The caller will deal with these. */
4723 if (flags
& LOOKUP_COMPLAIN
)
4725 op_error (code
, code2
, arg1
, arg2
, arg3
, "no match");
4726 print_z_candidates (candidates
);
4728 return error_mark_node
;
4730 candidates
= splice_viable (candidates
);
4731 cand
= tourney (candidates
, NULL_TREE
);
4735 if (flags
& LOOKUP_COMPLAIN
)
4737 op_error (code
, code2
, arg1
, arg2
, arg3
, "ambiguous overload");
4738 print_z_candidates (candidates
);
4740 return error_mark_node
;
4743 if (TREE_CODE (cand
->fn
) == FUNCTION_DECL
)
4745 extern int warn_synth
;
4747 && fnname
== ansi_opname
[MODIFY_EXPR
]
4748 && DECL_ARTIFICIAL (cand
->fn
)
4750 && ! candidates
->next
->next
)
4752 cp_warning ("using synthesized `%#D' for copy assignment",
4754 cp_warning_at (" where cfront would use `%#D'",
4756 ? candidates
->next
->fn
4760 if (DECL_FUNCTION_MEMBER_P (cand
->fn
))
4761 enforce_access (cand
->basetype_path
, cand
->fn
);
4763 /* Pedantically, it is ill-formed to define a function that could
4764 also be a template instantiation, but we won't implement that
4765 until things settle down. */
4766 if (templates
&& ! cand
->template && ! DECL_INITIAL (cand
->fn
)
4767 && TREE_CODE (TREE_TYPE (cand
->fn
)) != METHOD_TYPE
)
4768 add_maybe_template (cand
->fn
, templates
);
4770 return build_over_call
4771 (cand
->fn
, cand
->convs
,
4772 TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
4773 ? mem_arglist
: arglist
,
4777 /* Check for comparison of different enum types. */
4786 if (flag_int_enum_equivalence
== 0
4787 && TREE_CODE (TREE_TYPE (arg1
)) == ENUMERAL_TYPE
4788 && TREE_CODE (TREE_TYPE (arg2
)) == ENUMERAL_TYPE
4789 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
))
4790 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2
))))
4792 cp_warning ("comparison between `%#T' and `%#T'",
4793 TREE_TYPE (arg1
), TREE_TYPE (arg2
));
4797 arg1
= convert_from_reference
4798 (convert_like (TREE_VEC_ELT (cand
->convs
, 0), arg1
));
4800 arg2
= convert_like (TREE_VEC_ELT (cand
->convs
, 1), arg2
);
4802 arg3
= convert_like (TREE_VEC_ELT (cand
->convs
, 2), arg3
);
4808 return build_modify_expr (arg1
, code2
, arg2
);
4811 return build_indirect_ref (arg1
, "unary *");
4816 case TRUNC_DIV_EXPR
:
4827 case TRUNC_MOD_EXPR
:
4831 case TRUTH_ANDIF_EXPR
:
4832 case TRUTH_ORIF_EXPR
:
4833 return build_binary_op_nodefault (code
, arg1
, arg2
, code
);
4838 case TRUTH_NOT_EXPR
:
4839 case PREINCREMENT_EXPR
:
4840 case POSTINCREMENT_EXPR
:
4841 case PREDECREMENT_EXPR
:
4842 case POSTDECREMENT_EXPR
:
4845 return build_unary_op (code
, arg1
, candidates
!= 0);
4848 return build_array_ref (arg1
, arg2
);
4851 return build_conditional_expr (arg1
, arg2
, arg3
);
4854 return build_m_component_ref
4855 (build_indirect_ref (arg1
, NULL_PTR
), arg2
);
4857 /* The caller will deal with these. */
4864 my_friendly_abort (367);
4869 enforce_access (basetype_path
, function
)
4870 tree basetype_path
, function
;
4872 tree access
= compute_access (basetype_path
, function
);
4874 if (access
== access_private_node
)
4876 cp_error_at ("`%+#D' is %s", function
,
4877 TREE_PRIVATE (function
) ? "private"
4878 : "from private base class");
4879 error ("within this context");
4881 else if (access
== access_protected_node
)
4883 cp_error_at ("`%+#D' %s", function
,
4884 TREE_PROTECTED (function
) ? "is protected"
4885 : "has protected accessibility");
4886 error ("within this context");
4890 /* Perform the conversions in CONVS on the expression EXPR. */
4893 convert_like (convs
, expr
)
4896 if (ICS_BAD_FLAG (convs
)
4897 && TREE_CODE (convs
) != USER_CONV
4898 && TREE_CODE (convs
) != AMBIG_CONV
)
4901 for (; t
; t
= TREE_OPERAND (t
, 0))
4903 if (TREE_CODE (t
) == USER_CONV
)
4905 expr
= convert_like (t
, expr
);
4908 else if (TREE_CODE (t
) == AMBIG_CONV
)
4909 return convert_like (t
, expr
);
4910 else if (TREE_CODE (t
) == IDENTITY_CONV
)
4913 return convert_for_initialization
4914 (NULL_TREE
, TREE_TYPE (convs
), expr
, LOOKUP_NORMAL
,
4915 "conversion", NULL_TREE
, 0);
4918 switch (TREE_CODE (convs
))
4922 tree fn
= TREE_OPERAND (convs
, 1);
4924 enforce_access (TREE_OPERAND (convs
, 3), fn
);
4926 if (DECL_CONSTRUCTOR_P (fn
))
4928 tree t
= build_int_2 (0, 0);
4929 TREE_TYPE (t
) = build_pointer_type (DECL_CONTEXT (fn
));
4931 args
= build_tree_list (NULL_TREE
, expr
);
4932 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
4933 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
4934 args
= tree_cons (NULL_TREE
, t
, args
);
4937 args
= build_this (expr
);
4938 expr
= build_over_call
4939 (TREE_OPERAND (convs
, 1), TREE_OPERAND (convs
, 2),
4940 args
, LOOKUP_NORMAL
);
4942 /* If this is a constructor or a function returning an aggr type,
4943 we need to build up a TARGET_EXPR. */
4944 if (DECL_CONSTRUCTOR_P (fn
))
4945 expr
= build_cplus_new (TREE_TYPE (convs
), expr
);
4950 if (type_unknown_p (expr
))
4951 expr
= instantiate_type (TREE_TYPE (convs
), expr
, 1);
4952 if (TREE_READONLY_DECL_P (expr
))
4953 expr
= decl_constant_value (expr
);
4956 /* Call build_user_type_conversion again for the error. */
4957 return build_user_type_conversion
4958 (TREE_TYPE (convs
), TREE_OPERAND (convs
, 0), LOOKUP_NORMAL
);
4961 expr
= convert_like (TREE_OPERAND (convs
, 0), expr
);
4962 if (expr
== error_mark_node
)
4963 return error_mark_node
;
4965 switch (TREE_CODE (convs
))
4968 if (! IS_AGGR_TYPE (TREE_TYPE (convs
)))
4970 /* else fall through */
4972 return build_user_type_conversion
4973 (TREE_TYPE (convs
), expr
, LOOKUP_NORMAL
);
4975 return convert_to_reference
4976 (TREE_TYPE (convs
), expr
,
4977 CONV_IMPLICIT
, LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
4980 return decay_conversion (expr
);
4982 return ocp_convert (TREE_TYPE (convs
), expr
, CONV_IMPLICIT
,
4983 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
);
4987 convert_default_arg (type
, arg
)
4990 arg
= break_out_target_exprs (arg
);
4992 if (TREE_CODE (arg
) == CONSTRUCTOR
)
4994 arg
= digest_init (type
, arg
, 0);
4995 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
4996 "default argument", 0, 0);
5000 /* This could get clobbered by the following call. */
5001 if (TREE_HAS_CONSTRUCTOR (arg
))
5002 arg
= copy_node (arg
);
5004 arg
= convert_for_initialization (0, type
, arg
, LOOKUP_NORMAL
,
5005 "default argument", 0, 0);
5006 #ifdef PROMOTE_PROTOTYPES
5007 if ((TREE_CODE (type
) == INTEGER_TYPE
5008 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5009 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
5010 arg
= default_conversion (arg
);
5018 build_over_call (fn
, convs
, args
, flags
)
5019 tree fn
, convs
, args
;
5022 tree converted_args
= NULL_TREE
;
5023 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5024 tree conv
, arg
, val
;
5028 if (args
&& TREE_CODE (args
) != TREE_LIST
)
5029 args
= build_tree_list (NULL_TREE
, args
);
5032 /* The implicit parameters to a constructor are not considered by overload
5033 resolution, and must be of the proper type. */
5034 if (DECL_CONSTRUCTOR_P (fn
))
5036 converted_args
= tree_cons (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
5037 arg
= TREE_CHAIN (arg
);
5038 parm
= TREE_CHAIN (parm
);
5039 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn
)))
5041 converted_args
= tree_cons
5042 (NULL_TREE
, TREE_VALUE (arg
), converted_args
);
5043 arg
= TREE_CHAIN (arg
);
5044 parm
= TREE_CHAIN (parm
);
5047 /* Bypass access control for 'this' parameter. */
5048 else if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
5050 tree parmtype
= TREE_VALUE (parm
);
5051 tree argtype
= TREE_TYPE (TREE_VALUE (arg
));
5052 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs
, i
)))
5054 int dv
= (TYPE_VOLATILE (TREE_TYPE (parmtype
))
5055 < TYPE_VOLATILE (TREE_TYPE (argtype
)));
5056 int dc
= (TYPE_READONLY (TREE_TYPE (parmtype
))
5057 < TYPE_READONLY (TREE_TYPE (argtype
)));
5058 char *p
= (dv
&& dc
? "const and volatile"
5059 : dc
? "const" : dv
? "volatile" : "");
5061 cp_pedwarn ("passing `%T' as `this' argument of `%#D' discards %s",
5062 TREE_TYPE (argtype
), fn
, p
);
5064 converted_args
= tree_cons
5065 (NULL_TREE
, convert_force (TREE_VALUE (parm
), TREE_VALUE (arg
), CONV_C_CAST
),
5067 parm
= TREE_CHAIN (parm
);
5068 arg
= TREE_CHAIN (arg
);
5074 parm
= TREE_CHAIN (parm
), arg
= TREE_CHAIN (arg
), ++i
)
5076 tree type
= TREE_VALUE (parm
);
5078 conv
= TREE_VEC_ELT (convs
, i
);
5079 if (ICS_BAD_FLAG (conv
))
5082 val
= TREE_VALUE (arg
);
5084 for (; t
; t
= TREE_OPERAND (t
, 0))
5086 if (TREE_CODE (t
) == USER_CONV
5087 || TREE_CODE (t
) == AMBIG_CONV
)
5089 val
= convert_like (t
, val
);
5092 else if (TREE_CODE (t
) == IDENTITY_CONV
)
5095 val
= convert_for_initialization
5096 (NULL_TREE
, type
, val
, LOOKUP_NORMAL
,
5097 "argument passing", fn
, i
- is_method
);
5100 val
= convert_like (conv
, TREE_VALUE (arg
));
5102 #ifdef PROMOTE_PROTOTYPES
5103 if ((TREE_CODE (type
) == INTEGER_TYPE
5104 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5105 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
5106 val
= default_conversion (val
);
5108 converted_args
= tree_cons (NULL_TREE
, val
, converted_args
);
5111 /* Default arguments */
5112 for (; parm
&& parm
!= void_list_node
; parm
= TREE_CHAIN (parm
))
5114 tree arg
= TREE_PURPOSE (parm
);
5116 if (DECL_TEMPLATE_INFO (fn
) && uses_template_parms (arg
))
5117 /* This came from a template. Instantiate the default arg here,
5119 arg
= tsubst_expr (arg
,
5120 &TREE_VEC_ELT (DECL_TI_ARGS (fn
), 0),
5121 TREE_VEC_LENGTH (DECL_TI_ARGS (fn
)), NULL_TREE
);
5122 converted_args
= tree_cons
5123 (NULL_TREE
, convert_default_arg (TREE_VALUE (parm
), arg
),
5128 for (; arg
; arg
= TREE_CHAIN (arg
))
5130 val
= TREE_VALUE (arg
);
5132 if (TREE_CODE (TREE_TYPE (val
)) == REAL_TYPE
5133 && (TYPE_PRECISION (TREE_TYPE (val
))
5134 < TYPE_PRECISION (double_type_node
)))
5135 /* Convert `float' to `double'. */
5136 val
= cp_convert (double_type_node
, val
);
5137 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val
))
5138 && ! TYPE_HAS_TRIVIAL_INIT_REF (TREE_TYPE (val
)))
5139 cp_warning ("cannot pass objects of type `%T' through `...'",
5142 /* Convert `short' and `char' to full-size `int'. */
5143 val
= default_conversion (val
);
5145 converted_args
= tree_cons (NULL_TREE
, val
, converted_args
);
5148 converted_args
= nreverse (converted_args
);
5150 /* Avoid actually calling copy constructors and copy assignment operators,
5152 if (DECL_CONSTRUCTOR_P (fn
)
5153 && TREE_VEC_LENGTH (convs
) == 1
5154 && copy_args_p (fn
))
5157 arg
= TREE_VALUE (TREE_CHAIN (converted_args
));
5159 /* Pull out the real argument, disregarding const-correctness. */
5161 while (TREE_CODE (targ
) == NOP_EXPR
5162 || TREE_CODE (targ
) == NON_LVALUE_EXPR
5163 || TREE_CODE (targ
) == CONVERT_EXPR
)
5164 targ
= TREE_OPERAND (targ
, 0);
5165 if (TREE_CODE (targ
) == ADDR_EXPR
)
5167 targ
= TREE_OPERAND (targ
, 0);
5168 if (! comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg
))),
5169 TYPE_MAIN_VARIANT (TREE_TYPE (targ
)), 1))
5178 arg
= build_indirect_ref (arg
, 0);
5180 /* [class.copy]: the copy constructor is implicitly defined even if
5181 the implementation elided its use. */
5182 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn
)))
5185 /* If we're creating a temp and we already have one, don't create a
5186 new one. If we're not creating a temp but we get one, use
5187 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5188 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5189 temp or an INIT_EXPR otherwise. */
5190 if (integer_zerop (TREE_VALUE (args
)))
5192 if (! real_lvalue_p (arg
))
5194 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5196 val
= build (VAR_DECL
, DECL_CONTEXT (fn
));
5197 layout_decl (val
, 0);
5198 val
= build (TARGET_EXPR
, DECL_CONTEXT (fn
), val
, arg
, 0, 0);
5199 TREE_SIDE_EFFECTS (val
) = 1;
5203 else if (! real_lvalue_p (arg
)
5204 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn
)))
5206 tree to
= stabilize_reference
5207 (build_indirect_ref (TREE_VALUE (args
), 0));
5208 val
= build (INIT_EXPR
, DECL_CONTEXT (fn
), to
, arg
);
5209 TREE_SIDE_EFFECTS (val
) = 1;
5210 return build_unary_op (ADDR_EXPR
, val
, 0);
5213 else if (DECL_NAME (fn
) == ansi_opname
[MODIFY_EXPR
]
5215 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn
)))
5217 tree to
= stabilize_reference
5218 (build_indirect_ref (TREE_VALUE (converted_args
), 0));
5219 arg
= build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args
)), 0);
5220 val
= build (MODIFY_EXPR
, TREE_TYPE (to
), to
, arg
);
5221 TREE_SIDE_EFFECTS (val
) = 1;
5227 if (DECL_CONTEXT (fn
) && IS_SIGNATURE (DECL_CONTEXT (fn
)))
5228 return build_signature_method_call (fn
, converted_args
);
5229 else if (DECL_VINDEX (fn
) && (flags
& LOOKUP_NONVIRTUAL
) == 0)
5231 tree t
, *p
= &TREE_VALUE (converted_args
);
5232 tree binfo
= get_binfo
5233 (DECL_CONTEXT (fn
), TREE_TYPE (TREE_TYPE (*p
)), 0);
5234 *p
= convert_pointer_to_real (binfo
, *p
);
5235 if (TREE_SIDE_EFFECTS (*p
))
5236 *p
= save_expr (*p
);
5237 t
= build_pointer_type (TREE_TYPE (fn
));
5238 fn
= build_vfn_ref (p
, build_indirect_ref (*p
, 0), DECL_VINDEX (fn
));
5241 else if (DECL_INLINE (fn
))
5242 fn
= inline_conversion (fn
);
5244 fn
= build_addr_func (fn
);
5246 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))), converted_args
);
5247 if (TREE_TYPE (fn
) == void_type_node
)
5249 if (IS_AGGR_TYPE (TREE_TYPE (fn
)))
5250 fn
= build_cplus_new (TREE_TYPE (fn
), fn
);
5251 return convert_from_reference (require_complete_type (fn
));
5255 build_new_method_call (instance
, name
, args
, basetype_path
, flags
)
5256 tree instance
, name
, args
, basetype_path
;
5259 struct z_candidate
*candidates
= 0, *cand
;
5260 tree basetype
, mem_args
, fns
, instance_ptr
;
5262 tree user_args
= args
;
5264 /* If there is an extra argument for controlling virtual bases,
5265 remove it for error reporting. */
5266 if (flags
& LOOKUP_HAS_IN_CHARGE
)
5267 user_args
= TREE_CHAIN (args
);
5269 for (fns
= args
; fns
; fns
= TREE_CHAIN (fns
))
5270 if (TREE_VALUE (fns
) == error_mark_node
)
5271 return error_mark_node
;
5273 if (instance
== NULL_TREE
)
5274 basetype
= BINFO_TYPE (basetype_path
);
5277 if (TREE_CODE (instance
) == OFFSET_REF
)
5278 instance
= resolve_offset_ref (instance
);
5279 if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
5280 instance
= convert_from_reference (instance
);
5281 basetype
= TREE_TYPE (instance
);
5283 /* XXX this should be handled before we get here. */
5284 if (! IS_AGGR_TYPE (basetype
)
5285 && ! (TYPE_LANG_SPECIFIC (basetype
)
5286 && (IS_SIGNATURE_POINTER (basetype
)
5287 || IS_SIGNATURE_REFERENCE (basetype
))))
5289 if ((flags
& LOOKUP_COMPLAIN
) && basetype
!= error_mark_node
)
5290 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5291 name
, instance
, basetype
);
5293 return error_mark_node
;
5296 /* If `instance' is a signature pointer/reference and `name' is
5297 not a constructor, we are calling a signature member function.
5298 In that case set the `basetype' to the signature type. */
5299 if ((IS_SIGNATURE_POINTER (basetype
)
5300 || IS_SIGNATURE_REFERENCE (basetype
))
5301 && TYPE_IDENTIFIER (basetype
) != name
)
5302 basetype
= SIGNATURE_TYPE (basetype
);
5305 if (basetype_path
== NULL_TREE
)
5306 basetype_path
= TYPE_BINFO (basetype
);
5310 instance_ptr
= build_this (instance
);
5312 /* XXX this should be handled before we get here. */
5313 fns
= build_field_call (basetype_path
, instance_ptr
, name
, args
);
5319 instance_ptr
= build_int_2 (0, 0);
5320 TREE_TYPE (instance_ptr
) = build_pointer_type (basetype
);
5324 = (name
== ctor_identifier
? constructor_name_full (basetype
) : name
);
5326 fns
= lookup_fnfields (basetype_path
, name
, 1);
5328 if (fns
== error_mark_node
)
5329 return error_mark_node
;
5332 tree t
= TREE_VALUE (fns
);
5333 if (name
== ctor_identifier
&& TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
5334 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
5336 flags
|= LOOKUP_HAS_IN_CHARGE
;
5337 args
= tree_cons (NULL_TREE
, integer_one_node
, args
);
5339 mem_args
= tree_cons (NULL_TREE
, instance_ptr
, args
);
5340 for (; t
; t
= DECL_CHAIN (t
))
5342 /* We can end up here for copy-init of same or base class. */
5343 if (name
== ctor_identifier
5344 && (flags
& LOOKUP_ONLYCONVERTING
)
5345 && DECL_NONCONVERTING_P (t
))
5347 if (TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
)
5348 candidates
= add_function_candidate
5349 (candidates
, t
, mem_args
, flags
);
5351 candidates
= add_function_candidate (candidates
, t
, args
, flags
);
5352 candidates
->basetype_path
= TREE_PURPOSE (fns
);
5356 if (! any_viable (candidates
))
5358 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5359 if (flags
& LOOKUP_SPECULATIVELY
)
5361 cp_error ("no matching function for call to `%T::%D (%A)%V'", basetype
,
5362 pretty_name
, user_args
, TREE_TYPE (TREE_TYPE (instance_ptr
)));
5363 print_z_candidates (candidates
);
5364 return error_mark_node
;
5366 candidates
= splice_viable (candidates
);
5367 cand
= tourney (candidates
, NULL_TREE
);
5371 cp_error ("call of overloaded `%D(%A)' is ambiguous", pretty_name
,
5373 print_z_candidates (candidates
);
5374 return error_mark_node
;
5377 enforce_access (cand
->basetype_path
, cand
->fn
);
5378 if (DECL_ABSTRACT_VIRTUAL_P (cand
->fn
)
5379 && instance
== current_class_ref
5380 && DECL_CONSTRUCTOR_P (current_function_decl
)
5381 && ! (flags
& LOOKUP_NONVIRTUAL
)
5382 && value_member (cand
->fn
, get_abstract_virtuals (basetype
)))
5383 cp_error ("abstract virtual `%#D' called from constructor", cand
->fn
);
5384 if (TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
5385 && TREE_CODE (instance_ptr
) == NOP_EXPR
5386 && TREE_OPERAND (instance_ptr
, 0) == error_mark_node
)
5387 cp_error ("cannot call member function `%D' without object", cand
->fn
);
5389 if (DECL_VINDEX (cand
->fn
) && ! (flags
& LOOKUP_NONVIRTUAL
)
5390 && ((instance
== current_class_ref
&& (dtor_label
|| ctor_label
))
5391 || resolves_to_fixed_type_p (instance
, 0)))
5392 flags
|= LOOKUP_NONVIRTUAL
;
5394 return build_over_call
5395 (cand
->fn
, cand
->convs
,
5396 TREE_CODE (TREE_TYPE (cand
->fn
)) == METHOD_TYPE
? mem_args
: args
,
5400 /* Compare two implicit conversion sequences that differ only in their
5401 qualification conversion. Subroutine of compare_ics. */
5404 compare_qual (ics1
, ics2
)
5407 tree to1
= TREE_TYPE (ics1
);
5408 tree to2
= TREE_TYPE (ics2
);
5410 to1
= TREE_TYPE (to1
);
5411 to2
= TREE_TYPE (to2
);
5413 if (TREE_CODE (to1
) == OFFSET_TYPE
)
5415 to1
= TREE_TYPE (to1
);
5416 to2
= TREE_TYPE (to2
);
5419 if (TYPE_READONLY (to1
) >= TYPE_READONLY (to2
)
5420 && TYPE_VOLATILE (to1
) > TYPE_VOLATILE (to2
))
5422 else if (TYPE_READONLY (to1
) > TYPE_READONLY (to2
)
5423 && TYPE_VOLATILE (to1
) == TYPE_VOLATILE (to2
))
5425 else if (TYPE_READONLY (to1
) <= TYPE_READONLY (to2
)
5426 && TYPE_VOLATILE (to1
) < TYPE_VOLATILE (to2
))
5428 else if (TYPE_READONLY (to1
) < TYPE_READONLY (to2
)
5429 && TYPE_VOLATILE (to1
) == TYPE_VOLATILE (to2
))
5434 /* Compare two implicit conversion sequences according to the rules set out in
5435 [over.ics.rank]. Return values:
5437 1: ics1 is better than ics2
5438 -1: ics2 is better than ics1
5439 0: ics1 and ics2 are indistinguishable */
5442 compare_ics (ics1
, ics2
)
5447 if (TREE_CODE (ics1
) == QUAL_CONV
)
5448 main1
= TREE_OPERAND (ics1
, 0);
5452 if (TREE_CODE (ics2
) == QUAL_CONV
)
5453 main2
= TREE_OPERAND (ics2
, 0);
5457 /* Conversions for `this' are PTR_CONVs, but we compare them as though
5458 they were REF_BINDs. */
5459 if (ICS_THIS_FLAG (ics1
))
5462 if (TREE_CODE (t
) == PTR_CONV
)
5463 t
= TREE_OPERAND (t
, 0);
5464 t
= build1 (IDENTITY_CONV
, TREE_TYPE (TREE_TYPE (t
)), NULL_TREE
);
5465 t
= build_conv (REF_BIND
, TREE_TYPE (ics1
), t
);
5466 ICS_STD_RANK (t
) = ICS_STD_RANK (main1
);
5469 if (ICS_THIS_FLAG (ics2
))
5472 if (TREE_CODE (t
) == PTR_CONV
)
5473 t
= TREE_OPERAND (t
, 0);
5474 t
= build1 (IDENTITY_CONV
, TREE_TYPE (TREE_TYPE (t
)), NULL_TREE
);
5475 t
= build_conv (REF_BIND
, TREE_TYPE (ics2
), t
);
5476 ICS_STD_RANK (t
) = ICS_STD_RANK (main2
);
5480 if (ICS_RANK (ics1
) > ICS_RANK (ics2
))
5482 else if (ICS_RANK (ics1
) < ICS_RANK (ics2
))
5485 if (ICS_RANK (ics1
) == BAD_RANK
)
5487 if (ICS_USER_FLAG (ics1
) > ICS_USER_FLAG (ics2
)
5488 || ICS_STD_RANK (ics1
) > ICS_STD_RANK (ics2
))
5490 else if (ICS_USER_FLAG (ics1
) < ICS_USER_FLAG (ics2
)
5491 || ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5494 /* else fall through */
5497 /* User-defined conversion sequence U1 is a better conversion sequence
5498 than another user-defined conversion sequence U2 if they contain the
5499 same user-defined conversion operator or constructor and if the sec-
5500 ond standard conversion sequence of U1 is better than the second
5501 standard conversion sequence of U2. */
5503 if (ICS_USER_FLAG (ics1
))
5507 for (t1
= ics1
; TREE_CODE (t1
) != USER_CONV
; t1
= TREE_OPERAND (t1
, 0))
5508 if (TREE_CODE (t1
) == AMBIG_CONV
)
5510 for (t2
= ics2
; TREE_CODE (t2
) != USER_CONV
; t2
= TREE_OPERAND (t2
, 0))
5511 if (TREE_CODE (t2
) == AMBIG_CONV
)
5514 if (USER_CONV_FN (t1
) != USER_CONV_FN (t2
))
5516 else if (ICS_STD_RANK (ics1
) > ICS_STD_RANK (ics2
))
5518 else if (ICS_STD_RANK (ics1
) < ICS_STD_RANK (ics2
))
5521 /* else fall through */
5524 #if 0 /* Handled by ranking */
5525 /* A conversion that is not a conversion of a pointer, or pointer to
5526 member, to bool is better than another conversion that is such a
5530 if (TREE_CODE (main1
) != TREE_CODE (main2
))
5533 if (TREE_CODE (main1
) == PTR_CONV
|| TREE_CODE (main1
) == PMEM_CONV
5534 || TREE_CODE (main1
) == REF_BIND
|| TREE_CODE (main1
) == BASE_CONV
)
5536 tree to1
= TREE_TYPE (main1
);
5537 tree from1
= TREE_TYPE (TREE_OPERAND (main1
, 0));
5538 tree to2
= TREE_TYPE (main2
);
5539 tree from2
= TREE_TYPE (TREE_OPERAND (main2
, 0));
5542 /* Standard conversion sequence S1 is a better conversion sequence than
5543 standard conversion sequence S2 if...
5545 S1 and S2 differ only in their qualification conversion and they
5546 yield types identical except for cv-qualifiers and S2 adds all the
5547 qualifiers that S1 adds (and in the same places) and S2 adds yet
5548 more cv-qualifiers than S1, or the similar case with reference
5550 if (TREE_CODE (main1
) == REF_BIND
)
5552 if (TYPE_MAIN_VARIANT (TREE_TYPE (to1
))
5553 == TYPE_MAIN_VARIANT (TREE_TYPE (to2
)))
5554 return compare_qual (ics1
, ics2
);
5556 else if (TREE_CODE (main1
) != BASE_CONV
&& from1
== from2
&& to1
== to2
)
5557 return compare_qual (ics1
, ics2
);
5559 if (TYPE_PTRMEMFUNC_P (to1
))
5561 to1
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to1
));
5562 from1
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from1
));
5564 else if (TREE_CODE (main1
) != BASE_CONV
)
5566 to1
= TREE_TYPE (to1
);
5567 if (TREE_CODE (main1
) != REF_BIND
)
5568 from1
= TREE_TYPE (from1
);
5570 if (TREE_CODE (to1
) == OFFSET_TYPE
)
5572 to1
= TYPE_OFFSET_BASETYPE (to1
);
5573 from1
= TYPE_OFFSET_BASETYPE (from1
);
5577 if (TYPE_PTRMEMFUNC_P (to2
))
5579 to2
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to2
));
5580 from2
= TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from2
));
5582 else if (TREE_CODE (main1
) != BASE_CONV
)
5584 to2
= TREE_TYPE (to2
);
5585 if (TREE_CODE (main1
) != REF_BIND
)
5586 from2
= TREE_TYPE (from2
);
5588 if (TREE_CODE (to2
) == OFFSET_TYPE
)
5590 to2
= TYPE_OFFSET_BASETYPE (to2
);
5591 from2
= TYPE_OFFSET_BASETYPE (from2
);
5595 if (! (IS_AGGR_TYPE (from1
) && IS_AGGR_TYPE (from2
)))
5598 /* The sense of pmem conversions is reversed from that of the other
5600 if (TREE_CODE (main1
) == PMEM_CONV
)
5602 tree t
= from1
; from1
= from2
; from2
= t
;
5603 t
= to1
; to1
= to2
; to2
= t
;
5606 distf
= get_base_distance (from1
, from2
, 0, 0);
5609 distf
= -get_base_distance (from2
, from1
, 0, 0);
5614 /* If class B is derived directly or indirectly from class A,
5615 conver- sion of B* to A* is better than conversion of B* to
5616 void*, and conversion of A* to void* is better than
5617 conversion of B* to void*. */
5619 if (TREE_CODE (to1
) == VOID_TYPE
&& TREE_CODE (to2
) == VOID_TYPE
)
5626 else if (TREE_CODE (to2
) == VOID_TYPE
&& IS_AGGR_TYPE (to1
)
5627 && get_base_distance (to1
, from1
, 0, 0) != -1)
5629 else if (TREE_CODE (to1
) == VOID_TYPE
&& IS_AGGR_TYPE (to2
)
5630 && get_base_distance (to2
, from2
, 0, 0) != -1)
5633 if (! (IS_AGGR_TYPE (to1
) && IS_AGGR_TYPE (to2
)))
5636 /* If class B is derived directly or indirectly from class A and class
5637 C is derived directly or indirectly from B */
5639 distt
= get_base_distance (to1
, to2
, 0, 0);
5642 distt
= -get_base_distance (to2
, to1
, 0, 0);
5647 /* --conversion of C* to B* is better than conversion of C* to A*, */
5655 /* --conversion of B* to A* is better than conversion of C* to A*, */
5656 else if (distt
== 0)
5664 else if (TREE_CODE (TREE_TYPE (main1
)) == POINTER_TYPE
5665 || TYPE_PTRMEMFUNC_P (TREE_TYPE (main1
)))
5667 if (TREE_TYPE (main1
) == TREE_TYPE (main2
))
5668 return compare_qual (ics1
, ics2
);
5670 #if 0 /* This is now handled by making identity better than anything else. */
5671 /* existing practice, not WP-endorsed: const char * -> const char *
5672 is better than char * -> const char *. (jason 6/29/96) */
5673 if (TREE_TYPE (ics1
) == TREE_TYPE (ics2
))
5674 return -compare_qual (main1
, main2
);
5681 /* Compare two candidates for overloading as described in
5682 [over.match.best]. Return values:
5684 1: cand1 is better than cand2
5685 -1: cand2 is better than cand1
5686 0: cand1 and cand2 are indistinguishable */
5689 joust (cand1
, cand2
)
5690 struct z_candidate
*cand1
, *cand2
;
5693 int i
, off1
= 0, off2
= 0, len
;
5695 /* Candidates that involve bad conversions are always worse than those
5697 if (cand1
->viable
> cand2
->viable
)
5699 if (cand1
->viable
< cand2
->viable
)
5702 /* a viable function F1
5703 is defined to be a better function than another viable function F2 if
5704 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5705 ICSi(F2), and then */
5707 /* for some argument j, ICSj(F1) is a better conversion sequence than
5710 /* For comparing static and non-static member functions, we ignore the
5711 implicit object parameter of the non-static function. The WP says to
5712 pretend that the static function has an object parm, but that won't
5713 work with operator overloading. */
5714 len
= TREE_VEC_LENGTH (cand1
->convs
);
5715 if (len
!= TREE_VEC_LENGTH (cand2
->convs
))
5717 if (DECL_STATIC_FUNCTION_P (cand1
->fn
)
5718 && ! DECL_STATIC_FUNCTION_P (cand2
->fn
))
5720 else if (! DECL_STATIC_FUNCTION_P (cand1
->fn
)
5721 && DECL_STATIC_FUNCTION_P (cand2
->fn
))
5727 my_friendly_abort (42);
5730 for (i
= 0; i
< len
; ++i
)
5732 int comp
= compare_ics (TREE_VEC_ELT (cand1
->convs
, i
+off1
),
5733 TREE_VEC_ELT (cand2
->convs
, i
+off2
));
5737 if (winner
&& comp
!= winner
)
5750 F1 is a non-template function and F2 is a template function */
5752 if (! cand1
->template && cand2
->template)
5754 else if (cand1
->template && ! cand2
->template)
5756 else if (cand1
->template && cand2
->template)
5757 winner
= more_specialized
5758 (TI_TEMPLATE (cand1
->template), TI_TEMPLATE (cand2
->template));
5761 the context is an initialization by user-defined conversion (see
5762 _dcl.init_ and _over.match.user_) and the standard conversion
5763 sequence from the return type of F1 to the destination type (i.e.,
5764 the type of the entity being initialized) is a better conversion
5765 sequence than the standard conversion sequence from the return type
5766 of F2 to the destination type. */
5768 if (! winner
&& cand1
->second_conv
)
5769 winner
= compare_ics (cand1
->second_conv
, cand2
->second_conv
);
5771 /* If the built-in candidates are the same, arbitrarily pick one. */
5772 if (! winner
&& cand1
->fn
== cand2
->fn
5773 && TREE_CODE (cand1
->fn
) == IDENTIFIER_NODE
)
5775 for (i
= 0; i
< len
; ++i
)
5776 if (! comptypes (TREE_TYPE (TREE_VEC_ELT (cand1
->convs
, i
)),
5777 TREE_TYPE (TREE_VEC_ELT (cand2
->convs
, i
)), 1))
5779 if (i
== TREE_VEC_LENGTH (cand1
->convs
))
5782 /* Kludge around broken overloading rules whereby
5783 bool ? void *const & : void *const & is ambiguous. */
5784 /* Huh? Explain the problem better. */
5785 if (cand1
->fn
== ansi_opname
[COND_EXPR
])
5787 tree c1
= TREE_VEC_ELT (cand1
->convs
, 1);
5788 tree c2
= TREE_VEC_ELT (cand2
->convs
, 1);
5789 tree t1
= strip_top_quals (non_reference (TREE_TYPE (c1
)));
5790 tree t2
= strip_top_quals (non_reference (TREE_TYPE (c2
)));
5792 if (comptypes (t1
, t2
, 1))
5794 if (TREE_CODE (c1
) == REF_BIND
&& TREE_CODE (c2
) != REF_BIND
)
5796 if (TREE_CODE (c1
) != REF_BIND
&& TREE_CODE (c2
) == REF_BIND
)
5805 /* Extension: If the worst conversion for one candidate is worse than the
5806 worst conversion for the other, take the first. */
5807 if (! winner
&& ! pedantic
)
5809 int rank1
= IDENTITY_RANK
, rank2
= IDENTITY_RANK
;
5811 for (i
= 0; i
< len
; ++i
)
5813 if (ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
)) > rank1
)
5814 rank1
= ICS_RANK (TREE_VEC_ELT (cand1
->convs
, i
+off1
));
5815 if (ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
)) > rank2
)
5816 rank2
= ICS_RANK (TREE_VEC_ELT (cand2
->convs
, i
+off2
));
5828 /* Given a list of candidates for overloading, find the best one, if any.
5829 This algorithm has a worst case of O(2n) (winner is last), and a best
5830 case of O(n/2) (totally ambiguous); much better than a sorting
5833 static struct z_candidate
*
5834 tourney (candidates
)
5835 struct z_candidate
*candidates
;
5837 struct z_candidate
*champ
= candidates
, *challenger
;
5840 /* Walk through the list once, comparing each current champ to the next
5841 candidate, knocking out a candidate or two with each comparison. */
5843 for (challenger
= champ
->next
; challenger
; )
5845 fate
= joust (champ
, challenger
);
5847 challenger
= challenger
->next
;
5852 champ
= challenger
->next
;
5859 challenger
= champ
->next
;
5863 /* Make sure the champ is better than all the candidates it hasn't yet
5864 been compared to. This may do one more comparison than necessary. Oh
5867 for (challenger
= candidates
; challenger
!= champ
;
5868 challenger
= challenger
->next
)
5870 fate
= joust (champ
, challenger
);
5879 can_convert (to
, from
)
5882 if (flag_ansi_overloading
)
5884 tree t
= implicit_conversion (to
, from
, NULL_TREE
, LOOKUP_NORMAL
);
5885 return (t
&& ! ICS_BAD_FLAG (t
));
5889 struct harshness_code h
;
5890 h
= convert_harshness (to
, from
, NULL_TREE
);
5891 return (h
.code
< USER_CODE
) && (h
.distance
>= 0);
5896 can_convert_arg (to
, from
, arg
)
5899 if (flag_ansi_overloading
)
5901 tree t
= implicit_conversion (to
, from
, arg
, LOOKUP_NORMAL
);
5902 return (t
&& ! ICS_BAD_FLAG (t
));
5906 struct harshness_code h
;
5907 h
= convert_harshness (to
, from
, arg
);
5908 return (h
.code
< USER_CODE
) && (h
.distance
>= 0);