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 ((char *) 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 (basetype
!= get_type_value (name
))
1443 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1445 return convert (void_type_node
, exp
);
1448 if (! is_aggr_typedef (basename
, 1))
1449 return error_mark_node
;
1451 if (! IS_AGGR_TYPE (type
))
1453 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
1455 return error_mark_node
;
1458 if ((binfo
= binfo_or_else (basetype
, type
)))
1460 if (binfo
== error_mark_node
)
1461 return error_mark_node
;
1462 if (TREE_CODE (exp
) == INDIRECT_REF
)
1463 decl
= build_indirect_ref (convert_pointer_to (binfo
,
1464 build_unary_op (ADDR_EXPR
, exp
, 0)), NULL_PTR
);
1466 decl
= build_scoped_ref (exp
, scopes
);
1468 /* Call to a destructor. */
1469 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1471 /* Explicit call to destructor. */
1472 name
= TREE_OPERAND (name
, 0);
1473 if (! (name
== constructor_name (TREE_TYPE (decl
))
1474 || TREE_TYPE (decl
) == get_type_value (name
)))
1477 ("qualified type `%T' does not match destructor name `~%T'",
1478 TREE_TYPE (decl
), name
);
1479 return error_mark_node
;
1481 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl
)))
1482 return convert (void_type_node
, exp
);
1484 return build_delete (TREE_TYPE (decl
), decl
, integer_two_node
,
1485 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
,
1489 /* Call to a method. */
1490 return build_method_call (decl
, name
, parms
, binfo
,
1491 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1493 return error_mark_node
;
1497 print_candidates (candidates
)
1500 cp_error_at ("candidates are: %D", TREE_VALUE (candidates
));
1501 candidates
= TREE_CHAIN (candidates
);
1505 cp_error_at (" %D", TREE_VALUE (candidates
));
1506 candidates
= TREE_CHAIN (candidates
);
1511 print_n_candidates (candidates
, n
)
1512 struct candidate
*candidates
;
1517 cp_error_at ("candidates are: %D", candidates
[0].function
);
1518 for (i
= 1; i
< n
; i
++)
1519 cp_error_at (" %D", candidates
[i
].function
);
1522 /* Build something of the form ptr->method (args)
1523 or object.method (args). This can also build
1524 calls to constructors, and find friends.
1526 Member functions always take their class variable
1529 INSTANCE is a class instance.
1531 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
1533 PARMS help to figure out what that NAME really refers to.
1535 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
1536 down to the real instance type to use for access checking. We need this
1537 information to get protected accesses correct. This parameter is used
1538 by build_member_call.
1540 FLAGS is the logical disjunction of zero or more LOOKUP_
1541 flags. See cp-tree.h for more info.
1543 If this is all OK, calls build_function_call with the resolved
1546 This function must also handle being called to perform
1547 initialization, promotion/coercion of arguments, and
1548 instantiation of default parameters.
1550 Note that NAME may refer to an instance variable name. If
1551 `operator()()' is defined for the type of that field, then we return
1554 build_method_call (instance
, name
, parms
, basetype_path
, flags
)
1555 tree instance
, name
, parms
, basetype_path
;
1558 register tree function
, fntype
, value_type
;
1559 register tree basetype
, save_basetype
;
1560 register tree baselink
, result
, method_name
, parmtypes
, parm
;
1563 enum access_type access
= access_public
;
1565 /* Range of cases for vtable optimization. */
1566 enum vtable_needs
{ not_needed
, maybe_needed
, unneeded
, needed
};
1567 enum vtable_needs need_vtbl
= not_needed
;
1571 tree instance_ptr
= NULL_TREE
;
1572 int all_virtual
= flag_all_virtual
;
1573 int static_call_context
= 0;
1574 tree found_fns
= NULL_TREE
;
1576 /* Keep track of `const' and `volatile' objects. */
1577 int constp
, volatilep
;
1579 #ifdef GATHER_STATISTICS
1580 n_build_method_call
++;
1583 if (instance
== error_mark_node
1584 || name
== error_mark_node
1585 || parms
== error_mark_node
1586 || (instance
!= NULL_TREE
&& TREE_TYPE (instance
) == error_mark_node
))
1587 return error_mark_node
;
1589 /* This is the logic that magically deletes the second argument to
1590 operator delete, if it is not needed. */
1591 if (name
== ansi_opname
[(int) DELETE_EXPR
] && list_length (parms
)==2)
1593 tree save_last
= TREE_CHAIN (parms
);
1595 /* get rid of unneeded argument */
1596 TREE_CHAIN (parms
) = NULL_TREE
;
1597 result
= build_method_call (instance
, name
, parms
, basetype_path
,
1598 (LOOKUP_SPECULATIVELY
|flags
)
1600 /* If it works, return it. */
1601 if (result
&& result
!= error_mark_node
)
1602 return build_method_call (instance
, name
, parms
, basetype_path
, flags
);
1603 /* If it doesn't work, two argument delete must work */
1604 TREE_CHAIN (parms
) = save_last
;
1606 /* We already know whether it's needed or not for vec delete. */
1607 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
1608 && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance
)))
1609 TREE_CHAIN (parms
) = NULL_TREE
;
1611 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1613 flags
|= LOOKUP_DESTRUCTOR
;
1614 name
= TREE_OPERAND (name
, 0);
1616 error ("destructors take no parameters");
1617 basetype
= TREE_TYPE (instance
);
1618 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1619 basetype
= TREE_TYPE (basetype
);
1620 if (! ((IS_AGGR_TYPE (basetype
)
1621 && name
== constructor_name (basetype
))
1622 || basetype
== get_type_value (name
)))
1624 cp_error ("destructor name `~%D' does not match type `%T' of expression",
1626 return convert (void_type_node
, instance
);
1629 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1630 return convert (void_type_node
, instance
);
1631 instance
= default_conversion (instance
);
1632 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1633 return build_delete (build_pointer_type (basetype
),
1634 instance_ptr
, integer_two_node
,
1635 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0);
1641 /* Initialize name for error reporting. */
1642 if (IDENTIFIER_OPNAME_P (name
) && ! IDENTIFIER_TYPENAME_P (name
))
1644 char *p
= operator_name_string (name
);
1645 xref_name
= (char *)alloca (strlen (p
) + 10);
1646 sprintf (xref_name
, "operator %s", p
);
1648 else if (TREE_CODE (name
) == SCOPE_REF
)
1649 xref_name
= IDENTIFIER_POINTER (TREE_OPERAND (name
, 1));
1651 xref_name
= IDENTIFIER_POINTER (name
);
1653 GNU_xref_call (current_function_decl
, xref_name
);
1656 if (instance
== NULL_TREE
)
1658 basetype
= NULL_TREE
;
1659 /* Check cases where this is really a call to raise
1661 if (current_class_type
&& TREE_CODE (name
) == IDENTIFIER_NODE
)
1663 basetype
= purpose_member (name
, CLASSTYPE_TAGS (current_class_type
));
1665 basetype
= TREE_VALUE (basetype
);
1667 else if (TREE_CODE (name
) == SCOPE_REF
1668 && TREE_CODE (TREE_OPERAND (name
, 0)) == IDENTIFIER_NODE
)
1670 if (! is_aggr_typedef (TREE_OPERAND (name
, 0), 1))
1671 return error_mark_node
;
1672 basetype
= purpose_member (TREE_OPERAND (name
, 1),
1673 CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name
, 0))));
1675 basetype
= TREE_VALUE (basetype
);
1678 if (basetype
!= NULL_TREE
)
1680 /* call to a constructor... */
1681 else if (basetype_path
)
1682 basetype
= BINFO_TYPE (basetype_path
);
1683 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1685 basetype
= IDENTIFIER_TYPE_VALUE (name
);
1686 name
= constructor_name_full (basetype
);
1690 tree typedef_name
= lookup_name (name
, 1);
1691 if (typedef_name
&& TREE_CODE (typedef_name
) == TYPE_DECL
)
1693 /* Canonicalize the typedef name. */
1694 basetype
= TREE_TYPE (typedef_name
);
1695 name
= TYPE_IDENTIFIER (basetype
);
1699 cp_error ("no constructor named `%T' in scope",
1701 return error_mark_node
;
1705 if (! IS_AGGR_TYPE (basetype
))
1708 if ((flags
& LOOKUP_COMPLAIN
) && TREE_CODE (basetype
) != ERROR_MARK
)
1709 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1710 name
, instance
, basetype
);
1712 return error_mark_node
;
1715 else if (instance
== C_C_D
|| instance
== current_class_decl
)
1717 /* When doing initialization, we side-effect the TREE_TYPE of
1718 C_C_D, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */
1719 basetype
= TREE_TYPE (C_C_D
);
1721 /* Anything manifestly `this' in constructors and destructors
1722 has a known type, so virtual function tables are not needed. */
1723 if (TYPE_VIRTUAL_P (basetype
)
1724 && !(flags
& LOOKUP_NONVIRTUAL
))
1725 need_vtbl
= (dtor_label
|| ctor_label
)
1726 ? unneeded
: maybe_needed
;
1729 instance_ptr
= current_class_decl
;
1730 result
= build_field_call (TYPE_BINFO (current_class_type
),
1731 instance_ptr
, name
, parms
);
1736 else if (TREE_CODE (instance
) == RESULT_DECL
)
1738 basetype
= TREE_TYPE (instance
);
1739 /* Should we ever have to make a virtual function reference
1740 from a RESULT_DECL, know that it must be of fixed type
1741 within the scope of this function. */
1742 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1743 need_vtbl
= maybe_needed
;
1744 instance_ptr
= build1 (ADDR_EXPR
, TYPE_POINTER_TO (basetype
), instance
);
1748 /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */
1749 tree inst_ptr_basetype
;
1751 static_call_context
=
1752 (TREE_CODE (instance
) == INDIRECT_REF
1753 && TREE_CODE (TREE_OPERAND (instance
, 0)) == NOP_EXPR
1754 && TREE_OPERAND (TREE_OPERAND (instance
, 0), 0) == error_mark_node
);
1756 if (TREE_CODE (instance
) == OFFSET_REF
)
1757 instance
= resolve_offset_ref (instance
);
1759 /* the base type of an instance variable is pointer to class */
1760 basetype
= TREE_TYPE (instance
);
1762 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1764 basetype
= TREE_TYPE (basetype
);
1765 if (! IS_AGGR_TYPE (basetype
))
1766 goto non_aggr_error
;
1767 /* Call to convert not needed because we are remaining
1768 within the same type. */
1769 instance_ptr
= build1 (NOP_EXPR
, build_pointer_type (basetype
),
1771 inst_ptr_basetype
= TYPE_MAIN_VARIANT (basetype
);
1775 if (! IS_AGGR_TYPE (basetype
))
1776 goto non_aggr_error
;
1778 /* If `instance' is a signature pointer/reference and `name' is
1779 not a constructor, we are calling a signature member function.
1780 In that case set the `basetype' to the signature type. */
1781 if ((IS_SIGNATURE_POINTER (basetype
)
1782 || IS_SIGNATURE_REFERENCE (basetype
))
1783 && TYPE_IDENTIFIER (basetype
) != name
)
1784 basetype
= SIGNATURE_TYPE (basetype
);
1786 if ((IS_SIGNATURE (basetype
)
1787 && (instance_ptr
= build_optr_ref (instance
)))
1788 || (lvalue_p (instance
)
1789 && (instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0)))
1790 || (instance_ptr
= unary_complex_lvalue (ADDR_EXPR
, instance
)))
1792 if (instance_ptr
== error_mark_node
)
1793 return error_mark_node
;
1795 else if (TREE_CODE (instance
) == NOP_EXPR
1796 || TREE_CODE (instance
) == CONSTRUCTOR
)
1798 /* A cast is not an lvalue. Initialize a fresh temp
1799 with the value we are casting from, and proceed with
1800 that temporary. We can't cast to a reference type,
1801 so that simplifies the initialization to something
1803 tree temp
= get_temp_name (TREE_TYPE (instance
), 0);
1804 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
1805 expand_aggr_init (temp
, instance
, 0);
1808 store_init_value (temp
, instance
);
1809 expand_decl_init (temp
);
1812 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1816 if (TREE_CODE (instance
) != CALL_EXPR
1817 #ifdef PCC_STATIC_STRUCT_RETURN
1818 && TREE_CODE (instance
) != RTL_EXPR
1821 my_friendly_abort (125);
1822 if (TYPE_NEEDS_CONSTRUCTING (basetype
))
1823 instance
= build_cplus_new (basetype
, instance
, 0);
1826 instance
= get_temp_name (basetype
, 0);
1827 TREE_ADDRESSABLE (instance
) = 1;
1829 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1831 /* @@ Should we call comp_target_types here? */
1832 inst_ptr_basetype
= TREE_TYPE (TREE_TYPE (instance_ptr
));
1833 if (TYPE_MAIN_VARIANT (basetype
) == TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1834 basetype
= inst_ptr_basetype
;
1837 instance_ptr
= convert (TYPE_POINTER_TO (basetype
), instance_ptr
);
1838 if (instance_ptr
== error_mark_node
)
1839 return error_mark_node
;
1843 /* After converting `instance_ptr' above, `inst_ptr_basetype' was
1844 not updated, so we use `basetype' instead. */
1845 if (basetype_path
== NULL_TREE
1846 && IS_SIGNATURE (basetype
))
1847 basetype_path
= TYPE_BINFO (basetype
);
1848 else if (basetype_path
== NULL_TREE
||
1849 BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1850 basetype_path
= TYPE_BINFO (inst_ptr_basetype
);
1852 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1856 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1858 if (TREE_SIDE_EFFECTS (instance_ptr
))
1860 /* This action is needed because the instance is needed
1861 for providing the base of the virtual function table.
1862 Without using a SAVE_EXPR, the function we are building
1863 may be called twice, or side effects on the instance
1864 variable (such as a post-increment), may happen twice. */
1865 instance_ptr
= save_expr (instance_ptr
);
1866 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1868 else if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1870 /* This happens when called for operator new (). */
1871 instance
= build_indirect_ref (instance
, NULL_PTR
);
1874 need_vtbl
= maybe_needed
;
1878 if (TYPE_SIZE (basetype
) == 0)
1880 /* This is worth complaining about, I think. */
1881 cp_error ("cannot lookup method in incomplete type `%T'", basetype
);
1882 return error_mark_node
;
1885 save_basetype
= TYPE_MAIN_VARIANT (basetype
);
1888 if (all_virtual
== 1
1889 && (! strncmp (IDENTIFIER_POINTER (name
), OPERATOR_METHOD_FORMAT
,
1890 OPERATOR_METHOD_LENGTH
)
1891 || instance_ptr
== NULL_TREE
1892 || (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype
) == 0)))
1897 for (parmtypes
= NULL_TREE
, parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1899 tree t
= TREE_TYPE (TREE_VALUE (parm
));
1900 if (TREE_CODE (t
) == OFFSET_TYPE
)
1902 /* Convert OFFSET_TYPE entities to their normal selves. */
1903 TREE_VALUE (parm
) = resolve_offset_ref (TREE_VALUE (parm
));
1904 t
= TREE_TYPE (TREE_VALUE (parm
));
1906 if (TREE_CODE (TREE_VALUE (parm
)) == OFFSET_REF
1907 && TREE_CODE (t
) == METHOD_TYPE
)
1909 TREE_VALUE (parm
) = build_unary_op (ADDR_EXPR
, TREE_VALUE (parm
), 0);
1912 /* This breaks reference-to-array parameters. */
1913 if (TREE_CODE (t
) == ARRAY_TYPE
)
1915 /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
1916 This eliminates needless calls to `compute_conversion_costs'. */
1917 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
1918 t
= TREE_TYPE (TREE_VALUE (parm
));
1921 if (t
== error_mark_node
)
1922 return error_mark_node
;
1923 last
= build_tree_list (NULL_TREE
, t
);
1924 parmtypes
= chainon (parmtypes
, last
);
1929 /* TREE_READONLY (instance) fails for references. */
1930 constp
= TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr
)));
1931 volatilep
= TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr
)));
1932 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
1936 /* Raw constructors are always in charge. */
1937 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
1938 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
1940 flags
|= LOOKUP_HAS_IN_CHARGE
;
1941 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
1942 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
1945 if (flag_this_is_variable
> 0)
1949 parms
= tree_cons (NULL_TREE
,
1950 build1 (NOP_EXPR
, TYPE_POINTER_TO (basetype
),
1951 integer_zero_node
), parms
);
1957 instance_ptr
= build_new (NULL_TREE
, basetype
, void_type_node
, 0);
1958 if (instance_ptr
== error_mark_node
)
1959 return error_mark_node
;
1960 instance_ptr
= save_expr (instance_ptr
);
1961 TREE_CALLS_NEW (instance_ptr
) = 1;
1962 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1965 /* This breaks initialization of a reference from a new
1966 expression of a different type. And it doesn't appear to
1967 serve its original purpose any more, either. jason 10/12/94 */
1968 /* If it's a default argument initialized from a ctor, what we get
1969 from instance_ptr will match the arglist for the FUNCTION_DECL
1970 of the constructor. */
1971 if (parms
&& TREE_CODE (TREE_VALUE (parms
)) == CALL_EXPR
1972 && TREE_OPERAND (TREE_VALUE (parms
), 1)
1973 && TREE_CALLS_NEW (TREE_VALUE (TREE_OPERAND (TREE_VALUE (parms
), 1))))
1974 parms
= build_tree_list (NULL_TREE
, instance_ptr
);
1977 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
1981 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (instance_ptr
), parmtypes
);
1983 if (last
== NULL_TREE
)
1986 /* Look up function name in the structure type definition. */
1988 if ((IDENTIFIER_HAS_TYPE_VALUE (name
)
1989 && ! IDENTIFIER_OPNAME_P (name
)
1990 && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name
))
1991 && TREE_CODE (IDENTIFIER_TYPE_VALUE (name
)) != UNINSTANTIATED_P_TYPE
)
1992 || name
== constructor_name (basetype
))
1994 tree tmp
= NULL_TREE
;
1995 if (IDENTIFIER_TYPE_VALUE (name
) == basetype
1996 || name
== constructor_name (basetype
))
1997 tmp
= TYPE_BINFO (basetype
);
1999 tmp
= get_binfo (IDENTIFIER_TYPE_VALUE (name
), basetype
, 0);
2001 if (tmp
!= NULL_TREE
)
2003 name_kind
= "constructor";
2005 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2006 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2008 /* Constructors called for initialization
2009 only are never in charge. */
2012 flags
|= LOOKUP_HAS_IN_CHARGE
;
2013 tmplist
= tree_cons (NULL_TREE
, integer_zero_node
,
2014 TREE_CHAIN (parms
));
2015 TREE_CHAIN (parms
) = tmplist
;
2016 tmplist
= tree_cons (NULL_TREE
, integer_type_node
, TREE_CHAIN (parmtypes
));
2017 TREE_CHAIN (parmtypes
) = tmplist
;
2019 basetype
= BINFO_TYPE (tmp
);
2022 name_kind
= "method";
2025 name_kind
= "method";
2027 if (basetype_path
== NULL_TREE
2028 || BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (basetype
))
2029 basetype_path
= TYPE_BINFO (basetype
);
2030 result
= lookup_fnfields (basetype_path
, name
,
2031 (flags
& LOOKUP_COMPLAIN
));
2032 if (result
== error_mark_node
)
2033 return error_mark_node
;
2037 /* Now, go look for this method name. We do not find destructors here.
2039 Putting `void_list_node' on the end of the parmtypes
2040 fakes out `build_decl_overload' into doing the right thing. */
2041 TREE_CHAIN (last
) = void_list_node
;
2042 method_name
= build_decl_overload (name
, parmtypes
,
2043 1 + (name
== constructor_name (save_basetype
)
2044 || name
== constructor_name_full (save_basetype
)));
2045 TREE_CHAIN (last
) = NULL_TREE
;
2048 for (pass
= 0; pass
< 2; pass
++)
2050 struct candidate
*candidates
;
2051 struct candidate
*cp
;
2055 /* This increments every time we go up the type hierarchy.
2056 The idea is to prefer a function of the derived class if possible. */
2064 = (struct candidate
*) alloca ((ever_seen
+1)
2065 * sizeof (struct candidate
));
2066 bzero ((char *) candidates
, (ever_seen
+ 1) * sizeof (struct candidate
));
2068 len
= list_length (parms
);
2071 /* First see if a global function has a shot at it. */
2072 if (flags
& LOOKUP_GLOBAL
)
2075 tree parm
= instance_ptr
;
2077 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
)
2079 /* TREE_VALUE (parms) may have been modified by now;
2080 restore it to its original value. */
2081 TREE_VALUE (parms
) = parm
;
2082 friend_parms
= parms
;
2084 else if (TREE_CODE (TREE_TYPE (parm
)) == POINTER_TYPE
)
2087 parm
= build_indirect_ref (parm
, "friendifying parms (compiler error)");
2088 new_type
= cp_build_type_variant (TREE_TYPE (parm
), constp
,
2090 new_type
= build_reference_type (new_type
);
2091 parm
= convert (new_type
, parm
);
2092 friend_parms
= tree_cons (NULL_TREE
, parm
, TREE_CHAIN (parms
));
2095 my_friendly_abort (167);
2098 cp
->harshness
= (struct harshness_code
*)
2099 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2101 result
= build_overload_call (name
, friend_parms
, 0, cp
);
2102 /* If it turns out to be the one we were actually looking for
2103 (it was probably a friend function), the return the
2105 if (TREE_CODE (result
) == CALL_EXPR
)
2108 while ((cp
->h
.code
& EVIL_CODE
) == 0)
2110 /* non-standard uses: set the field to 0 to indicate
2111 we are using a non-member function. */
2113 if (cp
->harshness
[len
].distance
== 0
2114 && cp
->h
.code
< best
)
2123 /* We have a hit (of sorts). If the parameter list is
2124 "error_mark_node", or some variant thereof, it won't
2125 match any methods. Since we have verified that the is
2126 some method vaguely matching this one (in name at least),
2129 Don't stop for friends, however. */
2130 basetype_path
= TREE_PURPOSE (baselink
);
2132 function
= TREE_VALUE (baselink
);
2133 if (TREE_CODE (basetype_path
) == TREE_LIST
)
2134 basetype_path
= TREE_VALUE (basetype_path
);
2135 basetype
= BINFO_TYPE (basetype_path
);
2137 /* Cast the instance variable if necessary. */
2138 if (basetype
!= TYPE_MAIN_VARIANT
2139 (TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)))))
2141 if (basetype
== save_basetype
)
2142 TREE_VALUE (parms
) = instance_ptr
;
2145 tree type
= build_pointer_type
2146 (build_type_variant (basetype
, constp
, volatilep
));
2147 TREE_VALUE (parms
) = convert_force (type
, instance_ptr
);
2151 /* FIXME: this is the wrong place to get an error. Hopefully
2152 the access-control rewrite will make this change more cleanly. */
2153 if (TREE_VALUE (parms
) == error_mark_node
)
2154 return error_mark_node
;
2156 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function
)))
2157 function
= DECL_CHAIN (function
);
2159 for (; function
; function
= DECL_CHAIN (function
))
2161 #ifdef GATHER_STATISTICS
2162 n_inner_fields_searched
++;
2166 found_fns
= tree_cons (NULL_TREE
, function
, found_fns
);
2168 /* Not looking for friends here. */
2169 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
2170 && ! DECL_STATIC_FUNCTION_P (function
))
2175 && DECL_ASSEMBLER_NAME (function
) == method_name
)
2181 tree these_parms
= parms
;
2183 #ifdef GATHER_STATISTICS
2184 n_inner_fields_searched
++;
2187 cp
->harshness
= (struct harshness_code
*)
2188 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2190 if (DECL_STATIC_FUNCTION_P (function
))
2191 these_parms
= TREE_CHAIN (these_parms
);
2192 compute_conversion_costs (function
, these_parms
, cp
, len
);
2194 if ((cp
->h
.code
& EVIL_CODE
) == 0)
2196 cp
->u
.field
= function
;
2197 cp
->function
= function
;
2198 cp
->basetypes
= basetype_path
;
2200 /* No "two-level" conversions. */
2201 if (flags
& LOOKUP_NO_CONVERSION
2202 && (cp
->h
.code
& USER_CODE
))
2205 /* If we used default parameters, we must
2206 check to see whether anyone else might
2207 use them also, and report a possible
2209 if (! TYPE_USES_MULTIPLE_INHERITANCE (save_basetype
)
2210 && cp
->harshness
[len
].distance
== 0
2211 && cp
->h
.code
< best
)
2213 if (! DECL_STATIC_FUNCTION_P (function
))
2214 TREE_VALUE (parms
) = cp
->arg
;
2216 goto found_and_maybe_warn
;
2222 /* Now we have run through one link's member functions.
2223 arrange to head-insert this link's links. */
2224 baselink
= next_baselink (baselink
);
2226 /* Don't grab functions from base classes. lookup_fnfield will
2227 do the work to get us down into the right place. */
2228 baselink
= NULL_TREE
;
2232 tree igv
= lookup_name_nonclass (name
);
2234 /* No exact match could be found. Now try to find match
2235 using default conversions. */
2236 if ((flags
& LOOKUP_GLOBAL
) && igv
)
2238 if (TREE_CODE (igv
) == FUNCTION_DECL
)
2240 else if (TREE_CODE (igv
) == TREE_LIST
)
2241 ever_seen
+= count_functions (igv
);
2246 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2247 == LOOKUP_SPECULATIVELY
)
2250 TREE_CHAIN (last
) = void_list_node
;
2251 if (flags
& LOOKUP_GLOBAL
)
2252 cp_error ("no global or member function `%D(%A)' defined",
2255 cp_error ("no member function `%T::%D(%A)' defined",
2256 save_basetype
, name
, TREE_CHAIN (parmtypes
));
2257 return error_mark_node
;
2262 if (cp
- candidates
!= 0)
2264 /* Rank from worst to best. Then cp will point to best one.
2265 Private fields have their bits flipped. For unsigned
2266 numbers, this should make them look very large.
2267 If the best alternate has a (signed) negative value,
2268 then all we ever saw were private members. */
2269 if (cp
- candidates
> 1)
2271 int n_candidates
= cp
- candidates
;
2272 extern int warn_synth
;
2273 TREE_VALUE (parms
) = instance_ptr
;
2274 cp
= ideal_candidate (save_basetype
, candidates
,
2275 n_candidates
, parms
, len
);
2276 if (cp
== (struct candidate
*)0)
2278 if (flags
& LOOKUP_COMPLAIN
)
2280 TREE_CHAIN (last
) = void_list_node
;
2281 cp_error ("call of overloaded %s `%D(%A)' is ambiguous",
2282 name_kind
, name
, TREE_CHAIN (parmtypes
));
2283 print_n_candidates (candidates
, n_candidates
);
2285 return error_mark_node
;
2287 if (cp
->h
.code
& EVIL_CODE
)
2288 return error_mark_node
;
2290 && DECL_NAME (cp
->function
) == ansi_opname
[MODIFY_EXPR
]
2291 && DECL_ARTIFICIAL (cp
->function
)
2292 && n_candidates
== 2)
2294 cp_warning ("using synthesized `%#D' for copy assignment",
2296 cp_warning_at (" where cfront would use `%#D'",
2297 candidates
->function
);
2300 else if (cp
[-1].h
.code
& EVIL_CODE
)
2302 if (flags
& LOOKUP_COMPLAIN
)
2303 cp_error ("ambiguous type conversion requested for %s `%D'",
2305 return error_mark_node
;
2310 /* The global function was the best, so use it. */
2311 if (cp
->u
.field
== 0)
2313 /* We must convert the instance pointer into a reference type.
2314 Global overloaded functions can only either take
2315 aggregate objects (which come for free from references)
2316 or reference data types anyway. */
2317 TREE_VALUE (parms
) = copy_node (instance_ptr
);
2318 TREE_TYPE (TREE_VALUE (parms
)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2319 return build_function_call (cp
->function
, parms
);
2322 function
= cp
->function
;
2323 basetype_path
= cp
->basetypes
;
2324 if (! DECL_STATIC_FUNCTION_P (function
))
2325 TREE_VALUE (parms
) = cp
->arg
;
2326 goto found_and_maybe_warn
;
2329 if (flags
& (LOOKUP_COMPLAIN
|LOOKUP_SPECULATIVELY
))
2331 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2332 == LOOKUP_SPECULATIVELY
)
2335 if (DECL_STATIC_FUNCTION_P (cp
->function
))
2336 parms
= TREE_CHAIN (parms
);
2339 if (flags
& LOOKUP_SPECULATIVELY
)
2341 if (static_call_context
2342 && TREE_CODE (TREE_TYPE (cp
->function
)) == METHOD_TYPE
)
2343 cp_error ("object missing in call to `%D'", cp
->function
);
2344 else if (ever_seen
> 1)
2346 TREE_CHAIN (last
) = void_list_node
;
2347 cp_error ("no matching function for call to `%T::%D (%A)'",
2348 TREE_TYPE (TREE_TYPE (instance_ptr
)),
2349 name
, TREE_CHAIN (parmtypes
));
2350 TREE_CHAIN (last
) = NULL_TREE
;
2351 print_candidates (found_fns
);
2354 report_type_mismatch (cp
, parms
, name_kind
);
2355 return error_mark_node
;
2358 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2361 cp_error ("%T has no method named %D", save_basetype
, name
);
2362 return error_mark_node
;
2368 found_and_maybe_warn
:
2369 if ((cp
->harshness
[0].code
& CONST_CODE
)
2370 /* 12.1p2: Constructors can be called for const objects. */
2371 && ! DECL_CONSTRUCTOR_P (cp
->function
))
2373 if (flags
& LOOKUP_COMPLAIN
)
2375 cp_error_at ("non-const member function `%D'", cp
->function
);
2376 error ("called for const object at this point in file");
2378 /* Not good enough for a match. */
2380 return error_mark_node
;
2384 /* Silently return error_mark_node. */
2385 return error_mark_node
;
2388 if (flags
& LOOKUP_PROTECT
)
2389 access
= compute_access (basetype_path
, function
);
2391 if (access
== access_private
)
2393 if (flags
& LOOKUP_COMPLAIN
)
2395 cp_error_at ("%s `%+#D' is %s", name_kind
, function
,
2396 TREE_PRIVATE (function
) ? "private"
2397 : "from private base class");
2398 error ("within this context");
2400 return error_mark_node
;
2402 else if (access
== access_protected
)
2404 if (flags
& LOOKUP_COMPLAIN
)
2406 cp_error_at ("%s `%+#D' %s", name_kind
, function
,
2407 TREE_PROTECTED (function
) ? "is protected"
2408 : "has protected accessibility");
2409 error ("within this context");
2411 return error_mark_node
;
2414 /* From here on down, BASETYPE is the type that INSTANCE_PTR's
2415 type (if it exists) is a pointer to. */
2417 if (DECL_ABSTRACT_VIRTUAL_P (function
)
2418 && instance
== C_C_D
2419 && DECL_CONSTRUCTOR_P (current_function_decl
)
2420 && ! (flags
& LOOKUP_NONVIRTUAL
)
2421 && value_member (function
, get_abstract_virtuals (basetype
)))
2422 cp_error ("abstract virtual `%#D' called from constructor", function
);
2424 if (IS_SIGNATURE (basetype
) && static_call_context
)
2426 cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
2428 return error_mark_node
;
2430 else if (IS_SIGNATURE (basetype
))
2431 return build_signature_method_call (basetype
, instance
, function
, parms
);
2433 function
= DECL_MAIN_VARIANT (function
);
2434 /* Declare external function if necessary. */
2435 assemble_external (function
);
2437 fntype
= TREE_TYPE (function
);
2438 if (TREE_CODE (fntype
) == POINTER_TYPE
)
2439 fntype
= TREE_TYPE (fntype
);
2440 basetype
= DECL_CLASS_CONTEXT (function
);
2442 /* If we are referencing a virtual function from an object
2443 of effectively static type, then there is no need
2444 to go through the virtual function table. */
2445 if (need_vtbl
== maybe_needed
)
2447 int fixed_type
= resolves_to_fixed_type_p (instance
, 0);
2449 if (all_virtual
== 1
2450 && DECL_VINDEX (function
)
2451 && may_be_remote (basetype
))
2453 else if (DECL_VINDEX (function
))
2454 need_vtbl
= fixed_type
? unneeded
: needed
;
2456 need_vtbl
= not_needed
;
2459 if (TREE_CODE (fntype
) == METHOD_TYPE
&& static_call_context
2460 && !DECL_CONSTRUCTOR_P (function
))
2462 /* Let's be nice to the user for now, and give reasonable
2463 default behavior. */
2464 instance_ptr
= current_class_decl
;
2467 if (basetype
!= current_class_type
)
2469 tree binfo
= get_binfo (basetype
, current_class_type
, 1);
2470 if (binfo
== NULL_TREE
)
2472 error_not_base_type (function
, current_class_type
);
2473 return error_mark_node
;
2475 else if (basetype
== error_mark_node
)
2476 return error_mark_node
;
2479 /* Only allow a static member function to call another static member
2481 else if (DECL_LANG_SPECIFIC (function
)
2482 && !DECL_STATIC_FUNCTION_P (function
))
2484 cp_error ("cannot call member function `%D' without object",
2486 return error_mark_node
;
2490 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2492 if (TYPE_SIZE (value_type
) == 0)
2494 if (flags
& LOOKUP_COMPLAIN
)
2495 incomplete_type_error (0, value_type
);
2496 return error_mark_node
;
2499 if (DECL_STATIC_FUNCTION_P (function
))
2500 parms
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2501 TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
);
2502 else if (need_vtbl
== unneeded
)
2504 int sub_flags
= DECL_CONSTRUCTOR_P (function
) ? flags
: LOOKUP_NORMAL
;
2505 basetype
= TREE_TYPE (instance
);
2506 if (TYPE_METHOD_BASETYPE (TREE_TYPE (function
)) != TYPE_MAIN_VARIANT (basetype
)
2507 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
2509 basetype
= DECL_CLASS_CONTEXT (function
);
2510 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
2511 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2513 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2514 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, sub_flags
));
2518 if ((flags
& LOOKUP_NONVIRTUAL
) == 0)
2519 basetype
= DECL_CONTEXT (function
);
2521 /* First parm could be integer_zerop with casts like
2522 ((Object*)0)->Object::IsA() */
2523 if (!integer_zerop (TREE_VALUE (parms
)))
2525 /* Since we can't have inheritance with a union, doing get_binfo
2526 on it won't work. We do all the convert_pointer_to_real
2527 stuff to handle MI correctly...for unions, that's not
2528 an issue, so we must short-circuit that extra work here. */
2529 tree tmp
= TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)));
2530 if (tmp
!= NULL_TREE
&& TREE_CODE (tmp
) == UNION_TYPE
)
2531 instance_ptr
= TREE_VALUE (parms
);
2534 tree binfo
= get_binfo (basetype
,
2535 TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
))),
2537 instance_ptr
= convert_pointer_to_real (binfo
, TREE_VALUE (parms
));
2540 = convert_pointer_to (build_type_variant (basetype
,
2544 if (TREE_CODE (instance_ptr
) == COND_EXPR
)
2546 instance_ptr
= save_expr (instance_ptr
);
2547 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2549 else if (TREE_CODE (instance_ptr
) == NOP_EXPR
2550 && TREE_CODE (TREE_OPERAND (instance_ptr
, 0)) == ADDR_EXPR
2551 && TREE_OPERAND (TREE_OPERAND (instance_ptr
, 0), 0) == instance
)
2553 /* The call to `convert_pointer_to' may return error_mark_node. */
2554 else if (TREE_CODE (instance_ptr
) == ERROR_MARK
)
2555 return instance_ptr
;
2556 else if (instance
== NULL_TREE
2557 || TREE_CODE (instance
) != INDIRECT_REF
2558 || TREE_OPERAND (instance
, 0) != instance_ptr
)
2559 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2561 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2562 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
));
2566 /* Constructors do not overload method calls. */
2567 else if (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype
)
2568 && name
!= TYPE_IDENTIFIER (basetype
)
2569 && (TREE_CODE (function
) != FUNCTION_DECL
2570 || strncmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)),
2571 OPERATOR_METHOD_FORMAT
,
2572 OPERATOR_METHOD_LENGTH
))
2573 && (may_be_remote (basetype
) || instance
!= C_C_D
))
2577 parms
= TREE_CHAIN (parms
);
2579 if (!all_virtual
&& TREE_CODE (function
) == FUNCTION_DECL
)
2580 fn_as_int
= build_unary_op (ADDR_EXPR
, function
, 0);
2582 fn_as_int
= convert (TREE_TYPE (default_conversion (function
)), DECL_VINDEX (function
));
2583 if (all_virtual
== 1)
2584 fn_as_int
= convert (integer_type_node
, fn_as_int
);
2586 result
= build_opfncall (METHOD_CALL_EXPR
, LOOKUP_NORMAL
, instance
, fn_as_int
, parms
);
2588 if (result
== NULL_TREE
)
2590 compiler_error ("could not overload `operator->()(...)'");
2591 return error_mark_node
;
2593 else if (result
== error_mark_node
)
2594 return error_mark_node
;
2597 /* Do this if we want the result of operator->() to inherit
2598 the type of the function it is subbing for. */
2599 TREE_TYPE (result
) = value_type
;
2606 if (need_vtbl
== needed
)
2608 function
= build_vfn_ref (&TREE_VALUE (parms
), instance
,
2609 DECL_VINDEX (function
));
2610 TREE_TYPE (function
) = build_pointer_type (fntype
);
2613 if (TREE_CODE (function
) == FUNCTION_DECL
)
2614 GNU_xref_call (current_function_decl
,
2615 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)));
2620 if (TREE_CODE (function
) == FUNCTION_DECL
)
2622 is_constructor
= DECL_CONSTRUCTOR_P (function
);
2623 if (DECL_INLINE (function
))
2624 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
2627 assemble_external (function
);
2628 TREE_USED (function
) = 1;
2629 function
= default_conversion (function
);
2635 function
= default_conversion (function
);
2638 result
= build_nt (CALL_EXPR
, function
, parms
, NULL_TREE
);
2640 TREE_TYPE (result
) = value_type
;
2641 TREE_SIDE_EFFECTS (result
) = 1;
2642 TREE_RAISES (result
)
2643 = TYPE_RAISES_EXCEPTIONS (fntype
) || (parms
&& TREE_RAISES (parms
));
2644 TREE_HAS_CONSTRUCTOR (result
) = is_constructor
;
2649 /* Similar to `build_method_call', but for overloaded non-member functions.
2650 The name of this function comes through NAME. The name depends
2653 Note that this function must handle simple `C' promotions,
2654 as well as variable numbers of arguments (...), and
2655 default arguments to boot.
2657 If the overloading is successful, we return a tree node which
2658 contains the call to the function.
2660 If overloading produces candidates which are probable, but not definite,
2661 we hold these candidates. If FINAL_CP is non-zero, then we are free
2662 to assume that final_cp points to enough storage for all candidates that
2663 this function might generate. The `harshness' array is preallocated for
2664 the first candidate, but not for subsequent ones.
2666 Note that the DECL_RTL of FUNCTION must be made to agree with this
2667 function's new name. */
2670 build_overload_call_real (fnname
, parms
, flags
, final_cp
, buildxxx
)
2673 struct candidate
*final_cp
;
2676 /* must check for overloading here */
2677 tree overload_name
, functions
, function
, parm
;
2678 tree parmtypes
= NULL_TREE
, last
= NULL_TREE
;
2679 register tree outer
;
2681 int parmlength
= list_length (parms
);
2683 struct candidate
*candidates
, *cp
;
2687 final_cp
[0].h
.code
= 0;
2688 final_cp
[0].h
.distance
= 0;
2689 final_cp
[0].function
= 0;
2691 final_cp
[1].h
.code
= EVIL_CODE
;
2694 for (parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
2696 register tree t
= TREE_TYPE (TREE_VALUE (parm
));
2698 if (t
== error_mark_node
)
2701 final_cp
->h
.code
= EVIL_CODE
;
2702 return error_mark_node
;
2704 if (TREE_CODE (t
) == OFFSET_TYPE
)
2706 /* This breaks reference-to-array parameters. */
2707 || TREE_CODE (t
) == ARRAY_TYPE
2710 /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
2711 Also convert OFFSET_TYPE entities to their normal selves.
2712 This eliminates needless calls to `compute_conversion_costs'. */
2713 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
2714 t
= TREE_TYPE (TREE_VALUE (parm
));
2716 last
= build_tree_list (NULL_TREE
, t
);
2717 parmtypes
= chainon (parmtypes
, last
);
2720 TREE_CHAIN (last
) = void_list_node
;
2722 parmtypes
= void_list_node
;
2724 if (is_overloaded_fn (fnname
))
2727 if (TREE_CODE (fnname
) == TREE_LIST
)
2728 fnname
= TREE_PURPOSE (functions
);
2729 else if (TREE_CODE (fnname
) == FUNCTION_DECL
)
2730 fnname
= DECL_NAME (functions
);
2733 functions
= lookup_name_nonclass (fnname
);
2735 if (functions
== NULL_TREE
)
2737 if (flags
& LOOKUP_SPECULATIVELY
)
2739 if (flags
& LOOKUP_COMPLAIN
)
2740 error ("only member functions apply");
2742 final_cp
->h
.code
= EVIL_CODE
;
2743 return error_mark_node
;
2746 if (TREE_CODE (functions
) == FUNCTION_DECL
&& ! IDENTIFIER_OPNAME_P (fnname
))
2748 functions
= DECL_MAIN_VARIANT (functions
);
2751 /* We are just curious whether this is a viable alternative or
2753 compute_conversion_costs (functions
, parms
, final_cp
, parmlength
);
2757 return build_function_call_real (functions
, parms
, 1, flags
);
2760 if (TREE_CODE (functions
) == TREE_LIST
2761 && TREE_VALUE (functions
) == NULL_TREE
)
2763 if (flags
& LOOKUP_SPECULATIVELY
)
2766 if (flags
& LOOKUP_COMPLAIN
)
2767 cp_error ("function `%D' declared overloaded, but no instances of that function declared",
2768 TREE_PURPOSE (functions
));
2770 final_cp
->h
.code
= EVIL_CODE
;
2771 return error_mark_node
;
2774 length
= count_functions (functions
);
2777 candidates
= final_cp
;
2781 = (struct candidate
*)alloca ((length
+1) * sizeof (struct candidate
));
2782 bzero ((char *) candidates
, (length
+ 1) * sizeof (struct candidate
));
2787 my_friendly_assert (is_overloaded_fn (functions
), 169);
2789 functions
= get_first_fn (functions
);
2791 /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
2792 for (outer
= functions
; outer
; outer
= DECL_CHAIN (outer
))
2794 int template_cost
= 0;
2796 if (TREE_CODE (function
) != FUNCTION_DECL
2797 && ! (TREE_CODE (function
) == TEMPLATE_DECL
2798 && ! DECL_TEMPLATE_IS_CLASS (function
)
2799 && TREE_CODE (DECL_TEMPLATE_RESULT (function
)) == FUNCTION_DECL
))
2801 enum tree_code code
= TREE_CODE (function
);
2802 if (code
== TEMPLATE_DECL
)
2803 code
= TREE_CODE (DECL_TEMPLATE_RESULT (function
));
2804 if (code
== CONST_DECL
)
2806 ("enumeral value `%D' conflicts with function of same name",
2808 else if (code
== VAR_DECL
)
2810 if (TREE_STATIC (function
))
2812 ("variable `%D' conflicts with function of same name",
2816 ("constant field `%D' conflicts with function of same name",
2819 else if (code
== TYPE_DECL
)
2822 my_friendly_abort (2);
2823 error ("at this point in file");
2826 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2828 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function
));
2829 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
2832 i
= type_unification (DECL_TEMPLATE_PARMS (function
), targs
,
2833 TYPE_ARG_TYPES (TREE_TYPE (function
)),
2834 parms
, &template_cost
, 0);
2836 function
= instantiate_template (function
, targs
);
2839 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2841 /* Unconverted template -- failed match. */
2842 cp
->function
= function
;
2844 cp
->h
.code
= EVIL_CODE
;
2848 struct candidate
*cp2
;
2850 /* Check that this decl is not the same as a function that's in
2851 the list due to some template instantiation. */
2854 if (cp2
->function
== function
)
2858 if (cp2
->function
== function
)
2861 function
= DECL_MAIN_VARIANT (function
);
2863 /* Can't use alloca here, since result might be
2864 passed to calling function. */
2865 cp
->h_len
= parmlength
;
2866 cp
->harshness
= (struct harshness_code
*)
2867 oballoc ((parmlength
+ 1) * sizeof (struct harshness_code
));
2869 compute_conversion_costs (function
, parms
, cp
, parmlength
);
2871 /* Make sure this is clear as well. */
2872 cp
->h
.int_penalty
+= template_cost
;
2874 if ((cp
[0].h
.code
& EVIL_CODE
) == 0)
2876 cp
[1].h
.code
= EVIL_CODE
;
2882 if (cp
- candidates
)
2884 tree rval
= error_mark_node
;
2887 cp
[0].h
.code
= EVIL_CODE
;
2888 if (cp
- candidates
> 1)
2890 struct candidate
*best_cp
2891 = ideal_candidate (NULL_TREE
, candidates
,
2892 cp
- candidates
, parms
, parmlength
);
2893 if (best_cp
== (struct candidate
*)0)
2895 if (flags
& LOOKUP_COMPLAIN
)
2897 cp_error ("call of overloaded `%D' is ambiguous", fnname
);
2898 print_n_candidates (candidates
, cp
- candidates
);
2900 return error_mark_node
;
2903 rval
= best_cp
->function
;
2908 if (cp
->h
.code
& EVIL_CODE
)
2910 if (flags
& LOOKUP_COMPLAIN
)
2911 error ("type conversion ambiguous");
2914 rval
= cp
->function
;
2920 return buildxxx
? build_function_call_real (rval
, parms
, 0, flags
)
2921 : build_function_call_real (rval
, parms
, 1, flags
);
2924 if (flags
& LOOKUP_SPECULATIVELY
)
2927 if (flags
& LOOKUP_COMPLAIN
)
2928 report_type_mismatch (cp
, parms
, "function",
2929 decl_as_string (cp
->function
, 1));
2931 return error_mark_node
;
2935 build_overload_call (fnname
, parms
, flags
, final_cp
)
2938 struct candidate
*final_cp
;
2940 return build_overload_call_real (fnname
, parms
, flags
, final_cp
, 0);
2944 build_overload_call_maybe (fnname
, parms
, flags
, final_cp
)
2947 struct candidate
*final_cp
;
2949 return build_overload_call_real (fnname
, parms
, flags
, final_cp
, 1);