OSDN Git Service

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