gcc/cp/call.c

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