1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 hacked by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* High-level class interface. */
35 #define obstack_chunk_alloc xmalloc
36 #define obstack_chunk_free free
40 extern int inhibit_warnings
;
41 extern int flag_assume_nonnull_objects
;
42 extern tree ctor_label
, dtor_label
;
45 extern tree
unary_complex_lvalue ();
47 /* Compute the ease with which a conversion can be performed
48 between an expected and the given type. */
49 static struct harshness_code
convert_harshness ();
51 #define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG))
52 #define STD_RETURN(ARG) ((ARG).code = STD_CODE, (ARG))
53 #define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG))
54 #define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG))
55 #define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG))
57 /* Ordering function for overload resolution. Compare two candidates
60 rank_for_overload (x
, y
)
61 struct candidate
*x
, *y
;
63 if (y
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
64 return y
->h
.code
- x
->h
.code
;
65 if (x
->h
.code
& (EVIL_CODE
|ELLIPSIS_CODE
|USER_CODE
))
68 /* This is set by compute_conversion_costs, for calling a non-const
69 member function from a const member function. */
70 if ((y
->harshness
[0].code
& CONST_CODE
) ^ (x
->harshness
[0].code
& CONST_CODE
))
71 return y
->harshness
[0].code
- x
->harshness
[0].code
;
73 if (y
->h
.code
& STD_CODE
)
75 if (x
->h
.code
& STD_CODE
)
76 return y
->h
.distance
- x
->h
.distance
;
79 if (x
->h
.code
& STD_CODE
)
82 return y
->h
.code
- x
->h
.code
;
85 /* Compare two candidates, argument by argument. */
88 struct candidate
*x
, *y
;
92 if (x
->h_len
!= y
->h_len
)
95 for (i
= 0; i
< x
->h_len
; i
++)
97 if (y
->harshness
[i
].code
- x
->harshness
[i
].code
)
98 return y
->harshness
[i
].code
- x
->harshness
[i
].code
;
99 if ((y
->harshness
[i
].code
& STD_CODE
)
100 && (y
->harshness
[i
].distance
- x
->harshness
[i
].distance
))
101 return y
->harshness
[i
].distance
- x
->harshness
[i
].distance
;
103 /* They're both the same code. Now see if we're dealing with an
104 integral promotion that needs a finer grain of accuracy. */
105 if (y
->harshness
[0].code
& PROMO_CODE
106 && (y
->harshness
[i
].int_penalty
^ x
->harshness
[i
].int_penalty
))
107 return y
->harshness
[i
].int_penalty
- x
->harshness
[i
].int_penalty
;
112 /* TYPE is the type we wish to convert to. PARM is the parameter
113 we have to work with. We use a somewhat arbitrary cost function
114 to measure this conversion. */
115 static struct harshness_code
116 convert_harshness (type
, parmtype
, parm
)
117 register tree type
, parmtype
;
120 struct harshness_code h
;
121 register enum tree_code codel
;
122 register enum tree_code coder
;
129 #ifdef GATHER_STATISTICS
130 n_convert_harshness
++;
133 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
136 parm
= convert_from_reference (parm
);
137 parmtype
= TREE_TYPE (parmtype
);
141 lvalue
= lvalue_p (parm
);
145 if (TYPE_PTRMEMFUNC_P (type
))
146 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
147 if (TYPE_PTRMEMFUNC_P (parmtype
))
148 parmtype
= TYPE_PTRMEMFUNC_FN_TYPE (parmtype
);
150 codel
= TREE_CODE (type
);
151 coder
= TREE_CODE (parmtype
);
153 if (TYPE_MAIN_VARIANT (parmtype
) == TYPE_MAIN_VARIANT (type
))
154 return ZERO_RETURN (h
);
156 if (coder
== ERROR_MARK
)
157 return EVIL_RETURN (h
);
159 if (codel
== REFERENCE_TYPE
)
162 int constp
= parm
? TREE_READONLY (parm
) : TYPE_READONLY (parmtype
);
163 int volatilep
= (parm
? TREE_THIS_VOLATILE (parm
)
164 : TYPE_VOLATILE (parmtype
));
165 register tree intype
= TYPE_MAIN_VARIANT (parmtype
);
166 register enum tree_code form
= TREE_CODE (intype
);
169 ttl
= TREE_TYPE (type
);
171 /* Only allow const reference binding if we were given a parm to deal
172 with, since it isn't really a conversion. This is a hack to
173 prevent build_type_conversion from finding this conversion, but
174 still allow overloading to find it. */
175 if (! lvalue
&& ! (parm
&& TYPE_READONLY (ttl
)))
176 return EVIL_RETURN (h
);
178 if (TYPE_READONLY (ttl
) < constp
179 || TYPE_VOLATILE (ttl
) < volatilep
)
180 return EVIL_RETURN (h
);
182 /* When passing a non-const argument into a const reference, dig it a
183 little, so a non-const reference is preferred over this one. */
184 penalty
= ((TYPE_READONLY (ttl
) > constp
)
185 + (TYPE_VOLATILE (ttl
) > volatilep
));
187 ttl
= TYPE_MAIN_VARIANT (ttl
);
189 if (form
== OFFSET_TYPE
)
191 intype
= TREE_TYPE (intype
);
192 form
= TREE_CODE (intype
);
197 if (TREE_CODE (ttl
) == ARRAY_TYPE
&& TREE_CODE (ttr
) == ARRAY_TYPE
)
199 if (comptypes (ttl
, ttr
, 1))
200 return ZERO_RETURN (h
);
201 return EVIL_RETURN (h
);
204 h
= convert_harshness (ttl
, ttr
, NULL_TREE
);
205 if (penalty
&& h
.code
== 0)
208 h
.int_penalty
= penalty
;
213 if (codel
== POINTER_TYPE
&& fntype_p (parmtype
))
216 struct harshness_code h1
, h2
;
218 /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */
219 type
= TREE_TYPE (type
);
221 if (coder
== POINTER_TYPE
)
223 parmtype
= TREE_TYPE (parmtype
);
224 coder
= TREE_CODE (parmtype
);
227 if (coder
!= TREE_CODE (type
))
228 return EVIL_RETURN (h
);
230 if (type
!= parmtype
&& coder
== METHOD_TYPE
)
232 tree ttl
= TYPE_METHOD_BASETYPE (type
);
233 tree ttr
= TYPE_METHOD_BASETYPE (parmtype
);
235 int b_or_d
= get_base_distance (ttr
, ttl
, 0, 0);
238 b_or_d
= get_base_distance (ttl
, ttr
, 0, 0);
240 return EVIL_RETURN (h
);
241 h
.distance
= -b_or_d
;
247 type
= build_function_type
248 (TREE_TYPE (type
), TREE_CHAIN (TYPE_ARG_TYPES (type
)));
249 parmtype
= build_function_type
250 (TREE_TYPE (parmtype
), TREE_CHAIN (TYPE_ARG_TYPES (parmtype
)));
253 /* We allow the default conversion between function type
254 and pointer-to-function type for free. */
255 if (comptypes (type
, parmtype
, 1))
259 return EVIL_RETURN (h
);
261 /* Compare return types. */
262 p1
= TREE_TYPE (type
);
263 p2
= TREE_TYPE (parmtype
);
264 h2
= convert_harshness (p1
, p2
, NULL_TREE
);
265 if (h2
.code
& EVIL_CODE
)
268 h1
.code
= TRIVIAL_CODE
;
271 if (h2
.distance
!= 0)
275 /* This only works for pointers. */
276 if (TREE_CODE (p1
) != POINTER_TYPE
277 && TREE_CODE (p1
) != REFERENCE_TYPE
)
278 return EVIL_RETURN (h
);
282 /* Don't die if we happen to be dealing with void*. */
283 if (!IS_AGGR_TYPE (p1
) || !IS_AGGR_TYPE (p2
))
284 return EVIL_RETURN (h
);
286 binfo
= get_binfo (p2
, p1
, 0);
288 binfo
= get_binfo (p1
, p2
, 0);
290 if (! BINFO_OFFSET_ZEROP (binfo
))
293 static int explained
= 0;
295 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p2
, p1
);
297 message_2_types (sorry
, "cannot cast `%s' to `%s' at function call site", p1
, p2
);
300 sorry ("(because pointer values change during conversion)");
302 return EVIL_RETURN (h
);
307 if (h2
.distance
> h1
.distance
)
308 h1
.distance
= h2
.distance
;
310 p1
= TYPE_ARG_TYPES (type
);
311 p2
= TYPE_ARG_TYPES (parmtype
);
312 while (p1
&& TREE_VALUE (p1
) != void_type_node
313 && p2
&& TREE_VALUE (p2
) != void_type_node
)
315 h2
= convert_harshness (TREE_VALUE (p1
), TREE_VALUE (p2
),
317 if (h2
.code
& EVIL_CODE
)
322 /* This only works for pointers and references. */
323 if (TREE_CODE (TREE_VALUE (p1
)) != POINTER_TYPE
324 && TREE_CODE (TREE_VALUE (p1
)) != REFERENCE_TYPE
)
325 return EVIL_RETURN (h
);
326 h2
.distance
= - h2
.distance
;
330 if (h2
.distance
> h1
.distance
)
331 h1
.distance
= h2
.distance
;
332 p1
= TREE_CHAIN (p1
);
333 p2
= TREE_CHAIN (p2
);
340 return EVIL_RETURN (h
);
341 h1
.code
|= ELLIPSIS_CODE
;
346 if (TREE_PURPOSE (p1
) == NULL_TREE
)
347 h1
.code
|= EVIL_CODE
;
351 else if (codel
== POINTER_TYPE
&& coder
== OFFSET_TYPE
)
355 /* Get to the OFFSET_TYPE that this might be. */
356 type
= TREE_TYPE (type
);
358 if (coder
!= TREE_CODE (type
))
359 return EVIL_RETURN (h
);
361 ttl
= TYPE_OFFSET_BASETYPE (type
);
362 ttr
= TYPE_OFFSET_BASETYPE (parmtype
);
368 int b_or_d
= get_base_distance (ttr
, ttl
, 0, 0);
371 b_or_d
= get_base_distance (ttl
, ttr
, 0, 0);
373 return EVIL_RETURN (h
);
374 h
.distance
= -b_or_d
;
381 /* Now test the OFFSET_TYPE's target compatibility. */
382 type
= TREE_TYPE (type
);
383 parmtype
= TREE_TYPE (parmtype
);
386 if (coder
== UNKNOWN_TYPE
)
388 if (codel
== FUNCTION_TYPE
389 || codel
== METHOD_TYPE
390 || (codel
== POINTER_TYPE
391 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
392 || TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)))
393 return TRIVIAL_RETURN (h
);
394 return EVIL_RETURN (h
);
397 if (coder
== VOID_TYPE
)
398 return EVIL_RETURN (h
);
400 if (codel
== BOOLEAN_TYPE
)
402 if (INTEGRAL_CODE_P (coder
) || coder
== REAL_TYPE
)
403 return STD_RETURN (h
);
404 else if (coder
== POINTER_TYPE
|| coder
== OFFSET_TYPE
)
406 /* Make this worse than any conversion to another pointer.
407 FIXME this is how I think the language should work, but it may not
408 end up being how the language is standardized (jason 1/30/95). */
410 return STD_RETURN (h
);
412 return EVIL_RETURN (h
);
415 if (INTEGRAL_CODE_P (codel
))
417 /* Control equivalence of ints an enums. */
419 if (codel
== ENUMERAL_TYPE
420 && flag_int_enum_equivalence
== 0)
422 /* Enums can be converted to ints, but not vice-versa. */
423 if (coder
!= ENUMERAL_TYPE
424 || TYPE_MAIN_VARIANT (type
) != TYPE_MAIN_VARIANT (parmtype
))
425 return EVIL_RETURN (h
);
428 /* else enums and ints (almost) freely interconvert. */
430 if (INTEGRAL_CODE_P (coder
))
432 if (TYPE_MAIN_VARIANT (type
)
433 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
436 #if 0 /* What purpose does this serve? -jason */
437 /* A char, short, wchar_t, etc., should promote to an int if
438 it can handle it, otherwise to an unsigned. So we'll make
440 if (type
!= integer_type_node
)
449 else if (coder
== REAL_TYPE
)
457 if (codel
== REAL_TYPE
)
459 if (coder
== REAL_TYPE
)
461 if (TYPE_MAIN_VARIANT (type
)
462 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype
)))
469 else if (INTEGRAL_CODE_P (coder
))
477 /* Convert arrays which have not previously been converted. */
479 if (codel
== ARRAY_TYPE
)
480 codel
= POINTER_TYPE
;
482 if (coder
== ARRAY_TYPE
)
484 coder
= POINTER_TYPE
;
487 parm
= decay_conversion (parm
);
488 parmtype
= TREE_TYPE (parm
);
491 parmtype
= build_pointer_type (TREE_TYPE (parmtype
));
494 /* Conversions among pointers */
495 if (codel
== POINTER_TYPE
&& coder
== POINTER_TYPE
)
497 register tree ttl
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
498 register tree ttr
= TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
));
499 int penalty
= 4 * (ttl
!= ttr
);
501 /* Anything converts to void *. Since this may be `const void *'
502 (etc.) use VOID_TYPE instead of void_type_node. Otherwise, the
503 targets must be the same, except that we do allow (at some cost)
504 conversion between signed and unsigned pointer types. */
506 if ((TREE_CODE (ttl
) == METHOD_TYPE
507 || TREE_CODE (ttl
) == FUNCTION_TYPE
)
508 && TREE_CODE (ttl
) == TREE_CODE (ttr
))
510 if (comptypes (ttl
, ttr
, -1))
512 h
.code
= penalty
? STD_CODE
: 0;
521 if (TREE_CODE (ttl
) != VOID_TYPE
522 && (TREE_CODE (ttr
) != VOID_TYPE
|| !parm
|| !integer_zerop (parm
)))
524 if (TREE_UNSIGNED (ttl
) != TREE_UNSIGNED (ttr
))
526 ttl
= unsigned_type (ttl
);
527 ttr
= unsigned_type (ttr
);
530 if (comp_target_types (type
, parmtype
, 1) <= 0)
531 return EVIL_RETURN (h
);
534 if (!(TREE_CODE (ttl
) == VOID_TYPE
535 || TREE_CODE (ttr
) == VOID_TYPE
536 || (TREE_UNSIGNED (ttl
) ^ TREE_UNSIGNED (ttr
)
537 && (ttl
= unsigned_type (ttl
),
538 ttr
= unsigned_type (ttr
),
540 || (comp_target_types (ttl
, ttr
, 0) > 0)))
541 return EVIL_RETURN (h
);
544 if (penalty
== 10 || ttr
== ttl
)
546 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
548 /* If one was unsigned but the other wasn't, then we need to
549 do a standard conversion from T to unsigned T. */
551 h
.code
= PROMO_CODE
; /* was STD_CODE */
555 /* Note conversion from `T*' to `const T*',
556 or `T*' to `volatile T*'. */
558 && ((TYPE_READONLY (tmp1
) != TREE_READONLY (tmp2
))
559 || (TYPE_VOLATILE (tmp1
) != TYPE_VOLATILE (tmp2
))))
567 if (TREE_CODE (ttl
) == RECORD_TYPE
&& TREE_CODE (ttr
) == RECORD_TYPE
)
569 int b_or_d
= get_base_distance (ttl
, ttr
, 0, 0);
572 b_or_d
= get_base_distance (ttr
, ttl
, 0, 0);
574 return EVIL_RETURN (h
);
575 h
.distance
= -b_or_d
;
583 /* If converting from a `class*' to a `void*', make it
584 less favorable than any inheritance relationship. */
585 if (TREE_CODE (ttl
) == VOID_TYPE
&& IS_AGGR_TYPE (ttr
))
588 h
.distance
= CLASSTYPE_MAX_DEPTH (ttr
)+1;
592 h
.code
= penalty
? STD_CODE
: PROMO_CODE
;
593 /* Catch things like `const char *' -> `const void *'
594 vs `const char *' -> `void *'. */
597 tree tmp1
= TREE_TYPE (type
), tmp2
= TREE_TYPE (parmtype
);
598 if ((TYPE_READONLY (tmp1
) != TREE_READONLY (tmp2
))
599 || (TYPE_VOLATILE (tmp1
) != TYPE_VOLATILE (tmp2
)))
605 if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
607 /* This is not a bad match, but don't let it beat
608 integer-enum combinations. */
609 if (parm
&& integer_zerop (parm
))
617 /* C++: Since the `this' parameter of a signature member function
618 is represented as a signature pointer to handle default implementations
619 correctly, we can have the case that `type' is a signature pointer
620 while `parmtype' is a pointer to a signature table. We don't really
621 do any conversions in this case, so just return 0. */
623 if (codel
== RECORD_TYPE
&& coder
== POINTER_TYPE
624 && IS_SIGNATURE_POINTER (type
) && IS_SIGNATURE (TREE_TYPE (parmtype
)))
625 return ZERO_RETURN (h
);
627 if (codel
== RECORD_TYPE
&& coder
== RECORD_TYPE
)
629 int b_or_d
= get_base_distance (type
, parmtype
, 0, 0);
632 b_or_d
= get_base_distance (parmtype
, type
, 0, 0);
634 return EVIL_RETURN (h
);
635 h
.distance
= -b_or_d
;
642 return EVIL_RETURN (h
);
645 /* A clone of build_type_conversion for checking user-defined conversions in
646 overload resolution. */
649 user_harshness (type
, parmtype
, parm
)
650 register tree type
, parmtype
;
654 tree winner
= NULL_TREE
;
658 tree typename
= build_typename_overload (type
);
659 if (lookup_fnfields (TYPE_BINFO (parmtype
), typename
, 0))
663 for (conv
= lookup_conversions (parmtype
); conv
; conv
= TREE_CHAIN (conv
))
665 struct harshness_code tmp
;
667 if (winner
&& TREE_PURPOSE (winner
) == TREE_PURPOSE (conv
))
670 if (tmp
= convert_harshness (type
, TREE_VALUE (conv
), NULL_TREE
),
671 tmp
.code
< USER_CODE
&& tmp
.distance
>= 0)
690 can_convert (to
, from
)
693 struct harshness_code h
;
694 h
= convert_harshness (to
, from
, NULL_TREE
);
695 return h
.code
< USER_CODE
&& h
.distance
>= 0;
699 can_convert_arg (to
, from
, arg
)
702 struct harshness_code h
;
703 h
= convert_harshness (to
, from
, arg
);
704 return h
.code
< USER_CODE
&& h
.distance
>= 0;
707 #ifdef DEBUG_MATCHING
710 struct harshness_code
*h
;
712 static char buf
[1024];
715 bzero (buf
, 1024 * sizeof (char));
716 strcat (buf
, "codes=[");
717 if (h
->code
& EVIL_CODE
)
718 strcat (buf
, "EVIL");
719 if (h
->code
& CONST_CODE
)
720 strcat (buf
, " CONST");
721 if (h
->code
& ELLIPSIS_CODE
)
722 strcat (buf
, " ELLIPSIS");
723 if (h
->code
& USER_CODE
)
724 strcat (buf
, " USER");
725 if (h
->code
& STD_CODE
)
726 strcat (buf
, " STD");
727 if (h
->code
& PROMO_CODE
)
728 strcat (buf
, " PROMO");
729 if (h
->code
& QUAL_CODE
)
730 strcat (buf
, " QUAL");
731 if (h
->code
& TRIVIAL_CODE
)
732 strcat (buf
, " TRIVIAL");
736 sprintf (tmp
, "] distance=%d int_penalty=%d", h
->distance
, h
->int_penalty
);
744 /* Algorithm: For each argument, calculate how difficult it is to
745 make FUNCTION accept that argument. If we can easily tell that
746 FUNCTION won't be acceptable to one of the arguments, then we
747 don't need to compute the ease of converting the other arguments,
748 since it will never show up in the intersection of all arguments'
751 Conversions between builtin and user-defined types are allowed, but
752 no function involving such a conversion is preferred to one which
753 does not require such a conversion. Furthermore, such conversions
757 compute_conversion_costs (function
, tta_in
, cp
, arglen
)
760 struct candidate
*cp
;
763 tree ttf_in
= TYPE_ARG_TYPES (TREE_TYPE (function
));
767 /* Start out with no strikes against. */
768 int evil_strikes
= 0;
769 int ellipsis_strikes
= 0;
770 int user_strikes
= 0;
771 int b_or_d_strikes
= 0;
772 int easy_strikes
= 0;
774 int strike_index
= 0, win
;
775 struct harshness_code lose
;
776 extern int cp_silent
;
778 #ifdef GATHER_STATISTICS
779 n_compute_conversion_costs
++;
782 #ifndef DEBUG_MATCHING
783 /* We don't emit any warnings or errors while trying out each candidate. */
787 cp
->function
= function
;
788 cp
->arg
= tta
? TREE_VALUE (tta
) : NULL_TREE
;
789 cp
->u
.bad_arg
= 0; /* optimistic! */
793 cp
->h
.int_penalty
= 0;
794 bzero ((char *) cp
->harshness
,
795 (cp
->h_len
+ 1) * sizeof (struct harshness_code
));
799 struct harshness_code h
;
801 if (ttf
== void_list_node
)
804 if (type_unknown_p (TREE_VALUE (tta
)))
806 /* Must perform some instantiation here. */
807 tree rhs
= TREE_VALUE (tta
);
808 tree lhstype
= TREE_VALUE (ttf
);
810 /* Keep quiet about possible contravariance violations. */
811 int old_inhibit_warnings
= inhibit_warnings
;
812 inhibit_warnings
= 1;
814 /* @@ This is to undo what `grokdeclarator' does to
815 parameter types. It really should go through
816 something more general. */
818 TREE_TYPE (tta
) = unknown_type_node
;
819 rhs
= instantiate_type (lhstype
, rhs
, 0);
820 inhibit_warnings
= old_inhibit_warnings
;
822 if (TREE_CODE (rhs
) == ERROR_MARK
)
825 h
= convert_harshness (lhstype
, TREE_TYPE (rhs
), rhs
);
829 #ifdef DEBUG_MATCHING
830 static tree old_function
= NULL_TREE
;
832 if (!old_function
|| function
!= old_function
)
834 cp_error ("trying %D", function
);
835 old_function
= function
;
838 cp_error (" doing (%T) %E against arg %T",
839 TREE_TYPE (TREE_VALUE (tta
)), TREE_VALUE (tta
),
843 h
= convert_harshness (TREE_VALUE (ttf
),
844 TREE_TYPE (TREE_VALUE (tta
)),
847 #ifdef DEBUG_MATCHING
848 cp_error (" evaluated %s", print_harshness (&h
));
852 cp
->harshness
[strike_index
] = h
;
853 if ((h
.code
& EVIL_CODE
)
854 || ((h
.code
& STD_CODE
) && h
.distance
< 0))
856 cp
->u
.bad_arg
= strike_index
;
859 else if (h
.code
& ELLIPSIS_CODE
)
860 ellipsis_strikes
+= 1;
862 /* This is never set by `convert_harshness'. */
863 else if (h
.code
& USER_CODE
)
870 if ((h
.code
& STD_CODE
) && h
.distance
)
872 if (h
.distance
> b_or_d_strikes
)
873 b_or_d_strikes
= h
.distance
;
876 easy_strikes
+= (h
.code
& (STD_CODE
|PROMO_CODE
|TRIVIAL_CODE
));
877 cp
->h
.code
|= h
.code
;
878 /* Make sure we communicate this. */
879 cp
->h
.int_penalty
+= h
.int_penalty
;
882 ttf
= TREE_CHAIN (ttf
);
883 tta
= TREE_CHAIN (tta
);
889 /* ran out of formals, and parmlist is fixed size. */
890 if (ttf
/* == void_type_node */)
892 cp
->h
.code
= EVIL_CODE
;
899 struct harshness_code h
;
900 int l
= list_length (tta
);
901 ellipsis_strikes
+= l
;
902 h
.code
= ELLIPSIS_CODE
;
906 cp
->harshness
[strike_index
++] = h
;
909 else if (ttf
&& ttf
!= void_list_node
)
911 /* ran out of actuals, and no defaults. */
912 if (TREE_PURPOSE (ttf
) == NULL_TREE
)
914 cp
->h
.code
= EVIL_CODE
;
919 /* Store index of first default. */
920 cp
->harshness
[arglen
].distance
= strike_index
+1;
923 cp
->harshness
[arglen
].distance
= 0;
925 /* Argument list lengths work out, so don't need to check them again. */
928 /* We do not check for derived->base conversions here, since in
929 no case would they give evil strike counts, unless such conversions
930 are somehow ambiguous. */
932 /* See if any user-defined conversions apply.
933 But make sure that we do not loop. */
934 static int dont_convert_types
= 0;
936 if (dont_convert_types
)
938 cp
->h
.code
= EVIL_CODE
;
943 win
= 0; /* Only get one chance to win. */
944 ttf
= TYPE_ARG_TYPES (TREE_TYPE (function
));
951 if (ttf
== void_list_node
)
954 lose
= cp
->harshness
[strike_index
];
955 if ((lose
.code
& EVIL_CODE
)
956 || ((lose
.code
& STD_CODE
) && lose
.distance
< 0))
958 tree actual_type
= TREE_TYPE (TREE_VALUE (tta
));
959 tree formal_type
= TREE_VALUE (ttf
);
960 int extra_conversions
= 0;
962 dont_convert_types
= 1;
964 if (TREE_CODE (formal_type
) == REFERENCE_TYPE
)
965 formal_type
= TREE_TYPE (formal_type
);
966 if (TREE_CODE (actual_type
) == REFERENCE_TYPE
)
967 actual_type
= TREE_TYPE (actual_type
);
969 if (formal_type
!= error_mark_node
970 && actual_type
!= error_mark_node
)
972 formal_type
= TYPE_MAIN_VARIANT (formal_type
);
973 actual_type
= TYPE_MAIN_VARIANT (actual_type
);
975 if (TYPE_HAS_CONSTRUCTOR (formal_type
))
977 /* If it has a constructor for this type,
979 /* @@ There is no way to save this result yet, so
980 success is a NULL_TREE for now. */
981 if (convert_to_aggr (formal_type
, TREE_VALUE (tta
), 0, 1)
985 if (TYPE_LANG_SPECIFIC (actual_type
)
986 && TYPE_HAS_CONVERSION (actual_type
))
988 int extra
= user_harshness (formal_type
, actual_type
);
990 if (extra
== EVIL_CODE
)
995 extra_conversions
= extra
;
999 dont_convert_types
= 0;
1004 cp
->harshness
[strike_index
].code
1005 = USER_CODE
| (extra_conversions
? STD_CODE
: 0);
1010 if (cp
->u
.bad_arg
> strike_index
)
1011 cp
->u
.bad_arg
= strike_index
;
1013 evil_strikes
= win
? 2 : 1;
1018 ttf
= TREE_CHAIN (ttf
);
1019 tta
= TREE_CHAIN (tta
);
1024 /* Const member functions get a small penalty because defaulting
1025 to const is less useful than defaulting to non-const. */
1026 /* This is bogus, it does not correspond to anything in the ARM.
1027 This code will be fixed when this entire section is rewritten
1028 to conform to the ARM. (mrs) */
1029 if (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
1031 tree this_parm
= TREE_VALUE (ttf_in
);
1033 if (TREE_CODE (this_parm
) == RECORD_TYPE
/* Is `this' a sig ptr? */
1034 ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm
))))
1035 : TYPE_READONLY (TREE_TYPE (this_parm
)))
1037 cp
->harshness
[0].code
|= TRIVIAL_CODE
;
1042 /* Calling a non-const member function from a const member function
1043 is probably invalid, but for now we let it only draw a warning.
1044 We indicate that such a mismatch has occurred by setting the
1045 harshness to a maximum value. */
1046 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in
))) == POINTER_TYPE
1047 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in
))))))
1048 cp
->harshness
[0].code
|= CONST_CODE
;
1053 cp
->h
.code
= EVIL_CODE
;
1054 if (ellipsis_strikes
)
1055 cp
->h
.code
|= ELLIPSIS_CODE
;
1057 cp
->h
.code
|= USER_CODE
;
1059 #ifdef DEBUG_MATCHING
1060 cp_error ("final eval %s", print_harshness (&cp
->h
));
1064 /* Subroutine of ideal_candidate. See if X or Y is a better match
1067 strictly_better (x
, y
)
1068 unsigned short x
, y
;
1076 if (xor >= x
|| xor >= y
)
1081 /* When one of several possible overloaded functions and/or methods
1082 can be called, choose the best candidate for overloading.
1084 BASETYPE is the context from which we start method resolution
1085 or NULL if we are comparing overloaded functions.
1086 CANDIDATES is the array of candidates we have to choose from.
1087 N_CANDIDATES is the length of CANDIDATES.
1088 PARMS is a TREE_LIST of parameters to the function we'll ultimately
1089 choose. It is modified in place when resolving methods. It is not
1090 modified in place when resolving overloaded functions.
1091 LEN is the length of the parameter list. */
1093 static struct candidate
*
1094 ideal_candidate (basetype
, candidates
, n_candidates
, parms
, len
)
1096 struct candidate
*candidates
;
1101 struct candidate
*cp
= candidates
+n_candidates
;
1102 int i
, j
= -1, best_code
;
1104 /* For each argument, sort the functions from best to worst for the arg.
1105 For each function that's not best for this arg, set its overall
1106 harshness to EVIL so that other args won't like it. The candidate
1107 list for the last argument is the intersection of all the best-liked
1111 for (i
= 0; i
< len
; i
++)
1113 qsort (candidates
, n_candidates
, sizeof (struct candidate
),
1115 best_code
= cp
[-1].h
.code
;
1117 /* To find out functions that are worse than that represented
1118 by BEST_CODE, we can't just do a comparison like h.code>best_code.
1119 The total harshness for the "best" fn may be 8|8 for two args, and
1120 the harshness for the next-best may be 8|2. If we just compared,
1121 that would be checking 8>10, which would lead to the next-best
1122 being disqualified. What we actually want to do is get rid
1123 of functions that are definitely worse than that represented
1124 by best_code, i.e. those which have bits set higher than the
1125 highest in best_code. Sooooo, what we do is clear out everything
1126 represented by best_code, and see if we still come up with something
1127 higher. If so (e.g., 8|8 vs 8|16), it'll disqualify it properly. */
1128 for (j
= n_candidates
-2; j
>= 0; j
--)
1129 if ((candidates
[j
].h
.code
& ~best_code
) > best_code
)
1130 candidates
[j
].h
.code
= EVIL_CODE
;
1133 if (cp
[-1].h
.code
& EVIL_CODE
)
1136 qsort (candidates
, n_candidates
, sizeof (struct candidate
),
1138 best_code
= cp
[-1].h
.code
;
1141 /* If they're at least as good as each other, do an arg-by-arg check. */
1142 if (! strictly_better (cp
[-1].h
.code
, cp
[-2].h
.code
))
1147 for (j
= 0; j
< n_candidates
; j
++)
1148 if (! strictly_better (candidates
[j
].h
.code
, best_code
))
1151 qsort (candidates
+j
, n_candidates
-j
, sizeof (struct candidate
),
1153 for (i
= 0; i
< len
; i
++)
1155 if (cp
[-1].harshness
[i
].code
< cp
[-2].harshness
[i
].code
)
1157 else if (cp
[-1].harshness
[i
].code
> cp
[-2].harshness
[i
].code
)
1159 else if (cp
[-1].harshness
[i
].code
& STD_CODE
)
1161 /* If it involves a standard conversion, let the
1162 inheritance lattice be the final arbiter. */
1163 if (cp
[-1].harshness
[i
].distance
> cp
[-2].harshness
[i
].distance
)
1165 else if (cp
[-1].harshness
[i
].distance
< cp
[-2].harshness
[i
].distance
)
1168 else if (cp
[-1].harshness
[i
].code
& PROMO_CODE
)
1170 /* For integral promotions, take into account a finer
1171 granularity for determining which types should be favored
1172 over others in such promotions. */
1173 if (cp
[-1].harshness
[i
].int_penalty
> cp
[-2].harshness
[i
].int_penalty
)
1175 else if (cp
[-1].harshness
[i
].int_penalty
< cp
[-2].harshness
[i
].int_penalty
)
1180 if (! better
|| worse
)
1186 /* Assume that if the class referred to is not in the
1187 current class hierarchy, that it may be remote.
1188 PARENT is assumed to be of aggregate type here. */
1190 may_be_remote (parent
)
1193 if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent
) == 0)
1196 if (current_class_type
== NULL_TREE
)
1199 if (parent
== current_class_type
)
1202 if (UNIQUELY_DERIVED_FROM_P (parent
, current_class_type
))
1208 build_vfield_ref (datum
, type
)
1212 int old_assume_nonnull_objects
= flag_assume_nonnull_objects
;
1214 if (datum
== error_mark_node
)
1215 return error_mark_node
;
1217 /* Vtable references are always made from non-null objects. */
1218 flag_assume_nonnull_objects
= 1;
1219 if (TREE_CODE (TREE_TYPE (datum
)) == REFERENCE_TYPE
)
1220 datum
= convert_from_reference (datum
);
1222 if (! TYPE_USES_COMPLEX_INHERITANCE (type
))
1223 rval
= build (COMPONENT_REF
, TREE_TYPE (CLASSTYPE_VFIELD (type
)),
1224 datum
, CLASSTYPE_VFIELD (type
));
1226 rval
= build_component_ref (datum
, DECL_NAME (CLASSTYPE_VFIELD (type
)), 0, 0);
1227 flag_assume_nonnull_objects
= old_assume_nonnull_objects
;
1232 /* Build a call to a member of an object. I.e., one that overloads
1233 operator ()(), or is a pointer-to-function or pointer-to-method. */
1235 build_field_call (basetype_path
, instance_ptr
, name
, parms
)
1236 tree basetype_path
, instance_ptr
, name
, parms
;
1238 tree field
, instance
;
1240 if (instance_ptr
== current_class_decl
)
1242 /* Check to see if we really have a reference to an instance variable
1243 with `operator()()' overloaded. */
1244 field
= IDENTIFIER_CLASS_VALUE (name
);
1246 if (field
== NULL_TREE
)
1248 cp_error ("`this' has no member named `%D'", name
);
1249 return error_mark_node
;
1252 if (TREE_CODE (field
) == FIELD_DECL
)
1254 /* If it's a field, try overloading operator (),
1255 or calling if the field is a pointer-to-function. */
1256 instance
= build_component_ref_1 (C_C_D
, field
, 0);
1257 if (instance
== error_mark_node
)
1258 return error_mark_node
;
1260 if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance
))
1261 && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance
)))
1262 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, instance
, parms
, NULL_TREE
);
1264 if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1266 if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == FUNCTION_TYPE
)
1267 return build_function_call (instance
, parms
);
1268 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance
))) == METHOD_TYPE
)
1269 return build_function_call (instance
, tree_cons (NULL_TREE
, current_class_decl
, parms
));
1275 /* Check to see if this is not really a reference to an instance variable
1276 with `operator()()' overloaded. */
1277 field
= lookup_field (basetype_path
, name
, 1, 0);
1279 /* This can happen if the reference was ambiguous or for access
1281 if (field
== error_mark_node
)
1282 return error_mark_node
;
1287 tree ftype
= TREE_TYPE (field
);
1289 if (TREE_CODE (ftype
) == REFERENCE_TYPE
)
1290 ftype
= TREE_TYPE (ftype
);
1292 if (TYPE_LANG_SPECIFIC (ftype
) && TYPE_OVERLOADS_CALL_EXPR (ftype
))
1294 /* Make the next search for this field very short. */
1295 basetype
= DECL_FIELD_CONTEXT (field
);
1296 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
1298 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1299 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
,
1300 build_component_ref_1 (instance
, field
, 0),
1303 if (TREE_CODE (ftype
) == POINTER_TYPE
)
1305 if (TREE_CODE (TREE_TYPE (ftype
)) == FUNCTION_TYPE
1306 || TREE_CODE (TREE_TYPE (ftype
)) == METHOD_TYPE
)
1308 /* This is a member which is a pointer to function. */
1310 = build_component_ref_1 (build_indirect_ref (instance_ptr
,
1312 field
, LOOKUP_COMPLAIN
);
1313 if (ref
== error_mark_node
)
1314 return error_mark_node
;
1315 return build_function_call (ref
, parms
);
1318 else if (TREE_CODE (ftype
) == METHOD_TYPE
)
1320 error ("invalid call via pointer-to-member function");
1321 return error_mark_node
;
1330 find_scoped_type (type
, inner_name
, inner_types
)
1331 tree type
, inner_name
, inner_types
;
1333 tree tags
= CLASSTYPE_TAGS (type
);
1337 /* The TREE_PURPOSE of an enum tag (which becomes a member of the
1338 enclosing class) is set to the name for the enum type. So, if
1339 inner_name is `bar', and we strike `baz' for `enum bar { baz }',
1340 then this test will be true. */
1341 if (TREE_PURPOSE (tags
) == inner_name
)
1343 if (inner_types
== NULL_TREE
)
1344 return DECL_NESTED_TYPENAME (TYPE_NAME (TREE_VALUE (tags
)));
1345 return resolve_scope_to_name (TREE_VALUE (tags
), inner_types
);
1347 tags
= TREE_CHAIN (tags
);
1351 /* XXX This needs to be fixed better. */
1352 if (TREE_CODE (type
) == UNINSTANTIATED_P_TYPE
)
1354 sorry ("nested class lookup in template type");
1359 /* Look for a TYPE_DECL. */
1360 for (tags
= TYPE_FIELDS (type
); tags
; tags
= TREE_CHAIN (tags
))
1361 if (TREE_CODE (tags
) == TYPE_DECL
&& DECL_NAME (tags
) == inner_name
)
1363 /* Code by raeburn. */
1364 if (inner_types
== NULL_TREE
)
1365 return DECL_NESTED_TYPENAME (tags
);
1366 return resolve_scope_to_name (TREE_TYPE (tags
), inner_types
);
1372 /* Resolve an expression NAME1::NAME2::...::NAMEn to
1373 the name that names the above nested type. INNER_TYPES
1374 is a chain of nested type names (held together by SCOPE_REFs);
1375 OUTER_TYPE is the type we know to enclose INNER_TYPES.
1376 Returns NULL_TREE if there is an error. */
1378 resolve_scope_to_name (outer_type
, inner_stuff
)
1379 tree outer_type
, inner_stuff
;
1382 tree inner_name
, inner_type
;
1384 if (outer_type
== NULL_TREE
&& current_class_type
!= NULL_TREE
)
1386 /* We first try to look for a nesting in our current class context,
1387 then try any enclosing classes. */
1388 tree type
= current_class_type
;
1390 while (type
&& (TREE_CODE (type
) == RECORD_TYPE
1391 || TREE_CODE (type
) == UNION_TYPE
))
1393 tree rval
= resolve_scope_to_name (type
, inner_stuff
);
1395 if (rval
!= NULL_TREE
)
1397 type
= DECL_CONTEXT (TYPE_NAME (type
));
1401 if (TREE_CODE (inner_stuff
) == SCOPE_REF
)
1403 inner_name
= TREE_OPERAND (inner_stuff
, 0);
1404 inner_type
= TREE_OPERAND (inner_stuff
, 1);
1408 inner_name
= inner_stuff
;
1409 inner_type
= NULL_TREE
;
1412 if (outer_type
== NULL_TREE
)
1415 /* If we have something that's already a type by itself,
1417 if (IDENTIFIER_HAS_TYPE_VALUE (inner_name
))
1420 return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name
),
1425 x
= lookup_name (inner_name
, 0);
1427 if (x
&& TREE_CODE (x
) == NAMESPACE_DECL
)
1429 x
= lookup_namespace_name (x
, inner_type
);
1435 if (! IS_AGGR_TYPE (outer_type
))
1438 /* Look for member classes or enums. */
1439 tmp
= find_scoped_type (outer_type
, inner_name
, inner_type
);
1441 /* If it's not a type in this class, then go down into the
1442 base classes and search there. */
1443 if (! tmp
&& TYPE_BINFO (outer_type
))
1445 tree binfos
= TYPE_BINFO_BASETYPES (outer_type
);
1446 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1448 for (i
= 0; i
< n_baselinks
; i
++)
1450 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1451 tmp
= resolve_scope_to_name (BINFO_TYPE (base_binfo
), inner_stuff
);
1461 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
1462 This is how virtual function calls are avoided. */
1464 build_scoped_method_call (exp
, scopes
, name
, parms
)
1465 tree exp
, scopes
, name
, parms
;
1467 /* Because this syntactic form does not allow
1468 a pointer to a base class to be `stolen',
1469 we need not protect the derived->base conversion
1472 @@ But we do have to check access privileges later. */
1473 tree basename
= resolve_scope_to_name (NULL_TREE
, scopes
);
1474 tree basetype
, binfo
, decl
;
1475 tree type
= TREE_TYPE (exp
);
1477 if (type
== error_mark_node
1478 || basename
== NULL_TREE
)
1479 return error_mark_node
;
1481 basetype
= IDENTIFIER_TYPE_VALUE (basename
);
1483 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1484 type
= TREE_TYPE (type
);
1486 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
1487 that explicit ~int is caught in the parser; this deals with typedefs
1488 and template parms. */
1489 if (TREE_CODE (name
) == BIT_NOT_EXPR
&& ! is_aggr_typedef (basename
, 0))
1491 if (type
!= basetype
)
1492 cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
1493 exp
, basetype
, type
);
1494 name
= TREE_OPERAND (name
, 0);
1495 if (basetype
!= get_type_value (name
))
1496 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1498 return convert (void_type_node
, exp
);
1501 if (! is_aggr_typedef (basename
, 1))
1502 return error_mark_node
;
1504 if (! IS_AGGR_TYPE (type
))
1506 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
1508 return error_mark_node
;
1511 if ((binfo
= binfo_or_else (basetype
, type
)))
1513 if (binfo
== error_mark_node
)
1514 return error_mark_node
;
1515 if (TREE_CODE (exp
) == INDIRECT_REF
)
1516 decl
= build_indirect_ref (convert_pointer_to (binfo
,
1517 build_unary_op (ADDR_EXPR
, exp
, 0)), NULL_PTR
);
1519 decl
= build_scoped_ref (exp
, scopes
);
1521 /* Call to a destructor. */
1522 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1524 /* Explicit call to destructor. */
1525 name
= TREE_OPERAND (name
, 0);
1526 if (! (name
== constructor_name (TREE_TYPE (decl
))
1527 || TREE_TYPE (decl
) == get_type_value (name
)))
1530 ("qualified type `%T' does not match destructor name `~%T'",
1531 TREE_TYPE (decl
), name
);
1532 return error_mark_node
;
1534 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl
)))
1535 return convert (void_type_node
, exp
);
1537 return build_delete (TREE_TYPE (decl
), decl
, integer_two_node
,
1538 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
,
1542 /* Call to a method. */
1543 return build_method_call (decl
, name
, parms
, binfo
,
1544 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1546 return error_mark_node
;
1550 print_candidates (candidates
)
1553 cp_error_at ("candidates are: %D", TREE_VALUE (candidates
));
1554 candidates
= TREE_CHAIN (candidates
);
1558 cp_error_at (" %D", TREE_VALUE (candidates
));
1559 candidates
= TREE_CHAIN (candidates
);
1564 print_n_candidates (candidates
, n
)
1565 struct candidate
*candidates
;
1570 cp_error_at ("candidates are: %D", candidates
[0].function
);
1571 for (i
= 1; i
< n
; i
++)
1572 cp_error_at (" %D", candidates
[i
].function
);
1575 /* Build something of the form ptr->method (args)
1576 or object.method (args). This can also build
1577 calls to constructors, and find friends.
1579 Member functions always take their class variable
1582 INSTANCE is a class instance.
1584 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
1586 PARMS help to figure out what that NAME really refers to.
1588 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
1589 down to the real instance type to use for access checking. We need this
1590 information to get protected accesses correct. This parameter is used
1591 by build_member_call.
1593 FLAGS is the logical disjunction of zero or more LOOKUP_
1594 flags. See cp-tree.h for more info.
1596 If this is all OK, calls build_function_call with the resolved
1599 This function must also handle being called to perform
1600 initialization, promotion/coercion of arguments, and
1601 instantiation of default parameters.
1603 Note that NAME may refer to an instance variable name. If
1604 `operator()()' is defined for the type of that field, then we return
1607 build_method_call (instance
, name
, parms
, basetype_path
, flags
)
1608 tree instance
, name
, parms
, basetype_path
;
1611 register tree function
, fntype
, value_type
;
1612 register tree basetype
, save_basetype
;
1613 register tree baselink
, result
, method_name
, parmtypes
, parm
;
1616 enum access_type access
= access_public
;
1618 /* Range of cases for vtable optimization. */
1619 enum vtable_needs
{ not_needed
, maybe_needed
, unneeded
, needed
};
1620 enum vtable_needs need_vtbl
= not_needed
;
1624 tree instance_ptr
= NULL_TREE
;
1625 int all_virtual
= flag_all_virtual
;
1626 int static_call_context
= 0;
1627 tree found_fns
= NULL_TREE
;
1629 /* Keep track of `const' and `volatile' objects. */
1630 int constp
, volatilep
;
1632 #ifdef GATHER_STATISTICS
1633 n_build_method_call
++;
1636 if (instance
== error_mark_node
1637 || name
== error_mark_node
1638 || parms
== error_mark_node
1639 || (instance
!= NULL_TREE
&& TREE_TYPE (instance
) == error_mark_node
))
1640 return error_mark_node
;
1642 /* This is the logic that magically deletes the second argument to
1643 operator delete, if it is not needed. */
1644 if (name
== ansi_opname
[(int) DELETE_EXPR
] && list_length (parms
)==2)
1646 tree save_last
= TREE_CHAIN (parms
);
1648 /* get rid of unneeded argument */
1649 TREE_CHAIN (parms
) = NULL_TREE
;
1650 result
= build_method_call (instance
, name
, parms
, basetype_path
,
1651 (LOOKUP_SPECULATIVELY
|flags
)
1653 /* If it finds a match, return it. */
1655 return build_method_call (instance
, name
, parms
, basetype_path
, flags
);
1656 /* If it doesn't work, two argument delete must work */
1657 TREE_CHAIN (parms
) = save_last
;
1659 /* We already know whether it's needed or not for vec delete. */
1660 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
1661 && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance
)))
1662 TREE_CHAIN (parms
) = NULL_TREE
;
1664 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1666 flags
|= LOOKUP_DESTRUCTOR
;
1667 name
= TREE_OPERAND (name
, 0);
1669 error ("destructors take no parameters");
1670 basetype
= TREE_TYPE (instance
);
1671 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1672 basetype
= TREE_TYPE (basetype
);
1673 if (! ((IS_AGGR_TYPE (basetype
)
1674 && name
== constructor_name (basetype
))
1675 || basetype
== get_type_value (name
)))
1677 cp_error ("destructor name `~%D' does not match type `%T' of expression",
1679 return convert (void_type_node
, instance
);
1682 if (! TYPE_HAS_DESTRUCTOR (basetype
))
1683 return convert (void_type_node
, instance
);
1684 instance
= default_conversion (instance
);
1685 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1686 return build_delete (build_pointer_type (basetype
),
1687 instance_ptr
, integer_two_node
,
1688 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0);
1694 /* Initialize name for error reporting. */
1695 if (IDENTIFIER_OPNAME_P (name
) && ! IDENTIFIER_TYPENAME_P (name
))
1697 char *p
= operator_name_string (name
);
1698 xref_name
= (char *)alloca (strlen (p
) + 10);
1699 sprintf (xref_name
, "operator %s", p
);
1701 else if (TREE_CODE (name
) == SCOPE_REF
)
1702 xref_name
= IDENTIFIER_POINTER (TREE_OPERAND (name
, 1));
1704 xref_name
= IDENTIFIER_POINTER (name
);
1706 GNU_xref_call (current_function_decl
, xref_name
);
1709 if (instance
== NULL_TREE
)
1711 basetype
= NULL_TREE
;
1712 /* Check cases where this is really a call to raise
1714 if (current_class_type
&& TREE_CODE (name
) == IDENTIFIER_NODE
)
1716 basetype
= purpose_member (name
, CLASSTYPE_TAGS (current_class_type
));
1718 basetype
= TREE_VALUE (basetype
);
1720 else if (TREE_CODE (name
) == SCOPE_REF
1721 && TREE_CODE (TREE_OPERAND (name
, 0)) == IDENTIFIER_NODE
)
1723 if (! is_aggr_typedef (TREE_OPERAND (name
, 0), 1))
1724 return error_mark_node
;
1725 basetype
= purpose_member (TREE_OPERAND (name
, 1),
1726 CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name
, 0))));
1728 basetype
= TREE_VALUE (basetype
);
1731 if (basetype
!= NULL_TREE
)
1733 /* call to a constructor... */
1734 else if (basetype_path
)
1735 basetype
= BINFO_TYPE (basetype_path
);
1736 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1738 basetype
= IDENTIFIER_TYPE_VALUE (name
);
1739 name
= constructor_name_full (basetype
);
1743 tree typedef_name
= lookup_name (name
, 1);
1744 if (typedef_name
&& TREE_CODE (typedef_name
) == TYPE_DECL
)
1746 /* Canonicalize the typedef name. */
1747 basetype
= TREE_TYPE (typedef_name
);
1748 name
= TYPE_IDENTIFIER (basetype
);
1752 cp_error ("no constructor named `%T' in scope",
1754 return error_mark_node
;
1758 if (! IS_AGGR_TYPE (basetype
))
1761 if ((flags
& LOOKUP_COMPLAIN
) && TREE_CODE (basetype
) != ERROR_MARK
)
1762 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1763 name
, instance
, basetype
);
1765 return error_mark_node
;
1768 else if (instance
== C_C_D
|| instance
== current_class_decl
)
1770 /* When doing initialization, we side-effect the TREE_TYPE of
1771 C_C_D, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */
1772 basetype
= TREE_TYPE (C_C_D
);
1774 /* Anything manifestly `this' in constructors and destructors
1775 has a known type, so virtual function tables are not needed. */
1776 if (TYPE_VIRTUAL_P (basetype
)
1777 && !(flags
& LOOKUP_NONVIRTUAL
))
1778 need_vtbl
= (dtor_label
|| ctor_label
)
1779 ? unneeded
: maybe_needed
;
1781 /* If `this' is a signature pointer and `name' is not a constructor,
1782 we are calling a signature member function. In that case, set the
1783 `basetype' to the signature type and dereference the `optr' field. */
1784 if (IS_SIGNATURE_POINTER (basetype
)
1785 && TYPE_IDENTIFIER (basetype
) != name
)
1787 basetype
= SIGNATURE_TYPE (basetype
);
1788 instance_ptr
= build_optr_ref (instance
);
1789 instance_ptr
= convert (build_pointer_type (basetype
), instance_ptr
);
1790 basetype_path
= TYPE_BINFO (basetype
);
1795 instance_ptr
= current_class_decl
;
1796 basetype_path
= TYPE_BINFO (current_class_type
);
1798 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1803 else if (TREE_CODE (instance
) == RESULT_DECL
)
1805 basetype
= TREE_TYPE (instance
);
1806 /* Should we ever have to make a virtual function reference
1807 from a RESULT_DECL, know that it must be of fixed type
1808 within the scope of this function. */
1809 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1810 need_vtbl
= maybe_needed
;
1811 instance_ptr
= build1 (ADDR_EXPR
, build_pointer_type (basetype
), instance
);
1815 /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */
1816 tree inst_ptr_basetype
;
1818 static_call_context
=
1819 (TREE_CODE (instance
) == INDIRECT_REF
1820 && TREE_CODE (TREE_OPERAND (instance
, 0)) == NOP_EXPR
1821 && TREE_OPERAND (TREE_OPERAND (instance
, 0), 0) == error_mark_node
);
1823 if (TREE_CODE (instance
) == OFFSET_REF
)
1824 instance
= resolve_offset_ref (instance
);
1826 /* the base type of an instance variable is pointer to class */
1827 basetype
= TREE_TYPE (instance
);
1829 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1831 basetype
= TREE_TYPE (basetype
);
1832 if (! IS_AGGR_TYPE (basetype
))
1833 goto non_aggr_error
;
1834 /* Call to convert not needed because we are remaining
1835 within the same type. */
1836 instance_ptr
= build1 (NOP_EXPR
, build_pointer_type (basetype
),
1838 inst_ptr_basetype
= TYPE_MAIN_VARIANT (basetype
);
1842 if (! IS_AGGR_TYPE (basetype
)
1843 && ! (TYPE_LANG_SPECIFIC (basetype
)
1844 && (IS_SIGNATURE_POINTER (basetype
)
1845 || IS_SIGNATURE_REFERENCE (basetype
))))
1846 goto non_aggr_error
;
1848 /* If `instance' is a signature pointer/reference and `name' is
1849 not a constructor, we are calling a signature member function.
1850 In that case set the `basetype' to the signature type. */
1851 if ((IS_SIGNATURE_POINTER (basetype
)
1852 || IS_SIGNATURE_REFERENCE (basetype
))
1853 && TYPE_IDENTIFIER (basetype
) != name
)
1854 basetype
= SIGNATURE_TYPE (basetype
);
1856 if ((IS_SIGNATURE (basetype
)
1857 && (instance_ptr
= instance
))
1858 || (lvalue_p (instance
)
1859 && (instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0)))
1860 || (instance_ptr
= unary_complex_lvalue (ADDR_EXPR
, instance
)))
1862 if (instance_ptr
== error_mark_node
)
1863 return error_mark_node
;
1865 else if (TREE_CODE (instance
) == NOP_EXPR
1866 || TREE_CODE (instance
) == CONSTRUCTOR
)
1868 /* A cast is not an lvalue. Initialize a fresh temp
1869 with the value we are casting from, and proceed with
1870 that temporary. We can't cast to a reference type,
1871 so that simplifies the initialization to something
1873 tree temp
= get_temp_name (TREE_TYPE (instance
), 0);
1874 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
1875 expand_aggr_init (temp
, instance
, 0, flags
);
1878 store_init_value (temp
, instance
);
1879 expand_decl_init (temp
);
1882 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1886 if (TREE_CODE (instance
) != CALL_EXPR
)
1887 my_friendly_abort (125);
1888 if (TYPE_NEEDS_CONSTRUCTING (basetype
))
1889 instance
= build_cplus_new (basetype
, instance
, 0);
1892 instance
= get_temp_name (basetype
, 0);
1893 TREE_ADDRESSABLE (instance
) = 1;
1895 instance_ptr
= build_unary_op (ADDR_EXPR
, instance
, 0);
1897 /* @@ Should we call comp_target_types here? */
1898 if (IS_SIGNATURE (basetype
))
1899 inst_ptr_basetype
= basetype
;
1901 inst_ptr_basetype
= TREE_TYPE (TREE_TYPE (instance_ptr
));
1902 if (TYPE_MAIN_VARIANT (basetype
) == TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1903 basetype
= inst_ptr_basetype
;
1906 instance_ptr
= convert (build_pointer_type (basetype
), instance_ptr
);
1907 if (instance_ptr
== error_mark_node
)
1908 return error_mark_node
;
1912 /* After converting `instance_ptr' above, `inst_ptr_basetype' was
1913 not updated, so we use `basetype' instead. */
1914 if (basetype_path
== NULL_TREE
1915 && IS_SIGNATURE (basetype
))
1916 basetype_path
= TYPE_BINFO (basetype
);
1917 else if (basetype_path
== NULL_TREE
||
1918 BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (inst_ptr_basetype
))
1919 basetype_path
= TYPE_BINFO (inst_ptr_basetype
);
1921 result
= build_field_call (basetype_path
, instance_ptr
, name
, parms
);
1925 if (!(flags
& LOOKUP_NONVIRTUAL
) && TYPE_VIRTUAL_P (basetype
))
1927 if (TREE_SIDE_EFFECTS (instance_ptr
))
1929 /* This action is needed because the instance is needed
1930 for providing the base of the virtual function table.
1931 Without using a SAVE_EXPR, the function we are building
1932 may be called twice, or side effects on the instance
1933 variable (such as a post-increment), may happen twice. */
1934 instance_ptr
= save_expr (instance_ptr
);
1935 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
1937 else if (TREE_CODE (TREE_TYPE (instance
)) == POINTER_TYPE
)
1939 /* This happens when called for operator new (). */
1940 instance
= build_indirect_ref (instance
, NULL_PTR
);
1943 need_vtbl
= maybe_needed
;
1947 if (TYPE_SIZE (basetype
) == 0)
1949 /* This is worth complaining about, I think. */
1950 cp_error ("cannot lookup method in incomplete type `%T'", basetype
);
1951 return error_mark_node
;
1954 save_basetype
= TYPE_MAIN_VARIANT (basetype
);
1957 if (all_virtual
== 1
1958 && (! strncmp (IDENTIFIER_POINTER (name
), OPERATOR_METHOD_FORMAT
,
1959 OPERATOR_METHOD_LENGTH
)
1960 || instance_ptr
== NULL_TREE
1961 || (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype
) == 0)))
1966 for (parmtypes
= NULL_TREE
, parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
1968 tree t
= TREE_TYPE (TREE_VALUE (parm
));
1969 if (TREE_CODE (t
) == OFFSET_TYPE
)
1971 /* Convert OFFSET_TYPE entities to their normal selves. */
1972 TREE_VALUE (parm
) = resolve_offset_ref (TREE_VALUE (parm
));
1973 t
= TREE_TYPE (TREE_VALUE (parm
));
1975 if (TREE_CODE (TREE_VALUE (parm
)) == OFFSET_REF
1976 && TREE_CODE (t
) == METHOD_TYPE
)
1978 TREE_VALUE (parm
) = build_unary_op (ADDR_EXPR
, TREE_VALUE (parm
), 0);
1981 /* This breaks reference-to-array parameters. */
1982 if (TREE_CODE (t
) == ARRAY_TYPE
)
1984 /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
1985 This eliminates needless calls to `compute_conversion_costs'. */
1986 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
1987 t
= TREE_TYPE (TREE_VALUE (parm
));
1990 if (t
== error_mark_node
)
1991 return error_mark_node
;
1992 last
= build_tree_list (NULL_TREE
, t
);
1993 parmtypes
= chainon (parmtypes
, last
);
1996 if (instance
&& IS_SIGNATURE (basetype
))
1998 /* @@ Should this be the constp/volatilep flags for the optr field
1999 of the signature pointer? */
2000 constp
= TYPE_READONLY (basetype
);
2001 volatilep
= TYPE_VOLATILE (basetype
);
2002 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2006 /* TREE_READONLY (instance) fails for references. */
2007 constp
= TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2008 volatilep
= TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2009 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2013 /* Raw constructors are always in charge. */
2014 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2015 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2017 flags
|= LOOKUP_HAS_IN_CHARGE
;
2018 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
2019 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
2024 instance_ptr
= build_int_2 (0, 0);
2025 TREE_TYPE (instance_ptr
) = build_pointer_type (basetype
);
2026 parms
= tree_cons (NULL_TREE
, instance_ptr
, parms
);
2029 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (instance_ptr
), parmtypes
);
2031 if (last
== NULL_TREE
)
2034 /* Look up function name in the structure type definition. */
2036 if ((IDENTIFIER_HAS_TYPE_VALUE (name
)
2037 && ! IDENTIFIER_OPNAME_P (name
)
2038 && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name
))
2039 && TREE_CODE (IDENTIFIER_TYPE_VALUE (name
)) != UNINSTANTIATED_P_TYPE
)
2040 || name
== constructor_name (basetype
))
2042 tree tmp
= NULL_TREE
;
2043 if (IDENTIFIER_TYPE_VALUE (name
) == basetype
2044 || name
== constructor_name (basetype
))
2045 tmp
= TYPE_BINFO (basetype
);
2047 tmp
= get_binfo (IDENTIFIER_TYPE_VALUE (name
), basetype
, 0);
2049 if (tmp
!= NULL_TREE
)
2051 name_kind
= "constructor";
2053 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
)
2054 && ! (flags
& LOOKUP_HAS_IN_CHARGE
))
2056 /* Constructors called for initialization
2057 only are never in charge. */
2060 flags
|= LOOKUP_HAS_IN_CHARGE
;
2061 tmplist
= tree_cons (NULL_TREE
, integer_zero_node
,
2062 TREE_CHAIN (parms
));
2063 TREE_CHAIN (parms
) = tmplist
;
2064 tmplist
= tree_cons (NULL_TREE
, integer_type_node
, TREE_CHAIN (parmtypes
));
2065 TREE_CHAIN (parmtypes
) = tmplist
;
2067 basetype
= BINFO_TYPE (tmp
);
2070 name_kind
= "method";
2073 name_kind
= "method";
2075 if (basetype_path
== NULL_TREE
2076 || BINFO_TYPE (basetype_path
) != TYPE_MAIN_VARIANT (basetype
))
2077 basetype_path
= TYPE_BINFO (basetype
);
2078 result
= lookup_fnfields (basetype_path
, name
,
2079 (flags
& LOOKUP_COMPLAIN
));
2080 if (result
== error_mark_node
)
2081 return error_mark_node
;
2085 /* Now, go look for this method name. We do not find destructors here.
2087 Putting `void_list_node' on the end of the parmtypes
2088 fakes out `build_decl_overload' into doing the right thing. */
2089 TREE_CHAIN (last
) = void_list_node
;
2090 method_name
= build_decl_overload (name
, parmtypes
,
2091 1 + (name
== constructor_name (save_basetype
)
2092 || name
== constructor_name_full (save_basetype
)));
2093 TREE_CHAIN (last
) = NULL_TREE
;
2096 for (pass
= 0; pass
< 2; pass
++)
2098 struct candidate
*candidates
;
2099 struct candidate
*cp
;
2103 /* This increments every time we go up the type hierarchy.
2104 The idea is to prefer a function of the derived class if possible. */
2112 = (struct candidate
*) alloca ((ever_seen
+1)
2113 * sizeof (struct candidate
));
2114 bzero ((char *) candidates
, (ever_seen
+ 1) * sizeof (struct candidate
));
2116 len
= list_length (parms
);
2119 /* First see if a global function has a shot at it. */
2120 if (flags
& LOOKUP_GLOBAL
)
2123 tree parm
= instance_ptr
;
2125 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
)
2126 parm
= convert_from_reference (parm
);
2127 else if (TREE_CODE (TREE_TYPE (parm
)) == POINTER_TYPE
)
2128 parm
= build_indirect_ref (parm
, "friendifying parms (compiler error)");
2130 my_friendly_abort (167);
2132 friend_parms
= tree_cons (NULL_TREE
, parm
, TREE_CHAIN (parms
));
2135 cp
->harshness
= (struct harshness_code
*)
2136 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2138 result
= build_overload_call (name
, friend_parms
, 0, cp
);
2139 /* If it turns out to be the one we were actually looking for
2140 (it was probably a friend function), the return the
2142 if (TREE_CODE (result
) == CALL_EXPR
)
2145 while ((cp
->h
.code
& EVIL_CODE
) == 0)
2147 /* non-standard uses: set the field to 0 to indicate
2148 we are using a non-member function. */
2150 if (cp
->harshness
[len
].distance
== 0
2151 && cp
->h
.code
< best
)
2160 /* We have a hit (of sorts). If the parameter list is
2161 "error_mark_node", or some variant thereof, it won't
2162 match any methods. Since we have verified that the is
2163 some method vaguely matching this one (in name at least),
2166 Don't stop for friends, however. */
2167 basetype_path
= TREE_PURPOSE (baselink
);
2169 function
= TREE_VALUE (baselink
);
2170 if (TREE_CODE (basetype_path
) == TREE_LIST
)
2171 basetype_path
= TREE_VALUE (basetype_path
);
2172 basetype
= BINFO_TYPE (basetype_path
);
2175 /* Cast the instance variable if necessary. */
2176 if (basetype
!= TYPE_MAIN_VARIANT
2177 (TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)))))
2179 if (basetype
== save_basetype
)
2180 TREE_VALUE (parms
) = instance_ptr
;
2183 tree type
= build_pointer_type
2184 (build_type_variant (basetype
, constp
, volatilep
));
2185 TREE_VALUE (parms
) = convert_force (type
, instance_ptr
, 0);
2189 /* FIXME: this is the wrong place to get an error. Hopefully
2190 the access-control rewrite will make this change more cleanly. */
2191 if (TREE_VALUE (parms
) == error_mark_node
)
2192 return error_mark_node
;
2195 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function
)))
2196 function
= DECL_CHAIN (function
);
2198 for (; function
; function
= DECL_CHAIN (function
))
2200 #ifdef GATHER_STATISTICS
2201 n_inner_fields_searched
++;
2205 found_fns
= tree_cons (NULL_TREE
, function
, found_fns
);
2207 /* Not looking for friends here. */
2208 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
2209 && ! DECL_STATIC_FUNCTION_P (function
))
2214 && DECL_ASSEMBLER_NAME (function
) == method_name
)
2220 tree these_parms
= parms
;
2222 #ifdef GATHER_STATISTICS
2223 n_inner_fields_searched
++;
2226 cp
->harshness
= (struct harshness_code
*)
2227 alloca ((len
+ 1) * sizeof (struct harshness_code
));
2229 if (DECL_STATIC_FUNCTION_P (function
))
2230 these_parms
= TREE_CHAIN (these_parms
);
2231 compute_conversion_costs (function
, these_parms
, cp
, len
);
2233 if ((cp
->h
.code
& EVIL_CODE
) == 0)
2235 cp
->u
.field
= function
;
2236 cp
->function
= function
;
2237 cp
->basetypes
= basetype_path
;
2239 /* Don't allow non-converting constructors to convert. */
2240 if (flags
& LOOKUP_ONLYCONVERTING
2241 && DECL_LANG_SPECIFIC (function
)
2242 && DECL_NONCONVERTING_P (function
))
2245 /* No "two-level" conversions. */
2246 if (flags
& LOOKUP_NO_CONVERSION
2247 && (cp
->h
.code
& USER_CODE
))
2254 /* Now we have run through one link's member functions.
2255 arrange to head-insert this link's links. */
2256 baselink
= next_baselink (baselink
);
2258 /* Don't grab functions from base classes. lookup_fnfield will
2259 do the work to get us down into the right place. */
2260 baselink
= NULL_TREE
;
2264 tree igv
= lookup_name_nonclass (name
);
2266 /* No exact match could be found. Now try to find match
2267 using default conversions. */
2268 if ((flags
& LOOKUP_GLOBAL
) && igv
)
2270 if (TREE_CODE (igv
) == FUNCTION_DECL
)
2272 else if (TREE_CODE (igv
) == TREE_LIST
)
2273 ever_seen
+= count_functions (igv
);
2278 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2279 == LOOKUP_SPECULATIVELY
)
2282 TREE_CHAIN (last
) = void_list_node
;
2283 if (flags
& LOOKUP_GLOBAL
)
2284 cp_error ("no global or member function `%D(%A)' defined",
2287 cp_error ("no member function `%T::%D(%A)' defined",
2288 save_basetype
, name
, TREE_CHAIN (parmtypes
));
2289 return error_mark_node
;
2294 if (cp
- candidates
!= 0)
2296 /* Rank from worst to best. Then cp will point to best one.
2297 Private fields have their bits flipped. For unsigned
2298 numbers, this should make them look very large.
2299 If the best alternate has a (signed) negative value,
2300 then all we ever saw were private members. */
2301 if (cp
- candidates
> 1)
2303 int n_candidates
= cp
- candidates
;
2304 extern int warn_synth
;
2305 TREE_VALUE (parms
) = instance_ptr
;
2306 cp
= ideal_candidate (save_basetype
, candidates
,
2307 n_candidates
, parms
, len
);
2308 if (cp
== (struct candidate
*)0)
2310 if (flags
& LOOKUP_COMPLAIN
)
2312 TREE_CHAIN (last
) = void_list_node
;
2313 cp_error ("call of overloaded %s `%D(%A)' is ambiguous",
2314 name_kind
, name
, TREE_CHAIN (parmtypes
));
2315 print_n_candidates (candidates
, n_candidates
);
2317 return error_mark_node
;
2319 if (cp
->h
.code
& EVIL_CODE
)
2320 return error_mark_node
;
2322 && DECL_NAME (cp
->function
) == ansi_opname
[MODIFY_EXPR
]
2323 && DECL_ARTIFICIAL (cp
->function
)
2324 && n_candidates
== 2)
2326 cp_warning ("using synthesized `%#D' for copy assignment",
2328 cp_warning_at (" where cfront would use `%#D'",
2329 candidates
->function
);
2332 else if (cp
[-1].h
.code
& EVIL_CODE
)
2334 if (flags
& LOOKUP_COMPLAIN
)
2335 cp_error ("ambiguous type conversion requested for %s `%D'",
2337 return error_mark_node
;
2342 /* The global function was the best, so use it. */
2343 if (cp
->u
.field
== 0)
2345 /* We must convert the instance pointer into a reference type.
2346 Global overloaded functions can only either take
2347 aggregate objects (which come for free from references)
2348 or reference data types anyway. */
2349 TREE_VALUE (parms
) = copy_node (instance_ptr
);
2350 TREE_TYPE (TREE_VALUE (parms
)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr
)));
2351 return build_function_call (cp
->function
, parms
);
2354 function
= cp
->function
;
2355 basetype_path
= cp
->basetypes
;
2356 if (! DECL_STATIC_FUNCTION_P (function
))
2357 TREE_VALUE (parms
) = cp
->arg
;
2358 goto found_and_maybe_warn
;
2361 if (flags
& (LOOKUP_COMPLAIN
|LOOKUP_SPECULATIVELY
))
2363 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2364 == LOOKUP_SPECULATIVELY
)
2367 if (DECL_STATIC_FUNCTION_P (cp
->function
))
2368 parms
= TREE_CHAIN (parms
);
2371 if (flags
& LOOKUP_SPECULATIVELY
)
2373 if (static_call_context
2374 && TREE_CODE (TREE_TYPE (cp
->function
)) == METHOD_TYPE
)
2375 cp_error ("object missing in call to `%D'", cp
->function
);
2376 else if (ever_seen
> 1)
2378 TREE_CHAIN (last
) = void_list_node
;
2379 cp_error ("no matching function for call to `%T::%D (%A)%V'",
2380 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (instance_ptr
))),
2381 name
, TREE_CHAIN (parmtypes
),
2382 TREE_TYPE (TREE_TYPE (instance_ptr
)));
2383 TREE_CHAIN (last
) = NULL_TREE
;
2384 print_candidates (found_fns
);
2387 report_type_mismatch (cp
, parms
, name_kind
);
2388 return error_mark_node
;
2391 if ((flags
& (LOOKUP_SPECULATIVELY
|LOOKUP_COMPLAIN
))
2394 cp_error ("%T has no method named %D", save_basetype
, name
);
2395 return error_mark_node
;
2401 found_and_maybe_warn
:
2402 if ((cp
->harshness
[0].code
& CONST_CODE
)
2403 /* 12.1p2: Constructors can be called for const objects. */
2404 && ! DECL_CONSTRUCTOR_P (cp
->function
))
2406 if (flags
& LOOKUP_COMPLAIN
)
2408 cp_error_at ("non-const member function `%D'", cp
->function
);
2409 error ("called for const object at this point in file");
2411 /* Not good enough for a match. */
2413 return error_mark_node
;
2417 /* Silently return error_mark_node. */
2418 return error_mark_node
;
2421 if (flags
& LOOKUP_PROTECT
)
2422 access
= compute_access (basetype_path
, function
);
2424 if (access
== access_private
)
2426 if (flags
& LOOKUP_COMPLAIN
)
2428 cp_error_at ("%s `%+#D' is %s", name_kind
, function
,
2429 TREE_PRIVATE (function
) ? "private"
2430 : "from private base class");
2431 error ("within this context");
2433 return error_mark_node
;
2435 else if (access
== access_protected
)
2437 if (flags
& LOOKUP_COMPLAIN
)
2439 cp_error_at ("%s `%+#D' %s", name_kind
, function
,
2440 TREE_PROTECTED (function
) ? "is protected"
2441 : "has protected accessibility");
2442 error ("within this context");
2444 return error_mark_node
;
2447 /* From here on down, BASETYPE is the type that INSTANCE_PTR's
2448 type (if it exists) is a pointer to. */
2450 if (DECL_ABSTRACT_VIRTUAL_P (function
)
2451 && instance
== C_C_D
2452 && DECL_CONSTRUCTOR_P (current_function_decl
)
2453 && ! (flags
& LOOKUP_NONVIRTUAL
)
2454 && value_member (function
, get_abstract_virtuals (basetype
)))
2455 cp_error ("abstract virtual `%#D' called from constructor", function
);
2457 if (IS_SIGNATURE (basetype
) && static_call_context
)
2459 cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
2461 return error_mark_node
;
2463 else if (IS_SIGNATURE (basetype
))
2464 return build_signature_method_call (basetype
, instance
, function
, parms
);
2466 function
= DECL_MAIN_VARIANT (function
);
2467 /* Declare external function if necessary. */
2468 assemble_external (function
);
2471 /* Is it a synthesized method that needs to be synthesized? */
2472 if (DECL_ARTIFICIAL (function
) && ! flag_no_inline
2473 && ! DECL_INITIAL (function
)
2474 /* Kludge: don't synthesize for default args. */
2475 && current_function_decl
)
2476 synthesize_method (function
);
2479 if (pedantic
&& DECL_THIS_INLINE (function
) && ! DECL_ARTIFICIAL (function
)
2480 && ! DECL_INITIAL (function
) && ! DECL_PENDING_INLINE_INFO (function
))
2481 cp_warning ("inline function `%#D' called before definition", function
);
2483 fntype
= TREE_TYPE (function
);
2484 if (TREE_CODE (fntype
) == POINTER_TYPE
)
2485 fntype
= TREE_TYPE (fntype
);
2486 basetype
= DECL_CLASS_CONTEXT (function
);
2488 /* If we are referencing a virtual function from an object
2489 of effectively static type, then there is no need
2490 to go through the virtual function table. */
2491 if (need_vtbl
== maybe_needed
)
2493 int fixed_type
= resolves_to_fixed_type_p (instance
, 0);
2495 if (all_virtual
== 1
2496 && DECL_VINDEX (function
)
2497 && may_be_remote (basetype
))
2499 else if (DECL_VINDEX (function
))
2500 need_vtbl
= fixed_type
? unneeded
: needed
;
2502 need_vtbl
= not_needed
;
2505 if (TREE_CODE (fntype
) == METHOD_TYPE
&& static_call_context
2506 && !DECL_CONSTRUCTOR_P (function
))
2508 /* Let's be nice to the user for now, and give reasonable
2509 default behavior. */
2510 instance_ptr
= current_class_decl
;
2513 if (basetype
!= current_class_type
)
2515 tree binfo
= get_binfo (basetype
, current_class_type
, 1);
2516 if (binfo
== NULL_TREE
)
2518 error_not_base_type (function
, current_class_type
);
2519 return error_mark_node
;
2521 else if (basetype
== error_mark_node
)
2522 return error_mark_node
;
2525 /* Only allow a static member function to call another static member
2527 else if (DECL_LANG_SPECIFIC (function
)
2528 && !DECL_STATIC_FUNCTION_P (function
))
2530 cp_error ("cannot call member function `%D' without object",
2532 return error_mark_node
;
2536 value_type
= TREE_TYPE (fntype
) ? TREE_TYPE (fntype
) : void_type_node
;
2538 if (TYPE_SIZE (value_type
) == 0)
2540 if (flags
& LOOKUP_COMPLAIN
)
2541 incomplete_type_error (0, value_type
);
2542 return error_mark_node
;
2545 if (DECL_STATIC_FUNCTION_P (function
))
2546 parms
= convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
2547 TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
);
2548 else if (need_vtbl
== unneeded
)
2550 int sub_flags
= DECL_CONSTRUCTOR_P (function
) ? flags
: LOOKUP_NORMAL
;
2551 basetype
= TREE_TYPE (instance
);
2552 if (TYPE_METHOD_BASETYPE (TREE_TYPE (function
)) != TYPE_MAIN_VARIANT (basetype
)
2553 && TYPE_USES_COMPLEX_INHERITANCE (basetype
))
2555 basetype
= DECL_CLASS_CONTEXT (function
);
2556 instance_ptr
= convert_pointer_to (basetype
, instance_ptr
);
2557 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2559 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2560 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, sub_flags
));
2564 if ((flags
& LOOKUP_NONVIRTUAL
) == 0)
2565 basetype
= DECL_CONTEXT (function
);
2567 /* First parm could be integer_zerop with casts like
2568 ((Object*)0)->Object::IsA() */
2569 if (!integer_zerop (TREE_VALUE (parms
)))
2571 /* Since we can't have inheritance with a union, doing get_binfo
2572 on it won't work. We do all the convert_pointer_to_real
2573 stuff to handle MI correctly...for unions, that's not
2574 an issue, so we must short-circuit that extra work here. */
2575 tree tmp
= TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
)));
2576 if (tmp
!= NULL_TREE
&& TREE_CODE (tmp
) == UNION_TYPE
)
2577 instance_ptr
= TREE_VALUE (parms
);
2580 tree binfo
= get_binfo (basetype
,
2581 TREE_TYPE (TREE_TYPE (TREE_VALUE (parms
))),
2583 instance_ptr
= convert_pointer_to_real (binfo
, TREE_VALUE (parms
));
2586 = convert_pointer_to (build_type_variant (basetype
,
2590 if (TREE_CODE (instance_ptr
) == COND_EXPR
)
2592 instance_ptr
= save_expr (instance_ptr
);
2593 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2595 else if (TREE_CODE (instance_ptr
) == NOP_EXPR
2596 && TREE_CODE (TREE_OPERAND (instance_ptr
, 0)) == ADDR_EXPR
2597 && TREE_OPERAND (TREE_OPERAND (instance_ptr
, 0), 0) == instance
)
2599 /* The call to `convert_pointer_to' may return error_mark_node. */
2600 else if (TREE_CODE (instance_ptr
) == ERROR_MARK
)
2601 return instance_ptr
;
2602 else if (instance
== NULL_TREE
2603 || TREE_CODE (instance
) != INDIRECT_REF
2604 || TREE_OPERAND (instance
, 0) != instance_ptr
)
2605 instance
= build_indirect_ref (instance_ptr
, NULL_PTR
);
2607 parms
= tree_cons (NULL_TREE
, instance_ptr
,
2608 convert_arguments (NULL_TREE
, TREE_CHAIN (TYPE_ARG_TYPES (fntype
)), TREE_CHAIN (parms
), function
, LOOKUP_NORMAL
));
2612 /* Constructors do not overload method calls. */
2613 else if (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype
)
2614 && name
!= TYPE_IDENTIFIER (basetype
)
2615 && (TREE_CODE (function
) != FUNCTION_DECL
2616 || strncmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)),
2617 OPERATOR_METHOD_FORMAT
,
2618 OPERATOR_METHOD_LENGTH
))
2619 && (may_be_remote (basetype
) || instance
!= C_C_D
))
2623 parms
= TREE_CHAIN (parms
);
2625 if (!all_virtual
&& TREE_CODE (function
) == FUNCTION_DECL
)
2626 fn_as_int
= build_unary_op (ADDR_EXPR
, function
, 0);
2628 fn_as_int
= convert (TREE_TYPE (default_conversion (function
)), DECL_VINDEX (function
));
2629 if (all_virtual
== 1)
2630 fn_as_int
= convert (integer_type_node
, fn_as_int
);
2632 result
= build_opfncall (METHOD_CALL_EXPR
, LOOKUP_NORMAL
, instance
, fn_as_int
, parms
);
2634 if (result
== NULL_TREE
)
2636 compiler_error ("could not overload `operator->()(...)'");
2637 return error_mark_node
;
2639 else if (result
== error_mark_node
)
2640 return error_mark_node
;
2643 /* Do this if we want the result of operator->() to inherit
2644 the type of the function it is subbing for. */
2645 TREE_TYPE (result
) = value_type
;
2652 if (parms
== error_mark_node
2653 || (parms
&& TREE_CHAIN (parms
) == error_mark_node
))
2654 return error_mark_node
;
2656 if (need_vtbl
== needed
)
2658 function
= build_vfn_ref (&TREE_VALUE (parms
), instance
,
2659 DECL_VINDEX (function
));
2660 TREE_TYPE (function
) = build_pointer_type (fntype
);
2663 if (TREE_CODE (function
) == FUNCTION_DECL
)
2664 GNU_xref_call (current_function_decl
,
2665 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
)));
2670 if (TREE_CODE (function
) == FUNCTION_DECL
)
2672 is_constructor
= DECL_CONSTRUCTOR_P (function
);
2673 TREE_USED (function
) = 1;
2674 function
= default_conversion (function
);
2679 function
= default_conversion (function
);
2682 result
= build_nt (CALL_EXPR
, function
, parms
, NULL_TREE
);
2684 TREE_TYPE (result
) = value_type
;
2685 TREE_SIDE_EFFECTS (result
) = 1;
2686 TREE_HAS_CONSTRUCTOR (result
) = is_constructor
;
2687 result
= convert_from_reference (result
);
2692 /* Similar to `build_method_call', but for overloaded non-member functions.
2693 The name of this function comes through NAME. The name depends
2696 Note that this function must handle simple `C' promotions,
2697 as well as variable numbers of arguments (...), and
2698 default arguments to boot.
2700 If the overloading is successful, we return a tree node which
2701 contains the call to the function.
2703 If overloading produces candidates which are probable, but not definite,
2704 we hold these candidates. If FINAL_CP is non-zero, then we are free
2705 to assume that final_cp points to enough storage for all candidates that
2706 this function might generate. The `harshness' array is preallocated for
2707 the first candidate, but not for subsequent ones.
2709 Note that the DECL_RTL of FUNCTION must be made to agree with this
2710 function's new name. */
2713 build_overload_call_real (fnname
, parms
, flags
, final_cp
, buildxxx
)
2716 struct candidate
*final_cp
;
2719 /* must check for overloading here */
2720 tree overload_name
, functions
, function
, parm
;
2721 tree parmtypes
= NULL_TREE
, last
= NULL_TREE
;
2722 register tree outer
;
2724 int parmlength
= list_length (parms
);
2726 struct candidate
*candidates
, *cp
;
2730 final_cp
[0].h
.code
= 0;
2731 final_cp
[0].h
.distance
= 0;
2732 final_cp
[0].function
= 0;
2734 final_cp
[1].h
.code
= EVIL_CODE
;
2737 for (parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
2739 register tree t
= TREE_TYPE (TREE_VALUE (parm
));
2741 if (t
== error_mark_node
)
2744 final_cp
->h
.code
= EVIL_CODE
;
2745 return error_mark_node
;
2747 if (TREE_CODE (t
) == OFFSET_TYPE
)
2749 /* This breaks reference-to-array parameters. */
2750 || TREE_CODE (t
) == ARRAY_TYPE
2753 /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
2754 Also convert OFFSET_TYPE entities to their normal selves.
2755 This eliminates needless calls to `compute_conversion_costs'. */
2756 TREE_VALUE (parm
) = default_conversion (TREE_VALUE (parm
));
2757 t
= TREE_TYPE (TREE_VALUE (parm
));
2759 last
= build_tree_list (NULL_TREE
, t
);
2760 parmtypes
= chainon (parmtypes
, last
);
2763 TREE_CHAIN (last
) = void_list_node
;
2765 parmtypes
= void_list_node
;
2767 if (is_overloaded_fn (fnname
))
2770 if (TREE_CODE (fnname
) == TREE_LIST
)
2771 fnname
= TREE_PURPOSE (functions
);
2772 else if (TREE_CODE (fnname
) == FUNCTION_DECL
)
2773 fnname
= DECL_NAME (functions
);
2776 functions
= lookup_name_nonclass (fnname
);
2778 if (functions
== NULL_TREE
)
2780 if (flags
& LOOKUP_SPECULATIVELY
)
2782 if (flags
& LOOKUP_COMPLAIN
)
2783 error ("only member functions apply");
2785 final_cp
->h
.code
= EVIL_CODE
;
2786 return error_mark_node
;
2789 if (TREE_CODE (functions
) == FUNCTION_DECL
&& ! IDENTIFIER_OPNAME_P (fnname
))
2791 functions
= DECL_MAIN_VARIANT (functions
);
2794 /* We are just curious whether this is a viable alternative or
2796 compute_conversion_costs (functions
, parms
, final_cp
, parmlength
);
2800 return build_function_call_real (functions
, parms
, 1, flags
);
2803 if (TREE_CODE (functions
) == TREE_LIST
2804 && TREE_VALUE (functions
) == NULL_TREE
)
2806 if (flags
& LOOKUP_SPECULATIVELY
)
2809 if (flags
& LOOKUP_COMPLAIN
)
2810 cp_error ("function `%D' declared overloaded, but no instances of that function declared",
2811 TREE_PURPOSE (functions
));
2813 final_cp
->h
.code
= EVIL_CODE
;
2814 return error_mark_node
;
2817 length
= count_functions (functions
);
2820 candidates
= final_cp
;
2824 = (struct candidate
*)alloca ((length
+1) * sizeof (struct candidate
));
2825 bzero ((char *) candidates
, (length
+ 1) * sizeof (struct candidate
));
2830 my_friendly_assert (is_overloaded_fn (functions
), 169);
2832 functions
= get_first_fn (functions
);
2834 /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
2835 for (outer
= functions
; outer
; outer
= DECL_CHAIN (outer
))
2837 int template_cost
= 0;
2839 if (TREE_CODE (function
) != FUNCTION_DECL
2840 && ! (TREE_CODE (function
) == TEMPLATE_DECL
2841 && ! DECL_TEMPLATE_IS_CLASS (function
)
2842 && TREE_CODE (DECL_TEMPLATE_RESULT (function
)) == FUNCTION_DECL
))
2844 enum tree_code code
= TREE_CODE (function
);
2845 if (code
== TEMPLATE_DECL
)
2846 code
= TREE_CODE (DECL_TEMPLATE_RESULT (function
));
2847 if (code
== CONST_DECL
)
2849 ("enumeral value `%D' conflicts with function of same name",
2851 else if (code
== VAR_DECL
)
2853 if (TREE_STATIC (function
))
2855 ("variable `%D' conflicts with function of same name",
2859 ("constant field `%D' conflicts with function of same name",
2862 else if (code
== TYPE_DECL
)
2865 my_friendly_abort (2);
2866 error ("at this point in file");
2869 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2871 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function
));
2872 tree
*targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
2875 i
= type_unification (DECL_TEMPLATE_PARMS (function
), targs
,
2876 TYPE_ARG_TYPES (TREE_TYPE (function
)),
2877 parms
, &template_cost
, 0);
2879 function
= instantiate_template (function
, targs
);
2882 if (TREE_CODE (function
) == TEMPLATE_DECL
)
2884 /* Unconverted template -- failed match. */
2885 cp
->function
= function
;
2887 cp
->h
.code
= EVIL_CODE
;
2891 struct candidate
*cp2
;
2893 /* Check that this decl is not the same as a function that's in
2894 the list due to some template instantiation. */
2897 if (cp2
->function
== function
)
2901 if (cp2
->function
== function
)
2904 function
= DECL_MAIN_VARIANT (function
);
2906 /* Can't use alloca here, since result might be
2907 passed to calling function. */
2908 cp
->h_len
= parmlength
;
2909 cp
->harshness
= (struct harshness_code
*)
2910 oballoc ((parmlength
+ 1) * sizeof (struct harshness_code
));
2912 compute_conversion_costs (function
, parms
, cp
, parmlength
);
2914 /* Make sure this is clear as well. */
2915 cp
->h
.int_penalty
+= template_cost
;
2917 if ((cp
[0].h
.code
& EVIL_CODE
) == 0)
2919 cp
[1].h
.code
= EVIL_CODE
;
2925 if (cp
- candidates
)
2927 tree rval
= error_mark_node
;
2930 cp
[0].h
.code
= EVIL_CODE
;
2931 if (cp
- candidates
> 1)
2933 struct candidate
*best_cp
2934 = ideal_candidate (NULL_TREE
, candidates
,
2935 cp
- candidates
, parms
, parmlength
);
2936 if (best_cp
== (struct candidate
*)0)
2938 if (flags
& LOOKUP_COMPLAIN
)
2940 cp_error ("call of overloaded `%D' is ambiguous", fnname
);
2941 print_n_candidates (candidates
, cp
- candidates
);
2943 return error_mark_node
;
2946 rval
= best_cp
->function
;
2951 if (cp
->h
.code
& EVIL_CODE
)
2953 if (flags
& LOOKUP_COMPLAIN
)
2954 error ("type conversion ambiguous");
2957 rval
= cp
->function
;
2963 return buildxxx
? build_function_call_real (rval
, parms
, 0, flags
)
2964 : build_function_call_real (rval
, parms
, 1, flags
);
2967 if (flags
& LOOKUP_SPECULATIVELY
)
2970 if (flags
& LOOKUP_COMPLAIN
)
2971 report_type_mismatch (cp
, parms
, "function",
2972 decl_as_string (cp
->function
, 1));
2974 return error_mark_node
;
2978 build_overload_call (fnname
, parms
, flags
, final_cp
)
2981 struct candidate
*final_cp
;
2983 return build_overload_call_real (fnname
, parms
, flags
, final_cp
, 0);
2987 build_overload_call_maybe (fnname
, parms
, flags
, final_cp
)
2990 struct candidate
*final_cp
;
2992 return build_overload_call_real (fnname
, parms
, flags
, final_cp
, 1);