OSDN Git Service

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