OSDN Git Service

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