1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /* High-level class interface. */
33 #define obstack_chunk_alloc xmalloc
34 #define obstack_chunk_free free
38 extern int inhibit_warnings
;
39 extern int flag_assume_nonnull_objects
;
40 extern tree ctor_label
, dtor_label
;
43 extern tree
unary_complex_lvalue ();
45 /* Compute the ease with which a conversion can be performed
46 between an expected and the given type. */
47 static struct harshness_code
convert_harshness ();
49 #define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG))
50 #define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG))
51 #define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG))
52 #define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG))
54 /* Ordering function for overload resolution. Compare two candidates
57 rank_for_overload (x
, y
)
58 struct candidate
*x
, *y
;
60 if (y
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
61 return y
->h
.code
- x
->h
.code
;
62 if (x
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
65 /* This is set by compute_conversion_costs, for calling a non-const
66 member function from a const member function. */
67 if ((y
->harshness
[0].code
& CONST_CODE
) ^ (x
->harshness
[0].code
& CONST_CODE
))
68 return y
->harshness
[0].code
- x
->harshness
[0].code
;
70 if (y
->h
.code
& STD_CODE
)
72 if (x
->h
.code
& STD_CODE
)
73 return y
->h
.distance
- x
->h
.distance
;
76 if (x
->h
.code
& STD_CODE
)
79 return y
->h
.code
- x
->h
.code
;
82 /* Compare two candidates, argument by argument. */
85 struct candidate
*x
, *y
;
89 if (x
->h_len
!= y
->h_len
)
92 for (i
= 0; i
< x
->h_len
; i
++)
94 if (y
->harshness
[i
].code
- x
->harshness
[i
].code
)
95 return y
->harshness
[i
].code
- x
->harshness
[i
].code
;
96 if ((y
->harshness
[i
].code
& STD_CODE
)
97 && (y
->harshness
[i
].distance
- x
->harshness
[i
].distance
))
98 return y
->harshness
[i
].distance
- x
->harshness
[i
].distance
;
100 /* They're both the same code. Now see if we're dealing with an
101 integral promotion that needs a finer grain of accuracy. */
102 if (y
->harshness
[0].code
& PROMO_CODE
103 && (y
->harshness
[i
].int_penalty
^ x
->harshness
[i
].int_penalty
))
104 return y
->harshness
[i
].int_penalty
- x
->harshness
[i
].int_penalty
;
109 /* TYPE is the type we wish to convert to. PARM is the parameter
110 we have to work with. We use a somewhat arbitrary cost function
111 to measure this conversion. */
112 static struct harshness_code
113 convert_harshness (type
, parmtype
, parm
)
114 register tree type
, parmtype
;
117 struct harshness_code h
;
118 register enum tree_code codel
;
119 register enum tree_code coder
;
125 #ifdef GATHER_STATISTICS
126 n_convert_harshness
++;
129 if (TYPE_PTRMEMFUNC_P (type
))
130 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
131 if (TYPE_PTRMEMFUNC_P (parmtype
))
132 parmtype
= TYPE_PTRMEMFUNC_FN_TYPE (parmtype
);
134 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
137 parm
= convert_from_reference (parm
);
138 parmtype
= TREE_TYPE (parmtype
);
141 codel
= TREE_CODE (type
);
142 coder
= TREE_CODE (parmtype
);
144 if (TYPE_MAIN_VARIANT (parmtype
) == TYPE_MAIN_VARIANT (type
))
145 return ZERO_RETURN (h
);
147 if (coder
== ERROR_MARK
)
148 return EVIL_RETURN (h
);
150 if (codel
== POINTER_TYPE
&& fntype_p (parmtype
))
153 struct harshness_code h1
, h2
;
155 /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */
156 type
= TREE_TYPE (type
);
158 if (coder
== POINTER_TYPE
)
160 parmtype
= TREE_TYPE (parmtype
);
161 coder
= TREE_CODE (parmtype
);
164 if (coder
!= TREE_CODE (type
))
165 return EVIL_RETURN (h
);
167 /* We allow the default conversion between function type
168 and pointer-to-function type for free. */
169 if (type
== parmtype
)
170 return ZERO_RETURN (h
);
172 /* Compare return types. */
173 p1
= TREE_TYPE (type
);
174 p2
= TREE_TYPE (parmtype
);
175 h2
= convert_harshness (p1
, p2
, NULL_TREE
);
176 if (h2
.code
& EVIL_CODE
)
179 h1
.code
= TRIVIAL_CODE
;
182 if (h2
.distance
!= 0)
186 /* This only works for pointers. */
187 if (TREE_CODE (p1
) != POINTER_TYPE
188 && TREE_CODE (p1
) != REFERENCE_TYPE
)
189 return EVIL_RETURN (h
);
193 /* Don't die if we happen to be dealing with void*. */
194 if (!IS_AGGR_TYPE (p1
) || !IS_AGGR_TYPE (p2
))
195 return EVIL_RETURN (h
);
197 binfo
= get_binfo (p2
, p1
, 0);
199 binfo
= get_binfo (p1
, p2
, 0);
201 if (! BINFO_OFFSET_ZEROP (binfo
))
203 static int explained
= 0;
205 message_2_types (sorry
, "cannot cast `%d' to `%d' at function call site", p2
, p1
);
207 message_2_types (sorry
, "cannot cast `%d' to `%d' at function call site", p1
, p2
);
210 sorry ("(because pointer values change during conversion)");
211 return EVIL_RETURN (h
);
216 if (h2
.distance
> h1
.distance
)
217 h1
.distance
= h2
.distance
;
219 p1
= TYPE_ARG_TYPES (type
);
220 p2
= TYPE_ARG_TYPES (parmtype
);
221 while (p1
&& TREE_VALUE (p1
) != void_type_node
222 && p2
&& TREE_VALUE (p2
) != void_type_node
)
224 h2
= convert_harshness (TREE_VALUE (p1
), TREE_VALUE (p2
),
226 if (h2
.code
& EVIL_CODE
)
231 /* This only works for pointers and references. */
232 if (TREE_CODE (TREE_VALUE (p1
)) != POINTER_TYPE
233 && TREE_CODE (TREE_VALUE (p1
)) != REFERENCE_TYPE
)
234 return EVIL_RETURN (h
);
235 h2
.distance
= - h2
.distance
;
239 if (h2
.distance
> h1
.distance
)
240 h1
.distance
= h2
.distance
;
241 p1
= TREE_CHAIN (p1
);
242 p2
= TREE_CHAIN (p2
);
249 return EVIL_RETURN (h
);
250 h1
.code
|= ELLIPSIS_CODE
;
255 if (TREE_PURPOSE (p1
) == NULL_TREE
)
256 h1
.code
|= EVIL_CODE
;
260 else if (codel
== POINTER_TYPE
&& coder
== OFFSET_TYPE
)
262 /* Get to the OFFSET_TYPE that this might be. */
263 type
= TREE_TYPE (type
);
265 if (coder
!= TREE_CODE (type
))
266 return EVIL_RETURN (h
);
268 if (TYPE_OFFSET_BASETYPE (type
) == TYPE_OFFSET_BASETYPE (parmtype
))
270 else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (type
),
271 TYPE_OFFSET_BASETYPE (parmtype
)))
276 else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (parmtype
),
277 TYPE_OFFSET_BASETYPE (type
)))
283 return EVIL_RETURN (h
);
284 /* Now test the OFFSET_TYPE's target compatibility. */
285 type
= TREE_TYPE (type
);
286 parmtype
= TREE_TYPE (parmtype
);
289 if (coder
== UNKNOWN_TYPE
)
291 if (codel
== FUNCTION_TYPE
292 || codel
== METHOD_TYPE
293 || (codel
== POINTER_TYPE
294 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
295 || TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)))
296 return TRIVIAL_RETURN (h
);
297 return EVIL_RETURN (h
);
300 if (coder
== VOID_TYPE
)
301 return EVIL_RETURN (h
);
303 if (INTEGRAL_CODE_P (codel
))
305 /* Control equivalence of ints an enums. */
307 if (codel
== ENUMERAL_TYPE
308 && flag_int_enum_equivalence
== 0)
310 /* Enums can be converted to ints, but not vice-versa. */
311 if (coder
!= ENUMERAL_TYPE
312 || TYPE_MAIN_VARIANT (type
) != TYPE_MAIN_VARIANT (parmtype
))
313 return EVIL_RETURN (h
);
316 /* else enums and ints (almost) freely interconvert. */
318 if (INTEGRAL_CODE_P (coder
))
320 if (TYPE_MAIN_VARIANT (type
)
321 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
324 #if 0 /* What purpose does this serve? -jason */
325 /* A char, short, wchar_t, etc., should promote to an int if
326 it can handle it, otherwise to an unsigned. So we'll make
328 if (type
!= integer_type_node
)
337 else if (coder
== REAL_TYPE
)
345 if (codel
== REAL_TYPE
)
347 if (coder
== REAL_TYPE
)
349 if (TYPE_MAIN_VARIANT (type
)
350 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
357 else if (INTEGRAL_CODE_P (coder
))
365 /* Convert arrays which have not previously been converted. */
366 if (codel
== ARRAY_TYPE
)
367 codel
= POINTER_TYPE
;
368 if (coder
== ARRAY_TYPE
)
369 coder
= POINTER_TYPE
;
371 /* Conversions among pointers */
372 if (codel
== POINTER_TYPE
&& coder
== POINTER_TYPE
)
374 register tree ttl
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
375 register tree ttr
= TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
));
376 int penalty
= 4 * (ttl
!= ttr
);
378 /* Anything converts to void *. void * converts to anything.
379 Since these may be `const void *' (etc.) use VOID_TYPE
380 instead of void_type_node. Otherwise, the targets must be the same,
381 except that we do allow (at some cost) conversion between signed and
382 unsigned pointer types. */
384 if ((TREE_CODE (ttl
) == METHOD_TYPE
385 || TREE_CODE (ttl
) == FUNCTION_TYPE
)
386 && TREE_CODE (ttl
) == TREE_CODE (ttr
))
388 if (comptypes (ttl
, ttr
, -1))
390 h
.code
= penalty
? STD_CODE
: 0;
399 if (TREE_CODE (ttl
) != VOID_TYPE
&& TREE_CODE (ttr
) != VOID_TYPE
)
401 if (TREE_UNSIGNED (ttl
) != TREE_UNSIGNED (ttr
))
403 ttl
= unsigned_type (ttl
);
404 ttr
= unsigned_type (ttr
);
407 if (! comp_target_types (ttl
, ttr
, 0))
408 return EVIL_RETURN (h
);
411 if (!(TREE_CODE (ttl
) == VOID_TYPE
412 || TREE_CODE (ttr
) == VOID_TYPE
413 || (TREE_UNSIGNED (ttl
) ^ TREE_UNSIGNED (ttr
)
414 && (ttl
= unsigned_type (ttl
),
415 ttr
= unsigned_type (ttr
),
417 || (comp_target_types (ttl
, ttr
, 0))))
418 return EVIL_RETURN (h
);
421 if (penalty
== 10 || ttr
== ttl
)
423 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
425 /* If one was unsigned but the other wasn't, then we need to
426 do a standard conversion from T to unsigned T. */
428 h
.code
= PROMO_CODE
; /* was STD_CODE */
432 /* Note conversion from `T*' to `const T*',
433 or `T*' to `volatile T*'. */
435 && ((TYPE_READONLY (tmp1
) != TREE_READONLY (tmp2
))
436 || (TYPE_VOLATILE (tmp1
) != TYPE_VOLATILE (tmp2
))))
444 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
446 int b_or_d
= get_base_distance (ttl
, ttr
, 0, 0);
449 b_or_d
= get_base_distance (ttr
, ttl
, 0, 0);
451 return EVIL_RETURN (h
);
452 h
.distance
= -b_or_d
;
460 /* If converting from a `class*' to a `void*', make it
461 less favorable than any inheritance relationship. */
462 if (TREE_CODE (ttl
) == VOID_TYPE
&& IS_AGGR_TYPE (ttr
))
465 h
.distance
= CLASSTYPE_MAX_DEPTH (ttr
)+1;
468 h
.code
= penalty
? STD_CODE
: PROMO_CODE
;
472 if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
474 /* This is not a bad match, but don't let it beat
475 integer-enum combinations. */
476 if (parm
&& integer_zerop (parm
))
484 /* C++: Since the `this' parameter of a signature member function
485 is represented as a signature pointer to handle default implementations
486 correctly, we can have the case that `type' is a signature pointer
487 while `parmtype' is a pointer to a signature table. We don't really
488 do any conversions in this case, so just return 0. */
490 if (codel
== RECORD_TYPE
&& coder
== POINTER_TYPE
491 && IS_SIGNATURE_POINTER (type
) && IS_SIGNATURE (TREE_TYPE (parmtype
)))
492 return ZERO_RETURN (h
);
494 if (codel
== REFERENCE_TYPE
)
497 int constp
= parm
? TREE_READONLY (parm
) : TYPE_READONLY (parmtype
);
498 int volatilep
= (parm
? TREE_THIS_VOLATILE (parm
)
499 : TYPE_VOLATILE (parmtype
));
500 register tree intype
= TYPE_MAIN_VARIANT (parmtype
);
501 register enum tree_code form
= TREE_CODE (intype
);
504 ttl
= TREE_TYPE (type
);
506 /* When passing a non-const argument into a const reference (or vice
507 versa), dig it a little, so a non-const reference is preferred
508 over this one. (mrs) */
509 if (TYPE_READONLY (ttl
) != constp
510 || TYPE_VOLATILE (ttl
) != volatilep
)
515 ttl
= TYPE_MAIN_VARIANT (ttl
);
517 if (form
== OFFSET_TYPE
)
519 intype
= TREE_TYPE (intype
);
520 form
= TREE_CODE (intype
);
523 if (ttl
== intype
&& penalty
== 0)
524 return ZERO_RETURN (h
);
528 if (TREE_UNSIGNED (ttl
) ^ TREE_UNSIGNED (intype
))
530 ttl
= unsigned_type (ttl
);
531 intype
= unsigned_type (intype
);
537 /* If the initializer is not an lvalue, then it does not
538 matter if we make life easier for the programmer
539 by creating a temporary variable with which to
541 if (parm
&& (INTEGRAL_CODE_P (coder
)
542 || coder
== REAL_TYPE
)
543 && ! lvalue_p (parm
))
545 h
= convert_harshness (ttl
, ttr
, NULL_TREE
);
546 if (penalty
> 2 || h
.code
!= 0)
549 h
.code
|= TRIVIAL_CODE
;
563 h
.code
= TRIVIAL_CODE
;
564 /* We set this here so that build_overload_call_real will be
565 able to see the penalty we found, rather than just looking
566 at a TRIVIAL_CODE with no other information. */
567 h
.int_penalty
= penalty
;
572 /* Pointers to voids always convert for pointers. But
573 make them less natural than more specific matches. */
574 if (TREE_CODE (ttl
) == POINTER_TYPE
&& TREE_CODE (ttr
) == POINTER_TYPE
)
576 if (TREE_TYPE (ttl
) == void_type_node
577 || TREE_TYPE (ttr
) == void_type_node
)
585 /* Here it does matter. If this conversion is from derived to base,
586 allow it. Otherwise, types must be compatible in the strong sense. */
587 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
589 int b_or_d
= get_base_distance (ttl
, ttr
, 0, 0);
592 b_or_d
= get_base_distance (ttr
, ttl
, 0, 0);
594 return EVIL_RETURN (h
);
595 h
.distance
= -b_or_d
;
597 /* Say that this conversion is relatively painless.
598 If it turns out that there is a user-defined X(X&)
599 constructor, then that will be invoked, but that's
600 preferable to dealing with other user-defined conversions
601 that may produce surprising results. */
608 if (comp_target_types (ttl
, intype
, 1))
616 if (codel
== RECORD_TYPE
&& coder
== RECORD_TYPE
)
618 int b_or_d
= get_base_distance (type
, parmtype
, 0, 0);
621 b_or_d
= get_base_distance (parmtype
, type
, 0, 0);
623 return EVIL_RETURN (h
);
624 h
.distance
= -b_or_d
;
631 return EVIL_RETURN (h
);
634 #ifdef DEBUG_MATCHING
637 struct harshness_code
*h
;
639 static char buf
[1024];
642 bzero (buf
, 1024 * sizeof (char));
643 strcat (buf
, "codes=[");
644 if (h
->code
& EVIL_CODE
)
645 strcat (buf
, "EVIL");
646 if (h
->code
& CONST_CODE
)
647 strcat (buf
, " CONST");
648 if (h
->code
& ELLIPSIS_CODE
)
649 strcat (buf
, " ELLIPSIS");
650 if (h
->code
& USER_CODE
)
651 strcat (buf
, " USER");
652 if (h
->code
& STD_CODE
)
653 strcat (buf
, " STD");
654 if (h
->code
& PROMO_CODE
)
655 strcat (buf
, " PROMO");
656 if (h
->code
& QUAL_CODE
)
657 strcat (buf
, " QUAL");
658 if (h
->code
& TRIVIAL_CODE
)
659 strcat (buf
, " TRIVIAL");
663 sprintf (tmp
, "] distance=%d int_penalty=%d", h
->distance
, h
->int_penalty
);
671 /* Algorithm: For each argument, calculate how difficult it is to
672 make FUNCTION accept that argument. If we can easily tell that
673 FUNCTION won't be acceptable to one of the arguments, then we
674 don't need to compute the ease of converting the other arguments,
675 since it will never show up in the intersection of all arguments'
678 Conversions between builtin and user-defined types are allowed, but
679 no function involving such a conversion is preferred to one which
680 does not require such a conversion. Furthermore, such conversions
684 compute_conversion_costs (function
, tta_in
, cp
, arglen
)
687 struct candidate
*cp
;
690 tree ttf_in
= TYPE_ARG_TYPES (TREE_TYPE (function
));
694 /* Start out with no strikes against. */
695 int evil_strikes
= 0;
696 int ellipsis_strikes
= 0;
697 int user_strikes
= 0;
698 int b_or_d_strikes
= 0;
699 int easy_strikes
= 0;
701 int strike_index
= 0, win
;
702 struct harshness_code lose
;
703 extern int cp_silent
;
705 #ifdef GATHER_STATISTICS
706 n_compute_conversion_costs
++;
709 #ifndef DEBUG_MATCHING
710 /* We don't emit any warnings or errors while trying out each candidate. */
714 cp
->function
= function
;
715 cp
->arg
= tta
? TREE_VALUE (tta
) : NULL_TREE
;
716 cp
->u
.bad_arg
= 0; /* optimistic! */
720 cp
->h
.int_penalty
= 0;
721 bzero (cp
->harshness
,
722 (cp
->h_len
+ 1) * sizeof (struct harshness_code
));
726 struct harshness_code h
;
728 if (ttf
== void_list_node
)
731 if (type_unknown_p (TREE_VALUE (tta
)))
733 /* Must perform some instantiation here. */
734 tree rhs
= TREE_VALUE (tta
);
735 tree lhstype
= TREE_VALUE (ttf
);
737 /* Keep quiet about possible contravariance violations. */
738 int old_inhibit_warnings
= inhibit_warnings
;
739 inhibit_warnings
= 1;
741 /* @@ This is to undo what `grokdeclarator' does to
742 parameter types. It really should go through
743 something more general. */
745 TREE_TYPE (tta
) = unknown_type_node
;
746 rhs
= instantiate_type (lhstype
, rhs
, 0);
747 inhibit_warnings
= old_inhibit_warnings
;
749 if (TREE_CODE (rhs
) == ERROR_MARK
)
752 h
= convert_harshness (lhstype
, TREE_TYPE (rhs
), rhs
);
756 #ifdef DEBUG_MATCHING
757 static tree old_function
= NULL_TREE
;
759 if (!old_function
|| function
!= old_function
)
761 cp_error ("trying %D", function
);
762 old_function
= function
;
765 cp_error (" doing (%T) %E against arg %T",
766 TREE_TYPE (TREE_VALUE (tta
)), TREE_VALUE (tta
),
770 h
= convert_harshness (TREE_VALUE (ttf
),
771 TREE_TYPE (TREE_VALUE (tta
)),
774 #ifdef DEBUG_MATCHING
775 cp_error (" evaluated %s", print_harshness (&h
));
779 cp
->harshness
[strike_index
] = h
;
780 if ((h
.code
& EVIL_CODE
)
781 || ((h
.code
& STD_CODE
) && h
.distance
< 0))
783 cp
->u
.bad_arg
= strike_index
;
786 else if (h
.code
& ELLIPSIS_CODE
)
787 ellipsis_strikes
+= 1;
789 /* This is never set by `convert_harshness'. */
790 else if (h
.code
& USER_CODE
)
797 if ((h
.code
& STD_CODE
) && h
.distance
)
799 if (h
.distance
> b_or_d_strikes
)
800 b_or_d_strikes
= h
.distance
;
803 easy_strikes
+= (h
.code
& (STD_CODE
|PROMO_CODE
|TRIVIAL_CODE
));
804 cp
->h
.code
|= h
.code
;
805 /* Make sure we communicate this. */
806 cp
->h
.int_penalty
+= h
.int_penalty
;
809 ttf
= TREE_CHAIN (ttf
);
810 tta
= TREE_CHAIN (tta
);
816 /* ran out of formals, and parmlist is fixed size. */
817 if (ttf
/* == void_type_node */)
819 cp
->h
.code
= EVIL_CODE
;
826 struct harshness_code h
;
827 int l
= list_length (tta
);
828 ellipsis_strikes
+= l
;
829 h
.code
= ELLIPSIS_CODE
;
833 cp
->harshness
[strike_index
++] = h
;
836 else if (ttf
&& ttf
!= void_list_node
)
838 /* ran out of actuals, and no defaults. */
839 if (TREE_PURPOSE (ttf
) == NULL_TREE
)
841 cp
->h
.code
= EVIL_CODE
;
846 /* Store index of first default. */
847 cp
->harshness
[arglen
].distance
= strike_index
+1;
850 cp
->harshness
[arglen
].distance
= 0;
852 /* Argument list lengths work out, so don't need to check them again. */
855 /* We do not check for derived->base conversions here, since in
856 no case would they give evil strike counts, unless such conversions
857 are somehow ambiguous. */
859 /* See if any user-defined conversions apply.
860 But make sure that we do not loop. */
861 static int dont_convert_types
= 0;
863 if (dont_convert_types
)
865 cp
->h
.code
= EVIL_CODE
;
870 win
= 0; /* Only get one chance to win. */
871 ttf
= TYPE_ARG_TYPES (TREE_TYPE (function
));
878 if (ttf
== void_list_node
)
881 lose
= cp
->harshness
[strike_index
];
882 if ((lose
.code
& EVIL_CODE
)
883 || ((lose
.code
& STD_CODE
) && lose
.distance
< 0))
885 tree actual_type
= TREE_TYPE (TREE_VALUE (tta
));
886 tree formal_type
= TREE_VALUE (ttf
);
887 int extra_conversions
= 0;
889 dont_convert_types
= 1;
891 if (TREE_CODE (formal_type
) == REFERENCE_TYPE
)
892 formal_type
= TREE_TYPE (formal_type
);
893 if (TREE_CODE (actual_type
) == REFERENCE_TYPE
)
894 actual_type
= TREE_TYPE (actual_type
);
896 if (formal_type
!= error_mark_node
897 && actual_type
!= error_mark_node
)
899 formal_type
= TYPE_MAIN_VARIANT (formal_type
);
900 actual_type
= TYPE_MAIN_VARIANT (actual_type
);
902 if (TYPE_HAS_CONSTRUCTOR (formal_type
))
904 /* If it has a constructor for this type,
906 /* @@ There is no way to save this result yet, so
907 success is a NULL_TREE for now. */
908 if (convert_to_aggr (formal_type
, TREE_VALUE (tta
), 0, 1)
912 if (TYPE_LANG_SPECIFIC (actual_type
)
913 && TYPE_HAS_CONVERSION (actual_type
))
916 /* Don't issue warnings since we're only groping
917 around for the right answer, we haven't yet
918 committed to going with this solution. */
919 int old_inhibit_warnings
= inhibit_warnings
;
921 inhibit_warnings
= 1;
922 conv
= build_type_conversion
923 (CALL_EXPR
, TREE_VALUE (ttf
), TREE_VALUE (tta
), 0);
924 inhibit_warnings
= old_inhibit_warnings
;
928 if (conv
== error_mark_node
)
933 if (TREE_CODE (conv
) != CALL_EXPR
)
934 extra_conversions
= 1;
937 else if (TREE_CODE (TREE_VALUE (ttf
)) == REFERENCE_TYPE
)
939 conv
= build_type_conversion (CALL_EXPR
, formal_type
,
940 TREE_VALUE (tta
), 0);
943 if (conv
== error_mark_node
)
948 if (TREE_CODE (conv
) != CALL_EXPR
)
949 extra_conversions
= 1;
955 dont_convert_types
= 0;
960 cp
->harshness
[strike_index
].code
961 = USER_CODE
| (extra_conversions
? STD_CODE
: 0);
966 if (cp
->u
.bad_arg
> strike_index
)
967 cp
->u
.bad_arg
= strike_index
;
969 evil_strikes
= win
? 2 : 1;
974 ttf
= TREE_CHAIN (ttf
);
975 tta
= TREE_CHAIN (tta
);
980 /* Const member functions get a small penalty because defaulting
981 to const is less useful than defaulting to non-const. */
982 /* This is bogus, it does not correspond to anything in the ARM.
983 This code will be fixed when this entire section is rewritten
984 to conform to the ARM. (mrs) */
985 if (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
987 tree this_parm
= TREE_VALUE (ttf_in
);
989 if (TREE_CODE (this_parm
) == RECORD_TYPE
/* Is `this' a sig ptr? */
990 ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm
))))
991 : TYPE_READONLY (TREE_TYPE (this_parm
)))
993 cp
->harshness
[0].code
|= TRIVIAL_CODE
;
998 /* Calling a non-const member function from a const member function
999 is probably invalid, but for now we let it only draw a warning.
1000 We indicate that such a mismatch has occurred by setting the
1001 harshness to a maximum value. */
1002 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in
))) == POINTER_TYPE
1003 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in
))))))
1004 cp
->harshness
[0].code
|= CONST_CODE
;
1009 cp
->h
.code
= EVIL_CODE
;
1010 if (ellipsis_strikes
)
1011 cp
->h
.code
|= ELLIPSIS_CODE
;
1013 cp
->h
.code
|= USER_CODE
;
1015 #ifdef DEBUG_MATCHING
1016 cp_error ("final eval %s", print_harshness (&cp
->h
));
1020 /* Subroutine of ideal_candidate. See if X or Y is a better match
1023 strictly_better (x
, y
)
1024 unsigned short x
, y
;
1032 if (xor >= x
|| xor >= y
)
1037 /* When one of several possible overloaded functions and/or methods
1038 can be called, choose the best candidate for overloading.
1040 BASETYPE is the context from which we start method resolution
1041 or NULL if we are comparing overloaded functions.
1042 CANDIDATES is the array of candidates we have to choose from.
1043 N_CANDIDATES is the length of CANDIDATES.
1044 PARMS is a TREE_LIST of parameters to the function we'll ultimately
1045 choose. It is modified in place when resolving methods. It is not
1046 modified in place when resolving overloaded functions.
1047 LEN is the length of the parameter list. */
1049 static struct candidate
*
1050 ideal_candidate (basetype
, candidates
, n_candidates
, parms
, len
)
1052 struct candidate
*candidates
;
1057 struct candidate
*cp
= candidates
+n_candidates
;
1058 int i
, j
= -1, best_code
;
1060 /* For each argument, sort the functions from best to worst for the arg.
1061 For each function that's not best for this arg, set its overall
1062 harshness to EVIL so that other args won't like it. The candidate
1063 list for the last argument is the intersection of all the best-liked
1067 for (i
= 0; i
< len
; i
++)
1069 qsort (candidates
, n_candidates
, sizeof (struct candidate
),
1071 best_code
= cp
[-1].h
.code
;
1073 /* To find out functions that are worse than that represented
1074 by BEST_CODE, we can't just do a comparison like h.code>best_code.
1075 The total harshness for the "best" fn may be 8|8 for two args, and
1076 the harshness for the next-best may be 8|2. If we just compared,
1077 that would be checking 8>10, which would lead to the next-best
1078 being disqualified. What we actually want to do is get rid
1079 of functions that are definitely worse than that represented
1080 by best_code, i.e. those which have bits set higher than the
1081 highest in best_code. Sooooo, what we do is clear out everything
1082 represented by best_code, and see if we still come up with something
1083 higher. If so (e.g., 8|8 vs 8|16), it'll disqualify it properly. */
1084 for (j
= n_candidates
-2; j
>= 0; j
--)
1085 if ((candidates
[j
].h
.code
& ~best_code
) > best_code
)
1086 candidates
[j
].h
.code
= EVIL_CODE
;
1089 if (cp
[-1].h
.code
& EVIL_CODE
)
1092 qsort (candidates
, n_candidates
, sizeof (struct candidate
),
1094 best_code
= cp
[-1].h
.code
;
1097 /* If they're at least as good as each other, do an arg-by-arg check. */
1098 if (! strictly_better (cp
[-1].h
.code
, cp
[-2].h
.code
))
1103 for (j
= 0; j
< n_candidates
; j
++)
1104 if (! strictly_better (candidates
[j
].h
.code
, best_code
))
1107 qsort (candidates
+j
, n_candidates
-j
, sizeof (struct candidate
),
1109 for (i
= 0; i
< len
; i
++)
1111 if (cp
[-1].harshness
[i
].code
< cp
[-2].harshness
[i
].code
)
1113 else if (cp
[-1].harshness
[i
].code
> cp
[-2].harshness
[i
].code
)
1115 else if (cp
[-1].harshness
[i
].code
& STD_CODE
)
1117 /* If it involves a standard conversion, let the
1118 inheritance lattice be the final arbiter. */
1119 if (cp
[-1].harshness
[i
].distance
> cp
[-2].harshness
[i
].distance
)
1121 else if (cp
[-1].harshness
[i
].distance
< cp
[-2].harshness
[i
].distance
)
1124 else if (cp
[-1].harshness
[i
].code
& PROMO_CODE
)
1126 /* For integral promotions, take into account a finer
1127 granularity for determining which types should be favored
1128 over others in such promotions. */
1129 if (cp
[-1].harshness
[i
].int_penalty
> cp
[-2].harshness
[i
].int_penalty
)
1131 else if (cp
[-1].harshness
[i
].int_penalty
< cp
[-2].harshness
[i
].int_penalty
)
1136 if (! better
|| worse
)
1142 /* Assume that if the class referred to is not in the
1143 current class hierarchy, that it may be remote.
1144 PARENT is assumed to be of aggregate type here. */
1146 may_be_remote (parent
)
1149 if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent
) == 0)
1152 if (current_class_type
== NULL_TREE
)
1155 if (parent
== current_class_type
)
1158 if (UNIQUELY_DERIVED_FROM_P (parent
, current_class_type
))
1164 build_vfield_ref (datum
, type
)
1168 int old_assume_nonnull_objects
= flag_assume_nonnull_objects
;
1170 if (datum
== error_mark_node
)
1171 return error_mark_node
;
1173 /* Vtable references are always made from non-null objects. */
1174 flag_assume_nonnull_objects
= 1;
1175 if (TREE_CODE (TREE_TYPE (datum
)) == REFERENCE_TYPE
)
1176 datum
= convert_from_reference (datum
);
1178 if (! TYPE_USES_COMPLEX_INHERITANCE (type
))
1179 rval
= build (COMPONENT_REF
, TREE_TYPE (CLASSTYPE_VFIELD (type
)),
1180 datum
, CLASSTYPE_VFIELD (type
));
1182 rval
= build_component_ref (datum
, DECL_NAME (CLASSTYPE_VFIELD (type
)), 0, 0);
1183 flag_assume_nonnull_objects
= old_assume_nonnull_objects
;
1188 /* Build a call to a member of an object. I.e., one that overloads
1189 operator ()(), or is a pointer-to-function or pointer-to-method. */
1191 build_field_call (basetype_path
, instance_ptr
, name
, parms
)
1192 tree basetype_path
, instance_ptr
, name
, parms
;
1194 tree field
, instance
;
1196 if (instance_ptr
== current_class_decl
)
1198 /* Check to see if we really have a reference to an instance variable
1199 with `operator()()' overloaded. */
1200 field
= IDENTIFIER_CLASS_VALUE (name
);
1202 if (field
== NULL_TREE
)
1204 cp_error ("`this' has no member named `%D'", name
);
1205 return error_mark_node
;
1208 if (TREE_CODE (field
) == FIELD_DECL
)
1210 /* If it's a field, try overloading operator (),
1211 or calling if the field is a pointer-to-function. */
1212 instance
= build_component_ref_1 (C_C_D
, field
, 0);
1213 if (instance
== error_mark_node
)
1214 return error_mark_node
;
1216 if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1217 && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance
)))
1218 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, instance
, parms
, NULL_TREE
);
1220 if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1222 if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == FUNCTION_TYPE
)
1223 return build_function_call (instance
, parms
);
1224 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == METHOD_TYPE
)
1225 return build_function_call (instance
, tree_cons (NULL_TREE
, current_class_decl
, parms
));
1231 /* Check to see if this is not really a reference to an instance variable
1232 with `operator()()' overloaded. */
1233 field
= lookup_field (basetype_path
, name
, 1, 0);
1235 /* This can happen if the reference was ambiguous or for access
1237 if (field
== error_mark_node
)
1238 return error_mark_node
;
1243 tree ftype
= TREE_TYPE (field
);
1245 if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
1246 ftype
= TREE_TYPE (ftype
);
1248 if (TYPE_LANG_SPECIFIC (ftype
) && TYPE_OVERLOADS_CALL_EXPR (ftype
))
1250 /* Make the next search for this field very short. */
1251 basetype
= DECL_FIELD_CONTEXT (field
);
1252 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
1254 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1255 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
,
1256 build_component_ref_1 (instance
, field
, 0),
1259 if (TREE_CODE (ftype
) == POINTER_TYPE
)
1261 if (TREE_CODE (TREE_TYPE (ftype
)) == FUNCTION_TYPE
1262 || TREE_CODE (TREE_TYPE (ftype
)) == METHOD_TYPE
)
1264 /* This is a member which is a pointer to function. */
1266 = build_component_ref_1 (build_indirect_ref (instance_ptr
,
1268 field
, LOOKUP_COMPLAIN
);
1269 if (ref
== error_mark_node
)
1270 return error_mark_node
;
1271 return build_function_call (ref
, parms
);
1274 else if (TREE_CODE (ftype
) == METHOD_TYPE
)
1276 error ("invalid call via pointer-to-member function");
1277 return error_mark_node
;
1286 find_scoped_type (type
, inner_name
, inner_types
)
1287 tree type
, inner_name
, inner_types
;
1289 tree tags
= CLASSTYPE_TAGS (type
);
1293 /* The TREE_PURPOSE of an enum tag (which becomes a member of the
1294 enclosing class) is set to the name for the enum type. So, if
1295 inner_name is `bar', and we strike `baz' for `enum bar { baz }',
1296 then this test will be true. */
1297 if (TREE_PURPOSE (tags
) == inner_name
)
1299 if (inner_types
== NULL_TREE
)
1300 return DECL_NESTED_TYPENAME (TYPE_NAME (TREE_VALUE (tags
)));
1301 return resolve_scope_to_name (TREE_VALUE (tags
), inner_types
);
1303 tags
= TREE_CHAIN (tags
);
1307 /* XXX This needs to be fixed better. */
1308 if (TREE_CODE (type
) == UNINSTANTIATED_P_TYPE
)
1310 sorry ("nested class lookup in template type");
1315 /* Look for a TYPE_DECL. */
1316 for (tags
= TYPE_FIELDS (type
); tags
; tags
= TREE_CHAIN (tags
))
1317 if (TREE_CODE (tags
) == TYPE_DECL
&& DECL_NAME (tags
) == inner_name
)
1319 /* Code by raeburn. */
1320 if (inner_types
== NULL_TREE
)
1321 return DECL_NESTED_TYPENAME (tags
);
1322 return resolve_scope_to_name (TREE_TYPE (tags
), inner_types
);
1328 /* Resolve an expression NAME1::NAME2::...::NAMEn to
1329 the name that names the above nested type. INNER_TYPES
1330 is a chain of nested type names (held together by SCOPE_REFs);
1331 OUTER_TYPE is the type we know to enclose INNER_TYPES.
1332 Returns NULL_TREE if there is an error. */
1334 resolve_scope_to_name (outer_type
, inner_stuff
)
1335 tree outer_type
, inner_stuff
;
1338 tree inner_name
, inner_type
;
1340 if (outer_type
== NULL_TREE
&& current_class_type
!= NULL_TREE
)
1342 /* We first try to look for a nesting in our current class context,
1343 then try any enclosing classes. */
1344 tree type
= current_class_type
;
1346 while (type
&& (TREE_CODE (type
) == RECORD_TYPE
1347 || TREE_CODE (type
) == UNION_TYPE
))
1349 tree rval
= resolve_scope_to_name (type
, inner_stuff
);
1351 if (rval
!= NULL_TREE
)
1353 type
= DECL_CONTEXT (TYPE_NAME (type
));
1357 if (TREE_CODE (inner_stuff
) == SCOPE_REF
)
1359 inner_name
= TREE_OPERAND (inner_stuff
, 0);
1360 inner_type
= TREE_OPERAND (inner_stuff
, 1);
1364 inner_name
= inner_stuff
;
1365 inner_type
= NULL_TREE
;
1368 if (outer_type
== NULL_TREE
)
1370 /* If we have something that's already a type by itself,
1372 if (IDENTIFIER_HAS_TYPE_VALUE (inner_name
))
1375 return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name
),
1382 if (! IS_AGGR_TYPE (outer_type
))
1385 /* Look for member classes or enums. */
1386 tmp
= find_scoped_type (outer_type
, inner_name
, inner_type
);
1388 /* If it's not a type in this class, then go down into the
1389 base classes and search there. */
1390 if (! tmp
&& TYPE_BINFO (outer_type
))
1392 tree binfos
= TYPE_BINFO_BASETYPES (outer_type
);
1393 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1395 for (i
= 0; i
< n_baselinks
; i
++)
1397 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1398 tmp
= resolve_scope_to_name (BINFO_TYPE (base_binfo
), inner_stuff
);
1408 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
1409 This is how virtual function calls are avoided. */
1411 build_scoped_method_call (exp
, scopes
, name
, parms
)
1412 tree exp
, scopes
, name
, parms
;
1414 /* Because this syntactic form does not allow
1415 a pointer to a base class to be `stolen',
1416 we need not protect the derived->base conversion
1419 @@ But we do have to check access privileges later. */
1420 tree basename
= resolve_scope_to_name (NULL_TREE
, scopes
);
1421 tree basetype
, binfo
, decl
;
1422 tree type
= TREE_TYPE (exp
);
1424 if (type
== error_mark_node
1425 || basename
== NULL_TREE
)
1426 return error_mark_node
;
1428 basetype
= IDENTIFIER_TYPE_VALUE (basename
);
1430 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1431 type
= TREE_TYPE (type
);
1433 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
1434 that explicit ~int is caught in the parser; this deals with typedefs
1435 and template parms. */
1436 if (TREE_CODE (name
) == BIT_NOT_EXPR
&& ! is_aggr_typedef (basename
, 0))
1438 if (type
!= basetype
)
1439 cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
1440 exp
, basetype
, type
);
1441 name
= TREE_OPERAND (name
, 0);
1442 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1443 name
= IDENTIFIER_TYPE_VALUE (name
);
1444 if (basetype
!= name
)
1445 cp_error ("qualified type `%T' does not match destructor type `%T'",
1447 return void_zero_node
;
1450 if (! is_aggr_typedef (basename
, 1))
1451 return error_mark_node
;
1453 if (! IS_AGGR_TYPE (type
))
1455 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
1457 return error_mark_node
;
1460 if ((binfo
= binfo_or_else (basetype
, type
)))
1462 if (binfo
== error_mark_node
)
1463 return error_mark_node
;
1464 if (TREE_CODE (exp
) == INDIRECT_REF
)
1465 decl
= build_indirect_ref (convert_pointer_to (binfo
,
1466 build_unary_op (ADDR_EXPR
, exp
, 0)), NULL_PTR
);
1468 decl
= build_scoped_ref (exp
, scopes
);
1470 /* Call to a destructor. */
1471 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1473 /* Explicit call to destructor. */
1474 name
= TREE_OPERAND (name
, 0);
1475 if (name
!= constructor_name (TREE_TYPE (decl
)))
1478 ("qualified type `%T' does not match destructor type `%T'",
1479 TREE_TYPE (decl
), name
);
1480 return error_mark_node
;
1482 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl
)))
1483 return void_zero_node
;
1485 return build_delete (TREE_TYPE (decl
), decl
, integer_two_node
,
1486 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
,
1490 /* Call to a method. */
1491 return build_method_call (decl
, name
, parms
, binfo
,
1492 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1494 return error_mark_node
;
1498 print_candidates (candidates
)
1501 cp_error_at ("candidates are: %D", TREE_VALUE (candidates
));
1502 candidates
= TREE_CHAIN (candidates
);
1506 cp_error_at (" %D", TREE_VALUE (candidates
));
1507 candidates
= TREE_CHAIN (candidates
);
1512 print_n_candidates (candidates
, n
)
1513 struct candidate
*candidates
;
1518 cp_error_at ("candidates are: %D", candidates
[0].function
);
1519 for (i
= 1; i
< n
; i
++)
1520 cp_error_at (" %D", candidates
[i
].function
);
1523 /* Build something of the form ptr->method (args)
1524 or object.method (args). This can also build
1525 calls to constructors, and find friends.
1527 Member functions always take their class variable
1530 INSTANCE is a class instance.
1532 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
1534 PARMS help to figure out what that NAME really refers to.
1536 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
1537 down to the real instance type to use for access checking. We need this
1538 information to get protected accesses correct. This parameter is used
1539 by build_member_call.
1541 FLAGS is the logical disjunction of zero or more LOOKUP_
1542 flags. See cp-tree.h for more info.
1544 If this is all OK, calls build_function_call with the resolved
1547 This function must also handle being called to perform
1548 initialization, promotion/coercion of arguments, and
1549 instantiation of default parameters.
1551 Note that NAME may refer to an instance variable name. If
1552 `operator()()' is defined for the type of that field, then we return
1555 build_method_call (instance
, name
, parms
, basetype_path
, flags
)
1556 tree instance
, name
, parms
, basetype_path
;
1559 register tree function
, fntype
, value_type
;
1560 register tree basetype
, save_basetype
;
1561 register tree baselink
, result
, method_name
, parmtypes
, parm
;
1564 enum access_type access
= access_public
;
1566 /* Range of cases for vtable optimization. */
1567 enum vtable_needs
{ not_needed
, maybe_needed
, unneeded
, needed
};
1568 enum vtable_needs need_vtbl
= not_needed
;
1572 tree instance_ptr
= NULL_TREE
;
1573 int all_virtual
= flag_all_virtual
;
1574 int static_call_context
= 0;
1575 tree found_fns
= NULL_TREE
;
1577 /* Keep track of `const' and `volatile' objects. */
1578 int constp
, volatilep
;
1580 #ifdef GATHER_STATISTICS
1581 n_build_method_call
++;
1584 if (instance
== error_mark_node
1585 || name
== error_mark_node
1586 || parms
== error_mark_node
1587 || (instance
!= NULL_TREE
&& TREE_TYPE (instance
) == error_mark_node
))
1588 return error_mark_node
;
1590 /* This is the logic that magically deletes the second argument to
1591 operator delete, if it is not needed. */
1592 if (name
== ansi_opname
[(int) DELETE_EXPR
] && list_length (parms
)==2)
1594 tree save_last
= TREE_CHAIN (parms
);
1596 /* get rid of unneeded argument */
1597 TREE_CHAIN (parms
) = NULL_TREE
;
1598 result
= build_method_call (instance
, name
, parms
, basetype_path
,
1599 (LOOKUP_SPECULATIVELY
|flags
)
1601 /* If it works, return it. */
1602 if (result
&& result
!= error_mark_node
)
1603 return build_method_call (instance
, name
, parms
, basetype_path
, flags
);
1604 /* If it doesn't work, two argument delete must work */
1605 TREE_CHAIN (parms
) = save_last
;
1607 /* We already know whether it's needed or not for vec delete. */
1608 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
1609 && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance
)))
1610 TREE_CHAIN (parms
) = NULL_TREE
;
1612 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1614 flags
|= LOOKUP_DESTRUCTOR
;
1615 name
= TREE_OPERAND (name
, 0);
1617 error ("destructors take no parameters");
1618 basetype
= TREE_TYPE (instance
);
1619 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1620 basetype
= TREE_TYPE (basetype
);
1621 if (! ((IS_AGGR_TYPE (basetype
)
1622 && name
== constructor_name (basetype
))
1623 || basetype
== get_type_value (name
)))
1625 cp_error ("destructor name `~%D' does not match type `%T' of expression",
1627 return convert (void_type_node
, instance
);
1630 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1631 return convert (void_type_node
, instance
);
1632 instance
= default_conversion (instance
);
1633 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1634 return build_delete (build_pointer_type (basetype
),
1635 instance_ptr
, integer_two_node
,
1636 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0);
1642 /* Initialize name for error reporting. */
1643 if (IDENTIFIER_OPNAME_P (name
) && ! IDENTIFIER_TYPENAME_P (name
))
1645 char *p
= operator_name_string (name
);
1646 xref_name
= (char *)alloca (strlen (p
) + 10);
1647 sprintf (xref_name
, "operator %s", p
);
1649 else if (TREE_CODE (name
) == SCOPE_REF
)
1650 xref_name
= IDENTIFIER_POINTER (TREE_OPERAND (name
, 1));
1652 xref_name
= IDENTIFIER_POINTER (name
);
1654 GNU_xref_call (current_function_decl
, xref_name
);
1657 if (instance
== NULL_TREE
)
1659 basetype
= NULL_TREE
;
1660 /* Check cases where this is really a call to raise
1662 if (current_class_type
&& TREE_CODE (name
) == IDENTIFIER_NODE
)
1664 basetype
= purpose_member (name
, CLASSTYPE_TAGS (current_class_type
));
1666 basetype
= TREE_VALUE (basetype
);
1668 else if (TREE_CODE (name
) == SCOPE_REF
1669 && TREE_CODE (TREE_OPERAND (name
, 0)) == IDENTIFIER_NODE
)
1671 if (! is_aggr_typedef (TREE_OPERAND (name
, 0), 1))
1672 return error_mark_node
;
1673 basetype
= purpose_member (TREE_OPERAND (name
, 1),
1674 CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name
, 0))));
1676 basetype
= TREE_VALUE (basetype
);
1679 if (basetype
!= NULL_TREE
)
1681 /* call to a constructor... */
1682 else if (basetype_path
)
1683 basetype
= BINFO_TYPE (basetype_path
);
1684 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1686 basetype
= IDENTIFIER_TYPE_VALUE (name
);
1687 name
= constructor_name_full (basetype
);
1691 tree typedef_name
= lookup_name (name
, 1);
1692 if (typedef_name
&& TREE_CODE (typedef_name
) == TYPE_DECL
)
1694 /* Canonicalize the typedef name. */
1695 basetype
= TREE_TYPE (typedef_name
);
1696 name
= TYPE_IDENTIFIER (basetype
);
1700 cp_error ("no constructor named `%T' in scope",
1702 return error_mark_node
;
1706 if (! IS_AGGR_TYPE (basetype
))
1709 if ((flags
& LOOKUP_COMPLAIN
) && TREE_CODE (basetype
) != ERROR_MARK
)
1710 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1711 name
, instance
, basetype
);
1713 return error_mark_node
;
1716 else if (instance
== C_C_D
|| instance
== current_class_decl
)
1718 /* When doing initialization, we side-effect the TREE_TYPE of
1719 C_C_D, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */
1720 basetype
= TREE_TYPE (C_C_D
);
1722 /* Anything manifestly `this' in constructors and destructors
1723 has a known type, so virtual function tables are not needed. */
1724 if (TYPE_VIRTUAL_P (basetype
)
1725 && !(flags
& LOOKUP_NONVIRTUAL
))
1726 need_vtbl
= (dtor_label
|| ctor_label
)
1727 ? unneeded
: maybe_needed
;
1730 instance_ptr
= current_class_decl
;
1731 result
= build_field_call (TYPE_BINFO (current_class_type
),
1732 instance_ptr
, name
, parms
);
1737 else if (TREE_CODE (instance
) == RESULT_DECL
)
1739 basetype
= TREE_TYPE (instance
);
1740 /* Should we ever have to make a virtual function reference
1741 from a RESULT_DECL, know that it must be of fixed type
1742 within the scope of this function. */
1743 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1744 need_vtbl
= maybe_needed
;
1745 instance_ptr
= build1 (ADDR_EXPR
, TYPE_POINTER_TO (basetype
), instance
);
1749 /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */
1750 tree inst_ptr_basetype
;
1752 static_call_context
=
1753 (TREE_CODE (instance
) == INDIRECT_REF
1754 && TREE_CODE (TREE_OPERAND (instance
, 0)) == NOP_EXPR
1755 && TREE_OPERAND (TREE_OPERAND (instance
, 0), 0) == error_mark_node
);
1757 if (TREE_CODE (instance
) == OFFSET_REF
)
1758 instance
= resolve_offset_ref (instance
);
1760 /* the base type of an instance variable is pointer to class */
1761 basetype
= TREE_TYPE (instance
);
1763 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1765 basetype
= TREE_TYPE (basetype
);
1766 if (! IS_AGGR_TYPE (basetype
))
1767 goto non_aggr_error
;
1768 /* Call to convert not needed because we are remaining
1769 within the same type. */
1770 instance_ptr
= build1 (NOP_EXPR
, build_pointer_type (basetype
),
1772 inst_ptr_basetype
= TYPE_MAIN_VARIANT (basetype
);
1776 if (! IS_AGGR_TYPE (basetype
))
1777 goto non_aggr_error
;
1779 /* If `instance' is a signature pointer/reference and `name' is
1780 not a constructor, we are calling a signature member function.
1781 In that case set the `basetype' to the signature type. */
1782 if ((IS_SIGNATURE_POINTER (basetype
)
1783 || IS_SIGNATURE_REFERENCE (basetype
))
1784 && TYPE_IDENTIFIER (basetype
) != name
)
1785 basetype
= SIGNATURE_TYPE (basetype
);
1787 if ((IS_SIGNATURE (basetype
)
1788 && (instance_ptr
= build_optr_ref (instance
)))
1789 || (lvalue_p (instance
)
1790 && (instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0)))
1791 || (instance_ptr
= unary_complex_lvalue (ADDR_EXPR
, instance
)))
1793 if (instance_ptr
== error_mark_node
)
1794 return error_mark_node
;
1796 else if (TREE_CODE (instance
) == NOP_EXPR
1797 || TREE_CODE (instance
) == CONSTRUCTOR
)
1799 /* A cast is not an lvalue. Initialize a fresh temp
1800 with the value we are casting from, and proceed with
1801 that temporary. We can't cast to a reference type,
1802 so that simplifies the initialization to something
1804 tree temp
= get_temp_name (TREE_TYPE (instance
), 0);
1805 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
1806 expand_aggr_init (temp
, instance
, 0);
1809 store_init_value (temp
, instance
);
1810 expand_decl_init (temp
);
1813 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1817 if (TREE_CODE (instance
) != CALL_EXPR
)
1818 my_friendly_abort (125);
1819 if (TYPE_NEEDS_CONSTRUCTING (basetype
))
1820 instance
= build_cplus_new (basetype
, instance
, 0);
1823 instance
= get_temp_name (basetype
, 0);
1824 TREE_ADDRESSABLE (instance
) = 1;
1826 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1828 /* @@ Should we call comp_target_types here? */
1829 inst_ptr_basetype
= TREE_TYPE (TREE_TYPE (instance_ptr
));
1830 if (TYPE_MAIN_VARIANT (basetype
) == TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1831 basetype
= inst_ptr_basetype
;
1834 instance_ptr
= convert (TYPE_POINTER_TO (basetype
), instance_ptr
);
1835 if (instance_ptr
== error_mark_node
)
1836 return error_mark_node
;
1840 /* After converting `instance_ptr' above, `inst_ptr_basetype' was
1841 not updated, so we use `basetype' instead. */
1842 if (basetype_path
== NULL_TREE
1843 && IS_SIGNATURE (basetype
))
1844 basetype_path
= TYPE_BINFO (basetype
);
1845 else if (basetype_path
== NULL_TREE
||
1846 BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1847 basetype_path
= TYPE_BINFO (inst_ptr_basetype
);
1849 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1853 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1855 if (TREE_SIDE_EFFECTS (instance_ptr
))
1857 /* This action is needed because the instance is needed
1858 for providing the base of the virtual function table.
1859 Without using a SAVE_EXPR, the function we are building
1860 may be called twice, or side effects on the instance
1861 variable (such as a post-increment), may happen twice. */
1862 instance_ptr
= save_expr (instance_ptr
);
1863 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1865 else if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1867 /* This happens when called for operator new (). */
1868 instance
= build_indirect_ref (instance
, NULL_PTR
);
1871 need_vtbl
= maybe_needed
;
1875 if (TYPE_SIZE (basetype
) == 0)
1877 /* This is worth complaining about, I think. */
1878 cp_error ("cannot lookup method in incomplete type `%T'", basetype
);
1879 return error_mark_node
;
1882 save_basetype
= TYPE_MAIN_VARIANT (basetype
);
1885 if (all_virtual
== 1
1886 && (! strncmp (IDENTIFIER_POINTER (name
), OPERATOR_METHOD_FORMAT
,
1887 OPERATOR_METHOD_LENGTH
)
1888 || instance_ptr
== NULL_TREE
1889 || (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype
) == 0)))
1894 for (parmtypes
= NULL_TREE
, parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1896 tree t
= TREE_TYPE (TREE_VALUE (parm
));
1897 if (TREE_CODE (t
) == OFFSET_TYPE
)
1899 /* Convert OFFSET_TYPE entities to their normal selves. */
1900 TREE_VALUE (parm
) = resolve_offset_ref (TREE_VALUE (parm
));
1901 t
= TREE_TYPE (TREE_VALUE (parm
));
1903 if (TREE_CODE (TREE_VALUE (parm
)) == OFFSET_REF
1904 && TREE_CODE (t
) == METHOD_TYPE
)
1906 TREE_VALUE (parm
) = build_unary_op (ADDR_EXPR
, TREE_VALUE (parm
), 0);
1909 /* This breaks reference-to-array parameters. */
1910 if (TREE_CODE (t
) == ARRAY_TYPE
)
1912 /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
1913 This eliminates needless calls to `compute_conversion_costs'. */
1914 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
1915 t
= TREE_TYPE (TREE_VALUE (parm
));
1918 if (t
== error_mark_node
)
1919 return error_mark_node
;
1920 last
= build_tree_list (NULL_TREE
, t
);
1921 parmtypes
= chainon (parmtypes
, last
);
1926 /* TREE_READONLY (instance) fails for references. */
1927 constp
= TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr
)));
1928 volatilep
= TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr
)));
1929 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
1933 /* Raw constructors are always in charge. */
1934 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
1935 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
1937 flags
|= LOOKUP_HAS_IN_CHARGE
;
1938 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
1939 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
1942 if (flag_this_is_variable
> 0)
1946 parms
= tree_cons (NULL_TREE
, build1 (NOP_EXPR
, TYPE_POINTER_TO (basetype
), integer_zero_node
), parms
);
1952 instance_ptr
= build_new (NULL_TREE
, basetype
, void_type_node
, 0);
1953 if (instance_ptr
== error_mark_node
)
1954 return error_mark_node
;
1955 instance_ptr
= save_expr (instance_ptr
);
1956 TREE_CALLS_NEW (instance_ptr
) = 1;
1957 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1959 /* If it's a default argument initialized from a ctor, what we get
1960 from instance_ptr will match the arglist for the FUNCTION_DECL
1961 of the constructor. */
1962 if (parms
&& TREE_CODE (TREE_VALUE (parms
)) == CALL_EXPR
1963 && TREE_OPERAND (TREE_VALUE (parms
), 1)
1964 && TREE_CALLS_NEW (TREE_VALUE (TREE_OPERAND (TREE_VALUE (parms
), 1))))
1965 parms
= build_tree_list (NULL_TREE
, instance_ptr
);
1967 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
1971 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (instance_ptr
), parmtypes
);
1973 if (last
== NULL_TREE
)
1976 /* Look up function name in the structure type definition. */
1978 if ((IDENTIFIER_HAS_TYPE_VALUE (name
)
1979 && ! IDENTIFIER_OPNAME_P (name
)
1980 && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name
))
1981 && TREE_CODE (IDENTIFIER_TYPE_VALUE (name
)) != UNINSTANTIATED_P_TYPE
)
1982 || name
== constructor_name (basetype
))
1984 tree tmp
= NULL_TREE
;
1985 if (IDENTIFIER_TYPE_VALUE (name
) == basetype
1986 || name
== constructor_name (basetype
))
1987 tmp
= TYPE_BINFO (basetype
);
1989 tmp
= get_binfo (IDENTIFIER_TYPE_VALUE (name
), basetype
, 0);
1991 if (tmp
!= NULL_TREE
)
1993 name_kind
= "constructor";
1995 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
1996 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
1998 /* Constructors called for initialization
1999 only are never in charge. */
2002 flags
|= LOOKUP_HAS_IN_CHARGE
;
2003 tmplist
= tree_cons (NULL_TREE
, integer_zero_node
,
2004 TREE_CHAIN (parms
));
2005 TREE_CHAIN (parms
) = tmplist
;
2006 tmplist
= tree_cons (NULL_TREE
, integer_type_node
, TREE_CHAIN (parmtypes
));
2007 TREE_CHAIN (parmtypes
) = tmplist
;
2009 basetype
= BINFO_TYPE (tmp
);
2012 name_kind
= "method";
2015 name_kind
= "method";
2017 if (basetype_path
== NULL_TREE
2018 || BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (basetype
))
2019 basetype_path
= TYPE_BINFO (basetype
);
2020 result
= lookup_fnfields (basetype_path
, name
,
2021 (flags
& LOOKUP_COMPLAIN
));
2022 if (result
== error_mark_node
)
2023 return error_mark_node
;
2026 /* Now, go look for this method name. We do not find destructors here.
2028 Putting `void_list_node' on the end of the parmtypes
2029 fakes out `build_decl_overload' into doing the right thing. */
2030 TREE_CHAIN (last
) = void_list_node
;
2031 method_name
= build_decl_overload (name
, parmtypes
,
2032 1 + (name
== constructor_name (save_basetype
)
2033 || name
== constructor_name_full (save_basetype
)));
2034 TREE_CHAIN (last
) = NULL_TREE
;
2036 for (pass
= 0; pass
< 2; pass
++)
2038 struct candidate
*candidates
;
2039 struct candidate
*cp
;
2043 /* This increments every time we go up the type hierarchy.
2044 The idea is to prefer a function of the derived class if possible. */
2052 = (struct candidate
*) alloca ((ever_seen
+1)
2053 * sizeof (struct candidate
));
2054 bzero (candidates
, (ever_seen
+ 1) * sizeof (struct candidate
));
2056 len
= list_length (parms
);
2059 /* First see if a global function has a shot at it. */
2060 if (flags
& LOOKUP_GLOBAL
)
2063 tree parm
= instance_ptr
;
2065 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
)
2067 /* TREE_VALUE (parms) may have been modified by now;
2068 restore it to its original value. */
2069 TREE_VALUE (parms
) = parm
;
2070 friend_parms
= parms
;
2072 else if (TREE_CODE (TREE_TYPE (parm
)) == POINTER_TYPE
)
2075 parm
= build_indirect_ref (parm
, "friendifying parms (compiler error)");
2076 new_type
= c_build_type_variant (TREE_TYPE (parm
), constp
,
2078 new_type
= build_reference_type (new_type
);
2079 parm
= convert (new_type
, parm
);
2080 friend_parms
= tree_cons (NULL_TREE
, parm
, TREE_CHAIN (parms
));
2083 my_friendly_abort (167);
2086 cp
->harshness
= (struct harshness_code
*)
2087 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2089 result
= build_overload_call (name
, friend_parms
, 0, cp
);
2090 /* If it turns out to be the one we were actually looking for
2091 (it was probably a friend function), the return the
2093 if (TREE_CODE (result
) == CALL_EXPR
)
2096 while ((cp
->h
.code
& EVIL_CODE
) == 0)
2098 /* non-standard uses: set the field to 0 to indicate
2099 we are using a non-member function. */
2101 if (cp
->harshness
[len
].distance
== 0
2102 && cp
->h
.code
< best
)
2111 /* We have a hit (of sorts). If the parameter list is
2112 "error_mark_node", or some variant thereof, it won't
2113 match any methods. Since we have verified that the is
2114 some method vaguely matching this one (in name at least),
2117 Don't stop for friends, however. */
2118 basetype_path
= TREE_PURPOSE (baselink
);
2120 function
= TREE_VALUE (baselink
);
2121 if (TREE_CODE (basetype_path
) == TREE_LIST
)
2122 basetype_path
= TREE_VALUE (basetype_path
);
2123 basetype
= BINFO_TYPE (basetype_path
);
2125 /* Cast the instance variable if necessary. */
2126 if (basetype
!= TYPE_MAIN_VARIANT
2127 (TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)))))
2129 if (basetype
== save_basetype
)
2130 TREE_VALUE (parms
) = instance_ptr
;
2133 tree type
= build_pointer_type
2134 (build_type_variant (basetype
, constp
, volatilep
));
2135 TREE_VALUE (parms
) = convert_force (type
, instance_ptr
);
2139 /* FIXME: this is the wrong place to get an error. Hopefully
2140 the access-control rewrite will make this change more cleanly. */
2141 if (TREE_VALUE (parms
) == error_mark_node
)
2142 return error_mark_node
;
2144 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function
)))
2145 function
= DECL_CHAIN (function
);
2147 for (; function
; function
= DECL_CHAIN (function
))
2149 #ifdef GATHER_STATISTICS
2150 n_inner_fields_searched
++;
2154 found_fns
= tree_cons (NULL_TREE
, function
, found_fns
);
2156 /* Not looking for friends here. */
2157 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
2158 && ! DECL_STATIC_FUNCTION_P (function
))
2162 && DECL_ASSEMBLER_NAME (function
) == method_name
)
2167 tree these_parms
= parms
;
2169 #ifdef GATHER_STATISTICS
2170 n_inner_fields_searched
++;
2173 cp
->harshness
= (struct harshness_code
*)
2174 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2176 if (DECL_STATIC_FUNCTION_P (function
))
2177 these_parms
= TREE_CHAIN (these_parms
);
2178 compute_conversion_costs (function
, these_parms
, cp
, len
);
2180 if ((cp
->h
.code
& EVIL_CODE
) == 0)
2182 cp
->u
.field
= function
;
2183 cp
->function
= function
;
2184 cp
->basetypes
= basetype_path
;
2186 /* No "two-level" conversions. */
2187 if (flags
& LOOKUP_NO_CONVERSION
2188 && (cp
->h
.code
& USER_CODE
))
2191 /* If we used default parameters, we must
2192 check to see whether anyone else might
2193 use them also, and report a possible
2195 if (! TYPE_USES_MULTIPLE_INHERITANCE (save_basetype
)
2196 && cp
->harshness
[len
].distance
== 0
2197 && cp
->h
.code
< best
)
2199 if (! DECL_STATIC_FUNCTION_P (function
))
2200 TREE_VALUE (parms
) = cp
->arg
;
2202 goto found_and_maybe_warn
;
2208 /* Now we have run through one link's member functions.
2209 arrange to head-insert this link's links. */
2210 baselink
= next_baselink (baselink
);
2212 /* Don't grab functions from base classes. lookup_fnfield will
2213 do the work to get us down into the right place. */
2214 baselink
= NULL_TREE
;
2218 tree igv
= lookup_name_nonclass (name
);
2220 /* No exact match could be found. Now try to find match
2221 using default conversions. */
2222 if ((flags
& LOOKUP_GLOBAL
) && igv
)
2224 if (TREE_CODE (igv
) == FUNCTION_DECL
)
2226 else if (TREE_CODE (igv
) == TREE_LIST
)
2227 ever_seen
+= count_functions (igv
);
2232 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2233 == LOOKUP_SPECULATIVELY
)
2236 TREE_CHAIN (last
) = void_list_node
;
2237 if (flags
& LOOKUP_GLOBAL
)
2238 cp_error ("no global or member function `%D(%A)' defined",
2241 cp_error ("no member function `%T::%D(%A)' defined",
2242 save_basetype
, name
, TREE_CHAIN (parmtypes
));
2243 return error_mark_node
;
2248 if (cp
- candidates
!= 0)
2250 /* Rank from worst to best. Then cp will point to best one.
2251 Private fields have their bits flipped. For unsigned
2252 numbers, this should make them look very large.
2253 If the best alternate has a (signed) negative value,
2254 then all we ever saw were private members. */
2255 if (cp
- candidates
> 1)
2257 int n_candidates
= cp
- candidates
;
2258 TREE_VALUE (parms
) = instance_ptr
;
2259 cp
= ideal_candidate (save_basetype
, candidates
,
2260 n_candidates
, parms
, len
);
2261 if (cp
== (struct candidate
*)0)
2263 if (flags
& LOOKUP_COMPLAIN
)
2265 cp_error ("call of overloaded %s `%D' is ambiguous",
2267 print_n_candidates (candidates
, n_candidates
);
2269 return error_mark_node
;
2271 if (cp
->h
.code
& EVIL_CODE
)
2272 return error_mark_node
;
2274 else if (cp
[-1].h
.code
& EVIL_CODE
)
2276 if (flags
& LOOKUP_COMPLAIN
)
2277 cp_error ("ambiguous type conversion requested for %s `%D'",
2279 return error_mark_node
;
2284 /* The global function was the best, so use it. */
2285 if (cp
->u
.field
== 0)
2287 /* We must convert the instance pointer into a reference type.
2288 Global overloaded functions can only either take
2289 aggregate objects (which come for free from references)
2290 or reference data types anyway. */
2291 TREE_VALUE (parms
) = copy_node (instance_ptr
);
2292 TREE_TYPE (TREE_VALUE (parms
)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2293 return build_function_call (cp
->function
, parms
);
2296 function
= cp
->function
;
2297 basetype_path
= cp
->basetypes
;
2298 if (! DECL_STATIC_FUNCTION_P (function
))
2299 TREE_VALUE (parms
) = cp
->arg
;
2300 goto found_and_maybe_warn
;
2303 if (flags
& (LOOKUP_COMPLAIN
|LOOKUP_SPECULATIVELY
))
2305 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2306 == LOOKUP_SPECULATIVELY
)
2309 if (DECL_STATIC_FUNCTION_P (cp
->function
))
2310 parms
= TREE_CHAIN (parms
);
2313 if (flags
& LOOKUP_SPECULATIVELY
)
2315 if (static_call_context
2316 && TREE_CODE (TREE_TYPE (cp
->function
)) == METHOD_TYPE
)
2317 cp_error ("object missing in call to `%D'", cp
->function
);
2318 else if (ever_seen
> 1)
2320 TREE_CHAIN (last
) = void_list_node
;
2321 cp_error ("no matching function for call to `%T::%D (%A)'",
2322 TREE_TYPE (TREE_TYPE (instance_ptr
)),
2323 name
, TREE_CHAIN (parmtypes
));
2324 TREE_CHAIN (last
) = NULL_TREE
;
2325 print_candidates (found_fns
);
2328 report_type_mismatch (cp
, parms
, name_kind
);
2329 return error_mark_node
;
2332 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2335 cp_error ("%T has no method named %D", save_basetype
, name
);
2336 return error_mark_node
;
2342 found_and_maybe_warn
:
2343 if ((cp
->harshness
[0].code
& CONST_CODE
)
2344 /* 12.1p2: Constructors can be called for const objects. */
2345 && ! DECL_CONSTRUCTOR_P (cp
->function
))
2347 if (flags
& LOOKUP_COMPLAIN
)
2349 cp_error_at ("non-const member function `%D'", cp
->function
);
2350 error ("called for const object at this point in file");
2352 /* Not good enough for a match. */
2354 return error_mark_node
;
2358 /* Silently return error_mark_node. */
2359 return error_mark_node
;
2362 if (flags
& LOOKUP_PROTECT
)
2363 access
= compute_access (basetype_path
, function
);
2365 if (access
== access_private
)
2367 if (flags
& LOOKUP_COMPLAIN
)
2369 cp_error_at ("%s `%+#D' is %s", name_kind
, function
,
2370 TREE_PRIVATE (function
) ? "private"
2371 : "from private base class");
2372 error ("within this context");
2374 return error_mark_node
;
2376 else if (access
== access_protected
)
2378 if (flags
& LOOKUP_COMPLAIN
)
2380 cp_error_at ("%s `%+#D' %s", name_kind
, function
,
2381 TREE_PROTECTED (function
) ? "is protected"
2382 : "has protected accessibility");
2383 error ("within this context");
2385 return error_mark_node
;
2388 /* From here on down, BASETYPE is the type that INSTANCE_PTR's
2389 type (if it exists) is a pointer to. */
2391 if (DECL_ABSTRACT_VIRTUAL_P (function
)
2392 && instance
== C_C_D
2393 && DECL_CONSTRUCTOR_P (current_function_decl
)
2394 && ! (flags
& LOOKUP_NONVIRTUAL
)
2395 && value_member (function
, get_abstract_virtuals (basetype
)))
2396 cp_error ("abstract virtual `%#D' called from constructor", function
);
2398 if (IS_SIGNATURE (basetype
) && static_call_context
)
2400 cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
2402 return error_mark_node
;
2404 else if (IS_SIGNATURE (basetype
))
2405 return build_signature_method_call (basetype
, instance
, function
, parms
);
2407 function
= DECL_MAIN_VARIANT (function
);
2408 /* Declare external function if necessary. */
2409 assemble_external (function
);
2411 fntype
= TREE_TYPE (function
);
2412 if (TREE_CODE (fntype
) == POINTER_TYPE
)
2413 fntype
= TREE_TYPE (fntype
);
2414 basetype
= DECL_CLASS_CONTEXT (function
);
2416 /* If we are referencing a virtual function from an object
2417 of effectively static type, then there is no need
2418 to go through the virtual function table. */
2419 if (need_vtbl
== maybe_needed
)
2421 int fixed_type
= resolves_to_fixed_type_p (instance
, 0);
2423 if (all_virtual
== 1
2424 && DECL_VINDEX (function
)
2425 && may_be_remote (basetype
))
2427 else if (DECL_VINDEX (function
))
2428 need_vtbl
= fixed_type
? unneeded
: needed
;
2430 need_vtbl
= not_needed
;
2433 if (TREE_CODE (fntype
) == METHOD_TYPE
&& static_call_context
2434 && !DECL_CONSTRUCTOR_P (function
))
2436 /* Let's be nice to the user for now, and give reasonable
2437 default behavior. */
2438 instance_ptr
= current_class_decl
;
2441 if (basetype
!= current_class_type
)
2443 tree binfo
= get_binfo (basetype
, current_class_type
, 1);
2444 if (binfo
== NULL_TREE
)
2446 error_not_base_type (function
, current_class_type
);
2447 return error_mark_node
;
2449 else if (basetype
== error_mark_node
)
2450 return error_mark_node
;
2453 /* Only allow a static member function to call another static member
2455 else if (DECL_LANG_SPECIFIC (function
)
2456 && !DECL_STATIC_FUNCTION_P (function
))
2458 cp_error ("cannot call member function `%D' without object",
2460 return error_mark_node
;
2464 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2466 if (TYPE_SIZE (value_type
) == 0)
2468 if (flags
& LOOKUP_COMPLAIN
)
2469 incomplete_type_error (0, value_type
);
2470 return error_mark_node
;
2473 if (DECL_STATIC_FUNCTION_P (function
))
2474 parms
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2475 TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
);
2476 else if (need_vtbl
== unneeded
)
2478 int sub_flags
= DECL_CONSTRUCTOR_P (function
) ? flags
: LOOKUP_NORMAL
;
2479 basetype
= TREE_TYPE (instance
);
2480 if (TYPE_METHOD_BASETYPE (TREE_TYPE (function
)) != TYPE_MAIN_VARIANT (basetype
)
2481 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
2483 basetype
= DECL_CLASS_CONTEXT (function
);
2484 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
2485 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2487 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2488 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, sub_flags
));
2492 if ((flags
& LOOKUP_NONVIRTUAL
) == 0)
2493 basetype
= DECL_CONTEXT (function
);
2495 /* First parm could be integer_zerop with casts like
2496 ((Object*)0)->Object::IsA() */
2497 if (!integer_zerop (TREE_VALUE (parms
)))
2499 /* Since we can't have inheritance with a union, doing get_binfo
2500 on it won't work. We do all the convert_pointer_to_real
2501 stuff to handle MI correctly...for unions, that's not
2502 an issue, so we must short-circuit that extra work here. */
2503 tree tmp
= TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)));
2504 if (tmp
!= NULL_TREE
&& TREE_CODE (tmp
) == UNION_TYPE
)
2505 instance_ptr
= TREE_VALUE (parms
);
2508 tree binfo
= get_binfo (basetype
,
2509 TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
))),
2511 instance_ptr
= convert_pointer_to_real (binfo
, TREE_VALUE (parms
));
2514 = convert_pointer_to (build_type_variant (basetype
,
2518 if (TREE_CODE (instance_ptr
) == COND_EXPR
)
2520 instance_ptr
= save_expr (instance_ptr
);
2521 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2523 else if (TREE_CODE (instance_ptr
) == NOP_EXPR
2524 && TREE_CODE (TREE_OPERAND (instance_ptr
, 0)) == ADDR_EXPR
2525 && TREE_OPERAND (TREE_OPERAND (instance_ptr
, 0), 0) == instance
)
2527 /* The call to `convert_pointer_to' may return error_mark_node. */
2528 else if (TREE_CODE (instance_ptr
) == ERROR_MARK
)
2529 return instance_ptr
;
2530 else if (instance
== NULL_TREE
2531 || TREE_CODE (instance
) != INDIRECT_REF
2532 || TREE_OPERAND (instance
, 0) != instance_ptr
)
2533 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2535 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2536 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
));
2540 /* Constructors do not overload method calls. */
2541 else if (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype
)
2542 && name
!= TYPE_IDENTIFIER (basetype
)
2543 && (TREE_CODE (function
) != FUNCTION_DECL
2544 || strncmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)),
2545 OPERATOR_METHOD_FORMAT
,
2546 OPERATOR_METHOD_LENGTH
))
2547 && (may_be_remote (basetype
) || instance
!= C_C_D
))
2551 parms
= TREE_CHAIN (parms
);
2553 if (!all_virtual
&& TREE_CODE (function
) == FUNCTION_DECL
)
2554 fn_as_int
= build_unary_op (ADDR_EXPR
, function
, 0);
2556 fn_as_int
= convert (TREE_TYPE (default_conversion (function
)), DECL_VINDEX (function
));
2557 if (all_virtual
== 1)
2558 fn_as_int
= convert (integer_type_node
, fn_as_int
);
2560 result
= build_opfncall (METHOD_CALL_EXPR
, LOOKUP_NORMAL
, instance
, fn_as_int
, parms
);
2562 if (result
== NULL_TREE
)
2564 compiler_error ("could not overload `operator->()(...)'");
2565 return error_mark_node
;
2567 else if (result
== error_mark_node
)
2568 return error_mark_node
;
2571 /* Do this if we want the result of operator->() to inherit
2572 the type of the function it is subbing for. */
2573 TREE_TYPE (result
) = value_type
;
2580 if (need_vtbl
== needed
)
2582 function
= build_vfn_ref (&TREE_VALUE (parms
), instance
,
2583 DECL_VINDEX (function
));
2584 TREE_TYPE (function
) = build_pointer_type (fntype
);
2587 if (TREE_CODE (function
) == FUNCTION_DECL
)
2588 GNU_xref_call (current_function_decl
,
2589 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)));
2594 if (TREE_CODE (function
) == FUNCTION_DECL
)
2596 is_constructor
= DECL_CONSTRUCTOR_P (function
);
2597 if (DECL_INLINE (function
))
2598 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
2601 assemble_external (function
);
2602 TREE_USED (function
) = 1;
2603 function
= default_conversion (function
);
2609 function
= default_conversion (function
);
2612 result
= build_nt (CALL_EXPR
, function
, parms
, NULL_TREE
);
2614 TREE_TYPE (result
) = value_type
;
2615 TREE_SIDE_EFFECTS (result
) = 1;
2616 TREE_RAISES (result
)
2617 = TYPE_RAISES_EXCEPTIONS (fntype
) || (parms
&& TREE_RAISES (parms
));
2618 TREE_HAS_CONSTRUCTOR (result
) = is_constructor
;
2623 /* Similar to `build_method_call', but for overloaded non-member functions.
2624 The name of this function comes through NAME. The name depends
2627 Note that this function must handle simple `C' promotions,
2628 as well as variable numbers of arguments (...), and
2629 default arguments to boot.
2631 If the overloading is successful, we return a tree node which
2632 contains the call to the function.
2634 If overloading produces candidates which are probable, but not definite,
2635 we hold these candidates. If FINAL_CP is non-zero, then we are free
2636 to assume that final_cp points to enough storage for all candidates that
2637 this function might generate. The `harshness' array is preallocated for
2638 the first candidate, but not for subsequent ones.
2640 Note that the DECL_RTL of FUNCTION must be made to agree with this
2641 function's new name. */
2644 build_overload_call_real (fnname
, parms
, flags
, final_cp
, buildxxx
)
2647 struct candidate
*final_cp
;
2650 /* must check for overloading here */
2651 tree overload_name
, functions
, function
, parm
;
2652 tree parmtypes
= NULL_TREE
, last
= NULL_TREE
;
2653 register tree outer
;
2655 int parmlength
= list_length (parms
);
2657 struct candidate
*candidates
, *cp
;
2661 final_cp
[0].h
.code
= 0;
2662 final_cp
[0].h
.distance
= 0;
2663 final_cp
[0].function
= 0;
2665 final_cp
[1].h
.code
= EVIL_CODE
;
2668 for (parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
2670 register tree t
= TREE_TYPE (TREE_VALUE (parm
));
2672 if (t
== error_mark_node
)
2675 final_cp
->h
.code
= EVIL_CODE
;
2676 return error_mark_node
;
2678 if (TREE_CODE (t
) == ARRAY_TYPE
|| TREE_CODE (t
) == OFFSET_TYPE
)
2680 /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
2681 Also convert OFFSET_TYPE entities to their normal selves.
2682 This eliminates needless calls to `compute_conversion_costs'. */
2683 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
2684 t
= TREE_TYPE (TREE_VALUE (parm
));
2686 last
= build_tree_list (NULL_TREE
, t
);
2687 parmtypes
= chainon (parmtypes
, last
);
2690 TREE_CHAIN (last
) = void_list_node
;
2692 parmtypes
= void_list_node
;
2694 if (is_overloaded_fn (fnname
))
2697 if (TREE_CODE (fnname
) == TREE_LIST
)
2698 fnname
= TREE_PURPOSE (functions
);
2699 else if (TREE_CODE (fnname
) == FUNCTION_DECL
)
2700 fnname
= DECL_NAME (functions
);
2703 functions
= lookup_name_nonclass (fnname
);
2705 if (functions
== NULL_TREE
)
2707 if (flags
& LOOKUP_SPECULATIVELY
)
2709 if (flags
& LOOKUP_COMPLAIN
)
2710 error ("only member functions apply");
2712 final_cp
->h
.code
= EVIL_CODE
;
2713 return error_mark_node
;
2716 if (TREE_CODE (functions
) == FUNCTION_DECL
&& ! IDENTIFIER_OPNAME_P (fnname
))
2718 functions
= DECL_MAIN_VARIANT (functions
);
2721 /* We are just curious whether this is a viable alternative or
2723 compute_conversion_costs (functions
, parms
, final_cp
, parmlength
);
2727 return build_function_call_real (functions
, parms
, 1, flags
);
2730 if (TREE_CODE (functions
) == TREE_LIST
2731 && TREE_VALUE (functions
) == NULL_TREE
)
2733 if (flags
& LOOKUP_SPECULATIVELY
)
2736 if (flags
& LOOKUP_COMPLAIN
)
2737 cp_error ("function `%D' declared overloaded, but no instances of that function declared",
2738 TREE_PURPOSE (functions
));
2740 final_cp
->h
.code
= EVIL_CODE
;
2741 return error_mark_node
;
2744 length
= count_functions (functions
);
2747 candidates
= final_cp
;
2751 = (struct candidate
*)alloca ((length
+1) * sizeof (struct candidate
));
2752 bzero (candidates
, (length
+ 1) * sizeof (struct candidate
));
2757 my_friendly_assert (is_overloaded_fn (functions
), 169);
2759 functions
= get_first_fn (functions
);
2761 /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
2762 for (outer
= functions
; outer
; outer
= DECL_CHAIN (outer
))
2764 int template_cost
= 0;
2766 if (TREE_CODE (function
) != FUNCTION_DECL
2767 && ! (TREE_CODE (function
) == TEMPLATE_DECL
2768 && ! DECL_TEMPLATE_IS_CLASS (function
)
2769 && TREE_CODE (DECL_TEMPLATE_RESULT (function
)) == FUNCTION_DECL
))
2771 enum tree_code code
= TREE_CODE (function
);
2772 if (code
== TEMPLATE_DECL
)
2773 code
= TREE_CODE (DECL_TEMPLATE_RESULT (function
));
2774 if (code
== CONST_DECL
)
2776 ("enumeral value `%D' conflicts with function of same name",
2778 else if (code
== VAR_DECL
)
2780 if (TREE_STATIC (function
))
2782 ("variable `%D' conflicts with function of same name",
2786 ("constant field `%D' conflicts with function of same name",
2789 else if (code
== TYPE_DECL
)
2792 my_friendly_abort (2);
2793 error ("at this point in file");
2796 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2798 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function
));
2799 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
2802 i
= type_unification (DECL_TEMPLATE_PARMS (function
), targs
,
2803 TYPE_ARG_TYPES (TREE_TYPE (function
)),
2804 parms
, &template_cost
, 0);
2806 function
= instantiate_template (function
, targs
);
2809 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2811 /* Unconverted template -- failed match. */
2812 cp
->function
= function
;
2814 cp
->h
.code
= EVIL_CODE
;
2818 struct candidate
*cp2
;
2820 /* Check that this decl is not the same as a function that's in
2821 the list due to some template instantiation. */
2824 if (cp2
->function
== function
)
2828 if (cp2
->function
== function
)
2831 function
= DECL_MAIN_VARIANT (function
);
2833 /* Can't use alloca here, since result might be
2834 passed to calling function. */
2835 cp
->h_len
= parmlength
;
2836 cp
->harshness
= (struct harshness_code
*)
2837 oballoc ((parmlength
+ 1) * sizeof (struct harshness_code
));
2839 compute_conversion_costs (function
, parms
, cp
, parmlength
);
2841 /* Make sure this is clear as well. */
2842 cp
->h
.int_penalty
+= template_cost
;
2844 if ((cp
[0].h
.code
& EVIL_CODE
) == 0)
2846 cp
[1].h
.code
= EVIL_CODE
;
2852 if (cp
- candidates
)
2854 tree rval
= error_mark_node
;
2857 cp
[0].h
.code
= EVIL_CODE
;
2858 if (cp
- candidates
> 1)
2860 struct candidate
*best_cp
2861 = ideal_candidate (NULL_TREE
, candidates
,
2862 cp
- candidates
, parms
, parmlength
);
2863 if (best_cp
== (struct candidate
*)0)
2865 if (flags
& LOOKUP_COMPLAIN
)
2867 cp_error ("call of overloaded `%D' is ambiguous", fnname
);
2868 print_n_candidates (candidates
, cp
- candidates
);
2870 return error_mark_node
;
2873 rval
= best_cp
->function
;
2878 if (cp
->h
.code
& EVIL_CODE
)
2880 if (flags
& LOOKUP_COMPLAIN
)
2881 error ("type conversion ambiguous");
2884 rval
= cp
->function
;
2890 return buildxxx
? build_function_call_real (rval
, parms
, 0, flags
)
2891 : build_function_call_real (rval
, parms
, 1, flags
);
2894 if (flags
& LOOKUP_SPECULATIVELY
)
2897 if (flags
& LOOKUP_COMPLAIN
)
2898 report_type_mismatch (cp
, parms
, "function",
2899 decl_as_string (cp
->function
, 1));
2901 return error_mark_node
;
2905 build_overload_call (fnname
, parms
, flags
, final_cp
)
2908 struct candidate
*final_cp
;
2910 return build_overload_call_real (fnname
, parms
, flags
, final_cp
, 0);
2914 build_overload_call_maybe (fnname
, parms
, flags
, final_cp
)
2917 struct candidate
*final_cp
;
2919 return build_overload_call_real (fnname
, parms
, flags
, final_cp
, 1);