OSDN Git Service

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