OSDN Git Service

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