gcc/cp/call.c

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