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