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