56e089dd2e4a849efb446c8ba44ba8d2f7932c58
[gcc/gcc.git] / gcc / cp / call.c
1 /* Functions related to invoking methods and overloaded functions.
2    Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 
3    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4    Contributed by Michael Tiemann (tiemann@cygnus.com) and
5    modified by Brendan Kehoe (brendan@cygnus.com).
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING.  If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.  */
23
24
25 /* High-level class interface.  */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "tree.h"
32 #include "cp-tree.h"
33 #include "output.h"
34 #include "flags.h"
35 #include "rtl.h"
36 #include "toplev.h"
37 #include "expr.h"
38 #include "diagnostic.h"
39 #include "intl.h"
40 #include "target.h"
41 #include "convert.h"
42
43 /* The various kinds of conversion.  */
44
45 typedef enum conversion_kind { 
46   ck_identity,
47   ck_lvalue,
48   ck_qual,
49   ck_std,
50   ck_ptr,
51   ck_pmem,
52   ck_base,
53   ck_ref_bind,
54   ck_user,
55   ck_ambig,
56   ck_rvalue
57 } conversion_kind;
58
59 /* The rank of the conversion.  Order of the enumerals matters; better
60    conversions should come earlier in the list.  */
61
62 typedef enum conversion_rank {
63   cr_identity,
64   cr_exact,
65   cr_promotion,
66   cr_std,
67   cr_pbool,
68   cr_user,
69   cr_ellipsis,
70   cr_bad
71 } conversion_rank;
72
73 /* An implicit conversion sequence, in the sense of [over.best.ics].
74    The first conversion to be performed is at the end of the chain.
75    That conversion is always an cr_identity conversion.  */
76
77 typedef struct conversion conversion;
78 struct conversion {
79   /* The kind of conversion represented by this step.  */
80   conversion_kind kind;
81   /* The rank of this conversion.  */
82   conversion_rank rank;
83   BOOL_BITFIELD user_conv_p : 1;
84   BOOL_BITFIELD ellipsis_p : 1;
85   BOOL_BITFIELD this_p : 1;
86   BOOL_BITFIELD bad_p : 1;
87   /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
88      temporary should be created to hold the result of the
89      conversion.  */
90   BOOL_BITFIELD need_temporary_p : 1;
91   /* If KIND is ck_identity or ck_base_conv, true to indicate that the
92      copy constructor must be accessible, even though it is not being
93      used.  */
94   BOOL_BITFIELD check_copy_constructor_p : 1;
95   /* The type of the expression resulting from the conversion.  */
96   tree type;
97   union {
98     /* The next conversion in the chain.  Since the conversions are
99        arranged from outermost to innermost, the NEXT conversion will
100        actually be performed before this conversion.  This variant is
101        used only when KIND is neither ck_identity nor ck_ambig.  */
102     conversion *next;
103     /* The expression at the beginning of the conversion chain.  This
104        variant is used only if KIND is ck_identity or ck_ambig.  */
105     tree expr;
106   } u;
107   /* The function candidate corresponding to this conversion
108      sequence.  This field is only used if KIND is ck_user.  */
109   struct z_candidate *cand;
110 };
111
112 #define CONVERSION_RANK(NODE)                   \
113   ((NODE)->bad_p ? cr_bad                       \
114    : (NODE)->ellipsis_p ? cr_ellipsis           \
115    : (NODE)->user_conv_p ? cr_user              \
116    : (NODE)->rank)
117
118 static struct obstack conversion_obstack;
119 static bool conversion_obstack_initialized;
120
121 static struct z_candidate * tourney (struct z_candidate *);
122 static int equal_functions (tree, tree);
123 static int joust (struct z_candidate *, struct z_candidate *, bool);
124 static int compare_ics (conversion *, conversion *);
125 static tree build_over_call (struct z_candidate *, int);
126 static tree build_java_interface_fn_ref (tree, tree);
127 #define convert_like(CONV, EXPR)                                \
128   convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0,           \
129                      /*issue_conversion_warnings=*/true)
130 #define convert_like_with_context(CONV, EXPR, FN, ARGNO)        \
131   convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0,          \
132                      /*issue_conversion_warnings=*/true)
133 static tree convert_like_real (conversion *, tree, tree, int, int, bool);
134 static void op_error (enum tree_code, enum tree_code, tree, tree,
135                             tree, const char *);
136 static tree build_object_call (tree, tree);
137 static tree resolve_args (tree);
138 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
139 static void print_z_candidate (const char *, struct z_candidate *);
140 static void print_z_candidates (struct z_candidate *);
141 static tree build_this (tree);
142 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
143 static bool any_strictly_viable (struct z_candidate *);
144 static struct z_candidate *add_template_candidate
145         (struct z_candidate **, tree, tree, tree, tree, tree, 
146          tree, tree, int, unification_kind_t);
147 static struct z_candidate *add_template_candidate_real
148         (struct z_candidate **, tree, tree, tree, tree, tree, 
149            tree, tree, int, tree, unification_kind_t);
150 static struct z_candidate *add_template_conv_candidate 
151         (struct z_candidate **, tree, tree, tree, tree, tree, tree);
152 static void add_builtin_candidates
153         (struct z_candidate **, enum tree_code, enum tree_code,
154                tree, tree *, int);
155 static void add_builtin_candidate
156         (struct z_candidate **, enum tree_code, enum tree_code,
157                tree, tree, tree, tree *, tree *, int);
158 static bool is_complete (tree);
159 static void build_builtin_candidate 
160         (struct z_candidate **, tree, tree, tree, tree *, tree *,
161                int);
162 static struct z_candidate *add_conv_candidate 
163         (struct z_candidate **, tree, tree, tree, tree, tree);
164 static struct z_candidate *add_function_candidate 
165         (struct z_candidate **, tree, tree, tree, tree, tree, int);
166 static conversion *implicit_conversion (tree, tree, tree, int);
167 static conversion *standard_conversion (tree, tree, tree);
168 static conversion *reference_binding (tree, tree, tree, int);
169 static conversion *build_conv (conversion_kind, tree, conversion *);
170 static bool is_subseq (conversion *, conversion *);
171 static tree maybe_handle_ref_bind (conversion **);
172 static void maybe_handle_implicit_object (conversion **);
173 static struct z_candidate *add_candidate 
174         (struct z_candidate **, tree, tree, size_t, 
175          conversion **, tree, tree, int);
176 static tree source_type (conversion *);
177 static void add_warning (struct z_candidate *, struct z_candidate *);
178 static bool reference_related_p (tree, tree);
179 static bool reference_compatible_p (tree, tree);
180 static conversion *convert_class_to_reference (tree, tree, tree);
181 static conversion *direct_reference_binding (tree, conversion *);
182 static bool promoted_arithmetic_type_p (tree);
183 static conversion *conditional_conversion (tree, tree);
184 static char *name_as_c_string (tree, tree, bool *);
185 static tree call_builtin_trap (tree);
186 static tree prep_operand (tree);
187 static void add_candidates (tree, tree, tree, bool, tree, tree,
188                             int, struct z_candidate **);
189 static conversion *merge_conversion_sequences (conversion *, conversion *);
190 static bool magic_varargs_p (tree);
191
192 tree
193 build_vfield_ref (tree datum, tree type)
194 {
195   if (datum == error_mark_node)
196     return error_mark_node;
197
198   if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
199     datum = convert_from_reference (datum);
200
201   if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
202       && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
203     datum = convert_to_base (datum, type, /*check_access=*/false);
204
205   return build (COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),
206                 datum, TYPE_VFIELD (type));
207 }
208
209 /* Returns nonzero iff the destructor name specified in NAME
210    (a BIT_NOT_EXPR) matches BASETYPE.  The operand of NAME can take many
211    forms...  */
212
213 bool
214 check_dtor_name (tree basetype, tree name)
215 {
216   name = TREE_OPERAND (name, 0);
217
218   /* Just accept something we've already complained about.  */
219   if (name == error_mark_node)
220     return true;
221
222   if (TREE_CODE (name) == TYPE_DECL)
223     name = TREE_TYPE (name);
224   else if (TYPE_P (name))
225     /* OK */;
226   else if (TREE_CODE (name) == IDENTIFIER_NODE)
227     {
228       if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
229           || (TREE_CODE (basetype) == ENUMERAL_TYPE
230               && name == TYPE_IDENTIFIER (basetype)))
231         name = basetype;
232       else
233         name = get_type_value (name);
234     }
235   /* In the case of:
236       
237        template <class T> struct S { ~S(); };
238        int i;
239        i.~S();
240
241      NAME will be a class template.  */
242   else if (DECL_CLASS_TEMPLATE_P (name))
243     return false;
244   else
245     abort ();
246
247   if (name && TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (name))
248     return true;
249   return false;
250 }
251
252 /* We want the address of a function or method.  We avoid creating a
253    pointer-to-member function.  */
254
255 tree
256 build_addr_func (tree function)
257 {
258   tree type = TREE_TYPE (function);
259
260   /* We have to do these by hand to avoid real pointer to member
261      functions.  */
262   if (TREE_CODE (type) == METHOD_TYPE)
263     {
264       if (TREE_CODE (function) == OFFSET_REF)
265         {
266           tree object = build_address (TREE_OPERAND (function, 0));
267           return get_member_function_from_ptrfunc (&object,
268                                                    TREE_OPERAND (function, 1));
269         }
270       function = build_address (function);
271     }
272   else
273     function = decay_conversion (function);
274
275   return function;
276 }
277
278 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
279    POINTER_TYPE to those.  Note, pointer to member function types
280    (TYPE_PTRMEMFUNC_P) must be handled by our callers.  */
281
282 tree
283 build_call (tree function, tree parms)
284 {
285   int is_constructor = 0;
286   int nothrow;
287   tree tmp;
288   tree decl;
289   tree result_type;
290   tree fntype;
291
292   function = build_addr_func (function);
293
294   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
295     {
296       sorry ("unable to call pointer to member function here");
297       return error_mark_node;
298     }
299
300   fntype = TREE_TYPE (TREE_TYPE (function));
301   result_type = TREE_TYPE (fntype);
302
303   if (TREE_CODE (function) == ADDR_EXPR
304       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
305     decl = TREE_OPERAND (function, 0);
306   else
307     decl = NULL_TREE;
308
309   /* We check both the decl and the type; a function may be known not to
310      throw without being declared throw().  */
311   nothrow = ((decl && TREE_NOTHROW (decl))
312              || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
313
314   if (decl && TREE_THIS_VOLATILE (decl) && cfun)
315     current_function_returns_abnormally = 1;
316
317   if (decl && TREE_DEPRECATED (decl))
318     warn_deprecated_use (decl);
319   require_complete_eh_spec_types (fntype, decl);
320
321   if (decl && DECL_CONSTRUCTOR_P (decl))
322     is_constructor = 1;
323
324   if (decl && ! TREE_USED (decl))
325     {
326       /* We invoke build_call directly for several library functions.
327          These may have been declared normally if we're building libgcc,
328          so we can't just check DECL_ARTIFICIAL.  */
329       if (DECL_ARTIFICIAL (decl)
330           || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__", 2))
331         mark_used (decl);
332       else
333         abort ();
334     }
335
336   /* Don't pass empty class objects by value.  This is useful
337      for tags in STL, which are used to control overload resolution.
338      We don't need to handle other cases of copying empty classes.  */
339   if (! decl || ! DECL_BUILT_IN (decl))
340     for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
341       if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
342           && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
343         {
344           tree t = build (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
345           TREE_VALUE (tmp) = build (COMPOUND_EXPR, TREE_TYPE (t),
346                                     TREE_VALUE (tmp), t);
347         }
348
349   function = build (CALL_EXPR, result_type, function, parms);
350   TREE_HAS_CONSTRUCTOR (function) = is_constructor;
351   TREE_NOTHROW (function) = nothrow;
352   
353   return function;
354 }
355
356 /* Build something of the form ptr->method (args)
357    or object.method (args).  This can also build
358    calls to constructors, and find friends.
359
360    Member functions always take their class variable
361    as a pointer.
362
363    INSTANCE is a class instance.
364
365    NAME is the name of the method desired, usually an IDENTIFIER_NODE.
366
367    PARMS help to figure out what that NAME really refers to.
368
369    BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
370    down to the real instance type to use for access checking.  We need this
371    information to get protected accesses correct.
372
373    FLAGS is the logical disjunction of zero or more LOOKUP_
374    flags.  See cp-tree.h for more info.
375
376    If this is all OK, calls build_function_call with the resolved
377    member function.
378
379    This function must also handle being called to perform
380    initialization, promotion/coercion of arguments, and
381    instantiation of default parameters.
382
383    Note that NAME may refer to an instance variable name.  If
384    `operator()()' is defined for the type of that field, then we return
385    that result.  */
386
387 /* New overloading code.  */
388
389 typedef struct z_candidate z_candidate;
390
391 typedef struct candidate_warning candidate_warning;
392 struct candidate_warning {
393   z_candidate *loser;
394   candidate_warning *next;
395 };
396
397 struct z_candidate {
398   /* The FUNCTION_DECL that will be called if this candidate is
399      selected by overload resolution.  */
400   tree fn;
401   /* The arguments to use when calling this function.  */
402   tree args;
403   /* The implicit conversion sequences for each of the arguments to
404      FN.  */
405   conversion **convs;
406   /* The number of implicit conversion sequences.  */
407   size_t num_convs;
408   /* If FN is a user-defined conversion, the standard conversion
409      sequence from the type returned by FN to the desired destination
410      type.  */
411   conversion *second_conv;
412   int viable;
413   /* If FN is a member function, the binfo indicating the path used to
414      qualify the name of FN at the call site.  This path is used to
415      determine whether or not FN is accessible if it is selected by
416      overload resolution.  The DECL_CONTEXT of FN will always be a
417      (possibly improper) base of this binfo.  */
418   tree access_path;
419   /* If FN is a non-static member function, the binfo indicating the
420      subobject to which the `this' pointer should be converted if FN
421      is selected by overload resolution.  The type pointed to the by
422      the `this' pointer must correspond to the most derived class
423      indicated by the CONVERSION_PATH.  */
424   tree conversion_path;
425   tree template;
426   candidate_warning *warnings;
427   z_candidate *next;
428 };
429
430 bool
431 null_ptr_cst_p (tree t)
432 {
433   /* [conv.ptr]
434
435      A null pointer constant is an integral constant expression
436      (_expr.const_) rvalue of integer type that evaluates to zero.  */
437   if (t == null_node
438       || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
439     return true;
440   return false;
441 }
442
443
444 /* Returns nonzero if PARMLIST consists of only default parms and/or
445    ellipsis.  */
446
447 bool
448 sufficient_parms_p (tree parmlist)
449 {
450   for (; parmlist && parmlist != void_list_node;
451        parmlist = TREE_CHAIN (parmlist))
452     if (!TREE_PURPOSE (parmlist))
453       return false;
454   return true;
455 }
456
457 /* Allocate N bytes of memory from the conversion obstack.  The memory
458    is zeroed before being returned.  */
459
460 static void *
461 conversion_obstack_alloc (size_t n)
462 {
463   void *p;
464   if (!conversion_obstack_initialized)
465     {
466       gcc_obstack_init (&conversion_obstack);
467       conversion_obstack_initialized = true;
468     }
469   p = obstack_alloc (&conversion_obstack, n);
470   memset (p, 0, n);
471   return p;
472 }
473
474 /* Dynamically allocate a conversion.  */
475
476 static conversion *
477 alloc_conversion (conversion_kind kind)
478 {
479   conversion *c;
480   c = conversion_obstack_alloc (sizeof (conversion));
481   c->kind = kind;
482   return c;
483 }
484
485 #ifdef ENABLE_CHECKING
486
487 /* Make sure that all memory on the conversion obstack has been
488    freed.  */
489
490 void
491 validate_conversion_obstack (void)
492 {
493   if (conversion_obstack_initialized)
494     my_friendly_assert ((obstack_next_free (&conversion_obstack) 
495                          == obstack_base (&conversion_obstack)),
496                         20040208);
497 }
498
499 #endif /* ENABLE_CHECKING */
500
501 /* Dynamically allocate an array of N conversions.  */
502
503 static conversion **
504 alloc_conversions (size_t n)
505 {
506   return conversion_obstack_alloc (n * sizeof (conversion *));
507 }
508
509 static conversion *
510 build_conv (conversion_kind code, tree type, conversion *from)
511 {
512   conversion *t;
513   conversion_rank rank = CONVERSION_RANK (from);
514
515   /* We can't use buildl1 here because CODE could be USER_CONV, which
516      takes two arguments.  In that case, the caller is responsible for
517      filling in the second argument.  */
518   t = alloc_conversion (code);
519   t->type = type;
520   t->u.next = from;
521
522   switch (code)
523     {
524     case ck_ptr:
525     case ck_pmem:
526     case ck_base:
527     case ck_std:
528       if (rank < cr_std)
529         rank = cr_std;
530       break;
531
532     case ck_qual:
533       if (rank < cr_exact)
534         rank = cr_exact;
535       break;
536
537     default:
538       break;
539     }
540   t->rank = rank;
541   t->user_conv_p = (code == ck_user || from->user_conv_p);
542   t->bad_p = from->bad_p;
543   return t;
544 }
545
546 /* Build a representation of the identity conversion from EXPR to
547    itself.  The TYPE should match the the type of EXPR, if EXPR is
548    non-NULL.  */
549
550 static conversion *
551 build_identity_conv (tree type, tree expr)
552 {
553   conversion *c;
554   
555   c = alloc_conversion (ck_identity);
556   c->type = type;
557   c->u.expr = expr;
558
559   return c;
560 }
561
562 /* Converting from EXPR to TYPE was ambiguous in the sense that there
563    were multiple user-defined conversions to accomplish the job.
564    Build a conversion that indicates that ambiguity.  */
565
566 static conversion *
567 build_ambiguous_conv (tree type, tree expr)
568 {
569   conversion *c;
570
571   c = alloc_conversion (ck_ambig);
572   c->type = type;
573   c->u.expr = expr;
574
575   return c;
576 }
577
578 tree
579 strip_top_quals (tree t)
580 {
581   if (TREE_CODE (t) == ARRAY_TYPE)
582     return t;
583   return cp_build_qualified_type (t, 0);
584 }
585
586 /* Returns the standard conversion path (see [conv]) from type FROM to type
587    TO, if any.  For proper handling of null pointer constants, you must
588    also pass the expression EXPR to convert from.  */
589
590 static conversion *
591 standard_conversion (tree to, tree from, tree expr)
592 {
593   enum tree_code fcode, tcode;
594   conversion *conv;
595   bool fromref = false;
596
597   to = non_reference (to);
598   if (TREE_CODE (from) == REFERENCE_TYPE)
599     {
600       fromref = true;
601       from = TREE_TYPE (from);
602     }
603   to = strip_top_quals (to);
604   from = strip_top_quals (from);
605
606   if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
607       && expr && type_unknown_p (expr))
608     {
609       expr = instantiate_type (to, expr, tf_conv);
610       if (expr == error_mark_node)
611         return NULL;
612       from = TREE_TYPE (expr);
613     }
614
615   fcode = TREE_CODE (from);
616   tcode = TREE_CODE (to);
617
618   conv = build_identity_conv (from, expr);
619   if (fcode == FUNCTION_TYPE)
620     {
621       from = build_pointer_type (from);
622       fcode = TREE_CODE (from);
623       conv = build_conv (ck_lvalue, from, conv);
624     }
625   else if (fcode == ARRAY_TYPE)
626     {
627       from = build_pointer_type (TREE_TYPE (from));
628       fcode = TREE_CODE (from);
629       conv = build_conv (ck_lvalue, from, conv);
630     }
631   else if (fromref || (expr && lvalue_p (expr)))
632     conv = build_conv (ck_rvalue, from, conv);
633
634    /* Allow conversion between `__complex__' data types.  */
635   if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
636     {
637       /* The standard conversion sequence to convert FROM to TO is
638          the standard conversion sequence to perform componentwise
639          conversion.  */
640       conversion *part_conv = standard_conversion
641         (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE);
642       
643       if (part_conv)
644         {
645           conv = build_conv (part_conv->kind, to, conv);
646           conv->rank = part_conv->rank;
647         }
648       else
649         conv = NULL;
650
651       return conv;
652     }
653
654   if (same_type_p (from, to))
655     return conv;
656
657   if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
658       && expr && null_ptr_cst_p (expr))
659     conv = build_conv (ck_std, to, conv);
660   else if (tcode == POINTER_TYPE && fcode == POINTER_TYPE
661            && TREE_CODE (TREE_TYPE (to)) == VECTOR_TYPE
662            && TREE_CODE (TREE_TYPE (from)) == VECTOR_TYPE
663            && ((*targetm.vector_opaque_p) (TREE_TYPE (to))
664                || (*targetm.vector_opaque_p) (TREE_TYPE (from))))
665     conv = build_conv (ck_std, to, conv);
666   else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
667            || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
668     {
669       /* For backwards brain damage compatibility, allow interconversion of
670          pointers and integers with a pedwarn.  */
671       conv = build_conv (ck_std, to, conv);
672       conv->bad_p = true;
673     }
674   else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
675     {
676       /* For backwards brain damage compatibility, allow interconversion of
677          enums and integers with a pedwarn.  */
678       conv = build_conv (ck_std, to, conv);
679       conv->bad_p = true;
680     }
681   else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
682            || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
683     {
684       tree to_pointee;
685       tree from_pointee;
686
687       if (tcode == POINTER_TYPE
688           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
689                                                         TREE_TYPE (to)))
690         ;
691       else if (VOID_TYPE_P (TREE_TYPE (to))
692                && !TYPE_PTRMEM_P (from)
693                && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
694         {
695           from = build_pointer_type
696             (cp_build_qualified_type (void_type_node, 
697                                       cp_type_quals (TREE_TYPE (from))));
698           conv = build_conv (ck_ptr, from, conv);
699         }
700       else if (TYPE_PTRMEM_P (from))
701         {
702           tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
703           tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
704
705           if (DERIVED_FROM_P (fbase, tbase)
706               && (same_type_ignoring_top_level_qualifiers_p
707                   (TYPE_PTRMEM_POINTED_TO_TYPE (from),
708                    TYPE_PTRMEM_POINTED_TO_TYPE (to))))
709             {
710               from = build_ptrmem_type (tbase, 
711                                         TYPE_PTRMEM_POINTED_TO_TYPE (from));
712               conv = build_conv (ck_pmem, from, conv);
713             }
714         }
715       else if (IS_AGGR_TYPE (TREE_TYPE (from))
716                && IS_AGGR_TYPE (TREE_TYPE (to))
717                /* [conv.ptr]
718                   
719                   An rvalue of type "pointer to cv D," where D is a
720                   class type, can be converted to an rvalue of type
721                   "pointer to cv B," where B is a base class (clause
722                   _class.derived_) of D.  If B is an inaccessible
723                   (clause _class.access_) or ambiguous
724                   (_class.member.lookup_) base class of D, a program
725                   that necessitates this conversion is ill-formed.  */
726                /* Therefore, we use DERIVED_FROM_P, and not
727                   ACCESSIBLY_UNIQUELY_DERIVED_FROM_P, in this test.  */
728                && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
729         {
730           from = 
731             cp_build_qualified_type (TREE_TYPE (to),
732                                      cp_type_quals (TREE_TYPE (from)));
733           from = build_pointer_type (from);
734           conv = build_conv (ck_ptr, from, conv);
735         }
736
737       if (tcode == POINTER_TYPE)
738         {
739           to_pointee = TREE_TYPE (to);
740           from_pointee = TREE_TYPE (from);
741         }
742       else
743         {
744           to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
745           from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
746         }
747
748       if (same_type_p (from, to))
749         /* OK */;
750       else if (comp_ptr_ttypes (to_pointee, from_pointee))
751         conv = build_conv (ck_qual, to, conv);
752       else if (expr && string_conv_p (to, expr, 0))
753         /* converting from string constant to char *.  */
754         conv = build_conv (ck_qual, to, conv);
755       else if (ptr_reasonably_similar (to_pointee, from_pointee))
756         {
757           conv = build_conv (ck_ptr, to, conv);
758           conv->bad_p = true;
759         }
760       else
761         return NULL;
762
763       from = to;
764     }
765   else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
766     {
767       tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
768       tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
769       tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
770       tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
771
772       if (!DERIVED_FROM_P (fbase, tbase)
773           || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
774           || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
775                          TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
776           || cp_type_quals (fbase) != cp_type_quals (tbase))
777         return 0;
778
779       from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
780       from = build_method_type_directly (from, 
781                                          TREE_TYPE (fromfn),
782                                          TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
783       from = build_ptrmemfunc_type (build_pointer_type (from));
784       conv = build_conv (ck_pmem, from, conv);
785     }
786   else if (tcode == BOOLEAN_TYPE)
787     {
788       /* [conv.bool]
789
790           An rvalue of arithmetic, enumeration, pointer, or pointer to
791           member type can be converted to an rvalue of type bool.  */
792       if (ARITHMETIC_TYPE_P (from)
793           || fcode == ENUMERAL_TYPE
794           || fcode == POINTER_TYPE
795           || TYPE_PTR_TO_MEMBER_P (from))
796         {
797           conv = build_conv (ck_std, to, conv);
798           if (fcode == POINTER_TYPE
799               || TYPE_PTRMEM_P (from)
800               || (TYPE_PTRMEMFUNC_P (from) 
801                   && conv->rank < cr_pbool))
802             conv->rank = cr_pbool;
803           return conv;
804         }
805       
806       return NULL;
807     }
808   /* We don't check for ENUMERAL_TYPE here because there are no standard
809      conversions to enum type.  */
810   else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
811            || tcode == REAL_TYPE)
812     {
813       if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
814         return 0;
815       conv = build_conv (ck_std, to, conv);
816
817       /* Give this a better rank if it's a promotion.  */
818       if (same_type_p (to, type_promotes_to (from))
819           && conv->u.next->rank <= cr_promotion)
820         conv->rank = cr_promotion;
821     }
822   else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
823       && ((*targetm.vector_opaque_p) (from)
824           || (*targetm.vector_opaque_p) (to)))
825     return build_conv (ck_std, to, conv);
826   else if (IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
827            && is_properly_derived_from (from, to))
828     {
829       if (conv->kind == ck_rvalue)
830         conv = conv->u.next;
831       conv = build_conv (ck_base, to, conv);
832       /* The derived-to-base conversion indicates the initialization
833          of a parameter with base type from an object of a derived
834          type.  A temporary object is created to hold the result of
835          the conversion.  */
836       conv->need_temporary_p = true;
837     }
838   else
839     return NULL;
840
841   return conv;
842 }
843
844 /* Returns nonzero if T1 is reference-related to T2.  */
845
846 static bool
847 reference_related_p (tree t1, tree t2)
848 {
849   t1 = TYPE_MAIN_VARIANT (t1);
850   t2 = TYPE_MAIN_VARIANT (t2);
851
852   /* [dcl.init.ref]
853
854      Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
855      to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
856      of T2.  */
857   return (same_type_p (t1, t2)
858           || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
859               && DERIVED_FROM_P (t1, t2)));
860 }
861
862 /* Returns nonzero if T1 is reference-compatible with T2.  */
863
864 static bool
865 reference_compatible_p (tree t1, tree t2)
866 {
867   /* [dcl.init.ref]
868
869      "cv1 T1" is reference compatible with "cv2 T2" if T1 is
870      reference-related to T2 and cv1 is the same cv-qualification as,
871      or greater cv-qualification than, cv2.  */
872   return (reference_related_p (t1, t2)
873           && at_least_as_qualified_p (t1, t2));
874 }
875
876 /* Determine whether or not the EXPR (of class type S) can be
877    converted to T as in [over.match.ref].  */
878
879 static conversion *
880 convert_class_to_reference (tree t, tree s, tree expr)
881 {
882   tree conversions;
883   tree arglist;
884   conversion *conv;
885   tree reference_type;
886   struct z_candidate *candidates;
887   struct z_candidate *cand;
888   bool any_viable_p;
889
890   conversions = lookup_conversions (s);
891   if (!conversions)
892     return NULL;
893
894   /* [over.match.ref]
895
896      Assuming that "cv1 T" is the underlying type of the reference
897      being initialized, and "cv S" is the type of the initializer
898      expression, with S a class type, the candidate functions are
899      selected as follows:
900
901      --The conversion functions of S and its base classes are
902        considered.  Those that are not hidden within S and yield type
903        "reference to cv2 T2", where "cv1 T" is reference-compatible
904        (_dcl.init.ref_) with "cv2 T2", are candidate functions.
905
906      The argument list has one argument, which is the initializer
907      expression.  */
908
909   candidates = 0;
910
911   /* Conceptually, we should take the address of EXPR and put it in
912      the argument list.  Unfortunately, however, that can result in
913      error messages, which we should not issue now because we are just
914      trying to find a conversion operator.  Therefore, we use NULL,
915      cast to the appropriate type.  */
916   arglist = build_int_2 (0, 0);
917   TREE_TYPE (arglist) = build_pointer_type (s);
918   arglist = build_tree_list (NULL_TREE, arglist);
919
920   reference_type = build_reference_type (t);
921
922   while (conversions)
923     {
924       tree fns = TREE_VALUE (conversions);
925
926       for (; fns; fns = OVL_NEXT (fns))
927         {
928           tree f = OVL_CURRENT (fns);
929           tree t2 = TREE_TYPE (TREE_TYPE (f));
930           
931           cand = NULL;
932
933           /* If this is a template function, try to get an exact
934              match.  */
935           if (TREE_CODE (f) == TEMPLATE_DECL)
936             {
937               cand = add_template_candidate (&candidates,
938                                              f, s,
939                                              NULL_TREE,
940                                              arglist,
941                                              reference_type,
942                                              TYPE_BINFO (s),
943                                              TREE_PURPOSE (conversions),
944                                              LOOKUP_NORMAL,
945                                              DEDUCE_CONV);
946               
947               if (cand)
948                 {
949                   /* Now, see if the conversion function really returns
950                      an lvalue of the appropriate type.  From the
951                      point of view of unification, simply returning an
952                      rvalue of the right type is good enough.  */
953                   f = cand->fn;
954                   t2 = TREE_TYPE (TREE_TYPE (f));
955                   if (TREE_CODE (t2) != REFERENCE_TYPE
956                       || !reference_compatible_p (t, TREE_TYPE (t2)))
957                     {
958                       candidates = candidates->next;
959                       cand = NULL;
960                     }
961                 }
962             }
963           else if (TREE_CODE (t2) == REFERENCE_TYPE
964                    && reference_compatible_p (t, TREE_TYPE (t2)))
965             cand = add_function_candidate (&candidates, f, s, arglist, 
966                                            TYPE_BINFO (s),      
967                                            TREE_PURPOSE (conversions),
968                                            LOOKUP_NORMAL);
969           
970           if (cand)
971             {
972               conversion *identity_conv;
973               /* Build a standard conversion sequence indicating the
974                  binding from the reference type returned by the
975                  function to the desired REFERENCE_TYPE.  */
976               identity_conv 
977                 = build_identity_conv (TREE_TYPE (TREE_TYPE 
978                                                   (TREE_TYPE (cand->fn))),
979                                        NULL_TREE);
980               cand->second_conv
981                 = (direct_reference_binding 
982                    (reference_type, identity_conv));
983               cand->second_conv->bad_p |= cand->convs[0]->bad_p;
984             }
985         }
986       conversions = TREE_CHAIN (conversions);
987     }
988
989   candidates = splice_viable (candidates, pedantic, &any_viable_p);
990   /* If none of the conversion functions worked out, let our caller
991      know.  */
992   if (!any_viable_p)
993     return NULL;
994
995   cand = tourney (candidates);
996   if (!cand)
997     return NULL;
998
999   /* Now that we know that this is the function we're going to use fix
1000      the dummy first argument.  */
1001   cand->args = tree_cons (NULL_TREE,
1002                           build_this (expr),
1003                           TREE_CHAIN (cand->args));
1004
1005   /* Build a user-defined conversion sequence representing the
1006      conversion.  */
1007   conv = build_conv (ck_user,
1008                      TREE_TYPE (TREE_TYPE (cand->fn)),
1009                      build_identity_conv (TREE_TYPE (expr), expr));
1010   conv->cand = cand;
1011
1012   /* Merge it with the standard conversion sequence from the
1013      conversion function's return type to the desired type.  */
1014   cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1015
1016   if (cand->viable == -1)
1017     conv->bad_p = true;
1018   
1019   return cand->second_conv;
1020 }
1021
1022 /* A reference of the indicated TYPE is being bound directly to the
1023    expression represented by the implicit conversion sequence CONV.
1024    Return a conversion sequence for this binding.  */
1025
1026 static conversion *
1027 direct_reference_binding (tree type, conversion *conv)
1028 {
1029   tree t;
1030
1031   my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 20030306);
1032   my_friendly_assert (TREE_CODE (conv->type) != REFERENCE_TYPE, 20030306);
1033
1034   t = TREE_TYPE (type);
1035
1036   /* [over.ics.rank] 
1037      
1038      When a parameter of reference type binds directly
1039      (_dcl.init.ref_) to an argument expression, the implicit
1040      conversion sequence is the identity conversion, unless the
1041      argument expression has a type that is a derived class of the
1042      parameter type, in which case the implicit conversion sequence is
1043      a derived-to-base Conversion.
1044          
1045      If the parameter binds directly to the result of applying a
1046      conversion function to the argument expression, the implicit
1047      conversion sequence is a user-defined conversion sequence
1048      (_over.ics.user_), with the second standard conversion sequence
1049      either an identity conversion or, if the conversion function
1050      returns an entity of a type that is a derived class of the
1051      parameter type, a derived-to-base conversion.  */
1052   if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1053     {
1054       /* Represent the derived-to-base conversion.  */
1055       conv = build_conv (ck_base, t, conv);
1056       /* We will actually be binding to the base-class subobject in
1057          the derived class, so we mark this conversion appropriately.
1058          That way, convert_like knows not to generate a temporary.  */
1059       conv->need_temporary_p = false;
1060     }
1061   return build_conv (ck_ref_bind, type, conv);
1062 }
1063
1064 /* Returns the conversion path from type FROM to reference type TO for
1065    purposes of reference binding.  For lvalue binding, either pass a
1066    reference type to FROM or an lvalue expression to EXPR.  If the
1067    reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1068    the conversion returned.  */
1069
1070 static conversion *
1071 reference_binding (tree rto, tree rfrom, tree expr, int flags)
1072 {
1073   conversion *conv = NULL;
1074   tree to = TREE_TYPE (rto);
1075   tree from = rfrom;
1076   bool related_p;
1077   bool compatible_p;
1078   cp_lvalue_kind lvalue_p = clk_none;
1079
1080   if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1081     {
1082       expr = instantiate_type (to, expr, tf_none);
1083       if (expr == error_mark_node)
1084         return NULL;
1085       from = TREE_TYPE (expr);
1086     }
1087
1088   if (TREE_CODE (from) == REFERENCE_TYPE)
1089     {
1090       /* Anything with reference type is an lvalue.  */
1091       lvalue_p = clk_ordinary;
1092       from = TREE_TYPE (from);
1093     }
1094   else if (expr)
1095     lvalue_p = real_lvalue_p (expr);
1096
1097   /* Figure out whether or not the types are reference-related and
1098      reference compatible.  We have do do this after stripping
1099      references from FROM.  */
1100   related_p = reference_related_p (to, from);
1101   compatible_p = reference_compatible_p (to, from);
1102
1103   if (lvalue_p && compatible_p)
1104     {
1105       /* [dcl.init.ref]
1106
1107          If the initializer expression 
1108          
1109          -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1110             is reference-compatible with "cv2 T2,"
1111          
1112          the reference is bound directly to the initializer expression
1113          lvalue.  */
1114       conv = build_identity_conv (from, expr);
1115       conv = direct_reference_binding (rto, conv);
1116       if ((lvalue_p & clk_bitfield) != 0
1117           || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1118         /* For the purposes of overload resolution, we ignore the fact
1119            this expression is a bitfield or packed field. (In particular,
1120            [over.ics.ref] says specifically that a function with a
1121            non-const reference parameter is viable even if the
1122            argument is a bitfield.)
1123
1124            However, when we actually call the function we must create
1125            a temporary to which to bind the reference.  If the
1126            reference is volatile, or isn't const, then we cannot make
1127            a temporary, so we just issue an error when the conversion
1128            actually occurs.  */
1129         conv->need_temporary_p = true;
1130                                         
1131       return conv;
1132     }
1133   else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1134     {
1135       /* [dcl.init.ref]
1136
1137          If the initializer expression
1138
1139          -- has a class type (i.e., T2 is a class type) can be
1140             implicitly converted to an lvalue of type "cv3 T3," where
1141             "cv1 T1" is reference-compatible with "cv3 T3".  (this
1142             conversion is selected by enumerating the applicable
1143             conversion functions (_over.match.ref_) and choosing the
1144             best one through overload resolution.  (_over.match_). 
1145
1146         the reference is bound to the lvalue result of the conversion
1147         in the second case.  */
1148       conv = convert_class_to_reference (to, from, expr);
1149       if (conv)
1150         return conv;
1151     }
1152
1153   /* From this point on, we conceptually need temporaries, even if we
1154      elide them.  Only the cases above are "direct bindings".  */
1155   if (flags & LOOKUP_NO_TEMP_BIND)
1156     return NULL;
1157
1158   /* [over.ics.rank]
1159      
1160      When a parameter of reference type is not bound directly to an
1161      argument expression, the conversion sequence is the one required
1162      to convert the argument expression to the underlying type of the
1163      reference according to _over.best.ics_.  Conceptually, this
1164      conversion sequence corresponds to copy-initializing a temporary
1165      of the underlying type with the argument expression.  Any
1166      difference in top-level cv-qualification is subsumed by the
1167      initialization itself and does not constitute a conversion.  */
1168
1169   /* [dcl.init.ref]
1170
1171      Otherwise, the reference shall be to a non-volatile const type.  */
1172   if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1173     return NULL;
1174
1175   /* [dcl.init.ref]
1176      
1177      If the initializer expression is an rvalue, with T2 a class type,
1178      and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1179      is bound in one of the following ways:
1180      
1181      -- The reference is bound to the object represented by the rvalue
1182         or to a sub-object within that object.  
1183
1184      -- ...
1185         
1186      We use the first alternative.  The implicit conversion sequence
1187      is supposed to be same as we would obtain by generating a
1188      temporary.  Fortunately, if the types are reference compatible,
1189      then this is either an identity conversion or the derived-to-base
1190      conversion, just as for direct binding.  */
1191   if (CLASS_TYPE_P (from) && compatible_p)
1192     {
1193       conv = build_identity_conv (from, expr);
1194       conv = direct_reference_binding (rto, conv);
1195       conv->u.next->check_copy_constructor_p = true;
1196       return conv;
1197     }
1198
1199   /* [dcl.init.ref]
1200
1201      Otherwise, a temporary of type "cv1 T1" is created and
1202      initialized from the initializer expression using the rules for a
1203      non-reference copy initialization.  If T1 is reference-related to
1204      T2, cv1 must be the same cv-qualification as, or greater
1205      cv-qualification than, cv2; otherwise, the program is ill-formed.  */
1206   if (related_p && !at_least_as_qualified_p (to, from))
1207     return NULL;
1208
1209   conv = implicit_conversion (to, from, expr, flags);
1210   if (!conv)
1211     return NULL;
1212
1213   conv = build_conv (ck_ref_bind, rto, conv);
1214   /* This reference binding, unlike those above, requires the
1215      creation of a temporary.  */
1216   conv->need_temporary_p = true;
1217
1218   return conv;
1219 }
1220
1221 /* Returns the implicit conversion sequence (see [over.ics]) from type FROM
1222    to type TO.  The optional expression EXPR may affect the conversion.
1223    FLAGS are the usual overloading flags.  Only LOOKUP_NO_CONVERSION is
1224    significant.  */
1225
1226 static conversion *
1227 implicit_conversion (tree to, tree from, tree expr, int flags)
1228 {
1229   conversion *conv;
1230
1231   if (from == error_mark_node || to == error_mark_node
1232       || expr == error_mark_node)
1233     return NULL;
1234
1235   if (TREE_CODE (to) == REFERENCE_TYPE)
1236     conv = reference_binding (to, from, expr, flags);
1237   else
1238     conv = standard_conversion (to, from, expr);
1239
1240   if (conv)
1241     return conv;
1242
1243   if (expr != NULL_TREE
1244       && (IS_AGGR_TYPE (from)
1245           || IS_AGGR_TYPE (to))
1246       && (flags & LOOKUP_NO_CONVERSION) == 0)
1247     {
1248       struct z_candidate *cand;
1249
1250       cand = build_user_type_conversion_1
1251         (to, expr, LOOKUP_ONLYCONVERTING);
1252       if (cand)
1253         conv = cand->second_conv;
1254
1255       /* We used to try to bind a reference to a temporary here, but that
1256          is now handled by the recursive call to this function at the end
1257          of reference_binding.  */
1258       return conv;
1259     }
1260
1261   return NULL;
1262 }
1263
1264 /* Add a new entry to the list of candidates.  Used by the add_*_candidate
1265    functions.  */
1266
1267 static struct z_candidate *
1268 add_candidate (struct z_candidate **candidates, 
1269                tree fn, tree args, 
1270                size_t num_convs, conversion **convs, 
1271                tree access_path, tree conversion_path, 
1272                int viable)
1273 {
1274   struct z_candidate *cand 
1275     = conversion_obstack_alloc (sizeof (struct z_candidate));
1276
1277   cand->fn = fn;
1278   cand->args = args;
1279   cand->convs = convs;
1280   cand->num_convs = num_convs;
1281   cand->access_path = access_path;
1282   cand->conversion_path = conversion_path;
1283   cand->viable = viable;
1284   cand->next = *candidates;
1285   *candidates = cand;
1286
1287   return cand;
1288 }
1289
1290 /* Create an overload candidate for the function or method FN called with
1291    the argument list ARGLIST and add it to CANDIDATES.  FLAGS is passed on
1292    to implicit_conversion.
1293
1294    CTYPE, if non-NULL, is the type we want to pretend this function
1295    comes from for purposes of overload resolution.  */
1296
1297 static struct z_candidate *
1298 add_function_candidate (struct z_candidate **candidates, 
1299                         tree fn, tree ctype, tree arglist, 
1300                         tree access_path, tree conversion_path,
1301                         int flags)
1302 {
1303   tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1304   int i, len;
1305   conversion **convs;
1306   tree parmnode, argnode;
1307   tree orig_arglist;
1308   int viable = 1;
1309
1310   /* Built-in functions that haven't been declared don't really
1311      exist.  */
1312   if (DECL_ANTICIPATED (fn))
1313     return NULL;
1314
1315   /* The `this', `in_chrg' and VTT arguments to constructors are not
1316      considered in overload resolution.  */
1317   if (DECL_CONSTRUCTOR_P (fn))
1318     {
1319       parmlist = skip_artificial_parms_for (fn, parmlist);
1320       orig_arglist = arglist;
1321       arglist = skip_artificial_parms_for (fn, arglist);
1322     }
1323   else 
1324     orig_arglist = arglist;
1325
1326   len = list_length (arglist);
1327   convs = alloc_conversions (len);
1328
1329   /* 13.3.2 - Viable functions [over.match.viable]
1330      First, to be a viable function, a candidate function shall have enough
1331      parameters to agree in number with the arguments in the list.
1332
1333      We need to check this first; otherwise, checking the ICSes might cause
1334      us to produce an ill-formed template instantiation.  */
1335
1336   parmnode = parmlist;
1337   for (i = 0; i < len; ++i)
1338     {
1339       if (parmnode == NULL_TREE || parmnode == void_list_node)
1340         break;
1341       parmnode = TREE_CHAIN (parmnode);
1342     }
1343
1344   if (i < len && parmnode)
1345     viable = 0;
1346
1347   /* Make sure there are default args for the rest of the parms.  */
1348   else if (!sufficient_parms_p (parmnode))
1349     viable = 0;
1350
1351   if (! viable)
1352     goto out;
1353
1354   /* Second, for F to be a viable function, there shall exist for each
1355      argument an implicit conversion sequence that converts that argument
1356      to the corresponding parameter of F.  */
1357
1358   parmnode = parmlist;
1359   argnode = arglist;
1360
1361   for (i = 0; i < len; ++i)
1362     {
1363       tree arg = TREE_VALUE (argnode);
1364       tree argtype = lvalue_type (arg);
1365       conversion *t;
1366       int is_this;
1367
1368       if (parmnode == void_list_node)
1369         break;
1370
1371       is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1372                  && ! DECL_CONSTRUCTOR_P (fn));
1373
1374       if (parmnode)
1375         {
1376           tree parmtype = TREE_VALUE (parmnode);
1377
1378           /* The type of the implicit object parameter ('this') for
1379              overload resolution is not always the same as for the
1380              function itself; conversion functions are considered to
1381              be members of the class being converted, and functions
1382              introduced by a using-declaration are considered to be
1383              members of the class that uses them.
1384
1385              Since build_over_call ignores the ICS for the `this'
1386              parameter, we can just change the parm type.  */
1387           if (ctype && is_this)
1388             {
1389               parmtype
1390                 = build_qualified_type (ctype,
1391                                         TYPE_QUALS (TREE_TYPE (parmtype)));
1392               parmtype = build_pointer_type (parmtype);
1393             }
1394
1395           t = implicit_conversion (parmtype, argtype, arg, flags);
1396         }
1397       else
1398         {
1399           t = build_identity_conv (argtype, arg);
1400           t->ellipsis_p = true;
1401         }
1402
1403       if (t && is_this)
1404         t->this_p = true;
1405
1406       convs[i] = t;
1407       if (! t)
1408         {
1409           viable = 0;
1410           break;
1411         }
1412
1413       if (t->bad_p)
1414         viable = -1;
1415
1416       if (parmnode)
1417         parmnode = TREE_CHAIN (parmnode);
1418       argnode = TREE_CHAIN (argnode);
1419     }
1420
1421  out:
1422   return add_candidate (candidates, fn, orig_arglist, len, convs, 
1423                         access_path, conversion_path, viable);
1424 }
1425
1426 /* Create an overload candidate for the conversion function FN which will
1427    be invoked for expression OBJ, producing a pointer-to-function which
1428    will in turn be called with the argument list ARGLIST, and add it to
1429    CANDIDATES.  FLAGS is passed on to implicit_conversion.
1430
1431    Actually, we don't really care about FN; we care about the type it
1432    converts to.  There may be multiple conversion functions that will
1433    convert to that type, and we rely on build_user_type_conversion_1 to
1434    choose the best one; so when we create our candidate, we record the type
1435    instead of the function.  */
1436
1437 static struct z_candidate *
1438 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1439                     tree arglist, tree access_path, tree conversion_path)
1440 {
1441   tree totype = TREE_TYPE (TREE_TYPE (fn));
1442   int i, len, viable, flags;
1443   tree parmlist, parmnode, argnode;
1444   conversion **convs;
1445
1446   for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1447     parmlist = TREE_TYPE (parmlist);
1448   parmlist = TYPE_ARG_TYPES (parmlist);
1449
1450   len = list_length (arglist) + 1;
1451   convs = alloc_conversions (len);
1452   parmnode = parmlist;
1453   argnode = arglist;
1454   viable = 1;
1455   flags = LOOKUP_NORMAL;
1456
1457   /* Don't bother looking up the same type twice.  */
1458   if (*candidates && (*candidates)->fn == totype)
1459     return NULL;
1460
1461   for (i = 0; i < len; ++i)
1462     {
1463       tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1464       tree argtype = lvalue_type (arg);
1465       conversion *t;
1466
1467       if (i == 0)
1468         t = implicit_conversion (totype, argtype, arg, flags);
1469       else if (parmnode == void_list_node)
1470         break;
1471       else if (parmnode)
1472         t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, flags);
1473       else
1474         {
1475           t = build_identity_conv (argtype, arg);
1476           t->ellipsis_p = true;
1477         }
1478
1479       convs[i] = t;
1480       if (! t)
1481         break;
1482
1483       if (t->bad_p)
1484         viable = -1;
1485
1486       if (i == 0)
1487         continue;
1488
1489       if (parmnode)
1490         parmnode = TREE_CHAIN (parmnode);
1491       argnode = TREE_CHAIN (argnode);
1492     }
1493
1494   if (i < len)
1495     viable = 0;
1496
1497   if (!sufficient_parms_p (parmnode))
1498     viable = 0;
1499
1500   return add_candidate (candidates, totype, arglist, len, convs, 
1501                         access_path, conversion_path, viable);
1502 }
1503
1504 static void
1505 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1506                          tree type1, tree type2, tree *args, tree *argtypes,
1507                          int flags)
1508 {
1509   conversion *t;
1510   conversion **convs;
1511   size_t num_convs;
1512   int viable = 1, i;
1513   tree types[2];
1514
1515   types[0] = type1;
1516   types[1] = type2;
1517
1518   num_convs =  args[2] ? 3 : (args[1] ? 2 : 1);
1519   convs = alloc_conversions (num_convs);
1520
1521   for (i = 0; i < 2; ++i)
1522     {
1523       if (! args[i])
1524         break;
1525
1526       t = implicit_conversion (types[i], argtypes[i], args[i], flags);
1527       if (! t)
1528         {
1529           viable = 0;
1530           /* We need something for printing the candidate.  */
1531           t = build_identity_conv (types[i], NULL_TREE);
1532         }
1533       else if (t->bad_p)
1534         viable = 0;
1535       convs[i] = t;
1536     }
1537
1538   /* For COND_EXPR we rearranged the arguments; undo that now.  */
1539   if (args[2])
1540     {
1541       convs[2] = convs[1];
1542       convs[1] = convs[0];
1543       t = implicit_conversion (boolean_type_node, argtypes[2], args[2], flags);
1544       if (t)
1545         convs[0] = t;
1546       else
1547         viable = 0;
1548     }      
1549
1550   add_candidate (candidates, fnname, /*args=*/NULL_TREE, 
1551                  num_convs, convs, 
1552                  /*access_path=*/NULL_TREE,
1553                  /*conversion_path=*/NULL_TREE,
1554                  viable);
1555 }
1556
1557 static bool
1558 is_complete (tree t)
1559 {
1560   return COMPLETE_TYPE_P (complete_type (t));
1561 }
1562
1563 /* Returns nonzero if TYPE is a promoted arithmetic type.  */
1564
1565 static bool
1566 promoted_arithmetic_type_p (tree type)
1567 {
1568   /* [over.built]
1569
1570      In this section, the term promoted integral type is used to refer
1571      to those integral types which are preserved by integral promotion
1572      (including e.g.  int and long but excluding e.g.  char).
1573      Similarly, the term promoted arithmetic type refers to promoted
1574      integral types plus floating types.  */
1575   return ((INTEGRAL_TYPE_P (type)
1576            && same_type_p (type_promotes_to (type), type))
1577           || TREE_CODE (type) == REAL_TYPE);
1578 }
1579
1580 /* Create any builtin operator overload candidates for the operator in
1581    question given the converted operand types TYPE1 and TYPE2.  The other
1582    args are passed through from add_builtin_candidates to
1583    build_builtin_candidate.  
1584    
1585    TYPE1 and TYPE2 may not be permissible, and we must filter them. 
1586    If CODE is requires candidates operands of the same type of the kind
1587    of which TYPE1 and TYPE2 are, we add both candidates
1588    CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2).  */
1589
1590 static void
1591 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1592                        enum tree_code code2, tree fnname, tree type1,
1593                        tree type2, tree *args, tree *argtypes, int flags)
1594 {
1595   switch (code)
1596     {
1597     case POSTINCREMENT_EXPR:
1598     case POSTDECREMENT_EXPR:
1599       args[1] = integer_zero_node;
1600       type2 = integer_type_node;
1601       break;
1602     default:
1603       break;
1604     }
1605
1606   switch (code)
1607     {
1608
1609 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
1610      and  VQ  is  either  volatile or empty, there exist candidate operator
1611      functions of the form
1612              VQ T&   operator++(VQ T&);
1613              T       operator++(VQ T&, int);
1614    5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1615      type  other than bool, and VQ is either volatile or empty, there exist
1616      candidate operator functions of the form
1617              VQ T&   operator--(VQ T&);
1618              T       operator--(VQ T&, int);
1619    6 For every pair T, VQ), where T is  a  cv-qualified  or  cv-unqualified
1620      complete  object type, and VQ is either volatile or empty, there exist
1621      candidate operator functions of the form
1622              T*VQ&   operator++(T*VQ&);
1623              T*VQ&   operator--(T*VQ&);
1624              T*      operator++(T*VQ&, int);
1625              T*      operator--(T*VQ&, int);  */
1626
1627     case POSTDECREMENT_EXPR:
1628     case PREDECREMENT_EXPR:
1629       if (TREE_CODE (type1) == BOOLEAN_TYPE)
1630         return;
1631     case POSTINCREMENT_EXPR:
1632     case PREINCREMENT_EXPR:
1633       if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1634         {
1635           type1 = build_reference_type (type1);
1636           break;
1637         }
1638       return;
1639
1640 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1641      exist candidate operator functions of the form
1642
1643              T&      operator*(T*);
1644
1645    8 For every function type T, there exist candidate operator functions of
1646      the form
1647              T&      operator*(T*);  */
1648
1649     case INDIRECT_REF:
1650       if (TREE_CODE (type1) == POINTER_TYPE
1651           && (TYPE_PTROB_P (type1)
1652               || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1653         break;
1654       return; 
1655
1656 /* 9 For every type T, there exist candidate operator functions of the form
1657              T*      operator+(T*);
1658
1659    10For  every  promoted arithmetic type T, there exist candidate operator
1660      functions of the form
1661              T       operator+(T);
1662              T       operator-(T);  */
1663
1664     case CONVERT_EXPR: /* unary + */
1665       if (TREE_CODE (type1) == POINTER_TYPE)
1666         break;
1667     case NEGATE_EXPR:
1668       if (ARITHMETIC_TYPE_P (type1))
1669         break;
1670       return;
1671
1672 /* 11For every promoted integral type T,  there  exist  candidate  operator
1673      functions of the form
1674              T       operator~(T);  */
1675
1676     case BIT_NOT_EXPR:
1677       if (INTEGRAL_TYPE_P (type1))
1678         break;
1679       return;
1680
1681 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1682      is the same type as C2 or is a derived class of C2, T  is  a  complete
1683      object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1684      there exist candidate operator functions of the form
1685              CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1686      where CV12 is the union of CV1 and CV2.  */
1687
1688     case MEMBER_REF:
1689       if (TREE_CODE (type1) == POINTER_TYPE
1690           && TYPE_PTR_TO_MEMBER_P (type2))
1691         {
1692           tree c1 = TREE_TYPE (type1);
1693           tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1694
1695           if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1696               && (TYPE_PTRMEMFUNC_P (type2)
1697                   || is_complete (TREE_TYPE (TREE_TYPE (type2)))))
1698             break;
1699         }
1700       return;
1701
1702 /* 13For every pair of promoted arithmetic types L and R, there exist  can-
1703      didate operator functions of the form
1704              LR      operator*(L, R);
1705              LR      operator/(L, R);
1706              LR      operator+(L, R);
1707              LR      operator-(L, R);
1708              bool    operator<(L, R);
1709              bool    operator>(L, R);
1710              bool    operator<=(L, R);
1711              bool    operator>=(L, R);
1712              bool    operator==(L, R);
1713              bool    operator!=(L, R);
1714      where  LR  is  the  result of the usual arithmetic conversions between
1715      types L and R.
1716
1717    14For every pair of types T and I, where T  is  a  cv-qualified  or  cv-
1718      unqualified  complete  object  type and I is a promoted integral type,
1719      there exist candidate operator functions of the form
1720              T*      operator+(T*, I);
1721              T&      operator[](T*, I);
1722              T*      operator-(T*, I);
1723              T*      operator+(I, T*);
1724              T&      operator[](I, T*);
1725
1726    15For every T, where T is a pointer to complete object type, there exist
1727      candidate operator functions of the form112)
1728              ptrdiff_t operator-(T, T);
1729
1730    16For every pointer or enumeration type T, there exist candidate operator
1731      functions of the form
1732              bool    operator<(T, T);
1733              bool    operator>(T, T);
1734              bool    operator<=(T, T);
1735              bool    operator>=(T, T);
1736              bool    operator==(T, T);
1737              bool    operator!=(T, T);
1738
1739    17For every pointer to member type T,  there  exist  candidate  operator
1740      functions of the form
1741              bool    operator==(T, T);
1742              bool    operator!=(T, T);  */
1743
1744     case MINUS_EXPR:
1745       if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1746         break;
1747       if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1748         {
1749           type2 = ptrdiff_type_node;
1750           break;
1751         }
1752     case MULT_EXPR:
1753     case TRUNC_DIV_EXPR:
1754       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1755         break;
1756       return;
1757
1758     case EQ_EXPR:
1759     case NE_EXPR:
1760       if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1761           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1762         break;
1763       if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1764         {
1765           type2 = type1;
1766           break;
1767         }
1768       if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1769         {
1770           type1 = type2;
1771           break;
1772         }
1773       /* Fall through.  */
1774     case LT_EXPR:
1775     case GT_EXPR:
1776     case LE_EXPR:
1777     case GE_EXPR:
1778     case MAX_EXPR:
1779     case MIN_EXPR:
1780       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1781         break;
1782       if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1783         break;
1784       if (TREE_CODE (type1) == ENUMERAL_TYPE && TREE_CODE (type2) == ENUMERAL_TYPE)
1785         break;
1786       if (TYPE_PTR_P (type1) && null_ptr_cst_p (args[1]))
1787         {
1788           type2 = type1;
1789           break;
1790         }
1791       if (null_ptr_cst_p (args[0]) && TYPE_PTR_P (type2))
1792         {
1793           type1 = type2;
1794           break;
1795         }
1796       return;
1797
1798     case PLUS_EXPR:
1799       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1800         break;
1801     case ARRAY_REF:
1802       if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1803         {
1804           type1 = ptrdiff_type_node;
1805           break;
1806         }
1807       if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1808         {
1809           type2 = ptrdiff_type_node;
1810           break;
1811         }
1812       return;
1813
1814 /* 18For  every pair of promoted integral types L and R, there exist candi-
1815      date operator functions of the form
1816              LR      operator%(L, R);
1817              LR      operator&(L, R);
1818              LR      operator^(L, R);
1819              LR      operator|(L, R);
1820              L       operator<<(L, R);
1821              L       operator>>(L, R);
1822      where LR is the result of the  usual  arithmetic  conversions  between
1823      types L and R.  */
1824
1825     case TRUNC_MOD_EXPR:
1826     case BIT_AND_EXPR:
1827     case BIT_IOR_EXPR:
1828     case BIT_XOR_EXPR:
1829     case LSHIFT_EXPR:
1830     case RSHIFT_EXPR:
1831       if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1832         break;
1833       return;
1834
1835 /* 19For  every  triple  L, VQ, R), where L is an arithmetic or enumeration
1836      type, VQ is either volatile or empty, and R is a  promoted  arithmetic
1837      type, there exist candidate operator functions of the form
1838              VQ L&   operator=(VQ L&, R);
1839              VQ L&   operator*=(VQ L&, R);
1840              VQ L&   operator/=(VQ L&, R);
1841              VQ L&   operator+=(VQ L&, R);
1842              VQ L&   operator-=(VQ L&, R);
1843
1844    20For  every  pair T, VQ), where T is any type and VQ is either volatile
1845      or empty, there exist candidate operator functions of the form
1846              T*VQ&   operator=(T*VQ&, T*);
1847
1848    21For every pair T, VQ), where T is a pointer to member type and  VQ  is
1849      either  volatile or empty, there exist candidate operator functions of
1850      the form
1851              VQ T&   operator=(VQ T&, T);
1852
1853    22For every triple  T,  VQ,  I),  where  T  is  a  cv-qualified  or  cv-
1854      unqualified  complete object type, VQ is either volatile or empty, and
1855      I is a promoted integral type, there exist  candidate  operator  func-
1856      tions of the form
1857              T*VQ&   operator+=(T*VQ&, I);
1858              T*VQ&   operator-=(T*VQ&, I);
1859
1860    23For  every  triple  L,  VQ,  R), where L is an integral or enumeration
1861      type, VQ is either volatile or empty, and R  is  a  promoted  integral
1862      type, there exist candidate operator functions of the form
1863
1864              VQ L&   operator%=(VQ L&, R);
1865              VQ L&   operator<<=(VQ L&, R);
1866              VQ L&   operator>>=(VQ L&, R);
1867              VQ L&   operator&=(VQ L&, R);
1868              VQ L&   operator^=(VQ L&, R);
1869              VQ L&   operator|=(VQ L&, R);  */
1870
1871     case MODIFY_EXPR:
1872       switch (code2)
1873         {
1874         case PLUS_EXPR:
1875         case MINUS_EXPR:
1876           if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1877             {
1878               type2 = ptrdiff_type_node;
1879               break;
1880             }
1881         case MULT_EXPR:
1882         case TRUNC_DIV_EXPR:
1883           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1884             break;
1885           return;
1886
1887         case TRUNC_MOD_EXPR:
1888         case BIT_AND_EXPR:
1889         case BIT_IOR_EXPR:
1890         case BIT_XOR_EXPR:
1891         case LSHIFT_EXPR:
1892         case RSHIFT_EXPR:
1893           if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1894             break;
1895           return;
1896
1897         case NOP_EXPR:
1898           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1899             break;
1900           if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1901               || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1902               || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1903               || ((TYPE_PTRMEMFUNC_P (type1)
1904                    || TREE_CODE (type1) == POINTER_TYPE)
1905                   && null_ptr_cst_p (args[1])))
1906             {
1907               type2 = type1;
1908               break;
1909             }
1910           return;
1911
1912         default:
1913           abort ();
1914         }
1915       type1 = build_reference_type (type1);
1916       break;
1917
1918     case COND_EXPR:
1919       /* [over.built]
1920
1921          For every pair of promoted arithmetic types L and R, there
1922          exist candidate operator functions of the form 
1923
1924          LR operator?(bool, L, R); 
1925
1926          where LR is the result of the usual arithmetic conversions
1927          between types L and R.
1928
1929          For every type T, where T is a pointer or pointer-to-member
1930          type, there exist candidate operator functions of the form T
1931          operator?(bool, T, T);  */
1932
1933       if (promoted_arithmetic_type_p (type1)
1934           && promoted_arithmetic_type_p (type2))
1935         /* That's OK.  */
1936         break;
1937
1938       /* Otherwise, the types should be pointers.  */
1939       if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1940           || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1941         return;
1942       
1943       /* We don't check that the two types are the same; the logic
1944          below will actually create two candidates; one in which both
1945          parameter types are TYPE1, and one in which both parameter
1946          types are TYPE2.  */
1947       break;
1948
1949     default:
1950       abort ();
1951     }
1952
1953   /* If we're dealing with two pointer types or two enumeral types,
1954      we need candidates for both of them.  */
1955   if (type2 && !same_type_p (type1, type2)
1956       && TREE_CODE (type1) == TREE_CODE (type2)
1957       && (TREE_CODE (type1) == REFERENCE_TYPE
1958           || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1959           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1960           || TYPE_PTRMEMFUNC_P (type1)
1961           || IS_AGGR_TYPE (type1)
1962           || TREE_CODE (type1) == ENUMERAL_TYPE))
1963     {
1964       build_builtin_candidate
1965         (candidates, fnname, type1, type1, args, argtypes, flags);
1966       build_builtin_candidate
1967         (candidates, fnname, type2, type2, args, argtypes, flags);
1968       return;
1969     }
1970
1971   build_builtin_candidate
1972     (candidates, fnname, type1, type2, args, argtypes, flags);
1973 }
1974
1975 tree
1976 type_decays_to (tree type)
1977 {
1978   if (TREE_CODE (type) == ARRAY_TYPE)
1979     return build_pointer_type (TREE_TYPE (type));
1980   if (TREE_CODE (type) == FUNCTION_TYPE)
1981     return build_pointer_type (type);
1982   return type;
1983 }
1984
1985 /* There are three conditions of builtin candidates:
1986
1987    1) bool-taking candidates.  These are the same regardless of the input.
1988    2) pointer-pair taking candidates.  These are generated for each type
1989       one of the input types converts to.
1990    3) arithmetic candidates.  According to the standard, we should generate
1991       all of these, but I'm trying not to...
1992    
1993    Here we generate a superset of the possible candidates for this particular
1994    case.  That is a subset of the full set the standard defines, plus some
1995    other cases which the standard disallows. add_builtin_candidate will
1996    filter out the invalid set.  */
1997
1998 static void
1999 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2000                         enum tree_code code2, tree fnname, tree *args,
2001                         int flags)
2002 {
2003   int ref1, i;
2004   int enum_p = 0;
2005   tree type, argtypes[3];
2006   /* TYPES[i] is the set of possible builtin-operator parameter types
2007      we will consider for the Ith argument.  These are represented as
2008      a TREE_LIST; the TREE_VALUE of each node is the potential
2009      parameter type.  */
2010   tree types[2];
2011
2012   for (i = 0; i < 3; ++i)
2013     {
2014       if (args[i])
2015         argtypes[i]  = lvalue_type (args[i]);
2016       else
2017         argtypes[i] = NULL_TREE;
2018     }
2019
2020   switch (code)
2021     {
2022 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2023      and  VQ  is  either  volatile or empty, there exist candidate operator
2024      functions of the form
2025                  VQ T&   operator++(VQ T&);  */
2026
2027     case POSTINCREMENT_EXPR:
2028     case PREINCREMENT_EXPR:
2029     case POSTDECREMENT_EXPR:
2030     case PREDECREMENT_EXPR:
2031     case MODIFY_EXPR:
2032       ref1 = 1;
2033       break;
2034
2035 /* 24There also exist candidate operator functions of the form
2036              bool    operator!(bool);
2037              bool    operator&&(bool, bool);
2038              bool    operator||(bool, bool);  */
2039
2040     case TRUTH_NOT_EXPR:
2041       build_builtin_candidate
2042         (candidates, fnname, boolean_type_node,
2043          NULL_TREE, args, argtypes, flags);
2044       return;
2045
2046     case TRUTH_ORIF_EXPR:
2047     case TRUTH_ANDIF_EXPR:
2048       build_builtin_candidate
2049         (candidates, fnname, boolean_type_node,
2050          boolean_type_node, args, argtypes, flags);
2051       return;
2052
2053     case ADDR_EXPR:
2054     case COMPOUND_EXPR:
2055     case COMPONENT_REF:
2056       return;
2057
2058     case COND_EXPR:
2059     case EQ_EXPR:
2060     case NE_EXPR:
2061     case LT_EXPR:
2062     case LE_EXPR:
2063     case GT_EXPR:
2064     case GE_EXPR:
2065       enum_p = 1;
2066       /* Fall through.  */
2067     
2068     default:
2069       ref1 = 0;
2070     }
2071
2072   types[0] = types[1] = NULL_TREE;
2073
2074   for (i = 0; i < 2; ++i)
2075     {
2076       if (! args[i])
2077         ;
2078       else if (IS_AGGR_TYPE (argtypes[i]))
2079         {
2080           tree convs;
2081
2082           if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2083             return;
2084
2085           convs = lookup_conversions (argtypes[i]);
2086
2087           if (code == COND_EXPR)
2088             {
2089               if (real_lvalue_p (args[i]))
2090                 types[i] = tree_cons
2091                   (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2092
2093               types[i] = tree_cons
2094                 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2095             }
2096
2097           else if (! convs)
2098             return;
2099
2100           for (; convs; convs = TREE_CHAIN (convs))
2101             {
2102               type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2103
2104               if (i == 0 && ref1
2105                   && (TREE_CODE (type) != REFERENCE_TYPE
2106                       || CP_TYPE_CONST_P (TREE_TYPE (type))))
2107                 continue;
2108
2109               if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2110                 types[i] = tree_cons (NULL_TREE, type, types[i]);
2111
2112               type = non_reference (type);
2113               if (i != 0 || ! ref1)
2114                 {
2115                   type = TYPE_MAIN_VARIANT (type_decays_to (type));
2116                   if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2117                     types[i] = tree_cons (NULL_TREE, type, types[i]);
2118                   if (INTEGRAL_TYPE_P (type))
2119                     type = type_promotes_to (type);
2120                 }
2121
2122               if (! value_member (type, types[i]))
2123                 types[i] = tree_cons (NULL_TREE, type, types[i]);
2124             }
2125         }
2126       else
2127         {
2128           if (code == COND_EXPR && real_lvalue_p (args[i]))
2129             types[i] = tree_cons
2130               (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2131           type = non_reference (argtypes[i]);
2132           if (i != 0 || ! ref1)
2133             {
2134               type = TYPE_MAIN_VARIANT (type_decays_to (type));
2135               if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2136                 types[i] = tree_cons (NULL_TREE, type, types[i]);
2137               if (INTEGRAL_TYPE_P (type))
2138                 type = type_promotes_to (type);
2139             }
2140           types[i] = tree_cons (NULL_TREE, type, types[i]);
2141         }
2142     }
2143
2144   /* Run through the possible parameter types of both arguments,
2145      creating candidates with those parameter types.  */
2146   for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2147     {
2148       if (types[1])
2149         for (type = types[1]; type; type = TREE_CHAIN (type))
2150           add_builtin_candidate
2151             (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2152              TREE_VALUE (type), args, argtypes, flags);
2153       else
2154         add_builtin_candidate
2155           (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2156            NULL_TREE, args, argtypes, flags);
2157     }
2158
2159   return;
2160 }
2161
2162
2163 /* If TMPL can be successfully instantiated as indicated by
2164    EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2165
2166    TMPL is the template.  EXPLICIT_TARGS are any explicit template
2167    arguments.  ARGLIST is the arguments provided at the call-site.
2168    The RETURN_TYPE is the desired type for conversion operators.  If
2169    OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2170    If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2171    add_conv_candidate.  */
2172
2173 static struct z_candidate*
2174 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2175                              tree ctype, tree explicit_targs, tree arglist,
2176                              tree return_type, tree access_path,
2177                              tree conversion_path, int flags, tree obj,
2178                              unification_kind_t strict)
2179 {
2180   int ntparms = DECL_NTPARMS (tmpl);
2181   tree targs = make_tree_vec (ntparms);
2182   tree args_without_in_chrg = arglist;
2183   struct z_candidate *cand;
2184   int i;
2185   tree fn;
2186
2187   /* We don't do deduction on the in-charge parameter, the VTT
2188      parameter or 'this'.  */
2189   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2190     args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2191
2192   if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2193        || DECL_BASE_CONSTRUCTOR_P (tmpl))
2194       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (tmpl)))
2195     args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2196
2197   i = fn_type_unification (tmpl, explicit_targs, targs,
2198                            args_without_in_chrg,
2199                            return_type, strict, -1);
2200
2201   if (i != 0)
2202     return NULL;
2203
2204   fn = instantiate_template (tmpl, targs, tf_none);
2205   if (fn == error_mark_node)
2206     return NULL;
2207
2208   /* In [class.copy]:
2209
2210        A member function template is never instantiated to perform the
2211        copy of a class object to an object of its class type.  
2212
2213      It's a little unclear what this means; the standard explicitly
2214      does allow a template to be used to copy a class.  For example,
2215      in:
2216
2217        struct A {
2218          A(A&);
2219          template <class T> A(const T&);
2220        };
2221        const A f ();
2222        void g () { A a (f ()); }
2223        
2224      the member template will be used to make the copy.  The section
2225      quoted above appears in the paragraph that forbids constructors
2226      whose only parameter is (a possibly cv-qualified variant of) the
2227      class type, and a logical interpretation is that the intent was
2228      to forbid the instantiation of member templates which would then
2229      have that form.  */
2230   if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2) 
2231     {
2232       tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2233       if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2234                                     ctype))
2235         return NULL;
2236     }
2237
2238   if (obj != NULL_TREE)
2239     /* Aha, this is a conversion function.  */
2240     cand = add_conv_candidate (candidates, fn, obj, access_path,
2241                                conversion_path, arglist);
2242   else
2243     cand = add_function_candidate (candidates, fn, ctype,
2244                                    arglist, access_path, 
2245                                    conversion_path, flags);
2246   if (DECL_TI_TEMPLATE (fn) != tmpl)
2247     /* This situation can occur if a member template of a template
2248        class is specialized.  Then, instantiate_template might return
2249        an instantiation of the specialization, in which case the
2250        DECL_TI_TEMPLATE field will point at the original
2251        specialization.  For example:
2252
2253          template <class T> struct S { template <class U> void f(U);
2254                                        template <> void f(int) {}; };
2255          S<double> sd;
2256          sd.f(3);
2257
2258        Here, TMPL will be template <class U> S<double>::f(U).
2259        And, instantiate template will give us the specialization
2260        template <> S<double>::f(int).  But, the DECL_TI_TEMPLATE field
2261        for this will point at template <class T> template <> S<T>::f(int),
2262        so that we can find the definition.  For the purposes of
2263        overload resolution, however, we want the original TMPL.  */
2264     cand->template = tree_cons (tmpl, targs, NULL_TREE);
2265   else
2266     cand->template = DECL_TEMPLATE_INFO (fn);
2267
2268   return cand;
2269 }
2270
2271
2272 static struct z_candidate *
2273 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2274                         tree explicit_targs, tree arglist, tree return_type,
2275                         tree access_path, tree conversion_path, int flags,
2276                         unification_kind_t strict)
2277 {
2278   return 
2279     add_template_candidate_real (candidates, tmpl, ctype,
2280                                  explicit_targs, arglist, return_type, 
2281                                  access_path, conversion_path,
2282                                  flags, NULL_TREE, strict);
2283 }
2284
2285
2286 static struct z_candidate *
2287 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2288                              tree obj, tree arglist, tree return_type,
2289                              tree access_path, tree conversion_path)
2290 {
2291   return 
2292     add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2293                                  arglist, return_type, access_path,
2294                                  conversion_path, 0, obj, DEDUCE_CONV);
2295 }
2296
2297 /* The CANDS are the set of candidates that were considered for
2298    overload resolution.  Return the set of viable candidates.  If none
2299    of the candidates were viable, set *ANY_VIABLE_P to true.  STRICT_P
2300    is true if a candidate should be considered viable only if it is
2301    strictly viable.  */
2302
2303 static struct z_candidate*
2304 splice_viable (struct z_candidate *cands,
2305                bool strict_p,
2306                bool *any_viable_p)
2307 {
2308   struct z_candidate *viable;
2309   struct z_candidate **last_viable;
2310   struct z_candidate **cand;
2311
2312   viable = NULL;
2313   last_viable = &viable;
2314   *any_viable_p = false;
2315
2316   cand = &cands; 
2317   while (*cand) 
2318     {
2319       struct z_candidate *c = *cand;
2320       if (strict_p ? c->viable == 1 : c->viable)
2321         {
2322           *last_viable = c;
2323           *cand = c->next;
2324           c->next = NULL;
2325           last_viable = &c->next;
2326           *any_viable_p = true;
2327         }
2328       else
2329         cand = &c->next;
2330     }
2331
2332   return viable ? viable : cands;
2333 }
2334
2335 static bool
2336 any_strictly_viable (struct z_candidate *cands)
2337 {
2338   for (; cands; cands = cands->next)
2339     if (cands->viable == 1)
2340       return true;
2341   return false;
2342 }
2343
2344 static tree
2345 build_this (tree obj)
2346 {
2347   /* Fix this to work on non-lvalues.  */
2348   return build_unary_op (ADDR_EXPR, obj, 0);
2349 }
2350
2351 /* Returns true iff functions are equivalent. Equivalent functions are
2352    not '==' only if one is a function-local extern function or if
2353    both are extern "C".  */
2354
2355 static inline int
2356 equal_functions (tree fn1, tree fn2)
2357 {
2358   if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2359       || DECL_EXTERN_C_FUNCTION_P (fn1))
2360     return decls_match (fn1, fn2);
2361   return fn1 == fn2;
2362 }
2363
2364 /* Print information about one overload candidate CANDIDATE.  MSGSTR
2365    is the text to print before the candidate itself.
2366
2367    NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2368    to have been run through gettext by the caller.  This wart makes
2369    life simpler in print_z_candidates and for the translators.  */
2370
2371 static void
2372 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2373 {
2374   if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2375     {
2376       if (candidate->num_convs == 3)
2377         inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2378                 candidate->convs[0]->type,
2379                 candidate->convs[1]->type,
2380                 candidate->convs[2]->type);
2381       else if (candidate->num_convs == 2)
2382         inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2383                 candidate->convs[0]->type,
2384                 candidate->convs[1]->type);
2385       else
2386         inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2387                 candidate->convs[0]->type);
2388     }
2389   else if (TYPE_P (candidate->fn))
2390     inform ("%s %T <conversion>", msgstr, candidate->fn);
2391   else if (candidate->viable == -1)
2392     inform ("%J%s %+#D <near match>", candidate->fn, msgstr, candidate->fn);
2393   else
2394     inform ("%J%s %+#D", candidate->fn, msgstr, candidate->fn);
2395 }
2396
2397 static void
2398 print_z_candidates (struct z_candidate *candidates)
2399 {
2400   const char *str;
2401   struct z_candidate *cand1;
2402   struct z_candidate **cand2;
2403
2404   /* There may be duplicates in the set of candidates.  We put off
2405      checking this condition as long as possible, since we have no way
2406      to eliminate duplicates from a set of functions in less than n^2
2407      time.  Now we are about to emit an error message, so it is more
2408      permissible to go slowly.  */
2409   for (cand1 = candidates; cand1; cand1 = cand1->next)
2410     {
2411       tree fn = cand1->fn;
2412       /* Skip builtin candidates and conversion functions.  */
2413       if (TREE_CODE (fn) != FUNCTION_DECL)
2414         continue;
2415       cand2 = &cand1->next;
2416       while (*cand2)
2417         {
2418           if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2419               && equal_functions (fn, (*cand2)->fn))
2420             *cand2 = (*cand2)->next;
2421           else
2422             cand2 = &(*cand2)->next;
2423         }
2424     }
2425
2426   if (!candidates)
2427     return;
2428
2429   str = _("candidates are:");
2430   print_z_candidate (str, candidates);
2431   if (candidates->next)
2432     {
2433       /* Indent successive candidates by the width of the translation
2434          of the above string.  */
2435       size_t len = gcc_gettext_width (str) + 1;
2436       char *spaces = alloca (len);
2437       memset (spaces, ' ', len-1);
2438       spaces[len - 1] = '\0';
2439
2440       candidates = candidates->next;
2441       do
2442         {
2443           print_z_candidate (spaces, candidates);
2444           candidates = candidates->next;
2445         }
2446       while (candidates);
2447     }
2448 }
2449
2450 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2451    USER_CONV.  STD_SEQ is the standard conversion sequence applied to
2452    the result of the conversion function to convert it to the final
2453    desired type.  Merge the the two sequences into a single sequence,
2454    and return the merged sequence.  */
2455
2456 static conversion *
2457 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2458 {
2459   conversion **t;
2460
2461   my_friendly_assert (user_seq->kind == ck_user, 20030306);
2462
2463   /* Find the end of the second conversion sequence.  */
2464   t = &(std_seq); 
2465   while ((*t)->kind != ck_identity)
2466     t = &((*t)->u.next);
2467
2468   /* Replace the identity conversion with the user conversion
2469      sequence.  */
2470   *t = user_seq;
2471
2472   /* The entire sequence is a user-conversion sequence.  */
2473   std_seq->user_conv_p = true;
2474
2475   return std_seq;
2476 }
2477
2478 /* Returns the best overload candidate to perform the requested
2479    conversion.  This function is used for three the overloading situations
2480    described in [over.match.copy], [over.match.conv], and [over.match.ref].
2481    If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2482    per [dcl.init.ref], so we ignore temporary bindings.  */
2483
2484 static struct z_candidate *
2485 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2486 {
2487   struct z_candidate *candidates, *cand;
2488   tree fromtype = TREE_TYPE (expr);
2489   tree ctors = NULL_TREE;
2490   tree conv_fns = NULL_TREE;
2491   conversion *conv = NULL;
2492   tree args = NULL_TREE;
2493   bool any_viable_p;
2494
2495   /* We represent conversion within a hierarchy using RVALUE_CONV and
2496      BASE_CONV, as specified by [over.best.ics]; these become plain
2497      constructor calls, as specified in [dcl.init].  */
2498   my_friendly_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2499                       || !DERIVED_FROM_P (totype, fromtype), 20011226);
2500
2501   if (IS_AGGR_TYPE (totype))
2502     ctors = lookup_fnfields (TYPE_BINFO (totype),
2503                              complete_ctor_identifier,
2504                              0);
2505
2506   if (IS_AGGR_TYPE (fromtype))
2507     conv_fns = lookup_conversions (fromtype);
2508
2509   candidates = 0;
2510   flags |= LOOKUP_NO_CONVERSION;
2511
2512   if (ctors)
2513     {
2514       tree t;
2515
2516       ctors = BASELINK_FUNCTIONS (ctors);
2517
2518       t = build_int_2 (0, 0);
2519       TREE_TYPE (t) = build_pointer_type (totype);
2520       args = build_tree_list (NULL_TREE, expr);
2521       /* We should never try to call the abstract or base constructor
2522          from here.  */
2523       my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2524                           && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),
2525                           20011226);
2526       args = tree_cons (NULL_TREE, t, args);
2527     }
2528   for (; ctors; ctors = OVL_NEXT (ctors))
2529     {
2530       tree ctor = OVL_CURRENT (ctors);
2531       if (DECL_NONCONVERTING_P (ctor))
2532         continue;
2533
2534       if (TREE_CODE (ctor) == TEMPLATE_DECL) 
2535         cand = add_template_candidate (&candidates, ctor, totype,
2536                                        NULL_TREE, args, NULL_TREE, 
2537                                        TYPE_BINFO (totype),
2538                                        TYPE_BINFO (totype),
2539                                        flags,
2540                                        DEDUCE_CALL);
2541       else 
2542         cand = add_function_candidate (&candidates, ctor, totype,
2543                                        args, TYPE_BINFO (totype), 
2544                                        TYPE_BINFO (totype),
2545                                        flags); 
2546
2547       if (cand)
2548         cand->second_conv = build_identity_conv (totype, NULL_TREE);
2549     }
2550
2551   if (conv_fns)
2552     args = build_tree_list (NULL_TREE, build_this (expr));
2553
2554   for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2555     {
2556       tree fns;
2557       tree conversion_path = TREE_PURPOSE (conv_fns);
2558       int convflags = LOOKUP_NO_CONVERSION;
2559
2560       /* If we are called to convert to a reference type, we are trying to
2561          find an lvalue binding, so don't even consider temporaries.  If
2562          we don't find an lvalue binding, the caller will try again to
2563          look for a temporary binding.  */
2564       if (TREE_CODE (totype) == REFERENCE_TYPE)
2565         convflags |= LOOKUP_NO_TEMP_BIND;
2566       
2567       for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2568         {
2569           tree fn = OVL_CURRENT (fns);
2570           
2571           /* [over.match.funcs] For conversion functions, the function
2572              is considered to be a member of the class of the implicit
2573              object argument for the purpose of defining the type of
2574              the implicit object parameter.
2575
2576              So we pass fromtype as CTYPE to add_*_candidate.  */
2577
2578           if (TREE_CODE (fn) == TEMPLATE_DECL)
2579             cand = add_template_candidate (&candidates, fn, fromtype, 
2580                                            NULL_TREE,
2581                                            args, totype, 
2582                                            TYPE_BINFO (fromtype), 
2583                                            conversion_path,
2584                                            flags,
2585                                            DEDUCE_CONV);
2586           else 
2587             cand = add_function_candidate (&candidates, fn, fromtype,
2588                                            args,
2589                                            TYPE_BINFO (fromtype),
2590                                            conversion_path,
2591                                            flags); 
2592
2593           if (cand)
2594             {
2595               conversion *ics
2596                 = implicit_conversion (totype, 
2597                                        TREE_TYPE (TREE_TYPE (cand->fn)),
2598                                        0, convflags);
2599
2600               cand->second_conv = ics;
2601               
2602               if (!ics)
2603                 cand->viable = 0;
2604               else if (candidates->viable == 1 && ics->bad_p)
2605                 cand->viable = -1;
2606             }
2607         }
2608     }
2609
2610   candidates = splice_viable (candidates, pedantic, &any_viable_p);
2611   if (!any_viable_p)
2612     return 0;
2613
2614   cand = tourney (candidates);
2615   if (cand == 0)
2616     {
2617       if (flags & LOOKUP_COMPLAIN)
2618         {
2619           error ("conversion from `%T' to `%T' is ambiguous",
2620                     fromtype, totype);
2621           print_z_candidates (candidates);
2622         }
2623
2624       cand = candidates;        /* any one will do */
2625       cand->second_conv = build_ambiguous_conv (totype, expr);
2626       cand->second_conv->user_conv_p = true;
2627       if (!any_strictly_viable (candidates))
2628         cand->second_conv->bad_p = true;
2629       /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2630          ambiguous conversion is no worse than another user-defined
2631          conversion.  */
2632
2633       return cand;
2634     }
2635
2636   /* Build the user conversion sequence.  */
2637   conv = build_conv
2638     (ck_user,
2639      (DECL_CONSTRUCTOR_P (cand->fn)
2640       ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2641      build_identity_conv (TREE_TYPE (expr), expr));
2642   conv->cand = cand;
2643
2644   /* Combine it with the second conversion sequence.  */
2645   cand->second_conv = merge_conversion_sequences (conv,
2646                                                   cand->second_conv);
2647
2648   if (cand->viable == -1)
2649     cand->second_conv->bad_p = true;
2650
2651   return cand;
2652 }
2653
2654 tree
2655 build_user_type_conversion (tree totype, tree expr, int flags)
2656 {
2657   struct z_candidate *cand
2658     = build_user_type_conversion_1 (totype, expr, flags);
2659
2660   if (cand)
2661     {
2662       if (cand->second_conv->kind == ck_ambig)
2663         return error_mark_node;
2664       return convert_from_reference (convert_like (cand->second_conv, expr));
2665     }
2666   return NULL_TREE;
2667 }
2668
2669 /* Do any initial processing on the arguments to a function call.  */
2670
2671 static tree
2672 resolve_args (tree args)
2673 {
2674   tree t;
2675   for (t = args; t; t = TREE_CHAIN (t))
2676     {
2677       tree arg = TREE_VALUE (t);
2678       
2679       if (arg == error_mark_node)
2680         return error_mark_node;
2681       else if (VOID_TYPE_P (TREE_TYPE (arg)))
2682         {
2683           error ("invalid use of void expression");
2684           return error_mark_node;
2685         }
2686       arg = convert_from_reference (arg);
2687       TREE_VALUE (t) = arg;
2688     }
2689   return args;
2690 }
2691
2692 /* Perform overload resolution on FN, which is called with the ARGS.
2693
2694    Return the candidate function selected by overload resolution, or
2695    NULL if the event that overload resolution failed.  In the case
2696    that overload resolution fails, *CANDIDATES will be the set of
2697    candidates considered, and ANY_VIABLE_P will be set to true or
2698    false to indicate whether or not any of the candidates were
2699    viable.  
2700
2701    The ARGS should already have gone through RESOLVE_ARGS before this
2702    function is called.  */
2703
2704 static struct z_candidate *
2705 perform_overload_resolution (tree fn, 
2706                              tree args, 
2707                              struct z_candidate **candidates,
2708                              bool *any_viable_p)
2709 {
2710   struct z_candidate *cand;
2711   tree explicit_targs = NULL_TREE;
2712   int template_only = 0;
2713
2714   *candidates = NULL;
2715   *any_viable_p = true;
2716
2717   /* Check FN and ARGS.  */
2718   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL 
2719                       || TREE_CODE (fn) == TEMPLATE_DECL
2720                       || TREE_CODE (fn) == OVERLOAD
2721                       || TREE_CODE (fn) == TEMPLATE_ID_EXPR,
2722                       20020712);
2723   my_friendly_assert (!args || TREE_CODE (args) == TREE_LIST,
2724                       20020712);
2725
2726   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2727     {
2728       explicit_targs = TREE_OPERAND (fn, 1);
2729       fn = TREE_OPERAND (fn, 0);
2730       template_only = 1;
2731     }
2732
2733   /* Add the various candidate functions.  */
2734   add_candidates (fn, args, explicit_targs, template_only,
2735                   /*conversion_path=*/NULL_TREE,
2736                   /*access_path=*/NULL_TREE,
2737                   LOOKUP_NORMAL,
2738                   candidates);
2739
2740   *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2741   if (!*any_viable_p)
2742     return NULL;
2743
2744   cand = tourney (*candidates);
2745   return cand;
2746 }
2747
2748 /* Return an expression for a call to FN (a namespace-scope function,
2749    or a static member function) with the ARGS.  */
2750       
2751 tree
2752 build_new_function_call (tree fn, tree args)
2753 {
2754   struct z_candidate *candidates, *cand;
2755   bool any_viable_p;
2756   void *p;
2757   tree result;
2758
2759   args = resolve_args (args);
2760   if (args == error_mark_node)
2761     return error_mark_node;
2762
2763   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
2764   p = conversion_obstack_alloc (0);
2765
2766   cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2767
2768   if (!cand)
2769     {
2770       if (!any_viable_p && candidates && ! candidates->next)
2771         return build_function_call (candidates->fn, args);
2772       if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2773         fn = TREE_OPERAND (fn, 0);
2774       if (!any_viable_p)
2775         error ("no matching function for call to `%D(%A)'",
2776                DECL_NAME (OVL_CURRENT (fn)), args);
2777       else
2778         error ("call of overloaded `%D(%A)' is ambiguous",
2779                DECL_NAME (OVL_CURRENT (fn)), args);
2780       if (candidates)
2781         print_z_candidates (candidates);
2782       result = error_mark_node;
2783     }
2784   else
2785     result = build_over_call (cand, LOOKUP_NORMAL);
2786
2787   /* Free all the conversions we allocated.  */
2788   obstack_free (&conversion_obstack, p);
2789
2790   return result;
2791 }
2792
2793 /* Build a call to a global operator new.  FNNAME is the name of the
2794    operator (either "operator new" or "operator new[]") and ARGS are
2795    the arguments provided.  *SIZE points to the total number of bytes
2796    required by the allocation, and is updated if that is changed here.
2797    *COOKIE_SIZE is non-NULL if a cookie should be used.  If this
2798    function determines that no cookie should be used, after all,
2799    *COOKIE_SIZE is set to NULL_TREE.  */
2800
2801 tree
2802 build_operator_new_call (tree fnname, tree args, tree *size, tree *cookie_size)
2803 {
2804   tree fns;
2805   struct z_candidate *candidates;
2806   struct z_candidate *cand;
2807   bool any_viable_p;
2808
2809   args = tree_cons (NULL_TREE, *size, args);
2810   args = resolve_args (args);
2811   if (args == error_mark_node)
2812     return args;
2813
2814   fns = lookup_function_nonclass (fnname, args);
2815
2816   /* Figure out what function is being called.  */
2817   cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2818   
2819   /* If no suitable function could be found, issue an error message
2820      and give up.  */
2821   if (!cand)
2822     {
2823       if (!any_viable_p)
2824         error ("no matching function for call to `%D(%A)'",
2825                DECL_NAME (OVL_CURRENT (fns)), args);
2826       else
2827         error ("call of overloaded `%D(%A)' is ambiguous",
2828                DECL_NAME (OVL_CURRENT (fns)), args);
2829       if (candidates)
2830         print_z_candidates (candidates);
2831       return error_mark_node;
2832     }
2833
2834    /* If a cookie is required, add some extra space.  Whether
2835       or not a cookie is required cannot be determined until
2836       after we know which function was called.  */
2837    if (*cookie_size)
2838      {
2839        bool use_cookie = true;
2840        if (!abi_version_at_least (2))
2841          {
2842            tree placement = TREE_CHAIN (args);
2843            /* In G++ 3.2, the check was implemented incorrectly; it
2844               looked at the placement expression, rather than the
2845               type of the function.  */
2846            if (placement && !TREE_CHAIN (placement)
2847                && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2848                                ptr_type_node))
2849              use_cookie = false;
2850          }
2851        else
2852          {
2853            tree arg_types;
2854
2855            arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2856            /* Skip the size_t parameter.  */
2857            arg_types = TREE_CHAIN (arg_types);
2858            /* Check the remaining parameters (if any).  */
2859            if (arg_types 
2860                && TREE_CHAIN (arg_types) == void_list_node
2861                && same_type_p (TREE_VALUE (arg_types),
2862                                ptr_type_node))
2863              use_cookie = false;
2864          }
2865        /* If we need a cookie, adjust the number of bytes allocated.  */
2866        if (use_cookie)
2867          {
2868            /* Update the total size.  */
2869            *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2870            /* Update the argument list to reflect the adjusted size.  */
2871            TREE_VALUE (args) = *size;
2872          }
2873        else
2874          *cookie_size = NULL_TREE;
2875      }
2876
2877    /* Build the CALL_EXPR.  */
2878    return build_over_call (cand, LOOKUP_NORMAL);
2879 }
2880
2881 static tree
2882 build_object_call (tree obj, tree args)
2883 {
2884   struct z_candidate *candidates = 0, *cand;
2885   tree fns, convs, mem_args = NULL_TREE;
2886   tree type = TREE_TYPE (obj);
2887   bool any_viable_p;
2888   tree result = NULL_TREE;
2889   void *p;
2890
2891   if (TYPE_PTRMEMFUNC_P (type))
2892     {
2893       /* It's no good looking for an overloaded operator() on a
2894          pointer-to-member-function.  */
2895       error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2896       return error_mark_node;
2897     }
2898
2899   fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2900   if (fns == error_mark_node)
2901     return error_mark_node;
2902
2903   args = resolve_args (args);
2904
2905   if (args == error_mark_node)
2906     return error_mark_node;
2907
2908   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
2909   p = conversion_obstack_alloc (0);
2910
2911   if (fns)
2912     {
2913       tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2914       mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2915
2916       for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2917         {
2918           tree fn = OVL_CURRENT (fns);
2919           if (TREE_CODE (fn) == TEMPLATE_DECL)
2920             add_template_candidate (&candidates, fn, base, NULL_TREE,
2921                                     mem_args, NULL_TREE, 
2922                                     TYPE_BINFO (type),
2923                                     TYPE_BINFO (type),
2924                                     LOOKUP_NORMAL, DEDUCE_CALL);
2925           else
2926             add_function_candidate
2927               (&candidates, fn, base, mem_args, TYPE_BINFO (type),
2928                TYPE_BINFO (type), LOOKUP_NORMAL);
2929         }
2930     }
2931
2932   convs = lookup_conversions (type);
2933
2934   for (; convs; convs = TREE_CHAIN (convs))
2935     {
2936       tree fns = TREE_VALUE (convs);
2937       tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
2938
2939       if ((TREE_CODE (totype) == POINTER_TYPE
2940            && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2941           || (TREE_CODE (totype) == REFERENCE_TYPE
2942               && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
2943           || (TREE_CODE (totype) == REFERENCE_TYPE
2944               && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
2945               && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
2946         for (; fns; fns = OVL_NEXT (fns))
2947           {
2948             tree fn = OVL_CURRENT (fns);
2949             if (TREE_CODE (fn) == TEMPLATE_DECL) 
2950               add_template_conv_candidate 
2951                 (&candidates, fn, obj, args, totype,
2952                  /*access_path=*/NULL_TREE,
2953                  /*conversion_path=*/NULL_TREE);
2954             else
2955               add_conv_candidate (&candidates, fn, obj, args,
2956                                   /*conversion_path=*/NULL_TREE,
2957                                   /*access_path=*/NULL_TREE);
2958           }
2959     }
2960
2961   candidates = splice_viable (candidates, pedantic, &any_viable_p);
2962   if (!any_viable_p)
2963     {
2964       error ("no match for call to `(%T) (%A)'", TREE_TYPE (obj), args);
2965       print_z_candidates (candidates);
2966       result = error_mark_node;
2967     }
2968   else
2969     {
2970       cand = tourney (candidates);
2971       if (cand == 0)
2972         {
2973           error ("call of `(%T) (%A)' is ambiguous", TREE_TYPE (obj), args);
2974           print_z_candidates (candidates);
2975           result = error_mark_node;
2976         }
2977       /* Since cand->fn will be a type, not a function, for a conversion
2978          function, we must be careful not to unconditionally look at
2979          DECL_NAME here.  */
2980       else if (TREE_CODE (cand->fn) == FUNCTION_DECL
2981                && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
2982         result = build_over_call (cand, LOOKUP_NORMAL);
2983       else
2984         {
2985           obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
2986           result = build_function_call (obj, args);
2987         }
2988     }
2989
2990   /* Free all the conversions we allocated.  */
2991   obstack_free (&conversion_obstack, p);
2992
2993   return result;
2994 }
2995
2996 static void
2997 op_error (enum tree_code code, enum tree_code code2,
2998           tree arg1, tree arg2, tree arg3, const char *problem)
2999 {
3000   const char *opname;
3001
3002   if (code == MODIFY_EXPR)
3003     opname = assignment_operator_name_info[code2].name;
3004   else
3005     opname = operator_name_info[code].name;
3006
3007   switch (code)
3008     {
3009     case COND_EXPR:
3010       error ("%s for ternary 'operator?:' in '%E ? %E : %E'",
3011              problem, arg1, arg2, arg3);
3012       break;
3013       
3014     case POSTINCREMENT_EXPR:
3015     case POSTDECREMENT_EXPR:
3016       error ("%s for 'operator%s' in '%E%s'", problem, opname, arg1, opname);
3017       break;
3018       
3019     case ARRAY_REF:
3020       error ("%s for 'operator[]' in '%E[%E]'", problem, arg1, arg2);
3021       break;
3022
3023     case REALPART_EXPR:
3024     case IMAGPART_EXPR:
3025       error ("%s for '%s' in '%s %E'", problem, opname, opname, arg1);
3026       break;
3027       
3028     default:
3029       if (arg2)
3030         error ("%s for 'operator%s' in '%E %s %E'",
3031                problem, opname, arg1, opname, arg2);
3032       else
3033         error ("%s for 'operator%s' in '%s%E'",
3034                problem, opname, opname, arg1);
3035       break;
3036     }
3037 }
3038
3039 /* Return the implicit conversion sequence that could be used to
3040    convert E1 to E2 in [expr.cond].  */
3041
3042 static conversion *
3043 conditional_conversion (tree e1, tree e2)
3044 {
3045   tree t1 = non_reference (TREE_TYPE (e1));
3046   tree t2 = non_reference (TREE_TYPE (e2));
3047   conversion *conv;
3048   bool good_base;
3049
3050   /* [expr.cond]
3051
3052      If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3053      implicitly converted (clause _conv_) to the type "reference to
3054      T2", subject to the constraint that in the conversion the
3055      reference must bind directly (_dcl.init.ref_) to E1.  */
3056   if (real_lvalue_p (e2))
3057     {
3058       conv = implicit_conversion (build_reference_type (t2), 
3059                                   t1,
3060                                   e1,
3061                                   LOOKUP_NO_TEMP_BIND);
3062       if (conv)
3063         return conv;
3064     }
3065
3066   /* [expr.cond]
3067
3068      If E1 and E2 have class type, and the underlying class types are
3069      the same or one is a base class of the other: E1 can be converted
3070      to match E2 if the class of T2 is the same type as, or a base
3071      class of, the class of T1, and the cv-qualification of T2 is the
3072      same cv-qualification as, or a greater cv-qualification than, the
3073      cv-qualification of T1.  If the conversion is applied, E1 is
3074      changed to an rvalue of type T2 that still refers to the original
3075      source class object (or the appropriate subobject thereof).  */
3076   if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3077       && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3078     {
3079       if (good_base && at_least_as_qualified_p (t2, t1))
3080         {
3081           conv = build_identity_conv (t1, e1);
3082           if (!same_type_p (TYPE_MAIN_VARIANT (t1), 
3083                             TYPE_MAIN_VARIANT (t2)))
3084             conv = build_conv (ck_base, t2, conv);
3085           else
3086             conv = build_conv (ck_rvalue, t2, conv);
3087           return conv;
3088         }
3089       else
3090         return NULL;
3091     }
3092   else
3093     /* [expr.cond]
3094
3095        Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3096        converted to the type that expression E2 would have if E2 were
3097        converted to an rvalue (or the type it has, if E2 is an rvalue).  */
3098     return implicit_conversion (t2, t1, e1, LOOKUP_NORMAL);
3099 }
3100
3101 /* Implement [expr.cond].  ARG1, ARG2, and ARG3 are the three
3102    arguments to the conditional expression.  */
3103
3104 tree
3105 build_conditional_expr (tree arg1, tree arg2, tree arg3)
3106 {
3107   tree arg2_type;
3108   tree arg3_type;
3109   tree result = NULL_TREE;
3110   tree result_type = NULL_TREE;
3111   bool lvalue_p = true;
3112   struct z_candidate *candidates = 0;
3113   struct z_candidate *cand;
3114   void *p;
3115
3116   /* As a G++ extension, the second argument to the conditional can be
3117      omitted.  (So that `a ? : c' is roughly equivalent to `a ? a :
3118      c'.)  If the second operand is omitted, make sure it is
3119      calculated only once.  */
3120   if (!arg2)
3121     {
3122       if (pedantic)
3123         pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3124
3125       /* Make sure that lvalues remain lvalues.  See g++.oliva/ext1.C.  */
3126       if (real_lvalue_p (arg1))
3127         arg2 = arg1 = stabilize_reference (arg1);
3128       else
3129         arg2 = arg1 = save_expr (arg1);
3130     }
3131
3132   /* [expr.cond]
3133   
3134      The first expr ession is implicitly converted to bool (clause
3135      _conv_).  */
3136   arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3137
3138   /* If something has already gone wrong, just pass that fact up the
3139      tree.  */
3140   if (error_operand_p (arg1)
3141       || error_operand_p (arg2)
3142       || error_operand_p (arg3))
3143     return error_mark_node;
3144
3145   /* [expr.cond]
3146
3147      If either the second or the third operand has type (possibly
3148      cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3149      array-to-pointer (_conv.array_), and function-to-pointer
3150      (_conv.func_) standard conversions are performed on the second
3151      and third operands.  */
3152   arg2_type = TREE_TYPE (arg2);
3153   arg3_type = TREE_TYPE (arg3);
3154   if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3155     {
3156       /* Do the conversions.  We don't these for `void' type arguments
3157          since it can't have any effect and since decay_conversion
3158          does not handle that case gracefully.  */
3159       if (!VOID_TYPE_P (arg2_type))
3160         arg2 = decay_conversion (arg2);
3161       if (!VOID_TYPE_P (arg3_type))
3162         arg3 = decay_conversion (arg3);
3163       arg2_type = TREE_TYPE (arg2);
3164       arg3_type = TREE_TYPE (arg3);
3165
3166       /* [expr.cond]
3167
3168          One of the following shall hold:
3169
3170          --The second or the third operand (but not both) is a
3171            throw-expression (_except.throw_); the result is of the
3172            type of the other and is an rvalue.
3173
3174          --Both the second and the third operands have type void; the
3175            result is of type void and is an rvalue.  
3176
3177          We must avoid calling force_rvalue for expressions of type
3178          "void" because it will complain that their value is being
3179          used.   */
3180       if (TREE_CODE (arg2) == THROW_EXPR 
3181           && TREE_CODE (arg3) != THROW_EXPR)
3182         {
3183           if (!VOID_TYPE_P (arg3_type))
3184             arg3 = force_rvalue (arg3);
3185           arg3_type = TREE_TYPE (arg3);
3186           result_type = arg3_type;
3187         }
3188       else if (TREE_CODE (arg2) != THROW_EXPR 
3189                && TREE_CODE (arg3) == THROW_EXPR)
3190         {
3191           if (!VOID_TYPE_P (arg2_type))
3192             arg2 = force_rvalue (arg2);
3193           arg2_type = TREE_TYPE (arg2);
3194           result_type = arg2_type;
3195         }
3196       else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3197         result_type = void_type_node;
3198       else
3199         {
3200           error ("`%E' has type `void' and is not a throw-expression",
3201                     VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3202           return error_mark_node;
3203         }
3204
3205       lvalue_p = false;
3206       goto valid_operands;
3207     }
3208   /* [expr.cond]
3209
3210      Otherwise, if the second and third operand have different types,
3211      and either has (possibly cv-qualified) class type, an attempt is
3212      made to convert each of those operands to the type of the other.  */
3213   else if (!same_type_p (arg2_type, arg3_type)
3214            && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3215     {
3216       conversion *conv2;
3217       conversion *conv3;
3218       
3219       /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3220       p = conversion_obstack_alloc (0);
3221
3222       conv2 = conditional_conversion (arg2, arg3);
3223       conv3 = conditional_conversion (arg3, arg2);
3224
3225       /* [expr.cond]
3226
3227          If both can be converted, or one can be converted but the
3228          conversion is ambiguous, the program is ill-formed.  If
3229          neither can be converted, the operands are left unchanged and
3230          further checking is performed as described below.  If exactly
3231          one conversion is possible, that conversion is applied to the
3232          chosen operand and the converted operand is used in place of
3233          the original operand for the remainder of this section.  */
3234       if ((conv2 && !conv2->bad_p
3235            && conv3 && !conv3->bad_p)
3236           || (conv2 && conv2->kind == ck_ambig)
3237           || (conv3 && conv3->kind == ck_ambig))
3238         {
3239           error ("operands to ?: have different types");
3240           result = error_mark_node;
3241         }
3242       else if (conv2 && !conv2->bad_p)
3243         {
3244           arg2 = convert_like (conv2, arg2);
3245           arg2 = convert_from_reference (arg2);
3246           arg2_type = TREE_TYPE (arg2);
3247         }
3248       else if (conv3 && !conv3->bad_p)
3249         {
3250           arg3 = convert_like (conv3, arg3);
3251           arg3 = convert_from_reference (arg3);
3252           arg3_type = TREE_TYPE (arg3);
3253         }
3254
3255       /* Free all the conversions we allocated.  */
3256       obstack_free (&conversion_obstack, p);
3257
3258       if (result)
3259         return result;
3260
3261       /* If, after the conversion, both operands have class type,
3262          treat the cv-qualification of both operands as if it were the
3263          union of the cv-qualification of the operands.  
3264
3265          The standard is not clear about what to do in this
3266          circumstance.  For example, if the first operand has type
3267          "const X" and the second operand has a user-defined
3268          conversion to "volatile X", what is the type of the second
3269          operand after this step?  Making it be "const X" (matching
3270          the first operand) seems wrong, as that discards the
3271          qualification without actually performing a copy.  Leaving it
3272          as "volatile X" seems wrong as that will result in the
3273          conditional expression failing altogether, even though,
3274          according to this step, the one operand could be converted to
3275          the type of the other.  */
3276       if ((conv2 || conv3)
3277           && CLASS_TYPE_P (arg2_type)
3278           && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3279         arg2_type = arg3_type = 
3280           cp_build_qualified_type (arg2_type,
3281                                    TYPE_QUALS (arg2_type)
3282                                    | TYPE_QUALS (arg3_type));
3283     }
3284
3285   /* [expr.cond]
3286
3287      If the second and third operands are lvalues and have the same
3288      type, the result is of that type and is an lvalue.  */
3289   if (real_lvalue_p (arg2) 
3290       && real_lvalue_p (arg3) 
3291       && same_type_p (arg2_type, arg3_type))
3292     {
3293       result_type = arg2_type;
3294       goto valid_operands;
3295     }
3296
3297   /* [expr.cond]
3298
3299      Otherwise, the result is an rvalue.  If the second and third
3300      operand do not have the same type, and either has (possibly
3301      cv-qualified) class type, overload resolution is used to
3302      determine the conversions (if any) to be applied to the operands
3303      (_over.match.oper_, _over.built_).  */
3304   lvalue_p = false;
3305   if (!same_type_p (arg2_type, arg3_type)
3306       && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3307     {
3308       tree args[3];
3309       conversion *conv;
3310       bool any_viable_p;
3311
3312       /* Rearrange the arguments so that add_builtin_candidate only has
3313          to know about two args.  In build_builtin_candidates, the
3314          arguments are unscrambled.  */
3315       args[0] = arg2;
3316       args[1] = arg3;
3317       args[2] = arg1;
3318       add_builtin_candidates (&candidates, 
3319                               COND_EXPR, 
3320                               NOP_EXPR,
3321                               ansi_opname (COND_EXPR),
3322                               args,
3323                               LOOKUP_NORMAL);
3324
3325       /* [expr.cond]
3326
3327          If the overload resolution fails, the program is
3328          ill-formed.  */
3329       candidates = splice_viable (candidates, pedantic, &any_viable_p);
3330       if (!any_viable_p)
3331         {
3332           op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3333           print_z_candidates (candidates);
3334           return error_mark_node;
3335         }
3336       cand = tourney (candidates);
3337       if (!cand)
3338         {
3339           op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3340           print_z_candidates (candidates);
3341           return error_mark_node;
3342         }
3343
3344       /* [expr.cond]
3345
3346          Otherwise, the conversions thus determined are applied, and
3347          the converted operands are used in place of the original
3348          operands for the remainder of this section.  */
3349       conv = cand->convs[0];
3350       arg1 = convert_like (conv, arg1);
3351       conv = cand->convs[1];
3352       arg2 = convert_like (conv, arg2);
3353       conv = cand->convs[2];
3354       arg3 = convert_like (conv, arg3);
3355     }
3356
3357   /* [expr.cond]
3358
3359      Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3360      and function-to-pointer (_conv.func_) standard conversions are
3361      performed on the second and third operands.
3362
3363      We need to force the lvalue-to-rvalue conversion here for class types,
3364      so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3365      that isn't wrapped with a TARGET_EXPR plays havoc with exception
3366      regions.  */
3367
3368   arg2 = force_rvalue (arg2);
3369   if (!CLASS_TYPE_P (arg2_type))
3370     arg2_type = TREE_TYPE (arg2);
3371
3372   arg3 = force_rvalue (arg3);
3373   if (!CLASS_TYPE_P (arg2_type))
3374     arg3_type = TREE_TYPE (arg3);
3375
3376   if (arg2 == error_mark_node || arg3 == error_mark_node)
3377     return error_mark_node;
3378   
3379   /* [expr.cond]
3380      
3381      After those conversions, one of the following shall hold:
3382
3383      --The second and third operands have the same type; the result  is  of
3384        that type.  */
3385   if (same_type_p (arg2_type, arg3_type))
3386     result_type = arg2_type;
3387   /* [expr.cond]
3388
3389      --The second and third operands have arithmetic or enumeration
3390        type; the usual arithmetic conversions are performed to bring
3391        them to a common type, and the result is of that type.  */
3392   else if ((ARITHMETIC_TYPE_P (arg2_type) 
3393             || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3394            && (ARITHMETIC_TYPE_P (arg3_type)
3395                || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3396     {
3397       /* In this case, there is always a common type.  */
3398       result_type = type_after_usual_arithmetic_conversions (arg2_type, 
3399                                                              arg3_type);
3400       
3401       if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3402           && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3403          warning ("enumeral mismatch in conditional expression: `%T' vs `%T'",
3404                    arg2_type, arg3_type);
3405       else if (extra_warnings
3406                && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3407                     && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3408                    || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3409                        && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3410         warning ("enumeral and non-enumeral type in conditional expression");
3411       
3412       arg2 = perform_implicit_conversion (result_type, arg2);
3413       arg3 = perform_implicit_conversion (result_type, arg3);
3414     }
3415   /* [expr.cond]
3416
3417      --The second and third operands have pointer type, or one has
3418        pointer type and the other is a null pointer constant; pointer
3419        conversions (_conv.ptr_) and qualification conversions
3420        (_conv.qual_) are performed to bring them to their composite
3421        pointer type (_expr.rel_).  The result is of the composite
3422        pointer type.
3423
3424      --The second and third operands have pointer to member type, or
3425        one has pointer to member type and the other is a null pointer
3426        constant; pointer to member conversions (_conv.mem_) and
3427        qualification conversions (_conv.qual_) are performed to bring
3428        them to a common type, whose cv-qualification shall match the
3429        cv-qualification of either the second or the third operand.
3430        The result is of the common type.  */
3431   else if ((null_ptr_cst_p (arg2) 
3432             && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3433            || (null_ptr_cst_p (arg3) 
3434                && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3435            || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3436            || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3437            || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3438     {
3439       result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3440                                             arg3, "conditional expression");
3441       if (result_type == error_mark_node)
3442         return error_mark_node;
3443       arg2 = perform_implicit_conversion (result_type, arg2);
3444       arg3 = perform_implicit_conversion (result_type, arg3);
3445     }
3446
3447   if (!result_type)
3448     {
3449       error ("operands to ?: have different types");
3450       return error_mark_node;
3451     }
3452
3453  valid_operands:
3454   result = fold (build (COND_EXPR, result_type, arg1, arg2, arg3));
3455   /* We can't use result_type below, as fold might have returned a
3456      throw_expr.  */
3457
3458   /* Expand both sides into the same slot, hopefully the target of the
3459      ?: expression.  We used to check for TARGET_EXPRs here, but now we
3460      sometimes wrap them in NOP_EXPRs so the test would fail.  */
3461   if (!lvalue_p && CLASS_TYPE_P (TREE_TYPE (result)))
3462     result = get_target_expr (result);
3463   
3464   /* If this expression is an rvalue, but might be mistaken for an
3465      lvalue, we must add a NON_LVALUE_EXPR.  */
3466   if (!lvalue_p && real_lvalue_p (result))
3467     result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
3468
3469   return result;
3470 }
3471
3472 /* OPERAND is an operand to an expression.  Perform necessary steps
3473    required before using it.  If OPERAND is NULL_TREE, NULL_TREE is
3474    returned.  */
3475
3476 static tree
3477 prep_operand (tree operand)
3478 {
3479   if (operand)
3480     {
3481       operand = convert_from_reference (operand);
3482       if (CLASS_TYPE_P (TREE_TYPE (operand))
3483           && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3484         /* Make sure the template type is instantiated now.  */
3485         instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3486     }
3487
3488   return operand;
3489 }
3490
3491 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3492    OVERLOAD) to the CANDIDATES, returning an updated list of
3493    CANDIDATES.  The ARGS are the arguments provided to the call,
3494    without any implicit object parameter.  The EXPLICIT_TARGS are
3495    explicit template arguments provided.  TEMPLATE_ONLY is true if
3496    only template functions should be considered.  CONVERSION_PATH,
3497    ACCESS_PATH, and FLAGS are as for add_function_candidate.  */
3498
3499 static void
3500 add_candidates (tree fns, tree args, 
3501                 tree explicit_targs, bool template_only,
3502                 tree conversion_path, tree access_path,
3503                 int flags,
3504                 struct z_candidate **candidates)
3505 {
3506   tree ctype;
3507   tree non_static_args;
3508
3509   ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3510   /* Delay creating the implicit this parameter until it is needed.  */
3511   non_static_args = NULL_TREE;
3512
3513   while (fns) 
3514     {
3515       tree fn;
3516       tree fn_args;
3517
3518       fn = OVL_CURRENT (fns);
3519       /* Figure out which set of arguments to use.  */
3520       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3521         {
3522           /* If this function is a non-static member, prepend the implicit
3523              object parameter.  */
3524           if (!non_static_args)
3525             non_static_args = tree_cons (NULL_TREE,
3526                                          build_this (TREE_VALUE (args)),
3527                                          TREE_CHAIN (args));
3528           fn_args = non_static_args;
3529         }
3530       else
3531         /* Otherwise, just use the list of arguments provided.  */
3532         fn_args = args;
3533
3534       if (TREE_CODE (fn) == TEMPLATE_DECL)
3535         add_template_candidate (candidates, 
3536                                 fn, 
3537                                 ctype,
3538                                 explicit_targs,
3539                                 fn_args,
3540                                 NULL_TREE,
3541                                 access_path,
3542                                 conversion_path,
3543                                 flags,
3544                                 DEDUCE_CALL);
3545       else if (!template_only)
3546         add_function_candidate (candidates,
3547                                 fn,
3548                                 ctype,
3549                                 fn_args,
3550                                 access_path,
3551                                 conversion_path,
3552                                 flags);
3553       fns = OVL_NEXT (fns);
3554     }
3555 }
3556
3557 tree
3558 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3559               bool *overloaded_p)
3560 {
3561   struct z_candidate *candidates = 0, *cand;
3562   tree arglist, fnname;
3563   tree args[3];
3564   tree result = NULL_TREE;
3565   bool result_valid_p = false;
3566   enum tree_code code2 = NOP_EXPR;
3567   conversion *conv;
3568   void *p;
3569   bool strict_p;
3570   bool any_viable_p;
3571
3572   if (error_operand_p (arg1) 
3573       || error_operand_p (arg2) 
3574       || error_operand_p (arg3))
3575     return error_mark_node;
3576
3577   if (code == MODIFY_EXPR)
3578     {
3579       code2 = TREE_CODE (arg3);
3580       arg3 = NULL_TREE;
3581       fnname = ansi_assopname (code2);
3582     }
3583   else
3584     fnname = ansi_opname (code);
3585
3586   arg1 = prep_operand (arg1);
3587   
3588   switch (code)
3589     {
3590     case NEW_EXPR:
3591     case VEC_NEW_EXPR:
3592     case VEC_DELETE_EXPR:
3593     case DELETE_EXPR:
3594       /* Use build_op_new_call and build_op_delete_call instead.  */
3595       abort ();
3596
3597     case CALL_EXPR:
3598       return build_object_call (arg1, arg2);
3599
3600     default:
3601       break;
3602     }
3603
3604   arg2 = prep_operand (arg2);
3605   arg3 = prep_operand (arg3);
3606   
3607   if (code == COND_EXPR)
3608     {
3609       if (arg2 == NULL_TREE
3610           || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3611           || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3612           || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3613               && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3614         goto builtin;
3615     }
3616   else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3617            && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3618     goto builtin;
3619
3620   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3621     arg2 = integer_zero_node;
3622
3623   arglist = NULL_TREE;
3624   if (arg3)
3625     arglist = tree_cons (NULL_TREE, arg3, arglist);
3626   if (arg2)
3627     arglist = tree_cons (NULL_TREE, arg2, arglist);
3628   arglist = tree_cons (NULL_TREE, arg1, arglist);
3629
3630   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3631   p = conversion_obstack_alloc (0);
3632
3633   /* Add namespace-scope operators to the list of functions to
3634      consider.  */
3635   add_candidates (lookup_function_nonclass (fnname, arglist),
3636                   arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3637                   flags, &candidates);
3638   /* Add class-member operators to the candidate set.  */
3639   if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3640     {
3641       tree fns;
3642
3643       fns = lookup_fnfields (TYPE_BINFO (TREE_TYPE (arg1)), fnname, 1);
3644       if (fns == error_mark_node)
3645         {
3646           result = error_mark_node;
3647           goto user_defined_result_ready;
3648         }
3649       if (fns)
3650         add_candidates (BASELINK_FUNCTIONS (fns), arglist, 
3651                         NULL_TREE, false,
3652                         BASELINK_BINFO (fns),
3653                         TYPE_BINFO (TREE_TYPE (arg1)),
3654                         flags, &candidates);
3655     }
3656
3657   /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3658      to know about two args; a builtin candidate will always have a first
3659      parameter of type bool.  We'll handle that in
3660      build_builtin_candidate.  */
3661   if (code == COND_EXPR)
3662     {
3663       args[0] = arg2;
3664       args[1] = arg3;
3665       args[2] = arg1;
3666     }
3667   else
3668     {
3669       args[0] = arg1;
3670       args[1] = arg2;
3671       args[2] = NULL_TREE;
3672     }
3673
3674   add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3675
3676   switch (code)
3677     {
3678     case COMPOUND_EXPR:
3679     case ADDR_EXPR:
3680       /* For these, the built-in candidates set is empty
3681          [over.match.oper]/3.  We don't want non-strict matches
3682          because exact matches are always possible with built-in
3683          operators.  The built-in candidate set for COMPONENT_REF
3684          would be empty too, but since there are no such built-in
3685          operators, we accept non-strict matches for them.  */
3686       strict_p = true;
3687       break;
3688
3689     default:
3690       strict_p = pedantic;
3691       break;
3692     }      
3693
3694   candidates = splice_viable (candidates, strict_p, &any_viable_p);
3695   if (!any_viable_p)
3696     {
3697       switch (code)
3698         {
3699         case POSTINCREMENT_EXPR:
3700         case POSTDECREMENT_EXPR:
3701           /* Look for an `operator++ (int)'.  If they didn't have
3702              one, then we fall back to the old way of doing things.  */
3703           if (flags & LOOKUP_COMPLAIN)
3704             pedwarn ("no `%D(int)' declared for postfix `%s', trying prefix operator instead",
3705                         fnname, 
3706                         operator_name_info[code].name);
3707           if (code == POSTINCREMENT_EXPR)
3708             code = PREINCREMENT_EXPR;
3709           else
3710             code = PREDECREMENT_EXPR;   
3711           result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3712                                  overloaded_p);
3713           break;
3714
3715           /* The caller will deal with these.  */
3716         case ADDR_EXPR:
3717         case COMPOUND_EXPR:
3718         case COMPONENT_REF:
3719           result = NULL_TREE;
3720           result_valid_p = true;
3721           break;
3722
3723         default:
3724           if (flags & LOOKUP_COMPLAIN)
3725             {
3726               op_error (code, code2, arg1, arg2, arg3, "no match");
3727               print_z_candidates (candidates);
3728             }
3729           result = error_mark_node;
3730           break;
3731         }
3732     }
3733   else
3734     {
3735       cand = tourney (candidates);
3736       if (cand == 0)
3737         {
3738           if (flags & LOOKUP_COMPLAIN)
3739             {
3740               op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3741               print_z_candidates (candidates);
3742             }
3743           result = error_mark_node;
3744         }
3745       else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3746         {
3747           if (overloaded_p)
3748             *overloaded_p = true;
3749
3750           if (warn_synth
3751               && fnname == ansi_assopname (NOP_EXPR)
3752               && DECL_ARTIFICIAL (cand->fn)
3753               && candidates->next
3754               && ! candidates->next->next)
3755             {
3756               warning ("using synthesized `%#D' for copy assignment",
3757                           cand->fn);
3758               cp_warning_at ("  where cfront would use `%#D'",
3759                              cand == candidates
3760                              ? candidates->next->fn
3761                              : candidates->fn);
3762             }
3763
3764           result = build_over_call (cand, LOOKUP_NORMAL);
3765         }
3766       else
3767         {
3768           /* Check for comparison of different enum types.  */
3769           switch (code)
3770             {
3771             case GT_EXPR:
3772             case LT_EXPR:
3773             case GE_EXPR:
3774             case LE_EXPR:
3775             case EQ_EXPR:
3776             case NE_EXPR:
3777               if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE 
3778                   && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE 
3779                   && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3780                       != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3781                 {
3782                   warning ("comparison between `%#T' and `%#T'", 
3783                               TREE_TYPE (arg1), TREE_TYPE (arg2));
3784                 }
3785               break;
3786             default:
3787               break;
3788             }
3789
3790           /* We need to strip any leading REF_BIND so that bitfields
3791              don't cause errors.  This should not remove any important
3792              conversions, because builtins don't apply to class
3793              objects directly.  */
3794           conv = cand->convs[0];
3795           if (conv->kind == ck_ref_bind)
3796             conv = conv->u.next;
3797           arg1 = convert_like (conv, arg1);
3798           if (arg2)
3799             {
3800               conv = cand->convs[1];
3801               if (conv->kind == ck_ref_bind)
3802                 conv = conv->u.next;
3803               arg2 = convert_like (conv, arg2);
3804             }
3805           if (arg3)
3806             {
3807               conv = cand->convs[2];
3808               if (conv->kind == ck_ref_bind)
3809                 conv = conv->u.next;
3810               arg3 = convert_like (conv, arg3);
3811             }
3812         }
3813     }
3814
3815  user_defined_result_ready:
3816
3817   /* Free all the conversions we allocated.  */
3818   obstack_free (&conversion_obstack, p);
3819
3820   if (result || result_valid_p)
3821     return result;
3822
3823 builtin:
3824   switch (code)
3825     {
3826     case MODIFY_EXPR:
3827       return build_modify_expr (arg1, code2, arg2);
3828
3829     case INDIRECT_REF:
3830       return build_indirect_ref (arg1, "unary *");
3831
3832     case PLUS_EXPR:
3833     case MINUS_EXPR:
3834     case MULT_EXPR:
3835     case TRUNC_DIV_EXPR:
3836     case GT_EXPR:
3837     case LT_EXPR:
3838     case GE_EXPR:
3839     case LE_EXPR:
3840     case EQ_EXPR:
3841     case NE_EXPR:
3842     case MAX_EXPR:
3843     case MIN_EXPR:
3844     case LSHIFT_EXPR:
3845     case RSHIFT_EXPR:
3846     case TRUNC_MOD_EXPR:
3847     case BIT_AND_EXPR:
3848     case BIT_IOR_EXPR:
3849     case BIT_XOR_EXPR:
3850     case TRUTH_ANDIF_EXPR:
3851     case TRUTH_ORIF_EXPR:
3852       return cp_build_binary_op (code, arg1, arg2);
3853
3854     case CONVERT_EXPR:
3855     case NEGATE_EXPR:
3856     case BIT_NOT_EXPR:
3857     case TRUTH_NOT_EXPR:
3858     case PREINCREMENT_EXPR:
3859     case POSTINCREMENT_EXPR:
3860     case PREDECREMENT_EXPR:
3861     case POSTDECREMENT_EXPR:
3862     case REALPART_EXPR:
3863     case IMAGPART_EXPR:
3864       return build_unary_op (code, arg1, candidates != 0);
3865
3866     case ARRAY_REF:
3867       return build_array_ref (arg1, arg2);
3868
3869     case COND_EXPR:
3870       return build_conditional_expr (arg1, arg2, arg3);
3871
3872     case MEMBER_REF:
3873       return build_m_component_ref
3874         (build_indirect_ref (arg1, NULL), arg2);
3875
3876       /* The caller will deal with these.  */
3877     case ADDR_EXPR:
3878     case COMPONENT_REF:
3879     case COMPOUND_EXPR:
3880       return NULL_TREE;
3881
3882     default:
3883       abort ();
3884       return NULL_TREE;
3885     }
3886 }
3887
3888 /* Build a call to operator delete.  This has to be handled very specially,
3889    because the restrictions on what signatures match are different from all
3890    other call instances.  For a normal delete, only a delete taking (void *)
3891    or (void *, size_t) is accepted.  For a placement delete, only an exact
3892    match with the placement new is accepted.
3893
3894    CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3895    ADDR is the pointer to be deleted.
3896    SIZE is the size of the memory block to be deleted.
3897    GLOBAL_P is true if the delete-expression should not consider
3898    class-specific delete operators.
3899    PLACEMENT is the corresponding placement new call, or NULL_TREE.  */
3900
3901 tree
3902 build_op_delete_call (enum tree_code code, tree addr, tree size,
3903                       bool global_p, tree placement)
3904 {
3905   tree fn = NULL_TREE;
3906   tree fns, fnname, argtypes, args, type;
3907   int pass;
3908
3909   if (addr == error_mark_node)
3910     return error_mark_node;
3911
3912   type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
3913
3914   fnname = ansi_opname (code);
3915
3916   if (IS_AGGR_TYPE (type) && !global_p)
3917     /* In [class.free]
3918
3919        If the result of the lookup is ambiguous or inaccessible, or if
3920        the lookup selects a placement deallocation function, the
3921        program is ill-formed.
3922   
3923        Therefore, we ask lookup_fnfields to complain about ambiguity.  */
3924     {
3925       fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
3926       if (fns == error_mark_node)
3927         return error_mark_node;
3928     }
3929   else
3930     fns = NULL_TREE;
3931
3932   if (fns == NULL_TREE)
3933     fns = lookup_name_nonclass (fnname);
3934
3935   if (placement)
3936     {
3937       tree alloc_fn;
3938       tree call_expr;
3939
3940       /* Find the allocation function that is being called.  */
3941       call_expr = placement;
3942       /* Extract the function.  */
3943       alloc_fn = get_callee_fndecl (call_expr);
3944       my_friendly_assert (alloc_fn != NULL_TREE, 20020327);
3945       /* Then the second parm type.  */
3946       argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
3947       /* Also the second argument.  */
3948       args = TREE_CHAIN (TREE_OPERAND (call_expr, 1));
3949     }
3950   else
3951     {
3952       /* First try it without the size argument.  */
3953       argtypes = void_list_node;
3954       args = NULL_TREE;
3955     }
3956
3957   /* Strip const and volatile from addr.  */
3958   addr = cp_convert (ptr_type_node, addr);
3959
3960   /* We make two tries at finding a matching `operator delete'.  On
3961      the first pass, we look for a one-operator (or placement)
3962      operator delete.  If we're not doing placement delete, then on
3963      the second pass we look for a two-argument delete.  */
3964   for (pass = 0; pass < (placement ? 1 : 2); ++pass) 
3965     {
3966       /* Go through the `operator delete' functions looking for one
3967          with a matching type.  */
3968       for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns; 
3969            fn; 
3970            fn = OVL_NEXT (fn))
3971         {
3972           tree t;
3973
3974           /* The first argument must be "void *".  */
3975           t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
3976           if (!same_type_p (TREE_VALUE (t), ptr_type_node))
3977             continue;
3978           t = TREE_CHAIN (t);
3979           /* On the first pass, check the rest of the arguments.  */
3980           if (pass == 0)
3981             {
3982               tree a = argtypes;
3983               while (a && t)
3984                 {
3985                   if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
3986                     break;
3987                   a = TREE_CHAIN (a);
3988                   t = TREE_CHAIN (t);
3989                 }
3990               if (!a && !t)
3991                 break;
3992             }
3993           /* On the second pass, the second argument must be
3994              "size_t".  */
3995           else if (pass == 1
3996                    && same_type_p (TREE_VALUE (t), sizetype)
3997                    && TREE_CHAIN (t) == void_list_node)
3998             break;
3999         }
4000
4001       /* If we found a match, we're done.  */
4002       if (fn)
4003         break;
4004     }
4005
4006   /* If we have a matching function, call it.  */
4007   if (fn)
4008     {
4009       /* Make sure we have the actual function, and not an
4010          OVERLOAD.  */
4011       fn = OVL_CURRENT (fn);
4012
4013       /* If the FN is a member function, make sure that it is
4014          accessible.  */
4015       if (DECL_CLASS_SCOPE_P (fn))
4016         perform_or_defer_access_check (TYPE_BINFO (type), fn);
4017
4018       if (pass == 0)
4019         args = tree_cons (NULL_TREE, addr, args);
4020       else
4021         args = tree_cons (NULL_TREE, addr, 
4022                           build_tree_list (NULL_TREE, size));
4023
4024       if (placement)
4025         {
4026           /* The placement args might not be suitable for overload
4027              resolution at this point, so build the call directly.  */
4028           mark_used (fn);
4029           return build_cxx_call (fn, args, args);
4030         }
4031       else
4032         return build_function_call (fn, args);
4033     }
4034
4035   /* If we are doing placement delete we do nothing if we don't find a
4036      matching op delete.  */
4037   if (placement)
4038     return NULL_TREE;
4039
4040   error ("no suitable `operator %s' for `%T'",
4041          operator_name_info[(int)code].name, type);
4042   return error_mark_node;
4043 }
4044
4045 /* If the current scope isn't allowed to access DECL along
4046    BASETYPE_PATH, give an error.  The most derived class in
4047    BASETYPE_PATH is the one used to qualify DECL.  */
4048
4049 bool
4050 enforce_access (tree basetype_path, tree decl)
4051 {
4052   my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624);
4053   
4054   if (!accessible_p (basetype_path, decl))
4055     {
4056       if (TREE_PRIVATE (decl))
4057         cp_error_at ("`%+#D' is private", decl);
4058       else if (TREE_PROTECTED (decl))
4059         cp_error_at ("`%+#D' is protected", decl);
4060       else
4061         cp_error_at ("`%+#D' is inaccessible", decl);
4062       error ("within this context");
4063       return false;
4064     }
4065
4066   return true;
4067 }
4068
4069 /* Initialize a temporary of type TYPE with EXPR.  The FLAGS are a
4070    bitwise or of LOOKUP_* values.  If any errors are warnings are
4071    generated, set *DIAGNOSTIC_FN to "error" or "warning",
4072    respectively.  If no diagnostics are generated, set *DIAGNOSTIC_FN
4073    to NULL.  */
4074
4075 static tree
4076 build_temp (tree expr, tree type, int flags, 
4077             void (**diagnostic_fn)(const char *, ...))
4078 {
4079   int savew, savee;
4080
4081   savew = warningcount, savee = errorcount;
4082   expr = build_special_member_call (NULL_TREE, 
4083                                     complete_ctor_identifier,
4084                                     build_tree_list (NULL_TREE, expr), 
4085                                     TYPE_BINFO (type),
4086                                     flags);
4087   if (warningcount > savew)
4088     *diagnostic_fn = warning;
4089   else if (errorcount > savee)
4090     *diagnostic_fn = error;
4091   else
4092     *diagnostic_fn = NULL;
4093   return expr;
4094 }
4095             
4096
4097 /* Perform the conversions in CONVS on the expression EXPR.  FN and
4098    ARGNUM are used for diagnostics.  ARGNUM is zero based, -1
4099    indicates the `this' argument of a method.  INNER is nonzero when
4100    being called to continue a conversion chain. It is negative when a
4101    reference binding will be applied, positive otherwise.  If
4102    ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4103    conversions will be emitted if appropriate.  */
4104
4105 static tree
4106 convert_like_real (conversion *convs, tree expr, tree fn, int argnum, 
4107                    int inner, bool issue_conversion_warnings)
4108 {
4109   tree totype = convs->type;
4110   void (*diagnostic_fn)(const char *, ...);
4111
4112   if (convs->bad_p
4113       && convs->kind != ck_user
4114       && convs->kind != ck_ambig
4115       && convs->kind != ck_ref_bind)
4116     {
4117       conversion *t = convs;
4118       for (; t; t = convs->u.next)
4119         {
4120           if (t->kind == ck_user || !t->bad_p)
4121             {
4122               expr = convert_like_real (t, expr, fn, argnum, 1,
4123                                         /*issue_conversion_warnings=*/false);
4124               break;
4125             }
4126           else if (t->kind == ck_ambig)
4127             return convert_like_real (t, expr, fn, argnum, 1,
4128                                       /*issue_conversion_warnings=*/false);
4129           else if (t->kind == ck_identity)
4130             break;
4131         }
4132       pedwarn ("invalid conversion from `%T' to `%T'", TREE_TYPE (expr), totype);
4133       if (fn)
4134         pedwarn ("  initializing argument %P of `%D'", argnum, fn);
4135       return cp_convert (totype, expr);
4136     }
4137   
4138   if (issue_conversion_warnings)
4139     expr = dubious_conversion_warnings
4140              (totype, expr, "converting", fn, argnum);
4141   switch (convs->kind)
4142     {
4143     case ck_user:
4144       {
4145         struct z_candidate *cand = convs->cand;