OSDN Git Service

dd716a40e3beb6d19003ddd373f585b3c88aaa6b
[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               && !(flags & LOOKUP_ONLYCONVERTING)
1960               && DECL_CONSTRUCTOR_P (fn)
1961               && parmtype != error_mark_node
1962               && (same_type_ignoring_top_level_qualifiers_p
1963                   (non_reference (parmtype), ctype)))
1964             {
1965               lflags |= LOOKUP_COPY_PARM;
1966               /* We allow user-defined conversions within init-lists, but
1967                  not for the copy constructor.  */
1968               if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1969                 lflags |= LOOKUP_NO_CONVERSION;
1970             }
1971           else
1972             lflags |= LOOKUP_ONLYCONVERTING;
1973
1974           t = implicit_conversion (parmtype, argtype, arg,
1975                                    /*c_cast_p=*/false, lflags);
1976           to_type = parmtype;
1977         }
1978       else
1979         {
1980           t = build_identity_conv (argtype, arg);
1981           t->ellipsis_p = true;
1982           to_type = argtype;
1983         }
1984
1985       if (t && is_this)
1986         t->this_p = true;
1987
1988       convs[i] = t;
1989       if (! t)
1990         {
1991           viable = 0;
1992           reason = arg_conversion_rejection (first_arg, i, argtype, to_type);
1993           break;
1994         }
1995
1996       if (t->bad_p)
1997         {
1998           viable = -1;
1999           reason = bad_arg_conversion_rejection (first_arg, i, argtype, to_type);
2000         }
2001     }
2002
2003  out:
2004   return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
2005                         access_path, conversion_path, viable, reason);
2006 }
2007
2008 /* Create an overload candidate for the conversion function FN which will
2009    be invoked for expression OBJ, producing a pointer-to-function which
2010    will in turn be called with the argument list FIRST_ARG/ARGLIST,
2011    and add it to CANDIDATES.  This does not change ARGLIST.  FLAGS is
2012    passed on to implicit_conversion.
2013
2014    Actually, we don't really care about FN; we care about the type it
2015    converts to.  There may be multiple conversion functions that will
2016    convert to that type, and we rely on build_user_type_conversion_1 to
2017    choose the best one; so when we create our candidate, we record the type
2018    instead of the function.  */
2019
2020 static struct z_candidate *
2021 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
2022                     tree first_arg, const VEC(tree,gc) *arglist,
2023                     tree access_path, tree conversion_path)
2024 {
2025   tree totype = TREE_TYPE (TREE_TYPE (fn));
2026   int i, len, viable, flags;
2027   tree parmlist, parmnode;
2028   conversion **convs;
2029   struct rejection_reason *reason;
2030
2031   for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
2032     parmlist = TREE_TYPE (parmlist);
2033   parmlist = TYPE_ARG_TYPES (parmlist);
2034
2035   len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
2036   convs = alloc_conversions (len);
2037   parmnode = parmlist;
2038   viable = 1;
2039   flags = LOOKUP_IMPLICIT;
2040   reason = NULL;
2041
2042   /* Don't bother looking up the same type twice.  */
2043   if (*candidates && (*candidates)->fn == totype)
2044     return NULL;
2045
2046   for (i = 0; i < len; ++i)
2047     {
2048       tree arg, argtype, convert_type = NULL_TREE;
2049       conversion *t;
2050
2051       if (i == 0)
2052         arg = obj;
2053       else if (i == 1 && first_arg != NULL_TREE)
2054         arg = first_arg;
2055       else
2056         arg = VEC_index (tree, arglist,
2057                          i - (first_arg != NULL_TREE ? 1 : 0) - 1);
2058       argtype = lvalue_type (arg);
2059
2060       if (i == 0)
2061         {
2062           t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
2063                                    flags);
2064           convert_type = totype;
2065         }
2066       else if (parmnode == void_list_node)
2067         break;
2068       else if (parmnode)
2069         {
2070           t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
2071                                    /*c_cast_p=*/false, flags);
2072           convert_type = TREE_VALUE (parmnode);
2073         }
2074       else
2075         {
2076           t = build_identity_conv (argtype, arg);
2077           t->ellipsis_p = true;
2078           convert_type = argtype;
2079         }
2080
2081       convs[i] = t;
2082       if (! t)
2083         break;
2084
2085       if (t->bad_p)
2086         {
2087           viable = -1;
2088           reason = bad_arg_conversion_rejection (NULL_TREE, i, argtype, convert_type);
2089         }
2090
2091       if (i == 0)
2092         continue;
2093
2094       if (parmnode)
2095         parmnode = TREE_CHAIN (parmnode);
2096     }
2097
2098   if (i < len
2099       || ! sufficient_parms_p (parmnode))
2100     {
2101       int remaining = remaining_arguments (parmnode);
2102       viable = 0;
2103       reason = arity_rejection (NULL_TREE, i + remaining, len);
2104     }
2105
2106   return add_candidate (candidates, totype, first_arg, arglist, len, convs,
2107                         access_path, conversion_path, viable, reason);
2108 }
2109
2110 static void
2111 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
2112                          tree type1, tree type2, tree *args, tree *argtypes,
2113                          int flags)
2114 {
2115   conversion *t;
2116   conversion **convs;
2117   size_t num_convs;
2118   int viable = 1, i;
2119   tree types[2];
2120   struct rejection_reason *reason = NULL;
2121
2122   types[0] = type1;
2123   types[1] = type2;
2124
2125   num_convs =  args[2] ? 3 : (args[1] ? 2 : 1);
2126   convs = alloc_conversions (num_convs);
2127
2128   /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2129      conversion ops are allowed.  We handle that here by just checking for
2130      boolean_type_node because other operators don't ask for it.  COND_EXPR
2131      also does contextual conversion to bool for the first operand, but we
2132      handle that in build_conditional_expr, and type1 here is operand 2.  */
2133   if (type1 != boolean_type_node)
2134     flags |= LOOKUP_ONLYCONVERTING;
2135
2136   for (i = 0; i < 2; ++i)
2137     {
2138       if (! args[i])
2139         break;
2140
2141       t = implicit_conversion (types[i], argtypes[i], args[i],
2142                                /*c_cast_p=*/false, flags);
2143       if (! t)
2144         {
2145           viable = 0;
2146           /* We need something for printing the candidate.  */
2147           t = build_identity_conv (types[i], NULL_TREE);
2148           reason = arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2149         }
2150       else if (t->bad_p)
2151         {
2152           viable = 0;
2153           reason = bad_arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]);
2154         }
2155       convs[i] = t;
2156     }
2157
2158   /* For COND_EXPR we rearranged the arguments; undo that now.  */
2159   if (args[2])
2160     {
2161       convs[2] = convs[1];
2162       convs[1] = convs[0];
2163       t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
2164                                /*c_cast_p=*/false, flags);
2165       if (t)
2166         convs[0] = t;
2167       else
2168         {
2169           viable = 0;
2170           reason = arg_conversion_rejection (NULL_TREE, 0, argtypes[2],
2171                                              boolean_type_node);
2172         }
2173     }
2174
2175   add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
2176                  num_convs, convs,
2177                  /*access_path=*/NULL_TREE,
2178                  /*conversion_path=*/NULL_TREE,
2179                  viable, reason);
2180 }
2181
2182 static bool
2183 is_complete (tree t)
2184 {
2185   return COMPLETE_TYPE_P (complete_type (t));
2186 }
2187
2188 /* Returns nonzero if TYPE is a promoted arithmetic type.  */
2189
2190 static bool
2191 promoted_arithmetic_type_p (tree type)
2192 {
2193   /* [over.built]
2194
2195      In this section, the term promoted integral type is used to refer
2196      to those integral types which are preserved by integral promotion
2197      (including e.g.  int and long but excluding e.g.  char).
2198      Similarly, the term promoted arithmetic type refers to promoted
2199      integral types plus floating types.  */
2200   return ((CP_INTEGRAL_TYPE_P (type)
2201            && same_type_p (type_promotes_to (type), type))
2202           || TREE_CODE (type) == REAL_TYPE);
2203 }
2204
2205 /* Create any builtin operator overload candidates for the operator in
2206    question given the converted operand types TYPE1 and TYPE2.  The other
2207    args are passed through from add_builtin_candidates to
2208    build_builtin_candidate.
2209
2210    TYPE1 and TYPE2 may not be permissible, and we must filter them.
2211    If CODE is requires candidates operands of the same type of the kind
2212    of which TYPE1 and TYPE2 are, we add both candidates
2213    CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2).  */
2214
2215 static void
2216 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
2217                        enum tree_code code2, tree fnname, tree type1,
2218                        tree type2, tree *args, tree *argtypes, int flags)
2219 {
2220   switch (code)
2221     {
2222     case POSTINCREMENT_EXPR:
2223     case POSTDECREMENT_EXPR:
2224       args[1] = integer_zero_node;
2225       type2 = integer_type_node;
2226       break;
2227     default:
2228       break;
2229     }
2230
2231   switch (code)
2232     {
2233
2234 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2235      and  VQ  is  either  volatile or empty, there exist candidate operator
2236      functions of the form
2237              VQ T&   operator++(VQ T&);
2238              T       operator++(VQ T&, int);
2239    5 For every pair T, VQ), where T is an enumeration type or an arithmetic
2240      type  other than bool, and VQ is either volatile or empty, there exist
2241      candidate operator functions of the form
2242              VQ T&   operator--(VQ T&);
2243              T       operator--(VQ T&, int);
2244    6 For every pair T, VQ), where T is  a  cv-qualified  or  cv-unqualified
2245      complete  object type, and VQ is either volatile or empty, there exist
2246      candidate operator functions of the form
2247              T*VQ&   operator++(T*VQ&);
2248              T*VQ&   operator--(T*VQ&);
2249              T*      operator++(T*VQ&, int);
2250              T*      operator--(T*VQ&, int);  */
2251
2252     case POSTDECREMENT_EXPR:
2253     case PREDECREMENT_EXPR:
2254       if (TREE_CODE (type1) == BOOLEAN_TYPE)
2255         return;
2256     case POSTINCREMENT_EXPR:
2257     case PREINCREMENT_EXPR:
2258       if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
2259         {
2260           type1 = build_reference_type (type1);
2261           break;
2262         }
2263       return;
2264
2265 /* 7 For every cv-qualified or cv-unqualified object type T, there
2266      exist candidate operator functions of the form
2267
2268              T&      operator*(T*);
2269
2270    8 For every function type T, there exist candidate operator functions of
2271      the form
2272              T&      operator*(T*);  */
2273
2274     case INDIRECT_REF:
2275       if (TREE_CODE (type1) == POINTER_TYPE
2276           && !uses_template_parms (TREE_TYPE (type1))
2277           && (TYPE_PTROB_P (type1)
2278               || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
2279         break;
2280       return;
2281
2282 /* 9 For every type T, there exist candidate operator functions of the form
2283              T*      operator+(T*);
2284
2285    10For  every  promoted arithmetic type T, there exist candidate operator
2286      functions of the form
2287              T       operator+(T);
2288              T       operator-(T);  */
2289
2290     case UNARY_PLUS_EXPR: /* unary + */
2291       if (TREE_CODE (type1) == POINTER_TYPE)
2292         break;
2293     case NEGATE_EXPR:
2294       if (ARITHMETIC_TYPE_P (type1))
2295         break;
2296       return;
2297
2298 /* 11For every promoted integral type T,  there  exist  candidate  operator
2299      functions of the form
2300              T       operator~(T);  */
2301
2302     case BIT_NOT_EXPR:
2303       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
2304         break;
2305       return;
2306
2307 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2308      is the same type as C2 or is a derived class of C2, T  is  a  complete
2309      object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2310      there exist candidate operator functions of the form
2311              CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2312      where CV12 is the union of CV1 and CV2.  */
2313
2314     case MEMBER_REF:
2315       if (TREE_CODE (type1) == POINTER_TYPE
2316           && TYPE_PTR_TO_MEMBER_P (type2))
2317         {
2318           tree c1 = TREE_TYPE (type1);
2319           tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
2320
2321           if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
2322               && (TYPE_PTRMEMFUNC_P (type2)
2323                   || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
2324             break;
2325         }
2326       return;
2327
2328 /* 13For every pair of promoted arithmetic types L and R, there exist  can-
2329      didate operator functions of the form
2330              LR      operator*(L, R);
2331              LR      operator/(L, R);
2332              LR      operator+(L, R);
2333              LR      operator-(L, R);
2334              bool    operator<(L, R);
2335              bool    operator>(L, R);
2336              bool    operator<=(L, R);
2337              bool    operator>=(L, R);
2338              bool    operator==(L, R);
2339              bool    operator!=(L, R);
2340      where  LR  is  the  result of the usual arithmetic conversions between
2341      types L and R.
2342
2343    14For every pair of types T and I, where T  is  a  cv-qualified  or  cv-
2344      unqualified  complete  object  type and I is a promoted integral type,
2345      there exist candidate operator functions of the form
2346              T*      operator+(T*, I);
2347              T&      operator[](T*, I);
2348              T*      operator-(T*, I);
2349              T*      operator+(I, T*);
2350              T&      operator[](I, T*);
2351
2352    15For every T, where T is a pointer to complete object type, there exist
2353      candidate operator functions of the form112)
2354              ptrdiff_t operator-(T, T);
2355
2356    16For every pointer or enumeration type T, there exist candidate operator
2357      functions of the form
2358              bool    operator<(T, T);
2359              bool    operator>(T, T);
2360              bool    operator<=(T, T);
2361              bool    operator>=(T, T);
2362              bool    operator==(T, T);
2363              bool    operator!=(T, T);
2364
2365    17For every pointer to member type T,  there  exist  candidate  operator
2366      functions of the form
2367              bool    operator==(T, T);
2368              bool    operator!=(T, T);  */
2369
2370     case MINUS_EXPR:
2371       if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2372         break;
2373       if (TYPE_PTROB_P (type1)
2374           && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2375         {
2376           type2 = ptrdiff_type_node;
2377           break;
2378         }
2379     case MULT_EXPR:
2380     case TRUNC_DIV_EXPR:
2381       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2382         break;
2383       return;
2384
2385     case EQ_EXPR:
2386     case NE_EXPR:
2387       if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2388           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2389         break;
2390       if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2391         {
2392           type2 = type1;
2393           break;
2394         }
2395       if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2396         {
2397           type1 = type2;
2398           break;
2399         }
2400       /* Fall through.  */
2401     case LT_EXPR:
2402     case GT_EXPR:
2403     case LE_EXPR:
2404     case GE_EXPR:
2405     case MAX_EXPR:
2406     case MIN_EXPR:
2407       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2408         break;
2409       if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2410         break;
2411       if (TREE_CODE (type1) == ENUMERAL_TYPE 
2412           && TREE_CODE (type2) == ENUMERAL_TYPE)
2413         break;
2414       if (TYPE_PTR_P (type1) 
2415           && null_ptr_cst_p (args[1])
2416           && !uses_template_parms (type1))
2417         {
2418           type2 = type1;
2419           break;
2420         }
2421       if (null_ptr_cst_p (args[0]) 
2422           && TYPE_PTR_P (type2)
2423           && !uses_template_parms (type2))
2424         {
2425           type1 = type2;
2426           break;
2427         }
2428       return;
2429
2430     case PLUS_EXPR:
2431       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2432         break;
2433     case ARRAY_REF:
2434       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2435         {
2436           type1 = ptrdiff_type_node;
2437           break;
2438         }
2439       if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2440         {
2441           type2 = ptrdiff_type_node;
2442           break;
2443         }
2444       return;
2445
2446 /* 18For  every pair of promoted integral types L and R, there exist candi-
2447      date operator functions of the form
2448              LR      operator%(L, R);
2449              LR      operator&(L, R);
2450              LR      operator^(L, R);
2451              LR      operator|(L, R);
2452              L       operator<<(L, R);
2453              L       operator>>(L, R);
2454      where LR is the result of the  usual  arithmetic  conversions  between
2455      types L and R.  */
2456
2457     case TRUNC_MOD_EXPR:
2458     case BIT_AND_EXPR:
2459     case BIT_IOR_EXPR:
2460     case BIT_XOR_EXPR:
2461     case LSHIFT_EXPR:
2462     case RSHIFT_EXPR:
2463       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2464         break;
2465       return;
2466
2467 /* 19For  every  triple  L, VQ, R), where L is an arithmetic or enumeration
2468      type, VQ is either volatile or empty, and R is a  promoted  arithmetic
2469      type, there exist candidate operator functions of the form
2470              VQ L&   operator=(VQ L&, R);
2471              VQ L&   operator*=(VQ L&, R);
2472              VQ L&   operator/=(VQ L&, R);
2473              VQ L&   operator+=(VQ L&, R);
2474              VQ L&   operator-=(VQ L&, R);
2475
2476    20For  every  pair T, VQ), where T is any type and VQ is either volatile
2477      or empty, there exist candidate operator functions of the form
2478              T*VQ&   operator=(T*VQ&, T*);
2479
2480    21For every pair T, VQ), where T is a pointer to member type and  VQ  is
2481      either  volatile or empty, there exist candidate operator functions of
2482      the form
2483              VQ T&   operator=(VQ T&, T);
2484
2485    22For every triple  T,  VQ,  I),  where  T  is  a  cv-qualified  or  cv-
2486      unqualified  complete object type, VQ is either volatile or empty, and
2487      I is a promoted integral type, there exist  candidate  operator  func-
2488      tions of the form
2489              T*VQ&   operator+=(T*VQ&, I);
2490              T*VQ&   operator-=(T*VQ&, I);
2491
2492    23For  every  triple  L,  VQ,  R), where L is an integral or enumeration
2493      type, VQ is either volatile or empty, and R  is  a  promoted  integral
2494      type, there exist candidate operator functions of the form
2495
2496              VQ L&   operator%=(VQ L&, R);
2497              VQ L&   operator<<=(VQ L&, R);
2498              VQ L&   operator>>=(VQ L&, R);
2499              VQ L&   operator&=(VQ L&, R);
2500              VQ L&   operator^=(VQ L&, R);
2501              VQ L&   operator|=(VQ L&, R);  */
2502
2503     case MODIFY_EXPR:
2504       switch (code2)
2505         {
2506         case PLUS_EXPR:
2507         case MINUS_EXPR:
2508           if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2509             {
2510               type2 = ptrdiff_type_node;
2511               break;
2512             }
2513         case MULT_EXPR:
2514         case TRUNC_DIV_EXPR:
2515           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2516             break;
2517           return;
2518
2519         case TRUNC_MOD_EXPR:
2520         case BIT_AND_EXPR:
2521         case BIT_IOR_EXPR:
2522         case BIT_XOR_EXPR:
2523         case LSHIFT_EXPR:
2524         case RSHIFT_EXPR:
2525           if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2526             break;
2527           return;
2528
2529         case NOP_EXPR:
2530           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2531             break;
2532           if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2533               || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2534               || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2535               || ((TYPE_PTRMEMFUNC_P (type1)
2536                    || TREE_CODE (type1) == POINTER_TYPE)
2537                   && null_ptr_cst_p (args[1])))
2538             {
2539               type2 = type1;
2540               break;
2541             }
2542           return;
2543
2544         default:
2545           gcc_unreachable ();
2546         }
2547       type1 = build_reference_type (type1);
2548       break;
2549
2550     case COND_EXPR:
2551       /* [over.built]
2552
2553          For every pair of promoted arithmetic types L and R, there
2554          exist candidate operator functions of the form
2555
2556          LR operator?(bool, L, R);
2557
2558          where LR is the result of the usual arithmetic conversions
2559          between types L and R.
2560
2561          For every type T, where T is a pointer or pointer-to-member
2562          type, there exist candidate operator functions of the form T
2563          operator?(bool, T, T);  */
2564
2565       if (promoted_arithmetic_type_p (type1)
2566           && promoted_arithmetic_type_p (type2))
2567         /* That's OK.  */
2568         break;
2569
2570       /* Otherwise, the types should be pointers.  */
2571       if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2572           || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2573         return;
2574
2575       /* We don't check that the two types are the same; the logic
2576          below will actually create two candidates; one in which both
2577          parameter types are TYPE1, and one in which both parameter
2578          types are TYPE2.  */
2579       break;
2580
2581     case REALPART_EXPR:
2582     case IMAGPART_EXPR:
2583       if (ARITHMETIC_TYPE_P (type1))
2584         break;
2585       return;
2586  
2587     default:
2588       gcc_unreachable ();
2589     }
2590
2591   /* If we're dealing with two pointer types or two enumeral types,
2592      we need candidates for both of them.  */
2593   if (type2 && !same_type_p (type1, type2)
2594       && TREE_CODE (type1) == TREE_CODE (type2)
2595       && (TREE_CODE (type1) == REFERENCE_TYPE
2596           || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2597           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2598           || TYPE_PTRMEMFUNC_P (type1)
2599           || MAYBE_CLASS_TYPE_P (type1)
2600           || TREE_CODE (type1) == ENUMERAL_TYPE))
2601     {
2602       if (TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2603         {
2604           tree cptype = composite_pointer_type (type1, type2,
2605                                                 error_mark_node,
2606                                                 error_mark_node,
2607                                                 CPO_CONVERSION,
2608                                                 tf_none);
2609           if (cptype != error_mark_node)
2610             {
2611               build_builtin_candidate
2612                 (candidates, fnname, cptype, cptype, args, argtypes, flags);
2613               return;
2614             }
2615         }
2616
2617       build_builtin_candidate
2618         (candidates, fnname, type1, type1, args, argtypes, flags);
2619       build_builtin_candidate
2620         (candidates, fnname, type2, type2, args, argtypes, flags);
2621       return;
2622     }
2623
2624   build_builtin_candidate
2625     (candidates, fnname, type1, type2, args, argtypes, flags);
2626 }
2627
2628 tree
2629 type_decays_to (tree type)
2630 {
2631   if (TREE_CODE (type) == ARRAY_TYPE)
2632     return build_pointer_type (TREE_TYPE (type));
2633   if (TREE_CODE (type) == FUNCTION_TYPE)
2634     return build_pointer_type (type);
2635   return type;
2636 }
2637
2638 /* There are three conditions of builtin candidates:
2639
2640    1) bool-taking candidates.  These are the same regardless of the input.
2641    2) pointer-pair taking candidates.  These are generated for each type
2642       one of the input types converts to.
2643    3) arithmetic candidates.  According to the standard, we should generate
2644       all of these, but I'm trying not to...
2645
2646    Here we generate a superset of the possible candidates for this particular
2647    case.  That is a subset of the full set the standard defines, plus some
2648    other cases which the standard disallows. add_builtin_candidate will
2649    filter out the invalid set.  */
2650
2651 static void
2652 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2653                         enum tree_code code2, tree fnname, tree *args,
2654                         int flags)
2655 {
2656   int ref1, i;
2657   int enum_p = 0;
2658   tree type, argtypes[3], t;
2659   /* TYPES[i] is the set of possible builtin-operator parameter types
2660      we will consider for the Ith argument.  */
2661   VEC(tree,gc) *types[2];
2662   unsigned ix;
2663
2664   for (i = 0; i < 3; ++i)
2665     {
2666       if (args[i])
2667         argtypes[i] = unlowered_expr_type (args[i]);
2668       else
2669         argtypes[i] = NULL_TREE;
2670     }
2671
2672   switch (code)
2673     {
2674 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2675      and  VQ  is  either  volatile or empty, there exist candidate operator
2676      functions of the form
2677                  VQ T&   operator++(VQ T&);  */
2678
2679     case POSTINCREMENT_EXPR:
2680     case PREINCREMENT_EXPR:
2681     case POSTDECREMENT_EXPR:
2682     case PREDECREMENT_EXPR:
2683     case MODIFY_EXPR:
2684       ref1 = 1;
2685       break;
2686
2687 /* 24There also exist candidate operator functions of the form
2688              bool    operator!(bool);
2689              bool    operator&&(bool, bool);
2690              bool    operator||(bool, bool);  */
2691
2692     case TRUTH_NOT_EXPR:
2693       build_builtin_candidate
2694         (candidates, fnname, boolean_type_node,
2695          NULL_TREE, args, argtypes, flags);
2696       return;
2697
2698     case TRUTH_ORIF_EXPR:
2699     case TRUTH_ANDIF_EXPR:
2700       build_builtin_candidate
2701         (candidates, fnname, boolean_type_node,
2702          boolean_type_node, args, argtypes, flags);
2703       return;
2704
2705     case ADDR_EXPR:
2706     case COMPOUND_EXPR:
2707     case COMPONENT_REF:
2708       return;
2709
2710     case COND_EXPR:
2711     case EQ_EXPR:
2712     case NE_EXPR:
2713     case LT_EXPR:
2714     case LE_EXPR:
2715     case GT_EXPR:
2716     case GE_EXPR:
2717       enum_p = 1;
2718       /* Fall through.  */
2719
2720     default:
2721       ref1 = 0;
2722     }
2723
2724   types[0] = make_tree_vector ();
2725   types[1] = make_tree_vector ();
2726
2727   for (i = 0; i < 2; ++i)
2728     {
2729       if (! args[i])
2730         ;
2731       else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2732         {
2733           tree convs;
2734
2735           if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2736             return;
2737
2738           convs = lookup_conversions (argtypes[i]);
2739
2740           if (code == COND_EXPR)
2741             {
2742               if (real_lvalue_p (args[i]))
2743                 VEC_safe_push (tree, gc, types[i],
2744                                build_reference_type (argtypes[i]));
2745
2746               VEC_safe_push (tree, gc, types[i],
2747                              TYPE_MAIN_VARIANT (argtypes[i]));
2748             }
2749
2750           else if (! convs)
2751             return;
2752
2753           for (; convs; convs = TREE_CHAIN (convs))
2754             {
2755               type = TREE_TYPE (convs);
2756
2757               if (i == 0 && ref1
2758                   && (TREE_CODE (type) != REFERENCE_TYPE
2759                       || CP_TYPE_CONST_P (TREE_TYPE (type))))
2760                 continue;
2761
2762               if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2763                 VEC_safe_push (tree, gc, types[i], type);
2764
2765               type = non_reference (type);
2766               if (i != 0 || ! ref1)
2767                 {
2768                   type = cv_unqualified (type_decays_to (type));
2769                   if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2770                     VEC_safe_push (tree, gc, types[i], type);
2771                   if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2772                     type = type_promotes_to (type);
2773                 }
2774
2775               if (! vec_member (type, types[i]))
2776                 VEC_safe_push (tree, gc, types[i], type);
2777             }
2778         }
2779       else
2780         {
2781           if (code == COND_EXPR && real_lvalue_p (args[i]))
2782             VEC_safe_push (tree, gc, types[i],
2783                            build_reference_type (argtypes[i]));
2784           type = non_reference (argtypes[i]);
2785           if (i != 0 || ! ref1)
2786             {
2787               type = cv_unqualified (type_decays_to (type));
2788               if (enum_p && UNSCOPED_ENUM_P (type))
2789                 VEC_safe_push (tree, gc, types[i], type);
2790               if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2791                 type = type_promotes_to (type);
2792             }
2793           VEC_safe_push (tree, gc, types[i], type);
2794         }
2795     }
2796
2797   /* Run through the possible parameter types of both arguments,
2798      creating candidates with those parameter types.  */
2799   FOR_EACH_VEC_ELT_REVERSE (tree, types[0], ix, t)
2800     {
2801       unsigned jx;
2802       tree u;
2803
2804       if (!VEC_empty (tree, types[1]))
2805         FOR_EACH_VEC_ELT_REVERSE (tree, types[1], jx, u)
2806           add_builtin_candidate
2807             (candidates, code, code2, fnname, t,
2808              u, args, argtypes, flags);
2809       else
2810         add_builtin_candidate
2811           (candidates, code, code2, fnname, t,
2812            NULL_TREE, args, argtypes, flags);
2813     }
2814
2815   release_tree_vector (types[0]);
2816   release_tree_vector (types[1]);
2817 }
2818
2819
2820 /* If TMPL can be successfully instantiated as indicated by
2821    EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2822
2823    TMPL is the template.  EXPLICIT_TARGS are any explicit template
2824    arguments.  ARGLIST is the arguments provided at the call-site.
2825    This does not change ARGLIST.  The RETURN_TYPE is the desired type
2826    for conversion operators.  If OBJ is NULL_TREE, FLAGS and CTYPE are
2827    as for add_function_candidate.  If an OBJ is supplied, FLAGS and
2828    CTYPE are ignored, and OBJ is as for add_conv_candidate.  */
2829
2830 static struct z_candidate*
2831 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2832                              tree ctype, tree explicit_targs, tree first_arg,
2833                              const VEC(tree,gc) *arglist, tree return_type,
2834                              tree access_path, tree conversion_path,
2835                              int flags, tree obj, unification_kind_t strict)
2836 {
2837   int ntparms = DECL_NTPARMS (tmpl);
2838   tree targs = make_tree_vec (ntparms);
2839   unsigned int len = VEC_length (tree, arglist);
2840   unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2841   unsigned int skip_without_in_chrg = 0;
2842   tree first_arg_without_in_chrg = first_arg;
2843   tree *args_without_in_chrg;
2844   unsigned int nargs_without_in_chrg;
2845   unsigned int ia, ix;
2846   tree arg;
2847   struct z_candidate *cand;
2848   int i;
2849   tree fn;
2850   struct rejection_reason *reason = NULL;
2851   int errs;
2852
2853   /* We don't do deduction on the in-charge parameter, the VTT
2854      parameter or 'this'.  */
2855   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2856     {
2857       if (first_arg_without_in_chrg != NULL_TREE)
2858         first_arg_without_in_chrg = NULL_TREE;
2859       else
2860         ++skip_without_in_chrg;
2861     }
2862
2863   if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2864        || DECL_BASE_CONSTRUCTOR_P (tmpl))
2865       && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2866     {
2867       if (first_arg_without_in_chrg != NULL_TREE)
2868         first_arg_without_in_chrg = NULL_TREE;
2869       else
2870         ++skip_without_in_chrg;
2871     }
2872
2873   if (len < skip_without_in_chrg)
2874     return NULL;
2875
2876   nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2877                            + (len - skip_without_in_chrg));
2878   args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2879   ia = 0;
2880   if (first_arg_without_in_chrg != NULL_TREE)
2881     {
2882       args_without_in_chrg[ia] = first_arg_without_in_chrg;
2883       ++ia;
2884     }
2885   for (ix = skip_without_in_chrg;
2886        VEC_iterate (tree, arglist, ix, arg);
2887        ++ix)
2888     {
2889       args_without_in_chrg[ia] = arg;
2890       ++ia;
2891     }
2892   gcc_assert (ia == nargs_without_in_chrg);
2893
2894   errs = errorcount+sorrycount;
2895   i = fn_type_unification (tmpl, explicit_targs, targs,
2896                            args_without_in_chrg,
2897                            nargs_without_in_chrg,
2898                            return_type, strict, flags, false);
2899
2900   if (i != 0)
2901     {
2902       /* Don't repeat unification later if it already resulted in errors.  */
2903       if (errorcount+sorrycount == errs)
2904         reason = template_unification_rejection (tmpl, explicit_targs,
2905                                                  targs, args_without_in_chrg,
2906                                                  nargs_without_in_chrg,
2907                                                  return_type, strict, flags);
2908       else
2909         reason = template_unification_error_rejection ();
2910       goto fail;
2911     }
2912
2913   fn = instantiate_template (tmpl, targs, tf_none);
2914   if (fn == error_mark_node)
2915     {
2916       reason = template_instantiation_rejection (tmpl, targs);
2917       goto fail;
2918     }
2919
2920   /* In [class.copy]:
2921
2922        A member function template is never instantiated to perform the
2923        copy of a class object to an object of its class type.
2924
2925      It's a little unclear what this means; the standard explicitly
2926      does allow a template to be used to copy a class.  For example,
2927      in:
2928
2929        struct A {
2930          A(A&);
2931          template <class T> A(const T&);
2932        };
2933        const A f ();
2934        void g () { A a (f ()); }
2935
2936      the member template will be used to make the copy.  The section
2937      quoted above appears in the paragraph that forbids constructors
2938      whose only parameter is (a possibly cv-qualified variant of) the
2939      class type, and a logical interpretation is that the intent was
2940      to forbid the instantiation of member templates which would then
2941      have that form.  */
2942   if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2943     {
2944       tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2945       if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2946                                     ctype))
2947         {
2948           reason = invalid_copy_with_fn_template_rejection ();
2949           goto fail;
2950         }
2951     }
2952
2953   if (obj != NULL_TREE)
2954     /* Aha, this is a conversion function.  */
2955     cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2956                                access_path, conversion_path);
2957   else
2958     cand = add_function_candidate (candidates, fn, ctype,
2959                                    first_arg, arglist, access_path,
2960                                    conversion_path, flags);
2961   if (DECL_TI_TEMPLATE (fn) != tmpl)
2962     /* This situation can occur if a member template of a template
2963        class is specialized.  Then, instantiate_template might return
2964        an instantiation of the specialization, in which case the
2965        DECL_TI_TEMPLATE field will point at the original
2966        specialization.  For example:
2967
2968          template <class T> struct S { template <class U> void f(U);
2969                                        template <> void f(int) {}; };
2970          S<double> sd;
2971          sd.f(3);
2972
2973        Here, TMPL will be template <class U> S<double>::f(U).
2974        And, instantiate template will give us the specialization
2975        template <> S<double>::f(int).  But, the DECL_TI_TEMPLATE field
2976        for this will point at template <class T> template <> S<T>::f(int),
2977        so that we can find the definition.  For the purposes of
2978        overload resolution, however, we want the original TMPL.  */
2979     cand->template_decl = build_template_info (tmpl, targs);
2980   else
2981     cand->template_decl = DECL_TEMPLATE_INFO (fn);
2982   cand->explicit_targs = explicit_targs;
2983
2984   return cand;
2985  fail:
2986   return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2987                         access_path, conversion_path, 0, reason);
2988 }
2989
2990
2991 static struct z_candidate *
2992 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2993                         tree explicit_targs, tree first_arg,
2994                         const VEC(tree,gc) *arglist, tree return_type,
2995                         tree access_path, tree conversion_path, int flags,
2996                         unification_kind_t strict)
2997 {
2998   return
2999     add_template_candidate_real (candidates, tmpl, ctype,
3000                                  explicit_targs, first_arg, arglist,
3001                                  return_type, access_path, conversion_path,
3002                                  flags, NULL_TREE, strict);
3003 }
3004
3005
3006 static struct z_candidate *
3007 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
3008                              tree obj, tree first_arg,
3009                              const VEC(tree,gc) *arglist,
3010                              tree return_type, tree access_path,
3011                              tree conversion_path)
3012 {
3013   return
3014     add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
3015                                  first_arg, arglist, return_type, access_path,
3016                                  conversion_path, 0, obj, DEDUCE_CONV);
3017 }
3018
3019 /* The CANDS are the set of candidates that were considered for
3020    overload resolution.  Return the set of viable candidates, or CANDS
3021    if none are viable.  If any of the candidates were viable, set
3022    *ANY_VIABLE_P to true.  STRICT_P is true if a candidate should be
3023    considered viable only if it is strictly viable.  */
3024
3025 static struct z_candidate*
3026 splice_viable (struct z_candidate *cands,
3027                bool strict_p,
3028                bool *any_viable_p)
3029 {
3030   struct z_candidate *viable;
3031   struct z_candidate **last_viable;
3032   struct z_candidate **cand;
3033
3034   /* Be strict inside templates, since build_over_call won't actually
3035      do the conversions to get pedwarns.  */
3036   if (processing_template_decl)
3037     strict_p = true;
3038
3039   viable = NULL;
3040   last_viable = &viable;
3041   *any_viable_p = false;
3042
3043   cand = &cands;
3044   while (*cand)
3045     {
3046       struct z_candidate *c = *cand;
3047       if (strict_p ? c->viable == 1 : c->viable)
3048         {
3049           *last_viable = c;
3050           *cand = c->next;
3051           c->next = NULL;
3052           last_viable = &c->next;
3053           *any_viable_p = true;
3054         }
3055       else
3056         cand = &c->next;
3057     }
3058
3059   return viable ? viable : cands;
3060 }
3061
3062 static bool
3063 any_strictly_viable (struct z_candidate *cands)
3064 {
3065   for (; cands; cands = cands->next)
3066     if (cands->viable == 1)
3067       return true;
3068   return false;
3069 }
3070
3071 /* OBJ is being used in an expression like "OBJ.f (...)".  In other
3072    words, it is about to become the "this" pointer for a member
3073    function call.  Take the address of the object.  */
3074
3075 static tree
3076 build_this (tree obj)
3077 {
3078   /* In a template, we are only concerned about the type of the
3079      expression, so we can take a shortcut.  */
3080   if (processing_template_decl)
3081     return build_address (obj);
3082
3083   return cp_build_addr_expr (obj, tf_warning_or_error);
3084 }
3085
3086 /* Returns true iff functions are equivalent. Equivalent functions are
3087    not '==' only if one is a function-local extern function or if
3088    both are extern "C".  */
3089
3090 static inline int
3091 equal_functions (tree fn1, tree fn2)
3092 {
3093   if (TREE_CODE (fn1) != TREE_CODE (fn2))
3094     return 0;
3095   if (TREE_CODE (fn1) == TEMPLATE_DECL)
3096     return fn1 == fn2;
3097   if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
3098       || DECL_EXTERN_C_FUNCTION_P (fn1))
3099     return decls_match (fn1, fn2);
3100   return fn1 == fn2;
3101 }
3102
3103 /* Print information about a candidate being rejected due to INFO.  */
3104
3105 static void
3106 print_conversion_rejection (location_t loc, struct conversion_info *info)
3107 {
3108   if (info->n_arg == -1)
3109     /* Conversion of implicit `this' argument failed.  */
3110     inform (loc, "  no known conversion for implicit "
3111             "%<this%> parameter from %qT to %qT",
3112             info->from_type, info->to_type);
3113   else
3114     inform (loc, "  no known conversion for argument %d from %qT to %qT",
3115             info->n_arg+1, info->from_type, info->to_type);
3116 }
3117
3118 /* Print information about a candidate with WANT parameters and we found
3119    HAVE.  */
3120
3121 static void
3122 print_arity_information (location_t loc, unsigned int have, unsigned int want)
3123 {
3124   inform_n (loc, want,
3125             "  candidate expects %d argument, %d provided",
3126             "  candidate expects %d arguments, %d provided",
3127             want, have);
3128 }
3129
3130 /* Print information about one overload candidate CANDIDATE.  MSGSTR
3131    is the text to print before the candidate itself.
3132
3133    NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3134    to have been run through gettext by the caller.  This wart makes
3135    life simpler in print_z_candidates and for the translators.  */
3136
3137 static void
3138 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
3139 {
3140   const char *msg = (msgstr == NULL
3141                      ? ""
3142                      : ACONCAT ((msgstr, " ", NULL)));
3143   location_t loc = location_of (candidate->fn);
3144
3145   if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
3146     {
3147       if (candidate->num_convs == 3)
3148         inform (input_location, "%s%D(%T, %T, %T) <built-in>", msg, candidate->fn,
3149                 candidate->convs[0]->type,
3150                 candidate->convs[1]->type,
3151                 candidate->convs[2]->type);
3152       else if (candidate->num_convs == 2)
3153         inform (input_location, "%s%D(%T, %T) <built-in>", msg, candidate->fn,
3154                 candidate->convs[0]->type,
3155                 candidate->convs[1]->type);
3156       else
3157         inform (input_location, "%s%D(%T) <built-in>", msg, candidate->fn,
3158                 candidate->convs[0]->type);
3159     }
3160   else if (TYPE_P (candidate->fn))
3161     inform (input_location, "%s%T <conversion>", msg, candidate->fn);
3162   else if (candidate->viable == -1)
3163     inform (loc, "%s%#D <near match>", msg, candidate->fn);
3164   else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
3165     inform (loc, "%s%#D <deleted>", msg, candidate->fn);
3166   else
3167     inform (loc, "%s%#D", msg, candidate->fn);
3168   /* Give the user some information about why this candidate failed.  */
3169   if (candidate->reason != NULL)
3170     {
3171       struct rejection_reason *r = candidate->reason;
3172
3173       switch (r->code)
3174         {
3175         case rr_arity:
3176           print_arity_information (loc, r->u.arity.actual,
3177                                    r->u.arity.expected);
3178           break;
3179         case rr_arg_conversion:
3180           print_conversion_rejection (loc, &r->u.conversion);
3181           break;
3182         case rr_bad_arg_conversion:
3183           print_conversion_rejection (loc, &r->u.bad_conversion);
3184           break;
3185         case rr_explicit_conversion:
3186           inform (loc, "  return type %qT of explicit conversion function "
3187                   "cannot be converted to %qT with a qualification "
3188                   "conversion", r->u.conversion.from_type,
3189                   r->u.conversion.to_type);
3190           break;
3191         case rr_template_conversion:
3192           inform (loc, "  conversion from return type %qT of template "
3193                   "conversion function specialization to %qT is not an "
3194                   "exact match", r->u.conversion.from_type,
3195                   r->u.conversion.to_type);
3196           break;
3197         case rr_template_unification:
3198           /* We use template_unification_error_rejection if unification caused
3199              actual non-SFINAE errors, in which case we don't need to repeat
3200              them here.  */
3201           if (r->u.template_unification.tmpl == NULL_TREE)
3202             {
3203               inform (loc, "  substitution of deduced template arguments "
3204                       "resulted in errors seen above");
3205               break;
3206             }
3207           /* Re-run template unification with diagnostics.  */
3208           inform (loc, "  template argument deduction/substitution failed:");
3209           fn_type_unification (r->u.template_unification.tmpl,
3210                                r->u.template_unification.explicit_targs,
3211                                r->u.template_unification.targs,
3212                                r->u.template_unification.args,
3213                                r->u.template_unification.nargs,
3214                                r->u.template_unification.return_type,
3215                                r->u.template_unification.strict,
3216                                r->u.template_unification.flags,
3217                                true);
3218           break;
3219         case rr_template_instantiation:
3220           /* Re-run template instantiation with diagnostics.  */
3221           instantiate_template (r->u.template_instantiation.tmpl,
3222                                 r->u.template_instantiation.targs,
3223                                 tf_warning_or_error);
3224           break;
3225         case rr_invalid_copy:
3226           inform (loc,
3227                   "  a constructor taking a single argument of its own "
3228                   "class type is invalid");
3229           break;
3230         case rr_none:
3231         default:
3232           /* This candidate didn't have any issues or we failed to
3233              handle a particular code.  Either way...  */
3234           gcc_unreachable ();
3235         }
3236     }
3237 }
3238
3239 static void
3240 print_z_candidates (location_t loc, struct z_candidate *candidates)
3241 {
3242   struct z_candidate *cand1;
3243   struct z_candidate **cand2;
3244   int n_candidates;
3245
3246   if (!candidates)
3247     return;
3248
3249   /* Remove non-viable deleted candidates.  */
3250   cand1 = candidates;
3251   for (cand2 = &cand1; *cand2; )
3252     {
3253       if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
3254           && !(*cand2)->viable
3255           && DECL_DELETED_FN ((*cand2)->fn))
3256         *cand2 = (*cand2)->next;
3257       else
3258         cand2 = &(*cand2)->next;
3259     }
3260   /* ...if there are any non-deleted ones.  */
3261   if (cand1)
3262     candidates = cand1;
3263
3264   /* There may be duplicates in the set of candidates.  We put off
3265      checking this condition as long as possible, since we have no way
3266      to eliminate duplicates from a set of functions in less than n^2
3267      time.  Now we are about to emit an error message, so it is more
3268      permissible to go slowly.  */
3269   for (cand1 = candidates; cand1; cand1 = cand1->next)
3270     {
3271       tree fn = cand1->fn;
3272       /* Skip builtin candidates and conversion functions.  */
3273       if (!DECL_P (fn))
3274         continue;
3275       cand2 = &cand1->next;
3276       while (*cand2)
3277         {
3278           if (DECL_P ((*cand2)->fn)
3279               && equal_functions (fn, (*cand2)->fn))
3280             *cand2 = (*cand2)->next;
3281           else
3282             cand2 = &(*cand2)->next;
3283         }
3284     }
3285
3286   for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next)
3287     n_candidates++;
3288
3289   inform_n (loc, n_candidates, "candidate is:", "candidates are:");
3290   for (; candidates; candidates = candidates->next)
3291     print_z_candidate (NULL, candidates);
3292 }
3293
3294 /* USER_SEQ is a user-defined conversion sequence, beginning with a
3295    USER_CONV.  STD_SEQ is the standard conversion sequence applied to
3296    the result of the conversion function to convert it to the final
3297    desired type.  Merge the two sequences into a single sequence,
3298    and return the merged sequence.  */
3299
3300 static conversion *
3301 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
3302 {
3303   conversion **t;
3304   bool bad = user_seq->bad_p;
3305
3306   gcc_assert (user_seq->kind == ck_user);
3307
3308   /* Find the end of the second conversion sequence.  */
3309   for (t = &std_seq; (*t)->kind != ck_identity; t = &((*t)->u.next))
3310     {
3311       /* The entire sequence is a user-conversion sequence.  */
3312       (*t)->user_conv_p = true;
3313       if (bad)
3314         (*t)->bad_p = true;
3315     }
3316
3317   /* Replace the identity conversion with the user conversion
3318      sequence.  */
3319   *t = user_seq;
3320
3321   return std_seq;
3322 }
3323
3324 /* Handle overload resolution for initializing an object of class type from
3325    an initializer list.  First we look for a suitable constructor that
3326    takes a std::initializer_list; if we don't find one, we then look for a
3327    non-list constructor.
3328
3329    Parameters are as for add_candidates, except that the arguments are in
3330    the form of a CONSTRUCTOR (the initializer list) rather than a VEC, and
3331    the RETURN_TYPE parameter is replaced by TOTYPE, the desired type.  */
3332
3333 static void
3334 add_list_candidates (tree fns, tree first_arg,
3335                      tree init_list, tree totype,
3336                      tree explicit_targs, bool template_only,
3337                      tree conversion_path, tree access_path,
3338                      int flags,
3339                      struct z_candidate **candidates)
3340 {
3341   VEC(tree,gc) *args;
3342
3343   gcc_assert (*candidates == NULL);
3344
3345   /* For list-initialization we consider explicit constructors, but
3346      give an error if one is selected.  */
3347   flags &= ~LOOKUP_ONLYCONVERTING;
3348   /* And we don't allow narrowing conversions.  We also use this flag to
3349      avoid the copy constructor call for copy-list-initialization.  */
3350   flags |= LOOKUP_NO_NARROWING;
3351
3352   /* Always use the default constructor if the list is empty (DR 990).  */
3353   if (CONSTRUCTOR_NELTS (init_list) == 0
3354       && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
3355     ;
3356   /* If the class has a list ctor, try passing the list as a single
3357      argument first, but only consider list ctors.  */
3358   else if (TYPE_HAS_LIST_CTOR (totype))
3359     {
3360       flags |= LOOKUP_LIST_ONLY;
3361       args = make_tree_vector_single (init_list);
3362       add_candidates (fns, first_arg, args, NULL_TREE,
3363                       explicit_targs, template_only, conversion_path,
3364                       access_path, flags, candidates);
3365       if (any_strictly_viable (*candidates))
3366         return;
3367     }
3368
3369   args = ctor_to_vec (init_list);
3370
3371   /* We aren't looking for list-ctors anymore.  */
3372   flags &= ~LOOKUP_LIST_ONLY;
3373   /* We allow more user-defined conversions within an init-list.  */
3374   flags &= ~LOOKUP_NO_CONVERSION;
3375   /* But not for the copy ctor.  */
3376   flags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
3377
3378   add_candidates (fns, first_arg, args, NULL_TREE,
3379                   explicit_targs, template_only, conversion_path,
3380                   access_path, flags, candidates);
3381 }
3382
3383 /* Returns the best overload candidate to perform the requested
3384    conversion.  This function is used for three the overloading situations
3385    described in [over.match.copy], [over.match.conv], and [over.match.ref].
3386    If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
3387    per [dcl.init.ref], so we ignore temporary bindings.  */
3388
3389 static struct z_candidate *
3390 build_user_type_conversion_1 (tree totype, tree expr, int flags)
3391 {
3392   struct z_candidate *candidates, *cand;
3393   tree fromtype;
3394   tree ctors = NULL_TREE;
3395   tree conv_fns = NULL_TREE;
3396   conversion *conv = NULL;
3397   tree first_arg = NULL_TREE;
3398   VEC(tree,gc) *args = NULL;
3399   bool any_viable_p;
3400   int convflags;
3401
3402   if (!expr)
3403     return NULL;
3404
3405   fromtype = TREE_TYPE (expr);
3406
3407   /* We represent conversion within a hierarchy using RVALUE_CONV and
3408      BASE_CONV, as specified by [over.best.ics]; these become plain
3409      constructor calls, as specified in [dcl.init].  */
3410   gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
3411               || !DERIVED_FROM_P (totype, fromtype));
3412
3413   if (MAYBE_CLASS_TYPE_P (totype))
3414     /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
3415        creating a garbage BASELINK; constructors can't be inherited.  */
3416     ctors = lookup_fnfields_slot (totype, complete_ctor_identifier);
3417
3418   if (MAYBE_CLASS_TYPE_P (fromtype))
3419     {
3420       tree to_nonref = non_reference (totype);
3421       if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
3422           (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
3423            && DERIVED_FROM_P (to_nonref, fromtype)))
3424         {
3425           /* [class.conv.fct] A conversion function is never used to
3426              convert a (possibly cv-qualified) object to the (possibly
3427              cv-qualified) same object type (or a reference to it), to a
3428              (possibly cv-qualified) base class of that type (or a
3429              reference to it)...  */
3430         }
3431       else
3432         conv_fns = lookup_conversions (fromtype);
3433     }
3434
3435   candidates = 0;
3436   flags |= LOOKUP_NO_CONVERSION;
3437   if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3438     flags |= LOOKUP_NO_NARROWING;
3439
3440   /* It's OK to bind a temporary for converting constructor arguments, but
3441      not in converting the return value of a conversion operator.  */
3442   convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
3443   flags &= ~LOOKUP_NO_TEMP_BIND;
3444
3445   if (ctors)
3446     {
3447       int ctorflags = flags;
3448
3449       first_arg = build_int_cst (build_pointer_type (totype), 0);
3450
3451       /* We should never try to call the abstract or base constructor
3452          from here.  */
3453       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
3454                   && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
3455
3456       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3457         {
3458           /* List-initialization.  */
3459           add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
3460                                false, TYPE_BINFO (totype), TYPE_BINFO (totype),
3461                                ctorflags, &candidates);
3462         }
3463       else
3464         {
3465           args = make_tree_vector_single (expr);
3466           add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
3467                           TYPE_BINFO (totype), TYPE_BINFO (totype),
3468                           ctorflags, &candidates);
3469         }
3470
3471       for (cand = candidates; cand; cand = cand->next)
3472         {
3473           cand->second_conv = build_identity_conv (totype, NULL_TREE);
3474
3475           /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3476              set, then this is copy-initialization.  In that case, "The
3477              result of the call is then used to direct-initialize the
3478              object that is the destination of the copy-initialization."
3479              [dcl.init]
3480
3481              We represent this in the conversion sequence with an
3482              rvalue conversion, which means a constructor call.  */
3483           if (TREE_CODE (totype) != REFERENCE_TYPE
3484               && !(convflags & LOOKUP_NO_TEMP_BIND))
3485             cand->second_conv
3486               = build_conv (ck_rvalue, totype, cand->second_conv);
3487         }
3488     }
3489
3490   if (conv_fns)
3491     first_arg = build_this (expr);
3492
3493   for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3494     {
3495       tree conversion_path = TREE_PURPOSE (conv_fns);
3496       struct z_candidate *old_candidates;
3497
3498       /* If we are called to convert to a reference type, we are trying to
3499          find a direct binding, so don't even consider temporaries.  If
3500          we don't find a direct binding, the caller will try again to
3501          look for a temporary binding.  */
3502       if (TREE_CODE (totype) == REFERENCE_TYPE)
3503         convflags |= LOOKUP_NO_TEMP_BIND;
3504
3505       old_candidates = candidates;
3506       add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3507                       NULL_TREE, false,
3508                       conversion_path, TYPE_BINFO (fromtype),
3509                       flags, &candidates);
3510
3511       for (cand = candidates; cand != old_candidates; cand = cand->next)
3512         {
3513           tree rettype = TREE_TYPE (TREE_TYPE (cand->fn));
3514           conversion *ics
3515             = implicit_conversion (totype,
3516                                    rettype,
3517                                    0,
3518                                    /*c_cast_p=*/false, convflags);
3519
3520           /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3521              copy-initialization.  In that case, "The result of the
3522              call is then used to direct-initialize the object that is
3523              the destination of the copy-initialization."  [dcl.init]
3524
3525              We represent this in the conversion sequence with an
3526              rvalue conversion, which means a constructor call.  But
3527              don't add a second rvalue conversion if there's already
3528              one there.  Which there really shouldn't be, but it's
3529              harmless since we'd add it here anyway. */
3530           if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3531               && !(convflags & LOOKUP_NO_TEMP_BIND))
3532             ics = build_conv (ck_rvalue, totype, ics);
3533
3534           cand->second_conv = ics;
3535
3536           if (!ics)
3537             {
3538               cand->viable = 0;
3539               cand->reason = arg_conversion_rejection (NULL_TREE, -1,
3540                                                        rettype, totype);
3541             }
3542           else if (DECL_NONCONVERTING_P (cand->fn)
3543                    && ics->rank > cr_exact)
3544             {
3545               /* 13.3.1.5: For direct-initialization, those explicit
3546                  conversion functions that are not hidden within S and
3547                  yield type T or a type that can be converted to type T
3548                  with a qualification conversion (4.4) are also candidate
3549                  functions.  */
3550               /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3551                  I've raised this issue with the committee. --jason 9/2011 */
3552               cand->viable = -1;
3553               cand->reason = explicit_conversion_rejection (rettype, totype);
3554             }
3555           else if (cand->viable == 1 && ics->bad_p)
3556             {
3557               cand->viable = -1;
3558               cand->reason
3559                 = bad_arg_conversion_rejection (NULL_TREE, -1,
3560                                                 rettype, totype);
3561             }
3562           else if (primary_template_instantiation_p (cand->fn)
3563                    && ics->rank > cr_exact)
3564             {
3565               /* 13.3.3.1.2: If the user-defined conversion is specified by
3566                  a specialization of a conversion function template, the
3567                  second standard conversion sequence shall have exact match
3568                  rank.  */
3569               cand->viable = -1;
3570               cand->reason = template_conversion_rejection (rettype, totype);
3571             }
3572         }
3573     }
3574
3575   candidates = splice_viable (candidates, pedantic, &any_viable_p);
3576   if (!any_viable_p)
3577     {
3578       if (args)
3579         release_tree_vector (args);
3580       return NULL;
3581     }
3582
3583   cand = tourney (candidates);
3584   if (cand == 0)
3585     {
3586       if (flags & LOOKUP_COMPLAIN)
3587         {
3588           error ("conversion from %qT to %qT is ambiguous",
3589                     fromtype, totype);
3590           print_z_candidates (location_of (expr), candidates);
3591         }
3592
3593       cand = candidates;        /* any one will do */
3594       cand->second_conv = build_ambiguous_conv (totype, expr);
3595       cand->second_conv->user_conv_p = true;
3596       if (!any_strictly_viable (candidates))
3597         cand->second_conv->bad_p = true;
3598       /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3599          ambiguous conversion is no worse than another user-defined
3600          conversion.  */
3601
3602       return cand;
3603     }
3604
3605   /* Build the user conversion sequence.  */
3606   conv = build_conv
3607     (ck_user,
3608      (DECL_CONSTRUCTOR_P (cand->fn)
3609       ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3610      build_identity_conv (TREE_TYPE (expr), expr));
3611   conv->cand = cand;
3612   if (cand->viable == -1)
3613     conv->bad_p = true;
3614
3615   /* Remember that this was a list-initialization.  */
3616   if (flags & LOOKUP_NO_NARROWING)
3617     conv->check_narrowing = true;
3618
3619   /* Combine it with the second conversion sequence.  */
3620   cand->second_conv = merge_conversion_sequences (conv,
3621                                                   cand->second_conv);
3622
3623   return cand;
3624 }
3625
3626 /* Wrapper for above. */
3627
3628 tree
3629 build_user_type_conversion (tree totype, tree expr, int flags)
3630 {
3631   struct z_candidate *cand;
3632   tree ret;
3633
3634   bool subtime = timevar_cond_start (TV_OVERLOAD);
3635   cand = build_user_type_conversion_1 (totype, expr, flags);
3636
3637   if (cand)
3638     {
3639       if (cand->second_conv->kind == ck_ambig)
3640         ret = error_mark_node;
3641       else
3642         {
3643           expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3644           ret = convert_from_reference (expr);
3645         }
3646     }
3647   else
3648     ret = NULL_TREE;
3649
3650   timevar_cond_stop (TV_OVERLOAD, subtime);
3651   return ret;
3652 }
3653
3654 /* Subroutine of convert_nontype_argument.
3655
3656    EXPR is an argument for a template non-type parameter of integral or
3657    enumeration type.  Do any necessary conversions (that are permitted for
3658    non-type arguments) to convert it to the parameter type.
3659
3660    If conversion is successful, returns the converted expression;
3661    otherwise, returns error_mark_node.  */
3662
3663 tree
3664 build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain)
3665 {
3666   conversion *conv;
3667   void *p;
3668   tree t;
3669
3670   if (error_operand_p (expr))
3671     return error_mark_node;
3672
3673   gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3674
3675   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3676   p = conversion_obstack_alloc (0);
3677
3678   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
3679                               /*c_cast_p=*/false,
3680                               LOOKUP_IMPLICIT);
3681
3682   /* for a non-type template-parameter of integral or
3683      enumeration type, integral promotions (4.5) and integral
3684      conversions (4.7) are applied.  */
3685   /* It should be sufficient to check the outermost conversion step, since
3686      there are no qualification conversions to integer type.  */
3687   if (conv)
3688     switch (conv->kind)
3689       {
3690         /* A conversion function is OK.  If it isn't constexpr, we'll
3691            complain later that the argument isn't constant.  */
3692       case ck_user:
3693         /* The lvalue-to-rvalue conversion is OK.  */
3694       case ck_rvalue:
3695       case ck_identity:
3696         break;
3697
3698       case ck_std:
3699         t = conv->u.next->type;
3700         if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
3701           break;
3702
3703         if (complain & tf_error)
3704           error ("conversion from %qT to %qT not considered for "
3705                  "non-type template argument", t, type);
3706         /* and fall through.  */
3707
3708       default:
3709         conv = NULL;
3710         break;
3711       }
3712
3713   if (conv)
3714     expr = convert_like (conv, expr, complain);
3715   else
3716     expr = error_mark_node;
3717
3718   /* Free all the conversions we allocated.  */
3719   obstack_free (&conversion_obstack, p);
3720
3721   return expr;
3722 }
3723
3724 /* Do any initial processing on the arguments to a function call.  */
3725
3726 static VEC(tree,gc) *
3727 resolve_args (VEC(tree,gc) *args, tsubst_flags_t complain)
3728 {
3729   unsigned int ix;
3730   tree arg;
3731
3732   FOR_EACH_VEC_ELT (tree, args, ix, arg)
3733     {
3734       if (error_operand_p (arg))
3735         return NULL;
3736       else if (VOID_TYPE_P (TREE_TYPE (arg)))
3737         {
3738           if (complain & tf_error)
3739             error ("invalid use of void expression");
3740           return NULL;
3741         }
3742       else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3743         return NULL;
3744     }
3745   return args;
3746 }
3747
3748 /* Perform overload resolution on FN, which is called with the ARGS.
3749
3750    Return the candidate function selected by overload resolution, or
3751    NULL if the event that overload resolution failed.  In the case
3752    that overload resolution fails, *CANDIDATES will be the set of
3753    candidates considered, and ANY_VIABLE_P will be set to true or
3754    false to indicate whether or not any of the candidates were
3755    viable.
3756
3757    The ARGS should already have gone through RESOLVE_ARGS before this
3758    function is called.  */
3759
3760 static struct z_candidate *
3761 perform_overload_resolution (tree fn,
3762                              const VEC(tree,gc) *args,
3763                              struct z_candidate **candidates,
3764                              bool *any_viable_p)
3765 {
3766   struct z_candidate *cand;
3767   tree explicit_targs;
3768   int template_only;
3769
3770   bool subtime = timevar_cond_start (TV_OVERLOAD);
3771
3772   explicit_targs = NULL_TREE;
3773   template_only = 0;
3774
3775   *candidates = NULL;
3776   *any_viable_p = true;
3777
3778   /* Check FN.  */
3779   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3780               || TREE_CODE (fn) == TEMPLATE_DECL
3781               || TREE_CODE (fn) == OVERLOAD
3782               || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3783
3784   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3785     {
3786       explicit_targs = TREE_OPERAND (fn, 1);
3787       fn = TREE_OPERAND (fn, 0);
3788       template_only = 1;
3789     }
3790
3791   /* Add the various candidate functions.  */
3792   add_candidates (fn, NULL_TREE, args, NULL_TREE,
3793                   explicit_targs, template_only,
3794                   /*conversion_path=*/NULL_TREE,
3795                   /*access_path=*/NULL_TREE,
3796                   LOOKUP_NORMAL,
3797                   candidates);
3798
3799   *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3800   if (*any_viable_p)
3801     cand = tourney (*candidates);
3802   else
3803     cand = NULL;
3804
3805   timevar_cond_stop (TV_OVERLOAD, subtime);
3806   return cand;
3807 }
3808
3809 /* Print an error message about being unable to build a call to FN with
3810    ARGS.  ANY_VIABLE_P indicates whether any candidate functions could
3811    be located; CANDIDATES is a possibly empty list of such
3812    functions.  */
3813
3814 static void
3815 print_error_for_call_failure (tree fn, VEC(tree,gc) *args, bool any_viable_p,
3816                               struct z_candidate *candidates)
3817 {
3818   tree name = DECL_NAME (OVL_CURRENT (fn));
3819   location_t loc = location_of (name);
3820
3821   if (!any_viable_p)
3822     error_at (loc, "no matching function for call to %<%D(%A)%>",
3823               name, build_tree_list_vec (args));
3824   else
3825     error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous",
3826               name, build_tree_list_vec (args));
3827   if (candidates)
3828     print_z_candidates (loc, candidates);
3829 }
3830
3831 /* Return an expression for a call to FN (a namespace-scope function,
3832    or a static member function) with the ARGS.  This may change
3833    ARGS.  */
3834
3835 tree
3836 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p, 
3837                          tsubst_flags_t complain)
3838 {
3839   struct z_candidate *candidates, *cand;
3840   bool any_viable_p;
3841   void *p;
3842   tree result;
3843
3844   if (args != NULL && *args != NULL)
3845     {
3846       *args = resolve_args (*args, complain);
3847       if (*args == NULL)
3848         return error_mark_node;
3849     }
3850
3851   if (flag_tm)
3852     tm_malloc_replacement (fn);
3853
3854   /* If this function was found without using argument dependent
3855      lookup, then we want to ignore any undeclared friend
3856      functions.  */
3857   if (!koenig_p)
3858     {
3859       tree orig_fn = fn;
3860
3861       fn = remove_hidden_names (fn);
3862       if (!fn)
3863         {
3864           if (complain & tf_error)
3865             print_error_for_call_failure (orig_fn, *args, false, NULL);
3866           return error_mark_node;
3867         }
3868     }
3869
3870   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3871   p = conversion_obstack_alloc (0);
3872
3873   cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3874
3875   if (!cand)
3876     {
3877       if (complain & tf_error)
3878         {
3879           if (!any_viable_p && candidates && ! candidates->next
3880               && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3881             return cp_build_function_call_vec (candidates->fn, args, complain);
3882           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3883             fn = TREE_OPERAND (fn, 0);
3884           print_error_for_call_failure (fn, *args, any_viable_p, candidates);
3885         }
3886       result = error_mark_node;
3887     }
3888   else
3889     {
3890       int flags = LOOKUP_NORMAL;
3891       /* If fn is template_id_expr, the call has explicit template arguments
3892          (e.g. func<int>(5)), communicate this info to build_over_call
3893          through flags so that later we can use it to decide whether to warn
3894          about peculiar null pointer conversion.  */
3895       if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3896         flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
3897       result = build_over_call (cand, flags, complain);
3898     }
3899
3900   /* Free all the conversions we allocated.  */
3901   obstack_free (&conversion_obstack, p);
3902
3903   return result;
3904 }
3905
3906 /* Build a call to a global operator new.  FNNAME is the name of the
3907    operator (either "operator new" or "operator new[]") and ARGS are
3908    the arguments provided.  This may change ARGS.  *SIZE points to the
3909    total number of bytes required by the allocation, and is updated if
3910    that is changed here.  *COOKIE_SIZE is non-NULL if a cookie should
3911    be used.  If this function determines that no cookie should be
3912    used, after all, *COOKIE_SIZE is set to NULL_TREE.  If FN is
3913    non-NULL, it will be set, upon return, to the allocation function
3914    called.  */
3915
3916 tree
3917 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3918                          tree *size, tree *cookie_size,
3919                          tree *fn)
3920 {
3921   tree fns;
3922   struct z_candidate *candidates;
3923   struct z_candidate *cand;
3924   bool any_viable_p;
3925
3926   if (fn)
3927     *fn = NULL_TREE;
3928   VEC_safe_insert (tree, gc, *args, 0, *size);
3929   *args = resolve_args (*args, tf_warning_or_error);
3930   if (*args == NULL)
3931     return error_mark_node;
3932
3933   /* Based on:
3934
3935        [expr.new]
3936
3937        If this lookup fails to find the name, or if the allocated type
3938        is not a class type, the allocation function's name is looked
3939        up in the global scope.
3940
3941      we disregard block-scope declarations of "operator new".  */
3942   fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3943
3944   /* Figure out what function is being called.  */
3945   cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3946
3947   /* If no suitable function could be found, issue an error message
3948      and give up.  */
3949   if (!cand)
3950     {
3951       print_error_for_call_failure (fns, *args, any_viable_p, candidates);
3952       return error_mark_node;
3953     }
3954
3955    /* If a cookie is required, add some extra space.  Whether
3956       or not a cookie is required cannot be determined until
3957       after we know which function was called.  */
3958    if (*cookie_size)
3959      {
3960        bool use_cookie = true;
3961        if (!abi_version_at_least (2))
3962          {
3963            /* In G++ 3.2, the check was implemented incorrectly; it
3964               looked at the placement expression, rather than the
3965               type of the function.  */
3966            if (VEC_length (tree, *args) == 2
3967                && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3968                                ptr_type_node))
3969              use_cookie = false;
3970          }
3971        else
3972          {
3973            tree arg_types;
3974
3975            arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3976            /* Skip the size_t parameter.  */
3977            arg_types = TREE_CHAIN (arg_types);
3978            /* Check the remaining parameters (if any).  */
3979            if (arg_types
3980                && TREE_CHAIN (arg_types) == void_list_node
3981                && same_type_p (TREE_VALUE (arg_types),
3982                                ptr_type_node))
3983              use_cookie = false;
3984          }
3985        /* If we need a cookie, adjust the number of bytes allocated.  */
3986        if (use_cookie)
3987          {
3988            /* Update the total size.  */
3989            *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3990            /* Update the argument list to reflect the adjusted size.  */
3991            VEC_replace (tree, *args, 0, *size);
3992          }
3993        else
3994          *cookie_size = NULL_TREE;
3995      }
3996
3997    /* Tell our caller which function we decided to call.  */
3998    if (fn)
3999      *fn = cand->fn;
4000
4001    /* Build the CALL_EXPR.  */
4002    return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
4003 }
4004
4005 /* Build a new call to operator().  This may change ARGS.  */
4006
4007 static tree
4008 build_op_call_1 (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
4009 {
4010   struct z_candidate *candidates = 0, *cand;
4011   tree fns, convs, first_mem_arg = NULL_TREE;
4012   tree type = TREE_TYPE (obj);
4013   bool any_viable_p;
4014   tree result = NULL_TREE;
4015   void *p;
4016
4017   if (error_operand_p (obj))
4018     return error_mark_node;
4019
4020   obj = prep_operand (obj);
4021
4022   if (TYPE_PTRMEMFUNC_P (type))
4023     {
4024       if (complain & tf_error)
4025         /* It's no good looking for an overloaded operator() on a
4026            pointer-to-member-function.  */
4027         error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
4028       return error_mark_node;
4029     }
4030
4031   if (TYPE_BINFO (type))
4032     {
4033       fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
4034       if (fns == error_mark_node)
4035         return error_mark_node;
4036     }
4037   else
4038     fns = NULL_TREE;
4039
4040   if (args != NULL && *args != NULL)
4041     {
4042       *args = resolve_args (*args, complain);
4043       if (*args == NULL)
4044         return error_mark_node;
4045     }
4046
4047   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
4048   p = conversion_obstack_alloc (0);
4049
4050   if (fns)
4051     {
4052       first_mem_arg = build_this (obj);
4053
4054       add_candidates (BASELINK_FUNCTIONS (fns),
4055                       first_mem_arg, *args, NULL_TREE,
4056                       NULL_TREE, false,
4057                       BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns),
4058                       LOOKUP_NORMAL, &candidates);
4059     }
4060
4061   convs = lookup_conversions (type);
4062
4063   for (; convs; convs = TREE_CHAIN (convs))
4064     {
4065       tree fns = TREE_VALUE (convs);
4066       tree totype = TREE_TYPE (convs);
4067
4068       if ((TREE_CODE (totype) == POINTER_TYPE
4069            && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
4070           || (TREE_CODE (totype) == REFERENCE_TYPE
4071               && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
4072           || (TREE_CODE (totype) == REFERENCE_TYPE
4073               && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
4074               && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
4075         for (; fns; fns = OVL_NEXT (fns))
4076           {
4077             tree fn = OVL_CURRENT (fns);
4078
4079             if (DECL_NONCONVERTING_P (fn))
4080               continue;
4081
4082             if (TREE_CODE (fn) == TEMPLATE_DECL)
4083               add_template_conv_candidate
4084                 (&candidates, fn, obj, NULL_TREE, *args, totype,
4085                  /*access_path=*/NULL_TREE,
4086                  /*conversion_path=*/NULL_TREE);
4087             else
4088               add_conv_candidate (&candidates, fn, obj, NULL_TREE,
4089                                   *args, /*conversion_path=*/NULL_TREE,
4090                                   /*access_path=*/NULL_TREE);
4091           }
4092     }
4093
4094   candidates = splice_viable (candidates, pedantic, &any_viable_p);
4095   if (!any_viable_p)
4096     {
4097       if (complain & tf_error)
4098         {
4099           error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
4100                  build_tree_list_vec (*args));
4101           print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4102         }
4103       result = error_mark_node;
4104     }
4105   else
4106     {
4107       cand = tourney (candidates);
4108       if (cand == 0)
4109         {
4110           if (complain & tf_error)
4111             {
4112               error ("call of %<(%T) (%A)%> is ambiguous", 
4113                      TREE_TYPE (obj), build_tree_list_vec (*args));
4114               print_z_candidates (location_of (TREE_TYPE (obj)), candidates);
4115             }
4116           result = error_mark_node;
4117         }
4118       /* Since cand->fn will be a type, not a function, for a conversion
4119          function, we must be careful not to unconditionally look at
4120          DECL_NAME here.  */
4121       else if (TREE_CODE (cand->fn) == FUNCTION_DECL
4122                && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
4123         result = build_over_call (cand, LOOKUP_NORMAL, complain);
4124       else
4125         {
4126           obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
4127                                            complain);
4128           obj = convert_from_reference (obj);
4129           result = cp_build_function_call_vec (obj, args, complain);
4130         }
4131     }
4132
4133   /* Free all the conversions we allocated.  */
4134   obstack_free (&conversion_obstack, p);
4135
4136   return result;
4137 }
4138
4139 /* Wrapper for above.  */
4140
4141 tree
4142 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
4143 {
4144   tree ret;
4145   bool subtime = timevar_cond_start (TV_OVERLOAD);
4146   ret = build_op_call_1 (obj, args, complain);
4147   timevar_cond_stop (TV_OVERLOAD, subtime);
4148   return ret;
4149 }
4150
4151 static void
4152 op_error (enum tree_code code, enum tree_code code2,
4153           tree arg1, tree arg2, tree arg3, bool match)
4154 {
4155   const char *opname;
4156
4157   if (code == MODIFY_EXPR)
4158     opname = assignment_operator_name_info[code2].name;
4159   else
4160     opname = operator_name_info[code].name;
4161
4162   switch (code)
4163     {
4164     case COND_EXPR:
4165       if (match)
4166         error ("ambiguous overload for ternary %<operator?:%> "
4167                "in %<%E ? %E : %E%>", arg1, arg2, arg3);
4168       else
4169         error ("no match for ternary %<operator?:%> "