OSDN Git Service

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