OSDN Git Service

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