1 /* Functions related to invoking methods and overloaded functions.
2 Copyright (C) 1987, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 hacked by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* High-level class interface. */
35 #define obstack_chunk_alloc xmalloc
36 #define obstack_chunk_free free
40 extern int inhibit_warnings;
41 extern tree ctor_label, dtor_label;
43 /* Compute the ease with which a conversion can be performed
44 between an expected and the given type. */
46 static struct harshness_code convert_harshness PROTO((register tree, register tree, tree));
47 static tree build_new_method_call PROTO((tree, tree, tree, tree, int));
49 #define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG))
50 #define STD_RETURN(ARG) ((ARG).code = STD_CODE, (ARG))
51 #define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG))
52 #define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG))
53 #define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG))
55 /* Ordering function for overload resolution. Compare two candidates
59 rank_for_overload (x, y)
60 struct candidate *x, *y;
62 if (y->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE))
63 return y->h.code - x->h.code;
64 if (x->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE))
67 /* This is set by compute_conversion_costs, for calling a non-const
68 member function from a const member function. */
69 if ((y->harshness[0].code & CONST_CODE) ^ (x->harshness[0].code & CONST_CODE))
70 return y->harshness[0].code - x->harshness[0].code;
72 if (y->h.code & STD_CODE)
74 if (x->h.code & STD_CODE)
75 return y->h.distance - x->h.distance;
78 if (x->h.code & STD_CODE)
81 return y->h.code - x->h.code;
84 /* Compare two candidates, argument by argument. */
88 struct candidate *x, *y;
92 if (x->h_len != y->h_len)
95 for (i = 0; i < x->h_len; i++)
97 if (y->harshness[i].code - x->harshness[i].code)
98 return y->harshness[i].code - x->harshness[i].code;
99 if ((y->harshness[i].code & STD_CODE)
100 && (y->harshness[i].distance - x->harshness[i].distance))
101 return y->harshness[i].distance - x->harshness[i].distance;
103 /* They're both the same code. Now see if we're dealing with an
104 integral promotion that needs a finer grain of accuracy. */
105 if (y->harshness[0].code & PROMO_CODE
106 && (y->harshness[i].int_penalty ^ x->harshness[i].int_penalty))
107 return y->harshness[i].int_penalty - x->harshness[i].int_penalty;
112 /* TYPE is the type we wish to convert to. PARM is the parameter
113 we have to work with. We use a somewhat arbitrary cost function
114 to measure this conversion. */
116 static struct harshness_code
117 convert_harshness (type, parmtype, parm)
118 register tree type, parmtype;
121 struct harshness_code h;
122 register enum tree_code codel;
123 register enum tree_code coder;
130 #ifdef GATHER_STATISTICS
131 n_convert_harshness++;
134 if (TREE_CODE (parmtype) == REFERENCE_TYPE)
137 parm = convert_from_reference (parm);
138 parmtype = TREE_TYPE (parmtype);
142 lvalue = lvalue_p (parm);
146 if (TYPE_PTRMEMFUNC_P (type))
147 type = TYPE_PTRMEMFUNC_FN_TYPE (type);
148 if (TYPE_PTRMEMFUNC_P (parmtype))
149 parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
151 codel = TREE_CODE (type);
152 coder = TREE_CODE (parmtype);
154 if (TYPE_MAIN_VARIANT (parmtype) == TYPE_MAIN_VARIANT (type))
155 return ZERO_RETURN (h);
157 if (coder == ERROR_MARK)
158 return EVIL_RETURN (h);
160 if (codel == REFERENCE_TYPE)
163 int constp = parm ? TREE_READONLY (parm) : TYPE_READONLY (parmtype);
164 int volatilep = (parm ? TREE_THIS_VOLATILE (parm)
165 : TYPE_VOLATILE (parmtype));
166 register tree intype = TYPE_MAIN_VARIANT (parmtype);
167 register enum tree_code form = TREE_CODE (intype);
170 ttl = TREE_TYPE (type);
172 /* Only allow const reference binding if we were given a parm to deal
173 with, since it isn't really a conversion. This is a hack to
174 prevent build_type_conversion from finding this conversion, but
175 still allow overloading to find it. */
176 if (! lvalue && ! (parm && TYPE_READONLY (ttl)))
177 return EVIL_RETURN (h);
179 if ((TYPE_READONLY (ttl) < constp)
180 || (TYPE_VOLATILE (ttl) < volatilep))
181 return EVIL_RETURN (h);
183 /* When passing a non-const argument into a const reference, dig it a
184 little, so a non-const reference is preferred over this one. */
185 penalty = ((TYPE_READONLY (ttl) > constp)
186 + (TYPE_VOLATILE (ttl) > volatilep));
188 ttl = TYPE_MAIN_VARIANT (ttl);
190 if (form == OFFSET_TYPE)
192 intype = TREE_TYPE (intype);
193 form = TREE_CODE (intype);
198 if (TREE_CODE (ttl) == ARRAY_TYPE && TREE_CODE (ttr) == ARRAY_TYPE)
200 if (comptypes (ttl, ttr, 1))
201 return ZERO_RETURN (h);
202 return EVIL_RETURN (h);
205 h = convert_harshness (ttl, ttr, NULL_TREE);
206 if (penalty && h.code == 0)
209 h.int_penalty = penalty;
214 if (codel == POINTER_TYPE && fntype_p (parmtype))
217 struct harshness_code h1, h2;
219 /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */
220 type = TREE_TYPE (type);
222 if (coder == POINTER_TYPE)
224 parmtype = TREE_TYPE (parmtype);
225 coder = TREE_CODE (parmtype);
228 if (coder != TREE_CODE (type))
229 return EVIL_RETURN (h);
231 if (type != parmtype && coder == METHOD_TYPE)
233 tree ttl = TYPE_METHOD_BASETYPE (type);
234 tree ttr = TYPE_METHOD_BASETYPE (parmtype);
236 int b_or_d = get_base_distance (ttr, ttl, 0, (tree*)0);
239 b_or_d = get_base_distance (ttl, ttr, 0, (tree*)0);
241 return EVIL_RETURN (h);
242 h.distance = -b_or_d;
248 type = build_function_type
249 (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type)));
250 parmtype = build_function_type
251 (TREE_TYPE (parmtype), TREE_CHAIN (TYPE_ARG_TYPES (parmtype)));
254 /* We allow the default conversion between function type
255 and pointer-to-function type for free. */
256 if (comptypes (type, parmtype, 1))
260 return EVIL_RETURN (h);
262 /* Compare return types. */
263 p1 = TREE_TYPE (type);
264 p2 = TREE_TYPE (parmtype);
265 h2 = convert_harshness (p1, p2, NULL_TREE);
266 if (h2.code & EVIL_CODE)
269 h1.code = TRIVIAL_CODE;
272 if (h2.distance != 0)
276 /* This only works for pointers. */
277 if (TREE_CODE (p1) != POINTER_TYPE
278 && TREE_CODE (p1) != REFERENCE_TYPE)
279 return EVIL_RETURN (h);
283 /* Don't die if we happen to be dealing with void*. */
284 if (!IS_AGGR_TYPE (p1) || !IS_AGGR_TYPE (p2))
285 return EVIL_RETURN (h);
287 binfo = get_binfo (p2, p1, 0);
289 binfo = get_binfo (p1, p2, 0);
291 if (! BINFO_OFFSET_ZEROP (binfo))
294 static int explained = 0;
296 message_2_types (sorry, "cannot cast `%s' to `%s' at function call site", p2, p1);
298 message_2_types (sorry, "cannot cast `%s' to `%s' at function call site", p1, p2);
301 sorry ("(because pointer values change during conversion)");
303 return EVIL_RETURN (h);
308 if (h2.distance > h1.distance)
309 h1.distance = h2.distance;
311 p1 = TYPE_ARG_TYPES (type);
312 p2 = TYPE_ARG_TYPES (parmtype);
313 while (p1 && TREE_VALUE (p1) != void_type_node
314 && p2 && TREE_VALUE (p2) != void_type_node)
316 h2 = convert_harshness (TREE_VALUE (p1), TREE_VALUE (p2),
318 if (h2.code & EVIL_CODE)
323 /* This only works for pointers and references. */
324 if (TREE_CODE (TREE_VALUE (p1)) != POINTER_TYPE
325 && TREE_CODE (TREE_VALUE (p1)) != REFERENCE_TYPE)
326 return EVIL_RETURN (h);
327 h2.distance = - h2.distance;
331 if (h2.distance > h1.distance)
332 h1.distance = h2.distance;
333 p1 = TREE_CHAIN (p1);
334 p2 = TREE_CHAIN (p2);
341 return EVIL_RETURN (h);
342 h1.code |= ELLIPSIS_CODE;
347 if (TREE_PURPOSE (p1) == NULL_TREE)
348 h1.code |= EVIL_CODE;
352 else if (codel == POINTER_TYPE && coder == OFFSET_TYPE)
356 /* Get to the OFFSET_TYPE that this might be. */
357 type = TREE_TYPE (type);
359 if (coder != TREE_CODE (type))
360 return EVIL_RETURN (h);
362 ttl = TYPE_OFFSET_BASETYPE (type);
363 ttr = TYPE_OFFSET_BASETYPE (parmtype);
369 int b_or_d = get_base_distance (ttr, ttl, 0, (tree*)0);
372 b_or_d = get_base_distance (ttl, ttr, 0, (tree*)0);
374 return EVIL_RETURN (h);
375 h.distance = -b_or_d;
382 /* Now test the OFFSET_TYPE's target compatibility. */
383 type = TREE_TYPE (type);
384 parmtype = TREE_TYPE (parmtype);
387 if (coder == UNKNOWN_TYPE)
389 if (codel == FUNCTION_TYPE
390 || codel == METHOD_TYPE
391 || (codel == POINTER_TYPE
392 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
393 || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)))
394 return TRIVIAL_RETURN (h);
395 return EVIL_RETURN (h);
398 if (coder == VOID_TYPE)
399 return EVIL_RETURN (h);
401 if (codel == BOOLEAN_TYPE)
403 if (INTEGRAL_CODE_P (coder) || coder == REAL_TYPE)
404 return STD_RETURN (h);
405 else if (coder == POINTER_TYPE || coder == OFFSET_TYPE)
407 /* Make this worse than any conversion to another pointer.
408 FIXME this is how I think the language should work, but it may not
409 end up being how the language is standardized (jason 1/30/95). */
411 return STD_RETURN (h);
413 return EVIL_RETURN (h);
416 if (INTEGRAL_CODE_P (codel))
418 /* Control equivalence of ints an enums. */
420 if (codel == ENUMERAL_TYPE
421 && flag_int_enum_equivalence == 0)
423 /* Enums can be converted to ints, but not vice-versa. */
424 if (coder != ENUMERAL_TYPE
425 || TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (parmtype))
426 return EVIL_RETURN (h);
429 /* else enums and ints (almost) freely interconvert. */
431 if (INTEGRAL_CODE_P (coder))
433 if (TYPE_MAIN_VARIANT (type)
434 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype)))
443 else if (coder == REAL_TYPE)
451 if (codel == REAL_TYPE)
453 if (coder == REAL_TYPE)
455 if (TYPE_MAIN_VARIANT (type)
456 == TYPE_MAIN_VARIANT (type_promotes_to (parmtype)))
463 else if (INTEGRAL_CODE_P (coder))
471 /* Convert arrays which have not previously been converted. */
472 if (coder == ARRAY_TYPE)
474 coder = POINTER_TYPE;
477 parm = decay_conversion (parm);
478 parmtype = TREE_TYPE (parm);
481 parmtype = build_pointer_type (TREE_TYPE (parmtype));
484 /* Conversions among pointers */
485 if (codel == POINTER_TYPE && coder == POINTER_TYPE)
487 register tree ttl = TYPE_MAIN_VARIANT (TREE_TYPE (type));
488 register tree ttr = TYPE_MAIN_VARIANT (TREE_TYPE (parmtype));
489 int penalty = 4 * (ttl != ttr);
491 /* Anything converts to void *. Since this may be `const void *'
492 (etc.) use VOID_TYPE instead of void_type_node. Otherwise, the
493 targets must be the same, except that we do allow (at some cost)
494 conversion between signed and unsigned pointer types. */
496 if ((TREE_CODE (ttl) == METHOD_TYPE
497 || TREE_CODE (ttl) == FUNCTION_TYPE)
498 && TREE_CODE (ttl) == TREE_CODE (ttr))
500 if (comptypes (ttl, ttr, -1))
502 h.code = penalty ? STD_CODE : 0;
511 if (TREE_CODE (ttl) != VOID_TYPE
512 && (TREE_CODE (ttr) != VOID_TYPE || !parm || !null_ptr_cst_p (parm)))
514 if (comp_target_types (type, parmtype, 1) <= 0)
515 return EVIL_RETURN (h);
518 if (!(TREE_CODE (ttl) == VOID_TYPE
519 || TREE_CODE (ttr) == VOID_TYPE
520 || (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (ttr)
521 && (ttl = unsigned_type (ttl),
522 ttr = unsigned_type (ttr),
524 || (comp_target_types (ttl, ttr, 0) > 0)))
525 return EVIL_RETURN (h);
530 tree tmp1 = TREE_TYPE (type), tmp2 = TREE_TYPE (parmtype);
533 /* Note conversion from `T*' to `const T*',
534 or `T*' to `volatile T*'. */
535 if ((TYPE_READONLY (tmp1) < TREE_READONLY (tmp2))
536 || (TYPE_VOLATILE (tmp1) < TYPE_VOLATILE (tmp2)))
538 else if ((TYPE_READONLY (tmp1) != TREE_READONLY (tmp2))
539 || (TYPE_VOLATILE (tmp1) != TYPE_VOLATILE (tmp2)))
547 if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
549 int b_or_d = get_base_distance (ttl, ttr, 0, (tree*)0);
552 b_or_d = get_base_distance (ttr, ttl, 0, (tree*)0);
554 return EVIL_RETURN (h);
555 h.distance = -b_or_d;
563 /* If converting from a `class*' to a `void*', make it
564 less favorable than any inheritance relationship. */
565 if (TREE_CODE (ttl) == VOID_TYPE && IS_AGGR_TYPE (ttr))
568 h.distance = CLASSTYPE_MAX_DEPTH (ttr)+1;
572 h.code = penalty ? STD_CODE : PROMO_CODE;
573 /* Catch things like `const char *' -> `const void *'
574 vs `const char *' -> `void *'. */
577 tree tmp1 = TREE_TYPE (type), tmp2 = TREE_TYPE (parmtype);
578 if ((TYPE_READONLY (tmp1) < TREE_READONLY (tmp2))
579 || (TYPE_VOLATILE (tmp1) < TYPE_VOLATILE (tmp2)))
581 else if ((TYPE_READONLY (tmp1) > TREE_READONLY (tmp2))
582 || (TYPE_VOLATILE (tmp1) > TYPE_VOLATILE (tmp2)))
588 if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
590 /* This is not a bad match, but don't let it beat
591 integer-enum combinations. */
592 if (parm && integer_zerop (parm))
600 /* C++: Since the `this' parameter of a signature member function
601 is represented as a signature pointer to handle default implementations
602 correctly, we can have the case that `type' is a signature pointer
603 while `parmtype' is a pointer to a signature table. We don't really
604 do any conversions in this case, so just return 0. */
606 if (codel == RECORD_TYPE && coder == POINTER_TYPE
607 && IS_SIGNATURE_POINTER (type) && IS_SIGNATURE (TREE_TYPE (parmtype)))
608 return ZERO_RETURN (h);
610 if (codel == RECORD_TYPE && coder == RECORD_TYPE)
612 int b_or_d = get_base_distance (type, parmtype, 0, (tree*)0);
615 b_or_d = get_base_distance (parmtype, type, 0, (tree*)0);
617 return EVIL_RETURN (h);
618 h.distance = -b_or_d;
625 return EVIL_RETURN (h);
628 /* A clone of build_type_conversion for checking user-defined conversions in
629 overload resolution. */
632 user_harshness (type, parmtype)
633 register tree type, parmtype;
636 tree winner = NULL_TREE;
640 tree typename = build_typename_overload (type);
641 if (lookup_fnfields (TYPE_BINFO (parmtype), typename, 0))
645 for (conv = lookup_conversions (parmtype); conv; conv = TREE_CHAIN (conv))
647 struct harshness_code tmp;
648 tree cand = TREE_VALUE (conv);
650 if (winner && winner == cand)
653 tmp = convert_harshness (type, TREE_TYPE (TREE_TYPE (cand)), NULL_TREE);
654 if ((tmp.code < USER_CODE) && (tmp.distance >= 0))
672 #ifdef DEBUG_MATCHING
675 struct harshness_code *h;
677 static char buf[1024];
680 bzero (buf, 1024 * sizeof (char));
681 strcat (buf, "codes=[");
682 if (h->code & EVIL_CODE)
683 strcat (buf, "EVIL");
684 if (h->code & CONST_CODE)
685 strcat (buf, " CONST");
686 if (h->code & ELLIPSIS_CODE)
687 strcat (buf, " ELLIPSIS");
688 if (h->code & USER_CODE)
689 strcat (buf, " USER");
690 if (h->code & STD_CODE)
691 strcat (buf, " STD");
692 if (h->code & PROMO_CODE)
693 strcat (buf, " PROMO");
694 if (h->code & QUAL_CODE)
695 strcat (buf, " QUAL");
696 if (h->code & TRIVIAL_CODE)
697 strcat (buf, " TRIVIAL");
701 sprintf (tmp, "] distance=%d int_penalty=%d", h->distance, h->int_penalty);
709 /* Algorithm: For each argument, calculate how difficult it is to
710 make FUNCTION accept that argument. If we can easily tell that
711 FUNCTION won't be acceptable to one of the arguments, then we
712 don't need to compute the ease of converting the other arguments,
713 since it will never show up in the intersection of all arguments'
716 Conversions between builtin and user-defined types are allowed, but
717 no function involving such a conversion is preferred to one which
718 does not require such a conversion. Furthermore, such conversions
722 compute_conversion_costs (function, tta_in, cp, arglen)
725 struct candidate *cp;
728 tree ttf_in = TYPE_ARG_TYPES (TREE_TYPE (function));
732 /* Start out with no strikes against. */
733 int evil_strikes = 0;
734 int ellipsis_strikes = 0;
735 int user_strikes = 0;
736 int b_or_d_strikes = 0;
737 int easy_strikes = 0;
739 int strike_index = 0, win;
740 struct harshness_code lose;
741 extern int cp_silent;
743 #ifdef GATHER_STATISTICS
744 n_compute_conversion_costs++;
747 #ifndef DEBUG_MATCHING
748 /* We don't emit any warnings or errors while trying out each candidate. */
752 cp->function = function;
753 cp->arg = tta ? TREE_VALUE (tta) : NULL_TREE;
754 cp->u.bad_arg = 0; /* optimistic! */
758 cp->h.int_penalty = 0;
759 bzero ((char *) cp->harshness,
760 (cp->h_len + 1) * sizeof (struct harshness_code));
764 struct harshness_code h;
766 if (ttf == void_list_node)
769 if (type_unknown_p (TREE_VALUE (tta)))
771 /* Must perform some instantiation here. */
772 tree rhs = TREE_VALUE (tta);
773 tree lhstype = TREE_VALUE (ttf);
775 /* Keep quiet about possible contravariance violations. */
776 int old_inhibit_warnings = inhibit_warnings;
777 inhibit_warnings = 1;
779 /* @@ This is to undo what `grokdeclarator' does to
780 parameter types. It really should go through
781 something more general. */
783 TREE_TYPE (tta) = unknown_type_node;
784 rhs = instantiate_type (lhstype, rhs, 0);
785 inhibit_warnings = old_inhibit_warnings;
787 if (TREE_CODE (rhs) == ERROR_MARK)
790 h = convert_harshness (lhstype, TREE_TYPE (rhs), rhs);
794 #ifdef DEBUG_MATCHING
795 static tree old_function = NULL_TREE;
797 if (!old_function || function != old_function)
799 cp_error ("trying %D", function);
800 old_function = function;
803 cp_error (" doing (%T) %E against arg %T",
804 TREE_TYPE (TREE_VALUE (tta)), TREE_VALUE (tta),
808 h = convert_harshness (TREE_VALUE (ttf),
809 TREE_TYPE (TREE_VALUE (tta)),
812 #ifdef DEBUG_MATCHING
813 cp_error (" evaluated %s", print_harshness (&h));
817 cp->harshness[strike_index] = h;
818 if ((h.code & EVIL_CODE)
819 || ((h.code & STD_CODE) && h.distance < 0))
821 cp->u.bad_arg = strike_index;
824 else if (h.code & ELLIPSIS_CODE)
825 ellipsis_strikes += 1;
827 /* This is never set by `convert_harshness'. */
828 else if (h.code & USER_CODE)
835 if ((h.code & STD_CODE) && h.distance)
837 if (h.distance > b_or_d_strikes)
838 b_or_d_strikes = h.distance;
841 easy_strikes += (h.code & (STD_CODE|PROMO_CODE|TRIVIAL_CODE));
842 cp->h.code |= h.code;
843 /* Make sure we communicate this. */
844 cp->h.int_penalty += h.int_penalty;
847 ttf = TREE_CHAIN (ttf);
848 tta = TREE_CHAIN (tta);
854 /* ran out of formals, and parmlist is fixed size. */
855 if (ttf /* == void_type_node */)
857 cp->h.code = EVIL_CODE;
864 struct harshness_code h;
865 int l = list_length (tta);
866 ellipsis_strikes += l;
867 h.code = ELLIPSIS_CODE;
871 cp->harshness[strike_index++] = h;
874 else if (ttf && ttf != void_list_node)
876 /* ran out of actuals, and no defaults. */
877 if (TREE_PURPOSE (ttf) == NULL_TREE)
879 cp->h.code = EVIL_CODE;
884 /* Store index of first default. */
885 cp->harshness[arglen].distance = strike_index+1;
888 cp->harshness[arglen].distance = 0;
890 /* Argument list lengths work out, so don't need to check them again. */
893 /* We do not check for derived->base conversions here, since in
894 no case would they give evil strike counts, unless such conversions
895 are somehow ambiguous. */
897 /* See if any user-defined conversions apply.
898 But make sure that we do not loop. */
899 static int dont_convert_types = 0;
901 if (dont_convert_types)
903 cp->h.code = EVIL_CODE;
908 win = 0; /* Only get one chance to win. */
909 ttf = TYPE_ARG_TYPES (TREE_TYPE (function));
916 if (ttf == void_list_node)
919 lose = cp->harshness[strike_index];
920 if ((lose.code & EVIL_CODE)
921 || ((lose.code & STD_CODE) && lose.distance < 0))
923 tree actual_type = TREE_TYPE (TREE_VALUE (tta));
924 tree formal_type = TREE_VALUE (ttf);
925 int extra_conversions = 0;
927 dont_convert_types = 1;
929 if (TREE_CODE (formal_type) == REFERENCE_TYPE)
930 formal_type = TREE_TYPE (formal_type);
931 if (TREE_CODE (actual_type) == REFERENCE_TYPE)
932 actual_type = TREE_TYPE (actual_type);
934 if (formal_type != error_mark_node
935 && actual_type != error_mark_node)
937 formal_type = complete_type (TYPE_MAIN_VARIANT (formal_type));
938 actual_type = complete_type (TYPE_MAIN_VARIANT (actual_type));
940 if (TYPE_HAS_CONSTRUCTOR (formal_type))
942 /* If it has a constructor for this type,
944 /* @@ There is no way to save this result yet, so
945 success is a NULL_TREE for now. */
946 if (convert_to_aggr (formal_type, TREE_VALUE (tta), 0, 1)
950 if (TYPE_LANG_SPECIFIC (actual_type)
951 && TYPE_HAS_CONVERSION (actual_type))
953 int extra = user_harshness (formal_type, actual_type);
955 if (extra == EVIL_CODE)
960 extra_conversions = extra;
964 dont_convert_types = 0;
969 cp->harshness[strike_index].code
970 = USER_CODE | (extra_conversions ? STD_CODE : 0);
975 if (cp->u.bad_arg > strike_index)
976 cp->u.bad_arg = strike_index;
978 evil_strikes = win ? 2 : 1;
983 ttf = TREE_CHAIN (ttf);
984 tta = TREE_CHAIN (tta);
989 /* Const member functions get a small penalty because defaulting
990 to const is less useful than defaulting to non-const. */
991 /* This is bogus, it does not correspond to anything in the ARM.
992 This code will be fixed when this entire section is rewritten
993 to conform to the ARM. (mrs) */
994 if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
996 tree this_parm = TREE_VALUE (ttf_in);
998 if (TREE_CODE (this_parm) == RECORD_TYPE /* Is `this' a sig ptr? */
999 ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm))))
1000 : TYPE_READONLY (TREE_TYPE (this_parm)))
1002 cp->harshness[0].code |= TRIVIAL_CODE;
1007 /* Calling a non-const member function from a const member function
1008 is probably invalid, but for now we let it only draw a warning.
1009 We indicate that such a mismatch has occurred by setting the
1010 harshness to a maximum value. */
1011 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in))) == POINTER_TYPE
1012 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in))))))
1013 cp->harshness[0].code |= CONST_CODE;
1018 cp->h.code = EVIL_CODE;
1019 if (ellipsis_strikes)
1020 cp->h.code |= ELLIPSIS_CODE;
1022 cp->h.code |= USER_CODE;
1024 #ifdef DEBUG_MATCHING
1025 cp_error ("final eval %s", print_harshness (&cp->h));
1029 /* Subroutine of ideal_candidate. See if X or Y is a better match
1033 strictly_better (x, y)
1034 unsigned short x, y;
1042 if (xor >= x || xor >= y)
1047 /* When one of several possible overloaded functions and/or methods
1048 can be called, choose the best candidate for overloading.
1050 BASETYPE is the context from which we start method resolution
1051 or NULL if we are comparing overloaded functions.
1052 CANDIDATES is the array of candidates we have to choose from.
1053 N_CANDIDATES is the length of CANDIDATES.
1054 PARMS is a TREE_LIST of parameters to the function we'll ultimately
1055 choose. It is modified in place when resolving methods. It is not
1056 modified in place when resolving overloaded functions.
1057 LEN is the length of the parameter list. */
1059 static struct candidate *
1060 ideal_candidate (candidates, n_candidates, len)
1061 struct candidate *candidates;
1065 struct candidate *cp = candidates+n_candidates;
1066 int i, j = -1, best_code;
1068 /* For each argument, sort the functions from best to worst for the arg.
1069 For each function that's not best for this arg, set its overall
1070 harshness to EVIL so that other args won't like it. The candidate
1071 list for the last argument is the intersection of all the best-liked
1074 qsort (candidates, n_candidates, sizeof (struct candidate),
1076 best_code = cp[-1].h.code;
1078 /* If they're at least as good as each other, do an arg-by-arg check. */
1079 if (! strictly_better (cp[-1].h.code, cp[-2].h.code))
1084 for (j = 0; j < n_candidates; j++)
1085 if (! strictly_better (candidates[j].h.code, best_code))
1088 qsort (candidates+j, n_candidates-j, sizeof (struct candidate),
1090 for (i = 0; i < len; i++)
1092 if (cp[-1].harshness[i].code < cp[-2].harshness[i].code)
1094 else if (cp[-1].harshness[i].code > cp[-2].harshness[i].code)
1096 else if (cp[-1].harshness[i].code & STD_CODE)
1098 /* If it involves a standard conversion, let the
1099 inheritance lattice be the final arbiter. */
1100 if (cp[-1].harshness[i].distance > cp[-2].harshness[i].distance)
1102 else if (cp[-1].harshness[i].distance < cp[-2].harshness[i].distance)
1105 else if (cp[-1].harshness[i].code & PROMO_CODE)
1107 /* For integral promotions, take into account a finer
1108 granularity for determining which types should be favored
1109 over others in such promotions. */
1110 if (cp[-1].harshness[i].int_penalty > cp[-2].harshness[i].int_penalty)
1112 else if (cp[-1].harshness[i].int_penalty < cp[-2].harshness[i].int_penalty)
1117 if (! better || worse)
1123 /* Assume that if the class referred to is not in the
1124 current class hierarchy, that it may be remote.
1125 PARENT is assumed to be of aggregate type here. */
1128 may_be_remote (parent)
1131 if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent) == 0)
1134 if (current_class_type == NULL_TREE)
1137 if (parent == current_class_type)
1140 if (UNIQUELY_DERIVED_FROM_P (parent, current_class_type))
1146 build_vfield_ref (datum, type)
1150 int old_assume_nonnull_objects = flag_assume_nonnull_objects;
1152 if (datum == error_mark_node)
1153 return error_mark_node;
1155 /* Vtable references are always made from non-null objects. */
1156 flag_assume_nonnull_objects = 1;
1157 if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
1158 datum = convert_from_reference (datum);
1160 if (! TYPE_USES_COMPLEX_INHERITANCE (type))
1161 rval = build (COMPONENT_REF, TREE_TYPE (CLASSTYPE_VFIELD (type)),
1162 datum, CLASSTYPE_VFIELD (type));
1164 rval = build_component_ref (datum, DECL_NAME (CLASSTYPE_VFIELD (type)), NULL_TREE, 0);
1165 flag_assume_nonnull_objects = old_assume_nonnull_objects;
1170 /* Build a call to a member of an object. I.e., one that overloads
1171 operator ()(), or is a pointer-to-function or pointer-to-method. */
1174 build_field_call (basetype_path, instance_ptr, name, parms)
1175 tree basetype_path, instance_ptr, name, parms;
1177 tree field, instance;
1179 if (name == ctor_identifier || name == dtor_identifier)
1182 if (instance_ptr == current_class_ptr)
1184 /* Check to see if we really have a reference to an instance variable
1185 with `operator()()' overloaded. */
1186 field = IDENTIFIER_CLASS_VALUE (name);
1188 if (field == NULL_TREE)
1190 cp_error ("`this' has no member named `%D'", name);
1191 return error_mark_node;
1194 if (TREE_CODE (field) == FIELD_DECL)
1196 /* If it's a field, try overloading operator (),
1197 or calling if the field is a pointer-to-function. */
1198 instance = build_component_ref_1 (current_class_ref, field, 0);
1199 if (instance == error_mark_node)
1200 return error_mark_node;
1202 if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance))
1203 && (TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance))
1204 || flag_ansi_overloading))
1205 return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, instance, parms, NULL_TREE);
1207 if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
1209 if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == FUNCTION_TYPE)
1210 return build_function_call (instance, parms);
1211 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == METHOD_TYPE)
1212 return build_function_call (instance, tree_cons (NULL_TREE, current_class_ptr, parms));
1218 /* Check to see if this is not really a reference to an instance variable
1219 with `operator()()' overloaded. */
1220 field = lookup_field (basetype_path, name, 1, 0);
1222 /* This can happen if the reference was ambiguous or for access
1224 if (field == error_mark_node)
1225 return error_mark_node;
1230 tree ftype = TREE_TYPE (field);
1232 if (TREE_CODE (ftype) == REFERENCE_TYPE)
1233 ftype = TREE_TYPE (ftype);
1235 if (TYPE_LANG_SPECIFIC (ftype)
1236 && (TYPE_OVERLOADS_CALL_EXPR (ftype) || flag_ansi_overloading))
1238 /* Make the next search for this field very short. */
1239 basetype = DECL_FIELD_CONTEXT (field);
1240 instance_ptr = convert_pointer_to (basetype, instance_ptr);
1242 instance = build_indirect_ref (instance_ptr, NULL_PTR);
1243 return build_opfncall (CALL_EXPR, LOOKUP_NORMAL,
1244 build_component_ref_1 (instance, field, 0),
1247 if (TREE_CODE (ftype) == POINTER_TYPE)
1249 if (TREE_CODE (TREE_TYPE (ftype)) == FUNCTION_TYPE
1250 || TREE_CODE (TREE_TYPE (ftype)) == METHOD_TYPE)
1252 /* This is a member which is a pointer to function. */
1254 = build_component_ref_1 (build_indirect_ref (instance_ptr,
1256 field, LOOKUP_COMPLAIN);
1257 if (ref == error_mark_node)
1258 return error_mark_node;
1259 return build_function_call (ref, parms);
1262 else if (TREE_CODE (ftype) == METHOD_TYPE)
1264 error ("invalid call via pointer-to-member function");
1265 return error_mark_node;
1274 find_scoped_type (type, inner_name, inner_types)
1275 tree type, inner_name, inner_types;
1277 tree tags = CLASSTYPE_TAGS (type);
1281 /* The TREE_PURPOSE of an enum tag (which becomes a member of the
1282 enclosing class) is set to the name for the enum type. So, if
1283 inner_name is `bar', and we strike `baz' for `enum bar { baz }',
1284 then this test will be true. */
1285 if (TREE_PURPOSE (tags) == inner_name)
1287 if (inner_types == NULL_TREE)
1288 return TYPE_MAIN_DECL (TREE_VALUE (tags));
1289 return resolve_scope_to_name (TREE_VALUE (tags), inner_types);
1291 tags = TREE_CHAIN (tags);
1294 /* Look for a TYPE_DECL. */
1295 for (tags = TYPE_FIELDS (type); tags; tags = TREE_CHAIN (tags))
1296 if (TREE_CODE (tags) == TYPE_DECL && DECL_NAME (tags) == inner_name)
1298 /* Code by raeburn. */
1299 if (inner_types == NULL_TREE)
1301 return resolve_scope_to_name (TREE_TYPE (tags), inner_types);
1307 /* Resolve an expression NAME1::NAME2::...::NAMEn to
1308 the name that names the above nested type. INNER_TYPES
1309 is a chain of nested type names (held together by SCOPE_REFs);
1310 OUTER_TYPE is the type we know to enclose INNER_TYPES.
1311 Returns NULL_TREE if there is an error. */
1314 resolve_scope_to_name (outer_type, inner_stuff)
1315 tree outer_type, inner_stuff;
1318 tree inner_name, inner_type;
1320 if (outer_type == NULL_TREE && current_class_type != NULL_TREE)
1322 /* We first try to look for a nesting in our current class context,
1323 then try any enclosing classes. */
1324 tree type = current_class_type;
1326 while (type && (TREE_CODE (type) == RECORD_TYPE
1327 || TREE_CODE (type) == UNION_TYPE))
1329 tree rval = resolve_scope_to_name (type, inner_stuff);
1331 if (rval != NULL_TREE)
1333 type = DECL_CONTEXT (TYPE_MAIN_DECL (type));
1337 if (TREE_CODE (inner_stuff) == SCOPE_REF)
1339 inner_name = TREE_OPERAND (inner_stuff, 0);
1340 inner_type = TREE_OPERAND (inner_stuff, 1);
1344 inner_name = inner_stuff;
1345 inner_type = NULL_TREE;
1348 if (outer_type == NULL_TREE)
1351 /* If we have something that's already a type by itself,
1353 if (IDENTIFIER_HAS_TYPE_VALUE (inner_name))
1356 return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name),
1361 x = lookup_name (inner_name, 0);
1363 if (x && TREE_CODE (x) == NAMESPACE_DECL)
1365 x = lookup_namespace_name (x, inner_type);
1371 if (! IS_AGGR_TYPE (outer_type))
1374 /* Look for member classes or enums. */
1375 tmp = find_scoped_type (outer_type, inner_name, inner_type);
1377 /* If it's not a type in this class, then go down into the
1378 base classes and search there. */
1379 if (! tmp && TYPE_BINFO (outer_type))
1381 tree binfos = TYPE_BINFO_BASETYPES (outer_type);
1382 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1384 for (i = 0; i < n_baselinks; i++)
1386 tree base_binfo = TREE_VEC_ELT (binfos, i);
1387 tmp = resolve_scope_to_name (BINFO_TYPE (base_binfo), inner_stuff);
1397 /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
1398 This is how virtual function calls are avoided. */
1401 build_scoped_method_call (exp, basetype, name, parms)
1402 tree exp, basetype, name, parms;
1404 /* Because this syntactic form does not allow
1405 a pointer to a base class to be `stolen',
1406 we need not protect the derived->base conversion
1409 @@ But we do have to check access privileges later. */
1411 tree type = TREE_TYPE (exp);
1413 if (type == error_mark_node
1414 || basetype == error_mark_node)
1415 return error_mark_node;
1417 if (processing_template_decl)
1419 if (TREE_CODE (name) == BIT_NOT_EXPR)
1421 tree type = get_aggr_from_typedef (TREE_OPERAND (name, 0), 1);
1422 name = build_min_nt (BIT_NOT_EXPR, type);
1424 name = build_min_nt (SCOPE_REF, basetype, name);
1425 return build_min_nt (METHOD_CALL_EXPR, name, exp, parms, NULL_TREE);
1428 if (TREE_CODE (type) == REFERENCE_TYPE)
1429 type = TREE_TYPE (type);
1431 if (TREE_CODE (basetype) == TREE_VEC)
1434 basetype = BINFO_TYPE (binfo);
1439 /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
1440 that explicit ~int is caught in the parser; this deals with typedefs
1441 and template parms. */
1442 if (TREE_CODE (name) == BIT_NOT_EXPR && ! IS_AGGR_TYPE (basetype))
1444 if (type != basetype)
1445 cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
1446 exp, basetype, type);
1447 name = TREE_OPERAND (name, 0);
1448 if (basetype != name && basetype != get_type_value (name))
1449 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1451 return convert (void_type_node, exp);
1454 if (! is_aggr_type (basetype, 1))
1455 return error_mark_node;
1457 if (! IS_AGGR_TYPE (type))
1459 cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
1461 return error_mark_node;
1466 binfo = get_binfo (basetype, type, 1);
1467 if (binfo == error_mark_node)
1468 return error_mark_node;
1470 error_not_base_type (basetype, type);
1475 if (TREE_CODE (exp) == INDIRECT_REF)
1476 decl = build_indirect_ref
1477 (convert_pointer_to_real
1478 (binfo, build_unary_op (ADDR_EXPR, exp, 0)), NULL_PTR);
1480 decl = build_scoped_ref (exp, basetype);
1482 /* Call to a destructor. */
1483 if (TREE_CODE (name) == BIT_NOT_EXPR)
1485 /* Explicit call to destructor. */
1486 name = TREE_OPERAND (name, 0);
1487 if (! (name == TYPE_MAIN_VARIANT (TREE_TYPE (decl))
1488 || name == constructor_name (TREE_TYPE (decl))
1489 || TREE_TYPE (decl) == get_type_value (name)))
1492 ("qualified type `%T' does not match destructor name `~%T'",
1493 TREE_TYPE (decl), name);
1494 return error_mark_node;
1496 if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl)))
1497 return convert (void_type_node, exp);
1499 return build_delete (TREE_TYPE (decl), decl, integer_two_node,
1500 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR,
1504 /* Call to a method. */
1505 return build_method_call (decl, name, parms, binfo,
1506 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
1508 return error_mark_node;
1512 print_candidates (candidates)
1515 cp_error_at ("candidates are: %D", TREE_VALUE (candidates));
1516 candidates = TREE_CHAIN (candidates);
1520 cp_error_at (" %D", TREE_VALUE (candidates));
1521 candidates = TREE_CHAIN (candidates);
1526 print_n_candidates (candidates, n)
1527 struct candidate *candidates;
1532 cp_error_at ("candidates are: %D", candidates[0].function);
1533 for (i = 1; i < n; i++)
1534 cp_error_at (" %D", candidates[i].function);
1537 /* We want the address of a function or method. We avoid creating a
1538 pointer-to-member function. */
1541 build_addr_func (function)
1544 tree type = TREE_TYPE (function);
1546 /* We have to do these by hand to avoid real pointer to member
1548 if (TREE_CODE (type) == METHOD_TYPE)
1552 type = build_pointer_type (type);
1554 if (mark_addressable (function) == 0)
1555 return error_mark_node;
1557 addr = build1 (ADDR_EXPR, type, function);
1559 /* Address of a static or external variable or function counts
1561 if (staticp (function))
1562 TREE_CONSTANT (addr) = 1;
1567 function = default_conversion (function);
1572 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
1573 POINTER_TYPE to those. Note, pointer to member function types
1574 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
1577 build_call (function, result_type, parms)
1578 tree function, result_type, parms;
1580 int is_constructor = 0;
1582 function = build_addr_func (function);
1584 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
1586 sorry ("unable to call pointer to member function here");
1587 return error_mark_node;
1590 if (TREE_CODE (function) == ADDR_EXPR
1591 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1592 && DECL_CONSTRUCTOR_P (TREE_OPERAND (function, 0)))
1595 function = build_nt (CALL_EXPR, function, parms, NULL_TREE);
1596 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
1597 TREE_TYPE (function) = result_type;
1598 TREE_SIDE_EFFECTS (function) = 1;
1604 default_parm_conversions (parms, last)
1607 tree parm, parmtypes = NULL_TREE;
1611 for (parm = parms; parm; parm = TREE_CHAIN (parm))
1613 tree t = TREE_TYPE (TREE_VALUE (parm));
1615 if (TREE_CODE (t) == OFFSET_TYPE
1616 || TREE_CODE (t) == METHOD_TYPE
1617 || TREE_CODE (t) == FUNCTION_TYPE)
1619 TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
1620 t = TREE_TYPE (TREE_VALUE (parm));
1623 if (t == error_mark_node)
1624 return error_mark_node;
1626 *last = build_tree_list (NULL_TREE, t);
1627 parmtypes = chainon (parmtypes, *last);
1634 /* Build something of the form ptr->method (args)
1635 or object.method (args). This can also build
1636 calls to constructors, and find friends.
1638 Member functions always take their class variable
1641 INSTANCE is a class instance.
1643 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
1645 PARMS help to figure out what that NAME really refers to.
1647 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
1648 down to the real instance type to use for access checking. We need this
1649 information to get protected accesses correct. This parameter is used
1650 by build_member_call.
1652 FLAGS is the logical disjunction of zero or more LOOKUP_
1653 flags. See cp-tree.h for more info.
1655 If this is all OK, calls build_function_call with the resolved
1658 This function must also handle being called to perform
1659 initialization, promotion/coercion of arguments, and
1660 instantiation of default parameters.
1662 Note that NAME may refer to an instance variable name. If
1663 `operator()()' is defined for the type of that field, then we return
1667 build_method_call (instance, name, parms, basetype_path, flags)
1668 tree instance, name, parms, basetype_path;
1671 register tree function, fntype, value_type;
1672 register tree basetype, save_basetype;
1673 register tree baselink, result, parmtypes;
1676 tree access = access_public_node;
1677 tree orig_basetype = basetype_path ? BINFO_TYPE (basetype_path) : NULL_TREE;
1679 /* Range of cases for vtable optimization. */
1680 enum vtable_needs { not_needed, maybe_needed, unneeded, needed };
1681 enum vtable_needs need_vtbl = not_needed;
1684 tree save_name = name;
1686 tree instance_ptr = NULL_TREE;
1687 int all_virtual = flag_all_virtual;
1688 int static_call_context = 0;
1689 tree found_fns = NULL_TREE;
1691 /* Keep track of `const' and `volatile' objects. */
1692 int constp, volatilep;
1694 #ifdef GATHER_STATISTICS
1695 n_build_method_call++;
1698 if (instance == error_mark_node
1699 || name == error_mark_node
1700 || parms == error_mark_node
1701 || (instance != NULL_TREE && TREE_TYPE (instance) == error_mark_node))
1702 return error_mark_node;
1704 if (processing_template_decl)
1706 if (TREE_CODE (name) == BIT_NOT_EXPR)
1708 tree type = get_aggr_from_typedef (TREE_OPERAND (name, 0), 1);
1709 name = build_min_nt (BIT_NOT_EXPR, type);
1712 return build_min_nt (METHOD_CALL_EXPR, name, instance, parms, NULL_TREE);
1715 /* This is the logic that magically deletes the second argument to
1716 operator delete, if it is not needed. */
1717 if (name == ansi_opname[(int) DELETE_EXPR] && list_length (parms)==2)
1719 tree save_last = TREE_CHAIN (parms);
1721 /* get rid of unneeded argument */
1722 TREE_CHAIN (parms) = NULL_TREE;
1723 result = build_method_call (instance, name, parms, basetype_path,
1724 (LOOKUP_SPECULATIVELY|flags)
1726 /* If it finds a match, return it. */
1728 return build_method_call (instance, name, parms, basetype_path, flags);
1729 /* If it doesn't work, two argument delete must work */
1730 TREE_CHAIN (parms) = save_last;
1732 /* We already know whether it's needed or not for vec delete. */
1733 else if (name == ansi_opname[(int) VEC_DELETE_EXPR]
1734 && TYPE_LANG_SPECIFIC (TREE_TYPE (instance))
1735 && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance)))
1736 TREE_CHAIN (parms) = NULL_TREE;
1738 if (TREE_CODE (name) == BIT_NOT_EXPR)
1740 flags |= LOOKUP_DESTRUCTOR;
1741 name = TREE_OPERAND (name, 0);
1743 error ("destructors take no parameters");
1744 basetype = TREE_TYPE (instance);
1745 if (TREE_CODE (basetype) == REFERENCE_TYPE)
1746 basetype = TREE_TYPE (basetype);
1747 if (! (name == basetype
1748 || (IS_AGGR_TYPE (basetype)
1749 && name == constructor_name (basetype))
1750 || basetype == get_type_value (name)))
1752 cp_error ("destructor name `~%D' does not match type `%T' of expression",
1754 return convert (void_type_node, instance);
1757 if (! TYPE_HAS_DESTRUCTOR (basetype))
1758 return convert (void_type_node, instance);
1759 instance = default_conversion (instance);
1760 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
1761 return build_delete (build_pointer_type (basetype),
1762 instance_ptr, integer_two_node,
1763 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
1766 if (flag_ansi_overloading)
1767 return build_new_method_call (instance, name, parms, basetype_path, flags);
1772 /* Initialize name for error reporting. */
1773 if (IDENTIFIER_OPNAME_P (name) && ! IDENTIFIER_TYPENAME_P (name))
1775 char *p = operator_name_string (name);
1776 xref_name = (char *)alloca (strlen (p) + 10);
1777 sprintf (xref_name, "operator %s", p);
1779 else if (TREE_CODE (name) == SCOPE_REF)
1780 xref_name = IDENTIFIER_POINTER (TREE_OPERAND (name, 1));
1782 xref_name = IDENTIFIER_POINTER (name);
1784 GNU_xref_call (current_function_decl, xref_name);
1787 if (instance == NULL_TREE)
1789 basetype = NULL_TREE;
1790 /* Check cases where this is really a call to raise
1792 if (current_class_type && TREE_CODE (name) == IDENTIFIER_NODE)
1794 basetype = purpose_member (name, CLASSTYPE_TAGS (current_class_type));
1796 basetype = TREE_VALUE (basetype);
1798 else if (TREE_CODE (name) == SCOPE_REF
1799 && TREE_CODE (TREE_OPERAND (name, 0)) == IDENTIFIER_NODE)
1801 if (! is_aggr_typedef (TREE_OPERAND (name, 0), 1))
1802 return error_mark_node;
1803 basetype = purpose_member (TREE_OPERAND (name, 1),
1804 CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name, 0))));
1806 basetype = TREE_VALUE (basetype);
1809 if (basetype != NULL_TREE)
1811 /* call to a constructor... */
1812 else if (basetype_path)
1814 basetype = BINFO_TYPE (basetype_path);
1815 if (name == TYPE_IDENTIFIER (basetype))
1816 name = ctor_identifier;
1818 else if (IDENTIFIER_HAS_TYPE_VALUE (name))
1820 basetype = IDENTIFIER_TYPE_VALUE (name);
1821 name = ctor_identifier;
1825 tree typedef_name = lookup_name (name, 1);
1826 if (typedef_name && TREE_CODE (typedef_name) == TYPE_DECL)
1828 /* Canonicalize the typedef name. */
1829 basetype = TREE_TYPE (typedef_name);
1830 name = ctor_identifier;
1834 cp_error ("no constructor named `%T' in scope",
1836 return error_mark_node;
1840 if (! IS_AGGR_TYPE (basetype))
1843 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
1844 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
1845 name, instance, basetype);
1847 return error_mark_node;
1850 else if (instance == current_class_ref || instance == current_class_ptr)
1852 /* When doing initialization, we side-effect the TREE_TYPE of
1853 current_class_ref, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */
1854 basetype = TREE_TYPE (current_class_ref);
1856 /* Anything manifestly `this' in constructors and destructors
1857 has a known type, so virtual function tables are not needed. */
1858 if (TYPE_VIRTUAL_P (basetype)
1859 && !(flags & LOOKUP_NONVIRTUAL))
1860 need_vtbl = (dtor_label || ctor_label)
1861 ? unneeded : maybe_needed;
1863 /* If `this' is a signature pointer and `name' is not a constructor,
1864 we are calling a signature member function. In that case, set the
1865 `basetype' to the signature type and dereference the `optr' field. */
1866 if (IS_SIGNATURE_POINTER (basetype)
1867 && TYPE_IDENTIFIER (basetype) != name)
1869 basetype = SIGNATURE_TYPE (basetype);
1870 instance_ptr = instance;
1871 basetype_path = TYPE_BINFO (basetype);
1875 instance = current_class_ref;
1876 instance_ptr = current_class_ptr;
1877 basetype_path = TYPE_BINFO (current_class_type);
1879 result = build_field_call (basetype_path, instance_ptr, name, parms);
1884 else if (TREE_CODE (instance) == RESULT_DECL)
1886 basetype = TREE_TYPE (instance);
1887 /* Should we ever have to make a virtual function reference
1888 from a RESULT_DECL, know that it must be of fixed type
1889 within the scope of this function. */
1890 if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype))
1891 need_vtbl = maybe_needed;
1892 instance_ptr = build1 (ADDR_EXPR, build_pointer_type (basetype), instance);
1896 /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */
1897 tree inst_ptr_basetype;
1900 = (TREE_CODE (instance) == INDIRECT_REF
1901 && TREE_CODE (TREE_OPERAND (instance, 0)) == NOP_EXPR
1902 && TREE_OPERAND (TREE_OPERAND (instance, 0), 0) == error_mark_node);
1904 if (TREE_CODE (instance) == OFFSET_REF)
1905 instance = resolve_offset_ref (instance);
1907 /* the base type of an instance variable is pointer to class */
1908 basetype = TREE_TYPE (instance);
1910 if (TREE_CODE (basetype) == REFERENCE_TYPE)
1912 basetype = TREE_TYPE (basetype);
1913 if (! IS_AGGR_TYPE (basetype))
1914 goto non_aggr_error;
1915 /* Call to convert not needed because we are remaining
1916 within the same type. */
1917 instance_ptr = build1 (NOP_EXPR, build_pointer_type (basetype),
1919 inst_ptr_basetype = TYPE_MAIN_VARIANT (basetype);
1923 if (! IS_AGGR_TYPE (basetype)
1924 && ! (TYPE_LANG_SPECIFIC (basetype)
1925 && (IS_SIGNATURE_POINTER (basetype)
1926 || IS_SIGNATURE_REFERENCE (basetype))))
1927 goto non_aggr_error;
1929 /* If `instance' is a signature pointer/reference and `name' is
1930 not a constructor, we are calling a signature member function.
1931 In that case set the `basetype' to the signature type. */
1932 if ((IS_SIGNATURE_POINTER (basetype)
1933 || IS_SIGNATURE_REFERENCE (basetype))
1934 && TYPE_IDENTIFIER (basetype) != name)
1935 basetype = SIGNATURE_TYPE (basetype);
1937 basetype = complete_type (basetype);
1939 if ((IS_SIGNATURE (basetype)
1940 && (instance_ptr = instance))
1941 || (lvalue_p (instance)
1942 && (instance_ptr = build_unary_op (ADDR_EXPR, instance, 0)))
1943 || (instance_ptr = unary_complex_lvalue (ADDR_EXPR, instance)))
1945 if (instance_ptr == error_mark_node)
1946 return error_mark_node;
1948 else if (TREE_CODE (instance) == NOP_EXPR
1949 || TREE_CODE (instance) == CONSTRUCTOR)
1951 /* A cast is not an lvalue. Initialize a fresh temp
1952 with the value we are casting from, and proceed with
1953 that temporary. We can't cast to a reference type,
1954 so that simplifies the initialization to something
1956 tree temp = get_temp_name (TREE_TYPE (instance), 0);
1957 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
1958 expand_aggr_init (temp, instance, 0, flags);
1961 store_init_value (temp, instance);
1962 expand_decl_init (temp);
1965 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
1969 if (TREE_CODE (instance) != CALL_EXPR)
1970 my_friendly_abort (125);
1971 if (TYPE_NEEDS_CONSTRUCTING (basetype))
1972 instance = build_cplus_new (basetype, instance);
1975 instance = get_temp_name (basetype, 0);
1976 TREE_ADDRESSABLE (instance) = 1;
1978 instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
1980 /* @@ Should we call comp_target_types here? */
1981 if (IS_SIGNATURE (basetype))
1982 inst_ptr_basetype = basetype;
1984 inst_ptr_basetype = TREE_TYPE (TREE_TYPE (instance_ptr));
1985 if (TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (inst_ptr_basetype))
1986 basetype = inst_ptr_basetype;
1989 instance_ptr = convert (build_pointer_type (basetype), instance_ptr);
1990 if (instance_ptr == error_mark_node)
1991 return error_mark_node;
1995 /* After converting `instance_ptr' above, `inst_ptr_basetype' was
1996 not updated, so we use `basetype' instead. */
1997 if (basetype_path == NULL_TREE
1998 && IS_SIGNATURE (basetype))
1999 basetype_path = TYPE_BINFO (basetype);
2000 else if (basetype_path == NULL_TREE
2001 || (BINFO_TYPE (basetype_path)
2002 != TYPE_MAIN_VARIANT (inst_ptr_basetype)))
2003 basetype_path = TYPE_BINFO (inst_ptr_basetype);
2005 result = build_field_call (basetype_path, instance_ptr, name, parms);
2009 if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype))
2011 if (TREE_SIDE_EFFECTS (instance_ptr))
2013 /* This action is needed because the instance is needed
2014 for providing the base of the virtual function table.
2015 Without using a SAVE_EXPR, the function we are building
2016 may be called twice, or side effects on the instance
2017 variable (such as a post-increment), may happen twice. */
2018 instance_ptr = save_expr (instance_ptr);
2019 instance = build_indirect_ref (instance_ptr, NULL_PTR);
2021 else if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
2023 /* This happens when called for operator new (). */
2024 instance = build_indirect_ref (instance, NULL_PTR);
2027 need_vtbl = maybe_needed;
2031 if (save_name == ctor_identifier)
2032 save_name = TYPE_IDENTIFIER (basetype);
2034 if (TYPE_SIZE (complete_type (basetype)) == 0)
2036 /* This is worth complaining about, I think. */
2037 cp_error ("cannot lookup method in incomplete type `%T'", basetype);
2038 return error_mark_node;
2041 save_basetype = TYPE_MAIN_VARIANT (basetype);
2043 parmtypes = default_parm_conversions (parms, &last);
2044 if (parmtypes == error_mark_node)
2046 return error_mark_node;
2049 if (instance && IS_SIGNATURE (basetype))
2051 /* @@ Should this be the constp/volatilep flags for the optr field
2052 of the signature pointer? */
2053 constp = TYPE_READONLY (basetype);
2054 volatilep = TYPE_VOLATILE (basetype);
2055 parms = tree_cons (NULL_TREE, instance_ptr, parms);
2059 /* TREE_READONLY (instance) fails for references. */
2060 constp = TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr)));
2061 volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr)));
2062 parms = tree_cons (NULL_TREE, instance_ptr, parms);
2066 /* Raw constructors are always in charge. */
2067 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype)
2068 && ! (flags & LOOKUP_HAS_IN_CHARGE))
2070 flags |= LOOKUP_HAS_IN_CHARGE;
2071 parms = tree_cons (NULL_TREE, integer_one_node, parms);
2072 parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes);
2077 instance_ptr = build_int_2 (0, 0);
2078 TREE_TYPE (instance_ptr) = build_pointer_type (basetype);
2079 parms = tree_cons (NULL_TREE, instance_ptr, parms);
2082 parmtypes = tree_cons (NULL_TREE, TREE_TYPE (instance_ptr), parmtypes);
2084 if (last == NULL_TREE)
2087 /* Look up function name in the structure type definition. */
2089 /* FIXME Axe most of this now? */
2090 if ((IDENTIFIER_HAS_TYPE_VALUE (name)
2091 && ! IDENTIFIER_OPNAME_P (name)
2092 && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name)))
2093 || name == constructor_name (basetype)
2094 || name == ctor_identifier)
2096 tree tmp = NULL_TREE;
2097 if (IDENTIFIER_TYPE_VALUE (name) == basetype
2098 || name == constructor_name (basetype)
2099 || name == ctor_identifier)
2100 tmp = TYPE_BINFO (basetype);
2102 tmp = get_binfo (IDENTIFIER_TYPE_VALUE (name), basetype, 0);
2104 if (tmp != NULL_TREE)
2106 name_kind = "constructor";
2108 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype)
2109 && ! (flags & LOOKUP_HAS_IN_CHARGE))
2111 /* Constructors called for initialization
2112 only are never in charge. */
2115 flags |= LOOKUP_HAS_IN_CHARGE;
2116 tmplist = tree_cons (NULL_TREE, integer_zero_node,
2117 TREE_CHAIN (parms));
2118 TREE_CHAIN (parms) = tmplist;
2119 tmplist = tree_cons (NULL_TREE, integer_type_node, TREE_CHAIN (parmtypes));
2120 TREE_CHAIN (parmtypes) = tmplist;
2122 basetype = BINFO_TYPE (tmp);
2125 name_kind = "method";
2128 name_kind = "method";
2130 if (basetype_path == NULL_TREE
2131 || BINFO_TYPE (basetype_path) != TYPE_MAIN_VARIANT (basetype))
2132 basetype_path = TYPE_BINFO (basetype);
2133 result = lookup_fnfields (basetype_path, name,
2134 (flags & LOOKUP_COMPLAIN));
2135 if (result == error_mark_node)
2136 return error_mark_node;
2138 for (pass = 0; pass < 2; pass++)
2140 struct candidate *candidates;
2141 struct candidate *cp;
2150 = (struct candidate *) alloca ((ever_seen+1)
2151 * sizeof (struct candidate));
2152 bzero ((char *) candidates, (ever_seen + 1) * sizeof (struct candidate));
2154 len = list_length (parms);
2157 /* First see if a global function has a shot at it. */
2158 if (flags & LOOKUP_GLOBAL)
2161 tree parm = instance_ptr;
2163 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE)
2164 parm = convert_from_reference (parm);
2165 else if (TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE)
2166 parm = build_indirect_ref (parm, "friendifying parms (compiler error)");
2168 my_friendly_abort (167);
2170 friend_parms = tree_cons (NULL_TREE, parm, TREE_CHAIN (parms));
2173 cp->harshness = (struct harshness_code *)
2174 alloca ((len + 1) * sizeof (struct harshness_code));
2176 result = build_overload_call_real (name, friend_parms, 0, cp, 1);
2178 /* If it turns out to be the one we were actually looking for
2179 (it was probably a friend function), the return the
2181 if (TREE_CODE (result) == CALL_EXPR)
2184 while ((cp->h.code & EVIL_CODE) == 0)
2186 /* non-standard uses: set the field to 0 to indicate
2187 we are using a non-member function. */
2189 if (cp->harshness[len].distance == 0
2190 && cp->h.code < best)
2199 /* We have a hit (of sorts). If the parameter list is
2200 "error_mark_node", or some variant thereof, it won't
2201 match any methods. Since we have verified that the is
2202 some method vaguely matching this one (in name at least),
2205 Don't stop for friends, however. */
2206 basetype_path = TREE_PURPOSE (baselink);
2208 function = TREE_VALUE (baselink);
2209 if (TREE_CODE (basetype_path) == TREE_LIST)
2210 basetype_path = TREE_VALUE (basetype_path);
2211 basetype = BINFO_TYPE (basetype_path);
2213 for (; function; function = DECL_CHAIN (function))
2215 #ifdef GATHER_STATISTICS
2216 n_inner_fields_searched++;
2220 found_fns = tree_cons (NULL_TREE, function, found_fns);
2222 /* Not looking for friends here. */
2223 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE
2224 && ! DECL_STATIC_FUNCTION_P (function))
2229 tree these_parms = parms;
2231 #ifdef GATHER_STATISTICS
2232 n_inner_fields_searched++;
2235 cp->harshness = (struct harshness_code *)
2236 alloca ((len + 1) * sizeof (struct harshness_code));
2238 if (DECL_STATIC_FUNCTION_P (function))
2239 these_parms = TREE_CHAIN (these_parms);
2240 compute_conversion_costs (function, these_parms, cp, len);
2242 if ((cp->h.code & EVIL_CODE) == 0)
2244 cp->u.field = function;
2245 cp->function = function;
2246 cp->basetypes = basetype_path;
2248 /* Don't allow non-converting constructors to convert. */
2249 if (flags & LOOKUP_ONLYCONVERTING
2250 && DECL_LANG_SPECIFIC (function)
2251 && DECL_NONCONVERTING_P (function))
2254 /* No "two-level" conversions. */
2255 if (flags & LOOKUP_NO_CONVERSION
2256 && (cp->h.code & USER_CODE))
2267 tree igv = lookup_name_nonclass (name);
2269 /* No exact match could be found. Now try to find match
2270 using default conversions. */
2271 if ((flags & LOOKUP_GLOBAL) && igv)
2273 if (TREE_CODE (igv) == FUNCTION_DECL)
2275 else if (TREE_CODE (igv) == TREE_LIST)
2276 ever_seen += count_functions (igv);
2281 if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
2282 == LOOKUP_SPECULATIVELY)
2285 TREE_CHAIN (last) = void_list_node;
2286 if (flags & LOOKUP_GLOBAL)
2287 cp_error ("no global or member function `%D(%A)' defined",
2288 save_name, parmtypes);
2290 cp_error ("no member function `%T::%D(%A)' defined",
2291 save_basetype, save_name, TREE_CHAIN (parmtypes));
2292 return error_mark_node;
2297 if (cp - candidates != 0)
2299 /* Rank from worst to best. Then cp will point to best one.
2300 Private fields have their bits flipped. For unsigned
2301 numbers, this should make them look very large.
2302 If the best alternate has a (signed) negative value,
2303 then all we ever saw were private members. */
2304 if (cp - candidates > 1)
2306 int n_candidates = cp - candidates;
2307 extern int warn_synth;
2308 TREE_VALUE (parms) = instance_ptr;
2309 cp = ideal_candidate (candidates, n_candidates, len);
2310 if (cp == (struct candidate *)0)
2312 if (flags & LOOKUP_COMPLAIN)
2314 TREE_CHAIN (last) = void_list_node;
2315 cp_error ("call of overloaded %s `%D(%A)' is ambiguous",
2316 name_kind, save_name, TREE_CHAIN (parmtypes));
2317 print_n_candidates (candidates, n_candidates);
2319 return error_mark_node;
2321 if (cp->h.code & EVIL_CODE)
2322 return error_mark_node;
2324 && DECL_NAME (cp->function) == ansi_opname[MODIFY_EXPR]
2325 && DECL_ARTIFICIAL (cp->function)
2326 && n_candidates == 2)
2328 cp_warning ("using synthesized `%#D' for copy assignment",
2330 cp_warning_at (" where cfront would use `%#D'",
2331 candidates->function);
2334 else if (cp[-1].h.code & EVIL_CODE)
2336 if (flags & LOOKUP_COMPLAIN)
2337 cp_error ("ambiguous type conversion requested for %s `%D'",
2338 name_kind, save_name);
2339 return error_mark_node;
2344 /* The global function was the best, so use it. */
2345 if (cp->u.field == 0)
2347 /* We must convert the instance pointer into a reference type.
2348 Global overloaded functions can only either take
2349 aggregate objects (which come for free from references)
2350 or reference data types anyway. */
2351 TREE_VALUE (parms) = copy_node (instance_ptr);
2352 TREE_TYPE (TREE_VALUE (parms)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr)));
2353 return build_function_call (cp->function, parms);
2356 function = cp->function;
2357 basetype_path = cp->basetypes;
2358 if (! DECL_STATIC_FUNCTION_P (function))
2359 TREE_VALUE (parms) = cp->arg;
2360 goto found_and_maybe_warn;
2363 if (flags & (LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY))
2365 if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
2366 == LOOKUP_SPECULATIVELY)
2369 if (DECL_STATIC_FUNCTION_P (cp->function))
2370 parms = TREE_CHAIN (parms);
2373 if (flags & LOOKUP_SPECULATIVELY)
2375 if (static_call_context
2376 && TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
2377 cp_error ("object missing in call to `%D'", cp->function);
2378 else if (ever_seen > 1)
2380 TREE_CHAIN (last) = void_list_node;
2381 cp_error ("no matching function for call to `%T::%D (%A)%V'",
2382 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (instance_ptr))),
2383 save_name, TREE_CHAIN (parmtypes),
2384 TREE_TYPE (TREE_TYPE (instance_ptr)));
2385 TREE_CHAIN (last) = NULL_TREE;
2386 print_candidates (found_fns);
2389 report_type_mismatch (cp, parms, name_kind);
2390 return error_mark_node;
2393 if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
2396 cp_error ("%T has no method named %D", save_basetype, save_name);
2397 return error_mark_node;
2403 found_and_maybe_warn:
2404 if ((cp->harshness[0].code & CONST_CODE)
2405 /* 12.1p2: Constructors can be called for const objects. */
2406 && ! DECL_CONSTRUCTOR_P (cp->function))
2408 if (flags & LOOKUP_COMPLAIN)
2410 cp_error_at ("non-const member function `%D'", cp->function);
2411 error ("called for const object at this point in file");
2413 /* Not good enough for a match. */
2415 return error_mark_node;
2419 /* Silently return error_mark_node. */
2420 return error_mark_node;
2423 if (flags & LOOKUP_PROTECT)
2424 access = compute_access (basetype_path, function);
2426 if (access == access_private_node)
2428 if (flags & LOOKUP_COMPLAIN)
2430 cp_error_at ("%s `%+#D' is %s", name_kind, function,
2431 TREE_PRIVATE (function) ? "private"
2432 : "from private base class");
2433 error ("within this context");
2435 return error_mark_node;
2437 else if (access == access_protected_node)
2439 if (flags & LOOKUP_COMPLAIN)
2441 cp_error_at ("%s `%+#D' %s", name_kind, function,
2442 TREE_PROTECTED (function) ? "is protected"
2443 : "has protected accessibility");
2444 error ("within this context");
2446 return error_mark_node;
2449 /* From here on down, BASETYPE is the type that INSTANCE_PTR's
2450 type (if it exists) is a pointer to. */
2452 if (DECL_ABSTRACT_VIRTUAL_P (function)
2453 && instance == current_class_ref
2454 && DECL_CONSTRUCTOR_P (current_function_decl)
2455 && ! (flags & LOOKUP_NONVIRTUAL)
2456 && value_member (function, get_abstract_virtuals (basetype)))
2457 cp_error ("abstract virtual `%#D' called from constructor", function);
2459 if (IS_SIGNATURE (basetype))
2461 if (static_call_context)
2463 cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
2464 basetype, save_name);
2465 return error_mark_node;
2467 return build_signature_method_call (function, parms);
2470 function = DECL_MAIN_VARIANT (function);
2471 mark_used (function);
2473 fntype = TREE_TYPE (function);
2474 if (TREE_CODE (fntype) == POINTER_TYPE)
2475 fntype = TREE_TYPE (fntype);
2476 basetype = DECL_CLASS_CONTEXT (function);
2478 /* If we are referencing a virtual function from an object
2479 of effectively static type, then there is no need
2480 to go through the virtual function table. */
2481 if (need_vtbl == maybe_needed)
2483 int fixed_type = resolves_to_fixed_type_p (instance, 0);
2485 if (all_virtual == 1
2486 && DECL_VINDEX (function)
2487 && may_be_remote (basetype))
2489 else if (DECL_VINDEX (function))
2490 need_vtbl = fixed_type ? unneeded : needed;
2492 need_vtbl = not_needed;
2495 if (TREE_CODE (fntype) == METHOD_TYPE && static_call_context
2496 && !DECL_CONSTRUCTOR_P (function))
2498 /* Let's be nasty to the user now, and give reasonable
2500 instance_ptr = current_class_ptr;
2503 if (basetype != current_class_type)
2505 if (basetype == error_mark_node)
2506 return error_mark_node;
2509 if (orig_basetype != NULL_TREE)
2510 error_not_base_type (orig_basetype, current_class_type);
2512 error_not_base_type (function, current_class_type);
2513 return error_mark_node;
2517 /* Only allow a static member function to call another static member
2519 else if (DECL_LANG_SPECIFIC (function)
2520 && !DECL_STATIC_FUNCTION_P (function))
2522 cp_error ("cannot call member function `%D' without object",
2524 return error_mark_node;
2528 value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node;
2530 if (TYPE_SIZE (complete_type (value_type)) == 0)
2532 if (flags & LOOKUP_COMPLAIN)
2533 incomplete_type_error (0, value_type);
2534 return error_mark_node;
2537 if (DECL_STATIC_FUNCTION_P (function))
2538 parms = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
2539 TREE_CHAIN (parms), function, LOOKUP_NORMAL);
2540 else if (need_vtbl == unneeded)
2542 int sub_flags = DECL_CONSTRUCTOR_P (function) ? flags : LOOKUP_NORMAL;
2543 basetype = TREE_TYPE (instance);
2544 if (TYPE_METHOD_BASETYPE (TREE_TYPE (function))
2545 != TYPE_MAIN_VARIANT (basetype))
2547 basetype = DECL_CLASS_CONTEXT (function);
2548 instance_ptr = convert_pointer_to (basetype, instance_ptr);
2549 instance = build_indirect_ref (instance_ptr, NULL_PTR);
2551 parms = tree_cons (NULL_TREE, instance_ptr,
2552 convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), function, sub_flags));
2556 if ((flags & LOOKUP_NONVIRTUAL) == 0)
2557 basetype = DECL_CONTEXT (function);
2559 /* First parm could be integer_zerop with casts like
2560 ((Object*)0)->Object::IsA() */
2561 if (!integer_zerop (TREE_VALUE (parms)))
2563 /* Since we can't have inheritance with a union, doing get_binfo
2564 on it won't work. We do all the convert_pointer_to_real
2565 stuff to handle MI correctly...for unions, that's not
2566 an issue, so we must short-circuit that extra work here. */
2567 tree tmp = TREE_TYPE (TREE_TYPE (TREE_VALUE (parms)));
2568 if (tmp != NULL_TREE && TREE_CODE (tmp) == UNION_TYPE)
2569 instance_ptr = TREE_VALUE (parms);
2572 tree binfo = get_binfo (basetype,
2573 TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))),
2575 instance_ptr = convert_pointer_to_real (binfo, TREE_VALUE (parms));
2578 = convert_pointer_to (build_type_variant (basetype,
2582 if (TREE_CODE (instance_ptr) == COND_EXPR)
2584 instance_ptr = save_expr (instance_ptr);
2585 instance = build_indirect_ref (instance_ptr, NULL_PTR);
2587 else if (TREE_CODE (instance_ptr) == NOP_EXPR
2588 && TREE_CODE (TREE_OPERAND (instance_ptr, 0)) == ADDR_EXPR
2589 && TREE_OPERAND (TREE_OPERAND (instance_ptr, 0), 0) == instance)
2591 /* The call to `convert_pointer_to' may return error_mark_node. */
2592 else if (instance_ptr == error_mark_node)
2593 return instance_ptr;
2594 else if (instance == NULL_TREE
2595 || TREE_CODE (instance) != INDIRECT_REF
2596 || TREE_OPERAND (instance, 0) != instance_ptr)
2597 instance = build_indirect_ref (instance_ptr, NULL_PTR);
2599 parms = tree_cons (NULL_TREE, instance_ptr,
2600 convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), function, LOOKUP_NORMAL));
2603 if (parms == error_mark_node
2604 || (parms && TREE_CHAIN (parms) == error_mark_node))
2605 return error_mark_node;
2607 if (need_vtbl == needed)
2609 function = build_vfn_ref (&TREE_VALUE (parms), instance,
2610 DECL_VINDEX (function));
2611 TREE_TYPE (function) = build_pointer_type (fntype);
2614 if (TREE_CODE (function) == FUNCTION_DECL)
2615 GNU_xref_call (current_function_decl,
2616 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)));
2618 result = build_call (function, value_type, parms);
2619 if (IS_AGGR_TYPE (value_type))
2620 result = build_cplus_new (value_type, result);
2621 result = convert_from_reference (result);
2625 /* Similar to `build_method_call', but for overloaded non-member functions.
2626 The name of this function comes through NAME. The name depends
2629 Note that this function must handle simple `C' promotions,
2630 as well as variable numbers of arguments (...), and
2631 default arguments to boot.
2633 If the overloading is successful, we return a tree node which
2634 contains the call to the function.
2636 If overloading produces candidates which are probable, but not definite,
2637 we hold these candidates. If FINAL_CP is non-zero, then we are free
2638 to assume that final_cp points to enough storage for all candidates that
2639 this function might generate. The `harshness' array is preallocated for
2640 the first candidate, but not for subsequent ones.
2642 Note that the DECL_RTL of FUNCTION must be made to agree with this
2643 function's new name. */
2646 build_overload_call_real (fnname, parms, flags, final_cp, require_complete)
2649 struct candidate *final_cp;
2650 int require_complete;
2652 /* must check for overloading here */
2653 tree functions, function;
2654 tree parmtypes, last;
2655 register tree outer;
2657 int parmlength = list_length (parms);
2659 struct candidate *candidates, *cp;
2663 final_cp[0].h.code = 0;
2664 final_cp[0].h.distance = 0;
2665 final_cp[0].function = 0;
2667 final_cp[1].h.code = EVIL_CODE;
2670 parmtypes = default_parm_conversions (parms, &last);
2671 if (parmtypes == error_mark_node)
2674 final_cp->h.code = EVIL_CODE;
2675 return error_mark_node;
2679 TREE_CHAIN (last) = void_list_node;
2681 parmtypes = void_list_node;
2683 if (is_overloaded_fn (fnname))
2686 if (TREE_CODE (fnname) == TREE_LIST)
2687 fnname = TREE_PURPOSE (functions);
2688 else if (TREE_CODE (fnname) == FUNCTION_DECL)
2689 fnname = DECL_NAME (functions);
2692 functions = lookup_name_nonclass (fnname);
2694 if (functions == NULL_TREE)
2696 if (flags & LOOKUP_SPECULATIVELY)
2698 if (flags & LOOKUP_COMPLAIN)
2699 error ("only member functions apply");
2701 final_cp->h.code = EVIL_CODE;
2702 return error_mark_node;
2705 if (TREE_CODE (functions) == FUNCTION_DECL && ! IDENTIFIER_OPNAME_P (fnname))
2707 functions = DECL_MAIN_VARIANT (functions);
2710 /* We are just curious whether this is a viable alternative or
2712 compute_conversion_costs (functions, parms, final_cp, parmlength);
2716 return build_function_call_real (functions, parms, 1, flags);
2719 if (TREE_CODE (functions) == TREE_LIST
2720 && TREE_VALUE (functions) == NULL_TREE)
2722 if (flags & LOOKUP_SPECULATIVELY)
2725 if (flags & LOOKUP_COMPLAIN)
2726 cp_error ("function `%D' declared overloaded, but no instances of that function declared",
2727 TREE_PURPOSE (functions));
2729 final_cp->h.code = EVIL_CODE;
2730 return error_mark_node;
2733 length = count_functions (functions);
2736 candidates = final_cp;
2740 = (struct candidate *)alloca ((length+1) * sizeof (struct candidate));
2741 bzero ((char *) candidates, (length + 1) * sizeof (struct candidate));
2746 my_friendly_assert (is_overloaded_fn (functions), 169);
2748 functions = get_first_fn (functions);
2750 /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
2751 for (outer = functions; outer; outer = DECL_CHAIN (outer))
2753 int template_cost = 0;
2755 if (TREE_CODE (function) != FUNCTION_DECL
2756 && ! (TREE_CODE (function) == TEMPLATE_DECL
2757 && TREE_CODE (DECL_TEMPLATE_RESULT (function)) == FUNCTION_DECL))
2759 enum tree_code code = TREE_CODE (function);
2760 if (code == TEMPLATE_DECL)
2761 code = TREE_CODE (DECL_TEMPLATE_RESULT (function));
2762 if (code == CONST_DECL)
2764 ("enumeral value `%D' conflicts with function of same name",
2766 else if (code == VAR_DECL)
2768 if (TREE_STATIC (function))
2770 ("variable `%D' conflicts with function of same name",
2774 ("constant field `%D' conflicts with function of same name",
2777 else if (code == TYPE_DECL)
2780 my_friendly_abort (2);
2781 error ("at this point in file");
2784 if (TREE_CODE (function) == TEMPLATE_DECL)
2786 int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function));
2787 tree *targs = (tree *) alloca (sizeof (tree) * ntparms);
2790 i = type_unification (DECL_TEMPLATE_PARMS (function), targs,
2791 TYPE_ARG_TYPES (TREE_TYPE (function)),
2792 parms, &template_cost, 0, 0);
2795 function = instantiate_template (function, targs);
2796 if (function == error_mark_node)
2801 if (TREE_CODE (function) == TEMPLATE_DECL)
2803 /* Unconverted template -- failed match. */
2804 cp->function = function;
2806 cp->h.code = EVIL_CODE;
2810 struct candidate *cp2;
2812 /* Check that this decl is not the same as a function that's in
2813 the list due to some template instantiation. */
2816 if (cp2->function == function)
2820 if (cp2->function == function)
2823 function = DECL_MAIN_VARIANT (function);
2825 /* Can't use alloca here, since result might be
2826 passed to calling function. */
2827 cp->h_len = parmlength;
2828 cp->harshness = (struct harshness_code *)
2829 oballoc ((parmlength + 1) * sizeof (struct harshness_code));
2831 compute_conversion_costs (function, parms, cp, parmlength);
2833 /* Make sure this is clear as well. */
2834 cp->h.int_penalty += template_cost;
2836 if ((cp[0].h.code & EVIL_CODE) == 0)
2838 cp[1].h.code = EVIL_CODE;
2844 if (cp - candidates)
2846 tree rval = error_mark_node;
2849 cp[0].h.code = EVIL_CODE;
2850 if (cp - candidates > 1)
2852 struct candidate *best_cp
2853 = ideal_candidate (candidates, cp - candidates, parmlength);
2854 if (best_cp == (struct candidate *)0)
2856 if (flags & LOOKUP_COMPLAIN)
2858 cp_error ("call of overloaded `%D' is ambiguous", fnname);
2859 print_n_candidates (candidates, cp - candidates);
2861 return error_mark_node;
2864 rval = best_cp->function;
2869 if (cp->h.code & EVIL_CODE)
2871 if (flags & LOOKUP_COMPLAIN)
2872 error ("type conversion ambiguous");
2875 rval = cp->function;
2881 return build_function_call_real (rval, parms, require_complete, flags);
2884 if (flags & LOOKUP_SPECULATIVELY)
2887 if (flags & LOOKUP_COMPLAIN)
2888 report_type_mismatch (cp, parms, "function",
2889 decl_as_string (cp->function, 1));
2891 return error_mark_node;
2894 /* This requires a complete type on the result of the call. */
2897 build_overload_call (fnname, parms, flags)
2901 return build_overload_call_real (fnname, parms, flags, (struct candidate *)0, 1);
2904 /* New overloading code. */
2906 struct z_candidate {
2913 struct z_candidate *next;
2916 #define IDENTITY_RANK 0
2917 #define EXACT_RANK 1
2918 #define PROMO_RANK 2
2920 #define PBOOL_RANK 4
2922 #define ELLIPSIS_RANK 6
2925 #define ICS_RANK(NODE) \
2926 (ICS_BAD_FLAG (NODE) ? BAD_RANK \
2927 : ICS_ELLIPSIS_FLAG (NODE) ? ELLIPSIS_RANK \
2928 : ICS_USER_FLAG (NODE) ? USER_RANK \
2929 : ICS_STD_RANK (NODE))
2931 #define ICS_STD_RANK(NODE) TREE_COMPLEXITY (NODE)
2933 #define ICS_USER_FLAG(NODE) TREE_LANG_FLAG_0 (NODE)
2934 #define ICS_ELLIPSIS_FLAG(NODE) TREE_LANG_FLAG_1 (NODE)
2935 #define ICS_THIS_FLAG(NODE) TREE_LANG_FLAG_2 (NODE)
2936 #define ICS_BAD_FLAG(NODE) TREE_LANG_FLAG_3 (NODE)
2938 #define USER_CONV_FN(NODE) TREE_OPERAND (NODE, 1)
2940 static struct z_candidate * build_user_type_conversion_1 ();
2941 static tree convert_like ();
2942 static tree build_over_call ();
2943 static struct z_candidate * tourney ();
2944 static void enforce_access ();
2951 || integer_zerop (t) && INTEGRAL_TYPE_P (TREE_TYPE (t)))
2953 /* Remove this eventually. */
2954 if (! pedantic && TREE_TYPE (t) == ptr_type_node && integer_zerop (t))
2960 build_conv (code, type, from)
2961 enum tree_code code;
2964 tree t = build1 (code, type, from);
2965 int rank = ICS_STD_RANK (from);
2972 if (rank < STD_RANK)
2979 if (rank < EXACT_RANK)
2985 ICS_STD_RANK (t) = rank;
2986 ICS_USER_FLAG (t) = ICS_USER_FLAG (from);
2987 ICS_BAD_FLAG (t) = ICS_BAD_FLAG (from);
2995 if (TREE_CODE (t) == REFERENCE_TYPE)
3004 if (TREE_CODE (t) == ARRAY_TYPE)
3006 return TYPE_MAIN_VARIANT (t);
3009 /* Returns the standard conversion path (see [conv]) from type FROM to type
3010 TO, if any. For proper handling of null pointer constants, you must
3011 also pass the expression EXPR to convert from. */
3014 standard_conversion (to, from, expr)
3015 tree to, from, expr;
3017 enum tree_code fcode, tcode;
3021 if (TREE_CODE (to) == REFERENCE_TYPE)
3022 to = TREE_TYPE (to);
3023 if (TREE_CODE (from) == REFERENCE_TYPE)
3026 from = TREE_TYPE (from);
3028 to = strip_top_quals (to);
3029 from = strip_top_quals (from);
3031 fcode = TREE_CODE (from);
3032 tcode = TREE_CODE (to);
3034 conv = build1 (IDENTITY_CONV, from, expr);
3036 if (fcode == FUNCTION_TYPE)
3038 from = build_pointer_type (from);
3039 fcode = TREE_CODE (from);
3040 conv = build_conv (LVALUE_CONV, from, conv);
3042 else if (fcode == ARRAY_TYPE)
3044 from = build_pointer_type (TREE_TYPE (from));
3045 fcode = TREE_CODE (from);
3046 conv = build_conv (LVALUE_CONV, from, conv);
3048 else if (fromref || (expr && real_lvalue_p (expr)))
3049 conv = build_conv (RVALUE_CONV, from, conv);
3054 if ((tcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (to))
3055 && expr && null_ptr_cst_p (expr))
3057 conv = build_conv (STD_CONV, to, conv);
3059 else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE)
3061 enum tree_code ufcode = TREE_CODE (TREE_TYPE (from));
3062 enum tree_code utcode = TREE_CODE (TREE_TYPE (to));
3063 tree nconv = NULL_TREE;
3065 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (from)),
3066 TYPE_MAIN_VARIANT (TREE_TYPE (to)), 1))
3068 else if (utcode == VOID_TYPE && ufcode != OFFSET_TYPE
3069 && ufcode != FUNCTION_TYPE)
3071 from = build_pointer_type
3072 (cp_build_type_variant (void_type_node,
3073 TYPE_READONLY (TREE_TYPE (from)),
3074 TYPE_VOLATILE (TREE_TYPE (from))));
3075 nconv = build_conv (PTR_CONV, from, conv);
3077 else if (ufcode == OFFSET_TYPE && utcode == OFFSET_TYPE)
3079 tree fbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (from));
3080 tree tbase = TYPE_OFFSET_BASETYPE (TREE_TYPE (to));
3082 if (DERIVED_FROM_P (fbase, tbase)
3083 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (from))),
3084 TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (to))),
3087 from = build_offset_type (tbase, TREE_TYPE (TREE_TYPE (from)));
3088 from = build_pointer_type (from);
3089 nconv = build_conv (PMEM_CONV, from, conv);
3092 else if (IS_AGGR_TYPE (TREE_TYPE (from))
3093 && IS_AGGR_TYPE (TREE_TYPE (to)))
3095 if (DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
3097 from = cp_build_type_variant (TREE_TYPE (to),
3098 TYPE_READONLY (TREE_TYPE (from)),
3099 TYPE_VOLATILE (TREE_TYPE (from)));
3100 from = build_pointer_type (from);
3101 nconv = build_conv (PTR_CONV, from, conv);
3105 if (nconv && comptypes (from, to, 1))
3107 else if (nconv && comp_ptr_ttypes (TREE_TYPE (to), TREE_TYPE (from)))
3108 conv = build_conv (QUAL_CONV, to, nconv);
3109 else if (ptr_reasonably_similar (TREE_TYPE (to), TREE_TYPE (from)))
3111 conv = build_conv (PTR_CONV, to, conv);
3112 ICS_BAD_FLAG (conv) = 1;
3119 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
3121 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
3122 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
3123 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
3124 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
3126 if (! DERIVED_FROM_P (fbase, tbase)
3127 || ! comptypes (TREE_TYPE (fromfn), TREE_TYPE (tofn), 1)
3128 || ! compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
3129 TREE_CHAIN (TYPE_ARG_TYPES (tofn)), 1)
3130 || TYPE_READONLY (fbase) != TYPE_READONLY (tbase)
3131 || TYPE_VOLATILE (fbase) != TYPE_VOLATILE (tbase))
3134 from = cp_build_type_variant (tbase, TYPE_READONLY (fbase),
3135 TYPE_VOLATILE (fbase));
3136 from = build_cplus_method_type (from, TREE_TYPE (fromfn),
3137 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
3138 from = build_ptrmemfunc_type (build_pointer_type (from));
3139 conv = build_conv (PMEM_CONV, from, conv);
3141 else if (tcode == BOOLEAN_TYPE)
3143 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE
3144 || fcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (from)))
3147 conv = build_conv (STD_CONV, to, conv);
3148 if (fcode == POINTER_TYPE || TYPE_PTRMEMFUNC_P (from)
3149 && ICS_STD_RANK (conv) < PBOOL_RANK)
3150 ICS_STD_RANK (conv) = PBOOL_RANK;
3152 /* We don't check for ENUMERAL_TYPE here because there are no standard
3153 conversions to enum type. */
3154 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
3155 || tcode == REAL_TYPE)
3157 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
3159 conv = build_conv (STD_CONV, to, conv);
3161 /* Give this a better rank if it's a promotion. */
3162 if (to == type_promotes_to (from)
3163 && ICS_STD_RANK (TREE_OPERAND (conv, 0)) <= PROMO_RANK)
3164 ICS_STD_RANK (conv) = PROMO_RANK;
3166 else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
3167 && DERIVED_FROM_P (to, from))
3168 conv = build_conv (BASE_CONV, to, conv);
3175 /* Returns the conversion path from type FROM to reference type TO for
3176 purposes of reference binding. For lvalue binding, either pass a
3177 reference type to FROM or an lvalue expression to EXPR.
3179 Currently does not distinguish in the generated trees between binding to
3180 an lvalue and a temporary. Should it? */
3183 reference_binding (rto, rfrom, expr, flags)
3184 tree rto, rfrom, expr;
3189 tree to = TREE_TYPE (rto);
3193 if (TREE_CODE (from) == REFERENCE_TYPE)
3194 from = TREE_TYPE (from);
3195 else if (! expr || ! real_lvalue_p (expr))
3198 related = (TYPE_MAIN_VARIANT (to) == TYPE_MAIN_VARIANT (from)
3199 || (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
3200 && DERIVED_FROM_P (to, from)));
3202 if (lvalue && related
3203 && TYPE_READONLY (to) >= TYPE_READONLY (from)
3204 && TYPE_VOLATILE (to) >= TYPE_VOLATILE (from))
3206 conv = build1 (IDENTITY_CONV, from, expr);
3208 if (TYPE_MAIN_VARIANT (to) == TYPE_MAIN_VARIANT (from))
3209 conv = build_conv (REF_BIND, rto, conv);
3212 conv = build_conv (REF_BIND, rto, conv);
3213 ICS_STD_RANK (conv) = STD_RANK;
3221 conv = standard_conversion (to, rfrom, expr);
3224 conv = build_conv (REF_BIND, rto, conv);
3226 /* Bind directly to a base subobject of a class rvalue. Do it
3227 after building the conversion for proper handling of ICS_RANK. */
3228 if (TREE_CODE (TREE_OPERAND (conv, 0)) == BASE_CONV)
3229 TREE_OPERAND (conv, 0) = TREE_OPERAND (TREE_OPERAND (conv, 0), 0);
3232 && ((! (TYPE_READONLY (to) && ! TYPE_VOLATILE (to)
3233 && (flags & LOOKUP_NO_TEMP_BIND) == 0))
3234 /* If T1 is reference-related to T2, cv1 must be the same
3235 cv-qualification as, or greater cv-qualification than,
3236 cv2; otherwise, the program is ill-formed. */
3238 && (TYPE_READONLY (to) < TYPE_READONLY (from)
3239 || TYPE_VOLATILE (to) < TYPE_VOLATILE (from)))))
3240 ICS_BAD_FLAG (conv) = 1;
3246 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
3247 to type TO. The optional expression EXPR may affect the conversion.
3248 FLAGS are the usual overloading flags. Only LOOKUP_NO_CONVERSION is
3252 implicit_conversion (to, from, expr, flags)
3253 tree to, from, expr;
3257 struct z_candidate *cand;
3259 if (expr && type_unknown_p (expr))
3261 expr = instantiate_type (to, expr, 0);
3262 if (expr == error_mark_node)
3264 from = TREE_TYPE (expr);
3267 if (TREE_CODE (to) == REFERENCE_TYPE)
3268 conv = reference_binding (to, from, expr, flags);
3270 conv = standard_conversion (to, from, expr);
3274 else if ((IS_AGGR_TYPE (non_reference (from))
3275 || IS_AGGR_TYPE (non_reference (to)))
3276 && (flags & LOOKUP_NO_CONVERSION) == 0)
3278 cand = build_user_type_conversion_1
3279 (to, expr, LOOKUP_ONLYCONVERTING);
3281 conv = cand->second_conv;
3282 if ((! conv || ICS_BAD_FLAG (conv))
3283 && TREE_CODE (to) == REFERENCE_TYPE
3284 && TYPE_READONLY (TREE_TYPE (to))
3285 && ! TYPE_VOLATILE (TREE_TYPE (to))
3286 && (flags & LOOKUP_NO_TEMP_BIND) == 0)
3288 cand = build_user_type_conversion_1
3289 (TYPE_MAIN_VARIANT (TREE_TYPE (to)), expr, LOOKUP_ONLYCONVERTING);
3291 conv = build_conv (REF_BIND, to, cand->second_conv);
3298 /* Create an overload candidate for the function or method FN called with
3299 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
3300 to implicit_conversion. */
3302 static struct z_candidate *
3303 add_function_candidate (candidates, fn, arglist, flags)
3304 struct z_candidate *candidates;
3308 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
3311 tree parmnode = parmlist;
3312 tree argnode = arglist;
3314 struct z_candidate *cand;
3316 /* The `this' and `in_chrg' arguments to constructors are not considered
3317 in overload resolution. */
3318 if (DECL_CONSTRUCTOR_P (fn))
3320 parmnode = TREE_CHAIN (parmnode);
3321 argnode = TREE_CHAIN (argnode);
3322 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
3324 parmnode = TREE_CHAIN (parmnode);
3325 argnode = TREE_CHAIN (argnode);
3329 len = list_length (argnode);
3330 convs = make_tree_vec (len);
3332 for (i = 0; i < len; ++i)
3334 tree arg = TREE_VALUE (argnode);
3335 tree argtype = TREE_TYPE (arg);
3338 argtype = cp_build_type_variant
3339 (argtype, TREE_READONLY (arg), TREE_THIS_VOLATILE (arg));
3341 if (parmnode == void_list_node)
3344 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
3347 t = build1 (IDENTITY_CONV, argtype, arg);
3348 ICS_ELLIPSIS_FLAG (t) = 1;
3351 if (i == 0 && t && TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
3352 && ! DECL_CONSTRUCTOR_P (fn))
3353 ICS_THIS_FLAG (t) = 1;
3355 TREE_VEC_ELT (convs, i) = t;
3359 if (ICS_BAD_FLAG (t))
3363 parmnode = TREE_CHAIN (parmnode);
3364 argnode = TREE_CHAIN (argnode);
3370 /* Make sure there are default args for the rest of the parms. */
3371 for (; parmnode && parmnode != void_list_node;
3372 parmnode = TREE_CHAIN (parmnode))
3373 if (! TREE_PURPOSE (parmnode))
3379 cand = (struct z_candidate *) oballoc (sizeof (struct z_candidate));
3382 cand->convs = convs;
3383 cand->second_conv = NULL_TREE;
3384 cand->viable = viable;
3385 cand->basetype_path = NULL_TREE;
3386 cand->template = NULL_TREE;
3387 cand->next = candidates;
3392 /* Create an overload candidate for the conversion function FN which will
3393 be invoked for expression OBJ, producing a pointer-to-function which
3394 will in turn be called with the argument list ARGLIST, and add it to
3395 CANDIDATES. FLAGS is passed on to implicit_conversion. */
3397 static struct z_candidate *
3398 add_conv_candidate (candidates, fn, obj, arglist)
3399 struct z_candidate *candidates;
3400 tree fn, obj, arglist;
3402 tree totype = TREE_TYPE (TREE_TYPE (fn));
3403 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (totype));
3404 int i, len = list_length (arglist) + 1;
3405 tree convs = make_tree_vec (len);
3406 tree parmnode = parmlist;
3407 tree argnode = arglist;
3409 struct z_candidate *cand;
3410 int flags = LOOKUP_NORMAL;
3412 for (i = 0; i < len; ++i)
3414 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
3415 tree argtype = lvalue_type (arg);
3419 t = implicit_conversion (totype, argtype, arg, flags);
3420 else if (parmnode == void_list_node)
3423 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
3426 t = build1 (IDENTITY_CONV, argtype, arg);
3427 ICS_ELLIPSIS_FLAG (t) = 1;
3430 TREE_VEC_ELT (convs, i) = t;
3434 if (ICS_BAD_FLAG (t))
3441 parmnode = TREE_CHAIN (parmnode);
3442 argnode = TREE_CHAIN (argnode);
3448 for (; parmnode && parmnode != void_list_node;
3449 parmnode = TREE_CHAIN (parmnode))
3450 if (! TREE_PURPOSE (parmnode))
3456 cand = (struct z_candidate *) oballoc (sizeof (struct z_candidate));
3459 cand->convs = convs;
3460 cand->second_conv = NULL_TREE;
3461 cand->viable = viable;
3462 cand->basetype_path = NULL_TREE;
3463 cand->template = NULL_TREE;
3464 cand->next = candidates;
3469 static struct z_candidate *
3470 build_builtin_candidate (candidates, fnname, type1, type2,
3471 args, argtypes, flags)
3472 struct z_candidate *candidates;
3473 tree fnname, type1, type2, *args, *argtypes;
3479 struct z_candidate *cand;
3485 convs = make_tree_vec (args[2] ? 3 : (args[1] ? 2 : 1));
3487 for (i = 0; i < 2; ++i)
3492 t = implicit_conversion (types[i], argtypes[i], args[i], flags);
3496 /* We need something for printing the candidate. */
3497 t = build1 (IDENTITY_CONV, types[i], NULL_TREE);
3499 else if (ICS_BAD_FLAG (t))
3501 TREE_VEC_ELT (convs, i) = t;
3504 /* For COND_EXPR we rearranged the arguments; undo that now. */
3507 TREE_VEC_ELT (convs, 2) = TREE_VEC_ELT (convs, 1);
3508 TREE_VEC_ELT (convs, 1) = TREE_VEC_ELT (convs, 0);
3509 t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
3511 TREE_VEC_ELT (convs, 0) = t;
3516 cand = (struct z_candidate *) oballoc (sizeof (struct z_candidate));
3519 cand->convs = convs;
3520 cand->second_conv = NULL_TREE;
3521 cand->viable = viable;
3522 cand->basetype_path = NULL_TREE;
3523 cand->template = NULL_TREE;
3524 cand->next = candidates;
3533 return TYPE_SIZE (complete_type (t)) != NULL_TREE;
3536 /* Create any builtin operator overload candidates for the operator in
3537 question given the converted operand types TYPE1 and TYPE2. The other
3538 args are passed through from add_builtin_candidates to
3539 build_builtin_candidate. */
3541 static struct z_candidate *
3542 add_builtin_candidate (candidates, code, code2, fnname, type1, type2,
3543 args, argtypes, flags)
3544 struct z_candidate *candidates;
3545 enum tree_code code, code2;
3546 tree fnname, type1, type2, *args, *argtypes;
3551 case POSTINCREMENT_EXPR:
3552 case POSTDECREMENT_EXPR:
3553 args[1] = integer_zero_node;
3554 type2 = integer_type_node;
3560 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3561 and VQ is either volatile or empty, there exist candidate operator
3562 functions of the form
3563 VQ T& operator++(VQ T&);
3564 T operator++(VQ T&, int);
3565 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
3566 type other than bool, and VQ is either volatile or empty, there exist
3567 candidate operator functions of the form
3568 VQ T& operator--(VQ T&);
3569 T operator--(VQ T&, int);
3570 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
3571 complete object type, and VQ is either volatile or empty, there exist
3572 candidate operator functions of the form
3573 T*VQ& operator++(T*VQ&);
3574 T*VQ& operator--(T*VQ&);
3575 T* operator++(T*VQ&, int);
3576 T* operator--(T*VQ&, int); */
3578 case POSTDECREMENT_EXPR:
3579 case PREDECREMENT_EXPR:
3580 if (TREE_CODE (type1) == BOOLEAN_TYPE)
3582 case POSTINCREMENT_EXPR:
3583 case PREINCREMENT_EXPR:
3584 if ((ARITHMETIC_TYPE_P (type1) && TREE_CODE (type1) != ENUMERAL_TYPE)
3585 || TYPE_PTROB_P (type1))
3587 type1 = build_reference_type (type1);
3592 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
3593 exist candidate operator functions of the form
3597 8 For every function type T, there exist candidate operator functions of
3599 T& operator*(T*); */
3602 if (TREE_CODE (type1) == POINTER_TYPE
3603 && (TYPE_PTROB_P (type1)
3604 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
3608 /* 9 For every type T, there exist candidate operator functions of the form
3611 10For every promoted arithmetic type T, there exist candidate operator
3612 functions of the form
3616 case CONVERT_EXPR: /* unary + */
3617 if (TREE_CODE (type1) == POINTER_TYPE
3618 && TREE_CODE (TREE_TYPE (type1)) != OFFSET_TYPE)
3621 if (ARITHMETIC_TYPE_P (type1))
3625 /* 11For every promoted integral type T, there exist candidate operator
3626 functions of the form
3630 if (INTEGRAL_TYPE_P (type1))
3634 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
3635 is the same type as C2 or is a derived class of C2, T is a complete
3636 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
3637 there exist candidate operator functions of the form
3638 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
3639 where CV12 is the union of CV1 and CV2. */
3642 if (TREE_CODE (type1) == POINTER_TYPE
3643 && (TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2)))
3645 tree c1 = TREE_TYPE (type1);
3646 tree c2 = (TYPE_PTRMEMFUNC_P (type2)
3647 ? TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (type2))
3648 : TYPE_OFFSET_BASETYPE (TREE_TYPE (type2)));
3650 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
3651 && (TYPE_PTRMEMFUNC_P (type2)
3652 || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
3657 /* 13For every pair of promoted arithmetic types L and R, there exist can-
3658 didate operator functions of the form
3663 bool operator<(L, R);
3664 bool operator>(L, R);
3665 bool operator<=(L, R);
3666 bool operator>=(L, R);
3667 bool operator==(L, R);
3668 bool operator!=(L, R);
3669 where LR is the result of the usual arithmetic conversions between
3672 14For every pair of types T and I, where T is a cv-qualified or cv-
3673 unqualified complete object type and I is a promoted integral type,
3674 there exist candidate operator functions of the form
3675 T* operator+(T*, I);
3676 T& operator[](T*, I);
3677 T* operator-(T*, I);
3678 T* operator+(I, T*);
3679 T& operator[](I, T*);
3681 15For every T, where T is a pointer to complete object type, there exist
3682 candidate operator functions of the form112)
3683 ptrdiff_t operator-(T, T);
3685 16For every pointer type T, there exist candidate operator functions of
3687 bool operator<(T, T);
3688 bool operator>(T, T);
3689 bool operator<=(T, T);
3690 bool operator>=(T, T);
3691 bool operator==(T, T);
3692 bool operator!=(T, T);
3694 17For every pointer to member type T, there exist candidate operator
3695 functions of the form
3696 bool operator==(T, T);
3697 bool operator!=(T, T); */
3700 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
3702 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
3704 type2 = ptrdiff_type_node;
3708 case TRUNC_DIV_EXPR:
3709 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
3715 if (TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2)
3716 || TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
3718 if ((TYPE_PTRMEMFUNC_P (type1) || TYPE_PTRMEM_P (type1))
3719 && null_ptr_cst_p (args[1]))
3724 if ((TYPE_PTRMEMFUNC_P (type2) || TYPE_PTRMEM_P (type2))
3725 && null_ptr_cst_p (args[0]))
3736 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)
3737 || TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
3739 if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
3744 if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
3752 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
3755 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
3757 type1 = ptrdiff_type_node;
3760 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
3762 type2 = ptrdiff_type_node;
3767 /* 18For every pair of promoted integral types L and R, there exist candi-
3768 date operator functions of the form
3775 where LR is the result of the usual arithmetic conversions between
3778 case TRUNC_MOD_EXPR:
3784 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
3788 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
3789 type, VQ is either volatile or empty, and R is a promoted arithmetic
3790 type, there exist candidate operator functions of the form
3791 VQ L& operator=(VQ L&, R);
3792 VQ L& operator*=(VQ L&, R);
3793 VQ L& operator/=(VQ L&, R);
3794 VQ L& operator+=(VQ L&, R);
3795 VQ L& operator-=(VQ L&, R);
3797 20For every pair T, VQ), where T is any type and VQ is either volatile
3798 or empty, there exist candidate operator functions of the form
3799 T*VQ& operator=(T*VQ&, T*);
3801 21For every pair T, VQ), where T is a pointer to member type and VQ is
3802 either volatile or empty, there exist candidate operator functions of
3804 VQ T& operator=(VQ T&, T);
3806 22For every triple T, VQ, I), where T is a cv-qualified or cv-
3807 unqualified complete object type, VQ is either volatile or empty, and
3808 I is a promoted integral type, there exist candidate operator func-
3810 T*VQ& operator+=(T*VQ&, I);
3811 T*VQ& operator-=(T*VQ&, I);
3813 23For every triple L, VQ, R), where L is an integral or enumeration
3814 type, VQ is either volatile or empty, and R is a promoted integral
3815 type, there exist candidate operator functions of the form
3817 VQ L& operator%=(VQ L&, R);
3818 VQ L& operator<<=(VQ L&, R);
3819 VQ L& operator>>=(VQ L&, R);
3820 VQ L& operator&=(VQ L&, R);
3821 VQ L& operator^=(VQ L&, R);
3822 VQ L& operator|=(VQ L&, R); */
3829 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
3831 type2 = ptrdiff_type_node;
3835 case TRUNC_DIV_EXPR:
3836 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
3840 case TRUNC_MOD_EXPR:
3846 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
3851 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
3853 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
3854 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
3855 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
3856 || ((TYPE_PTRMEMFUNC_P (type1)
3857 || TREE_CODE (type1) == POINTER_TYPE)
3858 && null_ptr_cst_p (args[1])))
3866 my_friendly_abort (367);
3868 type1 = build_reference_type (type1);
3872 /* Kludge around broken overloading rules whereby
3873 bool ? const char& : enum is ambiguous
3874 (between int and const char&). */
3875 flags |= LOOKUP_NO_TEMP_BIND;
3877 /* Extension: Support ?: of enumeral type. Hopefully this will not
3878 be an extension for long. */
3879 if (TREE_CODE (type1) == ENUMERAL_TYPE && type1 == type2)
3881 else if (TREE_CODE (type1) == ENUMERAL_TYPE
3882 || TREE_CODE (type2) == ENUMERAL_TYPE)
3884 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
3886 if (TREE_CODE (type1) == TREE_CODE (type2)
3887 && (TREE_CODE (type1) == REFERENCE_TYPE
3888 || TREE_CODE (type1) == POINTER_TYPE
3889 || TYPE_PTRMEMFUNC_P (type1)
3890 || IS_AGGR_TYPE (type1)))
3892 if (TREE_CODE (type1) == REFERENCE_TYPE
3893 || TREE_CODE (type2) == REFERENCE_TYPE)
3895 if (((TYPE_PTRMEMFUNC_P (type1) || TREE_CODE (type1) == POINTER_TYPE)
3896 && null_ptr_cst_p (args[1]))
3897 || IS_AGGR_TYPE (type1))
3902 if (((TYPE_PTRMEMFUNC_P (type2) || TREE_CODE (type2) == POINTER_TYPE)
3903 && null_ptr_cst_p (args[0]))
3904 || IS_AGGR_TYPE (type2))
3912 my_friendly_abort (367);
3915 /* If we're dealing with two pointer types, we need candidates
3916 for both of them. */
3917 if (type2 && type1 != type2
3918 && TREE_CODE (type1) == TREE_CODE (type2)
3919 && (TREE_CODE (type1) == REFERENCE_TYPE
3920 || (TREE_CODE (type1) == POINTER_TYPE
3921 && TYPE_PTRMEM_P (type1) == TYPE_PTRMEM_P (type2))
3922 || TYPE_PTRMEMFUNC_P (type1)
3923 || IS_AGGR_TYPE (type1)))
3925 candidates = build_builtin_candidate
3926 (candidates, fnname, type1, type1, args, argtypes, flags);
3927 return build_builtin_candidate
3928 (candidates, fnname, type2, type2, args, argtypes, flags);
3931 return build_builtin_candidate
3932 (candidates, fnname, type1, type2, args, argtypes, flags);
3936 type_decays_to (type)
3939 if (TREE_CODE (type) == ARRAY_TYPE)
3940 return build_pointer_type (TREE_TYPE (type));
3941 if (TREE_CODE (type) == FUNCTION_TYPE)
3942 return build_pointer_type (type);
3946 /* There are three conditions of builtin candidates:
3948 1) bool-taking candidates. These are the same regardless of the input.
3949 2) pointer-pair taking candidates. These are generated for each type
3950 one of the input types converts to.
3951 3) arithmetic candidates. According to the WP, we should generate
3952 all of these, but I'm trying not to... */
3954 static struct z_candidate *
3955 add_builtin_candidates (candidates, code, code2, fnname, args, flags)
3956 struct z_candidate *candidates;
3957 enum tree_code code, code2;
3962 tree type, argtypes[3], types[2];
3964 for (i = 0; i < 3; ++i)
3967 argtypes[i] = lvalue_type (args[i]);
3969 argtypes[i] = NULL_TREE;
3974 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3975 and VQ is either volatile or empty, there exist candidate operator
3976 functions of the form
3977 VQ T& operator++(VQ T&); */
3979 case POSTINCREMENT_EXPR:
3980 case PREINCREMENT_EXPR:
3981 case POSTDECREMENT_EXPR:
3982 case PREDECREMENT_EXPR:
3987 /* 24There also exist candidate operator functions of the form
3988 bool operator!(bool);
3989 bool operator&&(bool, bool);
3990 bool operator||(bool, bool); */
3992 case TRUTH_NOT_EXPR:
3993 return build_builtin_candidate
3994 (candidates, fnname, boolean_type_node,
3995 NULL_TREE, args, argtypes, flags);
3997 case TRUTH_ORIF_EXPR:
3998 case TRUTH_ANDIF_EXPR:
3999 return build_builtin_candidate
4000 (candidates, fnname, boolean_type_node,
4001 boolean_type_node, args, argtypes, flags);
4012 types[0] = types[1] = NULL_TREE;
4014 for (i = 0; i < 2; ++i)
4018 else if (IS_AGGR_TYPE (argtypes[i]))
4020 tree convs = lookup_conversions (argtypes[i]);
4022 if (code == COND_EXPR)
4024 if (real_lvalue_p (args[i]))
4025 types[i] = tree_cons
4026 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
4028 types[i] = tree_cons
4029 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
4032 else if (! convs || (i == 0 && code == MODIFY_EXPR
4033 && code2 == NOP_EXPR))
4036 for (; convs; convs = TREE_CHAIN (convs))
4038 type = TREE_TYPE (TREE_TYPE (TREE_VALUE (convs)));
4041 && (TREE_CODE (type) != REFERENCE_TYPE
4042 || TYPE_READONLY (TREE_TYPE (type))))
4045 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
4046 types[i] = tree_cons (NULL_TREE, type, types[i]);
4048 type = non_reference (type);
4049 if (i != 0 || ! ref1)
4051 type = TYPE_MAIN_VARIANT (type_decays_to (type));
4052 if (code == COND_EXPR && TREE_CODE (type) == ENUMERAL_TYPE)
4053 types[i] = tree_cons (NULL_TREE, type, types[i]);
4054 if (INTEGRAL_TYPE_P (type))
4055 type = type_promotes_to (type);
4058 if (! value_member (type, types[i]))
4059 types[i] = tree_cons (NULL_TREE, type, types[i]);
4064 if (code == COND_EXPR && real_lvalue_p (args[i]))
4065 types[i] = tree_cons
4066 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
4067 type = non_reference (argtypes[i]);
4068 if (i != 0 || ! ref1)
4070 type = TYPE_MAIN_VARIANT (type_decays_to (type));
4071 if (code == COND_EXPR && TREE_CODE (type) == ENUMERAL_TYPE)
4072 types[i] = tree_cons (NULL_TREE, type, types[i]);
4073 if (INTEGRAL_TYPE_P (type))
4074 type = type_promotes_to (type);
4076 types[i] = tree_cons (NULL_TREE, type, types[i]);
4080 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
4083 for (type = types[1]; type; type = TREE_CHAIN (type))
4084 candidates = add_builtin_candidate
4085 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
4086 TREE_VALUE (type), args, argtypes, flags);
4088 candidates = add_builtin_candidate
4089 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
4090 NULL_TREE, args, argtypes, flags);
4096 static struct z_candidate *
4097 add_template_candidate (candidates, tmpl, arglist, flags)
4098 struct z_candidate *candidates;
4102 int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl));
4103 tree *targs = (tree *) alloca (sizeof (tree) * ntparms);
4104 struct z_candidate *cand;
4108 i = type_unification (DECL_TEMPLATE_PARMS (tmpl), targs,
4109 TYPE_ARG_TYPES (TREE_TYPE (tmpl)),
4110 arglist, &dummy, 0, 0);
4114 fn = instantiate_template (tmpl, targs);
4115 if (fn == error_mark_node)
4118 cand = add_function_candidate (candidates, fn, arglist, flags);
4119 cand->template = DECL_TEMPLATE_INFO (fn);
4125 struct z_candidate *cands;
4127 for (; cands; cands = cands->next)
4128 if (pedantic ? cands->viable == 1 : cands->viable)
4133 static struct z_candidate *
4134 splice_viable (cands)
4135 struct z_candidate *cands;
4137 struct z_candidate **p = &cands;
4141 if (pedantic ? (*p)->viable == 1 : (*p)->viable)
4154 /* Fix this to work on non-lvalues. */
4155 if (IS_SIGNATURE_POINTER (TREE_TYPE (obj))
4156 || IS_SIGNATURE_REFERENCE (TREE_TYPE (obj)))
4159 return build_unary_op (ADDR_EXPR, obj, 0);
4163 print_z_candidates (candidates)
4164 struct z_candidate *candidates;
4166 char *str = "candidates are:";
4167 for (; candidates; candidates = candidates->next)
4169 if (TREE_CODE (candidates->fn) == IDENTIFIER_NODE)
4171 if (candidates->fn == ansi_opname [COND_EXPR])
4172 cp_error ("%s %D(%T, %T, %T) <builtin>", str, candidates->fn,
4173 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
4174 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)),
4175 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 2)));
4176 else if (TREE_VEC_LENGTH (candidates->convs) == 2)
4177 cp_error ("%s %D(%T, %T) <builtin>", str, candidates->fn,
4178 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)),
4179 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 1)));
4181 cp_error ("%s %D(%T) <builtin>", str, candidates->fn,
4182 TREE_TYPE (TREE_VEC_ELT (candidates->convs, 0)));
4185 cp_error_at ("%s %+D%s", str, candidates->fn,
4186 candidates->viable == -1 ? " <near match>" : "");
4191 /* Returns the best overload candidate to perform the requested
4192 conversion. This function is used for three the overloading situations
4193 described in [over.match.copy], [over.match.conv], and [over.match.ref].
4194 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
4195 per [dcl.init.ref], so we ignore temporary bindings. */
4197 static struct z_candidate *
4198 build_user_type_conversion_1 (totype, expr, flags)
4202 struct z_candidate *candidates, *cand;
4203 tree fromtype = TREE_TYPE (expr);
4204 tree ctors = NULL_TREE, convs = NULL_TREE, *p;
4207 if (IS_AGGR_TYPE (totype))
4208 ctors = lookup_fnfields (TYPE_BINFO (totype), ctor_identifier, 0);
4209 if (IS_AGGR_TYPE (fromtype)
4210 && (! IS_AGGR_TYPE (totype) || ! DERIVED_FROM_P (totype, fromtype)))
4211 convs = lookup_conversions (fromtype);
4214 flags |= LOOKUP_NO_CONVERSION;
4218 tree t = build_int_2 (0, 0);
4219 TREE_TYPE (t) = build_pointer_type (totype);
4220 args = build_tree_list (NULL_TREE, expr);
4221 if (TYPE_USES_VIRTUAL_BASECLASSES (totype))
4222 args = tree_cons (NULL_TREE, integer_one_node, args);
4223 args = tree_cons (NULL_TREE, t, args);
4225 ctors = TREE_VALUE (ctors);
4227 for (; ctors; ctors = DECL_CHAIN (ctors))
4229 if (DECL_NONCONVERTING_P (ctors))
4232 candidates = add_function_candidate (candidates, ctors, args, flags);
4233 candidates->second_conv = build1 (IDENTITY_CONV, totype, NULL_TREE);
4234 candidates->basetype_path = TYPE_BINFO (totype);
4238 args = build_tree_list (NULL_TREE, build_this (expr));
4240 for (; convs; convs = TREE_CHAIN (convs))
4242 tree fn = TREE_VALUE (convs);
4243 int convflags = LOOKUP_NO_CONVERSION;
4246 /* If we are called to convert to a reference type, we are trying to
4247 find an lvalue binding, so don't even consider temporaries. If
4248 we don't find an lvalue binding, the caller will try again to
4249 look for a temporary binding. */
4250 if (TREE_CODE (totype) == REFERENCE_TYPE)
4251 convflags |= LOOKUP_NO_TEMP_BIND;
4253 ics = implicit_conversion
4254 (totype, TREE_TYPE (TREE_TYPE (fn)), 0, convflags);
4256 if (TREE_CODE (totype) == REFERENCE_TYPE && ics && ICS_BAD_FLAG (ics))
4257 /* ignore the near match. */;
4259 for (; fn; fn = DECL_CHAIN (fn))
4261 candidates = add_function_candidate (candidates, fn, args, flags);
4262 candidates->second_conv = ics;
4263 candidates->basetype_path = TREE_PURPOSE (convs);
4264 if (candidates->viable == 1 && ICS_BAD_FLAG (ics))
4265 candidates->viable = -1;
4269 if (! any_viable (candidates))
4272 if (flags & LOOKUP_COMPLAIN)
4274 if (candidates && ! candidates->next)
4275 /* say why this one won't work or try to be loose */;
4277 cp_error ("no viable candidates");
4284 candidates = splice_viable (candidates);
4285 cand = tourney (candidates, totype);
4289 if (flags & LOOKUP_COMPLAIN)
4291 cp_error ("conversion from `%T' to `%T' is ambiguous",
4293 print_z_candidates (candidates);
4296 cand = candidates; /* any one will do */
4297 cand->second_conv = build1 (AMBIG_CONV, totype, expr);
4298 ICS_USER_FLAG (cand->second_conv) = 1;
4299 ICS_BAD_FLAG (cand->second_conv) = 1;
4304 for (p = &(cand->second_conv); TREE_CODE (*p) != IDENTITY_CONV; )
4305 p = &(TREE_OPERAND (*p, 0));
4309 (DECL_CONSTRUCTOR_P (cand->fn)
4310 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
4311 NULL_TREE, cand->fn, cand->convs, cand->basetype_path);
4312 ICS_USER_FLAG (cand->second_conv) = 1;
4313 if (cand->viable == -1)
4314 ICS_BAD_FLAG (cand->second_conv) = 1;
4320 build_user_type_conversion (totype, expr, flags)
4324 struct z_candidate *cand
4325 = build_user_type_conversion_1 (totype, expr, flags);
4329 if (TREE_CODE (cand->second_conv) == AMBIG_CONV)
4330 return error_mark_node;
4331 return convert_from_reference (convert_like (cand->second_conv, expr));
4337 build_new_function_call (fn, args, obj)
4340 struct z_candidate *candidates = 0, *cand;
4342 if (obj == NULL_TREE && TREE_CODE (fn) == TREE_LIST)
4345 tree templates = NULL_TREE;
4347 for (t = args; t; t = TREE_CHAIN (t))
4349 if (TREE_VALUE (t) == error_mark_node)
4350 return error_mark_node;
4351 else if (TREE_CODE (TREE_TYPE (TREE_VALUE (t))) == VOID_TYPE)
4353 error ("invalid use of void expression");
4354 return error_mark_node;
4358 for (t = TREE_VALUE (fn); t; t = DECL_CHAIN (t))
4360 if (TREE_CODE (t) == TEMPLATE_DECL)
4362 templates = decl_tree_cons (NULL_TREE, t, templates);
4363 candidates = add_template_candidate
4364 (candidates, t, args, LOOKUP_NORMAL);
4367 candidates = add_function_candidate
4368 (candidates, t, args, LOOKUP_NORMAL);
4371 if (! any_viable (candidates))
4373 if (candidates && ! candidates->next)
4374 return build_function_call (candidates->fn, args);
4375 cp_error ("no matching function for call to `%D (%A)'",
4376 TREE_PURPOSE (fn), args);
4378 print_z_candidates (candidates);
4379 return error_mark_node;
4381 candidates = splice_viable (candidates);
4382 cand = tourney (candidates, NULL_TREE);
4386 cp_error ("call of overloaded `%D (%A)' is ambiguous",
4387 TREE_PURPOSE (fn), args);
4388 print_z_candidates (candidates);
4389 return error_mark_node;
4392 /* Pedantically, it is ill-formed to define a function that could
4393 also be a template instantiation, but we won't implement that
4394 until things settle down. */
4395 if (templates && ! cand->template && ! DECL_INITIAL (cand->fn))
4396 add_maybe_template (cand->fn, templates);
4398 return build_over_call (cand->fn, cand->convs, args, LOOKUP_NORMAL);
4401 return build_function_call (fn, args);
4405 build_object_call (obj, args)
4408 struct z_candidate *candidates = 0, *cand;
4409 tree fns, convs, mem_args;
4410 tree type = TREE_TYPE (obj);
4412 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname [CALL_EXPR], 0);
4416 tree fn = TREE_VALUE (fns);
4417 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
4419 for (; fn; fn = DECL_CHAIN (fn))
4421 candidates = add_function_candidate
4422 (candidates, fn, mem_args, LOOKUP_NORMAL);
4423 candidates->basetype_path = TREE_PURPOSE (fns);
4427 convs = lookup_conversions (type);
4429 for (; convs; convs = TREE_CHAIN (convs))
4431 tree fn = TREE_VALUE (convs);
4432 tree totype = TREE_TYPE (TREE_TYPE (fn));
4434 if (TREE_CODE (totype) == POINTER_TYPE
4435 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
4436 for (; fn; fn = DECL_CHAIN (fn))
4438 candidates = add_conv_candidate (candidates, fn, obj, args);
4439 candidates->basetype_path = TREE_PURPOSE (convs);
4443 if (! any_viable (candidates))
4445 cp_error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
4446 print_z_candidates (candidates);
4447 return error_mark_node;
4450 candidates = splice_viable (candidates);
4451 cand = tourney (candidates, NULL_TREE);
4455 cp_error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
4456 print_z_candidates (candidates);
4457 return error_mark_node;
4460 if (DECL_NAME (cand->fn) == ansi_opname [CALL_EXPR])
4461 return build_over_call (cand->fn, cand->convs, mem_args, LOOKUP_NORMAL);
4463 obj = convert_like (TREE_VEC_ELT (cand->convs, 0), obj);
4466 return build_function_call (obj, args);
4470 op_error (code, code2, arg1, arg2, arg3, problem)
4471 enum tree_code code, code2;
4472 tree arg1, arg2, arg3;
4476 = (code == MODIFY_EXPR ? assignop_tab [code2] : opname_tab [code]);
4481 cp_error ("%s for `%T ? %T : %T'", problem,
4482 error_type (arg1), error_type (arg2), error_type (arg3));
4484 case POSTINCREMENT_EXPR:
4485 case POSTDECREMENT_EXPR:
4486 cp_error ("%s for `%T%s'", problem, error_type (arg1), opname);
4489 cp_error ("%s for `%T[%T]'", problem,
4490 error_type (arg1), error_type (arg2));
4494 cp_error ("%s for `%T %s %T'", problem,
4495 error_type (arg1), opname, error_type (arg2));
4497 cp_error ("%s for `%s%T'", problem, opname, error_type (arg1));
4502 build_new_op (code, flags, arg1, arg2, arg3)
4503 enum tree_code code;
4505 tree arg1, arg2, arg3;
4507 struct z_candidate *candidates = 0, *cand;
4508 tree fns, mem_arglist, arglist, fnname;
4509 enum tree_code code2 = NOP_EXPR;
4510 tree templates = NULL_TREE;
4512 if (arg1 == error_mark_node
4513 || arg2 == error_mark_node
4514 || arg3 == error_mark_node)
4515 return error_mark_node;
4517 if (code == MODIFY_EXPR)
4519 code2 = TREE_CODE (arg3);
4521 fnname = ansi_assopname[code2];
4524 fnname = ansi_opname[code];
4533 arglist = tree_cons (NULL_TREE, arg2, arg3);
4534 if (flags & LOOKUP_GLOBAL)
4535 return build_new_function_call
4536 (lookup_name_nonclass (fnname), arglist, NULL_TREE);
4539 rval = build_method_call
4540 (build_indirect_ref (build1 (NOP_EXPR, arg1, error_mark_node),
4542 fnname, arglist, NULL_TREE, flags);
4543 if (rval == error_mark_node)
4544 /* User might declare fancy operator new, but invoke it
4545 like standard one. */
4548 TREE_TYPE (rval) = arg1;
4549 TREE_CALLS_NEW (rval) = 1;
4553 case VEC_DELETE_EXPR:
4558 if (flags & LOOKUP_GLOBAL)
4559 return build_new_function_call
4560 (lookup_name_nonclass (fnname),
4561 build_tree_list (NULL_TREE, arg1), NULL_TREE);
4563 arglist = tree_cons (NULL_TREE, arg1, build_tree_list (NULL_TREE, arg2));
4565 arg1 = TREE_TYPE (arg1);
4567 /* This handles the case where we're trying to delete
4572 if (TREE_CODE (TREE_TYPE (arg1)) == ARRAY_TYPE)
4574 /* Strip off the pointer and the array. */
4575 arg1 = TREE_TYPE (TREE_TYPE (arg1));
4577 while (TREE_CODE (arg1) == ARRAY_TYPE)
4578 arg1 = (TREE_TYPE (arg1));
4580 arg1 = build_pointer_type (arg1);
4584 rval = build_method_call
4585 (build_indirect_ref (build1 (NOP_EXPR, arg1,
4588 fnname, arglist, NULL_TREE, flags);
4590 /* This can happen when operator delete is protected. */
4591 my_friendly_assert (rval != error_mark_node, 250);
4592 TREE_TYPE (rval) = void_type_node;
4598 return build_object_call (arg1, arg2);
4601 /* The comma operator can have void args. */
4602 if (TREE_CODE (arg1) == OFFSET_REF)
4603 arg1 = resolve_offset_ref (arg1);
4604 if (arg2 && TREE_CODE (arg2) == OFFSET_REF)
4605 arg2 = resolve_offset_ref (arg2);
4606 if (arg3 && TREE_CODE (arg3) == OFFSET_REF)
4607 arg3 = resolve_offset_ref (arg3);
4609 if (code == COND_EXPR)
4611 if (arg2 == NULL_TREE
4612 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
4613 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
4614 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
4615 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
4618 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4619 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4622 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4623 arg2 = integer_zero_node;
4625 fns = lookup_name_nonclass (fnname);
4626 /* + Koenig lookup */
4629 arglist = tree_cons (NULL_TREE, arg1, tree_cons
4630 (NULL_TREE, arg2, build_tree_list (NULL_TREE, arg3)));
4632 arglist = tree_cons (NULL_TREE, arg1, build_tree_list (NULL_TREE, arg2));
4634 arglist = build_tree_list (NULL_TREE, arg1);
4636 if (fns && TREE_CODE (fns) == TREE_LIST)
4637 fns = TREE_VALUE (fns);
4638 for (; fns; fns = DECL_CHAIN (fns))
4640 if (TREE_CODE (fns) == TEMPLATE_DECL)
4642 templates = decl_tree_cons (NULL_TREE, fns, templates);
4643 candidates = add_template_candidate
4644 (candidates, fns, arglist, flags);
4647 candidates = add_function_candidate (candidates, fns, arglist, flags);
4650 if (IS_AGGR_TYPE (TREE_TYPE (arg1)))
4651 fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 0);
4657 tree fn = TREE_VALUE (fns);
4658 mem_arglist = tree_cons (NULL_TREE, build_this (arg1), TREE_CHAIN (arglist));
4659 for (; fn; fn = DECL_CHAIN (fn))
4661 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4662 candidates = add_function_candidate
4663 (candidates, fn, mem_arglist, flags);
4665 candidates = add_function_candidate (candidates, fn, arglist, flags);
4667 candidates->basetype_path = TREE_PURPOSE (fns);
4674 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
4675 to know about two args; a builtin candidate will always have a first
4676 parameter of type bool. We'll handle that in
4677 build_builtin_candidate. */
4678 if (code == COND_EXPR)
4688 args[2] = NULL_TREE;
4691 candidates = add_builtin_candidates
4692 (candidates, code, code2, fnname, args, flags);
4695 if (! any_viable (candidates))
4699 case POSTINCREMENT_EXPR:
4700 case POSTDECREMENT_EXPR:
4701 /* Look for an `operator++ (int)'. If they didn't have
4702 one, then we fall back to the old way of doing things. */
4703 if (flags & LOOKUP_COMPLAIN)
4704 cp_pedwarn ("no `%D (int)' declared for postfix `%s', trying prefix operator instead",
4705 fnname, opname_tab [code]);
4706 if (code == POSTINCREMENT_EXPR)
4707 code = PREINCREMENT_EXPR;
4709 code = PREDECREMENT_EXPR;
4710 return build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE);
4712 /* The caller will deal with these. */
4718 if (flags & LOOKUP_COMPLAIN)
4720 op_error (code, code2, arg1, arg2, arg3, "no match");
4721 print_z_candidates (candidates);
4723 return error_mark_node;
4725 candidates = splice_viable (candidates);
4726 cand = tourney (candidates, NULL_TREE);
4730 if (flags & LOOKUP_COMPLAIN)
4732 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
4733 print_z_candidates (candidates);
4735 return error_mark_node;
4738 if (TREE_CODE (cand->fn) == FUNCTION_DECL)
4740 extern int warn_synth;
4742 && fnname == ansi_opname[MODIFY_EXPR]
4743 && DECL_ARTIFICIAL (cand->fn)
4745 && ! candidates->next->next)
4747 cp_warning ("using synthesized `%#D' for copy assignment",
4749 cp_warning_at (" where cfront would use `%#D'",
4751 ? candidates->next->fn
4755 if (DECL_FUNCTION_MEMBER_P (cand->fn))
4756 enforce_access (cand->basetype_path, cand->fn);
4758 /* Pedantically, it is ill-formed to define a function that could
4759 also be a template instantiation, but we won't implement that
4760 until things settle down. */
4761 if (templates && ! cand->template && ! DECL_INITIAL (cand->fn)
4762 && TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE)
4763 add_maybe_template (cand->fn, templates);
4765 return build_over_call
4766 (cand->fn, cand->convs,
4767 TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
4768 ? mem_arglist : arglist,
4772 /* Check for comparison of different enum types. */
4781 if (flag_int_enum_equivalence == 0
4782 && TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
4783 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
4784 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
4785 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
4787 cp_warning ("comparison between `%#T' and `%#T'",
4788 TREE_TYPE (arg1), TREE_TYPE (arg2));
4792 arg1 = convert_from_reference
4793 (convert_like (TREE_VEC_ELT (cand->convs, 0), arg1));
4795 arg2 = convert_like (TREE_VEC_ELT (cand->convs, 1), arg2);
4797 arg3 = convert_like (TREE_VEC_ELT (cand->convs, 2), arg3);
4803 return build_modify_expr (arg1, code2, arg2);
4806 return build_indirect_ref (arg1, "unary *");
4811 case TRUNC_DIV_EXPR:
4822 case TRUNC_MOD_EXPR:
4826 case TRUTH_ANDIF_EXPR:
4827 case TRUTH_ORIF_EXPR:
4828 return build_binary_op_nodefault (code, arg1, arg2, code);
4833 case TRUTH_NOT_EXPR:
4834 case PREINCREMENT_EXPR:
4835 case POSTINCREMENT_EXPR:
4836 case PREDECREMENT_EXPR:
4837 case POSTDECREMENT_EXPR:
4838 return build_unary_op (code, arg1, candidates != 0);
4841 return build_array_ref (arg1, arg2);
4844 return build_conditional_expr (arg1, arg2, arg3);
4847 return build_m_component_ref
4848 (build_indirect_ref (arg1, NULL_PTR), arg2);
4850 /* The caller will deal with these. */
4857 my_friendly_abort (367);
4862 enforce_access (basetype_path, function)
4863 tree basetype_path, function;
4865 tree access = compute_access (basetype_path, function);
4867 if (access == access_private_node)
4869 cp_error_at ("`%+#D' is %s", function,
4870 TREE_PRIVATE (function) ? "private"
4871 : "from private base class");
4872 error ("within this context");
4874 else if (access == access_protected_node)
4876 cp_error_at ("`%+#D' %s", function,
4877 TREE_PROTECTED (function) ? "is protected"
4878 : "has protected accessibility");
4879 error ("within this context");
4883 /* Perform the conversions in CONVS on the expression EXPR. */
4886 convert_like (convs, expr)
4889 if (ICS_BAD_FLAG (convs)
4890 && TREE_CODE (convs) != USER_CONV
4891 && TREE_CODE (convs) != AMBIG_CONV)
4894 for (; t; t = TREE_OPERAND (t, 0))
4896 if (TREE_CODE (t) == USER_CONV)
4898 expr = convert_like (t, expr);
4901 else if (TREE_CODE (t) == AMBIG_CONV)
4902 return convert_like (t, expr);
4903 else if (TREE_CODE (t) == IDENTITY_CONV)
4906 return convert_for_initialization
4907 (NULL_TREE, TREE_TYPE (convs), expr, LOOKUP_NORMAL,
4908 "conversion", NULL_TREE, 0);
4911 switch (TREE_CODE (convs))
4915 tree fn = TREE_OPERAND (convs, 1);
4917 enforce_access (TREE_OPERAND (convs, 3), fn);
4919 if (DECL_CONSTRUCTOR_P (fn))
4921 tree t = build_int_2 (0, 0);
4922 TREE_TYPE (t) = build_pointer_type (DECL_CONTEXT (fn));
4924 args = build_tree_list (NULL_TREE, expr);
4925 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
4926 args = tree_cons (NULL_TREE, integer_one_node, args);
4927 args = tree_cons (NULL_TREE, t, args);
4930 args = build_this (expr);
4931 expr = build_over_call
4932 (TREE_OPERAND (convs, 1), TREE_OPERAND (convs, 2),
4933 args, LOOKUP_NORMAL);
4935 /* If this is a constructor or a function returning an aggr type,
4936 we need to build up a TARGET_EXPR. */
4937 if (DECL_CONSTRUCTOR_P (fn))
4938 expr = build_cplus_new (TREE_TYPE (convs), expr);
4943 if (type_unknown_p (expr))
4944 expr = instantiate_type (TREE_TYPE (convs), expr, 1);
4945 if (TREE_READONLY_DECL_P (expr))
4946 expr = decl_constant_value (expr);
4949 /* Call build_user_type_conversion again for the error. */
4950 return build_user_type_conversion
4951 (TREE_TYPE (convs), TREE_OPERAND (convs, 0), LOOKUP_NORMAL);
4954 expr = convert_like (TREE_OPERAND (convs, 0), expr);
4955 if (expr == error_mark_node)
4956 return error_mark_node;
4958 switch (TREE_CODE (convs))
4961 if (! IS_AGGR_TYPE (TREE_TYPE (convs)))
4963 /* else fall through */
4965 return build_user_type_conversion
4966 (TREE_TYPE (convs), expr, LOOKUP_NORMAL);
4968 return convert_to_reference
4969 (TREE_TYPE (convs), expr,
4970 CONV_IMPLICIT, LOOKUP_NORMAL|LOOKUP_NO_CONVERSION,
4973 return decay_conversion (expr);
4975 return cp_convert (TREE_TYPE (convs), expr, CONV_IMPLICIT,
4976 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
4980 convert_default_arg (type, arg)
4983 arg = break_out_target_exprs (arg);
4985 if (TREE_CODE (arg) == CONSTRUCTOR)
4987 arg = digest_init (type, arg, 0);
4988 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4989 "default argument", 0, 0);
4993 /* This could get clobbered by the following call. */
4994 if (TREE_HAS_CONSTRUCTOR (arg))
4995 arg = copy_node (arg);
4997 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4998 "default argument", 0, 0);
4999 #ifdef PROMOTE_PROTOTYPES
5000 if ((TREE_CODE (type) == INTEGER_TYPE
5001 || TREE_CODE (type) == ENUMERAL_TYPE)
5002 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
5003 arg = default_conversion (arg);
5011 build_over_call (fn, convs, args, flags)
5012 tree fn, convs, args;
5015 tree converted_args = NULL_TREE;
5016 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5017 tree conv, arg, val;
5021 if (args && TREE_CODE (args) != TREE_LIST)
5022 args = build_tree_list (NULL_TREE, args);
5025 /* The implicit parameters to a constructor are not considered by overload
5026 resolution, and must be of the proper type. */
5027 if (DECL_CONSTRUCTOR_P (fn))
5029 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
5030 arg = TREE_CHAIN (arg);
5031 parm = TREE_CHAIN (parm);
5032 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
5034 converted_args = tree_cons
5035 (NULL_TREE, TREE_VALUE (arg), converted_args);
5036 arg = TREE_CHAIN (arg);
5037 parm = TREE_CHAIN (parm);
5040 /* Bypass access control for 'this' parameter. */
5041 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5043 tree parmtype = TREE_VALUE (parm);
5044 tree argtype = TREE_TYPE (TREE_VALUE (arg));
5045 if (ICS_BAD_FLAG (TREE_VEC_ELT (convs, i)))
5047 int dv = (TYPE_VOLATILE (TREE_TYPE (parmtype))
5048 < TYPE_VOLATILE (TREE_TYPE (argtype)));
5049 int dc = (TYPE_READONLY (TREE_TYPE (parmtype))
5050 < TYPE_READONLY (TREE_TYPE (argtype)));
5051 char *p = (dv && dc ? "const and volatile"
5052 : dc ? "const" : dv ? "volatile" : "");
5054 cp_pedwarn ("passing `%T' as `this' argument of `%#D' discards %s",
5055 TREE_TYPE (argtype), fn, p);
5057 converted_args = tree_cons
5058 (NULL_TREE, convert_force (TREE_VALUE (parm), TREE_VALUE (arg), CONV_C_CAST),
5060 parm = TREE_CHAIN (parm);
5061 arg = TREE_CHAIN (arg);
5067 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
5069 tree type = TREE_VALUE (parm);
5071 conv = TREE_VEC_ELT (convs, i);
5072 if (ICS_BAD_FLAG (conv))
5075 val = TREE_VALUE (arg);
5077 for (; t; t = TREE_OPERAND (t, 0))
5079 if (TREE_CODE (t) == USER_CONV
5080 || TREE_CODE (t) == AMBIG_CONV)
5082 val = convert_like (t, val);
5085 else if (TREE_CODE (t) == IDENTITY_CONV)
5088 val = convert_for_initialization
5089 (NULL_TREE, type, val, LOOKUP_NORMAL,
5090 "argument passing", fn, i - is_method);
5093 val = convert_like (conv, TREE_VALUE (arg));
5095 #ifdef PROMOTE_PROTOTYPES
5096 if ((TREE_CODE (type) == INTEGER_TYPE
5097 || TREE_CODE (type) == ENUMERAL_TYPE)
5098 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
5099 val = default_conversion (val);
5101 converted_args = tree_cons (NULL_TREE, val, converted_args);
5104 /* Default arguments */
5105 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm))
5107 tree arg = TREE_PURPOSE (parm);
5109 if (PARM_DEFAULT_FROM_TEMPLATE (parm))
5110 /* This came from a template. Instantiate the default arg here,
5112 arg = tsubst_expr (arg, &TREE_VEC_ELT (DECL_TI_ARGS (fn), 0),
5113 TREE_VEC_LENGTH (DECL_TI_ARGS (fn)), NULL_TREE);
5114 converted_args = tree_cons
5115 (NULL_TREE, convert_default_arg (TREE_VALUE (parm), arg),
5120 for (; arg; arg = TREE_CHAIN (arg))
5122 val = TREE_VALUE (arg);
5124 if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
5125 && (TYPE_PRECISION (TREE_TYPE (val))
5126 < TYPE_PRECISION (double_type_node)))
5127 /* Convert `float' to `double'. */
5128 val = convert (double_type_node, val);
5129 else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val))
5130 && ! TYPE_HAS_TRIVIAL_INIT_REF (TREE_TYPE (val)))
5131 cp_warning ("cannot pass objects of type `%T' through `...'",
5134 /* Convert `short' and `char' to full-size `int'. */
5135 val = default_conversion (val);
5137 converted_args = tree_cons (NULL_TREE, val, converted_args);
5140 converted_args = nreverse (converted_args);
5142 /* Avoid actually calling copy constructors and copy assignment operators,
5144 if (DECL_CONSTRUCTOR_P (fn)
5145 && TREE_VEC_LENGTH (convs) == 1
5146 && copy_args_p (fn))
5149 arg = TREE_VALUE (TREE_CHAIN (converted_args));
5151 /* Pull out the real argument, disregarding const-correctness. */
5153 while (TREE_CODE (targ) == NOP_EXPR
5154 || TREE_CODE (targ) == NON_LVALUE_EXPR
5155 || TREE_CODE (targ) == CONVERT_EXPR)
5156 targ = TREE_OPERAND (targ, 0);
5157 if (TREE_CODE (targ) == ADDR_EXPR)
5159 targ = TREE_OPERAND (targ, 0);
5160 if (! comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg))),
5161 TYPE_MAIN_VARIANT (TREE_TYPE (targ)), 1))
5170 arg = build_indirect_ref (arg, 0);
5172 /* [class.copy]: the copy constructor is implicitly defined even if
5173 the implementation elided its use. */
5174 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
5177 /* If we're creating a temp and we already have one, don't create a
5178 new one. If we're not creating a temp but we get one, use
5179 INIT_EXPR to collapse the temp into our target. Otherwise, if the
5180 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5181 temp or an INIT_EXPR otherwise. */
5182 if (integer_zerop (TREE_VALUE (args)))
5184 if (! real_lvalue_p (arg))
5186 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5188 val = build (VAR_DECL, DECL_CONTEXT (fn));
5189 layout_decl (val, 0);
5190 val = build (TARGET_EXPR, DECL_CONTEXT (fn), val, arg, 0, 0);
5191 TREE_SIDE_EFFECTS (val) = 1;
5195 else if (! real_lvalue_p (arg)
5196 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5198 tree to = stabilize_reference
5199 (build_indirect_ref (TREE_VALUE (args), 0));
5200 val = build (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5201 TREE_SIDE_EFFECTS (val) = 1;
5202 return build_unary_op (ADDR_EXPR, val, 0);
5205 else if (DECL_NAME (fn) == ansi_opname[MODIFY_EXPR]
5207 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5209 tree to = stabilize_reference
5210 (build_indirect_ref (TREE_VALUE (converted_args), 0));
5211 arg = build_indirect_ref (TREE_VALUE (TREE_CHAIN (converted_args)), 0);
5212 val = build (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5213 TREE_SIDE_EFFECTS (val) = 1;
5219 if (DECL_CONTEXT (fn) && IS_SIGNATURE (DECL_CONTEXT (fn)))
5220 return build_signature_method_call (fn, converted_args);
5221 else if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5223 tree t, *p = &TREE_VALUE (converted_args);
5224 tree binfo = get_binfo
5225 (DECL_CONTEXT (fn), TREE_TYPE (TREE_TYPE (*p)), 0);
5226 *p = convert_pointer_to_real (binfo, *p);
5227 if (TREE_SIDE_EFFECTS (*p))
5228 *p = save_expr (*p);
5229 t = build_pointer_type (TREE_TYPE (fn));
5230 fn = build_vfn_ref (p, build_indirect_ref (*p, 0), DECL_VINDEX (fn));
5233 else if (DECL_INLINE (fn))
5234 fn = inline_conversion (fn);
5236 fn = build_addr_func (fn);
5238 fn = build_call (fn, TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))), converted_args);
5239 if (TREE_TYPE (fn) == void_type_node)
5241 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5242 fn = build_cplus_new (TREE_TYPE (fn), fn);
5243 return convert_from_reference (require_complete_type (fn));
5247 build_new_method_call (instance, name, args, basetype_path, flags)
5248 tree instance, name, args, basetype_path;
5251 struct z_candidate *candidates = 0, *cand;
5252 tree basetype, mem_args, fns, instance_ptr;
5254 tree user_args = args;
5256 /* If there is an extra argument for controlling virtual bases,
5257 remove it for error reporting. */
5258 if (flags & LOOKUP_HAS_IN_CHARGE)
5259 user_args = TREE_CHAIN (args);
5261 for (fns = args; fns; fns = TREE_CHAIN (fns))
5262 if (TREE_VALUE (fns) == error_mark_node)
5263 return error_mark_node;
5265 if (instance == NULL_TREE)
5266 basetype = BINFO_TYPE (basetype_path);
5269 if (TREE_CODE (instance) == OFFSET_REF)
5270 instance = resolve_offset_ref (instance);
5271 if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5272 instance = convert_from_reference (instance);
5273 basetype = TREE_TYPE (instance);
5275 /* XXX this should be handled before we get here. */
5276 if (! IS_AGGR_TYPE (basetype)
5277 && ! (TYPE_LANG_SPECIFIC (basetype)
5278 && (IS_SIGNATURE_POINTER (basetype)
5279 || IS_SIGNATURE_REFERENCE (basetype))))
5281 if ((flags & LOOKUP_COMPLAIN) && basetype != error_mark_node)
5282 cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
5283 name, instance, basetype);
5285 return error_mark_node;
5288 /* If `instance' is a signature pointer/reference and `name' is
5289 not a constructor, we are calling a signature member function.
5290 In that case set the `basetype' to the signature type. */
5291 if ((IS_SIGNATURE_POINTER (basetype)
5292 || IS_SIGNATURE_REFERENCE (basetype))
5293 && TYPE_IDENTIFIER (basetype) != name)
5294 basetype = SIGNATURE_TYPE (basetype);
5297 if (basetype_path == NULL_TREE)
5298 basetype_path = TYPE_BINFO (basetype);
5302 instance_ptr = build_this (instance);
5304 /* XXX this should be handled before we get here. */
5305 fns = build_field_call (basetype_path, instance_ptr, name, args);
5311 instance_ptr = build_int_2 (0, 0);
5312 TREE_TYPE (instance_ptr) = build_pointer_type (basetype);
5316 = (name == ctor_identifier ? constructor_name_full (basetype) : name);
5318 fns = lookup_fnfields (basetype_path, name, 1);
5320 if (fns == error_mark_node)
5321 return error_mark_node;
5324 tree t = TREE_VALUE (fns);
5325 if (name == ctor_identifier && TYPE_USES_VIRTUAL_BASECLASSES (basetype)
5326 && ! (flags & LOOKUP_HAS_IN_CHARGE))
5328 flags |= LOOKUP_HAS_IN_CHARGE;
5329 args = tree_cons (NULL_TREE, integer_one_node, args);
5331 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5332 for (; t; t = DECL_CHAIN (t))
5334 /* We can end up here for copy-init of same or base class. */
5335 if (name == ctor_identifier
5336 && (flags & LOOKUP_ONLYCONVERTING)
5337 && DECL_NONCONVERTING_P (t))
5339 if (TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE)
5340 candidates = add_function_candidate
5341 (candidates, t, mem_args, flags);
5343 candidates = add_function_candidate (candidates, t, args, flags);
5344 candidates->basetype_path = TREE_PURPOSE (fns);
5348 if (! any_viable (candidates))
5350 /* XXX will LOOKUP_SPECULATIVELY be needed when this is done? */
5351 if (flags & LOOKUP_SPECULATIVELY)
5353 cp_error ("no matching function for call to `%T::%D (%A)%V'", basetype,
5354 pretty_name, user_args, TREE_TYPE (TREE_TYPE (instance_ptr)));
5355 print_z_candidates (candidates);
5356 return error_mark_node;
5358 candidates = splice_viable (candidates);
5359 cand = tourney (candidates, NULL_TREE);
5363 cp_error ("call of overloaded `%D(%A)' is ambiguous", pretty_name,
5365 print_z_candidates (candidates);
5366 return error_mark_node;
5369 enforce_access (cand->basetype_path, cand->fn);
5370 if (DECL_ABSTRACT_VIRTUAL_P (cand->fn)
5371 && instance == current_class_ref
5372 && DECL_CONSTRUCTOR_P (current_function_decl)
5373 && ! (flags & LOOKUP_NONVIRTUAL)
5374 && value_member (cand->fn, get_abstract_virtuals (basetype)))
5375 cp_error ("abstract virtual `%#D' called from constructor", cand->fn);
5376 if (TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE
5377 && TREE_CODE (instance_ptr) == NOP_EXPR
5378 && TREE_OPERAND (instance_ptr, 0) == error_mark_node)
5379 cp_error ("cannot call member function `%D' without object", cand->fn);
5381 if (DECL_VINDEX (cand->fn) && ! (flags & LOOKUP_NONVIRTUAL)
5382 && ((instance == current_class_ref && (dtor_label || ctor_label))
5383 || resolves_to_fixed_type_p (instance, 0)))
5384 flags |= LOOKUP_NONVIRTUAL;
5386 return build_over_call
5387 (cand->fn, cand->convs,
5388 TREE_CODE (TREE_TYPE (cand->fn)) == METHOD_TYPE ? mem_args : args,
5392 /* Compare two implicit conversion sequences that differ only in their
5393 qualification conversion. Subroutine of compare_ics. */
5396 compare_qual (ics1, ics2)
5399 tree to1 = TREE_TYPE (ics1);
5400 tree to2 = TREE_TYPE (ics2);
5402 to1 = TREE_TYPE (to1);
5403 to2 = TREE_TYPE (to2);
5405 if (TREE_CODE (to1) == OFFSET_TYPE)
5407 to1 = TREE_TYPE (to1);
5408 to2 = TREE_TYPE (to2);
5411 if (TYPE_READONLY (to1) >= TYPE_READONLY (to2)
5412 && TYPE_VOLATILE (to1) > TYPE_VOLATILE (to2))
5414 else if (TYPE_READONLY (to1) > TYPE_READONLY (to2)
5415 && TYPE_VOLATILE (to1) == TYPE_VOLATILE (to2))
5417 else if (TYPE_READONLY (to1) <= TYPE_READONLY (to2)
5418 && TYPE_VOLATILE (to1) < TYPE_VOLATILE (to2))
5420 else if (TYPE_READONLY (to1) < TYPE_READONLY (to2)
5421 && TYPE_VOLATILE (to1) == TYPE_VOLATILE (to2))
5426 /* Compare two implicit conversion sequences according to the rules set out in
5427 [over.ics.rank]. Return values:
5429 1: ics1 is better than ics2
5430 -1: ics2 is better than ics1
5431 0: ics1 and ics2 are indistinguishable */
5434 compare_ics (ics1, ics2)
5439 if (TREE_CODE (ics1) == QUAL_CONV)
5440 main1 = TREE_OPERAND (ics1, 0);
5444 if (TREE_CODE (ics2) == QUAL_CONV)
5445 main2 = TREE_OPERAND (ics2, 0);
5449 /* Conversions for `this' are PTR_CONVs, but we compare them as though
5450 they were REF_BINDs. */
5451 if (ICS_THIS_FLAG (ics1))
5453 ics1 = build_conv (REF_BIND, TREE_TYPE (ics1), main1);
5454 TREE_OPERAND (ics1, 0) = TREE_OPERAND (main1, 0);
5457 if (ICS_THIS_FLAG (ics2))
5459 ics2 = build_conv (REF_BIND, TREE_TYPE (ics2), main2);
5460 TREE_OPERAND (ics2, 0) = TREE_OPERAND (main2, 0);
5464 if (ICS_RANK (ics1) > ICS_RANK (ics2))
5466 else if (ICS_RANK (ics1) < ICS_RANK (ics2))
5469 if (ICS_RANK (ics1) == BAD_RANK)
5471 if (ICS_USER_FLAG (ics1) > ICS_USER_FLAG (ics2)
5472 || ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5474 else if (ICS_USER_FLAG (ics1) < ICS_USER_FLAG (ics2)
5475 || ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5478 /* else fall through */
5481 /* User-defined conversion sequence U1 is a better conversion sequence
5482 than another user-defined conversion sequence U2 if they contain the
5483 same user-defined conversion operator or constructor and if the sec-
5484 ond standard conversion sequence of U1 is better than the second
5485 standard conversion sequence of U2. */
5487 if (ICS_USER_FLAG (ics1))
5491 for (t1 = ics1; TREE_CODE (t1) != USER_CONV; t1 = TREE_OPERAND (t1, 0))
5492 if (TREE_CODE (t1) == AMBIG_CONV)
5494 for (t2 = ics2; TREE_CODE (t2) != USER_CONV; t2 = TREE_OPERAND (t2, 0))
5495 if (TREE_CODE (t2) == AMBIG_CONV)
5498 if (USER_CONV_FN (t1) != USER_CONV_FN (t2))
5500 else if (ICS_STD_RANK (ics1) > ICS_STD_RANK (ics2))
5502 else if (ICS_STD_RANK (ics1) < ICS_STD_RANK (ics2))
5505 /* else fall through */
5508 #if 0 /* Handled by ranking */
5509 /* A conversion that is not a conversion of a pointer, or pointer to
5510 member, to bool is better than another conversion that is such a
5514 if (TREE_CODE (main1) != TREE_CODE (main2))
5517 if (TREE_CODE (main1) == PTR_CONV || TREE_CODE (main1) == PMEM_CONV
5518 || TREE_CODE (main1) == REF_BIND || TREE_CODE (main1) == BASE_CONV)
5520 tree to1 = TREE_TYPE (main1);
5521 tree from1 = TREE_TYPE (TREE_OPERAND (main1, 0));
5522 tree to2 = TREE_TYPE (main2);
5523 tree from2 = TREE_TYPE (TREE_OPERAND (main2, 0));
5526 /* Standard conversion sequence S1 is a better conversion sequence than
5527 standard conversion sequence S2 if...
5529 S1 and S2 differ only in their qualification conversion and they
5530 yield types identical except for cv-qualifiers and S2 adds all the
5531 qualifiers that S1 adds (and in the same places) and S2 adds yet
5532 more cv-qualifiers than S1, or the similar case with reference
5534 if (TREE_CODE (main1) == REF_BIND)
5536 if (TYPE_MAIN_VARIANT (TREE_TYPE (to1))
5537 == TYPE_MAIN_VARIANT (TREE_TYPE (to2)))
5538 return compare_qual (ics1, ics2);
5540 else if (TREE_CODE (main1) != BASE_CONV && from1 == from2 && to1 == to2)
5541 return compare_qual (ics1, ics2);
5543 if (TYPE_PTRMEMFUNC_P (to1))
5545 to1 = TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to1));
5546 from1 = TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from1));
5548 else if (TREE_CODE (main1) != BASE_CONV)
5550 to1 = TREE_TYPE (to1);
5551 if (TREE_CODE (main1) != REF_BIND)
5552 from1 = TREE_TYPE (from1);
5554 if (TREE_CODE (to1) == OFFSET_TYPE)
5556 to1 = TYPE_OFFSET_BASETYPE (to1);
5557 from1 = TYPE_OFFSET_BASETYPE (from1);
5561 if (TYPE_PTRMEMFUNC_P (to2))
5563 to2 = TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (to2));
5564 from2 = TYPE_METHOD_BASETYPE (TYPE_PTRMEMFUNC_FN_TYPE (from2));
5566 else if (TREE_CODE (main1) != BASE_CONV)
5568 to2 = TREE_TYPE (to2);
5569 if (TREE_CODE (main1) != REF_BIND)
5570 from2 = TREE_TYPE (from2);
5572 if (TREE_CODE (to2) == OFFSET_TYPE)
5574 to2 = TYPE_OFFSET_BASETYPE (to2);
5575 from2 = TYPE_OFFSET_BASETYPE (from2);
5579 if (! (IS_AGGR_TYPE (from1) && IS_AGGR_TYPE (from2)))
5582 /* The sense of pmem conversions is reversed from that of the other
5584 if (TREE_CODE (main1) == PMEM_CONV)
5586 tree t = from1; from1 = from2; from2 = t;
5587 t = to1; to1 = to2; to2 = t;
5590 distf = get_base_distance (from1, from2, 0, 0);
5593 distf = -get_base_distance (from2, from1, 0, 0);
5598 /* If class B is derived directly or indirectly from class A,
5599 conver- sion of B* to A* is better than conversion of B* to
5600 void*, and conversion of A* to void* is better than
5601 conversion of B* to void*. */
5603 if (TREE_CODE (to1) == VOID_TYPE && TREE_CODE (to2) == VOID_TYPE)
5610 else if (TREE_CODE (to2) == VOID_TYPE && IS_AGGR_TYPE (to1)
5611 && get_base_distance (to1, from1, 0, 0) != -1)
5613 else if (TREE_CODE (to1) == VOID_TYPE && IS_AGGR_TYPE (to2)
5614 && get_base_distance (to2, from2, 0, 0) != -1)
5617 if (! (IS_AGGR_TYPE (to1) && IS_AGGR_TYPE (to2)))
5620 /* If class B is derived directly or indirectly from class A and class
5621 C is derived directly or indirectly from B */
5623 distt = get_base_distance (to1, to2, 0, 0);
5626 distt = -get_base_distance (to2, to1, 0, 0);
5631 /* --conversion of C* to B* is better than conversion of C* to A*, */
5639 /* --conversion of B* to A* is better than conversion of C* to A*, */
5640 else if (distt == 0)
5648 else if (TREE_CODE (TREE_TYPE (main1)) == POINTER_TYPE
5649 || TYPE_PTRMEMFUNC_P (TREE_TYPE (main1)))
5651 if (TREE_TYPE (main1) == TREE_TYPE (main2))
5652 return compare_qual (ics1, ics2);
5654 #if 0 /* This is now handled by making identity better than anything else. */
5655 /* existing practice, not WP-endorsed: const char * -> const char *
5656 is better than char * -> const char *. (jason 6/29/96) */
5657 if (TREE_TYPE (ics1) == TREE_TYPE (ics2))
5658 return -compare_qual (main1, main2);
5665 /* Compare two candidates for overloading as described in
5666 [over.match.best]. Return values:
5668 1: cand1 is better than cand2
5669 -1: cand2 is better than cand1
5670 0: cand1 and cand2 are indistinguishable */
5673 joust (cand1, cand2)
5674 struct z_candidate *cand1, *cand2;
5677 int i, off1 = 0, off2 = 0, len;
5679 /* Candidates that involve bad conversions are always worse than those
5681 if (cand1->viable > cand2->viable)
5683 if (cand1->viable < cand2->viable)
5686 /* a viable function F1
5687 is defined to be a better function than another viable function F2 if
5688 for all arguments i, ICSi(F1) is not a worse conversion sequence than
5689 ICSi(F2), and then */
5691 /* for some argument j, ICSj(F1) is a better conversion sequence than
5694 /* For comparing static and non-static member functions, we ignore the
5695 implicit object parameter of the non-static function. The WP says to
5696 pretend that the static function has an object parm, but that won't
5697 work with operator overloading. */
5698 len = TREE_VEC_LENGTH (cand1->convs);
5699 if (len != TREE_VEC_LENGTH (cand2->convs))
5701 if (DECL_STATIC_FUNCTION_P (cand1->fn)
5702 && ! DECL_STATIC_FUNCTION_P (cand2->fn))
5704 else if (! DECL_STATIC_FUNCTION_P (cand1->fn)
5705 && DECL_STATIC_FUNCTION_P (cand2->fn))
5711 my_friendly_abort (42);
5714 for (i = 0; i < len; ++i)
5716 int comp = compare_ics (TREE_VEC_ELT (cand1->convs, i+off1),
5717 TREE_VEC_ELT (cand2->convs, i+off2));
5721 if (winner && comp != winner)
5734 F1 is a non-template function and F2 is a template function */
5736 if (! cand1->template && cand2->template)
5738 else if (cand1->template && ! cand2->template)
5740 else if (cand1->template && cand2->template)
5741 winner = more_specialized
5742 (TI_TEMPLATE (cand1->template), TI_TEMPLATE (cand2->template));
5745 the context is an initialization by user-defined conversion (see
5746 _dcl.init_ and _over.match.user_) and the standard conversion
5747 sequence from the return type of F1 to the destination type (i.e.,
5748 the type of the entity being initialized) is a better conversion
5749 sequence than the standard conversion sequence from the return type
5750 of F2 to the destination type. */
5752 if (! winner && cand1->second_conv)
5753 winner = compare_ics (cand1->second_conv, cand2->second_conv);
5755 /* If the built-in candidates are the same, arbitrarily pick one. */
5756 if (! winner && cand1->fn == cand2->fn
5757 && TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
5759 for (i = 0; i < len; ++i)
5760 if (! comptypes (TREE_TYPE (TREE_VEC_ELT (cand1->convs, i)),
5761 TREE_TYPE (TREE_VEC_ELT (cand2->convs, i)), 1))
5763 if (i == TREE_VEC_LENGTH (cand1->convs))
5766 /* Kludge around broken overloading rules whereby
5767 bool ? void *const & : void *const & is ambiguous. */
5768 /* Huh? Explain the problem better. */
5769 if (cand1->fn == ansi_opname[COND_EXPR])
5771 tree c1 = TREE_VEC_ELT (cand1->convs, 1);
5772 tree c2 = TREE_VEC_ELT (cand2->convs, 1);
5773 tree t1 = strip_top_quals (non_reference (TREE_TYPE (c1)));
5774 tree t2 = strip_top_quals (non_reference (TREE_TYPE (c2)));
5776 if (comptypes (t1, t2, 1))
5778 if (TREE_CODE (c1) == REF_BIND && TREE_CODE (c2) != REF_BIND)
5780 if (TREE_CODE (c1) != REF_BIND && TREE_CODE (c2) == REF_BIND)
5789 /* Extension: If the worst conversion for one candidate is worse than the
5790 worst conversion for the other, take the first. */
5791 if (! winner && ! pedantic)
5793 int rank1 = IDENTITY_RANK, rank2 = IDENTITY_RANK;
5795 for (i = 0; i < len; ++i)
5797 if (ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1)) > rank1)
5798 rank1 = ICS_RANK (TREE_VEC_ELT (cand1->convs, i+off1));
5799 if (ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2)) > rank2)
5800 rank2 = ICS_RANK (TREE_VEC_ELT (cand2->convs, i+off2));
5812 /* Given a list of candidates for overloading, find the best one, if any.
5813 This algorithm has a worst case of O(2n) (winner is last), and a best
5814 case of O(n/2) (totally ambiguous); much better than a sorting
5817 static struct z_candidate *
5818 tourney (candidates)
5819 struct z_candidate *candidates;
5821 struct z_candidate *champ = candidates, *challenger;
5824 /* Walk through the list once, comparing each current champ to the next
5825 candidate, knocking out a candidate or two with each comparison. */
5827 for (challenger = champ->next; challenger; )
5829 fate = joust (champ, challenger);
5831 challenger = challenger->next;
5836 champ = challenger->next;
5843 challenger = champ->next;
5847 /* Make sure the champ is better than all the candidates it hasn't yet
5848 been compared to. This may do one more comparison than necessary. Oh
5851 for (challenger = candidates; challenger != champ;
5852 challenger = challenger->next)
5854 fate = joust (champ, challenger);
5863 can_convert (to, from)
5866 if (flag_ansi_overloading)
5868 tree t = implicit_conversion (to, from, NULL_TREE, LOOKUP_NORMAL);
5869 return (t && ! ICS_BAD_FLAG (t));
5873 struct harshness_code h;
5874 h = convert_harshness (to, from, NULL_TREE);
5875 return (h.code < USER_CODE) && (h.distance >= 0);
5880 can_convert_arg (to, from, arg)
5883 if (flag_ansi_overloading)
5885 tree t = implicit_conversion (to, from, arg, LOOKUP_NORMAL);
5886 return (t && ! ICS_BAD_FLAG (t));
5890 struct harshness_code h;
5891 h = convert_harshness (to, from, arg);
5892 return (h.code < USER_CODE) && (h.distance >= 0);