Merge branch 'vendor/GCC47'
[dragonfly.git] / contrib / gcc-4.7 / 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 if (TREE_CODE (ftype) == REFERENCE_TYPE)
898         /* Value-initialization of reference is ill-formed.  */
899         return NULL;
900       else
901         {
902           if (empty_ctor == NULL_TREE)
903             empty_ctor = build_constructor (init_list_type_node, NULL);
904           val = empty_ctor;
905         }
906       ++i;
907
908       if (TREE_CODE (ftype) == ARRAY_TYPE
909           && TREE_CODE (val) == CONSTRUCTOR)
910         ok = can_convert_array (ftype, val, flags);
911       else
912         ok = can_convert_arg (ftype, TREE_TYPE (val), val, flags);
913
914       if (!ok)
915         return NULL;
916
917       if (TREE_CODE (type) == UNION_TYPE)
918         break;
919     }
920
921   if (i < CONSTRUCTOR_NELTS (ctor))
922     return NULL;
923
924   c = alloc_conversion (ck_aggr);
925   c->type = type;
926   c->rank = cr_exact;
927   c->user_conv_p = true;
928   c->u.next = NULL;
929   return c;
930 }
931
932 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
933    array type, if such a conversion is possible.  */
934
935 static conversion *
936 build_array_conv (tree type, tree ctor, int flags)
937 {
938   conversion *c;
939   unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
940   tree elttype = TREE_TYPE (type);
941   unsigned i;
942   tree val;
943   bool bad = false;
944   bool user = false;
945   enum conversion_rank rank = cr_exact;
946
947   if (TYPE_DOMAIN (type))
948     {
949       unsigned HOST_WIDE_INT alen = tree_low_cst (array_type_nelts_top (type), 1);
950       if (alen < len)
951         return NULL;
952     }
953
954   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
955     {
956       conversion *sub
957         = implicit_conversion (elttype, TREE_TYPE (val), val,
958                                false, flags);
959       if (sub == NULL)
960         return NULL;
961
962       if (sub->rank > rank)
963         rank = sub->rank;
964       if (sub->user_conv_p)
965         user = true;
966       if (sub->bad_p)
967         bad = true;
968     }
969
970   c = alloc_conversion (ck_aggr);
971   c->type = type;
972   c->rank = rank;
973   c->user_conv_p = user;
974   c->bad_p = bad;
975   c->u.next = NULL;
976   return c;
977 }
978
979 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
980    complex type, if such a conversion is possible.  */
981
982 static conversion *
983 build_complex_conv (tree type, tree ctor, int flags)
984 {
985   conversion *c;
986   unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
987   tree elttype = TREE_TYPE (type);
988   unsigned i;
989   tree val;
990   bool bad = false;
991   bool user = false;
992   enum conversion_rank rank = cr_exact;
993
994   if (len != 2)
995     return NULL;
996
997   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
998     {
999       conversion *sub
1000         = implicit_conversion (elttype, TREE_TYPE (val), val,
1001                                false, flags);
1002       if (sub == NULL)
1003         return NULL;
1004
1005       if (sub->rank > rank)
1006         rank = sub->rank;
1007       if (sub->user_conv_p)
1008         user = true;
1009       if (sub->bad_p)
1010         bad = true;
1011     }
1012
1013   c = alloc_conversion (ck_aggr);
1014   c->type = type;
1015   c->rank = rank;
1016   c->user_conv_p = user;
1017   c->bad_p = bad;
1018   c->u.next = NULL;
1019   return c;
1020 }
1021
1022 /* Build a representation of the identity conversion from EXPR to
1023    itself.  The TYPE should match the type of EXPR, if EXPR is non-NULL.  */
1024
1025 static conversion *
1026 build_identity_conv (tree type, tree expr)
1027 {
1028   conversion *c;
1029
1030   c = alloc_conversion (ck_identity);
1031   c->type = type;
1032   c->u.expr = expr;
1033
1034   return c;
1035 }
1036
1037 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1038    were multiple user-defined conversions to accomplish the job.
1039    Build a conversion that indicates that ambiguity.  */
1040
1041 static conversion *
1042 build_ambiguous_conv (tree type, tree expr)
1043 {
1044   conversion *c;
1045
1046   c = alloc_conversion (ck_ambig);
1047   c->type = type;
1048   c->u.expr = expr;
1049
1050   return c;
1051 }
1052
1053 tree
1054 strip_top_quals (tree t)
1055 {
1056   if (TREE_CODE (t) == ARRAY_TYPE)
1057     return t;
1058   return cp_build_qualified_type (t, 0);
1059 }
1060
1061 /* Returns the standard conversion path (see [conv]) from type FROM to type
1062    TO, if any.  For proper handling of null pointer constants, you must
1063    also pass the expression EXPR to convert from.  If C_CAST_P is true,
1064    this conversion is coming from a C-style cast.  */
1065
1066 static conversion *
1067 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
1068                      int flags)
1069 {
1070   enum tree_code fcode, tcode;
1071   conversion *conv;
1072   bool fromref = false;
1073   tree qualified_to;
1074
1075   to = non_reference (to);
1076   if (TREE_CODE (from) == REFERENCE_TYPE)
1077     {
1078       fromref = true;
1079       from = TREE_TYPE (from);
1080     }
1081   qualified_to = to;
1082   to = strip_top_quals (to);
1083   from = strip_top_quals (from);
1084
1085   if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
1086       && expr && type_unknown_p (expr))
1087     {
1088       tsubst_flags_t tflags = tf_conv;
1089       if (!(flags & LOOKUP_PROTECT))
1090         tflags |= tf_no_access_control;
1091       expr = instantiate_type (to, expr, tflags);
1092       if (expr == error_mark_node)
1093         return NULL;
1094       from = TREE_TYPE (expr);
1095     }
1096
1097   fcode = TREE_CODE (from);
1098   tcode = TREE_CODE (to);
1099
1100   conv = build_identity_conv (from, expr);
1101   if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
1102     {
1103       from = type_decays_to (from);
1104       fcode = TREE_CODE (from);
1105       conv = build_conv (ck_lvalue, from, conv);
1106     }
1107   else if (fromref || (expr && lvalue_p (expr)))
1108     {
1109       if (expr)
1110         {
1111           tree bitfield_type;
1112           bitfield_type = is_bitfield_expr_with_lowered_type (expr);
1113           if (bitfield_type)
1114             {
1115               from = strip_top_quals (bitfield_type);
1116               fcode = TREE_CODE (from);
1117             }
1118         }
1119       conv = build_conv (ck_rvalue, from, conv);
1120       if (flags & LOOKUP_PREFER_RVALUE)
1121         conv->rvaluedness_matches_p = true;
1122     }
1123
1124    /* Allow conversion between `__complex__' data types.  */
1125   if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
1126     {
1127       /* The standard conversion sequence to convert FROM to TO is
1128          the standard conversion sequence to perform componentwise
1129          conversion.  */
1130       conversion *part_conv = standard_conversion
1131         (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
1132
1133       if (part_conv)
1134         {
1135           conv = build_conv (part_conv->kind, to, conv);
1136           conv->rank = part_conv->rank;
1137         }
1138       else
1139         conv = NULL;
1140
1141       return conv;
1142     }
1143
1144   if (same_type_p (from, to))
1145     {
1146       if (CLASS_TYPE_P (to) && conv->kind == ck_rvalue)
1147         conv->type = qualified_to;
1148       return conv;
1149     }
1150
1151   /* [conv.ptr]
1152      A null pointer constant can be converted to a pointer type; ... A
1153      null pointer constant of integral type can be converted to an
1154      rvalue of type std::nullptr_t. */
1155   if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)
1156        || NULLPTR_TYPE_P (to))
1157       && expr && null_ptr_cst_p (expr))
1158     conv = build_conv (ck_std, to, conv);
1159   else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
1160            || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
1161     {
1162       /* For backwards brain damage compatibility, allow interconversion of
1163          pointers and integers with a pedwarn.  */
1164       conv = build_conv (ck_std, to, conv);
1165       conv->bad_p = true;
1166     }
1167   else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
1168     {
1169       /* For backwards brain damage compatibility, allow interconversion of
1170          enums and integers with a pedwarn.  */
1171       conv = build_conv (ck_std, to, conv);
1172       conv->bad_p = true;
1173     }
1174   else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
1175            || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
1176     {
1177       tree to_pointee;
1178       tree from_pointee;
1179
1180       if (tcode == POINTER_TYPE
1181           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
1182                                                         TREE_TYPE (to)))
1183         ;
1184       else if (VOID_TYPE_P (TREE_TYPE (to))
1185                && !TYPE_PTRMEM_P (from)
1186                && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
1187         {
1188           tree nfrom = TREE_TYPE (from);
1189           from = build_pointer_type
1190             (cp_build_qualified_type (void_type_node, 
1191                                       cp_type_quals (nfrom)));
1192           conv = build_conv (ck_ptr, from, conv);
1193         }
1194       else if (TYPE_PTRMEM_P (from))
1195         {
1196           tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
1197           tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
1198
1199           if (DERIVED_FROM_P (fbase, tbase)
1200               && (same_type_ignoring_top_level_qualifiers_p
1201                   (TYPE_PTRMEM_POINTED_TO_TYPE (from),
1202                    TYPE_PTRMEM_POINTED_TO_TYPE (to))))
1203             {
1204               from = build_ptrmem_type (tbase,
1205                                         TYPE_PTRMEM_POINTED_TO_TYPE (from));
1206               conv = build_conv (ck_pmem, from, conv);
1207             }
1208           else if (!same_type_p (fbase, tbase))
1209             return NULL;
1210         }
1211       else if (CLASS_TYPE_P (TREE_TYPE (from))
1212                && CLASS_TYPE_P (TREE_TYPE (to))
1213                /* [conv.ptr]
1214
1215                   An rvalue of type "pointer to cv D," where D is a
1216                   class type, can be converted to an rvalue of type
1217                   "pointer to cv B," where B is a base class (clause
1218                   _class.derived_) of D.  If B is an inaccessible
1219                   (clause _class.access_) or ambiguous
1220                   (_class.member.lookup_) base class of D, a program
1221                   that necessitates this conversion is ill-formed.
1222                   Therefore, we use DERIVED_FROM_P, and do not check
1223                   access or uniqueness.  */
1224                && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
1225         {
1226           from =
1227             cp_build_qualified_type (TREE_TYPE (to),
1228                                      cp_type_quals (TREE_TYPE (from)));
1229           from = build_pointer_type (from);
1230           conv = build_conv (ck_ptr, from, conv);
1231           conv->base_p = true;
1232         }
1233
1234       if (tcode == POINTER_TYPE)
1235         {
1236           to_pointee = TREE_TYPE (to);
1237           from_pointee = TREE_TYPE (from);
1238         }
1239       else
1240         {
1241           to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
1242           from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
1243         }
1244
1245       if (same_type_p (from, to))
1246         /* OK */;
1247       else if (c_cast_p && comp_ptr_ttypes_const (to, from))
1248         /* In a C-style cast, we ignore CV-qualification because we
1249            are allowed to perform a static_cast followed by a
1250            const_cast.  */
1251         conv = build_conv (ck_qual, to, conv);
1252       else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
1253         conv = build_conv (ck_qual, to, conv);
1254       else if (expr && string_conv_p (to, expr, 0))
1255         /* converting from string constant to char *.  */
1256         conv = build_conv (ck_qual, to, conv);
1257       /* Allow conversions among compatible ObjC pointer types (base
1258          conversions have been already handled above).  */
1259       else if (c_dialect_objc ()
1260                && objc_compare_types (to, from, -4, NULL_TREE))
1261         conv = build_conv (ck_ptr, to, conv);
1262       else if (ptr_reasonably_similar (to_pointee, from_pointee))
1263         {
1264           conv = build_conv (ck_ptr, to, conv);
1265           conv->bad_p = true;
1266         }
1267       else
1268         return NULL;
1269
1270       from = to;
1271     }
1272   else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
1273     {
1274       tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
1275       tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
1276       tree fbase = class_of_this_parm (fromfn);
1277       tree tbase = class_of_this_parm (tofn);
1278
1279       if (!DERIVED_FROM_P (fbase, tbase)
1280           || !same_type_p (static_fn_type (fromfn),
1281                            static_fn_type (tofn)))
1282         return NULL;
1283
1284       from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
1285       from = build_ptrmemfunc_type (build_pointer_type (from));
1286       conv = build_conv (ck_pmem, from, conv);
1287       conv->base_p = true;
1288     }
1289   else if (tcode == BOOLEAN_TYPE)
1290     {
1291       /* [conv.bool]
1292
1293           An rvalue of arithmetic, unscoped enumeration, pointer, or
1294           pointer to member type can be converted to an rvalue of type
1295           bool. ... An rvalue of type std::nullptr_t can be converted
1296           to an rvalue of type bool;  */
1297       if (ARITHMETIC_TYPE_P (from)
1298           || UNSCOPED_ENUM_P (from)
1299           || fcode == POINTER_TYPE
1300           || TYPE_PTR_TO_MEMBER_P (from)
1301           || NULLPTR_TYPE_P (from))
1302         {
1303           conv = build_conv (ck_std, to, conv);
1304           if (fcode == POINTER_TYPE
1305               || TYPE_PTRMEM_P (from)
1306               || (TYPE_PTRMEMFUNC_P (from)
1307                   && conv->rank < cr_pbool)
1308               || NULLPTR_TYPE_P (from))
1309             conv->rank = cr_pbool;
1310           return conv;
1311         }
1312
1313       return NULL;
1314     }
1315   /* We don't check for ENUMERAL_TYPE here because there are no standard
1316      conversions to enum type.  */
1317   /* As an extension, allow conversion to complex type.  */
1318   else if (ARITHMETIC_TYPE_P (to))
1319     {
1320       if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
1321           || SCOPED_ENUM_P (from))
1322         return NULL;
1323       conv = build_conv (ck_std, to, conv);
1324
1325       /* Give this a better rank if it's a promotion.  */
1326       if (same_type_p (to, type_promotes_to (from))
1327           && conv->u.next->rank <= cr_promotion)
1328         conv->rank = cr_promotion;
1329     }
1330   else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
1331            && vector_types_convertible_p (from, to, false))
1332     return build_conv (ck_std, to, conv);
1333   else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
1334            && is_properly_derived_from (from, to))
1335     {
1336       if (conv->kind == ck_rvalue)
1337         conv = conv->u.next;
1338       conv = build_conv (ck_base, to, conv);
1339       /* The derived-to-base conversion indicates the initialization
1340          of a parameter with base type from an object of a derived
1341          type.  A temporary object is created to hold the result of
1342          the conversion unless we're binding directly to a reference.  */
1343       conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
1344     }
1345   else
1346     return NULL;
1347
1348   if (flags & LOOKUP_NO_NARROWING)
1349     conv->check_narrowing = true;
1350
1351   return conv;
1352 }
1353
1354 /* Returns nonzero if T1 is reference-related to T2.  */
1355
1356 bool
1357 reference_related_p (tree t1, tree t2)
1358 {
1359   if (t1 == error_mark_node || t2 == error_mark_node)
1360     return false;
1361
1362   t1 = TYPE_MAIN_VARIANT (t1);
1363   t2 = TYPE_MAIN_VARIANT (t2);
1364
1365   /* [dcl.init.ref]
1366
1367      Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1368      to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1369      of T2.  */
1370   return (same_type_p (t1, t2)
1371           || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
1372               && DERIVED_FROM_P (t1, t2)));
1373 }
1374
1375 /* Returns nonzero if T1 is reference-compatible with T2.  */
1376
1377 static bool
1378 reference_compatible_p (tree t1, tree t2)
1379 {
1380   /* [dcl.init.ref]
1381
1382      "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1383      reference-related to T2 and cv1 is the same cv-qualification as,
1384      or greater cv-qualification than, cv2.  */
1385   return (reference_related_p (t1, t2)
1386           && at_least_as_qualified_p (t1, t2));
1387 }
1388
1389 /* A reference of the indicated TYPE is being bound directly to the
1390    expression represented by the implicit conversion sequence CONV.
1391    Return a conversion sequence for this binding.  */
1392
1393 static conversion *
1394 direct_reference_binding (tree type, conversion *conv)
1395 {
1396   tree t;
1397
1398   gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1399   gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1400
1401   t = TREE_TYPE (type);
1402
1403   /* [over.ics.rank]
1404
1405      When a parameter of reference type binds directly
1406      (_dcl.init.ref_) to an argument expression, the implicit
1407      conversion sequence is the identity conversion, unless the
1408      argument expression has a type that is a derived class of the
1409      parameter type, in which case the implicit conversion sequence is
1410      a derived-to-base Conversion.
1411
1412      If the parameter binds directly to the result of applying a
1413      conversion function to the argument expression, the implicit
1414      conversion sequence is a user-defined conversion sequence
1415      (_over.ics.user_), with the second standard conversion sequence
1416      either an identity conversion or, if the conversion function
1417      returns an entity of a type that is a derived class of the
1418      parameter type, a derived-to-base conversion.  */
1419   if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1420     {
1421       /* Represent the derived-to-base conversion.  */
1422       conv = build_conv (ck_base, t, conv);
1423       /* We will actually be binding to the base-class subobject in
1424          the derived class, so we mark this conversion appropriately.
1425          That way, convert_like knows not to generate a temporary.  */
1426       conv->need_temporary_p = false;
1427     }
1428   return build_conv (ck_ref_bind, type, conv);
1429 }
1430
1431 /* Returns the conversion path from type FROM to reference type TO for
1432    purposes of reference binding.  For lvalue binding, either pass a
1433    reference type to FROM or an lvalue expression to EXPR.  If the
1434    reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1435    the conversion returned.  If C_CAST_P is true, this
1436    conversion is coming from a C-style cast.  */
1437
1438 static conversion *
1439 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1440 {
1441   conversion *conv = NULL;
1442   tree to = TREE_TYPE (rto);
1443   tree from = rfrom;
1444   tree tfrom;
1445   bool related_p;
1446   bool compatible_p;
1447   cp_lvalue_kind gl_kind;
1448   bool is_lvalue;
1449
1450   if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1451     {
1452       expr = instantiate_type (to, expr, tf_none);
1453       if (expr == error_mark_node)
1454         return NULL;
1455       from = TREE_TYPE (expr);
1456     }
1457
1458   if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1459     {
1460       maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1461       conv = implicit_conversion (to, from, expr, c_cast_p,
1462                                   flags);
1463       if (!CLASS_TYPE_P (to)
1464           && CONSTRUCTOR_NELTS (expr) == 1)
1465         {
1466           expr = CONSTRUCTOR_ELT (expr, 0)->value;
1467           if (error_operand_p (expr))
1468             return NULL;
1469           from = TREE_TYPE (expr);
1470         }
1471     }
1472
1473   if (TREE_CODE (from) == REFERENCE_TYPE)
1474     {
1475       from = TREE_TYPE (from);
1476       if (!TYPE_REF_IS_RVALUE (rfrom)
1477           || TREE_CODE (from) == FUNCTION_TYPE)
1478         gl_kind = clk_ordinary;
1479       else
1480         gl_kind = clk_rvalueref;
1481     }
1482   else if (expr)
1483     {
1484       gl_kind = lvalue_kind (expr);
1485       if (gl_kind & clk_class)
1486         /* A class prvalue is not a glvalue.  */
1487         gl_kind = clk_none;
1488     }
1489   else
1490     gl_kind = clk_none;
1491   is_lvalue = gl_kind && !(gl_kind & clk_rvalueref);
1492
1493   tfrom = from;
1494   if ((gl_kind & clk_bitfield) != 0)
1495     tfrom = unlowered_expr_type (expr);
1496
1497   /* Figure out whether or not the types are reference-related and
1498      reference compatible.  We have do do this after stripping
1499      references from FROM.  */
1500   related_p = reference_related_p (to, tfrom);
1501   /* If this is a C cast, first convert to an appropriately qualified
1502      type, so that we can later do a const_cast to the desired type.  */
1503   if (related_p && c_cast_p
1504       && !at_least_as_qualified_p (to, tfrom))
1505     to = cp_build_qualified_type (to, cp_type_quals (tfrom));
1506   compatible_p = reference_compatible_p (to, tfrom);
1507
1508   /* Directly bind reference when target expression's type is compatible with
1509      the reference and expression is an lvalue. In DR391, the wording in
1510      [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1511      const and rvalue references to rvalues of compatible class type.
1512      We should also do direct bindings for non-class xvalues.  */
1513   if (compatible_p
1514       && (is_lvalue
1515           || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1516                 && !(flags & LOOKUP_NO_RVAL_BIND))
1517                || TYPE_REF_IS_RVALUE (rto))
1518               && (gl_kind
1519                   || (!(flags & LOOKUP_NO_TEMP_BIND)
1520                       && (CLASS_TYPE_P (from)
1521                           || TREE_CODE (from) == ARRAY_TYPE))))))
1522     {
1523       /* [dcl.init.ref]
1524
1525          If the initializer expression
1526
1527          -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1528             is reference-compatible with "cv2 T2,"
1529
1530          the reference is bound directly to the initializer expression
1531          lvalue.
1532
1533          [...]
1534          If the initializer expression is an rvalue, with T2 a class type,
1535          and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1536          is bound to the object represented by the rvalue or to a sub-object
1537          within that object.  */
1538
1539       conv = build_identity_conv (tfrom, expr);
1540       conv = direct_reference_binding (rto, conv);
1541
1542       if (flags & LOOKUP_PREFER_RVALUE)
1543         /* The top-level caller requested that we pretend that the lvalue
1544            be treated as an rvalue.  */
1545         conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1546       else if (TREE_CODE (rfrom) == REFERENCE_TYPE)
1547         /* Handle rvalue reference to function properly.  */
1548         conv->rvaluedness_matches_p
1549           = (TYPE_REF_IS_RVALUE (rto) == TYPE_REF_IS_RVALUE (rfrom));
1550       else
1551         conv->rvaluedness_matches_p 
1552           = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1553
1554       if ((gl_kind & clk_bitfield) != 0
1555           || ((gl_kind & clk_packed) != 0 && !TYPE_PACKED (to)))
1556         /* For the purposes of overload resolution, we ignore the fact
1557            this expression is a bitfield or packed field. (In particular,
1558            [over.ics.ref] says specifically that a function with a
1559            non-const reference parameter is viable even if the
1560            argument is a bitfield.)
1561
1562            However, when we actually call the function we must create
1563            a temporary to which to bind the reference.  If the
1564            reference is volatile, or isn't const, then we cannot make
1565            a temporary, so we just issue an error when the conversion
1566            actually occurs.  */
1567         conv->need_temporary_p = true;
1568
1569       /* Don't allow binding of lvalues (other than function lvalues) to
1570          rvalue references.  */
1571       if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1572           && TREE_CODE (to) != FUNCTION_TYPE
1573           && !(flags & LOOKUP_PREFER_RVALUE))
1574         conv->bad_p = true;
1575
1576       return conv;
1577     }
1578   /* [class.conv.fct] A conversion function is never used to convert a
1579      (possibly cv-qualified) object to the (possibly cv-qualified) same
1580      object type (or a reference to it), to a (possibly cv-qualified) base
1581      class of that type (or a reference to it).... */
1582   else if (CLASS_TYPE_P (from) && !related_p
1583            && !(flags & LOOKUP_NO_CONVERSION))
1584     {
1585       /* [dcl.init.ref]
1586
1587          If the initializer expression
1588
1589          -- has a class type (i.e., T2 is a class type) can be
1590             implicitly converted to an lvalue of type "cv3 T3," where
1591             "cv1 T1" is reference-compatible with "cv3 T3".  (this
1592             conversion is selected by enumerating the applicable
1593             conversion functions (_over.match.ref_) and choosing the
1594             best one through overload resolution.  (_over.match_).
1595
1596         the reference is bound to the lvalue result of the conversion
1597         in the second case.  */
1598       z_candidate *cand = build_user_type_conversion_1 (rto, expr, flags);
1599       if (cand)
1600         return cand->second_conv;
1601     }
1602
1603   /* From this point on, we conceptually need temporaries, even if we
1604      elide them.  Only the cases above are "direct bindings".  */
1605   if (flags & LOOKUP_NO_TEMP_BIND)
1606     return NULL;
1607
1608   /* [over.ics.rank]
1609
1610      When a parameter of reference type is not bound directly to an
1611      argument expression, the conversion sequence is the one required
1612      to convert the argument expression to the underlying type of the
1613      reference according to _over.best.ics_.  Conceptually, this
1614      conversion sequence corresponds to copy-initializing a temporary
1615      of the underlying type with the argument expression.  Any
1616      difference in top-level cv-qualification is subsumed by the
1617      initialization itself and does not constitute a conversion.  */
1618
1619   /* [dcl.init.ref]
1620
1621      Otherwise, the reference shall be to a non-volatile const type.
1622
1623      Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1624   if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1625     return NULL;
1626
1627   /* [dcl.init.ref]
1628
1629      Otherwise, a temporary of type "cv1 T1" is created and
1630      initialized from the initializer expression using the rules for a
1631      non-reference copy initialization.  If T1 is reference-related to
1632      T2, cv1 must be the same cv-qualification as, or greater
1633      cv-qualification than, cv2; otherwise, the program is ill-formed.  */
1634   if (related_p && !at_least_as_qualified_p (to, from))
1635     return NULL;
1636
1637   /* We're generating a temporary now, but don't bind any more in the
1638      conversion (specifically, don't slice the temporary returned by a
1639      conversion operator).  */
1640   flags |= LOOKUP_NO_TEMP_BIND;
1641
1642   /* Core issue 899: When [copy-]initializing a temporary to be bound
1643      to the first parameter of a copy constructor (12.8) called with
1644      a single argument in the context of direct-initialization,
1645      explicit conversion functions are also considered.
1646
1647      So don't set LOOKUP_ONLYCONVERTING in that case.  */
1648   if (!(flags & LOOKUP_COPY_PARM))
1649     flags |= LOOKUP_ONLYCONVERTING;
1650
1651   if (!conv)
1652     conv = implicit_conversion (to, from, expr, c_cast_p,
1653                                 flags);
1654   if (!conv)
1655     return NULL;
1656
1657   conv = build_conv (ck_ref_bind, rto, conv);
1658   /* This reference binding, unlike those above, requires the
1659      creation of a temporary.  */
1660   conv->need_temporary_p = true;
1661   conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1662
1663   return conv;
1664 }
1665
1666 /* Returns the implicit conversion sequence (see [over.ics]) from type
1667    FROM to type TO.  The optional expression EXPR may affect the
1668    conversion.  FLAGS are the usual overloading flags.  If C_CAST_P is
1669    true, this conversion is coming from a C-style cast.  */
1670
1671 static conversion *
1672 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1673                      int flags)
1674 {
1675   conversion *conv;
1676
1677   if (from == error_mark_node || to == error_mark_node
1678       || expr == error_mark_node)
1679     return NULL;
1680
1681   /* Other flags only apply to the primary function in overload
1682      resolution, or after we've chosen one.  */
1683   flags &= (LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION|LOOKUP_COPY_PARM
1684             |LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND|LOOKUP_PREFER_RVALUE
1685             |LOOKUP_NO_NARROWING|LOOKUP_PROTECT);
1686
1687   if (TREE_CODE (to) == REFERENCE_TYPE)
1688     conv = reference_binding (to, from, expr, c_cast_p, flags);
1689   else
1690     conv = standard_conversion (to, from, expr, c_cast_p, flags);
1691
1692   if (conv)
1693     return conv;
1694
1695   if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1696     {
1697       if (is_std_init_list (to))
1698         return build_list_conv (to, expr, flags);
1699
1700       /* As an extension, allow list-initialization of _Complex.  */
1701       if (TREE_CODE (to) == COMPLEX_TYPE)
1702         {
1703           conv = build_complex_conv (to, expr, flags);
1704           if (conv)
1705             return conv;
1706         }
1707
1708       /* Allow conversion from an initializer-list with one element to a
1709          scalar type.  */
1710       if (SCALAR_TYPE_P (to))
1711         {
1712           int nelts = CONSTRUCTOR_NELTS (expr);
1713           tree elt;
1714
1715           if (nelts == 0)
1716             elt = build_value_init (to, tf_none);
1717           else if (nelts == 1)
1718             elt = CONSTRUCTOR_ELT (expr, 0)->value;
1719           else
1720             elt = error_mark_node;
1721
1722           conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1723                                       c_cast_p, flags);
1724           if (conv)
1725             {
1726               conv->check_narrowing = true;
1727               if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1728                 /* Too many levels of braces, i.e. '{{1}}'.  */
1729                 conv->bad_p = true;
1730               return conv;
1731             }
1732         }
1733       else if (TREE_CODE (to) == ARRAY_TYPE)
1734         return build_array_conv (to, expr, flags);
1735     }
1736
1737   if (expr != NULL_TREE
1738       && (MAYBE_CLASS_TYPE_P (from)
1739           || MAYBE_CLASS_TYPE_P (to))
1740       && (flags & LOOKUP_NO_CONVERSION) == 0)
1741     {
1742       struct z_candidate *cand;
1743
1744       if (CLASS_TYPE_P (to)
1745           && BRACE_ENCLOSED_INITIALIZER_P (expr)
1746           && !CLASSTYPE_NON_AGGREGATE (complete_type (to)))
1747         return build_aggr_conv (to, expr, flags);
1748
1749       cand = build_user_type_conversion_1 (to, expr, flags);
1750       if (cand)
1751         conv = cand->second_conv;
1752
1753       /* We used to try to bind a reference to a temporary here, but that
1754          is now handled after the recursive call to this function at the end
1755          of reference_binding.  */
1756       return conv;
1757     }
1758
1759   return NULL;
1760 }
1761
1762 /* Add a new entry to the list of candidates.  Used by the add_*_candidate
1763    functions.  ARGS will not be changed until a single candidate is
1764    selected.  */
1765
1766 static struct z_candidate *
1767 add_candidate (struct z_candidate **candidates,
1768                tree fn, tree first_arg, const VEC(tree,gc) *args,
1769                size_t num_convs, conversion **convs,
1770                tree access_path, tree conversion_path,
1771                int viable, struct rejection_reason *reason)
1772 {
1773   struct z_candidate *cand = (struct z_candidate *)
1774     conversion_obstack_alloc (sizeof (struct z_candidate));
1775
1776   cand->fn = fn;
1777   cand->first_arg = first_arg;
1778   cand->args = args;
1779   cand->convs = convs;
1780   cand->num_convs = num_convs;
1781   cand->access_path = access_path;
1782   cand->conversion_path = conversion_path;
1783   cand->viable = viable;
1784   cand->reason = reason;
1785   cand->next = *candidates;
1786   *candidates = cand;
1787
1788   return cand;
1789 }
1790
1791 /* Return the number of remaining arguments in the parameter list
1792    beginning with ARG.  */
1793
1794 static int
1795 remaining_arguments (tree arg)
1796 {
1797   int n;
1798
1799   for (n = 0; arg != NULL_TREE && arg != void_list_node;
1800        arg = TREE_CHAIN (arg))
1801     n++;
1802
1803   return n;
1804 }
1805
1806 /* Create an overload candidate for the function or method FN called
1807    with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1808    FLAGS is passed on to implicit_conversion.
1809
1810    This does not change ARGS.
1811
1812    CTYPE, if non-NULL, is the type we want to pretend this function
1813    comes from for purposes of overload resolution.  */
1814
1815 static struct z_candidate *
1816 add_function_candidate (struct z_candidate **candidates,
1817                         tree fn, tree ctype, tree first_arg,
1818                         const VEC(tree,gc) *args, tree access_path,
1819                         tree conversion_path, int flags)
1820 {
1821   tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1822   int i, len;
1823   conversion **convs;
1824   tree parmnode;
1825   tree orig_first_arg = first_arg;
1826   int skip;
1827   int viable = 1;
1828   struct rejection_reason *reason = NULL;
1829
1830   /* At this point we should not see any functions which haven't been
1831      explicitly declared, except for friend functions which will have
1832      been found using argument dependent lookup.  */
1833   gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1834
1835   /* The `this', `in_chrg' and VTT arguments to constructors are not
1836      considered in overload resolution.  */
1837   if (DECL_CONSTRUCTOR_P (fn))
1838     {
1839       parmlist = skip_artificial_parms_for (fn, parmlist);
1840       skip = num_artificial_parms_for (fn);
1841       if (skip > 0 && first_arg != NULL_TREE)
1842         {
1843           --skip;
1844           first_arg = NULL_TREE;
1845         }
1846     }
1847   else
1848     skip = 0;
1849
1850   len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1851   convs = alloc_conversions (len);
1852
1853   /* 13.3.2 - Viable functions [over.match.viable]
1854      First, to be a viable function, a candidate function shall have enough
1855      parameters to agree in number with the arguments in the list.
1856
1857      We need to check this first; otherwise, checking the ICSes might cause
1858      us to produce an ill-formed template instantiation.  */
1859
1860   parmnode = parmlist;
1861   for (i = 0; i < len; ++i)
1862     {
1863       if (parmnode == NULL_TREE || parmnode == void_list_node)
1864         break;
1865       parmnode = TREE_CHAIN (parmnode);
1866     }
1867
1868   if ((i < len && parmnode)
1869       || !sufficient_parms_p (parmnode))
1870     {
1871       int remaining = remaining_arguments (parmnode);
1872       viable = 0;
1873       reason = arity_rejection (first_arg, i + remaining, len);
1874     }
1875   /* When looking for a function from a subobject from an implicit
1876      copy/move constructor/operator=, don't consider anything that takes (a
1877      reference to) an unrelated type.  See c++/44909 and core 1092.  */
1878   else if (parmlist && (flags & LOOKUP_DEFAULTED))
1879     {
1880       if (DECL_CONSTRUCTOR_P (fn))
1881         i = 1;
1882       else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1883                && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1884         i = 2;
1885       else
1886         i = 0;
1887       if (i && len == i)
1888         {
1889           parmnode = chain_index (i-1, parmlist);
1890           if (!reference_related_p (non_reference (TREE_VALUE (parmnode)),
1891                                     ctype))
1892             viable = 0;
1893         }
1894
1895       /* This only applies at the top level.  */
1896       flags &= ~LOOKUP_DEFAULTED;
1897     }
1898
1899   if (! viable)
1900     goto out;
1901
1902   /* Second, for F to be a viable function, there shall exist for each
1903      argument an implicit conversion sequence that converts that argument
1904      to the corresponding parameter of F.  */
1905
1906   parmnode = parmlist;
1907
1908   for (i = 0; i < len; ++i)
1909     {
1910       tree arg, argtype, to_type;
1911       conversion *t;
1912       int is_this;
1913
1914       if (parmnode == void_list_node)
1915         break;
1916
1917       if (i == 0 && first_arg != NULL_TREE)
1918         arg = first_arg;
1919       else
1920         arg = VEC_index (tree, args,
1921                          i + skip - (first_arg != NULL_TREE ? 1 : 0));
1922       argtype = lvalue_type (arg);
1923
1924       is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1925                  && ! DECL_CONSTRUCTOR_P (fn));
1926
1927       if (parmnode)
1928         {
1929           tree parmtype = TREE_VALUE (parmnode);
1930           int lflags = flags;
1931
1932           parmnode = TREE_CHAIN (parmnode);
1933
1934           /* The type of the implicit object parameter ('this') for
1935              overload resolution is not always the same as for the
1936              function itself; conversion functions are considered to
1937              be members of the class being converted, and functions
1938              introduced by a using-declaration are considered to be
1939              members of the class that uses them.
1940
1941              Since build_over_call ignores the ICS for the `this'
1942              parameter, we can just change the parm type.  */
1943           if (ctype && is_this)
1944             {
1945               parmtype = cp_build_qualified_type
1946                 (ctype, cp_type_quals (TREE_TYPE (parmtype)));
1947               parmtype = build_pointer_type (parmtype);
1948             }
1949
1950           /* Core issue 899: When [copy-]initializing a temporary to be bound
1951              to the first parameter of a copy constructor (12.8) called with
1952              a single argument in the context of direct-initialization,
1953              explicit conversion functions are also considered.
1954
1955              So set LOOKUP_COPY_PARM to let reference_binding know that
1956              it's being called in that context.  We generalize the above
1957              to handle move constructors and template constructors as well;
1958              the standardese should soon be updated similarly.  */
1959           if (ctype && i == 0 && (len-skip == 1)
1960               && DECL_CONSTRUCTOR_P (fn)
1961               && parmtype != error_mark_node
1962               && (same_type_ignoring_top_level_qualifiers_p
1963                   (non_reference (parmtype), ctype)))
1964             {
1965               if (!(flags & LOOKUP_ONLYCONVERTING))
1966                 lflags |= LOOKUP_COPY_PARM;
1967               /* We allow user-defined conversions within init-lists, but
1968                  don't list-initialize the copy parm, as that would mean
1969                  using two levels of braces for the same type.  */
1970               if ((flags & LOOKUP_LIST_INIT_CTOR)
1971                   && BRACE_ENCLOSED_INITIALIZER_P (arg))
1972                 lflags |= LOOKUP_NO_CONVERSION;
1973             }
1974           else
1975             lflags |= LOOKUP_ONLYCONVERTING;
1976
1977           t = implicit_conversion (parmtype, argtype, arg,
1978                                    /*c_cast_p=*/false, lflags);
1979           to_type = parmtype;
1980         }
1981       else
1982         {
1983           t = build_identity_conv (argtype, arg);
1984           t->ellipsis_p = true;
1985           to_type = argtype;
1986         }
1987
1988       if (t && is_this)
1989         t->this_p = true;
1990
1991       convs[i] = t;
1992       if (! t)
1993         {
1994           viable = 0;
1995           reason = arg_conversion_rejection (first_arg, i, argtype, to_type);
1996           break;
1997         }
1998
1999       if (t->bad_p)
2000         {
2001           viable = -1;
2002           reason = bad_arg_conversion_rejection (first_arg, i, argtype, to_type);
2003         }
2004     }
2005
2006  out:
2007   return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
2008                         access_path, conversion_path, viable, reason);
2009 }
2010
2011 /* Create an overload candidate for the conversion function FN which will
2012    be invoked for expression OBJ, producing a pointer-to-function which
2013    will in turn be called with the argument list FIRST_ARG/ARGLIST,
2014    and add it to CANDIDATES.  This does not change ARGLIST.  FLAGS is
2015    passed on to implicit_conversion.
2016
2017    Actually, we don't really care about FN; we care about the type it
2018    converts to.  There may be multiple conversion functions that will
2019    convert to that type, and we rely on build_user_type_conversion_1 to
2020    choose the best one; so when we create our candidate, we record the type
2021    instead of the function.  */
2022
2023 static struct z_candidate *
2024 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
2025                     tree first_arg, const VEC(tree,gc) *arglist,
2026                     tree access_path, tree conversion_path)
2027 {
2028   tree totype = TREE_TYPE (TREE_TYPE (fn));
2029   int i, len, viable, flags;
2030   tree parmlist, parmnode;
2031   conversion **convs;
2032   struct rejection_reason *reason;
2033
2034   for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
2035     parmlist = TREE_TYPE (parmlist);
2036   parmlist = TYPE_ARG_TYPES (parmlist);
2037
2038   len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
2039   convs = alloc_conversions (len);
2040   parmnode = parmlist;
2041   viable = 1;
2042   flags = LOOKUP_IMPLICIT;
2043   reason = NULL;
2044
2045   /* Don't bother looking up the same type twice.  */
2046   if (*candidates && (*candidates)->fn == totype)
2047     return NULL;
2048
2049   for (i = 0; i < len; ++i)
2050     {
2051       tree arg, argtype, convert_type = NULL_TREE;
2052       conversion *t;
2053
2054       if (i == 0)
2055         arg = obj;
2056       else if (i == 1 && first_arg != NULL_TREE)
2057         arg = first_arg;
2058       else
2059         arg = VEC_index (tree, arglist,
2060                          i - (first_arg != NULL_TREE ? 1 : 0) - 1);
2061       argtype = lvalue_type (arg);
2062
2063       if (i == 0)
2064         {
2065           t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
2066                                    flags);
2067           convert_type = totype;
2068         }
2069       else if (parmnode == void_list_node)
2070         break;
2071       else if (parmnode)
2072         {
2073           t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
2074                                    /*c_cast_p=*/false, flags);
2075           convert_type = TREE_VALUE (parmnode);
2076         }
2077       else
2078         {
2079           t = build_identity_conv (argtype, arg);
2080           t->ellipsis_p = true;
2081           convert_type = argtype;
2082         }
2083
2084       convs[i] = t;
2085       if (! t)
2086         break;
2087
2088       if (t->bad_p)
2089         {
2090           viable = -1;
2091           reason = bad_arg_conversion_rejection (NULL_TREE, i, argtype, convert_type);
2092         }
2093
2094       if (i == 0)
2095         continue;
2096
2097       if (parmnode)
2098         parmnode = TREE_CHAIN (parmnode);
2099     }
2100
2101   if (i < len
2102       || ! sufficient_parms_p (parmnode))
2103     {
2104       int remaining = remaining_arguments (parmnode);
2105       viable = 0;
2106       reason = arity_rejection (NULL_TREE, i + remaining, len);
2107     }
2108
2109   return add_candidate (candidates, totype, first_arg, arglist, len, convs,
2110                         access_path, conversion_path, viable, reason);
2111 }
2112
2113 static void
2114 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
2115                          tree type1, tree type2, tree *args, tree *argtypes,
2116                          int flags)
2117 {
2118   conversion *t;
2119   conversion **convs;
2120   size_t num_convs;
2121   int viable = 1, i;
2122   tree types[2];
2123   struct rejection_reason *reason = NULL;
2124
2125   types[0] = type1;
2126   types[1] = type2;
2127
2128   num_convs =  args[2] ? 3 : (args[1] ? 2 : 1);
2129   convs = alloc_conversions (num_convs);
2130
2131   /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2132      conversion ops are allowed.  We handle that here by just checking for
2133      boolean_type_node because other operators don't ask for it.  COND_EXPR
2134      also does contextual conversion to bool for the first operand, but we
2135      handle that in build_conditional_expr, and type1 here is operand 2.  */
2136   if (type1 != boolean_type_node)
2137     flags |= LOOKUP_ONLYCONVERTING;
2138
2139   for (i = 0; i < 2; ++i)
2140     {
2141       if (! args[i])
2142         break;
2143
2144       t = implicit_conversion (types[i], argtypes[i], args[i],
2145                                /*c_cast_p=*/false, flags);
2146       if (! t)
2147         {
2148           viable = 0;
2149           /* We need something for printing the candidate.  */
2150           t = build_identity_conv (types[i], NULL_TREE);
2151           reason = arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2152         }
2153       else if (t->bad_p)
2154         {
2155           viable = 0;
2156           reason = bad_arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2157         }
2158       convs[i] = t;
2159     }
2160
2161   /* For COND_EXPR we rearranged the arguments; undo that now.  */
2162   if (args[2])
2163     {
2164       convs[2] = convs[1];
2165       convs[1] = convs[0];
2166       t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
2167                                /*c_cast_p=*/false, flags);
2168       if (t)
2169         convs[0] = t;
2170       else
2171         {
2172           viable = 0;
2173           reason = arg_conversion_rejection (NULL_TREE, 0, argtypes[2],
2174                                              boolean_type_node);
2175         }
2176     }
2177
2178   add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
2179                  num_convs, convs,
2180                  /*access_path=*/NULL_TREE,
2181                  /*conversion_path=*/NULL_TREE,
2182                  viable, reason);
2183 }
2184
2185 static bool
2186 is_complete (tree t)
2187 {
2188   return COMPLETE_TYPE_P (complete_type (t));
2189 }
2190
2191 /* Returns nonzero if TYPE is a promoted arithmetic type.  */
2192
2193 static bool
2194 promoted_arithmetic_type_p (tree type)
2195 {
2196   /* [over.built]
2197
2198      In this section, the term promoted integral type is used to refer
2199      to those integral types which are preserved by integral promotion
2200      (including e.g.  int and long but excluding e.g.  char).
2201      Similarly, the term promoted arithmetic type refers to promoted
2202      integral types plus floating types.  */
2203   return ((CP_INTEGRAL_TYPE_P (type)
2204            && same_type_p (type_promotes_to (type), type))
2205           || TREE_CODE (type) == REAL_TYPE);
2206 }
2207
2208 /* Create any builtin operator overload candidates for the operator in
2209    question given the converted operand types TYPE1 and TYPE2.  The other
2210    args are passed through from add_builtin_candidates to
2211    build_builtin_candidate.
2212
2213    TYPE1 and TYPE2 may not be permissible, and we must filter them.
2214    If CODE is requires candidates operands of the same type of the kind
2215    of which TYPE1 and TYPE2 are, we add both candidates
2216    CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2).  */
2217
2218 static void
2219 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
2220                        enum tree_code code2, tree fnname, tree type1,
2221                        tree type2, tree *args, tree *argtypes, int flags)
2222 {
2223   switch (code)
2224     {
2225     case POSTINCREMENT_EXPR:
2226     case POSTDECREMENT_EXPR:
2227       args[1] = integer_zero_node;
2228       type2 = integer_type_node;
2229       break;
2230     default:
2231       break;
2232     }
2233
2234   switch (code)
2235     {
2236
2237 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2238      and  VQ  is  either  volatile or empty, there exist candidate operator
2239      functions of the form
2240              VQ T&   operator++(VQ T&);
2241              T       operator++(VQ T&, int);
2242    5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2243      type  other than bool, and VQ is either volatile or empty, there exist
2244      candidate operator functions of the form
2245              VQ T&   operator--(VQ T&);
2246              T       operator--(VQ T&, int);
2247    6 For every pair T, VQ), where T is  a  cv-qualified  or  cv-unqualified
2248      complete  object type, and VQ is either volatile or empty, there exist
2249      candidate operator functions of the form
2250              T*VQ&   operator++(T*VQ&);
2251              T*VQ&   operator--(T*VQ&);
2252              T*      operator++(T*VQ&, int);
2253              T*      operator--(T*VQ&, int);  */
2254
2255     case POSTDECREMENT_EXPR:
2256     case PREDECREMENT_EXPR:
2257       if (TREE_CODE (type1) == BOOLEAN_TYPE)
2258         return;
2259     case POSTINCREMENT_EXPR:
2260     case PREINCREMENT_EXPR:
2261       if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
2262         {
2263           type1 = build_reference_type (type1);
2264           break;
2265         }
2266       return;
2267
2268 /* 7 For every cv-qualified or cv-unqualified object type T, there
2269      exist candidate operator functions of the form
2270
2271              T&      operator*(T*);
2272
2273    8 For every function type T, there exist candidate operator functions of
2274      the form
2275              T&      operator*(T*);  */
2276
2277     case INDIRECT_REF:
2278       if (TREE_CODE (type1) == POINTER_TYPE
2279           && !uses_template_parms (TREE_TYPE (type1))
2280           && (TYPE_PTROB_P (type1)
2281               || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
2282         break;
2283       return;
2284
2285 /* 9 For every type T, there exist candidate operator functions of the form
2286              T*      operator+(T*);
2287
2288    10For  every  promoted arithmetic type T, there exist candidate operator
2289      functions of the form
2290              T       operator+(T);
2291              T       operator-(T);  */
2292
2293     case UNARY_PLUS_EXPR: /* unary + */
2294       if (TREE_CODE (type1) == POINTER_TYPE)
2295         break;
2296     case NEGATE_EXPR:
2297       if (ARITHMETIC_TYPE_P (type1))
2298         break;
2299       return;
2300
2301 /* 11For every promoted integral type T,  there  exist  candidate  operator
2302      functions of the form
2303              T       operator~(T);  */
2304
2305     case BIT_NOT_EXPR:
2306       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
2307         break;
2308       return;
2309
2310 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2311      is the same type as C2 or is a derived class of C2, T  is  a  complete
2312      object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2313      there exist candidate operator functions of the form
2314              CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2315      where CV12 is the union of CV1 and CV2.  */
2316
2317     case MEMBER_REF:
2318       if (TREE_CODE (type1) == POINTER_TYPE
2319           && TYPE_PTR_TO_MEMBER_P (type2))
2320         {
2321           tree c1 = TREE_TYPE (type1);
2322           tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
2323
2324           if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
2325               && (TYPE_PTRMEMFUNC_P (type2)
2326                   || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
2327             break;
2328         }
2329       return;
2330
2331 /* 13For every pair of promoted arithmetic types L and R, there exist  can-
2332      didate operator functions of the form
2333              LR      operator*(L, R);
2334              LR      operator/(L, R);
2335              LR      operator+(L, R);
2336              LR      operator-(L, R);
2337              bool    operator<(L, R);
2338              bool    operator>(L, R);
2339              bool    operator<=(L, R);
2340              bool    operator>=(L, R);
2341              bool    operator==(L, R);
2342              bool    operator!=(L, R);
2343      where  LR  is  the  result of the usual arithmetic conversions between
2344      types L and R.
2345
2346    14For every pair of types T and I, where T  is  a  cv-qualified  or  cv-
2347      unqualified  complete  object  type and I is a promoted integral type,
2348      there exist candidate operator functions of the form
2349              T*      operator+(T*, I);
2350              T&      operator[](T*, I);
2351              T*      operator-(T*, I);
2352              T*      operator+(I, T*);
2353              T&      operator[](I, T*);
2354
2355    15For every T, where T is a pointer to complete object type, there exist
2356      candidate operator functions of the form112)
2357              ptrdiff_t operator-(T, T);
2358
2359    16For every pointer or enumeration type T, there exist candidate operator
2360      functions of the form
2361              bool    operator<(T, T);
2362              bool    operator>(T, T);
2363              bool    operator<=(T, T);
2364              bool    operator>=(T, T);
2365              bool    operator==(T, T);
2366              bool    operator!=(T, T);
2367
2368    17For every pointer to member type T,  there  exist  candidate  operator
2369      functions of the form
2370              bool    operator==(T, T);
2371              bool    operator!=(T, T);  */
2372
2373     case MINUS_EXPR:
2374       if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2375         break;
2376       if (TYPE_PTROB_P (type1)
2377           && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2378         {
2379           type2 = ptrdiff_type_node;
2380           break;
2381         }
2382     case MULT_EXPR:
2383     case TRUNC_DIV_EXPR:
2384       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2385         break;
2386       return;
2387
2388     case EQ_EXPR:
2389     case NE_EXPR:
2390       if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2391           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2392         break;
2393       if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2394         {
2395           type2 = type1;
2396           break;
2397         }
2398       if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2399         {
2400           type1 = type2;
2401           break;
2402         }
2403       /* Fall through.  */
2404     case LT_EXPR:
2405     case GT_EXPR:
2406     case LE_EXPR:
2407     case GE_EXPR:
2408     case MAX_EXPR:
2409     case MIN_EXPR:
2410       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2411         break;
2412       if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2413         break;
2414       if (TREE_CODE (type1) == ENUMERAL_TYPE 
2415           && TREE_CODE (type2) == ENUMERAL_TYPE)
2416         break;
2417       if (TYPE_PTR_P (type1) 
2418           && null_ptr_cst_p (args[1])
2419           && !uses_template_parms (type1))
2420         {
2421           type2 = type1;
2422           break;
2423         }
2424       if (null_ptr_cst_p (args[0]) 
2425           && TYPE_PTR_P (type2)
2426           && !uses_template_parms (type2))
2427         {
2428           type1 = type2;
2429           break;
2430         }
2431       return;
2432
2433     case PLUS_EXPR:
2434       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2435         break;
2436     case ARRAY_REF:
2437       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2438         {
2439           type1 = ptrdiff_type_node;
2440           break;
2441         }
2442       if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2443         {
2444           type2 = ptrdiff_type_node;
2445           break;
2446         }
2447       return;
2448
2449 /* 18For  every pair of promoted integral types L and R, there exist candi-
2450      date operator functions of the form
2451              LR      operator%(L, R);
2452              LR      operator&(L, R);
2453              LR      operator^(L, R);
2454              LR      operator|(L, R);
2455              L       operator<<(L, R);
2456              L       operator>>(L, R);
2457      where LR is the result of the  usual  arithmetic  conversions  between
2458      types L and R.  */
2459
2460     case TRUNC_MOD_EXPR:
2461     case BIT_AND_EXPR:
2462     case BIT_IOR_EXPR:
2463     case BIT_XOR_EXPR:
2464     case LSHIFT_EXPR:
2465     case RSHIFT_EXPR:
2466       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2467         break;
2468       return;
2469
2470 /* 19For  every  triple  L, VQ, R), where L is an arithmetic or enumeration
2471      type, VQ is either volatile or empty, and R is a  promoted  arithmetic
2472      type, there exist candidate operator functions of the form
2473              VQ L&   operator=(VQ L&, R);
2474              VQ L&   operator*=(VQ L&, R);
2475              VQ L&   operator/=(VQ L&, R);
2476              VQ L&   operator+=(VQ L&, R);
2477              VQ L&   operator-=(VQ L&, R);
2478
2479    20For  every  pair T, VQ), where T is any type and VQ is either volatile
2480      or empty, there exist candidate operator functions of the form
2481              T*VQ&   operator=(T*VQ&, T*);
2482
2483    21For every pair T, VQ), where T is a pointer to member type and  VQ  is
2484      either  volatile or empty, there exist candidate operator functions of
2485      the form
2486              VQ T&   operator=(VQ T&, T);
2487
2488    22For every triple  T,  VQ,  I),  where  T  is  a  cv-qualified  or  cv-
2489      unqualified  complete object type, VQ is either volatile or empty, and
2490      I is a promoted integral type, there exist  candidate  operator  func-
2491      tions of the form
2492              T*VQ&   operator+=(T*VQ&, I);
2493              T*VQ&   operator-=(T*VQ&, I);
2494
2495    23For  every  triple  L,  VQ,  R), where L is an integral or enumeration
2496      type, VQ is either volatile or empty, and R  is  a  promoted  integral
2497      type, there exist candidate operator functions of the form
2498
2499              VQ L&   operator%=(VQ L&, R);
2500              VQ L&   operator<<=(VQ L&, R);
2501              VQ L&   operator>>=(VQ L&, R);
2502              VQ L&   operator&=(VQ L&, R);
2503              VQ L&   operator^=(VQ L&, R);
2504              VQ L&   operator|=(VQ L&, R);  */
2505
2506     case MODIFY_EXPR:
2507       switch (code2)
2508         {
2509         case PLUS_EXPR:
2510         case MINUS_EXPR:
2511           if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2512             {
2513               type2 = ptrdiff_type_node;
2514               break;
2515             }
2516         case MULT_EXPR:
2517         case TRUNC_DIV_EXPR:
2518           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2519             break;
2520           return;
2521
2522         case TRUNC_MOD_EXPR:
2523         case BIT_AND_EXPR:
2524         case BIT_IOR_EXPR:
2525         case BIT_XOR_EXPR:
2526         case LSHIFT_EXPR:
2527         case RSHIFT_EXPR:
2528           if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2529             break;
2530           return;
2531
2532         case NOP_EXPR:
2533           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2534             break;
2535           if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2536               || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2537               || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2538               || ((TYPE_PTRMEMFUNC_P (type1)
2539                    || TREE_CODE (type1) == POINTER_TYPE)
2540                   && null_ptr_cst_p (args[1])))
2541             {
2542               type2 = type1;
2543               break;
2544             }
2545           return;
2546
2547         default:
2548           gcc_unreachable ();
2549         }
2550       type1 = build_reference_type (type1);
2551       break;
2552
2553     case COND_EXPR:
2554       /* [over.built]
2555
2556          For every pair of promoted arithmetic types L and R, there
2557          exist candidate operator functions of the form
2558
2559          LR operator?(bool, L, R);
2560
2561          where LR is the result of the usual arithmetic conversions
2562          between types L and R.
2563
2564          For every type T, where T is a pointer or pointer-to-member
2565          type, there exist candidate operator functions of the form T
2566          operator?(bool, T, T);  */
2567
2568       if (promoted_arithmetic_type_p (type1)
2569           && promoted_arithmetic_type_p (type2))
2570         /* That's OK.  */
2571         break;
2572
2573       /* Otherwise, the types should be pointers.  */
2574       if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2575           || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2576         return;
2577
2578       /* We don't check that the two types are the same; the logic
2579          below will actually create two candidates; one in which both
2580          parameter types are TYPE1, and one in which both parameter
2581          types are TYPE2.  */
2582       break;
2583
2584     case REALPART_EXPR:
2585     case IMAGPART_EXPR:
2586       if (ARITHMETIC_TYPE_P (type1))
2587         break;
2588       return;
2589  
2590     default:
2591       gcc_unreachable ();
2592     }
2593
2594   /* If we're dealing with two pointer types or two enumeral types,
2595      we need candidates for both of them.  */
2596   if (type2 && !same_type_p (type1, type2)
2597       && TREE_CODE (type1) == TREE_CODE (type2)
2598       && (TREE_CODE (type1) == REFERENCE_TYPE
2599           || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2600           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2601           || TYPE_PTRMEMFUNC_P (type1)
2602           || MAYBE_CLASS_TYPE_P (type1)
2603           || TREE_CODE (type1) == ENUMERAL_TYPE))
2604     {
2605       if (TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2606         {
2607           tree cptype = composite_pointer_type (type1, type2,
2608                                                 error_mark_node,
2609                                                 error_mark_node,
2610                                                 CPO_CONVERSION,
2611                                                 tf_none);
2612           if (cptype != error_mark_node)
2613             {
2614               build_builtin_candidate
2615                 (candidates, fnname, cptype, cptype, args, argtypes, flags);
2616               return;
2617             }
2618         }
2619
2620       build_builtin_candidate
2621         (candidates, fnname, type1, type1, args, argtypes, flags);
2622       build_builtin_candidate
2623         (candidates, fnname, type2, type2, args, argtypes, flags);
2624       return;
2625     }
2626
2627   build_builtin_candidate
2628     (candidates, fnname, type1, type2, args, argtypes, flags);
2629 }
2630
2631 tree
2632 type_decays_to (tree type)
2633 {
2634   if (TREE_CODE (type) == ARRAY_TYPE)
2635     return build_pointer_type (TREE_TYPE (type));
2636   if (TREE_CODE (type) == FUNCTION_TYPE)
2637     return build_pointer_type (type);
2638   return type;
2639 }
2640
2641 /* There are three conditions of builtin candidates:
2642
2643    1) bool-taking candidates.  These are the same regardless of the input.
2644    2) pointer-pair taking candidates.  These are generated for each type
2645       one of the input types converts to.
2646    3) arithmetic candidates.  According to the standard, we should generate
2647       all of these, but I'm trying not to...
2648
2649    Here we generate a superset of the possible candidates for this particular
2650    case.  That is a subset of the full set the standard defines, plus some
2651    other cases which the standard disallows. add_builtin_candidate will
2652    filter out the invalid set.  */
2653
2654 static void
2655 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2656                         enum tree_code code2, tree fnname, tree *args,
2657                         int flags)
2658 {
2659   int ref1, i;
2660   int enum_p = 0;
2661   tree type, argtypes[3], t;
2662   /* TYPES[i] is the set of possible builtin-operator parameter types
2663      we will consider for the Ith argument.  */
2664   VEC(tree,gc) *types[2];
2665   unsigned ix;
2666
2667   for (i = 0; i < 3; ++i)
2668     {
2669       if (args[i])
2670         argtypes[i] = unlowered_expr_type (args[i]);
2671       else
2672         argtypes[i] = NULL_TREE;
2673     }
2674
2675   switch (code)
2676     {
2677 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2678      and  VQ  is  either  volatile or empty, there exist candidate operator
2679      functions of the form
2680                  VQ T&   operator++(VQ T&);  */
2681
2682     case POSTINCREMENT_EXPR:
2683     case PREINCREMENT_EXPR:
2684     case POSTDECREMENT_EXPR:
2685     case PREDECREMENT_EXPR:
2686     case MODIFY_EXPR:
2687       ref1 = 1;
2688       break;
2689
2690 /* 24There also exist candidate operator functions of the form
2691              bool    operator!(bool);
2692              bool    operator&&(bool, bool);
2693              bool    operator||(bool, bool);  */
2694
2695     case TRUTH_NOT_EXPR:
2696       build_builtin_candidate
2697         (candidates, fnname, boolean_type_node,
2698          NULL_TREE, args, argtypes, flags);
2699       return;
2700
2701     case TRUTH_ORIF_EXPR:
2702     case TRUTH_ANDIF_EXPR:
2703       build_builtin_candidate
2704         (candidates, fnname, boolean_type_node,
2705          boolean_type_node, args, argtypes, flags);
2706       return;
2707
2708     case ADDR_EXPR:
2709     case COMPOUND_EXPR:
2710     case COMPONENT_REF:
2711       return;
2712
2713     case COND_EXPR:
2714     case EQ_EXPR:
2715     case NE_EXPR:
2716     case LT_EXPR:
2717     case LE_EXPR:
2718     case GT_EXPR:
2719     case GE_EXPR:
2720       enum_p = 1;
2721       /* Fall through.  */
2722
2723     default:
2724       ref1 = 0;
2725     }
2726
2727   types[0] = make_tree_vector ();
2728   types[1] = make_tree_vector ();
2729
2730   for (i = 0; i < 2; ++i)
2731     {
2732       if (! args[i])
2733         ;
2734       else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2735         {
2736           tree convs;
2737
2738           if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2739             return;
2740
2741           convs = lookup_conversions (argtypes[i]);
2742
2743           if (code == COND_EXPR)
2744             {
2745               if (real_lvalue_p (args[i]))
2746                 VEC_safe_push (tree, gc, types[i],
2747                                build_reference_type (argtypes[i]));
2748
2749               VEC_safe_push (tree, gc, types[i],
2750                              TYPE_MAIN_VARIANT (argtypes[i]));
2751             }
2752
2753           else if (! convs)
2754             return;
2755
2756           for (; convs; convs = TREE_CHAIN (convs))
2757             {
2758               type = TREE_TYPE (convs);
2759
2760               if (i == 0 && ref1
2761                   && (TREE_CODE (type) != REFERENCE_TYPE
2762                       || CP_TYPE_CONST_P (TREE_TYPE (type))))
2763                 continue;
2764
2765               if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2766                 VEC_safe_push (tree, gc, types[i], type);
2767
2768               type = non_reference (type);
2769               if (i != 0 || ! ref1)
2770                 {
2771                   type = cv_unqualified (type_decays_to (type));
2772                   if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2773                     VEC_safe_push (tree, gc, types[i], type);
2774                   if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2775                     type = type_promotes_to (type);
2776                 }
2777
2778               if (! vec_member (type, types[i]))
2779                 VEC_safe_push (tree, gc, types[i], type);
2780             }
2781         }
2782       else
2783         {
2784           if (code == COND_EXPR && real_lvalue_p (args[i]))
2785             VEC_safe_push (tree, gc, types[i],
2786                            build_reference_type (argtypes[i]));
2787           type = non_reference (argtypes[i]);
2788           if (i != 0 || ! ref1)
2789             {
2790               type = cv_unqualified (type_decays_to (type));
2791               if (enum_p && UNSCOPED_ENUM_P (type))
2792                 VEC_safe_push (tree, gc, types[i], type);
2793               if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2794                 type = type_promotes_to (type);
2795             }
2796           VEC_safe_push (tree, gc, types[i], type);
2797         }
2798     }
2799
2800   /* Run through the possible parameter types of both arguments,
2801      creating candidates with those parameter types.  */
2802   FOR_EACH_VEC_ELT_REVERSE (tree, types[0], ix, t)
2803     {
2804       unsigned jx;
2805       tree u;
2806
2807       if (!VEC_empty (tree, types[1]))
2808         FOR_EACH_VEC_ELT_REVERSE (tree, types[1], jx, u)
2809           add_builtin_candidate
2810             (candidates, code, code2, fnname, t,
2811              u, args, argtypes, flags);
2812       else
2813         add_builtin_candidate
2814           (candidates, code, code2, fnname, t,
2815            NULL_TREE, args, argtypes, flags);
2816     }
2817
2818   release_tree_vector (types[0]);
2819   release_tree_vector (types[1]);
2820 }
2821
2822
2823 /* If TMPL can be successfully instantiated as indicated by
2824    EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2825
2826    TMPL is the template.  EXPLICIT_TARGS are any explicit template
2827    arguments.  ARGLIST is the arguments provided at the call-site.
2828    This does not change ARGLIST.  The RETURN_TYPE is the desired type
2829    for conversion operators.  If OBJ is NULL_TREE, FLAGS and CTYPE are
2830    as for add_function_candidate.  If an OBJ is supplied, FLAGS and
2831    CTYPE are ignored, and OBJ is as for add_conv_candidate.  */
2832
2833 static struct z_candidate*
2834 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2835                              tree ctype, tree explicit_targs, tree first_arg,
2836                              const VEC(tree,gc) *arglist, tree return_type,
2837                              tree access_path, tree conversion_path,
2838                              int flags, tree obj, unification_kind_t strict)
2839 {
2840   int ntparms = DECL_NTPARMS (tmpl);
2841   tree targs = make_tree_vec (ntparms);
2842   unsigned int len = VEC_length (tree, arglist);
2843   unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2844   unsigned int skip_without_in_chrg = 0;
2845   tree first_arg_without_in_chrg = first_arg;
2846   tree *args_without_in_chrg;
2847   unsigned int nargs_without_in_chrg;
2848   unsigned int ia, ix;
2849   tree arg;
2850   struct z_candidate *cand;
2851   int i;
2852   tree fn;
2853   struct rejection_reason *reason = NULL;
2854   int errs;
2855
2856   /* We don't do deduction on the in-charge parameter, the VTT
2857      parameter or 'this'.  */
2858   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2859     {
2860       if (first_arg_without_in_chrg != NULL_TREE)
2861         first_arg_without_in_chrg = NULL_TREE;
2862       else
2863         ++skip_without_in_chrg;
2864     }
2865
2866   if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2867        || DECL_BASE_CONSTRUCTOR_P (tmpl))
2868       && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2869     {
2870       if (first_arg_without_in_chrg != NULL_TREE)
2871         first_arg_without_in_chrg = NULL_TREE;
2872       else
2873         ++skip_without_in_chrg;
2874     }
2875
2876   if (len < skip_without_in_chrg)
2877     return NULL;
2878
2879   nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2880                            + (len - skip_without_in_chrg));
2881   args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2882   ia = 0;
2883   if (first_arg_without_in_chrg != NULL_TREE)
2884     {
2885       args_without_in_chrg[ia] = first_arg_without_in_chrg;
2886       ++ia;
2887     }
2888   for (ix = skip_without_in_chrg;
2889        VEC_iterate (tree, arglist, ix, arg);
2890        ++ix)
2891     {
2892       args_without_in_chrg[ia] = arg;
2893       ++ia;
2894     }
2895   gcc_assert (ia == nargs_without_in_chrg);
2896
2897   errs = errorcount+sorrycount;
2898   i = fn_type_unification (tmpl, explicit_targs, targs,
2899                            args_without_in_chrg,
2900                            nargs_without_in_chrg,
2901                            return_type, strict, flags, false);
2902
2903   if (i != 0)
2904     {
2905       /* Don't repeat unification later if it already resulted in errors.  */
2906       if (errorcount+sorrycount == errs)
2907         reason = template_unification_rejection (tmpl, explicit_targs,
2908                                                  targs, args_without_in_chrg,
2909                                                  nargs_without_in_chrg,
2910                                                  return_type, strict, flags);
2911       else
2912         reason = template_unification_error_rejection ();
2913       goto fail;
2914     }
2915
2916   fn = instantiate_template (tmpl, targs, tf_none);
2917   if (fn == error_mark_node)
2918     {
2919       reason = template_instantiation_rejection (tmpl, targs);
2920       goto fail;
2921     }
2922
2923   /* In [class.copy]:
2924
2925        A member function template is never instantiated to perform the
2926        copy of a class object to an object of its class type.
2927
2928      It's a little unclear what this means; the standard explicitly
2929      does allow a template to be used to copy a class.  For example,
2930      in:
2931
2932        struct A {
2933          A(A&);
2934          template <class T> A(const T&);
2935        };
2936        const A f ();
2937        void g () { A a (f ()); }
2938
2939      the member template will be used to make the copy.  The section
2940      quoted above appears in the paragraph that forbids constructors
2941      whose only parameter is (a possibly cv-qualified variant of) the
2942      class type, and a logical interpretation is that the intent was
2943      to forbid the instantiation of member templates which would then
2944      have that form.  */
2945   if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2946     {
2947       tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2948       if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2949                                     ctype))
2950         {
2951           reason = invalid_copy_with_fn_template_rejection ();
2952           goto fail;
2953         }
2954     }
2955
2956   if (obj != NULL_TREE)
2957     /* Aha, this is a conversion function.  */
2958     cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2959                                access_path, conversion_path);
2960   else
2961     cand = add_function_candidate (candidates, fn, ctype,
2962                                    first_arg, arglist, access_path,
2963                                    conversion_path, flags);
2964   if (DECL_TI_TEMPLATE (fn) != tmpl)
2965     /* This situation can occur if a member template of a template
2966        class is specialized.  Then, instantiate_template might return
2967        an instantiation of the specialization, in which case the
2968        DECL_TI_TEMPLATE field will point at the original
2969        specialization.  For example:
2970
2971          template <class T> struct S { template <class U> void f(U);
2972                                        template <> void f(int) {}; };
2973          S<double> sd;
2974          sd.f(3);
2975
2976        Here, TMPL will be template <class U> S<double>::f(U).
2977        And, instantiate template will give us the specialization
2978        template <> S<double>::f(int).  But, the DECL_TI_TEMPLATE field
2979        for this will point at template <class T> template <> S<T>::f(int),
2980        so that we can find the definition.  For the purposes of
2981        overload resolution, however, we want the original TMPL.  */
2982     cand->template_decl = build_template_info (tmpl, targs);
2983   else
2984     cand->template_decl = DECL_TEMPLATE_INFO (fn);
2985   cand->explicit_targs = explicit_targs;
2986
2987   return cand;
2988  fail:
2989   return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2990                         access_path, conversion_path, 0, reason);
2991 }
2992
2993
2994 static struct z_candidate *
2995 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2996                         tree explicit_targs, tree first_arg,
2997                         const VEC(tree,gc) *arglist, tree return_type,
2998                         tree access_path, tree conversion_path, int flags,
2999                         unification_kind_t strict)
3000 {
3001   return
3002     add_template_candidate_real (candidates, tmpl, ctype,
3003                                  explicit_targs, first_arg, arglist,
3004                                  return_type, access_path, conversion_path,
3005                                  flags, NULL_TREE, strict);
3006 }
3007
3008
3009 static struct z_candidate *
3010 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
3011                              tree obj, tree first_arg,
3012                              const VEC(tree,gc) *arglist,
3013                              tree return_type, tree access_path,
3014                              tree conversion_path)
3015 {
3016   return
3017     add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
3018                                  first_arg, arglist, return_type, access_path,
3019                                  conversion_path, 0, obj, DEDUCE_CONV);
3020 }
3021
3022 /* The CANDS are the set of candidates that were considered for
3023    overload resolution.  Return the set of viable candidates, or CANDS
3024    if none are viable.  If any of the candidates were viable, set
3025    *ANY_VIABLE_P to true.  STRICT_P is true if a candidate should be
3026    considered viable only if it is strictly viable.  */
3027
3028 static struct z_candidate*
3029 splice_viable (struct z_candidate *cands,
3030                bool strict_p,
3031                bool *any_viable_p)
3032 {
3033   struct z_candidate *viable;
3034   struct z_candidate **last_viable;
3035   struct z_candidate **cand;
3036
3037   /* Be strict inside templates, since build_over_call won't actually
3038      do the conversions to get pedwarns.  */
3039   if (processing_template_decl)
3040     strict_p = true;
3041
3042   viable = NULL;
3043   last_viable = &viable;
3044   *any_viable_p = false;
3045
3046   cand = &cands;
3047   while (*cand)
3048     {
3049       struct z_candidate *c = *cand;
3050       if (strict_p ? c->viable == 1 : c->viable)
3051         {
3052           *last_viable = c;
3053           *cand = c->next;
3054           c->next = NULL;
3055           last_viable = &c->next;
3056           *any_viable_p = true;
3057         }
3058       else
3059         cand = &c->next;
3060     }
3061
3062   return viable ? viable : cands;
3063 }
3064
3065 static bool
3066 any_strictly_viable (struct z_candidate *cands)
3067 {
3068   for (; cands; cands = cands->next)
3069     if (cands->viable == 1)
3070       return true;
3071   return false;
3072 }
3073
3074 /* OBJ is being used in an expression like "OBJ.f (...)".  In other
3075    words, it is about to become the "this" pointer for a member
3076    function call.  Take the address of the object.  */
3077
3078 static tree
3079 build_this (tree obj)
3080 {
3081   /* In a template, we are only concerned about the type of the
3082      expression, so we can take a shortcut.  */
3083   if (processing_template_decl)
3084     return build_address (obj);
3085
3086   return cp_build_addr_expr (obj, tf_warning_or_error);
3087 }
3088
3089 /* Returns true iff functions are equivalent. Equivalent functions are
3090    not '==' only if one is a function-local extern function or if
3091    both are extern "C".  */
3092
3093 static inline int
3094 equal_functions (tree fn1, tree fn2)
3095 {
3096   if (TREE_CODE (fn1) != TREE_CODE (fn2))
3097     return 0;
3098   if (TREE_CODE (fn1) == TEMPLATE_DECL)
3099     return fn1 == fn2;
3100   if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
3101       || DECL_EXTERN_C_FUNCTION_P (fn1))
3102     return decls_match (fn1, fn2);
3103   return fn1 == fn2;
3104 }
3105
3106 /* Print information about a candidate being rejected due to INFO.  */
3107
3108 static void
3109 print_conversion_rejection (location_t loc, struct conversion_info *info)
3110 {
3111   if (info->n_arg == -1)
3112     /* Conversion of implicit `this' argument failed.  */
3113     inform (loc, "  no known conversion for implicit "
3114             "%<this%> parameter from %qT to %qT",
3115             info->from_type, info->to_type);
3116   else
3117     inform (loc, "  no known conversion for argument %d from %qT to %qT",
3118             info->n_arg+1, info->from_type, info->to_type);
3119 }
3120
3121 /* Print information about a candidate with WANT parameters and we found
3122    HAVE.  */
3123
3124 static void
3125 print_arity_information (location_t loc, unsigned int have, unsigned int want)
3126 {
3127   inform_n (loc, want,
3128             "  candidate expects %d argument, %d provided",
3129             "  candidate expects %d arguments, %d provided",
3130             want, have);
3131 }
3132
3133 /* Print information about one overload candidate CANDIDATE.  MSGSTR
3134    is the text to print before the candidate itself.
3135
3136    NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3137    to have been run through gettext by the caller.  This wart makes
3138    life simpler in print_z_candidates and for the translators.  */
3139
3140 static void
3141 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
3142 {
3143   const char *msg = (msgstr == NULL
3144                      ? ""
3145                      : ACONCAT ((msgstr, " ", NULL)));
3146   location_t loc = location_of (candidate->fn);
3147
3148   if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
3149     {
3150       if (candidate->num_convs == 3)
3151         inform (input_location, "%s%D(%T, %T, %T) <built-in>", msg, candidate->fn,
3152                 candidate->convs[0]->type,
3153                 candidate->convs[1]->type,
3154                 candidate->convs[2]->type);
3155       else if (candidate->num_convs == 2)
3156         inform (input_location, "%s%D(%T, %T) <built-in>", msg, candidate->fn,
3157                 candidate->convs[0]->type,
3158                 candidate->convs[1]->type);
3159       else
3160         inform (input_location, "%s%D(%T) <built-in>", msg, candidate->fn,
3161                 candidate->convs[0]->type);
3162     }
3163   else if (TYPE_P (candidate->fn))
3164     inform (input_location, "%s%T <conversion>", msg, candidate->fn);
3165   else if (candidate->viable == -1)
3166     inform (loc, "%s%#D <near match>", msg, candidate->fn);
3167   else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
3168     inform (loc, "%s%#D <deleted>", msg, candidate->fn);
3169   else
3170     inform (loc, "%s%#D", msg, candidate->fn);
3171   /* Give the user some information about why this candidate failed.  */
3172   if (candidate->reason != NULL)
3173     {
3174       struct rejection_reason *r = candidate->reason;
3175
3176       switch (r->code)
3177         {
3178         case rr_arity:
3179           print_arity_information (loc, r->u.arity.actual,
3180                                    r->u.arity.expected);
3181           break;
3182         case rr_arg_conversion:
3183           print_conversion_rejection (loc, &r->u.conversion);
3184           break;
3185         case rr_bad_arg_conversion:
3186           print_conversion_rejection (loc, &r->u.bad_conversion);
3187           break;
3188         case rr_explicit_conversion:
3189           inform (loc, "  return type %qT of explicit conversion function "
3190                   "cannot be converted to %qT with a qualification "
3191                   "conversion", r->u.conversion.from_type,
3192                   r->u.conversion.to_type);
3193           break;
3194         case rr_template_conversion:
3195           inform (loc, "  conversion from return type %qT of template "
3196                   "conversion function specialization to %qT is not an "
3197                   "exact match", r->u.conversion.from_type,
3198                   r->u.conversion.to_type);
3199           break;
3200         case rr_template_unification:
3201           /* We use template_unification_error_rejection if unification caused
3202              actual non-SFINAE errors, in which case we don't need to repeat
3203              them here.  */
3204           if (r->u.template_unification.tmpl == NULL_TREE)
3205             {
3206               inform (loc, "  substitution of deduced template arguments "
3207                       "resulted in errors seen above");
3208               break;
3209             }
3210           /* Re-run template unification with diagnostics.  */
3211           inform (loc, "  template argument deduction/substitution failed:");
3212           fn_type_unification (r->u.template_unification.tmpl,
3213                                r->u.template_unification.explicit_targs,
3214                                r->u.template_unification.targs,
3215                                r->u.template_unification.args,
3216                                r->u.template_unification.nargs,
3217                                r->u.template_unification.return_type,
3218                                r->u.template_unification.strict,
3219                                r->u.template_unification.flags,
3220                                true);
3221           break;
3222         case rr_template_instantiation:
3223           /* Re-run template instantiation with diagnostics.  */
3224           instantiate_template (r->u.template_instantiation.tmpl,
3225                                 r->u.template_instantiation.targs,
3226                                 tf_warning_or_error);
3227           break;
3228         case rr_invalid_copy:
3229           inform (loc,
3230                   "  a constructor taking a single argument of its own "
3231                   "class type is invalid");
3232           break;
3233         case rr_none:
3234         default:
3235           /* This candidate didn't have any issues or we failed to
3236              handle a particular code.  Either way...  */
3237           gcc_unreachable ();
3238         }
3239     }
3240 }
3241
3242 static void
3243 print_z_candidates (location_t loc, struct z_candidate *candidates)
3244 {
3245   struct z_candidate *cand1;
3246   struct z_candidate **cand2;
3247   int n_candidates;
3248
3249   if (!candidates)
3250     return;
3251
3252   /* Remove non-viable deleted candidates.  */
3253   cand1 = candidates;
3254   for (cand2 = &cand1; *cand2; )
3255     {
3256       if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
3257           && !(*cand2)->viable
3258           && DECL_DELETED_FN ((*cand2)->fn))
3259         *cand2 = (*cand2)->next;
3260       else
3261         cand2 = &(*cand2)->next;
3262     }
3263   /* ...if there are any non-deleted ones.  */
3264   if (cand1)
3265     candidates = cand1;
3266
3267   /* There may be duplicates in the set of candidates.  We put off
3268      checking this condition as long as possible, since we have no way
3269      to eliminate duplicates from a set of functions in less than n^2
3270      time.  Now we are about to emit an error message, so it is more
3271      permissible to go slowly.  */
3272   for (cand1 = candidates; cand1; cand1 = cand1->next)
3273     {
3274       tree fn = cand1->fn;
3275       /* Skip builtin candidates and conversion functions.  */
3276       if (!DECL_P (fn))
3277         continue;
3278       cand2 = &cand1->next;
3279       while (*cand2)
3280         {
3281           if (DECL_P ((*cand2)->fn)
3282               && equal_functions (fn, (*cand2)->fn))
3283             *cand2 = (*cand2)->next;
3284           else
3285             cand2 = &(*cand2)->next;
3286         }
3287     }
3288
3289   for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next)
3290     n_candidates++;
3291
3292   inform_n (loc, n_candidates, "candidate is:", "candidates are:");
3293   for (; candidates; candidates = candidates->next)
3294     print_z_candidate (NULL, candidates);
3295 }
3296
3297 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3298    USER_CONV.  STD_SEQ is the standard conversion sequence applied to
3299    the result of the conversion function to convert it to the final
3300    desired type.  Merge the two sequences into a single sequence,
3301    and return the merged sequence.  */
3302
3303 static conversion *
3304 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
3305 {
3306   conversion **t;
3307   bool bad = user_seq->bad_p;
3308
3309   gcc_assert (user_seq->kind == ck_user);
3310
3311   /* Find the end of the second conversion sequence.  */
3312   for (t = &std_seq; (*t)->kind != ck_identity; t = &((*t)->u.next))
3313     {
3314       /* The entire sequence is a user-conversion sequence.  */
3315       (*t)->user_conv_p = true;
3316       if (bad)
3317         (*t)->bad_p = true;
3318     }
3319
3320   /* Replace the identity conversion with the user conversion
3321      sequence.  */
3322   *t = user_seq;
3323
3324   return std_seq;
3325 }
3326
3327 /* Handle overload resolution for initializing an object of class type from
3328    an initializer list.  First we look for a suitable constructor that
3329    takes a std::initializer_list; if we don't find one, we then look for a
3330    non-list constructor.
3331
3332    Parameters are as for add_candidates, except that the arguments are in
3333    the form of a CONSTRUCTOR (the initializer list) rather than a VEC, and
3334    the RETURN_TYPE parameter is replaced by TOTYPE, the desired type.  */
3335
3336 static void
3337 add_list_candidates (tree fns, tree first_arg,
3338                      tree init_list, tree totype,
3339                      tree explicit_targs, bool template_only,
3340                      tree conversion_path, tree access_path,
3341                      int flags,
3342                      struct z_candidate **candidates)
3343 {
3344   VEC(tree,gc) *args;
3345
3346   gcc_assert (*candidates == NULL);
3347
3348   /* We're looking for a ctor for list-initialization.  */
3349   flags |= LOOKUP_LIST_INIT_CTOR;
3350   /* And we don't allow narrowing conversions.  We also use this flag to
3351      avoid the copy constructor call for copy-list-initialization.  */
3352   flags |= LOOKUP_NO_NARROWING;
3353
3354   /* Always use the default constructor if the list is empty (DR 990).  */
3355   if (CONSTRUCTOR_NELTS (init_list) == 0
3356       && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
3357     ;
3358   /* If the class has a list ctor, try passing the list as a single
3359      argument first, but only consider list ctors.  */
3360   else if (TYPE_HAS_LIST_CTOR (totype))
3361     {
3362       flags |= LOOKUP_LIST_ONLY;
3363       args = make_tree_vector_single (init_list);
3364       add_candidates (fns, first_arg, args, NULL_TREE,
3365                       explicit_targs, template_only, conversion_path,
3366                       access_path, flags, candidates);
3367       if (any_strictly_viable (*candidates))
3368         return;
3369     }
3370
3371   args = ctor_to_vec (init_list);
3372
3373   /* We aren't looking for list-ctors anymore.  */
3374   flags &= ~LOOKUP_LIST_ONLY;
3375   /* We allow more user-defined conversions within an init-list.  */
3376   flags &= ~LOOKUP_NO_CONVERSION;
3377
3378   add_candidates (fns, first_arg, args, NULL_TREE,
3379                   explicit_targs, template_only, conversion_path,
3380                   access_path, flags, candidates);
3381 }
3382
3383 /* Returns the best overload candidate to perform the requested
3384    conversion.  This function is used for three the overloading situations
3385    described in [over.match.copy], [over.match.conv], and [over.match.ref].
3386    If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3387    per [dcl.init.ref], so we ignore temporary bindings.  */
3388
3389 static struct z_candidate *
3390 build_user_type_conversion_1 (tree totype, tree expr, int flags)
3391 {
3392   struct z_candidate *candidates, *cand;
3393   tree fromtype;
3394   tree ctors = NULL_TREE;
3395   tree conv_fns = NULL_TREE;
3396   conversion *conv = NULL;
3397   tree first_arg = NULL_TREE;
3398   VEC(tree,gc) *args = NULL;
3399   bool any_viable_p;
3400   int convflags;
3401
3402   if (!expr)
3403     return NULL;
3404
3405   fromtype = TREE_TYPE (expr);
3406
3407   /* We represent conversion within a hierarchy using RVALUE_CONV and
3408      BASE_CONV, as specified by [over.best.ics]; these become plain
3409      constructor calls, as specified in [dcl.init].  */
3410   gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
3411               || !DERIVED_FROM_P (totype, fromtype));
3412
3413   if (MAYBE_CLASS_TYPE_P (totype))
3414     /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3415        creating a garbage BASELINK; constructors can't be inherited.  */
3416     ctors = lookup_fnfields_slot (totype, complete_ctor_identifier);
3417
3418   if (MAYBE_CLASS_TYPE_P (fromtype))
3419     {
3420       tree to_nonref = non_reference (totype);
3421       if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
3422           (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
3423            && DERIVED_FROM_P (to_nonref, fromtype)))
3424         {
3425           /* [class.conv.fct] A conversion function is never used to
3426              convert a (possibly cv-qualified) object to the (possibly
3427              cv-qualified) same object type (or a reference to it), to a
3428              (possibly cv-qualified) base class of that type (or a
3429              reference to it)...  */
3430         }
3431       else
3432         conv_fns = lookup_conversions (fromtype);
3433     }
3434
3435   candidates = 0;
3436   flags |= LOOKUP_NO_CONVERSION;
3437   if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3438     flags |= LOOKUP_NO_NARROWING;
3439
3440   /* It's OK to bind a temporary for converting constructor arguments, but
3441      not in converting the return value of a conversion operator.  */
3442   convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
3443   flags &= ~LOOKUP_NO_TEMP_BIND;
3444
3445   if (ctors)
3446     {
3447       int ctorflags = flags;
3448
3449       first_arg = build_int_cst (build_pointer_type (totype), 0);
3450
3451       /* We should never try to call the abstract or base constructor
3452          from here.  */
3453       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
3454                   && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
3455
3456       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3457         {
3458           /* List-initialization.  */
3459           add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
3460                                false, TYPE_BINFO (totype), TYPE_BINFO (totype),
3461                                ctorflags, &candidates);
3462         }
3463       else
3464         {
3465           args = make_tree_vector_single (expr);
3466           add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
3467                           TYPE_BINFO (totype), TYPE_BINFO (totype),
3468                           ctorflags, &candidates);
3469         }
3470
3471       for (cand = candidates; cand; cand = cand->next)
3472         {
3473           cand->second_conv = build_identity_conv (totype, NULL_TREE);
3474
3475           /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3476              set, then this is copy-initialization.  In that case, "The
3477              result of the call is then used to direct-initialize the
3478              object that is the destination of the copy-initialization."
3479              [dcl.init]
3480
3481              We represent this in the conversion sequence with an
3482              rvalue conversion, which means a constructor call.  */
3483           if (TREE_CODE (totype) != REFERENCE_TYPE
3484               && !(convflags & LOOKUP_NO_TEMP_BIND))
3485             cand->second_conv
3486               = build_conv (ck_rvalue, totype, cand->second_conv);
3487         }
3488     }
3489
3490   if (conv_fns)
3491     first_arg = build_this (expr);
3492
3493   for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3494     {
3495       tree conversion_path = TREE_PURPOSE (conv_fns);
3496       struct z_candidate *old_candidates;
3497
3498       /* If we are called to convert to a reference type, we are trying to
3499          find a direct binding, so don't even consider temporaries.  If
3500          we don't find a direct binding, the caller will try again to
3501          look for a temporary binding.  */
3502       if (TREE_CODE (totype) == REFERENCE_TYPE)
3503         convflags |= LOOKUP_NO_TEMP_BIND;
3504
3505       old_candidates = candidates;
3506       add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3507                       NULL_TREE, false,
3508                       conversion_path, TYPE_BINFO (fromtype),
3509                       flags, &candidates);
3510
3511       for (cand = candidates; cand != old_candidates; cand = cand->next)
3512         {
3513           tree rettype = TREE_TYPE (TREE_TYPE (cand->fn));
3514           conversion *ics
3515             = implicit_conversion (totype,
3516                                    rettype,
3517                                    0,
3518                                    /*c_cast_p=*/false, convflags);
3519
3520           /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3521              copy-initialization.  In that case, "The result of the
3522              call is then used to direct-initialize the object that is
3523              the destination of the copy-initialization."  [dcl.init]
3524
3525              We represent this in the conversion sequence with an
3526              rvalue conversion, which means a constructor call.  But
3527              don't add a second rvalue conversion if there's already
3528              one there.  Which there really shouldn't be, but it's
3529              harmless since we'd add it here anyway. */
3530           if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3531               && !(convflags & LOOKUP_NO_TEMP_BIND))
3532             ics = build_conv (ck_rvalue, totype, ics);
3533
3534           cand->second_conv = ics;
3535
3536           if (!ics)
3537             {
3538               cand->viable = 0;
3539               cand->reason = arg_conversion_rejection (NULL_TREE, -1,
3540                                                        rettype, totype);
3541             }
3542           else if (DECL_NONCONVERTING_P (cand->fn)
3543                    && ics->rank > cr_exact)
3544             {
3545               /* 13.3.1.5: For direct-initialization, those explicit
3546                  conversion functions that are not hidden within S and
3547                  yield type T or a type that can be converted to type T
3548                  with a qualification conversion (4.4) are also candidate
3549                  functions.  */
3550               /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3551                  I've raised this issue with the committee. --jason 9/2011 */
3552               cand->viable = -1;
3553               cand->reason = explicit_conversion_rejection (rettype, totype);
3554             }
3555           else if (cand->viable == 1 && ics->bad_p)
3556             {
3557               cand->viable = -1;
3558               cand->reason
3559                 = bad_arg_conversion_rejection (NULL_TREE, -1,
3560                                                 rettype, totype);
3561             }
3562           else if (primary_template_instantiation_p (cand->fn)
3563                    && ics->rank > cr_exact)
3564             {
3565               /* 13.3.3.1.2: If the user-defined conversion is specified by
3566                  a specialization of a conversion function template, the
3567                  second standard conversion sequence shall have exact match
3568                  rank.  */
3569               cand->viable = -1;
3570               cand->reason = template_conversion_rejection (rettype, totype);
3571             }
3572         }
3573     }
3574
3575   candidates = splice_viable (candidates, pedantic, &any_viable_p);
3576   if (!any_viable_p)
3577     {
3578       if (args)
3579         release_tree_vector (args);
3580       return NULL;
3581     }
3582
3583   cand = tourney (candidates);
3584   if (cand == 0)
3585     {
3586       if (flags & LOOKUP_COMPLAIN)
3587         {
3588           error ("conversion from %qT to %qT is ambiguous",
3589                     fromtype, totype);
3590           print_z_candidates (location_of (expr), candidates);
3591         }
3592
3593       cand = candidates;        /* any one will do */
3594       cand->second_conv = build_ambiguous_conv (totype, expr);
3595       cand->second_conv->user_conv_p = true;
3596       if (!any_strictly_viable (candidates))
3597         cand->second_conv->bad_p = true;
3598       /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3599          ambiguous conversion is no worse than another user-defined
3600          conversion.  */
3601
3602       return cand;
3603     }
3604
3605   /* Build the user conversion sequence.  */
3606   conv = build_conv
3607     (ck_user,
3608      (DECL_CONSTRUCTOR_P (cand->fn)
3609       ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3610      build_identity_conv (TREE_TYPE (expr), expr));
3611   conv->cand = cand;
3612   if (cand->viable == -1)
3613     conv->bad_p = true;
3614
3615   /* Remember that this was a list-initialization.  */
3616   if (flags & LOOKUP_NO_NARROWING)
3617     conv->check_narrowing = true;
3618
3619   /* Combine it with the second conversion sequence.  */
3620   cand->second_conv = merge_conversion_sequences (conv,
3621                                                   cand->second_conv);
3622
3623   return cand;
3624 }
3625
3626 /* Wrapper for above. */
3627
3628 tree
3629 build_user_type_conversion (tree totype, tree expr, int flags)
3630 {
3631   struct z_candidate *cand;
3632   tree ret;
3633
3634   bool subtime = timevar_cond_start (TV_OVERLOAD);
3635   cand = build_user_type_conversion_1 (totype, expr, flags);
3636
3637   if (cand)
3638     {
3639       if (cand->second_conv->kind == ck_ambig)
3640         ret = error_mark_node;
3641       else
3642         {
3643           expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3644           ret = convert_from_reference (expr);
3645         }
3646     }
3647   else
3648     ret = NULL_TREE;
3649
3650   timevar_cond_stop (TV_OVERLOAD, subtime);
3651   return ret;
3652 }
3653
3654 /* Subroutine of convert_nontype_argument.
3655
3656    EXPR is an argument for a template non-type parameter of integral or
3657    enumeration type.  Do any necessary conversions (that are permitted for
3658    non-type arguments) to convert it to the parameter type.
3659
3660    If conversion is successful, returns the converted expression;
3661    otherwise, returns error_mark_node.  */
3662
3663 tree
3664 build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain)
3665 {
3666   conversion *conv;
3667   void *p;
3668   tree t;
3669
3670   if (error_operand_p (expr))
3671     return error_mark_node;
3672
3673   gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3674
3675   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3676   p = conversion_obstack_alloc (0);
3677
3678   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
3679                               /*c_cast_p=*/false,
3680                               LOOKUP_IMPLICIT);
3681
3682   /* for a non-type template-parameter of integral or
3683      enumeration type, integral promotions (4.5) and integral
3684      conversions (4.7) are applied.  */
3685   /* It should be sufficient to check the outermost conversion step, since
3686      there are no qualification conversions to integer type.  */
3687   if (conv)
3688     switch (conv->kind)
3689       {
3690         /* A conversion function is OK.  If it isn't constexpr, we'll
3691            complain later that the argument isn't constant.  */
3692       case ck_user:
3693         /* The lvalue-to-rvalue conversion is OK.  */
3694       case ck_rvalue:
3695       case ck_identity:
3696         break;
3697
3698       case ck_std:
3699         t = conv->u.next->type;
3700         if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
3701           break;
3702
3703         if (complain & tf_error)
3704           error ("conversion from %qT to %qT not considered for "
3705                  "non-type template argument", t, type);
3706         /* and fall through.  */
3707
3708       default:
3709         conv = NULL;
3710         break;
3711       }
3712
3713   if (conv)
3714     expr = convert_like (conv, expr, complain);
3715   else
3716     expr = error_mark_node;
3717
3718   /* Free all the conversions we allocated.  */
3719   obstack_free (&conversion_obstack, p);
3720
3721   return expr;
3722 }
3723
3724 /* Do any initial processing on the arguments to a function call.  */
3725
3726 static VEC(tree,gc) *
3727 resolve_args (VEC(tree,gc) *args, tsubst_flags_t complain)
3728 {
3729   unsigned int ix;
3730   tree arg;
3731
3732   FOR_EACH_VEC_ELT (tree, args, ix, arg)
3733     {
3734       if (error_operand_p (arg))
3735         return NULL;
3736       else if (VOID_TYPE_P (TREE_TYPE (arg)))
3737         {
3738           if (complain & tf_error)
3739             error ("invalid use of void expression");
3740           return NULL;
3741         }
3742       else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3743         return NULL;
3744     }
3745   return args;
3746 }
3747
3748 /* Perform overload resolution on FN, which is called with the ARGS.
3749
3750    Return the candidate function selected by overload resolution, or
3751    NULL if the event that overload resolution failed.  In the case
3752    that overload resolution fails, *CANDIDATES will be the set of
3753    candidates considered, and ANY_VIABLE_P will be set to true or
3754    false to indicate whether or not any of the candidates were
3755    viable.
3756
3757    The ARGS should already have gone through RESOLVE_ARGS before this
3758    function is called.  */
3759
3760 static struct z_candidate *
3761 perform_overload_resolution (tree fn,
3762                              const VEC(tree,gc) *args,
3763                              struct z_candidate **candidates,
3764                              bool *any_viable_p)
3765 {
3766   struct z_candidate *cand;
3767   tree explicit_targs;
3768   int template_only;
3769
3770   bool subtime = timevar_cond_start (TV_OVERLOAD);
3771
3772   explicit_targs = NULL_TREE;
3773   template_only = 0;
3774
3775   *candidates = NULL;
3776   *any_viable_p = true;
3777
3778   /* Check FN.  */
3779   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3780               || TREE_CODE (fn) == TEMPLATE_DECL
3781               || TREE_CODE (fn) == OVERLOAD
3782               || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3783
3784   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3785     {
3786       explicit_targs = TREE_OPERAND (fn, 1);
3787       fn = TREE_OPERAND (fn, 0);
3788       template_only = 1;
3789     }
3790
3791   /* Add the various candidate functions.  */
3792   add_candidates (fn, NULL_TREE, args, NULL_TREE,
3793                   explicit_targs, template_only,
3794                   /*conversion_path=*/NULL_TREE,
3795                   /*access_path=*/NULL_TREE,
3796                   LOOKUP_NORMAL,
3797                   candidates);
3798
3799   *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3800   if (*any_viable_p)
3801     cand = tourney (*candidates);
3802   else
3803     cand = NULL;
3804
3805   timevar_cond_stop (TV_OVERLOAD, subtime);
3806   return cand;
3807 }
3808
3809 /* Print an error message about being unable to build a call to FN with
3810    ARGS.  ANY_VIABLE_P indicates whether any candidate functions could
3811    be located; CANDIDATES is a possibly empty list of such
3812    functions.  */
3813
3814 static void
3815 print_error_for_call_failure (tree fn, VEC(tree,gc) *args, bool any_viable_p,
3816                               struct z_candidate *candidates)
3817 {
3818   tree name = DECL_NAME (OVL_CURRENT (fn));
3819   location_t loc = location_of (name);
3820
3821   if (!any_viable_p)
3822     error_at (loc, "no matching function for call to %<%D(%A)%>",
3823               name, build_tree_list_vec (args));
3824   else
3825     error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous",
3826               name, build_tree_list_vec (args));
3827   if (candidates)
3828     print_z_candidates (loc, candidates);
3829 }
3830
3831 /* Return an expression for a call to FN (a namespace-scope function,
3832    or a static member function) with the ARGS.  This may change
3833    ARGS.  */
3834
3835 tree
3836 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p, 
3837                          tsubst_flags_t complain)
3838 {
3839   struct z_candidate *candidates, *cand;
3840   bool any_viable_p;
3841   void *p;
3842   tree result;
3843
3844   if (args != NULL && *args != NULL)
3845     {
3846       *args = resolve_args (*args, complain);
3847       if (*args == NULL)
3848         return error_mark_node;
3849     }
3850
3851   if (flag_tm)
3852     tm_malloc_replacement (fn);
3853
3854   /* If this function was found without using argument dependent
3855      lookup, then we want to ignore any undeclared friend
3856      functions.  */
3857   if (!koenig_p)
3858     {
3859       tree orig_fn = fn;
3860
3861       fn = remove_hidden_names (fn);
3862       if (!fn)
3863         {
3864           if (complain & tf_error)
3865             print_error_for_call_failure (orig_fn, *args, false, NULL);
3866           return error_mark_node;
3867         }
3868     }
3869
3870   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3871   p = conversion_obstack_alloc (0);
3872
3873   cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3874
3875   if (!cand)
3876     {
3877       if (complain & tf_error)
3878         {
3879           if (!any_viable_p && candidates && ! candidates->next
3880               && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3881             return cp_build_function_call_vec (candidates->fn, args, complain);
3882           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3883             fn = TREE_OPERAND (fn, 0);
3884           print_error_for_call_failure (fn, *args, any_viable_p, candidates);
3885         }
3886       result = error_mark_node;
3887     }
3888   else
3889     {
3890       int flags = LOOKUP_NORMAL;
3891       /* If fn is template_id_expr, the call has explicit template arguments
3892          (e.g. func<int>(5)), communicate this info to build_over_call
3893          through flags so that later we can use it to decide whether to warn
3894          about peculiar null pointer conversion.  */
3895       if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3896         flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
3897       result = build_over_call (cand, flags, complain);
3898     }
3899
3900   /* Free all the conversions we allocated.  */
3901   obstack_free (&conversion_obstack, p);
3902
3903   return result;
3904 }
3905
3906 /* Build a call to a global operator new.  FNNAME is the name of the
3907    operator (either "operator new" or "operator new[]") and ARGS are
3908    the arguments provided.  This may change ARGS.  *SIZE points to the
3909    total number of bytes required by the allocation, and is updated if
3910    that is changed here.  *COOKIE_SIZE is non-NULL if a cookie should
3911    be used.  If this function determines that no cookie should be
3912    used, after all, *COOKIE_SIZE is set to NULL_TREE.  If FN is
3913    non-NULL, it will be set, upon return, to the allocation function
3914    called.  */
3915
3916 tree
3917 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3918                          tree *size, tree *cookie_size,
3919                          tree *fn)
3920 {
3921   tree fns;
3922   struct z_candidate *candidates;
3923   struct z_candidate *cand;
3924   bool any_viable_p;
3925
3926   if (fn)
3927     *fn = NULL_TREE;
3928   VEC_safe_insert (tree, gc, *args, 0, *size);
3929   *args = resolve_args (*args, tf_warning_or_error);
3930   if (*args == NULL)
3931     return error_mark_node;
3932
3933   /* Based on:
3934
3935        [expr.new]
3936
3937        If this lookup fails to find the name, or if the allocated type
3938        is not a class type, the allocation function's name is looked
3939        up in the global scope.
3940
3941      we disregard block-scope declarations of "operator new".  */
3942   fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3943
3944   /* Figure out what function is being called.  */
3945   cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3946
3947   /* If no suitable function could be found, issue an error message
3948      and give up.  */
3949   if (!cand)
3950     {
3951       print_error_for_call_failure (fns, *args, any_viable_p, candidates);
3952       return error_mark_node;
3953     }
3954
3955    /* If a cookie is required, add some extra space.  Whether
3956       or not a cookie is required cannot be determined until
3957       after we know which function was called.  */
3958    if (*cookie_size)
3959      {
3960        bool use_cookie = true;
3961        if (!abi_version_at_least (2))
3962          {
3963            /* In G++ 3.2, the check was implemented incorrectly; it
3964               looked at the placement expression, rather than the
3965               type of the function.  */
3966            if (VEC_length (tree, *args) == 2
3967                && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3968                                ptr_type_node))
3969              use_cookie = false;
3970          }
3971        else
3972          {
3973            tree arg_types;
3974
3975            arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3976            /* Skip the size_t parameter.  */
3977            arg_types = TREE_CHAIN (arg_types);
3978            /* Check the remaining parameters (if any).  */
3979            if (arg_types
3980                && TREE_CHAIN (arg_types) == void_list_node
3981                && same_type_p (TREE_VALUE (arg_types),
3982                                ptr_type_node))
3983              use_cookie = false;
3984          }
3985        /* If we need a cookie, adjust the number of bytes allocated.  */
3986        if (use_cookie)
3987          {
3988            /* Update the total size.  */
3989            *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3990            /* Update the argument list to reflect the adjusted size.  */
3991            VEC_replace (tree, *args, 0, *size);
3992          }
3993        else
3994          *cookie_size = NULL_TREE;
3995      }
3996
3997    /* Tell our caller which function we decided to call.  */
3998    if (fn)
3999      *fn = cand->fn;
4000
4001    /* Build the CALL_EXPR.  */
4002    return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
4003 }
4004
4005 /* Build a new call to operator().  This may change ARGS.  */
4006
4007 static tree
4008 build_op_call_1 (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
4009 {
4010   struct z_candidate *candidates = 0, *cand;
4011   tree fns, convs, first_mem_arg = NULL_TREE;
4012   tree type = TREE_TYPE (obj);
4013   bool any_viable_p;
4014   tree result = NULL_TREE;
4015   void *p;
4016
4017   if (error_operand_p (obj))
4018     return error_mark_node;
4019
4020   obj = prep_operand (obj);
4021
4022   if (TYPE_PTRMEMFUNC_P (type))
4023     {
4024       if (complain & tf_error)
4025         /* It's no good looking for an overloaded operator() on a
4026            pointer-to-member-function.  */
4027         error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
4028       return error_mark_node;
4029     }
4030
4031   if (TYPE_BINFO (type))
4032     {
4033       fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
4034       if (fns == error_mark_node)
4035         return error_mark_node;
4036     }
4037   else
4038     fns = NULL_TREE;
4039
4040   if (args != NULL && *args != NULL)
4041     {
4042       *args = resolve_args (*args, complain);
4043       if (*args == NULL)
4044         return error_mark_node;
4045     }
4046
4047   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
4048   p = conversion_obstack_alloc (0);
4049
4050   if (fns)
4051     {
4052       first_mem_arg = build_this (obj);
4053
4054       add_candidates (BASELINK_FUNCTIONS (fns),
4055                       first_mem_arg, *args, NULL_TREE,
4056                       NULL_TREE, false,
4057                       BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
4058                       LOOKUP_NORMAL, &candidates);
4059     }
4060
4061   convs = lookup_conversions (type);
4062
4063   for (; convs; convs = TREE_CHAIN (convs))
4064     {
4065       tree fns = TREE_VALUE (convs);
4066       tree totype = TREE_TYPE (convs);
4067
4068       if ((TREE_CODE (totype) == POINTER_TYPE
4069            && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
4070           || (TREE_CODE (totype) == REFERENCE_TYPE
4071               && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
4072           || (TREE_CODE (totype) == REFERENCE_TYPE
4073               && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
4074               && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
4075         for (; fns; fns = OVL_NEXT (fns))
4076           {
4077             tree fn = OVL_CURRENT (fns);
4078
4079             if (DECL_NONCONVERTING_P (fn))
4080               continue;
4081
4082             if (TREE_CODE (fn) == TEMPLATE_DECL)
4083               add_template_conv_candidate
4084                 (&candidates, fn, obj, NULL_TREE, *args, totype,
4085                  /*access_path=*/NULL_TREE,
4086                  /*conversion_path=*/NULL_TREE);
4087             else
4088               add_conv_candidate (&candidates, fn, obj, NULL_TREE,
4089                                   *args, /*conversion_path=*/NULL_TREE,
4090                                   /*access_path=*/NULL_TREE);
4091           }
4092     }
4093
4094   candidates = splice_viable (candidates, pedantic, &any_viable_p);
4095   if (!any_viable_p)
4096     {
4097       if (complain & tf_error)
4098         {
4099           error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
4100                  build_tree_list_vec (*args));
4101           print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4102         }
4103       result = error_mark_node;
4104     }
4105   else
4106     {
4107       cand = tourney (candidates);
4108       if (cand == 0)
4109         {
4110           if (complain & tf_error)
4111             {
4112               error ("call of %<(%T) (%A)%> is ambiguous", 
4113                      TREE_TYPE (obj), build_tree_list_vec (*args));
4114               print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4115             }
4116           result = error_mark_node;
4117         }
4118       /* Since cand->fn will be a type, not a function, for a conversion
4119          function, we must be careful not to unconditionally look at
4120          DECL_NAME here.  */
4121       else if (TREE_CODE (cand->fn) == FUNCTION_DECL
4122                && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
4123         result = build_over_call (cand, LOOKUP_NORMAL, complain);
4124       else
4125         {
4126           obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
4127                                            complain);
4128           obj = convert_from_reference (obj);
4129           result = cp_build_function_call_vec (obj, args, complain);
4130         }
4131     }
4132
4133   /* Free all the conversions we allocated.  */
4134   obstack_free (&conversion_obstack, p);
4135
4136   return result;
4137 }
4138
4139 /* Wrapper for above.  */
4140
4141 tree
4142 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
4143 {
4144   tree ret;
4145   bool subtime = timevar_cond_start (TV_OVERLOAD);
4146   ret = build_op_call_1 (obj, args, complain);