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