OSDN Git Service

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