OSDN Git Service

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