OSDN Git Service

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