OSDN Git Service

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