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