OSDN Git Service

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