OSDN Git Service

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