OSDN Git Service

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