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