OSDN Git Service

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