gcc/cp/call.c

   1 /* Functions related to invoking methods and overloaded functions.
   2    Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com) and
   6    modified by Brendan Kehoe (brendan@cygnus.com).
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 3, or (at your option)
  13 any later version.
  14
  15 GCC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24
  25 /* High-level class interface.  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31 #include "tree.h"
  32 #include "cp-tree.h"
  33 #include "output.h"
  34 #include "flags.h"
  35 #include "rtl.h"
  36 #include "toplev.h"
  37 #include "expr.h"
  38 #include "diagnostic.h"
  39 #include "intl.h"
  40 #include "target.h"
  41 #include "convert.h"
  42 #include "langhooks.h"
  43
  44 /* The various kinds of conversion.  */
  45
  46 typedef enum conversion_kind {
  47   ck_identity,
  48   ck_lvalue,
  49   ck_qual,
  50   ck_std,
  51   ck_ptr,
  52   ck_pmem,
  53   ck_base,
  54   ck_ref_bind,
  55   ck_user,
  56   ck_ambig,
  57   ck_list,
  58   ck_aggr,
  59   ck_rvalue
  60 } conversion_kind;
  61
  62 /* The rank of the conversion.  Order of the enumerals matters; better
  63    conversions should come earlier in the list.  */
  64
  65 typedef enum conversion_rank {
  66   cr_identity,
  67   cr_exact,
  68   cr_promotion,
  69   cr_std,
  70   cr_pbool,
  71   cr_user,
  72   cr_ellipsis,
  73   cr_bad
  74 } conversion_rank;
  75
  76 /* An implicit conversion sequence, in the sense of [over.best.ics].
  77    The first conversion to be performed is at the end of the chain.
  78    That conversion is always a cr_identity conversion.  */
  79
  80 typedef struct conversion conversion;
  81 struct conversion {
  82   /* The kind of conversion represented by this step.  */
  83   conversion_kind kind;
  84   /* The rank of this conversion.  */
  85   conversion_rank rank;
  86   BOOL_BITFIELD user_conv_p : 1;
  87   BOOL_BITFIELD ellipsis_p : 1;
  88   BOOL_BITFIELD this_p : 1;
  89   BOOL_BITFIELD bad_p : 1;
  90   /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
  91      temporary should be created to hold the result of the
  92      conversion.  */
  93   BOOL_BITFIELD need_temporary_p : 1;
  94   /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
  95      from a pointer-to-derived to pointer-to-base is being performed.  */
  96   BOOL_BITFIELD base_p : 1;
  97   /* If KIND is ck_ref_bind, true when either an lvalue reference is
  98      being bound to an lvalue expression or an rvalue reference is
  99      being bound to an rvalue expression. */
 100   BOOL_BITFIELD rvaluedness_matches_p: 1;
 101   BOOL_BITFIELD check_narrowing: 1;
 102   /* The type of the expression resulting from the conversion.  */
 103   tree type;
 104   union {
 105     /* The next conversion in the chain.  Since the conversions are
 106        arranged from outermost to innermost, the NEXT conversion will
 107        actually be performed before this conversion.  This variant is
 108        used only when KIND is neither ck_identity nor ck_ambig.  */
 109     conversion *next;
 110     /* The expression at the beginning of the conversion chain.  This
 111        variant is used only if KIND is ck_identity or ck_ambig.  */
 112     tree expr;
 113     /* The array of conversions for an initializer_list.  */
 114     conversion **list;
 115   } u;
 116   /* The function candidate corresponding to this conversion
 117      sequence.  This field is only used if KIND is ck_user.  */
 118   struct z_candidate *cand;
 119 };
 120
 121 #define CONVERSION_RANK(NODE)                   \
 122   ((NODE)->bad_p ? cr_bad                       \
 123    : (NODE)->ellipsis_p ? cr_ellipsis           \
 124    : (NODE)->user_conv_p ? cr_user              \
 125    : (NODE)->rank)
 126
 127 static struct obstack conversion_obstack;
 128 static bool conversion_obstack_initialized;
 129
 130 static struct z_candidate * tourney (struct z_candidate *);
 131 static int equal_functions (tree, tree);
 132 static int joust (struct z_candidate *, struct z_candidate *, bool);
 133 static int compare_ics (conversion *, conversion *);
 134 static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
 135 static tree build_java_interface_fn_ref (tree, tree);
 136 #define convert_like(CONV, EXPR, COMPLAIN)                      \
 137   convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0,           \
 138                      /*issue_conversion_warnings=*/true,        \
 139                      /*c_cast_p=*/false, (COMPLAIN))
 140 #define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN )     \
 141   convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0,                  \
 142                      /*issue_conversion_warnings=*/true,                \
 143                      /*c_cast_p=*/false, (COMPLAIN))
 144 static tree convert_like_real (conversion *, tree, tree, int, int, bool,
 145                                bool, tsubst_flags_t);
 146 static void op_error (enum tree_code, enum tree_code, tree, tree,
 147                       tree, const char *);
 148 static VEC(tree,gc) *resolve_args (VEC(tree,gc) *);
 149 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
 150 static void print_z_candidate (const char *, struct z_candidate *);
 151 static void print_z_candidates (struct z_candidate *);
 152 static tree build_this (tree);
 153 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
 154 static bool any_strictly_viable (struct z_candidate *);
 155 static struct z_candidate *add_template_candidate
 156         (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
 157          tree, tree, tree, int, unification_kind_t);
 158 static struct z_candidate *add_template_candidate_real
 159         (struct z_candidate **, tree, tree, tree, tree, const VEC(tree,gc) *,
 160          tree, tree, tree, int, tree, unification_kind_t);
 161 static struct z_candidate *add_template_conv_candidate
 162         (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
 163          tree, tree);
 164 static void add_builtin_candidates
 165         (struct z_candidate **, enum tree_code, enum tree_code,
 166          tree, tree *, int);
 167 static void add_builtin_candidate
 168         (struct z_candidate **, enum tree_code, enum tree_code,
 169          tree, tree, tree, tree *, tree *, int);
 170 static bool is_complete (tree);
 171 static void build_builtin_candidate
 172         (struct z_candidate **, tree, tree, tree, tree *, tree *,
 173          int);
 174 static struct z_candidate *add_conv_candidate
 175         (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
 176          tree);
 177 static struct z_candidate *add_function_candidate
 178         (struct z_candidate **, tree, tree, tree, const VEC(tree,gc) *, tree,
 179          tree, int);
 180 static conversion *implicit_conversion (tree, tree, tree, bool, int);
 181 static conversion *standard_conversion (tree, tree, tree, bool, int);
 182 static conversion *reference_binding (tree, tree, tree, bool, int);
 183 static conversion *build_conv (conversion_kind, tree, conversion *);
 184 static conversion *build_list_conv (tree, tree, int);
 185 static bool is_subseq (conversion *, conversion *);
 186 static conversion *maybe_handle_ref_bind (conversion **);
 187 static void maybe_handle_implicit_object (conversion **);
 188 static struct z_candidate *add_candidate
 189         (struct z_candidate **, tree, tree, const VEC(tree,gc) *, size_t,
 190          conversion **, tree, tree, int);
 191 static tree source_type (conversion *);
 192 static void add_warning (struct z_candidate *, struct z_candidate *);
 193 static bool reference_related_p (tree, tree);
 194 static bool reference_compatible_p (tree, tree);
 195 static conversion *convert_class_to_reference (tree, tree, tree, int);
 196 static conversion *direct_reference_binding (tree, conversion *);
 197 static bool promoted_arithmetic_type_p (tree);
 198 static conversion *conditional_conversion (tree, tree);
 199 static char *name_as_c_string (tree, tree, bool *);
 200 static tree call_builtin_trap (void);
 201 static tree prep_operand (tree);
 202 static void add_candidates (tree, const VEC(tree,gc) *, tree, bool, tree, tree,
 203                             int, struct z_candidate **);
 204 static conversion *merge_conversion_sequences (conversion *, conversion *);
 205 static bool magic_varargs_p (tree);
 206 static tree build_temp (tree, tree, int, diagnostic_t *);
 207
 208 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
 209    NAME can take many forms...  */
 210
 211 bool
 212 check_dtor_name (tree basetype, tree name)
 213 {
 214   /* Just accept something we've already complained about.  */
 215   if (name == error_mark_node)
 216     return true;
 217
 218   if (TREE_CODE (name) == TYPE_DECL)
 219     name = TREE_TYPE (name);
 220   else if (TYPE_P (name))
 221     /* OK */;
 222   else if (TREE_CODE (name) == IDENTIFIER_NODE)
 223     {
 224       if ((MAYBE_CLASS_TYPE_P (basetype)
 225            && name == constructor_name (basetype))
 226           || (TREE_CODE (basetype) == ENUMERAL_TYPE
 227               && name == TYPE_IDENTIFIER (basetype)))
 228         return true;
 229       else
 230         name = get_type_value (name);
 231     }
 232   else
 233     {
 234       /* In the case of:
 235
 236          template <class T> struct S { ~S(); };
 237          int i;
 238          i.~S();
 239
 240          NAME will be a class template.  */
 241       gcc_assert (DECL_CLASS_TEMPLATE_P (name));
 242       return false;
 243     }
 244
 245   if (!name)
 246     return false;
 247   return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
 248 }
 249
 250 /* We want the address of a function or method.  We avoid creating a
 251    pointer-to-member function.  */
 252
 253 tree
 254 build_addr_func (tree function)
 255 {
 256   tree type = TREE_TYPE (function);
 257
 258   /* We have to do these by hand to avoid real pointer to member
 259      functions.  */
 260   if (TREE_CODE (type) == METHOD_TYPE)
 261     {
 262       if (TREE_CODE (function) == OFFSET_REF)
 263         {
 264           tree object = build_address (TREE_OPERAND (function, 0));
 265           return get_member_function_from_ptrfunc (&object,
 266                                                    TREE_OPERAND (function, 1));
 267         }
 268       function = build_address (function);
 269     }
 270   else
 271     function = decay_conversion (function);
 272
 273   return function;
 274 }
 275
 276 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
 277    POINTER_TYPE to those.  Note, pointer to member function types
 278    (TYPE_PTRMEMFUNC_P) must be handled by our callers.  There are
 279    two variants.  build_call_a is the primitive taking an array of
 280    arguments, while build_call_n is a wrapper that handles varargs.  */
 281
 282 tree
 283 build_call_n (tree function, int n, ...)
 284 {
 285   if (n == 0)
 286     return build_call_a (function, 0, NULL);
 287   else
 288     {
 289       tree *argarray = (tree *) alloca (n * sizeof (tree));
 290       va_list ap;
 291       int i;
 292
 293       va_start (ap, n);
 294       for (i = 0; i < n; i++)
 295         argarray[i] = va_arg (ap, tree);
 296       va_end (ap);
 297       return build_call_a (function, n, argarray);
 298     }
 299 }
 300
 301 tree
 302 build_call_a (tree function, int n, tree *argarray)
 303 {
 304   int is_constructor = 0;
 305   int nothrow;
 306   tree decl;
 307   tree result_type;
 308   tree fntype;
 309   int i;
 310
 311   function = build_addr_func (function);
 312
 313   gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
 314   fntype = TREE_TYPE (TREE_TYPE (function));
 315   gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
 316               || TREE_CODE (fntype) == METHOD_TYPE);
 317   result_type = TREE_TYPE (fntype);
 318
 319   if (TREE_CODE (function) == ADDR_EXPR
 320       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
 321     {
 322       decl = TREE_OPERAND (function, 0);
 323       if (!TREE_USED (decl))
 324         {
 325           /* We invoke build_call directly for several library
 326              functions.  These may have been declared normally if
 327              we're building libgcc, so we can't just check
 328              DECL_ARTIFICIAL.  */
 329           gcc_assert (DECL_ARTIFICIAL (decl)
 330                       || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
 331                                    "__", 2));
 332           mark_used (decl);
 333         }
 334     }
 335   else
 336     decl = NULL_TREE;
 337
 338   /* We check both the decl and the type; a function may be known not to
 339      throw without being declared throw().  */
 340   nothrow = ((decl && TREE_NOTHROW (decl))
 341              || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
 342
 343   if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain)
 344     current_function_returns_abnormally = 1;
 345
 346   if (decl && TREE_DEPRECATED (decl))
 347     warn_deprecated_use (decl, NULL_TREE);
 348   require_complete_eh_spec_types (fntype, decl);
 349
 350   if (decl && DECL_CONSTRUCTOR_P (decl))
 351     is_constructor = 1;
 352
 353   /* Don't pass empty class objects by value.  This is useful
 354      for tags in STL, which are used to control overload resolution.
 355      We don't need to handle other cases of copying empty classes.  */
 356   if (! decl || ! DECL_BUILT_IN (decl))
 357     for (i = 0; i < n; i++)
 358       if (is_empty_class (TREE_TYPE (argarray[i]))
 359           && ! TREE_ADDRESSABLE (TREE_TYPE (argarray[i])))
 360         {
 361           tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (argarray[i]));
 362           argarray[i] = build2 (COMPOUND_EXPR, TREE_TYPE (t),
 363                                 argarray[i], t);
 364         }
 365
 366   function = build_call_array (result_type, function, n, argarray);
 367   TREE_HAS_CONSTRUCTOR (function) = is_constructor;
 368   TREE_NOTHROW (function) = nothrow;
 369
 370   return function;
 371 }
 372
 373 /* Build something of the form ptr->method (args)
 374    or object.method (args).  This can also build
 375    calls to constructors, and find friends.
 376
 377    Member functions always take their class variable
 378    as a pointer.
 379
 380    INSTANCE is a class instance.
 381
 382    NAME is the name of the method desired, usually an IDENTIFIER_NODE.
 383
 384    PARMS help to figure out what that NAME really refers to.
 385
 386    BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
 387    down to the real instance type to use for access checking.  We need this
 388    information to get protected accesses correct.
 389
 390    FLAGS is the logical disjunction of zero or more LOOKUP_
 391    flags.  See cp-tree.h for more info.
 392
 393    If this is all OK, calls build_function_call with the resolved
 394    member function.
 395
 396    This function must also handle being called to perform
 397    initialization, promotion/coercion of arguments, and
 398    instantiation of default parameters.
 399
 400    Note that NAME may refer to an instance variable name.  If
 401    `operator()()' is defined for the type of that field, then we return
 402    that result.  */
 403
 404 /* New overloading code.  */
 405
 406 typedef struct z_candidate z_candidate;
 407
 408 typedef struct candidate_warning candidate_warning;
 409 struct candidate_warning {
 410   z_candidate *loser;
 411   candidate_warning *next;
 412 };
 413
 414 struct z_candidate {
 415   /* The FUNCTION_DECL that will be called if this candidate is
 416      selected by overload resolution.  */
 417   tree fn;
 418   /* If not NULL_TREE, the first argument to use when calling this
 419      function.  */
 420   tree first_arg;
 421   /* The rest of the arguments to use when calling this function.  If
 422      there are no further arguments this may be NULL or it may be an
 423      empty vector.  */
 424   const VEC(tree,gc) *args;
 425   /* The implicit conversion sequences for each of the arguments to
 426      FN.  */
 427   conversion **convs;
 428   /* The number of implicit conversion sequences.  */
 429   size_t num_convs;
 430   /* If FN is a user-defined conversion, the standard conversion
 431      sequence from the type returned by FN to the desired destination
 432      type.  */
 433   conversion *second_conv;
 434   int viable;
 435   /* If FN is a member function, the binfo indicating the path used to
 436      qualify the name of FN at the call site.  This path is used to
 437      determine whether or not FN is accessible if it is selected by
 438      overload resolution.  The DECL_CONTEXT of FN will always be a
 439      (possibly improper) base of this binfo.  */
 440   tree access_path;
 441   /* If FN is a non-static member function, the binfo indicating the
 442      subobject to which the `this' pointer should be converted if FN
 443      is selected by overload resolution.  The type pointed to the by
 444      the `this' pointer must correspond to the most derived class
 445      indicated by the CONVERSION_PATH.  */
 446   tree conversion_path;
 447   tree template_decl;
 448   candidate_warning *warnings;
 449   z_candidate *next;
 450 };
 451
 452 /* Returns true iff T is a null pointer constant in the sense of
 453    [conv.ptr].  */
 454
 455 bool
 456 null_ptr_cst_p (tree t)
 457 {
 458   /* [conv.ptr]
 459
 460      A null pointer constant is an integral constant expression
 461      (_expr.const_) rvalue of integer type that evaluates to zero.  */
 462   t = integral_constant_value (t);
 463   if (t == null_node)
 464     return true;
 465   if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
 466     {
 467       STRIP_NOPS (t);
 468       if (!TREE_OVERFLOW (t))
 469         return true;
 470     }
 471   return false;
 472 }
 473
 474 /* Returns nonzero if PARMLIST consists of only default parms and/or
 475    ellipsis.  */
 476
 477 bool
 478 sufficient_parms_p (const_tree parmlist)
 479 {
 480   for (; parmlist && parmlist != void_list_node;
 481        parmlist = TREE_CHAIN (parmlist))
 482     if (!TREE_PURPOSE (parmlist))
 483       return false;
 484   return true;
 485 }
 486
 487 /* Allocate N bytes of memory from the conversion obstack.  The memory
 488    is zeroed before being returned.  */
 489
 490 static void *
 491 conversion_obstack_alloc (size_t n)
 492 {
 493   void *p;
 494   if (!conversion_obstack_initialized)
 495     {
 496       gcc_obstack_init (&conversion_obstack);
 497       conversion_obstack_initialized = true;
 498     }
 499   p = obstack_alloc (&conversion_obstack, n);
 500   memset (p, 0, n);
 501   return p;
 502 }
 503
 504 /* Dynamically allocate a conversion.  */
 505
 506 static conversion *
 507 alloc_conversion (conversion_kind kind)
 508 {
 509   conversion *c;
 510   c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
 511   c->kind = kind;
 512   return c;
 513 }
 514
 515 #ifdef ENABLE_CHECKING
 516
 517 /* Make sure that all memory on the conversion obstack has been
 518    freed.  */
 519
 520 void
 521 validate_conversion_obstack (void)
 522 {
 523   if (conversion_obstack_initialized)
 524     gcc_assert ((obstack_next_free (&conversion_obstack)
 525                  == obstack_base (&conversion_obstack)));
 526 }
 527
 528 #endif /* ENABLE_CHECKING */
 529
 530 /* Dynamically allocate an array of N conversions.  */
 531
 532 static conversion **
 533 alloc_conversions (size_t n)
 534 {
 535   return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
 536 }
 537
 538 static conversion *
 539 build_conv (conversion_kind code, tree type, conversion *from)
 540 {
 541   conversion *t;
 542   conversion_rank rank = CONVERSION_RANK (from);
 543
 544   /* Note that the caller is responsible for filling in t->cand for
 545      user-defined conversions.  */
 546   t = alloc_conversion (code);
 547   t->type = type;
 548   t->u.next = from;
 549
 550   switch (code)
 551     {
 552     case ck_ptr:
 553     case ck_pmem:
 554     case ck_base:
 555     case ck_std:
 556       if (rank < cr_std)
 557         rank = cr_std;
 558       break;
 559
 560     case ck_qual:
 561       if (rank < cr_exact)
 562         rank = cr_exact;
 563       break;
 564
 565     default:
 566       break;
 567     }
 568   t->rank = rank;
 569   t->user_conv_p = (code == ck_user || from->user_conv_p);
 570   t->bad_p = from->bad_p;
 571   t->base_p = false;
 572   return t;
 573 }
 574
 575 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
 576    specialization of std::initializer_list<T>, if such a conversion is
 577    possible.  */
 578
 579 static conversion *
 580 build_list_conv (tree type, tree ctor, int flags)
 581 {
 582   tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
 583   unsigned len = CONSTRUCTOR_NELTS (ctor);
 584   conversion **subconvs = alloc_conversions (len);
 585   conversion *t;
 586   unsigned i;
 587   tree val;
 588
 589   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
 590     {
 591       conversion *sub
 592         = implicit_conversion (elttype, TREE_TYPE (val), val,
 593                                false, flags);
 594       if (sub == NULL)
 595         return NULL;
 596
 597       subconvs[i] = sub;
 598     }
 599
 600   t = alloc_conversion (ck_list);
 601   t->type = type;
 602   t->u.list = subconvs;
 603   t->rank = cr_exact;
 604
 605   for (i = 0; i < len; ++i)
 606     {
 607       conversion *sub = subconvs[i];
 608       if (sub->rank > t->rank)
 609         t->rank = sub->rank;
 610       if (sub->user_conv_p)
 611         t->user_conv_p = true;
 612       if (sub->bad_p)
 613         t->bad_p = true;
 614     }
 615
 616   return t;
 617 }
 618
 619 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
 620    aggregate class, if such a conversion is possible.  */
 621
 622 static conversion *
 623 build_aggr_conv (tree type, tree ctor, int flags)
 624 {
 625   unsigned HOST_WIDE_INT i = 0;
 626   conversion *c;
 627   tree field = TYPE_FIELDS (type);
 628
 629   for (; field; field = TREE_CHAIN (field), ++i)
 630     {
 631       if (TREE_CODE (field) != FIELD_DECL)
 632         continue;
 633       if (i < CONSTRUCTOR_NELTS (ctor))
 634         {
 635           constructor_elt *ce = CONSTRUCTOR_ELT (ctor, i);
 636           if (!can_convert_arg (TREE_TYPE (field), TREE_TYPE (ce->value),
 637                                 ce->value, flags))
 638             return NULL;
 639         }
 640       else if (build_value_init (TREE_TYPE (field)) == error_mark_node)
 641         return NULL;
 642     }
 643
 644   c = alloc_conversion (ck_aggr);
 645   c->type = type;
 646   c->rank = cr_exact;
 647   c->user_conv_p = true;
 648   c->u.next = NULL;
 649   return c;
 650 }
 651
 652 /* Build a representation of the identity conversion from EXPR to
 653    itself.  The TYPE should match the type of EXPR, if EXPR is non-NULL.  */
 654
 655 static conversion *
 656 build_identity_conv (tree type, tree expr)
 657 {
 658   conversion *c;
 659
 660   c = alloc_conversion (ck_identity);
 661   c->type = type;
 662   c->u.expr = expr;
 663
 664   return c;
 665 }
 666
 667 /* Converting from EXPR to TYPE was ambiguous in the sense that there
 668    were multiple user-defined conversions to accomplish the job.
 669    Build a conversion that indicates that ambiguity.  */
 670
 671 static conversion *
 672 build_ambiguous_conv (tree type, tree expr)
 673 {
 674   conversion *c;
 675
 676   c = alloc_conversion (ck_ambig);
 677   c->type = type;
 678   c->u.expr = expr;
 679
 680   return c;
 681 }
 682
 683 tree
 684 strip_top_quals (tree t)
 685 {
 686   if (TREE_CODE (t) == ARRAY_TYPE)
 687     return t;
 688   return cp_build_qualified_type (t, 0);
 689 }
 690
 691 /* Returns the standard conversion path (see [conv]) from type FROM to type
 692    TO, if any.  For proper handling of null pointer constants, you must
 693    also pass the expression EXPR to convert from.  If C_CAST_P is true,
 694    this conversion is coming from a C-style cast.  */
 695
 696 static conversion *
 697 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
 698                      int flags)
 699 {
 700   enum tree_code fcode, tcode;
 701   conversion *conv;
 702   bool fromref = false;
 703
 704   to = non_reference (to);
 705   if (TREE_CODE (from) == REFERENCE_TYPE)
 706     {
 707       fromref = true;
 708       from = TREE_TYPE (from);
 709     }
 710   to = strip_top_quals (to);
 711   from = strip_top_quals (from);
 712
 713   if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
 714       && expr && type_unknown_p (expr))
 715     {
 716       tsubst_flags_t tflags = tf_conv;
 717       if (!(flags & LOOKUP_PROTECT))
 718         tflags |= tf_no_access_control;
 719       expr = instantiate_type (to, expr, tflags);
 720       if (expr == error_mark_node)
 721         return NULL;
 722       from = TREE_TYPE (expr);
 723     }
 724
 725   fcode = TREE_CODE (from);
 726   tcode = TREE_CODE (to);
 727
 728   conv = build_identity_conv (from, expr);
 729   if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
 730     {
 731       from = type_decays_to (from);
 732       fcode = TREE_CODE (from);
 733       conv = build_conv (ck_lvalue, from, conv);
 734     }
 735   else if (fromref || (expr && lvalue_p (expr)))
 736     {
 737       if (expr)
 738         {
 739           tree bitfield_type;
 740           bitfield_type = is_bitfield_expr_with_lowered_type (expr);
 741           if (bitfield_type)
 742             {
 743               from = strip_top_quals (bitfield_type);
 744               fcode = TREE_CODE (from);
 745             }
 746         }
 747       conv = build_conv (ck_rvalue, from, conv);
 748     }
 749
 750    /* Allow conversion between `__complex__' data types.  */
 751   if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
 752     {
 753       /* The standard conversion sequence to convert FROM to TO is
 754          the standard conversion sequence to perform componentwise
 755          conversion.  */
 756       conversion *part_conv = standard_conversion
 757         (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
 758
 759       if (part_conv)
 760         {
 761           conv = build_conv (part_conv->kind, to, conv);
 762           conv->rank = part_conv->rank;
 763         }
 764       else
 765         conv = NULL;
 766
 767       return conv;
 768     }
 769
 770   if (same_type_p (from, to))
 771     return conv;
 772
 773   if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
 774       && expr && null_ptr_cst_p (expr))
 775     conv = build_conv (ck_std, to, conv);
 776   else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
 777            || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
 778     {
 779       /* For backwards brain damage compatibility, allow interconversion of
 780          pointers and integers with a pedwarn.  */
 781       conv = build_conv (ck_std, to, conv);
 782       conv->bad_p = true;
 783     }
 784   else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
 785     {
 786       /* For backwards brain damage compatibility, allow interconversion of
 787          enums and integers with a pedwarn.  */
 788       conv = build_conv (ck_std, to, conv);
 789       conv->bad_p = true;
 790     }
 791   else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
 792            || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
 793     {
 794       tree to_pointee;
 795       tree from_pointee;
 796
 797       if (tcode == POINTER_TYPE
 798           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
 799                                                         TREE_TYPE (to)))
 800         ;
 801       else if (VOID_TYPE_P (TREE_TYPE (to))
 802                && !TYPE_PTRMEM_P (from)
 803                && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
 804         {
 805           from = build_pointer_type
 806             (cp_build_qualified_type (void_type_node,
 807                                       cp_type_quals (TREE_TYPE (from))));
 808           conv = build_conv (ck_ptr, from, conv);
 809         }
 810       else if (TYPE_PTRMEM_P (from))
 811         {
 812           tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
 813           tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
 814
 815           if (DERIVED_FROM_P (fbase, tbase)
 816               && (same_type_ignoring_top_level_qualifiers_p
 817                   (TYPE_PTRMEM_POINTED_TO_TYPE (from),
 818                    TYPE_PTRMEM_POINTED_TO_TYPE (to))))
 819             {
 820               from = build_ptrmem_type (tbase,
 821                                         TYPE_PTRMEM_POINTED_TO_TYPE (from));
 822               conv = build_conv (ck_pmem, from, conv);
 823             }
 824           else if (!same_type_p (fbase, tbase))
 825             return NULL;
 826         }
 827       else if (CLASS_TYPE_P (TREE_TYPE (from))
 828                && CLASS_TYPE_P (TREE_TYPE (to))
 829                /* [conv.ptr]
 830
 831                   An rvalue of type "pointer to cv D," where D is a
 832                   class type, can be converted to an rvalue of type
 833                   "pointer to cv B," where B is a base class (clause
 834                   _class.derived_) of D.  If B is an inaccessible
 835                   (clause _class.access_) or ambiguous
 836                   (_class.member.lookup_) base class of D, a program
 837                   that necessitates this conversion is ill-formed.
 838                   Therefore, we use DERIVED_FROM_P, and do not check
 839                   access or uniqueness.  */
 840                && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
 841         {
 842           from =
 843             cp_build_qualified_type (TREE_TYPE (to),
 844                                      cp_type_quals (TREE_TYPE (from)));
 845           from = build_pointer_type (from);
 846           conv = build_conv (ck_ptr, from, conv);
 847           conv->base_p = true;
 848         }
 849
 850       if (tcode == POINTER_TYPE)
 851         {
 852           to_pointee = TREE_TYPE (to);
 853           from_pointee = TREE_TYPE (from);
 854         }
 855       else
 856         {
 857           to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
 858           from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
 859         }
 860
 861       if (same_type_p (from, to))
 862         /* OK */;
 863       else if (c_cast_p && comp_ptr_ttypes_const (to, from))
 864         /* In a C-style cast, we ignore CV-qualification because we
 865            are allowed to perform a static_cast followed by a
 866            const_cast.  */
 867         conv = build_conv (ck_qual, to, conv);
 868       else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
 869         conv = build_conv (ck_qual, to, conv);
 870       else if (expr && string_conv_p (to, expr, 0))
 871         /* converting from string constant to char *.  */
 872         conv = build_conv (ck_qual, to, conv);
 873       else if (ptr_reasonably_similar (to_pointee, from_pointee))
 874         {
 875           conv = build_conv (ck_ptr, to, conv);
 876           conv->bad_p = true;
 877         }
 878       else
 879         return NULL;
 880
 881       from = to;
 882     }
 883   else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
 884     {
 885       tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
 886       tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
 887       tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
 888       tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
 889
 890       if (!DERIVED_FROM_P (fbase, tbase)
 891           || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
 892           || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
 893                          TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
 894           || cp_type_quals (fbase) != cp_type_quals (tbase))
 895         return NULL;
 896
 897       from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
 898       from = build_method_type_directly (from,
 899                                          TREE_TYPE (fromfn),
 900                                          TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
 901       from = build_ptrmemfunc_type (build_pointer_type (from));
 902       conv = build_conv (ck_pmem, from, conv);
 903       conv->base_p = true;
 904     }
 905   else if (tcode == BOOLEAN_TYPE)
 906     {
 907       /* [conv.bool]
 908
 909           An rvalue of arithmetic, unscoped enumeration, pointer, or
 910           pointer to member type can be converted to an rvalue of type
 911           bool.  */
 912       if (ARITHMETIC_TYPE_P (from)
 913           || UNSCOPED_ENUM_P (from)
 914           || fcode == POINTER_TYPE
 915           || TYPE_PTR_TO_MEMBER_P (from))
 916         {
 917           conv = build_conv (ck_std, to, conv);
 918           if (fcode == POINTER_TYPE
 919               || TYPE_PTRMEM_P (from)
 920               || (TYPE_PTRMEMFUNC_P (from)
 921                   && conv->rank < cr_pbool))
 922             conv->rank = cr_pbool;
 923           return conv;
 924         }
 925
 926       return NULL;
 927     }
 928   /* We don't check for ENUMERAL_TYPE here because there are no standard
 929      conversions to enum type.  */
 930   /* As an extension, allow conversion to complex type.  */
 931   else if (ARITHMETIC_TYPE_P (to))
 932     {
 933       if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
 934           || SCOPED_ENUM_P (from))
 935         return NULL;
 936       conv = build_conv (ck_std, to, conv);
 937
 938       /* Give this a better rank if it's a promotion.  */
 939       if (same_type_p (to, type_promotes_to (from))
 940           && conv->u.next->rank <= cr_promotion)
 941         conv->rank = cr_promotion;
 942     }
 943   else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
 944            && vector_types_convertible_p (from, to, false))
 945     return build_conv (ck_std, to, conv);
 946   else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
 947            && is_properly_derived_from (from, to))
 948     {
 949       if (conv->kind == ck_rvalue)
 950         conv = conv->u.next;
 951       conv = build_conv (ck_base, to, conv);
 952       /* The derived-to-base conversion indicates the initialization
 953          of a parameter with base type from an object of a derived
 954          type.  A temporary object is created to hold the result of
 955          the conversion unless we're binding directly to a reference.  */
 956       conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
 957     }
 958   else
 959     return NULL;
 960
 961   if (flags & LOOKUP_NO_NARROWING)
 962     conv->check_narrowing = true;
 963
 964   return conv;
 965 }
 966
 967 /* Returns nonzero if T1 is reference-related to T2.  */
 968
 969 static bool
 970 reference_related_p (tree t1, tree t2)
 971 {
 972   t1 = TYPE_MAIN_VARIANT (t1);
 973   t2 = TYPE_MAIN_VARIANT (t2);
 974
 975   /* [dcl.init.ref]
 976
 977      Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
 978      to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
 979      of T2.  */
 980   return (same_type_p (t1, t2)
 981           || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
 982               && DERIVED_FROM_P (t1, t2)));
 983 }
 984
 985 /* Returns nonzero if T1 is reference-compatible with T2.  */
 986
 987 static bool
 988 reference_compatible_p (tree t1, tree t2)
 989 {
 990   /* [dcl.init.ref]
 991
 992      "cv1 T1" is reference compatible with "cv2 T2" if T1 is
 993      reference-related to T2 and cv1 is the same cv-qualification as,
 994      or greater cv-qualification than, cv2.  */
 995   return (reference_related_p (t1, t2)
 996           && at_least_as_qualified_p (t1, t2));
 997 }
 998
 999 /* Determine whether or not the EXPR (of class type S) can be
1000    converted to T as in [over.match.ref].  */
1001
1002 static conversion *
1003 convert_class_to_reference (tree reference_type, tree s, tree expr, int flags)
1004 {
1005   tree conversions;
1006   tree first_arg;
1007   conversion *conv;
1008   tree t;
1009   struct z_candidate *candidates;
1010   struct z_candidate *cand;
1011   bool any_viable_p;
1012
1013   conversions = lookup_conversions (s);
1014   if (!conversions)
1015     return NULL;
1016
1017   /* [over.match.ref]
1018
1019      Assuming that "cv1 T" is the underlying type of the reference
1020      being initialized, and "cv S" is the type of the initializer
1021      expression, with S a class type, the candidate functions are
1022      selected as follows:
1023
1024      --The conversion functions of S and its base classes are
1025        considered.  Those that are not hidden within S and yield type
1026        "reference to cv2 T2", where "cv1 T" is reference-compatible
1027        (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1028
1029      The argument list has one argument, which is the initializer
1030      expression.  */
1031
1032   candidates = 0;
1033
1034   /* Conceptually, we should take the address of EXPR and put it in
1035      the argument list.  Unfortunately, however, that can result in
1036      error messages, which we should not issue now because we are just
1037      trying to find a conversion operator.  Therefore, we use NULL,
1038      cast to the appropriate type.  */
1039   first_arg = build_int_cst (build_pointer_type (s), 0);
1040
1041   t = TREE_TYPE (reference_type);
1042
1043   for (; conversions; conversions = TREE_CHAIN (conversions))
1044     {
1045       tree fns = TREE_VALUE (conversions);
1046
1047       for (; fns; fns = OVL_NEXT (fns))
1048         {
1049           tree f = OVL_CURRENT (fns);
1050           tree t2 = TREE_TYPE (TREE_TYPE (f));
1051
1052           if (DECL_NONCONVERTING_P (f)
1053               && (flags & LOOKUP_ONLYCONVERTING))
1054             continue;
1055
1056           cand = NULL;
1057
1058           /* If this is a template function, try to get an exact
1059              match.  */
1060           if (TREE_CODE (f) == TEMPLATE_DECL)
1061             {
1062               cand = add_template_candidate (&candidates,
1063                                              f, s,
1064                                              NULL_TREE,
1065                                              first_arg,
1066                                              NULL,
1067                                              reference_type,
1068                                              TYPE_BINFO (s),
1069                                              TREE_PURPOSE (conversions),
1070                                              LOOKUP_NORMAL,
1071                                              DEDUCE_CONV);
1072
1073               if (cand)
1074                 {
1075                   /* Now, see if the conversion function really returns
1076                      an lvalue of the appropriate type.  From the
1077                      point of view of unification, simply returning an
1078                      rvalue of the right type is good enough.  */
1079                   f = cand->fn;
1080                   t2 = TREE_TYPE (TREE_TYPE (f));
1081                   if (TREE_CODE (t2) != REFERENCE_TYPE
1082                       || !reference_compatible_p (t, TREE_TYPE (t2)))
1083                     {
1084                       candidates = candidates->next;
1085                       cand = NULL;
1086                     }
1087                 }
1088             }
1089           else if (TREE_CODE (t2) == REFERENCE_TYPE
1090                    && reference_compatible_p (t, TREE_TYPE (t2)))
1091             cand = add_function_candidate (&candidates, f, s, first_arg,
1092                                            NULL, TYPE_BINFO (s),
1093                                            TREE_PURPOSE (conversions),
1094                                            LOOKUP_NORMAL);
1095
1096           if (cand)
1097             {
1098               conversion *identity_conv;
1099               /* Build a standard conversion sequence indicating the
1100                  binding from the reference type returned by the
1101                  function to the desired REFERENCE_TYPE.  */
1102               identity_conv
1103                 = build_identity_conv (TREE_TYPE (TREE_TYPE
1104                                                   (TREE_TYPE (cand->fn))),
1105                                        NULL_TREE);
1106               cand->second_conv
1107                 = (direct_reference_binding
1108                    (reference_type, identity_conv));
1109               cand->second_conv->rvaluedness_matches_p
1110                 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1111                   == TYPE_REF_IS_RVALUE (reference_type);
1112               cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1113             }
1114         }
1115     }
1116
1117   candidates = splice_viable (candidates, pedantic, &any_viable_p);
1118   /* If none of the conversion functions worked out, let our caller
1119      know.  */
1120   if (!any_viable_p)
1121     return NULL;
1122
1123   cand = tourney (candidates);
1124   if (!cand)
1125     return NULL;
1126
1127   /* Now that we know that this is the function we're going to use fix
1128      the dummy first argument.  */
1129   gcc_assert (cand->first_arg == NULL_TREE
1130               || integer_zerop (cand->first_arg));
1131   cand->first_arg = build_this (expr);
1132
1133   /* Build a user-defined conversion sequence representing the
1134      conversion.  */
1135   conv = build_conv (ck_user,
1136                      TREE_TYPE (TREE_TYPE (cand->fn)),
1137                      build_identity_conv (TREE_TYPE (expr), expr));
1138   conv->cand = cand;
1139
1140   /* Merge it with the standard conversion sequence from the
1141      conversion function's return type to the desired type.  */
1142   cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1143
1144   if (cand->viable == -1)
1145     conv->bad_p = true;
1146
1147   return cand->second_conv;
1148 }
1149
1150 /* A reference of the indicated TYPE is being bound directly to the
1151    expression represented by the implicit conversion sequence CONV.
1152    Return a conversion sequence for this binding.  */
1153
1154 static conversion *
1155 direct_reference_binding (tree type, conversion *conv)
1156 {
1157   tree t;
1158
1159   gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1160   gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1161
1162   t = TREE_TYPE (type);
1163
1164   /* [over.ics.rank]
1165
1166      When a parameter of reference type binds directly
1167      (_dcl.init.ref_) to an argument expression, the implicit
1168      conversion sequence is the identity conversion, unless the
1169      argument expression has a type that is a derived class of the
1170      parameter type, in which case the implicit conversion sequence is
1171      a derived-to-base Conversion.
1172
1173      If the parameter binds directly to the result of applying a
1174      conversion function to the argument expression, the implicit
1175      conversion sequence is a user-defined conversion sequence
1176      (_over.ics.user_), with the second standard conversion sequence
1177      either an identity conversion or, if the conversion function
1178      returns an entity of a type that is a derived class of the
1179      parameter type, a derived-to-base conversion.  */
1180   if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1181     {
1182       /* Represent the derived-to-base conversion.  */
1183       conv = build_conv (ck_base, t, conv);
1184       /* We will actually be binding to the base-class subobject in
1185          the derived class, so we mark this conversion appropriately.
1186          That way, convert_like knows not to generate a temporary.  */
1187       conv->need_temporary_p = false;
1188     }
1189   return build_conv (ck_ref_bind, type, conv);
1190 }
1191
1192 /* Returns the conversion path from type FROM to reference type TO for
1193    purposes of reference binding.  For lvalue binding, either pass a
1194    reference type to FROM or an lvalue expression to EXPR.  If the
1195    reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1196    the conversion returned.  If C_CAST_P is true, this
1197    conversion is coming from a C-style cast.  */
1198
1199 static conversion *
1200 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1201 {
1202   conversion *conv = NULL;
1203   tree to = TREE_TYPE (rto);
1204   tree from = rfrom;
1205   tree tfrom;
1206   bool related_p;
1207   bool compatible_p;
1208   cp_lvalue_kind lvalue_p = clk_none;
1209
1210   if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1211     {
1212       expr = instantiate_type (to, expr, tf_none);
1213       if (expr == error_mark_node)
1214         return NULL;
1215       from = TREE_TYPE (expr);
1216     }
1217
1218   if (TREE_CODE (from) == REFERENCE_TYPE)
1219     {
1220       /* Anything with reference type is an lvalue.  */
1221       lvalue_p = clk_ordinary;
1222       from = TREE_TYPE (from);
1223     }
1224   else if (expr)
1225     lvalue_p = real_lvalue_p (expr);
1226
1227   tfrom = from;
1228   if ((lvalue_p & clk_bitfield) != 0)
1229     tfrom = unlowered_expr_type (expr);
1230
1231   /* Figure out whether or not the types are reference-related and
1232      reference compatible.  We have do do this after stripping
1233      references from FROM.  */
1234   related_p = reference_related_p (to, tfrom);
1235   /* If this is a C cast, first convert to an appropriately qualified
1236      type, so that we can later do a const_cast to the desired type.  */
1237   if (related_p && c_cast_p
1238       && !at_least_as_qualified_p (to, tfrom))
1239     to = build_qualified_type (to, cp_type_quals (tfrom));
1240   compatible_p = reference_compatible_p (to, tfrom);
1241
1242   /* Directly bind reference when target expression's type is compatible with
1243      the reference and expression is an lvalue. In DR391, the wording in
1244      [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1245      const and rvalue references to rvalues of compatible class type. */
1246   if (compatible_p
1247       && (lvalue_p
1248           || (!(flags & LOOKUP_NO_TEMP_BIND)
1249               && (CP_TYPE_CONST_NON_VOLATILE_P(to) || TYPE_REF_IS_RVALUE (rto))
1250               && CLASS_TYPE_P (from))))
1251     {
1252       /* [dcl.init.ref]
1253
1254          If the initializer expression
1255
1256          -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1257             is reference-compatible with "cv2 T2,"
1258
1259          the reference is bound directly to the initializer expression
1260          lvalue.
1261
1262          [...]
1263          If the initializer expression is an rvalue, with T2 a class type,
1264          and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1265          is bound to the object represented by the rvalue or to a sub-object
1266          within that object.  */
1267
1268       conv = build_identity_conv (tfrom, expr);
1269       conv = direct_reference_binding (rto, conv);
1270
1271       if (flags & LOOKUP_PREFER_RVALUE)
1272         /* The top-level caller requested that we pretend that the lvalue
1273            be treated as an rvalue.  */
1274         conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1275       else
1276         conv->rvaluedness_matches_p
1277           = (TYPE_REF_IS_RVALUE (rto) == !lvalue_p);
1278
1279       if ((lvalue_p & clk_bitfield) != 0
1280           || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1281         /* For the purposes of overload resolution, we ignore the fact
1282            this expression is a bitfield or packed field. (In particular,
1283            [over.ics.ref] says specifically that a function with a
1284            non-const reference parameter is viable even if the
1285            argument is a bitfield.)
1286
1287            However, when we actually call the function we must create
1288            a temporary to which to bind the reference.  If the
1289            reference is volatile, or isn't const, then we cannot make
1290            a temporary, so we just issue an error when the conversion
1291            actually occurs.  */
1292         conv->need_temporary_p = true;
1293
1294       return conv;
1295     }
1296   /* [class.conv.fct] A conversion function is never used to convert a
1297      (possibly cv-qualified) object to the (possibly cv-qualified) same
1298      object type (or a reference to it), to a (possibly cv-qualified) base
1299      class of that type (or a reference to it).... */
1300   else if (CLASS_TYPE_P (from) && !related_p
1301            && !(flags & LOOKUP_NO_CONVERSION))
1302     {
1303       /* [dcl.init.ref]
1304
1305          If the initializer expression
1306
1307          -- has a class type (i.e., T2 is a class type) can be
1308             implicitly converted to an lvalue of type "cv3 T3," where
1309             "cv1 T1" is reference-compatible with "cv3 T3".  (this
1310             conversion is selected by enumerating the applicable
1311             conversion functions (_over.match.ref_) and choosing the
1312             best one through overload resolution.  (_over.match_).
1313
1314         the reference is bound to the lvalue result of the conversion
1315         in the second case.  */
1316       conv = convert_class_to_reference (rto, from, expr, flags);
1317       if (conv)
1318         return conv;
1319     }
1320
1321   /* From this point on, we conceptually need temporaries, even if we
1322      elide them.  Only the cases above are "direct bindings".  */
1323   if (flags & LOOKUP_NO_TEMP_BIND)
1324     return NULL;
1325
1326   /* [over.ics.rank]
1327
1328      When a parameter of reference type is not bound directly to an
1329      argument expression, the conversion sequence is the one required
1330      to convert the argument expression to the underlying type of the
1331      reference according to _over.best.ics_.  Conceptually, this
1332      conversion sequence corresponds to copy-initializing a temporary
1333      of the underlying type with the argument expression.  Any
1334      difference in top-level cv-qualification is subsumed by the
1335      initialization itself and does not constitute a conversion.  */
1336
1337   /* [dcl.init.ref]
1338
1339      Otherwise, the reference shall be to a non-volatile const type.
1340
1341      Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1342   if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1343     return NULL;
1344
1345   /* [dcl.init.ref]
1346
1347      Otherwise, a temporary of type "cv1 T1" is created and
1348      initialized from the initializer expression using the rules for a
1349      non-reference copy initialization.  If T1 is reference-related to
1350      T2, cv1 must be the same cv-qualification as, or greater
1351      cv-qualification than, cv2; otherwise, the program is ill-formed.  */
1352   if (related_p && !at_least_as_qualified_p (to, from))
1353     return NULL;
1354
1355   /* We're generating a temporary now, but don't bind any more in the
1356      conversion (specifically, don't slice the temporary returned by a
1357      conversion operator).  */
1358   flags |= LOOKUP_NO_TEMP_BIND;
1359
1360   /* Temporaries are copy-initialized, except for this hack to allow
1361      explicit conversion ops to the copy ctor.  See also
1362      add_function_candidate.  */
1363   if (!(flags & LOOKUP_COPY_PARM))
1364     flags |= LOOKUP_ONLYCONVERTING;
1365
1366   conv = implicit_conversion (to, from, expr, c_cast_p,
1367                               flags);
1368   if (!conv)
1369     return NULL;
1370
1371   conv = build_conv (ck_ref_bind, rto, conv);
1372   /* This reference binding, unlike those above, requires the
1373      creation of a temporary.  */
1374   conv->need_temporary_p = true;
1375   conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1376
1377   return conv;
1378 }
1379
1380 /* Returns the implicit conversion sequence (see [over.ics]) from type
1381    FROM to type TO.  The optional expression EXPR may affect the
1382    conversion.  FLAGS are the usual overloading flags.  If C_CAST_P is
1383    true, this conversion is coming from a C-style cast.  */
1384
1385 static conversion *
1386 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1387                      int flags)
1388 {
1389   conversion *conv;
1390
1391   if (from == error_mark_node || to == error_mark_node
1392       || expr == error_mark_node)
1393     return NULL;
1394
1395   if (TREE_CODE (to) == REFERENCE_TYPE)
1396     conv = reference_binding (to, from, expr, c_cast_p, flags);
1397   else
1398     conv = standard_conversion (to, from, expr, c_cast_p, flags);
1399
1400   if (conv)
1401     return conv;
1402
1403   if (is_std_init_list (to) && expr
1404       && BRACE_ENCLOSED_INITIALIZER_P (expr))
1405     return build_list_conv (to, expr, flags);
1406
1407   if (expr != NULL_TREE
1408       && (MAYBE_CLASS_TYPE_P (from)
1409           || MAYBE_CLASS_TYPE_P (to))
1410       && (flags & LOOKUP_NO_CONVERSION) == 0)
1411     {
1412       struct z_candidate *cand;
1413       int convflags = (flags & (LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING));
1414
1415       if (CLASS_TYPE_P (to)
1416           && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1417           && BRACE_ENCLOSED_INITIALIZER_P (expr))
1418         return build_aggr_conv (to, expr, flags);
1419
1420       cand = build_user_type_conversion_1 (to, expr, convflags);
1421       if (cand)
1422         conv = cand->second_conv;
1423
1424       /* We used to try to bind a reference to a temporary here, but that
1425          is now handled after the recursive call to this function at the end
1426          of reference_binding.  */
1427       return conv;
1428     }
1429
1430   return NULL;
1431 }
1432
1433 /* Add a new entry to the list of candidates.  Used by the add_*_candidate
1434    functions.  ARGS will not be changed until a single candidate is
1435    selected.  */
1436
1437 static struct z_candidate *
1438 add_candidate (struct z_candidate **candidates,
1439                tree fn, tree first_arg, const VEC(tree,gc) *args,
1440                size_t num_convs, conversion **convs,
1441                tree access_path, tree conversion_path,
1442                int viable)
1443 {
1444   struct z_candidate *cand = (struct z_candidate *)
1445     conversion_obstack_alloc (sizeof (struct z_candidate));
1446
1447   cand->fn = fn;
1448   cand->first_arg = first_arg;
1449   cand->args = args;
1450   cand->convs = convs;
1451   cand->num_convs = num_convs;
1452   cand->access_path = access_path;
1453   cand->conversion_path = conversion_path;
1454   cand->viable = viable;
1455   cand->next = *candidates;
1456   *candidates = cand;
1457
1458   return cand;
1459 }
1460
1461 /* Create an overload candidate for the function or method FN called
1462    with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1463    FLAGS is passed on to implicit_conversion.
1464
1465    This does not change ARGS.
1466
1467    CTYPE, if non-NULL, is the type we want to pretend this function
1468    comes from for purposes of overload resolution.  */
1469
1470 static struct z_candidate *
1471 add_function_candidate (struct z_candidate **candidates,
1472                         tree fn, tree ctype, tree first_arg,
1473                         const VEC(tree,gc) *args, tree access_path,
1474                         tree conversion_path, int flags)
1475 {
1476   tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1477   int i, len;
1478   conversion **convs;
1479   tree parmnode;
1480   tree orig_first_arg = first_arg;
1481   int skip;
1482   int viable = 1;
1483
1484   /* At this point we should not see any functions which haven't been
1485      explicitly declared, except for friend functions which will have
1486      been found using argument dependent lookup.  */
1487   gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1488
1489   /* The `this', `in_chrg' and VTT arguments to constructors are not
1490      considered in overload resolution.  */
1491   if (DECL_CONSTRUCTOR_P (fn))
1492     {
1493       parmlist = skip_artificial_parms_for (fn, parmlist);
1494       skip = num_artificial_parms_for (fn);
1495       if (skip > 0 && first_arg != NULL_TREE)
1496         {
1497           --skip;
1498           first_arg = NULL_TREE;
1499         }
1500     }
1501   else
1502     skip = 0;
1503
1504   len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1505   convs = alloc_conversions (len);
1506
1507   /* 13.3.2 - Viable functions [over.match.viable]
1508      First, to be a viable function, a candidate function shall have enough
1509      parameters to agree in number with the arguments in the list.
1510
1511      We need to check this first; otherwise, checking the ICSes might cause
1512      us to produce an ill-formed template instantiation.  */
1513
1514   parmnode = parmlist;
1515   for (i = 0; i < len; ++i)
1516     {
1517       if (parmnode == NULL_TREE || parmnode == void_list_node)
1518         break;
1519       parmnode = TREE_CHAIN (parmnode);
1520     }
1521
1522   if (i < len && parmnode)
1523     viable = 0;
1524
1525   /* Make sure there are default args for the rest of the parms.  */
1526   else if (!sufficient_parms_p (parmnode))
1527     viable = 0;
1528
1529   if (! viable)
1530     goto out;
1531
1532   /* Second, for F to be a viable function, there shall exist for each
1533      argument an implicit conversion sequence that converts that argument
1534      to the corresponding parameter of F.  */
1535
1536   parmnode = parmlist;
1537
1538   for (i = 0; i < len; ++i)
1539     {
1540       tree arg, argtype;
1541       conversion *t;
1542       int is_this;
1543
1544       if (parmnode == void_list_node)
1545         break;
1546
1547       if (i == 0 && first_arg != NULL_TREE)
1548         arg = first_arg;
1549       else
1550         arg = VEC_index (tree, args,
1551                          i + skip - (first_arg != NULL_TREE ? 1 : 0));
1552       argtype = lvalue_type (arg);
1553
1554       is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1555                  && ! DECL_CONSTRUCTOR_P (fn));
1556
1557       if (parmnode)
1558         {
1559           tree parmtype = TREE_VALUE (parmnode);
1560           int lflags = flags;
1561
1562           /* The type of the implicit object parameter ('this') for
1563              overload resolution is not always the same as for the
1564              function itself; conversion functions are considered to
1565              be members of the class being converted, and functions
1566              introduced by a using-declaration are considered to be
1567              members of the class that uses them.
1568
1569              Since build_over_call ignores the ICS for the `this'
1570              parameter, we can just change the parm type.  */
1571           if (ctype && is_this)
1572             {
1573               parmtype
1574                 = build_qualified_type (ctype,
1575                                         TYPE_QUALS (TREE_TYPE (parmtype)));
1576               parmtype = build_pointer_type (parmtype);
1577             }
1578
1579           if (ctype && i == 0 && DECL_COPY_CONSTRUCTOR_P (fn))
1580             {
1581               /* Hack: Direct-initialize copy parm (i.e. suppress
1582                  LOOKUP_ONLYCONVERTING) to make explicit conversion ops
1583                  work.  See also reference_binding.  */
1584               lflags |= LOOKUP_COPY_PARM;
1585               if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1586                 lflags |= LOOKUP_NO_CONVERSION;
1587             }
1588           else
1589             lflags |= LOOKUP_ONLYCONVERTING;
1590
1591           t = implicit_conversion (parmtype, argtype, arg,
1592                                    /*c_cast_p=*/false, lflags);
1593         }
1594       else
1595         {
1596           t = build_identity_conv (argtype, arg);
1597           t->ellipsis_p = true;
1598         }
1599
1600       if (t && is_this)
1601         t->this_p = true;
1602
1603       convs[i] = t;
1604       if (! t)
1605         {
1606           viable = 0;
1607           break;
1608         }
1609
1610       if (t->bad_p)
1611         viable = -1;
1612
1613       if (parmnode)
1614         parmnode = TREE_CHAIN (parmnode);
1615     }
1616
1617  out:
1618   return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
1619                         access_path, conversion_path, viable);
1620 }
1621
1622 /* Create an overload candidate for the conversion function FN which will
1623    be invoked for expression OBJ, producing a pointer-to-function which
1624    will in turn be called with the argument list FIRST_ARG/ARGLIST,
1625    and add it to CANDIDATES.  This does not change ARGLIST.  FLAGS is
1626    passed on to implicit_conversion.
1627
1628    Actually, we don't really care about FN; we care about the type it
1629    converts to.  There may be multiple conversion functions that will
1630    convert to that type, and we rely on build_user_type_conversion_1 to
1631    choose the best one; so when we create our candidate, we record the type
1632    instead of the function.  */
1633
1634 static struct z_candidate *
1635 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1636                     tree first_arg, const VEC(tree,gc) *arglist,
1637                     tree access_path, tree conversion_path)
1638 {
1639   tree totype = TREE_TYPE (TREE_TYPE (fn));
1640   int i, len, viable, flags;
1641   tree parmlist, parmnode;
1642   conversion **convs;
1643
1644   for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1645     parmlist = TREE_TYPE (parmlist);
1646   parmlist = TYPE_ARG_TYPES (parmlist);
1647
1648   len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
1649   convs = alloc_conversions (len);
1650   parmnode = parmlist;
1651   viable = 1;
1652   flags = LOOKUP_IMPLICIT;
1653
1654   /* Don't bother looking up the same type twice.  */
1655   if (*candidates && (*candidates)->fn == totype)
1656     return NULL;
1657
1658   for (i = 0; i < len; ++i)
1659     {
1660       tree arg, argtype;
1661       conversion *t;
1662
1663       if (i == 0)
1664         arg = obj;
1665       else if (i == 1 && first_arg != NULL_TREE)
1666         arg = first_arg;
1667       else
1668         arg = VEC_index (tree, arglist,
1669                          i - (first_arg != NULL_TREE ? 1 : 0) - 1);
1670       argtype = lvalue_type (arg);
1671
1672       if (i == 0)
1673         t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1674                                  flags);
1675       else if (parmnode == void_list_node)
1676         break;
1677       else if (parmnode)
1678         t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1679                                  /*c_cast_p=*/false, flags);
1680       else
1681         {
1682           t = build_identity_conv (argtype, arg);
1683           t->ellipsis_p = true;
1684         }
1685
1686       convs[i] = t;
1687       if (! t)
1688         break;
1689
1690       if (t->bad_p)
1691         viable = -1;
1692
1693       if (i == 0)
1694         continue;
1695
1696       if (parmnode)
1697         parmnode = TREE_CHAIN (parmnode);
1698     }
1699
1700   if (i < len)
1701     viable = 0;
1702
1703   if (!sufficient_parms_p (parmnode))
1704     viable = 0;
1705
1706   return add_candidate (candidates, totype, first_arg, arglist, len, convs,
1707                         access_path, conversion_path, viable);
1708 }
1709
1710 static void
1711 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1712                          tree type1, tree type2, tree *args, tree *argtypes,
1713                          int flags)
1714 {
1715   conversion *t;
1716   conversion **convs;
1717   size_t num_convs;
1718   int viable = 1, i;
1719   tree types[2];
1720
1721   types[0] = type1;
1722   types[1] = type2;
1723
1724   num_convs =  args[2] ? 3 : (args[1] ? 2 : 1);
1725   convs = alloc_conversions (num_convs);
1726   flags |= LOOKUP_ONLYCONVERTING;
1727
1728   for (i = 0; i < 2; ++i)
1729     {
1730       if (! args[i])
1731         break;
1732
1733       t = implicit_conversion (types[i], argtypes[i], args[i],
1734                                /*c_cast_p=*/false, flags);
1735       if (! t)
1736         {
1737           viable = 0;
1738           /* We need something for printing the candidate.  */
1739           t = build_identity_conv (types[i], NULL_TREE);
1740         }
1741       else if (t->bad_p)
1742         viable = 0;
1743       convs[i] = t;
1744     }
1745
1746   /* For COND_EXPR we rearranged the arguments; undo that now.  */
1747   if (args[2])
1748     {
1749       convs[2] = convs[1];
1750       convs[1] = convs[0];
1751       t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1752                                /*c_cast_p=*/false, flags);
1753       if (t)
1754         convs[0] = t;
1755       else
1756         viable = 0;
1757     }
1758
1759   add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
1760                  num_convs, convs,
1761                  /*access_path=*/NULL_TREE,
1762                  /*conversion_path=*/NULL_TREE,
1763                  viable);
1764 }
1765
1766 static bool
1767 is_complete (tree t)
1768 {
1769   return COMPLETE_TYPE_P (complete_type (t));
1770 }
1771
1772 /* Returns nonzero if TYPE is a promoted arithmetic type.  */
1773
1774 static bool
1775 promoted_arithmetic_type_p (tree type)
1776 {
1777   /* [over.built]
1778
1779      In this section, the term promoted integral type is used to refer
1780      to those integral types which are preserved by integral promotion
1781      (including e.g.  int and long but excluding e.g.  char).
1782      Similarly, the term promoted arithmetic type refers to promoted
1783      integral types plus floating types.  */
1784   return ((CP_INTEGRAL_TYPE_P (type)
1785            && same_type_p (type_promotes_to (type), type))
1786           || TREE_CODE (type) == REAL_TYPE);
1787 }
1788
1789 /* Create any builtin operator overload candidates for the operator in
1790    question given the converted operand types TYPE1 and TYPE2.  The other
1791    args are passed through from add_builtin_candidates to
1792    build_builtin_candidate.
1793
1794    TYPE1 and TYPE2 may not be permissible, and we must filter them.
1795    If CODE is requires candidates operands of the same type of the kind
1796    of which TYPE1 and TYPE2 are, we add both candidates
1797    CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2).  */
1798
1799 static void
1800 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1801                        enum tree_code code2, tree fnname, tree type1,
1802                        tree type2, tree *args, tree *argtypes, int flags)
1803 {
1804   switch (code)
1805     {
1806     case POSTINCREMENT_EXPR:
1807     case POSTDECREMENT_EXPR:
1808       args[1] = integer_zero_node;
1809       type2 = integer_type_node;
1810       break;
1811     default:
1812       break;
1813     }
1814
1815   switch (code)
1816     {
1817
1818 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
1819      and  VQ  is  either  volatile or empty, there exist candidate operator
1820      functions of the form
1821              VQ T&   operator++(VQ T&);
1822              T       operator++(VQ T&, int);
1823    5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1824      type  other than bool, and VQ is either volatile or empty, there exist
1825      candidate operator functions of the form
1826              VQ T&   operator--(VQ T&);
1827              T       operator--(VQ T&, int);
1828    6 For every pair T, VQ), where T is  a  cv-qualified  or  cv-unqualified
1829      complete  object type, and VQ is either volatile or empty, there exist
1830      candidate operator functions of the form
1831              T*VQ&   operator++(T*VQ&);
1832              T*VQ&   operator--(T*VQ&);
1833              T*      operator++(T*VQ&, int);
1834              T*      operator--(T*VQ&, int);  */
1835
1836     case POSTDECREMENT_EXPR:
1837     case PREDECREMENT_EXPR:
1838       if (TREE_CODE (type1) == BOOLEAN_TYPE)
1839         return;
1840     case POSTINCREMENT_EXPR:
1841     case PREINCREMENT_EXPR:
1842       if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1843         {
1844           type1 = build_reference_type (type1);
1845           break;
1846         }
1847       return;
1848
1849 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
1850      exist candidate operator functions of the form
1851
1852              T&      operator*(T*);
1853
1854    8 For every function type T, there exist candidate operator functions of
1855      the form
1856              T&      operator*(T*);  */
1857
1858     case INDIRECT_REF:
1859       if (TREE_CODE (type1) == POINTER_TYPE
1860           && (TYPE_PTROB_P (type1)
1861               || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1862         break;
1863       return;
1864
1865 /* 9 For every type T, there exist candidate operator functions of the form
1866              T*      operator+(T*);
1867
1868    10For  every  promoted arithmetic type T, there exist candidate operator
1869      functions of the form
1870              T       operator+(T);
1871              T       operator-(T);  */
1872
1873     case UNARY_PLUS_EXPR: /* unary + */
1874       if (TREE_CODE (type1) == POINTER_TYPE)
1875         break;
1876     case NEGATE_EXPR:
1877       if (ARITHMETIC_TYPE_P (type1))
1878         break;
1879       return;
1880
1881 /* 11For every promoted integral type T,  there  exist  candidate  operator
1882      functions of the form
1883              T       operator~(T);  */
1884
1885     case BIT_NOT_EXPR:
1886       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
1887         break;
1888       return;
1889
1890 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1891      is the same type as C2 or is a derived class of C2, T  is  a  complete
1892      object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1893      there exist candidate operator functions of the form
1894              CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1895      where CV12 is the union of CV1 and CV2.  */
1896
1897     case MEMBER_REF:
1898       if (TREE_CODE (type1) == POINTER_TYPE
1899           && TYPE_PTR_TO_MEMBER_P (type2))
1900         {
1901           tree c1 = TREE_TYPE (type1);
1902           tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1903
1904           if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
1905               && (TYPE_PTRMEMFUNC_P (type2)
1906                   || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1907             break;
1908         }
1909       return;
1910
1911 /* 13For every pair of promoted arithmetic types L and R, there exist  can-
1912      didate operator functions of the form
1913              LR      operator*(L, R);
1914              LR      operator/(L, R);
1915              LR      operator+(L, R);
1916              LR      operator-(L, R);
1917              bool    operator<(L, R);
1918              bool    operator>(L, R);
1919              bool    operator<=(L, R);
1920              bool    operator>=(L, R);
1921              bool    operator==(L, R);
1922              bool    operator!=(L, R);
1923      where  LR  is  the  result of the usual arithmetic conversions between
1924      types L and R.
1925
1926    14For every pair of types T and I, where T  is  a  cv-qualified  or  cv-
1927      unqualified  complete  object  type and I is a promoted integral type,
1928      there exist candidate operator functions of the form
1929              T*      operator+(T*, I);
1930              T&      operator[](T*, I);
1931              T*      operator-(T*, I);
1932              T*      operator+(I, T*);
1933              T&      operator[](I, T*);
1934
1935    15For every T, where T is a pointer to complete object type, there exist
1936      candidate operator functions of the form112)
1937              ptrdiff_t operator-(T, T);
1938
1939    16For every pointer or enumeration type T, there exist candidate operator
1940      functions of the form
1941              bool    operator<(T, T);
1942              bool    operator>(T, T);
1943              bool    operator<=(T, T);
1944              bool    operator>=(T, T);
1945              bool    operator==(T, T);
1946              bool    operator!=(T, T);
1947
1948    17For every pointer to member type T,  there  exist  candidate  operator
1949      functions of the form
1950              bool    operator==(T, T);
1951              bool    operator!=(T, T);  */
1952
1953     case MINUS_EXPR:
1954       if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1955         break;
1956       if (TYPE_PTROB_P (type1)
1957           && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
1958         {
1959           type2 = ptrdiff_type_node;
1960           break;
1961         }
1962     case MULT_EXPR:
1963     case TRUNC_DIV_EXPR:
1964       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1965         break;
1966       return;
1967
1968     case EQ_EXPR:
1969     case NE_EXPR:
1970       if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1971           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1972         break;
1973       if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1974         {
1975           type2 = type1;
1976           break;
1977         }
1978       if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1979         {
1980           type1 = type2;
1981           break;
1982         }
1983       /* Fall through.  */
1984     case LT_EXPR:
1985     case GT_EXPR:
1986     case LE_EXPR:
1987     case GE_EXPR:
1988     case MAX_EXPR:
1989     case MIN_EXPR:
1990       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1991         break;
1992       if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1993         break;
1994       if (TREE_CODE (type1) == ENUMERAL_TYPE
1995           && TREE_CODE (type2) == ENUMERAL_TYPE)
1996         break;
1997       if (TYPE_PTR_P (type1)
1998           && null_ptr_cst_p (args[1])
1999           && !uses_template_parms (type1))
2000         {
2001           type2 = type1;
2002           break;
2003         }
2004       if (null_ptr_cst_p (args[0])
2005           && TYPE_PTR_P (type2)
2006           && !uses_template_parms (type2))
2007         {
2008           type1 = type2;
2009           break;
2010         }
2011       return;
2012
2013     case PLUS_EXPR:
2014       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2015         break;
2016     case ARRAY_REF:
2017       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2018         {
2019           type1 = ptrdiff_type_node;
2020           break;
2021         }
2022       if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2023         {
2024           type2 = ptrdiff_type_node;
2025           break;
2026         }
2027       return;
2028
2029 /* 18For  every pair of promoted integral types L and R, there exist candi-
2030      date operator functions of the form
2031              LR      operator%(L, R);
2032              LR      operator&(L, R);
2033              LR      operator^(L, R);
2034              LR      operator|(L, R);
2035              L       operator<<(L, R);
2036              L       operator>>(L, R);
2037      where LR is the result of the  usual  arithmetic  conversions  between
2038      types L and R.  */
2039
2040     case TRUNC_MOD_EXPR:
2041     case BIT_AND_EXPR:
2042     case BIT_IOR_EXPR:
2043     case BIT_XOR_EXPR:
2044     case LSHIFT_EXPR:
2045     case RSHIFT_EXPR:
2046       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2047         break;
2048       return;
2049
2050 /* 19For  every  triple  L, VQ, R), where L is an arithmetic or enumeration
2051      type, VQ is either volatile or empty, and R is a  promoted  arithmetic
2052      type, there exist candidate operator functions of the form
2053              VQ L&   operator=(VQ L&, R);
2054              VQ L&   operator*=(VQ L&, R);
2055              VQ L&   operator/=(VQ L&, R);
2056              VQ L&   operator+=(VQ L&, R);
2057              VQ L&   operator-=(VQ L&, R);
2058
2059    20For  every  pair T, VQ), where T is any type and VQ is either volatile
2060      or empty, there exist candidate operator functions of the form
2061              T*VQ&   operator=(T*VQ&, T*);
2062
2063    21For every pair T, VQ), where T is a pointer to member type and  VQ  is
2064      either  volatile or empty, there exist candidate operator functions of
2065      the form
2066              VQ T&   operator=(VQ T&, T);
2067
2068    22For every triple  T,  VQ,  I),  where  T  is  a  cv-qualified  or  cv-
2069      unqualified  complete object type, VQ is either volatile or empty, and
2070      I is a promoted integral type, there exist  candidate  operator  func-
2071      tions of the form
2072              T*VQ&   operator+=(T*VQ&, I);
2073              T*VQ&   operator-=(T*VQ&, I);
2074
2075    23For  every  triple  L,  VQ,  R), where L is an integral or enumeration
2076      type, VQ is either volatile or empty, and R  is  a  promoted  integral
2077      type, there exist candidate operator functions of the form
2078
2079              VQ L&   operator%=(VQ L&, R);
2080              VQ L&   operator<<=(VQ L&, R);
2081              VQ L&   operator>>=(VQ L&, R);
2082              VQ L&   operator&=(VQ L&, R);
2083              VQ L&   operator^=(VQ L&, R);
2084              VQ L&   operator|=(VQ L&, R);  */
2085
2086     case MODIFY_EXPR:
2087       switch (code2)
2088         {
2089         case PLUS_EXPR:
2090         case MINUS_EXPR:
2091           if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2092             {
2093               type2 = ptrdiff_type_node;
2094               break;
2095             }
2096         case MULT_EXPR:
2097         case TRUNC_DIV_EXPR:
2098           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2099             break;
2100           return;
2101
2102         case TRUNC_MOD_EXPR:
2103         case BIT_AND_EXPR:
2104         case BIT_IOR_EXPR:
2105         case BIT_XOR_EXPR:
2106         case LSHIFT_EXPR:
2107         case RSHIFT_EXPR:
2108           if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2109             break;
2110           return;
2111
2112         case NOP_EXPR:
2113           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2114             break;
2115           if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2116               || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2117               || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2118               || ((TYPE_PTRMEMFUNC_P (type1)
2119                    || TREE_CODE (type1) == POINTER_TYPE)
2120                   && null_ptr_cst_p (args[1])))
2121             {
2122               type2 = type1;
2123               break;
2124             }
2125           return;
2126
2127         default:
2128           gcc_unreachable ();
2129         }
2130       type1 = build_reference_type (type1);
2131       break;
2132
2133     case COND_EXPR:
2134       /* [over.built]
2135
2136          For every pair of promoted arithmetic types L and R, there
2137          exist candidate operator functions of the form
2138
2139          LR operator?(bool, L, R);
2140
2141          where LR is the result of the usual arithmetic conversions
2142          between types L and R.
2143
2144          For every type T, where T is a pointer or pointer-to-member
2145          type, there exist candidate operator functions of the form T
2146          operator?(bool, T, T);  */
2147
2148       if (promoted_arithmetic_type_p (type1)
2149           && promoted_arithmetic_type_p (type2))
2150         /* That's OK.  */
2151         break;
2152
2153       /* Otherwise, the types should be pointers.  */
2154       if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2155           || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2156         return;
2157
2158       /* We don't check that the two types are the same; the logic
2159          below will actually create two candidates; one in which both
2160          parameter types are TYPE1, and one in which both parameter
2161          types are TYPE2.  */
2162       break;
2163
2164     default:
2165       gcc_unreachable ();
2166     }
2167
2168   /* If we're dealing with two pointer types or two enumeral types,
2169      we need candidates for both of them.  */
2170   if (type2 && !same_type_p (type1, type2)
2171       && TREE_CODE (type1) == TREE_CODE (type2)
2172       && (TREE_CODE (type1) == REFERENCE_TYPE
2173           || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2174           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2175           || TYPE_PTRMEMFUNC_P (type1)
2176           || MAYBE_CLASS_TYPE_P (type1)
2177           || TREE_CODE (type1) == ENUMERAL_TYPE))
2178     {
2179       build_builtin_candidate
2180         (candidates, fnname, type1, type1, args, argtypes, flags);
2181       build_builtin_candidate
2182         (candidates, fnname, type2, type2, args, argtypes, flags);
2183       return;
2184     }
2185
2186   build_builtin_candidate
2187     (candidates, fnname, type1, type2, args, argtypes, flags);
2188 }
2189
2190 tree
2191 type_decays_to (tree type)
2192 {
2193   if (TREE_CODE (type) == ARRAY_TYPE)
2194     return build_pointer_type (TREE_TYPE (type));
2195   if (TREE_CODE (type) == FUNCTION_TYPE)
2196     return build_pointer_type (type);
2197   return type;
2198 }
2199
2200 /* There are three conditions of builtin candidates:
2201
2202    1) bool-taking candidates.  These are the same regardless of the input.
2203    2) pointer-pair taking candidates.  These are generated for each type
2204       one of the input types converts to.
2205    3) arithmetic candidates.  According to the standard, we should generate
2206       all of these, but I'm trying not to...
2207
2208    Here we generate a superset of the possible candidates for this particular
2209    case.  That is a subset of the full set the standard defines, plus some
2210    other cases which the standard disallows. add_builtin_candidate will
2211    filter out the invalid set.  */
2212
2213 static void
2214 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2215                         enum tree_code code2, tree fnname, tree *args,
2216                         int flags)
2217 {
2218   int ref1, i;
2219   int enum_p = 0;
2220   tree type, argtypes[3];
2221   /* TYPES[i] is the set of possible builtin-operator parameter types
2222      we will consider for the Ith argument.  These are represented as
2223      a TREE_LIST; the TREE_VALUE of each node is the potential
2224      parameter type.  */
2225   tree types[2];
2226
2227   for (i = 0; i < 3; ++i)
2228     {
2229       if (args[i])
2230         argtypes[i] = unlowered_expr_type (args[i]);
2231       else
2232         argtypes[i] = NULL_TREE;
2233     }
2234
2235   switch (code)
2236     {
2237 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2238      and  VQ  is  either  volatile or empty, there exist candidate operator
2239      functions of the form
2240                  VQ T&   operator++(VQ T&);  */
2241
2242     case POSTINCREMENT_EXPR:
2243     case PREINCREMENT_EXPR:
2244     case POSTDECREMENT_EXPR:
2245     case PREDECREMENT_EXPR:
2246     case MODIFY_EXPR:
2247       ref1 = 1;
2248       break;
2249
2250 /* 24There also exist candidate operator functions of the form
2251              bool    operator!(bool);
2252              bool    operator&&(bool, bool);
2253              bool    operator||(bool, bool);  */
2254
2255     case TRUTH_NOT_EXPR:
2256       build_builtin_candidate
2257         (candidates, fnname, boolean_type_node,
2258          NULL_TREE, args, argtypes, flags);
2259       return;
2260
2261     case TRUTH_ORIF_EXPR:
2262     case TRUTH_ANDIF_EXPR:
2263       build_builtin_candidate
2264         (candidates, fnname, boolean_type_node,
2265          boolean_type_node, args, argtypes, flags);
2266       return;
2267
2268     case ADDR_EXPR:
2269     case COMPOUND_EXPR:
2270     case COMPONENT_REF:
2271       return;
2272
2273     case COND_EXPR:
2274     case EQ_EXPR:
2275     case NE_EXPR:
2276     case LT_EXPR:
2277     case LE_EXPR:
2278     case GT_EXPR:
2279     case GE_EXPR:
2280       enum_p = 1;
2281       /* Fall through.  */
2282
2283     default:
2284       ref1 = 0;
2285     }
2286
2287   types[0] = types[1] = NULL_TREE;
2288
2289   for (i = 0; i < 2; ++i)
2290     {
2291       if (! args[i])
2292         ;
2293       else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2294         {
2295           tree convs;
2296
2297           if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2298             return;
2299
2300           convs = lookup_conversions (argtypes[i]);
2301
2302           if (code == COND_EXPR)
2303             {
2304               if (real_lvalue_p (args[i]))
2305                 types[i] = tree_cons
2306                   (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2307
2308               types[i] = tree_cons
2309                 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2310             }
2311
2312           else if (! convs)
2313             return;
2314
2315           for (; convs; convs = TREE_CHAIN (convs))
2316             {
2317               type = TREE_TYPE (convs);
2318
2319               if (i == 0 && ref1
2320                   && (TREE_CODE (type) != REFERENCE_TYPE
2321                       || CP_TYPE_CONST_P (TREE_TYPE (type))))
2322                 continue;
2323
2324               if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2325                 types[i] = tree_cons (NULL_TREE, type, types[i]);
2326
2327               type = non_reference (type);
2328               if (i != 0 || ! ref1)
2329                 {
2330                   type = TYPE_MAIN_VARIANT (type_decays_to (type));
2331                   if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2332                     types[i] = tree_cons (NULL_TREE, type, types[i]);
2333                   if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2334                     type = type_promotes_to (type);
2335                 }
2336
2337               if (! value_member (type, types[i]))
2338                 types[i] = tree_cons (NULL_TREE, type, types[i]);
2339             }
2340         }
2341       else
2342         {
2343           if (code == COND_EXPR && real_lvalue_p (args[i]))
2344             types[i] = tree_cons
2345               (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2346           type = non_reference (argtypes[i]);
2347           if (i != 0 || ! ref1)
2348             {
2349               type = TYPE_MAIN_VARIANT (type_decays_to (type));
2350               if (enum_p && UNSCOPED_ENUM_P (type))
2351                 types[i] = tree_cons (NULL_TREE, type, types[i]);
2352               if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2353                 type = type_promotes_to (type);
2354             }
2355           types[i] = tree_cons (NULL_TREE, type, types[i]);
2356         }
2357     }
2358
2359   /* Run through the possible parameter types of both arguments,
2360      creating candidates with those parameter types.  */
2361   for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2362     {
2363       if (types[1])
2364         for (type = types[1]; type; type = TREE_CHAIN (type))
2365           add_builtin_candidate
2366             (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2367              TREE_VALUE (type), args, argtypes, flags);
2368       else
2369         add_builtin_candidate
2370           (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2371            NULL_TREE, args, argtypes, flags);
2372     }
2373 }
2374
2375
2376 /* If TMPL can be successfully instantiated as indicated by
2377    EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2378
2379    TMPL is the template.  EXPLICIT_TARGS are any explicit template
2380    arguments.  ARGLIST is the arguments provided at the call-site.
2381    This does not change ARGLIST.  The RETURN_TYPE is the desired type
2382    for conversion operators.  If OBJ is NULL_TREE, FLAGS and CTYPE are
2383    as for add_function_candidate.  If an OBJ is supplied, FLAGS and
2384    CTYPE are ignored, and OBJ is as for add_conv_candidate.  */
2385
2386 static struct z_candidate*
2387 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2388                              tree ctype, tree explicit_targs, tree first_arg,
2389                              const VEC(tree,gc) *arglist, tree return_type,
2390                              tree access_path, tree conversion_path,
2391                              int flags, tree obj, unification_kind_t strict)
2392 {
2393   int ntparms = DECL_NTPARMS (tmpl);
2394   tree targs = make_tree_vec (ntparms);
2395   unsigned int nargs;
2396   int skip_without_in_chrg;
2397   tree first_arg_without_in_chrg;
2398   tree *args_without_in_chrg;
2399   unsigned int nargs_without_in_chrg;
2400   unsigned int ia, ix;
2401   tree arg;
2402   struct z_candidate *cand;
2403   int i;
2404   tree fn;
2405
2406   nargs = (first_arg == NULL_TREE ? 0 : 1) + VEC_length (tree, arglist);
2407
2408   skip_without_in_chrg = 0;
2409
2410   first_arg_without_in_chrg = first_arg;
2411
2412   /* We don't do deduction on the in-charge parameter, the VTT
2413      parameter or 'this'.  */
2414   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2415     {
2416       if (first_arg_without_in_chrg != NULL_TREE)
2417         first_arg_without_in_chrg = NULL_TREE;
2418       else
2419         ++skip_without_in_chrg;
2420     }
2421
2422   if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2423        || DECL_BASE_CONSTRUCTOR_P (tmpl))
2424       && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2425     {
2426       if (first_arg_without_in_chrg != NULL_TREE)
2427         first_arg_without_in_chrg = NULL_TREE;
2428       else
2429         ++skip_without_in_chrg;
2430     }
2431
2432   nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2433                            + (VEC_length (tree, arglist)
2434                               - skip_without_in_chrg));
2435   args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2436   ia = 0;
2437   if (first_arg_without_in_chrg != NULL_TREE)
2438     {
2439       args_without_in_chrg[ia] = first_arg_without_in_chrg;
2440       ++ia;
2441     }
2442   for (ix = skip_without_in_chrg;
2443        VEC_iterate (tree, arglist, ix, arg);
2444        ++ix)
2445     {
2446       args_without_in_chrg[ia] = arg;
2447       ++ia;
2448     }
2449   gcc_assert (ia == nargs_without_in_chrg);
2450
2451   i = fn_type_unification (tmpl, explicit_targs, targs,
2452                            args_without_in_chrg,
2453                            nargs_without_in_chrg,
2454                            return_type, strict, flags);
2455
2456   if (i != 0)
2457     return NULL;
2458
2459   fn = instantiate_template (tmpl, targs, tf_none);
2460   if (fn == error_mark_node)
2461     return NULL;
2462
2463   /* In [class.copy]:
2464
2465        A member function template is never instantiated to perform the
2466        copy of a class object to an object of its class type.
2467
2468      It's a little unclear what this means; the standard explicitly
2469      does allow a template to be used to copy a class.  For example,
2470      in:
2471
2472        struct A {
2473          A(A&);
2474          template <class T> A(const T&);
2475        };
2476        const A f ();
2477        void g () { A a (f ()); }
2478
2479      the member template will be used to make the copy.  The section
2480      quoted above appears in the paragraph that forbids constructors
2481      whose only parameter is (a possibly cv-qualified variant of) the
2482      class type, and a logical interpretation is that the intent was
2483      to forbid the instantiation of member templates which would then
2484      have that form.  */
2485   if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2486     {
2487       tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2488       if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2489                                     ctype))
2490         return NULL;
2491     }
2492
2493   if (obj != NULL_TREE)
2494     /* Aha, this is a conversion function.  */
2495     cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2496                                access_path, conversion_path);
2497   else
2498     cand = add_function_candidate (candidates, fn, ctype,
2499                                    first_arg, arglist, access_path,
2500                                    conversion_path, flags);
2501   if (DECL_TI_TEMPLATE (fn) != tmpl)
2502     /* This situation can occur if a member template of a template
2503        class is specialized.  Then, instantiate_template might return
2504        an instantiation of the specialization, in which case the
2505        DECL_TI_TEMPLATE field will point at the original
2506        specialization.  For example:
2507
2508          template <class T> struct S { template <class U> void f(U);
2509                                        template <> void f(int) {}; };
2510          S<double> sd;
2511          sd.f(3);
2512
2513        Here, TMPL will be template <class U> S<double>::f(U).
2514        And, instantiate template will give us the specialization
2515        template <> S<double>::f(int).  But, the DECL_TI_TEMPLATE field
2516        for this will point at template <class T> template <> S<T>::f(int),
2517        so that we can find the definition.  For the purposes of
2518        overload resolution, however, we want the original TMPL.  */
2519     cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2520   else
2521     cand->template_decl = DECL_TEMPLATE_INFO (fn);
2522
2523   return cand;
2524 }
2525
2526
2527 static struct z_candidate *
2528 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2529                         tree explicit_targs, tree first_arg,
2530                         const VEC(tree,gc) *arglist, tree return_type,
2531                         tree access_path, tree conversion_path, int flags,
2532                         unification_kind_t strict)
2533 {
2534   return
2535     add_template_candidate_real (candidates, tmpl, ctype,
2536                                  explicit_targs, first_arg, arglist,
2537                                  return_type, access_path, conversion_path,
2538                                  flags, NULL_TREE, strict);
2539 }
2540
2541
2542 static struct z_candidate *
2543 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2544                              tree obj, tree first_arg,
2545                              const VEC(tree,gc) *arglist,
2546                              tree return_type, tree access_path,
2547                              tree conversion_path)
2548 {
2549   return
2550     add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2551                                  first_arg, arglist, return_type, access_path,
2552                                  conversion_path, 0, obj, DEDUCE_CONV);
2553 }
2554
2555 /* The CANDS are the set of candidates that were considered for
2556    overload resolution.  Return the set of viable candidates.  If none
2557    of the candidates were viable, set *ANY_VIABLE_P to true.  STRICT_P
2558    is true if a candidate should be considered viable only if it is
2559    strictly viable.  */
2560
2561 static struct z_candidate*
2562 splice_viable (struct z_candidate *cands,
2563                bool strict_p,
2564                bool *any_viable_p)
2565 {
2566   struct z_candidate *viable;
2567   struct z_candidate **last_viable;
2568   struct z_candidate **cand;
2569
2570   viable = NULL;
2571   last_viable = &viable;
2572   *any_viable_p = false;
2573
2574   cand = &cands;
2575   while (*cand)
2576     {
2577       struct z_candidate *c = *cand;
2578       if (strict_p ? c->viable == 1 : c->viable)
2579         {
2580           *last_viable = c;
2581           *cand = c->next;
2582           c->next = NULL;
2583           last_viable = &c->next;
2584           *any_viable_p = true;
2585         }
2586       else
2587         cand = &c->next;
2588     }
2589
2590   return viable ? viable : cands;
2591 }
2592
2593 static bool
2594 any_strictly_viable (struct z_candidate *cands)
2595 {
2596   for (; cands; cands = cands->next)
2597     if (cands->viable == 1)
2598       return true;
2599   return false;
2600 }
2601
2602 /* OBJ is being used in an expression like "OBJ.f (...)".  In other
2603    words, it is about to become the "this" pointer for a member
2604    function call.  Take the address of the object.  */
2605
2606 static tree
2607 build_this (tree obj)
2608 {
2609   /* In a template, we are only concerned about the type of the
2610      expression, so we can take a shortcut.  */
2611   if (processing_template_decl)
2612     return build_address (obj);
2613
2614   return cp_build_unary_op (ADDR_EXPR, obj, 0, tf_warning_or_error);
2615 }
2616
2617 /* Returns true iff functions are equivalent. Equivalent functions are
2618    not '==' only if one is a function-local extern function or if
2619    both are extern "C".  */
2620
2621 static inline int
2622 equal_functions (tree fn1, tree fn2)
2623 {
2624   if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2625       || DECL_EXTERN_C_FUNCTION_P (fn1))
2626     return decls_match (fn1, fn2);
2627   return fn1 == fn2;
2628 }
2629
2630 /* Print information about one overload candidate CANDIDATE.  MSGSTR
2631    is the text to print before the candidate itself.
2632
2633    NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2634    to have been run through gettext by the caller.  This wart makes
2635    life simpler in print_z_candidates and for the translators.  */
2636
2637 static void
2638 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2639 {
2640   if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2641     {
2642       if (candidate->num_convs == 3)
2643         inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2644                 candidate->convs[0]->type,
2645                 candidate->convs[1]->type,
2646                 candidate->convs[2]->type);
2647       else if (candidate->num_convs == 2)
2648         inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2649                 candidate->convs[0]->type,
2650                 candidate->convs[1]->type);
2651       else
2652         inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2653                 candidate->convs[0]->type);
2654     }
2655   else if (TYPE_P (candidate->fn))
2656     inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2657   else if (candidate->viable == -1)
2658     inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2659   else
2660     inform (input_location, "%s %+#D", msgstr, candidate->fn);
2661 }
2662
2663 static void
2664 print_z_candidates (struct z_candidate *candidates)
2665 {
2666   const char *str;
2667   struct z_candidate *cand1;
2668   struct z_candidate **cand2;
2669
2670   /* There may be duplicates in the set of candidates.  We put off
2671      checking this condition as long as possible, since we have no way
2672      to eliminate duplicates from a set of functions in less than n^2
2673      time.  Now we are about to emit an error message, so it is more
2674      permissible to go slowly.  */
2675   for (cand1 = candidates; cand1; cand1 = cand1->next)
2676     {
2677       tree fn = cand1->fn;
2678       /* Skip builtin candidates and conversion functions.  */
2679       if (TREE_CODE (fn) != FUNCTION_DECL)
2680         continue;
2681       cand2 = &cand1->next;
2682       while (*cand2)
2683         {
2684           if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2685               && equal_functions (fn, (*cand2)->fn))
2686             *cand2 = (*cand2)->next;
2687           else
2688             cand2 = &(*cand2)->next;
2689         }
2690     }
2691
2692   if (!candidates)
2693     return;
2694
2695   str = _("candidates are:");
2696   print_z_candidate (str, candidates);
2697   if (candidates->next)
2698     {
2699       /* Indent successive candidates by the width of the translation
2700          of the above string.  */
2701       size_t len = gcc_gettext_width (str) + 1;
2702       char *spaces = (char *) alloca (len);
2703       memset (spaces, ' ', len-1);
2704       spaces[len - 1] = '\0';
2705
2706       candidates = candidates->next;
2707       do
2708         {
2709           print_z_candidate (spaces, candidates);
2710           candidates = candidates->next;
2711         }
2712       while (candidates);
2713     }
2714 }
2715
2716 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2717    USER_CONV.  STD_SEQ is the standard conversion sequence applied to
2718    the result of the conversion function to convert it to the final
2719    desired type.  Merge the two sequences into a single sequence,
2720    and return the merged sequence.  */
2721
2722 static conversion *
2723 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2724 {
2725   conversion **t;
2726
2727   gcc_assert (user_seq->kind == ck_user);
2728
2729   /* Find the end of the second conversion sequence.  */
2730   t = &(std_seq);
2731   while ((*t)->kind != ck_identity)
2732     t = &((*t)->u.next);
2733
2734   /* Replace the identity conversion with the user conversion
2735      sequence.  */
2736   *t = user_seq;
2737
2738   /* The entire sequence is a user-conversion sequence.  */
2739   std_seq->user_conv_p = true;
2740
2741   return std_seq;
2742 }
2743
2744 /* Returns the best overload candidate to perform the requested
2745    conversion.  This function is used for three the overloading situations
2746    described in [over.match.copy], [over.match.conv], and [over.match.ref].
2747    If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2748    per [dcl.init.ref], so we ignore temporary bindings.  */
2749
2750 static struct z_candidate *
2751 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2752 {
2753   struct z_candidate *candidates, *cand;
2754   tree fromtype = TREE_TYPE (expr);
2755   tree ctors = NULL_TREE;
2756   tree conv_fns = NULL_TREE;
2757   conversion *conv = NULL;
2758   tree first_arg = NULL_TREE;
2759   VEC(tree,gc) *args = NULL;
2760   bool any_viable_p;
2761   int convflags;
2762
2763   /* We represent conversion within a hierarchy using RVALUE_CONV and
2764      BASE_CONV, as specified by [over.best.ics]; these become plain
2765      constructor calls, as specified in [dcl.init].  */
2766   gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
2767               || !DERIVED_FROM_P (totype, fromtype));
2768
2769   if (MAYBE_CLASS_TYPE_P (totype))
2770     ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2771
2772   if (MAYBE_CLASS_TYPE_P (fromtype))
2773     {
2774       tree to_nonref = non_reference (totype);
2775       if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
2776           (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
2777            && DERIVED_FROM_P (to_nonref, fromtype)))
2778         {
2779           /* [class.conv.fct] A conversion function is never used to
2780              convert a (possibly cv-qualified) object to the (possibly
2781              cv-qualified) same object type (or a reference to it), to a
2782              (possibly cv-qualified) base class of that type (or a
2783              reference to it)...  */
2784         }
2785       else
2786         conv_fns = lookup_conversions (fromtype);
2787     }
2788
2789   candidates = 0;
2790   flags |= LOOKUP_NO_CONVERSION;
2791
2792   /* It's OK to bind a temporary for converting constructor arguments, but
2793      not in converting the return value of a conversion operator.  */
2794   convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
2795   flags &= ~LOOKUP_NO_TEMP_BIND;
2796
2797   if (ctors)
2798     {
2799       ctors = BASELINK_FUNCTIONS (ctors);
2800
2801       first_arg = build_int_cst (build_pointer_type (totype), 0);
2802       if (BRACE_ENCLOSED_INITIALIZER_P (expr)
2803           && !TYPE_HAS_LIST_CTOR (totype))
2804         {
2805           args = ctor_to_vec (expr);
2806           /* We still allow more conversions within an init-list.  */
2807           flags = ((flags & ~LOOKUP_NO_CONVERSION)
2808                    /* But not for the copy ctor.  */
2809                    |LOOKUP_NO_COPY_CTOR_CONVERSION
2810                    |LOOKUP_NO_NARROWING);
2811         }
2812       else
2813         args = make_tree_vector_single (expr);
2814
2815       /* We should never try to call the abstract or base constructor
2816          from here.  */
2817       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2818                   && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2819     }
2820   for (; ctors; ctors = OVL_NEXT (ctors))
2821     {
2822       tree ctor = OVL_CURRENT (ctors);
2823       if (DECL_NONCONVERTING_P (ctor)
2824           && !BRACE_ENCLOSED_INITIALIZER_P (expr))
2825         continue;
2826
2827       if (TREE_CODE (ctor) == TEMPLATE_DECL)
2828         cand = add_template_candidate (&candidates, ctor, totype,
2829                                        NULL_TREE, first_arg, args, NULL_TREE,
2830                                        TYPE_BINFO (totype),
2831                                        TYPE_BINFO (totype),
2832                                        flags,
2833                                        DEDUCE_CALL);
2834       else
2835         cand = add_function_candidate (&candidates, ctor, totype,
2836                                        first_arg, args, TYPE_BINFO (totype),
2837                                        TYPE_BINFO (totype),
2838                                        flags);
2839
2840       if (cand)
2841         {
2842           cand->second_conv = build_identity_conv (totype, NULL_TREE);
2843
2844           /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
2845              set, then this is copy-initialization.  In that case, "The
2846              result of the call is then used to direct-initialize the
2847              object that is the destination of the copy-initialization."
2848              [dcl.init]
2849
2850              We represent this in the conversion sequence with an
2851              rvalue conversion, which means a constructor call.  */
2852           if (TREE_CODE (totype) != REFERENCE_TYPE
2853               && !(convflags & LOOKUP_NO_TEMP_BIND))
2854             cand->second_conv
2855               = build_conv (ck_rvalue, totype, cand->second_conv);
2856         }
2857     }
2858
2859   if (conv_fns)
2860     first_arg = build_this (expr);
2861
2862   for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2863     {
2864       tree fns;
2865       tree conversion_path = TREE_PURPOSE (conv_fns);
2866
2867       /* If we are called to convert to a reference type, we are trying to
2868          find an lvalue binding, so don't even consider temporaries.  If
2869          we don't find an lvalue binding, the caller will try again to
2870          look for a temporary binding.  */
2871       if (TREE_CODE (totype) == REFERENCE_TYPE)
2872         convflags |= LOOKUP_NO_TEMP_BIND;
2873
2874       for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2875         {
2876           tree fn = OVL_CURRENT (fns);
2877
2878           if (DECL_NONCONVERTING_P (fn)
2879               && (flags & LOOKUP_ONLYCONVERTING))
2880             continue;
2881
2882           /* [over.match.funcs] For conversion functions, the function
2883              is considered to be a member of the class of the implicit
2884              object argument for the purpose of defining the type of
2885              the implicit object parameter.
2886
2887              So we pass fromtype as CTYPE to add_*_candidate.  */
2888
2889           if (TREE_CODE (fn) == TEMPLATE_DECL)
2890             cand = add_template_candidate (&candidates, fn, fromtype,
2891                                            NULL_TREE,
2892                                            first_arg, NULL, totype,
2893                                            TYPE_BINFO (fromtype),
2894                                            conversion_path,
2895                                            flags,
2896                                            DEDUCE_CONV);
2897           else
2898             cand = add_function_candidate (&candidates, fn, fromtype,
2899                                            first_arg, NULL,
2900                                            TYPE_BINFO (fromtype),
2901                                            conversion_path,
2902                                            flags);
2903
2904           if (cand)
2905             {
2906               conversion *ics
2907                 = implicit_conversion (totype,
2908                                        TREE_TYPE (TREE_TYPE (cand->fn)),
2909                                        0,
2910                                        /*c_cast_p=*/false, convflags);
2911
2912               /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
2913                  copy-initialization.  In that case, "The result of the
2914                  call is then used to direct-initialize the object that is
2915                  the destination of the copy-initialization."  [dcl.init]
2916
2917                  We represent this in the conversion sequence with an
2918                  rvalue conversion, which means a constructor call.  But
2919                  don't add a second rvalue conversion if there's already
2920                  one there.  Which there really shouldn't be, but it's
2921                  harmless since we'd add it here anyway. */
2922               if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
2923                   && !(convflags & LOOKUP_NO_TEMP_BIND))
2924                 ics = build_conv (ck_rvalue, totype, ics);
2925
2926               cand->second_conv = ics;
2927
2928               if (!ics)
2929                 cand->viable = 0;
2930               else if (candidates->viable == 1 && ics->bad_p)
2931                 cand->viable = -1;
2932             }
2933         }
2934     }
2935
2936   candidates = splice_viable (candidates, pedantic, &any_viable_p);
2937   if (!any_viable_p)
2938     return NULL;
2939
2940   cand = tourney (candidates);
2941   if (cand == 0)
2942     {
2943       if (flags & LOOKUP_COMPLAIN)
2944         {
2945           error ("conversion from %qT to %qT is ambiguous",
2946                     fromtype, totype);
2947           print_z_candidates (candidates);
2948         }
2949
2950       cand = candidates;        /* any one will do */
2951       cand->second_conv = build_ambiguous_conv (totype, expr);
2952       cand->second_conv->user_conv_p = true;
2953       if (!any_strictly_viable (candidates))
2954         cand->second_conv->bad_p = true;
2955       /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2956          ambiguous conversion is no worse than another user-defined
2957          conversion.  */
2958
2959       return cand;
2960     }
2961
2962   /* Build the user conversion sequence.  */
2963   conv = build_conv
2964     (ck_user,
2965      (DECL_CONSTRUCTOR_P (cand->fn)
2966       ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2967      build_identity_conv (TREE_TYPE (expr), expr));
2968   conv->cand = cand;
2969
2970   /* Remember that this was a list-initialization.  */
2971   if (flags & LOOKUP_NO_NARROWING)
2972     conv->check_narrowing = true;
2973
2974   /* Combine it with the second conversion sequence.  */
2975   cand->second_conv = merge_conversion_sequences (conv,
2976                                                   cand->second_conv);
2977
2978   if (cand->viable == -1)
2979     cand->second_conv->bad_p = true;
2980
2981   return cand;
2982 }
2983
2984 tree
2985 build_user_type_conversion (tree totype, tree expr, int flags)
2986 {
2987   struct z_candidate *cand
2988     = build_user_type_conversion_1 (totype, expr, flags);
2989
2990   if (cand)
2991     {
2992       if (cand->second_conv->kind == ck_ambig)
2993         return error_mark_node;
2994       expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
2995       return convert_from_reference (expr);
2996     }
2997   return NULL_TREE;
2998 }
2999
3000 /* Do any initial processing on the arguments to a function call.  */
3001
3002 static VEC(tree,gc) *
3003 resolve_args (VEC(tree,gc) *args)
3004 {
3005   unsigned int ix;
3006   tree arg;
3007
3008   for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
3009     {
3010       if (error_operand_p (arg))
3011         return NULL;
3012       else if (VOID_TYPE_P (TREE_TYPE (arg)))
3013         {
3014           error ("invalid use of void expression");
3015           return NULL;
3016         }
3017       else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3018         return NULL;
3019     }
3020   return args;
3021 }
3022
3023 /* Perform overload resolution on FN, which is called with the ARGS.
3024
3025    Return the candidate function selected by overload resolution, or
3026    NULL if the event that overload resolution failed.  In the case
3027    that overload resolution fails, *CANDIDATES will be the set of
3028    candidates considered, and ANY_VIABLE_P will be set to true or
3029    false to indicate whether or not any of the candidates were
3030    viable.
3031
3032    The ARGS should already have gone through RESOLVE_ARGS before this
3033    function is called.  */
3034
3035 static struct z_candidate *
3036 perform_overload_resolution (tree fn,
3037                              const VEC(tree,gc) *args,
3038                              struct z_candidate **candidates,
3039                              bool *any_viable_p)
3040 {
3041   struct z_candidate *cand;
3042   tree explicit_targs = NULL_TREE;
3043   int template_only = 0;
3044
3045   *candidates = NULL;
3046   *any_viable_p = true;
3047
3048   /* Check FN.  */
3049   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3050               || TREE_CODE (fn) == TEMPLATE_DECL
3051               || TREE_CODE (fn) == OVERLOAD
3052               || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3053
3054   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3055     {
3056       explicit_targs = TREE_OPERAND (fn, 1);
3057       fn = TREE_OPERAND (fn, 0);
3058       template_only = 1;
3059     }
3060
3061   /* Add the various candidate functions.  */
3062   add_candidates (fn, args, explicit_targs, template_only,
3063                   /*conversion_path=*/NULL_TREE,
3064                   /*access_path=*/NULL_TREE,
3065                   LOOKUP_NORMAL,
3066                   candidates);
3067
3068   *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3069   if (!*any_viable_p)
3070     return NULL;
3071
3072   cand = tourney (*candidates);
3073   return cand;
3074 }
3075
3076 /* Return an expression for a call to FN (a namespace-scope function,
3077    or a static member function) with the ARGS.  This may change
3078    ARGS.  */
3079
3080 tree
3081 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3082                          tsubst_flags_t complain)
3083 {
3084   struct z_candidate *candidates, *cand;
3085   bool any_viable_p;
3086   void *p;
3087   tree result;
3088
3089   if (args != NULL && *args != NULL)
3090     {
3091       *args = resolve_args (*args);
3092       if (*args == NULL)
3093         return error_mark_node;
3094     }
3095
3096   /* If this function was found without using argument dependent
3097      lookup, then we want to ignore any undeclared friend
3098      functions.  */
3099   if (!koenig_p)
3100     {
3101       tree orig_fn = fn;
3102
3103       fn = remove_hidden_names (fn);
3104       if (!fn)
3105         {
3106           if (complain & tf_error)
3107             error ("no matching function for call to %<%D(%A)%>",
3108                    DECL_NAME (OVL_CURRENT (orig_fn)),
3109                    build_tree_list_vec (*args));
3110           return error_mark_node;
3111         }
3112     }
3113
3114   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3115   p = conversion_obstack_alloc (0);
3116
3117   cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3118
3119   if (!cand)
3120     {
3121       if (complain & tf_error)
3122         {
3123           if (!any_viable_p && candidates && ! candidates->next)
3124             return cp_build_function_call_vec (candidates->fn, args, complain);
3125           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3126             fn = TREE_OPERAND (fn, 0);
3127           if (!any_viable_p)
3128             error ("no matching function for call to %<%D(%A)%>",
3129                    DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3130           else
3131             error ("call of overloaded %<%D(%A)%> is ambiguous",
3132                    DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3133           if (candidates)
3134             print_z_candidates (candidates);
3135         }
3136       result = error_mark_node;
3137     }
3138   else
3139     result = build_over_call (cand, LOOKUP_NORMAL, complain);
3140
3141   /* Free all the conversions we allocated.  */
3142   obstack_free (&conversion_obstack, p);
3143
3144   return result;
3145 }
3146
3147 /* Build a call to a global operator new.  FNNAME is the name of the
3148    operator (either "operator new" or "operator new[]") and ARGS are
3149    the arguments provided.  This may change ARGS.  *SIZE points to the
3150    total number of bytes required by the allocation, and is updated if
3151    that is changed here.  *COOKIE_SIZE is non-NULL if a cookie should
3152    be used.  If this function determines that no cookie should be
3153    used, after all, *COOKIE_SIZE is set to NULL_TREE.  If FN is
3154    non-NULL, it will be set, upon return, to the allocation function
3155    called.  */
3156
3157 tree
3158 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3159                          tree *size, tree *cookie_size,
3160                          tree *fn)
3161 {
3162   tree fns;
3163   struct z_candidate *candidates;
3164   struct z_candidate *cand;
3165   bool any_viable_p;
3166
3167   if (fn)
3168     *fn = NULL_TREE;
3169   VEC_safe_insert (tree, gc, *args, 0, *size);
3170   *args = resolve_args (*args);
3171   if (*args == NULL)
3172     return error_mark_node;
3173
3174   /* Based on:
3175
3176        [expr.new]
3177
3178        If this lookup fails to find the name, or if the allocated type
3179        is not a class type, the allocation function's name is looked
3180        up in the global scope.
3181
3182      we disregard block-scope declarations of "operator new".  */
3183   fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3184
3185   /* Figure out what function is being called.  */
3186   cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3187
3188   /* If no suitable function could be found, issue an error message
3189      and give up.  */
3190   if (!cand)
3191     {
3192       if (!any_viable_p)
3193         error ("no matching function for call to %<%D(%A)%>",
3194                DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3195       else
3196         error ("call of overloaded %<%D(%A)%> is ambiguous",
3197                DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3198       if (candidates)
3199         print_z_candidates (candidates);
3200       return error_mark_node;
3201     }
3202
3203    /* If a cookie is required, add some extra space.  Whether
3204       or not a cookie is required cannot be determined until
3205       after we know which function was called.  */
3206    if (*cookie_size)
3207      {
3208        bool use_cookie = true;
3209        if (!abi_version_at_least (2))
3210          {
3211            /* In G++ 3.2, the check was implemented incorrectly; it
3212               looked at the placement expression, rather than the
3213               type of the function.  */
3214            if (VEC_length (tree, *args) == 2
3215                && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3216                                ptr_type_node))
3217              use_cookie = false;
3218          }
3219        else
3220          {
3221            tree arg_types;
3222
3223            arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3224            /* Skip the size_t parameter.  */
3225            arg_types = TREE_CHAIN (arg_types);
3226            /* Check the remaining parameters (if any).  */
3227            if (arg_types
3228                && TREE_CHAIN (arg_types) == void_list_node
3229                && same_type_p (TREE_VALUE (arg_types),
3230                                ptr_type_node))
3231              use_cookie = false;
3232          }
3233        /* If we need a cookie, adjust the number of bytes allocated.  */
3234        if (use_cookie)
3235          {
3236            /* Update the total size.  */
3237            *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3238            /* Update the argument list to reflect the adjusted size.  */
3239            VEC_replace (tree, *args, 0, *size);
3240          }
3241        else
3242          *cookie_size = NULL_TREE;
3243      }
3244
3245    /* Tell our caller which function we decided to call.  */
3246    if (fn)
3247      *fn = cand->fn;
3248
3249    /* Build the CALL_EXPR.  */
3250    return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3251 }
3252
3253 /* Build a new call to operator().  This may change ARGS.  */
3254
3255 tree
3256 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3257 {
3258   struct z_candidate *candidates = 0, *cand;
3259   tree fns, convs, first_mem_arg = NULL_TREE;
3260   tree type = TREE_TYPE (obj);
3261   bool any_viable_p;
3262   tree result = NULL_TREE;
3263   void *p;
3264
3265   if (error_operand_p (obj))
3266     return error_mark_node;
3267
3268   obj = prep_operand (obj);
3269
3270   if (TYPE_PTRMEMFUNC_P (type))
3271     {
3272       if (complain & tf_error)
3273         /* It's no good looking for an overloaded operator() on a
3274            pointer-to-member-function.  */
3275         error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
3276       return error_mark_node;
3277     }
3278
3279   if (TYPE_BINFO (type))
3280     {
3281       fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
3282       if (fns == error_mark_node)
3283         return error_mark_node;
3284     }
3285   else
3286     fns = NULL_TREE;
3287
3288   if (args != NULL && *args != NULL)
3289     {
3290       *args = resolve_args (*args);
3291       if (*args == NULL)
3292         return error_mark_node;
3293     }
3294
3295   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3296   p = conversion_obstack_alloc (0);
3297
3298   if (fns)
3299     {
3300       tree base = BINFO_TYPE (BASELINK_BINFO (fns));
3301       first_mem_arg = build_this (obj);
3302
3303       for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
3304         {
3305           tree fn = OVL_CURRENT (fns);
3306           if (TREE_CODE (fn) == TEMPLATE_DECL)
3307             add_template_candidate (&candidates, fn, base, NULL_TREE,
3308                                     first_mem_arg, *args, NULL_TREE,
3309                                     TYPE_BINFO (type),
3310                                     TYPE_BINFO (type),
3311                                     LOOKUP_NORMAL, DEDUCE_CALL);
3312           else
3313             add_function_candidate
3314               (&candidates, fn, base, first_mem_arg, *args, TYPE_BINFO (type),
3315                TYPE_BINFO (type), LOOKUP_NORMAL);
3316         }
3317     }
3318
3319   convs = lookup_conversions (type);
3320
3321   for (; convs; convs = TREE_CHAIN (convs))
3322     {
3323       tree fns = TREE_VALUE (convs);
3324       tree totype = TREE_TYPE (convs);
3325
3326       if ((TREE_CODE (totype) == POINTER_TYPE
3327            && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3328           || (TREE_CODE (totype) == REFERENCE_TYPE
3329               && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3330           || (TREE_CODE (totype) == REFERENCE_TYPE
3331               && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3332               && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3333         for (; fns; fns = OVL_NEXT (fns))
3334           {
3335             tree fn = OVL_CURRENT (fns);
3336
3337             if (DECL_NONCONVERTING_P (fn))
3338               continue;
3339
3340             if (TREE_CODE (fn) == TEMPLATE_DECL)
3341               add_template_conv_candidate
3342                 (&candidates, fn, obj, NULL_TREE, *args, totype,
3343                  /*access_path=*/NULL_TREE,
3344                  /*conversion_path=*/NULL_TREE);
3345             else
3346               add_conv_candidate (&candidates, fn, obj, NULL_TREE,
3347                                   *args, /*conversion_path=*/NULL_TREE,
3348                                   /*access_path=*/NULL_TREE);
3349           }
3350     }
3351
3352   candidates = splice_viable (candidates, pedantic, &any_viable_p);
3353   if (!any_viable_p)
3354     {
3355       if (complain & tf_error)
3356         {
3357           error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj),
3358                  build_tree_list_vec (*args));
3359           print_z_candidates (candidates);
3360         }
3361       result = error_mark_node;
3362     }
3363   else
3364     {
3365       cand = tourney (candidates);
3366       if (cand == 0)
3367         {
3368           if (complain & tf_error)
3369             {
3370               error ("call of %<(%T) (%A)%> is ambiguous",
3371                      TREE_TYPE (obj), build_tree_list_vec (*args));
3372               print_z_candidates (candidates);
3373             }
3374           result = error_mark_node;
3375         }
3376       /* Since cand->fn will be a type, not a function, for a conversion
3377          function, we must be careful not to unconditionally look at
3378          DECL_NAME here.  */
3379       else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3380                && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3381         result = build_over_call (cand, LOOKUP_NORMAL, complain);
3382       else
3383         {
3384           obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
3385                                            complain);
3386           obj = convert_from_reference (obj);
3387           result = cp_build_function_call_vec (obj, args, complain);
3388         }
3389     }
3390
3391   /* Free all the conversions we allocated.  */
3392   obstack_free (&conversion_obstack, p);
3393
3394   return result;
3395 }
3396
3397 static void
3398 op_error (enum tree_code code, enum tree_code code2,
3399           tree arg1, tree arg2, tree arg3, const char *problem)
3400 {
3401   const char *opname;
3402
3403   if (code == MODIFY_EXPR)
3404     opname = assignment_operator_name_info[code2].name;
3405   else
3406     opname = operator_name_info[code].name;
3407
3408   switch (code)
3409     {
3410     case COND_EXPR:
3411       error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3412              problem, arg1, arg2, arg3);
3413       break;
3414
3415     case POSTINCREMENT_EXPR:
3416     case POSTDECREMENT_EXPR:
3417       error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3418       break;
3419
3420     case ARRAY_REF:
3421       error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3422       break;
3423
3424     case REALPART_EXPR:
3425     case IMAGPART_EXPR:
3426       error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3427       break;
3428
3429     default:
3430       if (arg2)
3431         error ("%s for %<operator%s%> in %<%E %s %E%>",
3432                problem, opname, arg1, opname, arg2);
3433       else
3434         error ("%s for %<operator%s%> in %<%s%E%>",
3435                problem, opname, opname, arg1);
3436       break;
3437     }
3438 }
3439
3440 /* Return the implicit conversion sequence that could be used to
3441    convert E1 to E2 in [expr.cond].  */
3442
3443 static conversion *
3444 conditional_conversion (tree e1, tree e2)
3445 {
3446   tree t1 = non_reference (TREE_TYPE (e1));
3447   tree t2 = non_reference (TREE_TYPE (e2));
3448   conversion *conv;
3449   bool good_base;
3450
3451   /* [expr.cond]
3452
3453      If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3454      implicitly converted (clause _conv_) to the type "reference to
3455      T2", subject to the constraint that in the conversion the
3456      reference must bind directly (_dcl.init.ref_) to E1.  */
3457   if (real_lvalue_p (e2))
3458     {
3459       conv = implicit_conversion (build_reference_type (t2),
3460                                   t1,
3461                                   e1,
3462                                   /*c_cast_p=*/false,
3463                                   LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING);
3464       if (conv)
3465         return conv;
3466     }
3467
3468   /* [expr.cond]
3469
3470      If E1 and E2 have class type, and the underlying class types are
3471      the same or one is a base class of the other: E1 can be converted
3472      to match E2 if the class of T2 is the same type as, or a base
3473      class of, the class of T1, and the cv-qualification of T2 is the
3474      same cv-qualification as, or a greater cv-qualification than, the
3475      cv-qualification of T1.  If the conversion is applied, E1 is
3476      changed to an rvalue of type T2 that still refers to the original
3477      source class object (or the appropriate subobject thereof).  */
3478   if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3479       && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3480     {
3481       if (good_base && at_least_as_qualified_p (t2, t1))
3482         {
3483           conv = build_identity_conv (t1, e1);
3484           if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3485                             TYPE_MAIN_VARIANT (t2)))
3486             conv = build_conv (ck_base, t2, conv);
3487           else
3488             conv = build_conv (ck_rvalue, t2, conv);
3489           return conv;
3490         }
3491       else
3492         return NULL;
3493     }
3494   else
3495     /* [expr.cond]
3496
3497        Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3498        converted to the type that expression E2 would have if E2 were
3499        converted to an rvalue (or the type it has, if E2 is an rvalue).  */
3500     return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3501                                 LOOKUP_IMPLICIT);
3502 }
3503
3504 /* Implement [expr.cond].  ARG1, ARG2, and ARG3 are the three
3505    arguments to the conditional expression.  */
3506
3507 tree
3508 build_conditional_expr (tree arg1, tree arg2, tree arg3,
3509                         tsubst_flags_t complain)
3510 {
3511   tree arg2_type;
3512   tree arg3_type;
3513   tree result = NULL_TREE;
3514   tree result_type = NULL_TREE;
3515   bool lvalue_p = true;
3516   struct z_candidate *candidates = 0;
3517   struct z_candidate *cand;
3518   void *p;
3519
3520   /* As a G++ extension, the second argument to the conditional can be
3521      omitted.  (So that `a ? : c' is roughly equivalent to `a ? a :
3522      c'.)  If the second operand is omitted, make sure it is
3523      calculated only once.  */
3524   if (!arg2)
3525     {
3526       if (complain & tf_error)
3527         pedwarn (input_location, OPT_pedantic,
3528                  "ISO C++ forbids omitting the middle term of a ?: expression");
3529
3530       /* Make sure that lvalues remain lvalues.  See g++.oliva/ext1.C.  */
3531       if (real_lvalue_p (arg1))
3532         arg2 = arg1 = stabilize_reference (arg1);
3533       else
3534         arg2 = arg1 = save_expr (arg1);
3535     }
3536
3537   /* [expr.cond]
3538
3539      The first expression is implicitly converted to bool (clause
3540      _conv_).  */
3541   arg1 = perform_implicit_conversion (boolean_type_node, arg1, complain);
3542
3543   /* If something has already gone wrong, just pass that fact up the
3544      tree.  */
3545   if (error_operand_p (arg1)
3546       || error_operand_p (arg2)
3547       || error_operand_p (arg3))
3548     return error_mark_node;
3549
3550   /* [expr.cond]
3551
3552      If either the second or the third operand has type (possibly
3553      cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3554      array-to-pointer (_conv.array_), and function-to-pointer
3555      (_conv.func_) standard conversions are performed on the second
3556      and third operands.  */
3557   arg2_type = unlowered_expr_type (arg2);
3558   arg3_type = unlowered_expr_type (arg3);
3559   if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3560     {
3561       /* Do the conversions.  We don't these for `void' type arguments
3562          since it can't have any effect and since decay_conversion
3563          does not handle that case gracefully.  */
3564       if (!VOID_TYPE_P (arg2_type))
3565         arg2 = decay_conversion (arg2);
3566       if (!VOID_TYPE_P (arg3_type))
3567         arg3 = decay_conversion (arg3);
3568       arg2_type = TREE_TYPE (arg2);
3569       arg3_type = TREE_TYPE (arg3);
3570
3571       /* [expr.cond]
3572
3573          One of the following shall hold:
3574
3575          --The second or the third operand (but not both) is a
3576            throw-expression (_except.throw_); the result is of the
3577            type of the other and is an rvalue.
3578
3579          --Both the second and the third operands have type void; the
3580            result is of type void and is an rvalue.
3581
3582          We must avoid calling force_rvalue for expressions of type
3583          "void" because it will complain that their value is being
3584          used.  */
3585       if (TREE_CODE (arg2) == THROW_EXPR
3586           && TREE_CODE (arg3) != THROW_EXPR)
3587         {
3588           if (!VOID_TYPE_P (arg3_type))
3589             arg3 = force_rvalue (arg3);
3590           arg3_type = TREE_TYPE (arg3);
3591           result_type = arg3_type;
3592         }
3593       else if (TREE_CODE (arg2) != THROW_EXPR
3594                && TREE_CODE (arg3) == THROW_EXPR)
3595         {
3596           if (!VOID_TYPE_P (arg2_type))
3597             arg2 = force_rvalue (arg2);
3598           arg2_type = TREE_TYPE (arg2);
3599           result_type = arg2_type;
3600         }
3601       else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3602         result_type = void_type_node;
3603       else
3604         {
3605           if (complain & tf_error)
3606             {
3607               if (VOID_TYPE_P (arg2_type))
3608                 error ("second operand to the conditional operator "
3609                        "is of type %<void%>, "
3610                        "but the third operand is neither a throw-expression "
3611                        "nor of type %<void%>");
3612               else
3613                 error ("third operand to the conditional operator "
3614                        "is of type %<void%>, "
3615                        "but the second operand is neither a throw-expression "
3616                        "nor of type %<void%>");
3617             }
3618           return error_mark_node;
3619         }
3620
3621       lvalue_p = false;
3622       goto valid_operands;
3623     }
3624   /* [expr.cond]
3625
3626      Otherwise, if the second and third operand have different types,
3627      and either has (possibly cv-qualified) class type, an attempt is
3628      made to convert each of those operands to the type of the other.  */
3629   else if (!same_type_p (arg2_type, arg3_type)
3630            && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3631     {
3632       conversion *conv2;
3633       conversion *conv3;
3634
3635       /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3636       p = conversion_obstack_alloc (0);
3637
3638       conv2 = conditional_conversion (arg2, arg3);
3639       conv3 = conditional_conversion (arg3, arg2);
3640
3641       /* [expr.cond]
3642
3643          If both can be converted, or one can be converted but the
3644          conversion is ambiguous, the program is ill-formed.  If
3645          neither can be converted, the operands are left unchanged and
3646          further checking is performed as described below.  If exactly
3647          one conversion is possible, that conversion is applied to the
3648          chosen operand and the converted operand is used in place of
3649          the original operand for the remainder of this section.  */
3650       if ((conv2 && !conv2->bad_p
3651            && conv3 && !conv3->bad_p)
3652           || (conv2 && conv2->kind == ck_ambig)
3653           || (conv3 && conv3->kind == ck_ambig))
3654         {
3655           error ("operands to ?: have different types %qT and %qT",
3656                  arg2_type, arg3_type);
3657           result = error_mark_node;
3658         }
3659       else if (conv2 && (!conv2->bad_p || !conv3))
3660         {
3661           arg2 = convert_like (conv2, arg2, complain);
3662           arg2 = convert_from_reference (arg2);
3663           arg2_type = TREE_TYPE (arg2);
3664           /* Even if CONV2 is a valid conversion, the result of the
3665              conversion may be invalid.  For example, if ARG3 has type
3666              "volatile X", and X does not have a copy constructor
3667              accepting a "volatile X&", then even if ARG2 can be
3668              converted to X, the conversion will fail.  */
3669           if (error_operand_p (arg2))
3670             result = error_mark_node;
3671         }
3672       else if (conv3 && (!conv3->bad_p || !conv2))
3673         {
3674           arg3 = convert_like (conv3, arg3, complain);
3675           arg3 = convert_from_reference (arg3);
3676           arg3_type = TREE_TYPE (arg3);
3677           if (error_operand_p (arg3))
3678             result = error_mark_node;
3679         }
3680
3681       /* Free all the conversions we allocated.  */
3682       obstack_free (&conversion_obstack, p);
3683
3684       if (result)
3685         return result;
3686
3687       /* If, after the conversion, both operands have class type,
3688          treat the cv-qualification of both operands as if it were the
3689          union of the cv-qualification of the operands.
3690
3691          The standard is not clear about what to do in this
3692          circumstance.  For example, if the first operand has type
3693          "const X" and the second operand has a user-defined
3694          conversion to "volatile X", what is the type of the second
3695          operand after this step?  Making it be "const X" (matching
3696          the first operand) seems wrong, as that discards the
3697          qualification without actually performing a copy.  Leaving it
3698          as "volatile X" seems wrong as that will result in the
3699          conditional expression failing altogether, even though,
3700          according to this step, the one operand could be converted to
3701          the type of the other.  */
3702       if ((conv2 || conv3)
3703           && CLASS_TYPE_P (arg2_type)
3704           && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3705         arg2_type = arg3_type =
3706           cp_build_qualified_type (arg2_type,
3707                                    TYPE_QUALS (arg2_type)
3708                                    | TYPE_QUALS (arg3_type));
3709     }
3710
3711   /* [expr.cond]
3712
3713      If the second and third operands are lvalues and have the same
3714      type, the result is of that type and is an lvalue.  */
3715   if (real_lvalue_p (arg2)
3716       && real_lvalue_p (arg3)
3717       && same_type_p (arg2_type, arg3_type))
3718     {
3719       result_type = arg2_type;
3720       goto valid_operands;
3721     }
3722
3723   /* [expr.cond]
3724
3725      Otherwise, the result is an rvalue.  If the second and third
3726      operand do not have the same type, and either has (possibly
3727      cv-qualified) class type, overload resolution is used to
3728      determine the conversions (if any) to be applied to the operands
3729      (_over.match.oper_, _over.built_).  */
3730   lvalue_p = false;
3731   if (!same_type_p (arg2_type, arg3_type)
3732       && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3733     {
3734       tree args[3];
3735       conversion *conv;
3736       bool any_viable_p;
3737
3738       /* Rearrange the arguments so that add_builtin_candidate only has
3739          to know about two args.  In build_builtin_candidates, the
3740          arguments are unscrambled.  */
3741       args[0] = arg2;
3742       args[1] = arg3;
3743       args[2] = arg1;
3744       add_builtin_candidates (&candidates,
3745                               COND_EXPR,
3746                               NOP_EXPR,
3747                               ansi_opname (COND_EXPR),
3748                               args,
3749                               LOOKUP_NORMAL);
3750
3751       /* [expr.cond]
3752
3753          If the overload resolution fails, the program is
3754          ill-formed.  */
3755       candidates = splice_viable (candidates, pedantic, &any_viable_p);
3756       if (!any_viable_p)
3757         {
3758           if (complain & tf_error)
3759             {
3760               op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3761               print_z_candidates (candidates);
3762             }
3763           return error_mark_node;
3764         }
3765       cand = tourney (candidates);
3766       if (!cand)
3767         {
3768           if (complain & tf_error)
3769             {
3770               op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3771               print_z_candidates (candidates);
3772             }
3773           return error_mark_node;
3774         }
3775
3776       /* [expr.cond]
3777
3778          Otherwise, the conversions thus determined are applied, and
3779          the converted operands are used in place of the original
3780          operands for the remainder of this section.  */
3781       conv = cand->convs[0];
3782       arg1 = convert_like (conv, arg1, complain);
3783       conv = cand->convs[1];
3784       arg2 = convert_like (conv, arg2, complain);
3785       conv = cand->convs[2];
3786       arg3 = convert_like (conv, arg3, complain);
3787     }
3788
3789   /* [expr.cond]
3790
3791      Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3792      and function-to-pointer (_conv.func_) standard conversions are
3793      performed on the second and third operands.
3794
3795      We need to force the lvalue-to-rvalue conversion here for class types,
3796      so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3797      that isn't wrapped with a TARGET_EXPR plays havoc with exception
3798      regions.  */
3799
3800   arg2 = force_rvalue (arg2);
3801   if (!CLASS_TYPE_P (arg2_type))
3802     arg2_type = TREE_TYPE (arg2);
3803
3804   arg3 = force_rvalue (arg3);
3805   if (!CLASS_TYPE_P (arg2_type))
3806     arg3_type = TREE_TYPE (arg3);
3807
3808   if (arg2 == error_mark_node || arg3 == error_mark_node)
3809     return error_mark_node;
3810
3811   /* [expr.cond]
3812
3813      After those conversions, one of the following shall hold:
3814
3815      --The second and third operands have the same type; the result  is  of
3816        that type.  */
3817   if (same_type_p (arg2_type, arg3_type))
3818     result_type = arg2_type;
3819   /* [expr.cond]
3820
3821      --The second and third operands have arithmetic or enumeration
3822        type; the usual arithmetic conversions are performed to bring
3823        them to a common type, and the result is of that type.  */
3824   else if ((ARITHMETIC_TYPE_P (arg2_type)
3825             || UNSCOPED_ENUM_P (arg2_type))
3826            && (ARITHMETIC_TYPE_P (arg3_type)
3827                || UNSCOPED_ENUM_P (arg3_type)))
3828     {
3829       /* In this case, there is always a common type.  */
3830       result_type = type_after_usual_arithmetic_conversions (arg2_type,
3831                                                              arg3_type);
3832
3833       if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3834           && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3835         {
3836           if (complain & tf_warning)
3837             warning (0,
3838                      "enumeral mismatch in conditional expression: %qT vs %qT",
3839                      arg2_type, arg3_type);
3840         }
3841       else if (extra_warnings
3842                && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3843                     && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3844                    || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3845                        && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3846         {
3847           if (complain & tf_warning)
3848             warning (0,
3849                      "enumeral and non-enumeral type in conditional expression");
3850         }
3851
3852       arg2 = perform_implicit_conversion (result_type, arg2, complain);
3853       arg3 = perform_implicit_conversion (result_type, arg3, complain);
3854     }
3855   /* [expr.cond]
3856
3857      --The second and third operands have pointer type, or one has
3858        pointer type and the other is a null pointer constant; pointer
3859        conversions (_conv.ptr_) and qualification conversions
3860        (_conv.qual_) are performed to bring them to their composite
3861        pointer type (_expr.rel_).  The result is of the composite
3862        pointer type.
3863
3864      --The second and third operands have pointer to member type, or
3865        one has pointer to member type and the other is a null pointer
3866        constant; pointer to member conversions (_conv.mem_) and
3867        qualification conversions (_conv.qual_) are performed to bring
3868        them to a common type, whose cv-qualification shall match the
3869        cv-qualification of either the second or the third operand.
3870        The result is of the common type.  */
3871   else if ((null_ptr_cst_p (arg2)
3872             && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3873            || (null_ptr_cst_p (arg3)
3874                && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3875            || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3876            || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3877            || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3878     {
3879       result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3880                                             arg3, "conditional expression",
3881                                             complain);
3882       if (result_type == error_mark_node)
3883         return error_mark_node;
3884       arg2 = perform_implicit_conversion (result_type, arg2, complain);
3885       arg3 = perform_implicit_conversion (result_type, arg3, complain);
3886     }
3887
3888   if (!result_type)
3889     {
3890       if (complain & tf_error)
3891         error ("operands to ?: have different types %qT and %qT",
3892                arg2_type, arg3_type);
3893       return error_mark_node;
3894     }
3895
3896  valid_operands:
3897   result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3898                                             arg2, arg3));
3899   /* We can't use result_type below, as fold might have returned a
3900      throw_expr.  */
3901
3902   if (!lvalue_p)
3903     {
3904       /* Expand both sides into the same slot, hopefully the target of
3905          the ?: expression.  We used to check for TARGET_EXPRs here,
3906          but now we sometimes wrap them in NOP_EXPRs so the test would
3907          fail.  */
3908       if (CLASS_TYPE_P (TREE_TYPE (result)))
3909         result = get_target_expr (result);
3910       /* If this expression is an rvalue, but might be mistaken for an
3911          lvalue, we must add a NON_LVALUE_EXPR.  */
3912       result = rvalue (result);
3913     }
3914
3915   return result;
3916 }
3917
3918 /* OPERAND is an operand to an expression.  Perform necessary steps
3919    required before using it.  If OPERAND is NULL_TREE, NULL_TREE is
3920    returned.  */
3921
3922 static tree
3923 prep_operand (tree operand)
3924 {
3925   if (operand)
3926     {
3927       if (CLASS_TYPE_P (TREE_TYPE (operand))
3928           && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3929         /* Make sure the template type is instantiated now.  */
3930         instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3931     }
3932
3933   return operand;
3934 }
3935
3936 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
3937    OVERLOAD) to the CANDIDATES, returning an updated list of
3938    CANDIDATES.  The ARGS are the arguments provided to the call,
3939    without any implicit object parameter.  This may change ARGS.  The
3940    EXPLICIT_TARGS are explicit template arguments provided.
3941    TEMPLATE_ONLY is true if only template functions should be
3942    considered.  CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
3943    add_function_candidate.  */
3944
3945 static void
3946 add_candidates (tree fns, const VEC(tree,gc) *args,
3947                 tree explicit_targs, bool template_only,
3948                 tree conversion_path, tree access_path,
3949                 int flags,
3950                 struct z_candidate **candidates)
3951 {
3952   tree ctype;
3953   VEC(tree,gc) *non_static_args;
3954   tree first_arg;
3955
3956   ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3957   /* Delay creating the implicit this parameter until it is needed.  */
3958   non_static_args = NULL;
3959   first_arg = NULL_TREE;
3960
3961   while (fns)
3962     {
3963       tree fn;
3964       tree fn_first_arg;
3965       const VEC(tree,gc) *fn_args;
3966
3967       fn = OVL_CURRENT (fns);
3968       /* Figure out which set of arguments to use.  */
3969       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3970         {
3971           /* If this function is a non-static member, prepend the implicit
3972              object parameter.  */
3973           if (non_static_args == NULL)
3974             {
3975               unsigned int ix;
3976               tree arg;
3977
3978               non_static_args = VEC_alloc (tree, gc,
3979                                            VEC_length (tree, args) - 1);
3980               for (ix = 1; VEC_iterate (tree, args, ix, arg); ++ix)
3981                 VEC_quick_push (tree, non_static_args, arg);
3982             }
3983           if (first_arg == NULL_TREE)
3984             first_arg = build_this (VEC_index (tree, args, 0));
3985           fn_first_arg = first_arg;
3986           fn_args = non_static_args;
3987         }
3988       else
3989         {
3990           /* Otherwise, just use the list of arguments provided.  */
3991           fn_first_arg = NULL_TREE;
3992           fn_args = args;
3993         }
3994
3995       if (TREE_CODE (fn) == TEMPLATE_DECL)
3996         add_template_candidate (candidates,
3997                                 fn,
3998                                 ctype,
3999                                 explicit_targs,
4000                                 fn_first_arg,
4001                                 fn_args,
4002                                 NULL_TREE,
4003                                 access_path,
4004                                 conversion_path,
4005                                 flags,
4006                                 DEDUCE_CALL);
4007       else if (!template_only)
4008         add_function_candidate (candidates,
4009                                 fn,
4010                                 ctype,
4011                                 fn_first_arg,
4012                                 fn_args,
4013                                 access_path,
4014                                 conversion_path,
4015                                 flags);
4016       fns = OVL_NEXT (fns);
4017     }
4018 }
4019
4020 tree
4021 build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
4022               bool *overloaded_p, tsubst_flags_t complain)
4023 {
4024   struct z_candidate *candidates = 0, *cand;
4025   VEC(tree,gc) *arglist;
4026   tree fnname;
4027   tree args[3];
4028   tree result = NULL_TREE;
4029   bool result_valid_p = false;
4030   enum tree_code code2 = NOP_EXPR;
4031   enum tree_code code_orig_arg1 = ERROR_MARK;
4032   enum tree_code code_orig_arg2 = ERROR_MARK;
4033   conversion *conv;
4034   void *p;
4035   bool strict_p;
4036   bool any_viable_p;
4037
4038   if (error_operand_p (arg1)
4039       || error_operand_p (arg2)
4040       || error_operand_p (arg3))
4041     return error_mark_node;
4042
4043   if (code == MODIFY_EXPR)
4044     {
4045       code2 = TREE_CODE (arg3);
4046       arg3 = NULL_TREE;
4047       fnname = ansi_assopname (code2);
4048     }
4049   else
4050     fnname = ansi_opname (code);
4051
4052   arg1 = prep_operand (arg1);
4053
4054   switch (code)
4055     {
4056     case NEW_EXPR:
4057     case VEC_NEW_EXPR:
4058     case VEC_DELETE_EXPR:
4059     case DELETE_EXPR:
4060       /* Use build_op_new_call and build_op_delete_call instead.  */
4061       gcc_unreachable ();
4062
4063     case CALL_EXPR:
4064       /* Use build_op_call instead.  */
4065       gcc_unreachable ();
4066
4067     case TRUTH_ORIF_EXPR:
4068     case TRUTH_ANDIF_EXPR:
4069     case TRUTH_AND_EXPR:
4070     case TRUTH_OR_EXPR:
4071       /* These are saved for the sake of warn_logical_operator.  */
4072       code_orig_arg1 = TREE_CODE (arg1);
4073       code_orig_arg2 = TREE_CODE (arg2);
4074
4075     default:
4076       break;
4077     }
4078
4079   arg2 = prep_operand (arg2);
4080   arg3 = prep_operand (arg3);
4081
4082   if (code == COND_EXPR)
4083     {
4084       if (arg2 == NULL_TREE
4085           || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
4086           || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
4087           || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
4088               && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
4089         goto builtin;
4090     }
4091   else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
4092            && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
4093     goto builtin;
4094
4095   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
4096     arg2 = integer_zero_node;
4097
4098   arglist = VEC_alloc (tree, gc, 3);
4099   VEC_quick_push (tree, arglist, arg1);
4100   if (arg2 != NULL_TREE)
4101     VEC_quick_push (tree, arglist, arg2);
4102   if (arg3 != NULL_TREE)
4103     VEC_quick_push (tree, arglist, arg3);
4104
4105   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
4106   p = conversion_obstack_alloc (0);
4107
4108   /* Add namespace-scope operators to the list of functions to
4109      consider.  */
4110   add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
4111                   arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
4112                   flags, &candidates);
4113   /* Add class-member operators to the candidate set.  */
4114   if (CLASS_TYPE_P (TREE_TYPE (arg1)))
4115     {
4116       tree fns;
4117
4118       fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
4119       if (fns == error_mark_node)
4120         {
4121           result = error_mark_node;
4122           goto user_defined_result_ready;
4123         }
4124       if (fns)
4125         add_candidates (BASELINK_FUNCTIONS (fns), arglist,
4126                         NULL_TREE, false,
4127                         BASELINK_BINFO (fns),
4128                         TYPE_BINFO (TREE_TYPE (arg1)),
4129                         flags, &candidates);
4130     }
4131
4132   /* Rearrange the arguments for ?: so that add_builtin_candidate only has
4133      to know about two args; a builtin candidate will always have a first
4134      parameter of type bool.  We'll handle that in
4135      build_builtin_candidate.  */
4136   if (code == COND_EXPR)
4137     {
4138       args[0] = arg2;
4139       args[1] = arg3;
4140       args[2] = arg1;
4141     }
4142   else
4143     {
4144       args[0] = arg1;
4145       args[1] = arg2;
4146       args[2] = NULL_TREE;
4147     }
4148
4149   add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
4150
4151   switch (code)
4152     {
4153     case COMPOUND_EXPR:
4154     case ADDR_EXPR:
4155       /* For these, the built-in candidates set is empty
4156          [over.match.oper]/3.  We don't want non-strict matches
4157          because exact matches are always possible with built-in
4158          operators.  The built-in candidate set for COMPONENT_REF
4159          would be empty too, but since there are no such built-in
4160          operators, we accept non-strict matches for them.  */
4161       strict_p = true;
4162       break;
4163
4164     default:
4165       strict_p = pedantic;
4166       break;
4167     }
4168
4169   candidates = splice_viable (candidates, strict_p, &any_viable_p);
4170   if (!any_viable_p)
4171     {
4172       switch (code)
4173         {
4174         case POSTINCREMENT_EXPR:
4175         case POSTDECREMENT_EXPR:
4176           /* Don't try anything fancy if we're not allowed to produce
4177              errors.  */
4178           if (!(complain & tf_error))
4179             return error_mark_node;
4180
4181           /* Look for an `operator++ (int)'.  If they didn't have
4182              one, then we fall back to the old way of doing things.  */
4183           if (flags & LOOKUP_COMPLAIN)
4184             permerror (input_location, "no %<%D(int)%> declared for postfix %qs, "
4185                        "trying prefix operator instead",
4186                        fnname,
4187                        operator_name_info[code].name);
4188           if (code == POSTINCREMENT_EXPR)
4189             code = PREINCREMENT_EXPR;
4190           else
4191             code = PREDECREMENT_EXPR;
4192           result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
4193                                  overloaded_p, complain);
4194           break;
4195
4196           /* The caller will deal with these.  */
4197         case ADDR_EXPR:
4198         case COMPOUND_EXPR:
4199         case COMPONENT_REF:
4200           result = NULL_TREE;
4201           result_valid_p = true;
4202           break;
4203
4204         default:
4205           if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4206             {
4207                 /* If one of the arguments of the operator represents
4208                    an invalid use of member function pointer, try to report
4209                    a meaningful error ...  */
4210                 if (invalid_nonstatic_memfn_p (arg1, tf_error)
4211                     || invalid_nonstatic_memfn_p (arg2, tf_error)
4212                     || invalid_nonstatic_memfn_p (arg3, tf_error))
4213                   /* We displayed the error message.  */;
4214                 else
4215                   {
4216                     /* ... Otherwise, report the more generic
4217                        "no matching operator found" error */
4218                     op_error (code, code2, arg1, arg2, arg3, "no match");
4219                     print_z_candidates (candidates);
4220                   }
4221             }
4222           result = error_mark_node;
4223           break;
4224         }
4225     }
4226   else
4227     {
4228       cand = tourney (candidates);
4229       if (cand == 0)
4230         {
4231           if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4232             {
4233               op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
4234               print_z_candidates (candidates);
4235             }
4236           result = error_mark_node;
4237         }
4238       else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
4239         {
4240           if (overloaded_p)
4241             *overloaded_p = true;
4242
4243           if (resolve_args (arglist) == NULL)
4244             result = error_mark_node;
4245           else
4246             result = build_over_call (cand, LOOKUP_NORMAL, complain);
4247         }
4248       else
4249         {
4250           /* Give any warnings we noticed during overload resolution.  */
4251           if (cand->warnings && (complain & tf_warning))
4252             {
4253               struct candidate_warning *w;
4254               for (w = cand->warnings; w; w = w->next)
4255                 joust (cand, w->loser, 1);
4256             }
4257
4258           /* Check for comparison of different enum types.  */
4259           switch (code)
4260             {
4261             case GT_EXPR:
4262             case LT_EXPR:
4263             case GE_EXPR:
4264             case LE_EXPR:
4265             case EQ_EXPR:
4266             case NE_EXPR:
4267               if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
4268                   && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
4269                   && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
4270                       != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
4271                   && (complain & tf_warning))
4272                 {
4273                   warning (OPT_Wenum_compare,
4274                            "comparison between %q#T and %q#T",
4275                            TREE_TYPE (arg1), TREE_TYPE (arg2));
4276                 }
4277               break;
4278             default:
4279               break;
4280             }
4281
4282           /* We need to strip any leading REF_BIND so that bitfields
4283              don't cause errors.  This should not remove any important
4284              conversions, because builtins don't apply to class
4285              objects directly.  */
4286           conv = cand->convs[0];
4287           if (conv->kind == ck_ref_bind)
4288             conv = conv->u.next;
4289           arg1 = convert_like (conv, arg1, complain);
4290
4291           if (arg2)
4292             {
4293               /* We need to call warn_logical_operator before
4294                  converting arg2 to a boolean_type.  */
4295               if (complain & tf_warning)
4296                 warn_logical_operator (input_location, code, boolean_type_node,
4297                                        code_orig_arg1, arg1,
4298                                        code_orig_arg2, arg2);
4299
4300               conv = cand->convs[1];
4301               if (conv->kind == ck_ref_bind)
4302                 conv = conv->u.next;
4303               arg2 = convert_like (conv, arg2, complain);
4304             }
4305           if (arg3)
4306             {
4307               conv = cand->convs[2];
4308               if (conv->kind == ck_ref_bind)
4309                 conv = conv->u.next;
4310               arg3 = convert_like (conv, arg3, complain);
4311             }
4312
4313         }
4314     }
4315
4316  user_defined_result_ready:
4317
4318   /* Free all the conversions we allocated.  */
4319   obstack_free (&conversion_obstack, p);
4320
4321   if (result || result_valid_p)
4322     return result;
4323
4324  builtin:
4325   switch (code)
4326     {
4327     case MODIFY_EXPR:
4328       return cp_build_modify_expr (arg1, code2, arg2, complain);
4329
4330     case INDIRECT_REF:
4331       return cp_build_indirect_ref (arg1, "unary *", complain);
4332
4333     case TRUTH_ANDIF_EXPR:
4334     case TRUTH_ORIF_EXPR:
4335     case TRUTH_AND_EXPR:
4336     case TRUTH_OR_EXPR:
4337       warn_logical_operator (input_location, code, boolean_type_node,
4338                              code_orig_arg1, arg1, code_orig_arg2, arg2);
4339       /* Fall through.  */
4340     case PLUS_EXPR:
4341     case MINUS_EXPR:
4342     case MULT_EXPR:
4343     case TRUNC_DIV_EXPR:
4344     case GT_EXPR:
4345     case LT_EXPR:
4346     case GE_EXPR:
4347     case LE_EXPR:
4348     case EQ_EXPR:
4349     case NE_EXPR:
4350     case MAX_EXPR:
4351     case MIN_EXPR:
4352     case LSHIFT_EXPR:
4353     case RSHIFT_EXPR:
4354     case TRUNC_MOD_EXPR:
4355     case BIT_AND_EXPR:
4356     case BIT_IOR_EXPR:
4357     case BIT_XOR_EXPR:
4358       return cp_build_binary_op (input_location, code, arg1, arg2, complain);
4359
4360     case UNARY_PLUS_EXPR:
4361     case NEGATE_EXPR:
4362     case BIT_NOT_EXPR:
4363     case TRUTH_NOT_EXPR:
4364     case PREINCREMENT_EXPR:
4365     case POSTINCREMENT_EXPR:
4366     case PREDECREMENT_EXPR:
4367     case POSTDECREMENT_EXPR:
4368     case REALPART_EXPR:
4369     case IMAGPART_EXPR:
4370       return cp_build_unary_op (code, arg1, candidates != 0, complain);
4371
4372     case ARRAY_REF:
4373       return build_array_ref (arg1, arg2, input_location);
4374
4375     case COND_EXPR:
4376       return build_conditional_expr (arg1, arg2, arg3, complain);
4377
4378     case MEMBER_REF:
4379       return build_m_component_ref (cp_build_indirect_ref (arg1, NULL,
4380                                                            complain),
4381                                     arg2);
4382
4383       /* The caller will deal with these.  */
4384     case ADDR_EXPR:
4385     case COMPONENT_REF:
4386     case COMPOUND_EXPR:
4387       return NULL_TREE;
4388
4389     default:
4390       gcc_unreachable ();
4391     }
4392   return NULL_TREE;
4393 }
4394
4395 /* Build a call to operator delete.  This has to be handled very specially,
4396    because the restrictions on what signatures match are different from all
4397    other call instances.  For a normal delete, only a delete taking (void *)
4398    or (void *, size_t) is accepted.  For a placement delete, only an exact
4399    match with the placement new is accepted.
4400
4401    CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4402    ADDR is the pointer to be deleted.
4403    SIZE is the size of the memory block to be deleted.
4404    GLOBAL_P is true if the delete-expression should not consider
4405    class-specific delete operators.
4406    PLACEMENT is the corresponding placement new call, or NULL_TREE.
4407
4408    If this call to "operator delete" is being generated as part to
4409    deallocate memory allocated via a new-expression (as per [expr.new]
4410    which requires that if the initialization throws an exception then
4411    we call a deallocation function), then ALLOC_FN is the allocation
4412    function.  */
4413
4414 tree
4415 build_op_delete_call (enum tree_code code, tree addr, tree size,
4416                       bool global_p, tree placement,
4417                       tree alloc_fn)
4418 {
4419   tree fn = NULL_TREE;
4420   tree fns, fnname, argtypes, type;
4421   int pass;
4422
4423   if (addr == error_mark_node)
4424     return error_mark_node;
4425
4426   type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4427
4428   fnname = ansi_opname (code);
4429
4430   if (CLASS_TYPE_P (type)
4431       && COMPLETE_TYPE_P (complete_type (type))
4432       && !global_p)
4433     /* In [class.free]
4434
4435        If the result of the lookup is ambiguous or inaccessible, or if
4436        the lookup selects a placement deallocation function, the
4437        program is ill-formed.
4438
4439        Therefore, we ask lookup_fnfields to complain about ambiguity.  */
4440     {
4441       fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4442       if (fns == error_mark_node)
4443         return error_mark_node;
4444     }
4445   else
4446     fns = NULL_TREE;
4447
4448   if (fns == NULL_TREE)
4449     fns = lookup_name_nonclass (fnname);
4450
4451   /* Strip const and volatile from addr.  */
4452   addr = cp_convert (ptr_type_node, addr);
4453
4454   if (placement)
4455     {
4456       /* Get the parameter types for the allocation function that is
4457          being called.  */
4458       gcc_assert (alloc_fn != NULL_TREE);
4459       argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4460     }
4461   else
4462     {
4463       /* First try it without the size argument.  */
4464       argtypes = void_list_node;
4465     }
4466
4467   /* We make two tries at finding a matching `operator delete'.  On
4468      the first pass, we look for a one-operator (or placement)
4469      operator delete.  If we're not doing placement delete, then on
4470      the second pass we look for a two-argument delete.  */
4471   for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4472     {
4473       /* Go through the `operator delete' functions looking for one
4474          with a matching type.  */
4475       for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4476            fn;
4477            fn = OVL_NEXT (fn))
4478         {
4479           tree t;
4480
4481           /* The first argument must be "void *".  */
4482           t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4483           if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4484             continue;
4485           t = TREE_CHAIN (t);
4486           /* On the first pass, check the rest of the arguments.  */
4487           if (pass == 0)
4488             {
4489               tree a = argtypes;
4490               while (a && t)
4491                 {
4492                   if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4493                     break;
4494                   a = TREE_CHAIN (a);
4495                   t = TREE_CHAIN (t);
4496                 }
4497               if (!a && !t)
4498                 break;
4499             }
4500           /* On the second pass, look for a function with exactly two
4501              arguments: "void *" and "size_t".  */
4502           else if (pass == 1
4503                    /* For "operator delete(void *, ...)" there will be
4504                       no second argument, but we will not get an exact
4505                       match above.  */
4506                    && t
4507                    && same_type_p (TREE_VALUE (t), size_type_node)
4508                    && TREE_CHAIN (t) == void_list_node)
4509             break;
4510         }
4511
4512       /* If we found a match, we're done.  */
4513       if (fn)
4514         break;
4515     }
4516
4517   /* If we have a matching function, call it.  */
4518   if (fn)
4519     {
4520       /* Make sure we have the actual function, and not an
4521          OVERLOAD.  */
4522       fn = OVL_CURRENT (fn);
4523
4524       /* If the FN is a member function, make sure that it is
4525          accessible.  */
4526       if (DECL_CLASS_SCOPE_P (fn))
4527         perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4528
4529       if (placement)
4530         {
4531           /* The placement args might not be suitable for overload
4532              resolution at this point, so build the call directly.  */
4533           int nargs = call_expr_nargs (placement);
4534           tree *argarray = (tree *) alloca (nargs * sizeof (tree));
4535           int i;
4536           argarray[0] = addr;
4537           for (i = 1; i < nargs; i++)
4538             argarray[i] = CALL_EXPR_ARG (placement, i);
4539           mark_used (fn);
4540           return build_cxx_call (fn, nargs, argarray);
4541         }
4542       else
4543         {
4544           tree ret;
4545           VEC(tree,gc) *args = VEC_alloc (tree, gc, 2);
4546           VEC_quick_push (tree, args, addr);
4547           if (pass != 0)
4548             VEC_quick_push (tree, args, size);
4549           ret = cp_build_function_call_vec (fn, &args, tf_warning_or_error);
4550           VEC_free (tree, gc, args);
4551           return ret;
4552         }
4553     }
4554
4555   /* [expr.new]
4556
4557      If no unambiguous matching deallocation function can be found,
4558      propagating the exception does not cause the object's memory to
4559      be freed.  */
4560   if (alloc_fn)
4561     {
4562       if (!placement)
4563         warning (0, "no corresponding deallocation function for %qD",
4564                  alloc_fn);
4565       return NULL_TREE;
4566     }
4567
4568   error ("no suitable %<operator %s%> for %qT",
4569          operator_name_info[(int)code].name, type);
4570   return error_mark_node;
4571 }
4572
4573 /* If the current scope isn't allowed to access DECL along
4574    BASETYPE_PATH, give an error.  The most derived class in
4575    BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4576    the declaration to use in the error diagnostic.  */
4577
4578 bool
4579 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4580 {
4581   gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4582
4583   if (!accessible_p (basetype_path, decl, true))
4584     {
4585       if (TREE_PRIVATE (decl))
4586         error ("%q+#D is private", diag_decl);
4587       else if (TREE_PROTECTED (decl))
4588         error ("%q+#D is protected", diag_decl);
4589       else
4590         error ("%q+#D is inaccessible", diag_decl);
4591       error ("within this context");
4592       return false;
4593     }
4594
4595   return true;
4596 }
4597
4598 /* Initialize a temporary of type TYPE with EXPR.  The FLAGS are a
4599    bitwise or of LOOKUP_* values.  If any errors are warnings are
4600    generated, set *DIAGNOSTIC_FN to "error" or "warning",
4601    respectively.  If no diagnostics are generated, set *DIAGNOSTIC_FN
4602    to NULL.  */
4603
4604 static tree
4605 build_temp (tree expr, tree type, int flags,
4606             diagnostic_t *diagnostic_kind)
4607 {
4608   int savew, savee;
4609   VEC(tree,gc) *args;
4610
4611   savew = warningcount, savee = errorcount;
4612   args = make_tree_vector_single (expr);
4613   expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
4614                                     &args, type, flags, tf_warning_or_error);
4615   release_tree_vector (args);
4616   if (warningcount > savew)
4617     *diagnostic_kind = DK_WARNING;
4618   else if (errorcount > savee)
4619     *diagnostic_kind = DK_ERROR;
4620   else
4621     *diagnostic_kind = DK_UNSPECIFIED;
4622   return expr;
4623 }
4624
4625 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4626    EXPR is implicitly converted to type TOTYPE.
4627    FN and ARGNUM are used for diagnostics.  */
4628
4629 static void
4630 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
4631 {
4632   tree t = non_reference (totype);
4633
4634   /* Issue warnings about peculiar, but valid, uses of NULL.  */
4635   if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4636     {
4637       if (fn)
4638         warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4639                  argnum, fn);
4640       else
4641         warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4642     }
4643
4644   /* Issue warnings if "false" is converted to a NULL pointer */
4645   else if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4646     warning (OPT_Wconversion,
4647              "converting %<false%> to pointer type for argument %P of %qD",
4648              argnum, fn);
4649 }
4650
4651 /* Perform the conversions in CONVS on the expression EXPR.  FN and
4652    ARGNUM are used for diagnostics.  ARGNUM is zero based, -1
4653    indicates the `this' argument of a method.  INNER is nonzero when
4654    being called to continue a conversion chain. It is negative when a
4655    reference binding will be applied, positive otherwise.  If
4656    ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4657    conversions will be emitted if appropriate.  If C_CAST_P is true,
4658    this conversion is coming from a C-style cast; in that case,
4659    conversions to inaccessible bases are permitted.  */
4660
4661 static tree
4662 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4663                    int inner, bool issue_conversion_warnings,
4664                    bool c_cast_p, tsubst_flags_t complain)
4665 {
4666   tree totype = convs->type;
4667   diagnostic_t diag_kind;
4668   int flags;
4669
4670   if (convs->bad_p
4671       && convs->kind != ck_user
4672       && convs->kind != ck_ambig
4673       && convs->kind != ck_ref_bind
4674       && convs->kind != ck_rvalue
4675       && convs->kind != ck_base)
4676     {
4677       conversion *t = convs;
4678       for (; t; t = convs->u.next)
4679         {
4680           if (t->kind == ck_user || !t->bad_p)
4681             {
4682               expr = convert_like_real (t, expr, fn, argnum, 1,
4683                                         /*issue_conversion_warnings=*/false,
4684                                         /*c_cast_p=*/false,
4685                                         complain);
4686               break;
4687             }
4688           else if (t->kind == ck_ambig)
4689             return convert_like_real (t, expr, fn, argnum, 1,
4690                                       /*issue_conversion_warnings=*/false,
4691                                       /*c_cast_p=*/false,
4692                                       complain);
4693           else if (t->kind == ck_identity)
4694             break;
4695         }
4696       if (complain & tf_error)
4697         {
4698           permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4699           if (fn)
4700             permerror (input_location, "  initializing argument %P of %qD", argnum, fn);
4701         }
4702       else
4703         return error_mark_node;
4704
4705       return cp_convert (totype, expr);
4706     }
4707
4708   if (issue_conversion_warnings && (complain & tf_warning))
4709     conversion_null_warnings (totype, expr, fn, argnum);
4710
4711   switch (convs->kind)
4712     {
4713     case ck_user:
4714       {
4715         struct z_candidate *cand = convs->cand;
4716         tree convfn = cand->fn;
4717         unsigned i;
4718
4719         /* When converting from an init list we consider explicit
4720            constructors, but actually trying to call one is an error.  */
4721         if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn))
4722           {
4723             if (complain & tf_error)
4724               error ("converting to %qT from initializer list would use "
4725                      "explicit constructor %qD", totype, convfn);
4726             else
4727               return error_mark_node;
4728           }
4729
4730         /* Set user_conv_p on the argument conversions, so rvalue/base
4731            handling knows not to allow any more UDCs.  */
4732         for (i = 0; i < cand->num_convs; ++i)
4733           cand->convs[i]->user_conv_p = true;
4734
4735         expr = build_over_call (cand, LOOKUP_NORMAL, complain);
4736
4737         /* If this is a constructor or a function returning an aggr type,
4738            we need to build up a TARGET_EXPR.  */
4739         if (DECL_CONSTRUCTOR_P (convfn))
4740           {
4741             expr = build_cplus_new (totype, expr);
4742
4743             /* Remember that this was list-initialization.  */
4744             if (convs->check_narrowing)
4745               TARGET_EXPR_LIST_INIT_P (expr) = true;
4746           }
4747
4748         return expr;
4749       }
4750     case ck_identity:
4751       if (type_unknown_p (expr))
4752         expr = instantiate_type (totype, expr, complain);
4753       /* Convert a constant to its underlying value, unless we are
4754          about to bind it to a reference, in which case we need to
4755          leave it as an lvalue.  */
4756       if (inner >= 0)
4757         {
4758           expr = decl_constant_value (expr);
4759           if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype))
4760             /* If __null has been converted to an integer type, we do not
4761                want to warn about uses of EXPR as an integer, rather than
4762                as a pointer.  */
4763             expr = build_int_cst (totype, 0);
4764         }
4765       return expr;
4766     case ck_ambig:
4767       /* Call build_user_type_conversion again for the error.  */
4768       return build_user_type_conversion
4769         (totype, convs->u.expr, LOOKUP_NORMAL);
4770
4771     case ck_list:
4772       {
4773         /* Conversion to std::initializer_list<T>.  */
4774         tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
4775         tree new_ctor = build_constructor (init_list_type_node, NULL);
4776         unsigned len = CONSTRUCTOR_NELTS (expr);
4777         tree array, val;
4778         VEC(tree,gc) *parms;
4779         unsigned ix;
4780
4781         /* Convert all the elements.  */
4782         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
4783           {
4784             tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
4785                                           1, false, false, complain);
4786             if (sub == error_mark_node)
4787               return sub;
4788             check_narrowing (TREE_TYPE (sub), val);
4789             CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
4790           }
4791         /* Build up the array.  */
4792         elttype = cp_build_qualified_type
4793           (elttype, TYPE_QUALS (elttype) | TYPE_QUAL_CONST);
4794         array = build_array_of_n_type (elttype, len);
4795         array = finish_compound_literal (array, new_ctor);
4796
4797         parms = make_tree_vector ();
4798         VEC_safe_push (tree, gc, parms, decay_conversion (array));
4799         VEC_safe_push (tree, gc, parms, size_int (len));
4800         /* Call the private constructor.  */
4801         push_deferring_access_checks (dk_no_check);
4802         new_ctor = build_special_member_call
4803           (NULL_TREE, complete_ctor_identifier, &parms, totype, 0, complain);
4804         release_tree_vector (parms);
4805         pop_deferring_access_checks ();
4806         return build_cplus_new (totype, new_ctor);
4807       }
4808
4809     case ck_aggr:
4810       return get_target_expr (digest_init (totype, expr));
4811
4812     default:
4813       break;
4814     };
4815
4816   expr = convert_like_real (convs->u.next, expr, fn, argnum,
4817                             convs->kind == ck_ref_bind ? -1 : 1,
4818                             convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
4819                             c_cast_p,
4820                             complain);
4821   if (expr == error_mark_node)
4822     return error_mark_node;
4823
4824   switch (convs->kind)
4825     {
4826     case ck_rvalue:
4827       expr = convert_bitfield_to_declared_type (expr);
4828       if (! MAYBE_CLASS_TYPE_P (totype))
4829         return expr;
4830       /* Else fall through.  */
4831     case ck_base:
4832       if (convs->kind == ck_base && !convs->need_temporary_p)
4833         {
4834           /* We are going to bind a reference directly to a base-class
4835              subobject of EXPR.  */
4836           /* Build an expression for `*((base*) &expr)'.  */
4837           expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
4838           expr = convert_to_base (expr, build_pointer_type (totype),
4839                                   !c_cast_p, /*nonnull=*/true);
4840           expr = cp_build_indirect_ref (expr, "implicit conversion", complain);
4841           return expr;
4842         }
4843
4844       /* Copy-initialization where the cv-unqualified version of the source
4845          type is the same class as, or a derived class of, the class of the
4846          destination [is treated as direct-initialization].  [dcl.init] */
4847       flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
4848       if (convs->user_conv_p)
4849         /* This conversion is being done in the context of a user-defined
4850            conversion (i.e. the second step of copy-initialization), so
4851            don't allow any more.  */
4852         flags |= LOOKUP_NO_CONVERSION;
4853       expr = build_temp (expr, totype, flags, &diag_kind);
4854       if (diag_kind && fn)
4855         {
4856           if ((complain & tf_error))
4857             emit_diagnostic (diag_kind, input_location, 0,
4858                              "  initializing argument %P of %qD", argnum, fn);
4859           else if (diag_kind == DK_ERROR)
4860             return error_mark_node;
4861         }
4862       return build_cplus_new (totype, expr);
4863
4864     case ck_ref_bind:
4865       {
4866         tree ref_type = totype;
4867
4868         /* If necessary, create a temporary.
4869
4870            VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
4871            that need temporaries, even when their types are reference
4872            compatible with the type of reference being bound, so the
4873            upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...)
4874            doesn't fail.  */
4875         if (convs->need_temporary_p
4876             || TREE_CODE (expr) == CONSTRUCTOR
4877             || TREE_CODE (expr) == VA_ARG_EXPR)
4878           {
4879             tree type = convs->u.next->type;
4880             cp_lvalue_kind lvalue = real_lvalue_p (expr);
4881
4882             if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
4883                 && !TYPE_REF_IS_RVALUE (ref_type))
4884               {
4885                 if (complain & tf_error)
4886                   {
4887                     /* If the reference is volatile or non-const, we
4888                        cannot create a temporary.  */
4889                     if (lvalue & clk_bitfield)
4890                       error ("cannot bind bitfield %qE to %qT",
4891                              expr, ref_type);
4892                     else if (lvalue & clk_packed)
4893                       error ("cannot bind packed field %qE to %qT",
4894                              expr, ref_type);
4895                     else
4896                       error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4897                   }
4898                 return error_mark_node;
4899               }
4900             /* If the source is a packed field, and we must use a copy
4901                constructor, then building the target expr will require
4902                binding the field to the reference parameter to the
4903                copy constructor, and we'll end up with an infinite
4904                loop.  If we can use a bitwise copy, then we'll be
4905                OK.  */
4906             if ((lvalue & clk_packed)
4907                 && CLASS_TYPE_P (type)
4908                 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4909               {
4910                 if (complain & tf_error)
4911                   error ("cannot bind packed field %qE to %qT",
4912                          expr, ref_type);
4913                 return error_mark_node;
4914               }
4915             if (lvalue & clk_bitfield)
4916               {
4917                 expr = convert_bitfield_to_declared_type (expr);
4918                 expr = fold_convert (type, expr);
4919               }
4920             expr = build_target_expr_with_type (expr, type);
4921           }
4922
4923         /* Take the address of the thing to which we will bind the
4924            reference.  */
4925         expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain);
4926         if (expr == error_mark_node)
4927           return error_mark_node;
4928
4929         /* Convert it to a pointer to the type referred to by the
4930            reference.  This will adjust the pointer if a derived to
4931            base conversion is being performed.  */
4932         expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4933                            expr);
4934         /* Convert the pointer to the desired reference type.  */
4935         return build_nop (ref_type, expr);
4936       }
4937
4938     case ck_lvalue:
4939       return decay_conversion (expr);
4940
4941     case ck_qual:
4942       /* Warn about deprecated conversion if appropriate.  */
4943       string_conv_p (totype, expr, 1);
4944       break;
4945
4946     case ck_ptr:
4947       if (convs->base_p)
4948         expr = convert_to_base (expr, totype, !c_cast_p,
4949                                 /*nonnull=*/false);
4950       return build_nop (totype, expr);
4951
4952     case ck_pmem:
4953       return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4954                              c_cast_p);
4955
4956     default:
4957       break;
4958     }
4959
4960   if (convs->check_narrowing)
4961     check_narrowing (totype, expr);
4962
4963   if (issue_conversion_warnings && (complain & tf_warning))
4964     expr = convert_and_check (totype, expr);
4965   else
4966     expr = convert (totype, expr);
4967
4968   return expr;
4969 }
4970
4971 /* Build a call to __builtin_trap.  */
4972
4973 static tree
4974 call_builtin_trap (void)
4975 {
4976   tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4977
4978   gcc_assert (fn != NULL);
4979   fn = build_call_n (fn, 0);
4980   return fn;
4981 }
4982
4983 /* ARG is being passed to a varargs function.  Perform any conversions
4984    required.  Return the converted value.  */
4985
4986 tree
4987 convert_arg_to_ellipsis (tree arg)
4988 {
4989   /* [expr.call]
4990
4991      The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4992      standard conversions are performed.  */
4993   arg = decay_conversion (arg);
4994   /* [expr.call]
4995
4996      If the argument has integral or enumeration type that is subject
4997      to the integral promotions (_conv.prom_), or a floating point
4998      type that is subject to the floating point promotion
4999      (_conv.fpprom_), the value of the argument is converted to the
5000      promoted type before the call.  */
5001   if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
5002       && (TYPE_PRECISION (TREE_TYPE (arg))
5003           < TYPE_PRECISION (double_type_node)))
5004     arg = convert_to_real (double_type_node, arg);
5005   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
5006     arg = perform_integral_promotions (arg);
5007
5008   arg = require_complete_type (arg);
5009
5010   if (arg != error_mark_node
5011       && !pod_type_p (TREE_TYPE (arg)))
5012     {
5013       /* Undefined behavior [expr.call] 5.2.2/7.  We used to just warn
5014          here and do a bitwise copy, but now cp_expr_size will abort if we
5015          try to do that.
5016          If the call appears in the context of a sizeof expression,
5017          there is no need to emit a warning, since the expression won't be
5018          evaluated. We keep the builtin_trap just as a safety check.  */
5019       if (!skip_evaluation)
5020         warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
5021                  "call will abort at runtime", TREE_TYPE (arg));
5022       arg = call_builtin_trap ();
5023       arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
5024                     integer_zero_node);
5025     }
5026
5027   return arg;
5028 }
5029
5030 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused.  */
5031
5032 tree
5033 build_x_va_arg (tree expr, tree type)
5034 {
5035   if (processing_template_decl)
5036     return build_min (VA_ARG_EXPR, type, expr);
5037
5038   type = complete_type_or_else (type, NULL_TREE);
5039
5040   if (expr == error_mark_node || !type)
5041     return error_mark_node;
5042
5043   if (! pod_type_p (type))
5044     {
5045       /* Remove reference types so we don't ICE later on.  */
5046       tree type1 = non_reference (type);
5047       /* Undefined behavior [expr.call] 5.2.2/7.  */
5048       warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
5049                "call will abort at runtime", type);
5050       expr = convert (build_pointer_type (type1), null_node);
5051       expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
5052                      call_builtin_trap (), expr);
5053       expr = cp_build_indirect_ref (expr, NULL, tf_warning_or_error);
5054       return expr;
5055     }
5056
5057   return build_va_arg (expr, type);
5058 }
5059
5060 /* TYPE has been given to va_arg.  Apply the default conversions which
5061    would have happened when passed via ellipsis.  Return the promoted
5062    type, or the passed type if there is no change.  */
5063
5064 tree
5065 cxx_type_promotes_to (tree type)
5066 {
5067   tree promote;
5068
5069   /* Perform the array-to-pointer and function-to-pointer
5070      conversions.  */
5071   type = type_decays_to (type);
5072
5073   promote = type_promotes_to (type);
5074   if (same_type_p (type, promote))
5075     promote = type;
5076
5077   return promote;
5078 }
5079
5080 /* ARG is a default argument expression being passed to a parameter of
5081    the indicated TYPE, which is a parameter to FN.  Do any required
5082    conversions.  Return the converted value.  */
5083
5084 static GTY(()) VEC(tree,gc) *default_arg_context;
5085
5086 tree
5087 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
5088 {
5089   int i;
5090   tree t;
5091
5092   /* If the ARG is an unparsed default argument expression, the
5093      conversion cannot be performed.  */
5094   if (TREE_CODE (arg) == DEFAULT_ARG)
5095     {
5096       error ("the default argument for parameter %d of %qD has "
5097              "not yet been parsed",
5098              parmnum, fn);
5099       return error_mark_node;
5100     }
5101
5102   /* Detect recursion.  */
5103   for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
5104     if (t == fn)
5105       {
5106         error ("recursive evaluation of default argument for %q#D", fn);
5107         return error_mark_node;
5108       }
5109   VEC_safe_push (tree, gc, default_arg_context, fn);
5110
5111   if (fn && DECL_TEMPLATE_INFO (fn))
5112     arg = tsubst_default_argument (fn, type, arg);
5113
5114   /* Due to:
5115
5116        [dcl.fct.default]
5117
5118        The names in the expression are bound, and the semantic
5119        constraints are checked, at the point where the default
5120        expressions appears.
5121
5122      we must not perform access checks here.  */
5123   push_deferring_access_checks (dk_no_check);
5124   arg = break_out_target_exprs (arg);
5125   if (TREE_CODE (arg) == CONSTRUCTOR)
5126     {
5127       arg = digest_init (type, arg);
5128       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5129                                         "default argument", fn, parmnum,
5130                                         tf_warning_or_error);
5131     }
5132   else
5133     {
5134       /* We must make a copy of ARG, in case subsequent processing
5135          alters any part of it.  For example, during gimplification a
5136          cast of the form (T) &X::f (where "f" is a member function)
5137          will lead to replacing the PTRMEM_CST for &X::f with a
5138          VAR_DECL.  We can avoid the copy for constants, since they
5139          are never modified in place.  */
5140       if (!CONSTANT_CLASS_P (arg))
5141         arg = unshare_expr (arg);
5142       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5143                                         "default argument", fn, parmnum,
5144                                         tf_warning_or_error);
5145       arg = convert_for_arg_passing (type, arg);
5146     }
5147   pop_deferring_access_checks();
5148
5149   VEC_pop (tree, default_arg_context);
5150
5151   return arg;
5152 }
5153
5154 /* Returns the type which will really be used for passing an argument of
5155    type TYPE.  */
5156
5157 tree
5158 type_passed_as (tree type)
5159 {
5160   /* Pass classes with copy ctors by invisible reference.  */
5161   if (TREE_ADDRESSABLE (type))
5162     {
5163       type = build_reference_type (type);
5164       /* There are no other pointers to this temporary.  */
5165       type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
5166     }
5167   else if (targetm.calls.promote_prototypes (type)
5168            && INTEGRAL_TYPE_P (type)
5169            && COMPLETE_TYPE_P (type)
5170            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5171                                    TYPE_SIZE (integer_type_node)))
5172     type = integer_type_node;
5173
5174   return type;
5175 }
5176
5177 /* Actually perform the appropriate conversion.  */
5178
5179 tree
5180 convert_for_arg_passing (tree type, tree val)
5181 {
5182   tree bitfield_type;
5183
5184   /* If VAL is a bitfield, then -- since it has already been converted
5185      to TYPE -- it cannot have a precision greater than TYPE.
5186
5187      If it has a smaller precision, we must widen it here.  For
5188      example, passing "int f:3;" to a function expecting an "int" will
5189      not result in any conversion before this point.
5190
5191      If the precision is the same we must not risk widening.  For
5192      example, the COMPONENT_REF for a 32-bit "long long" bitfield will
5193      often have type "int", even though the C++ type for the field is
5194      "long long".  If the value is being passed to a function
5195      expecting an "int", then no conversions will be required.  But,
5196      if we call convert_bitfield_to_declared_type, the bitfield will
5197      be converted to "long long".  */
5198   bitfield_type = is_bitfield_expr_with_lowered_type (val);
5199   if (bitfield_type
5200       && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
5201     val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
5202
5203   if (val == error_mark_node)
5204     ;
5205   /* Pass classes with copy ctors by invisible reference.  */
5206   else if (TREE_ADDRESSABLE (type))
5207     val = build1 (ADDR_EXPR, build_reference_type (type), val);
5208   else if (targetm.calls.promote_prototypes (type)
5209            && INTEGRAL_TYPE_P (type)
5210            && COMPLETE_TYPE_P (type)
5211            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5212                                    TYPE_SIZE (integer_type_node)))
5213     val = perform_integral_promotions (val);
5214   if (warn_missing_format_attribute)
5215     {
5216       tree rhstype = TREE_TYPE (val);
5217       const enum tree_code coder = TREE_CODE (rhstype);
5218       const enum tree_code codel = TREE_CODE (type);
5219       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5220           && coder == codel
5221           && check_missing_format_attribute (type, rhstype))
5222         warning (OPT_Wmissing_format_attribute,
5223                  "argument of function call might be a candidate for a format attribute");
5224     }
5225   return val;
5226 }
5227
5228 /* Returns true iff FN is a function with magic varargs, i.e. ones for
5229    which no conversions at all should be done.  This is true for some
5230    builtins which don't act like normal functions.  */
5231
5232 static bool
5233 magic_varargs_p (tree fn)
5234 {
5235   if (DECL_BUILT_IN (fn))
5236     switch (DECL_FUNCTION_CODE (fn))
5237       {
5238       case BUILT_IN_CLASSIFY_TYPE:
5239       case BUILT_IN_CONSTANT_P:
5240       case BUILT_IN_NEXT_ARG:
5241       case BUILT_IN_VA_START:
5242         return true;
5243
5244       default:;
5245         return lookup_attribute ("type generic",
5246                                  TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
5247       }
5248
5249   return false;
5250 }
5251
5252 /* Subroutine of the various build_*_call functions.  Overload resolution
5253    has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
5254    ARGS is a TREE_LIST of the unconverted arguments to the call.  FLAGS is a
5255    bitmask of various LOOKUP_* flags which apply to the call itself.  */
5256
5257 static tree
5258 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
5259 {
5260   tree fn = cand->fn;
5261   const VEC(tree,gc) *args = cand->args;
5262   tree first_arg = cand->first_arg;
5263   conversion **convs = cand->convs;
5264   conversion *conv;
5265   tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5266   int parmlen;
5267   tree val;
5268   int i = 0;
5269   int j = 0;
5270   unsigned int arg_index = 0;
5271   int is_method = 0;
5272   int nargs;
5273   tree *argarray;
5274   bool already_used = false;
5275
5276   /* In a template, there is no need to perform all of the work that
5277      is normally done.  We are only interested in the type of the call
5278      expression, i.e., the return type of the function.  Any semantic
5279      errors will be deferred until the template is instantiated.  */
5280   if (processing_template_decl)
5281     {
5282       tree expr;
5283       tree return_type;
5284       const tree *argarray;
5285       unsigned int nargs;
5286
5287       return_type = TREE_TYPE (TREE_TYPE (fn));
5288       nargs = VEC_length (tree, args);
5289       if (first_arg == NULL_TREE)
5290         argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
5291       else
5292         {
5293           tree *alcarray;
5294           unsigned int ix;
5295           tree arg;
5296
5297           ++nargs;
5298           alcarray = XALLOCAVEC (tree, nargs);
5299           alcarray[0] = first_arg;
5300           for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
5301             alcarray[ix + 1] = arg;
5302           argarray = alcarray;
5303         }
5304       expr = build_call_array (return_type, build_addr_func (fn), nargs,
5305                                argarray);
5306       if (TREE_THIS_VOLATILE (fn) && cfun)
5307         current_function_returns_abnormally = 1;
5308       if (!VOID_TYPE_P (return_type))
5309         require_complete_type (return_type);
5310       return convert_from_reference (expr);
5311     }
5312
5313   /* Give any warnings we noticed during overload resolution.  */
5314   if (cand->warnings)
5315     {
5316       struct candidate_warning *w;
5317       for (w = cand->warnings; w; w = w->next)
5318         joust (cand, w->loser, 1);
5319     }
5320
5321   /* Make =delete work with SFINAE.  */
5322   if (DECL_DELETED_FN (fn) && !(complain & tf_error))
5323     return error_mark_node;
5324
5325   if (DECL_FUNCTION_MEMBER_P (fn))
5326     {
5327       /* If FN is a template function, two cases must be considered.
5328          For example:
5329
5330            struct A {
5331              protected:
5332                template <class T> void f();
5333            };
5334            template <class T> struct B {
5335              protected:
5336                void g();
5337            };
5338            struct C : A, B<int> {
5339              using A::f;        // #1
5340              using B<int>::g;   // #2
5341            };
5342
5343          In case #1 where `A::f' is a member template, DECL_ACCESS is
5344          recorded in the primary template but not in its specialization.
5345          We check access of FN using its primary template.
5346
5347          In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
5348          because it is a member of class template B, DECL_ACCESS is
5349          recorded in the specialization `B<int>::g'.  We cannot use its
5350          primary template because `B<T>::g' and `B<int>::g' may have
5351          different access.  */
5352       if (DECL_TEMPLATE_INFO (fn)
5353           && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
5354         perform_or_defer_access_check (cand->access_path,
5355                                        DECL_TI_TEMPLATE (fn), fn);
5356       else
5357         perform_or_defer_access_check (cand->access_path, fn, fn);
5358     }
5359
5360   /* Find maximum size of vector to hold converted arguments.  */
5361   parmlen = list_length (parm);
5362   nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
5363   if (parmlen > nargs)
5364     nargs = parmlen;
5365   argarray = (tree *) alloca (nargs * sizeof (tree));
5366
5367   /* The implicit parameters to a constructor are not considered by overload
5368      resolution, and must be of the proper type.  */
5369   if (DECL_CONSTRUCTOR_P (fn))
5370     {
5371       if (first_arg != NULL_TREE)
5372         {
5373           argarray[j++] = first_arg;
5374           first_arg = NULL_TREE;
5375         }
5376       else
5377         {
5378           argarray[j++] = VEC_index (tree, args, arg_index);
5379           ++arg_index;
5380         }
5381       parm = TREE_CHAIN (parm);
5382       /* We should never try to call the abstract constructor.  */
5383       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
5384
5385       if (DECL_HAS_VTT_PARM_P (fn))
5386         {
5387           argarray[j++] = VEC_index (tree, args, arg_index);
5388           ++arg_index;
5389           parm = TREE_CHAIN (parm);
5390         }
5391     }
5392   /* Bypass access control for 'this' parameter.  */
5393   else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5394     {
5395       tree parmtype = TREE_VALUE (parm);
5396       tree arg = (first_arg != NULL_TREE
5397                   ? first_arg
5398                   : VEC_index (tree, args, arg_index));
5399       tree argtype = TREE_TYPE (arg);
5400       tree converted_arg;
5401       tree base_binfo;
5402
5403       if (convs[i]->bad_p)
5404         {
5405           if (complain & tf_error)
5406             permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
5407                        TREE_TYPE (argtype), fn);
5408           else
5409             return error_mark_node;
5410         }
5411
5412       /* [class.mfct.nonstatic]: If a nonstatic member function of a class
5413          X is called for an object that is not of type X, or of a type
5414          derived from X, the behavior is undefined.
5415
5416          So we can assume that anything passed as 'this' is non-null, and
5417          optimize accordingly.  */
5418       gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
5419       /* Convert to the base in which the function was declared.  */
5420       gcc_assert (cand->conversion_path != NULL_TREE);
5421       converted_arg = build_base_path (PLUS_EXPR,
5422                                        arg,
5423                                        cand->conversion_path,
5424                                        1);
5425       /* Check that the base class is accessible.  */
5426       if (!accessible_base_p (TREE_TYPE (argtype),
5427                               BINFO_TYPE (cand->conversion_path), true))
5428         error ("%qT is not an accessible base of %qT",
5429                BINFO_TYPE (cand->conversion_path),
5430                TREE_TYPE (argtype));
5431       /* If fn was found by a using declaration, the conversion path
5432          will be to the derived class, not the base declaring fn. We
5433          must convert from derived to base.  */
5434       base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
5435                                 TREE_TYPE (parmtype), ba_unique, NULL);
5436       converted_arg = build_base_path (PLUS_EXPR, converted_arg,
5437                                        base_binfo, 1);
5438
5439       argarray[j++] = converted_arg;
5440       parm = TREE_CHAIN (parm);
5441       if (first_arg != NULL_TREE)
5442         first_arg = NULL_TREE;
5443       else
5444         ++arg_index;
5445       ++i;
5446       is_method = 1;
5447     }
5448
5449   gcc_assert (first_arg == NULL_TREE);
5450   for (; arg_index < VEC_length (tree, args) && parm;
5451        parm = TREE_CHAIN (parm), ++arg_index, ++i)
5452     {
5453       tree type = TREE_VALUE (parm);
5454
5455       conv = convs[i];
5456
5457       /* Don't make a copy here if build_call is going to.  */
5458       if (conv->kind == ck_rvalue
5459           && COMPLETE_TYPE_P (complete_type (type))
5460           && !TREE_ADDRESSABLE (type))
5461         conv = conv->u.next;
5462
5463       val = convert_like_with_context
5464         (conv, VEC_index (tree, args, arg_index), fn, i - is_method,
5465          complain);
5466
5467       val = convert_for_arg_passing (type, val);
5468       if (val == error_mark_node)
5469         return error_mark_node;
5470       else
5471         argarray[j++] = val;
5472     }
5473
5474   /* Default arguments */
5475   for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5476     argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5477                                          TREE_PURPOSE (parm),
5478                                          fn, i - is_method);
5479   /* Ellipsis */
5480   for (; arg_index < VEC_length (tree, args); ++arg_index)
5481     {
5482       tree a = VEC_index (tree, args, arg_index);
5483       if (magic_varargs_p (fn))
5484         /* Do no conversions for magic varargs.  */;
5485       else
5486         a = convert_arg_to_ellipsis (a);
5487       argarray[j++] = a;
5488     }
5489
5490   gcc_assert (j <= nargs);
5491   nargs = j;
5492
5493   check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5494                             nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5495
5496   /* Avoid actually calling copy constructors and copy assignment operators,
5497      if possible.  */
5498
5499   if (! flag_elide_constructors)
5500     /* Do things the hard way.  */;
5501   else if (cand->num_convs == 1
5502            && (DECL_COPY_CONSTRUCTOR_P (fn)
5503                || DECL_MOVE_CONSTRUCTOR_P (fn)))
5504     {
5505       tree targ;
5506       tree arg = argarray[num_artificial_parms_for (fn)];
5507       tree fa;
5508
5509       /* Pull out the real argument, disregarding const-correctness.  */
5510       targ = arg;
5511       while (CONVERT_EXPR_P (targ)
5512              || TREE_CODE (targ) == NON_LVALUE_EXPR)
5513         targ = TREE_OPERAND (targ, 0);
5514       if (TREE_CODE (targ) == ADDR_EXPR)
5515         {
5516           targ = TREE_OPERAND (targ, 0);
5517           if (!same_type_ignoring_top_level_qualifiers_p
5518               (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5519             targ = NULL_TREE;
5520         }
5521       else
5522         targ = NULL_TREE;
5523
5524       if (targ)
5525         arg = targ;
5526       else
5527         arg = cp_build_indirect_ref (arg, 0, complain);
5528
5529       if (TREE_CODE (arg) == TARGET_EXPR
5530           && TARGET_EXPR_LIST_INIT_P (arg))
5531         {
5532           /* Copy-list-initialization doesn't require the copy constructor
5533              to be defined.  */
5534         }
5535       /* [class.copy]: the copy constructor is implicitly defined even if
5536          the implementation elided its use.  */
5537       else if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
5538         {
5539           mark_used (fn);
5540           already_used = true;
5541         }
5542
5543       /* If we're creating a temp and we already have one, don't create a
5544          new one.  If we're not creating a temp but we get one, use
5545          INIT_EXPR to collapse the temp into our target.  Otherwise, if the
5546          ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5547          temp or an INIT_EXPR otherwise.  */
5548       fa = (cand->first_arg != NULL_TREE
5549             ? cand->first_arg
5550             : VEC_index (tree, args, 0));
5551       if (integer_zerop (fa))
5552         {
5553           if (TREE_CODE (arg) == TARGET_EXPR)
5554             return arg;
5555           else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5556             return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5557         }
5558       else if (TREE_CODE (arg) == TARGET_EXPR
5559                || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5560                    && !move_fn_p (fn)))
5561         {
5562           tree to = stabilize_reference (cp_build_indirect_ref (fa, 0,
5563                                                                 complain));
5564
5565           val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5566           return val;
5567         }
5568     }
5569   else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5570            && copy_fn_p (fn)
5571            && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5572     {
5573       tree to = stabilize_reference
5574         (cp_build_indirect_ref (argarray[0], 0, complain));
5575       tree type = TREE_TYPE (to);
5576       tree as_base = CLASSTYPE_AS_BASE (type);
5577       tree arg = argarray[1];
5578
5579       if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5580         {
5581           arg = cp_build_indirect_ref (arg, 0, complain);
5582           val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5583         }
5584       else
5585         {
5586           /* We must only copy the non-tail padding parts.
5587              Use __builtin_memcpy for the bitwise copy.
5588              FIXME fix 22488 so we can go back to using MODIFY_EXPR
5589              instead of an explicit call to memcpy.  */
5590
5591           tree arg0, arg1, arg2, t;
5592           tree test = NULL_TREE;
5593
5594           arg2 = TYPE_SIZE_UNIT (as_base);
5595           arg1 = arg;
5596           arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5597
5598           if (!(optimize && flag_tree_ter))
5599             {
5600               /* When TER is off get_pointer_alignment returns 0, so a call
5601                  to __builtin_memcpy is expanded as a call to memcpy, which
5602                  is invalid with identical args.  When TER is on it is
5603                  expanded as a block move, which should be safe.  */
5604               arg0 = save_expr (arg0);
5605               arg1 = save_expr (arg1);
5606               test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5607             }
5608           t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5609           t = build_call_n (t, 3, arg0, arg1, arg2);
5610
5611           t = convert (TREE_TYPE (arg0), t);
5612           if (test)
5613             t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5614           val = cp_build_indirect_ref (t, 0, complain);
5615           TREE_NO_WARNING (val) = 1;
5616         }
5617
5618       return val;
5619     }
5620
5621   if (!already_used)
5622     mark_used (fn);
5623
5624   if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5625     {
5626       tree t;
5627       tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5628                                 DECL_CONTEXT (fn),
5629                                 ba_any, NULL);
5630       gcc_assert (binfo && binfo != error_mark_node);
5631
5632       /* Warn about deprecated virtual functions now, since we're about
5633          to throw away the decl.  */
5634       if (TREE_DEPRECATED (fn))
5635         warn_deprecated_use (fn, NULL_TREE);
5636
5637       argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5638       if (TREE_SIDE_EFFECTS (argarray[0]))
5639         argarray[0] = save_expr (argarray[0]);
5640       t = build_pointer_type (TREE_TYPE (fn));
5641       if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5642         fn = build_java_interface_fn_ref (fn, argarray[0]);
5643       else
5644         fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5645       TREE_TYPE (fn) = t;
5646     }
5647   else
5648     fn = build_addr_func (fn);
5649
5650   return build_cxx_call (fn, nargs, argarray);
5651 }
5652
5653 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5654    This function performs no overload resolution, conversion, or other
5655    high-level operations.  */
5656
5657 tree
5658 build_cxx_call (tree fn, int nargs, tree *argarray)
5659 {
5660   tree fndecl;
5661
5662   fn = build_call_a (fn, nargs, argarray);
5663
5664   /* If this call might throw an exception, note that fact.  */
5665   fndecl = get_callee_fndecl (fn);
5666   if ((!fndecl || !TREE_NOTHROW (fndecl))
5667       && at_function_scope_p ()
5668       && cfun)
5669     cp_function_chain->can_throw = 1;
5670
5671   /* Check that arguments to builtin functions match the expectations.  */
5672   if (fndecl
5673       && DECL_BUILT_IN (fndecl)
5674       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5675       && !check_builtin_function_arguments (fndecl, nargs, argarray))
5676     return error_mark_node;
5677
5678   /* Some built-in function calls will be evaluated at compile-time in
5679      fold ().  */
5680   fn = fold_if_not_in_template (fn);
5681
5682   if (VOID_TYPE_P (TREE_TYPE (fn)))
5683     return fn;
5684
5685   fn = require_complete_type (fn);
5686   if (fn == error_mark_node)
5687     return error_mark_node;
5688
5689   if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
5690     fn = build_cplus_new (TREE_TYPE (fn), fn);
5691   return convert_from_reference (fn);
5692 }
5693
5694 static GTY(()) tree java_iface_lookup_fn;
5695
5696 /* Make an expression which yields the address of the Java interface
5697    method FN.  This is achieved by generating a call to libjava's
5698    _Jv_LookupInterfaceMethodIdx().  */
5699
5700 static tree
5701 build_java_interface_fn_ref (tree fn, tree instance)
5702 {
5703   tree lookup_fn, method, idx;
5704   tree klass_ref, iface, iface_ref;
5705   int i;
5706
5707   if (!java_iface_lookup_fn)
5708     {
5709       tree endlink = build_void_list_node ();
5710       tree t = tree_cons (NULL_TREE, ptr_type_node,
5711                           tree_cons (NULL_TREE, ptr_type_node,
5712                                      tree_cons (NULL_TREE, java_int_type_node,
5713                                                 endlink)));
5714       java_iface_lookup_fn
5715         = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5716                                 build_function_type (ptr_type_node, t),
5717                                 0, NOT_BUILT_IN, NULL, NULL_TREE);
5718     }
5719
5720   /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5721      This is the first entry in the vtable.  */
5722   klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, 0,
5723                                                      tf_warning_or_error),
5724                               integer_zero_node);
5725
5726   /* Get the java.lang.Class pointer for the interface being called.  */
5727   iface = DECL_CONTEXT (fn);
5728   iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5729   if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5730       || DECL_CONTEXT (iface_ref) != iface)
5731     {
5732       error ("could not find class$ field in java interface type %qT",
5733                 iface);
5734       return error_mark_node;
5735     }
5736   iface_ref = build_address (iface_ref);
5737   iface_ref = convert (build_pointer_type (iface), iface_ref);
5738
5739   /* Determine the itable index of FN.  */
5740   i = 1;
5741   for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5742     {
5743       if (!DECL_VIRTUAL_P (method))
5744         continue;
5745       if (fn == method)
5746         break;
5747       i++;
5748     }
5749   idx = build_int_cst (NULL_TREE, i);
5750
5751   lookup_fn = build1 (ADDR_EXPR,
5752                       build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5753                       java_iface_lookup_fn);
5754   return build_call_nary (ptr_type_node, lookup_fn,
5755                           3, klass_ref, iface_ref, idx);
5756 }
5757
5758 /* Returns the value to use for the in-charge parameter when making a
5759    call to a function with the indicated NAME.
5760
5761    FIXME:Can't we find a neater way to do this mapping?  */
5762
5763 tree
5764 in_charge_arg_for_name (tree name)
5765 {
5766  if (name == base_ctor_identifier
5767       || name == base_dtor_identifier)
5768     return integer_zero_node;
5769   else if (name == complete_ctor_identifier)
5770     return integer_one_node;
5771   else if (name == complete_dtor_identifier)
5772     return integer_two_node;
5773   else if (name == deleting_dtor_identifier)
5774     return integer_three_node;
5775
5776   /* This function should only be called with one of the names listed
5777      above.  */
5778   gcc_unreachable ();
5779   return NULL_TREE;
5780 }
5781
5782 /* Build a call to a constructor, destructor, or an assignment
5783    operator for INSTANCE, an expression with class type.  NAME
5784    indicates the special member function to call; *ARGS are the
5785    arguments.  ARGS may be NULL.  This may change ARGS.  BINFO
5786    indicates the base of INSTANCE that is to be passed as the `this'
5787    parameter to the member function called.
5788
5789    FLAGS are the LOOKUP_* flags to use when processing the call.
5790
5791    If NAME indicates a complete object constructor, INSTANCE may be
5792    NULL_TREE.  In this case, the caller will call build_cplus_new to
5793    store the newly constructed object into a VAR_DECL.  */
5794
5795 tree
5796 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
5797                            tree binfo, int flags, tsubst_flags_t complain)
5798 {
5799   tree fns;
5800   /* The type of the subobject to be constructed or destroyed.  */
5801   tree class_type;
5802   VEC(tree,gc) *allocated = NULL;
5803   tree ret;
5804
5805   gcc_assert (name == complete_ctor_identifier
5806               || name == base_ctor_identifier
5807               || name == complete_dtor_identifier
5808               || name == base_dtor_identifier
5809               || name == deleting_dtor_identifier
5810               || name == ansi_assopname (NOP_EXPR));
5811   if (TYPE_P (binfo))
5812     {
5813       /* Resolve the name.  */
5814       if (!complete_type_or_else (binfo, NULL_TREE))
5815         return error_mark_node;
5816
5817       binfo = TYPE_BINFO (binfo);
5818     }
5819
5820   gcc_assert (binfo != NULL_TREE);
5821
5822   class_type = BINFO_TYPE (binfo);
5823
5824   /* Handle the special case where INSTANCE is NULL_TREE.  */
5825   if (name == complete_ctor_identifier && !instance)
5826     {
5827       instance = build_int_cst (build_pointer_type (class_type), 0);
5828       instance = build1 (INDIRECT_REF, class_type, instance);
5829     }
5830   else
5831     {
5832       if (name == complete_dtor_identifier
5833           || name == base_dtor_identifier
5834           || name == deleting_dtor_identifier)
5835         gcc_assert (args == NULL || VEC_empty (tree, *args));
5836
5837       /* Convert to the base class, if necessary.  */
5838       if (!same_type_ignoring_top_level_qualifiers_p
5839           (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5840         {
5841           if (name != ansi_assopname (NOP_EXPR))
5842             /* For constructors and destructors, either the base is
5843                non-virtual, or it is virtual but we are doing the
5844                conversion from a constructor or destructor for the
5845                complete object.  In either case, we can convert
5846                statically.  */
5847             instance = convert_to_base_statically (instance, binfo);
5848           else
5849             /* However, for assignment operators, we must convert
5850                dynamically if the base is virtual.  */
5851             instance = build_base_path (PLUS_EXPR, instance,
5852                                         binfo, /*nonnull=*/1);
5853         }
5854     }
5855
5856   gcc_assert (instance != NULL_TREE);
5857
5858   fns = lookup_fnfields (binfo, name, 1);
5859
5860   /* When making a call to a constructor or destructor for a subobject
5861      that uses virtual base classes, pass down a pointer to a VTT for
5862      the subobject.  */
5863   if ((name == base_ctor_identifier
5864        || name == base_dtor_identifier)
5865       && CLASSTYPE_VBASECLASSES (class_type))
5866     {
5867       tree vtt;
5868       tree sub_vtt;
5869
5870       /* If the current function is a complete object constructor
5871          or destructor, then we fetch the VTT directly.
5872          Otherwise, we look it up using the VTT we were given.  */
5873       vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5874       vtt = decay_conversion (vtt);
5875       vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5876                     build2 (EQ_EXPR, boolean_type_node,
5877                             current_in_charge_parm, integer_zero_node),
5878                     current_vtt_parm,
5879                     vtt);
5880       gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5881       sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
5882                         BINFO_SUBVTT_INDEX (binfo));
5883
5884       if (args == NULL)
5885         {
5886           allocated = make_tree_vector ();
5887           args = &allocated;
5888         }
5889
5890       VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
5891     }
5892
5893   ret = build_new_method_call (instance, fns, args,
5894                                TYPE_BINFO (BINFO_TYPE (binfo)),
5895                                flags, /*fn=*/NULL,
5896                                complain);
5897
5898   if (allocated != NULL)
5899     release_tree_vector (allocated);
5900
5901   return ret;
5902 }
5903
5904 /* Return the NAME, as a C string.  The NAME indicates a function that
5905    is a member of TYPE.  *FREE_P is set to true if the caller must
5906    free the memory returned.
5907
5908    Rather than go through all of this, we should simply set the names
5909    of constructors and destructors appropriately, and dispense with
5910    ctor_identifier, dtor_identifier, etc.  */
5911
5912 static char *
5913 name_as_c_string (tree name, tree type, bool *free_p)
5914 {
5915   char *pretty_name;
5916
5917   /* Assume that we will not allocate memory.  */
5918   *free_p = false;
5919   /* Constructors and destructors are special.  */
5920   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5921     {
5922       pretty_name
5923         = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
5924       /* For a destructor, add the '~'.  */
5925       if (name == complete_dtor_identifier
5926           || name == base_dtor_identifier
5927           || name == deleting_dtor_identifier)
5928         {
5929           pretty_name = concat ("~", pretty_name, NULL);
5930           /* Remember that we need to free the memory allocated.  */
5931           *free_p = true;
5932         }
5933     }
5934   else if (IDENTIFIER_TYPENAME_P (name))
5935     {
5936       pretty_name = concat ("operator ",
5937                             type_as_string_translate (TREE_TYPE (name),
5938                                                       TFF_PLAIN_IDENTIFIER),
5939                             NULL);
5940       /* Remember that we need to free the memory allocated.  */
5941       *free_p = true;
5942     }
5943   else
5944     pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
5945
5946   return pretty_name;
5947 }
5948
5949 /* Build a call to "INSTANCE.FN (ARGS)".  If FN_P is non-NULL, it will
5950    be set, upon return, to the function called.  ARGS may be NULL.
5951    This may change ARGS.  */
5952
5953 tree
5954 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
5955                        tree conversion_path, int flags,
5956                        tree *fn_p, tsubst_flags_t complain)
5957 {
5958   struct z_candidate *candidates = 0, *cand;
5959   tree explicit_targs = NULL_TREE;
5960   tree basetype = NULL_TREE;
5961   tree access_binfo;
5962   tree optype;
5963   tree first_mem_arg = NULL_TREE;
5964   tree instance_ptr;
5965   tree name;
5966   bool skip_first_for_error;
5967   VEC(tree,gc) *user_args;
5968   tree call;
5969   tree fn;
5970   tree class_type;
5971   int template_only = 0;
5972   bool any_viable_p;
5973   tree orig_instance;
5974   tree orig_fns;
5975   VEC(tree,gc) *orig_args = NULL;
5976   void *p;
5977
5978   gcc_assert (instance != NULL_TREE);
5979
5980   /* We don't know what function we're going to call, yet.  */
5981   if (fn_p)
5982     *fn_p = NULL_TREE;
5983
5984   if (error_operand_p (instance)
5985       || error_operand_p (fns))
5986     return error_mark_node;
5987
5988   if (!BASELINK_P (fns))
5989     {
5990       if (complain & tf_error)
5991         error ("call to non-function %qD", fns);
5992       return error_mark_node;
5993     }
5994
5995   orig_instance = instance;
5996   orig_fns = fns;
5997
5998   /* Dismantle the baselink to collect all the information we need.  */
5999   if (!conversion_path)
6000     conversion_path = BASELINK_BINFO (fns);
6001   access_binfo = BASELINK_ACCESS_BINFO (fns);
6002   optype = BASELINK_OPTYPE (fns);
6003   fns = BASELINK_FUNCTIONS (fns);
6004   if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6005     {
6006       explicit_targs = TREE_OPERAND (fns, 1);
6007       fns = TREE_OPERAND (fns, 0);
6008       template_only = 1;
6009     }
6010   gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6011               || TREE_CODE (fns) == TEMPLATE_DECL
6012               || TREE_CODE (fns) == OVERLOAD);
6013   fn = get_first_fn (fns);
6014   name = DECL_NAME (fn);
6015
6016   basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6017   gcc_assert (CLASS_TYPE_P (basetype));
6018
6019   if (processing_template_decl)
6020     {
6021       orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6022       instance = build_non_dependent_expr (instance);
6023       if (args != NULL)
6024         make_args_non_dependent (*args);
6025     }
6026
6027   /* Figure out whether to skip the first argument for the error
6028      message we will display to users if an error occurs.  We don't
6029      want to display any compiler-generated arguments.  The "this"
6030      pointer hasn't been added yet.  However, we must remove the VTT
6031      pointer if this is a call to a base-class constructor or
6032      destructor.  */
6033   skip_first_for_error = false;
6034   user_args = args == NULL ? NULL : *args;
6035   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6036     {
6037       /* Callers should explicitly indicate whether they want to construct
6038          the complete object or just the part without virtual bases.  */
6039       gcc_assert (name != ctor_identifier);
6040       /* Similarly for destructors.  */
6041       gcc_assert (name != dtor_identifier);
6042       /* Remove the VTT pointer, if present.  */
6043       if ((name == base_ctor_identifier || name == base_dtor_identifier)
6044           && CLASSTYPE_VBASECLASSES (basetype))
6045         skip_first_for_error = true;
6046     }
6047
6048   /* Process the argument list.  */
6049   if (args != NULL && *args != NULL)
6050     {
6051       *args = resolve_args (*args);
6052       if (*args == NULL)
6053         return error_mark_node;
6054     }
6055
6056   instance_ptr = build_this (instance);
6057
6058   /* It's OK to call destructors and constructors on cv-qualified objects.
6059      Therefore, convert the INSTANCE_PTR to the unqualified type, if
6060      necessary.  */
6061   if (DECL_DESTRUCTOR_P (fn)
6062       || DECL_CONSTRUCTOR_P (fn))
6063     {
6064       tree type = build_pointer_type (basetype);
6065       if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6066         instance_ptr = build_nop (type, instance_ptr);
6067     }
6068   if (DECL_DESTRUCTOR_P (fn))
6069     name = complete_dtor_identifier;
6070
6071   /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6072      initializer, not T({ }).  If the type doesn't have a list ctor,
6073      break apart the list into separate ctor args.  */
6074   if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6075       && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6076       && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0))
6077       && !TYPE_HAS_LIST_CTOR (basetype))
6078     {
6079       gcc_assert (VEC_length (tree, *args) == 1);
6080       *args = ctor_to_vec (VEC_index (tree, *args, 0));
6081     }
6082
6083   class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
6084   first_mem_arg = instance_ptr;
6085
6086   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6087   p = conversion_obstack_alloc (0);
6088
6089   for (fn = fns; fn; fn = OVL_NEXT (fn))
6090     {
6091       tree t = OVL_CURRENT (fn);
6092       tree this_first_arg;
6093
6094       /* We can end up here for copy-init of same or base class.  */
6095       if ((flags & LOOKUP_ONLYCONVERTING)
6096           && DECL_NONCONVERTING_P (t))
6097         continue;
6098
6099       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
6100         this_first_arg = first_mem_arg;
6101       else
6102         this_first_arg = NULL_TREE;
6103
6104       if (TREE_CODE (t) == TEMPLATE_DECL)
6105         /* A member template.  */
6106         add_template_candidate (&candidates, t,
6107                                 class_type,
6108                                 explicit_targs,
6109                                 this_first_arg,
6110                                 args == NULL ? NULL : *args,
6111                                 optype,
6112                                 access_binfo,
6113                                 conversion_path,
6114                                 flags,
6115                                 DEDUCE_CALL);
6116       else if (! template_only)
6117         add_function_candidate (&candidates, t,
6118                                 class_type,
6119                                 this_first_arg,
6120                                 args == NULL ? NULL : *args,
6121                                 access_binfo,
6122                                 conversion_path,
6123                                 flags);
6124     }
6125
6126   candidates = splice_viable (candidates, pedantic, &any_viable_p);
6127   if (!any_viable_p)
6128     {
6129       if (complain & tf_error)
6130         {
6131           if (!COMPLETE_TYPE_P (basetype))
6132             cxx_incomplete_type_error (instance_ptr, basetype);
6133           else
6134             {
6135               char *pretty_name;
6136               bool free_p;
6137               tree arglist;
6138
6139               pretty_name = name_as_c_string (name, basetype, &free_p);
6140               arglist = build_tree_list_vec (user_args);
6141               if (skip_first_for_error)
6142                 arglist = TREE_CHAIN (arglist);
6143               error ("no matching function for call to %<%T::%s(%A)%#V%>",
6144                      basetype, pretty_name, arglist,
6145                      TREE_TYPE (TREE_TYPE (instance_ptr)));
6146               if (free_p)
6147                 free (pretty_name);
6148             }
6149           print_z_candidates (candidates);
6150         }
6151       call = error_mark_node;
6152     }
6153   else
6154     {
6155       cand = tourney (candidates);
6156       if (cand == 0)
6157         {
6158           char *pretty_name;
6159           bool free_p;
6160           tree arglist;
6161
6162           if (complain & tf_error)
6163             {
6164               pretty_name = name_as_c_string (name, basetype, &free_p);
6165               arglist = build_tree_list_vec (user_args);
6166               if (skip_first_for_error)
6167                 arglist = TREE_CHAIN (arglist);
6168               error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6169                      arglist);
6170               print_z_candidates (candidates);
6171               if (free_p)
6172                 free (pretty_name);
6173             }
6174           call = error_mark_node;
6175         }
6176       else
6177         {
6178           fn = cand->fn;
6179
6180           if (!(flags & LOOKUP_NONVIRTUAL)
6181               && DECL_PURE_VIRTUAL_P (fn)
6182               && instance == current_class_ref
6183               && (DECL_CONSTRUCTOR_P (current_function_decl)
6184                   || DECL_DESTRUCTOR_P (current_function_decl))
6185               && (complain & tf_warning))
6186             /* This is not an error, it is runtime undefined
6187                behavior.  */
6188             warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6189                       "abstract virtual %q#D called from constructor"
6190                       : "abstract virtual %q#D called from destructor"),
6191                      fn);
6192
6193           if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6194               && is_dummy_object (instance_ptr))
6195             {
6196               if (complain & tf_error)
6197                 error ("cannot call member function %qD without object",
6198                        fn);
6199               call = error_mark_node;
6200             }
6201           else
6202             {
6203               if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6204                   && resolves_to_fixed_type_p (instance, 0))
6205                 flags |= LOOKUP_NONVIRTUAL;
6206               /* Now we know what function is being called.  */
6207               if (fn_p)
6208                 *fn_p = fn;
6209               /* Build the actual CALL_EXPR.  */
6210               call = build_over_call (cand, flags, complain);
6211               /* In an expression of the form `a->f()' where `f' turns
6212                  out to be a static member function, `a' is
6213                  none-the-less evaluated.  */
6214               if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6215                   && !is_dummy_object (instance_ptr)
6216                   && TREE_SIDE_EFFECTS (instance_ptr))
6217                 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6218                                instance_ptr, call);
6219               else if (call != error_mark_node
6220                        && DECL_DESTRUCTOR_P (cand->fn)
6221                        && !VOID_TYPE_P (TREE_TYPE (call)))
6222                 /* An explicit call of the form "x->~X()" has type
6223                    "void".  However, on platforms where destructors
6224                    return "this" (i.e., those where
6225                    targetm.cxx.cdtor_returns_this is true), such calls
6226                    will appear to have a return value of pointer type
6227                    to the low-level call machinery.  We do not want to
6228                    change the low-level machinery, since we want to be
6229                    able to optimize "delete f()" on such platforms as
6230                    "operator delete(~X(f()))" (rather than generating
6231                    "t = f(), ~X(t), operator delete (t)").  */
6232                 call = build_nop (void_type_node, call);
6233             }
6234         }
6235     }
6236
6237   if (processing_template_decl && call != error_mark_node)
6238     {
6239       bool cast_to_void = false;
6240
6241       if (TREE_CODE (call) == COMPOUND_EXPR)
6242         call = TREE_OPERAND (call, 1);
6243       else if (TREE_CODE (call) == NOP_EXPR)
6244         {
6245           cast_to_void = true;
6246           call = TREE_OPERAND (call, 0);
6247         }
6248       if (TREE_CODE (call) == INDIRECT_REF)
6249         call = TREE_OPERAND (call, 0);
6250       call = (build_min_non_dep_call_vec
6251               (call,
6252                build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6253                           orig_instance, orig_fns, NULL_TREE),
6254                orig_args));
6255       call = convert_from_reference (call);
6256       if (cast_to_void)
6257         call = build_nop (void_type_node, call);
6258     }
6259
6260  /* Free all the conversions we allocated.  */
6261   obstack_free (&conversion_obstack, p);
6262
6263   if (orig_args != NULL)
6264     release_tree_vector (orig_args);
6265
6266   return call;
6267 }
6268
6269 /* Returns true iff standard conversion sequence ICS1 is a proper
6270    subsequence of ICS2.  */
6271
6272 static bool
6273 is_subseq (conversion *ics1, conversion *ics2)
6274 {
6275   /* We can assume that a conversion of the same code
6276      between the same types indicates a subsequence since we only get
6277      here if the types we are converting from are the same.  */
6278
6279   while (ics1->kind == ck_rvalue
6280          || ics1->kind == ck_lvalue)
6281     ics1 = ics1->u.next;
6282
6283   while (1)
6284     {
6285       while (ics2->kind == ck_rvalue
6286              || ics2->kind == ck_lvalue)
6287         ics2 = ics2->u.next;
6288
6289       if (ics2->kind == ck_user
6290           || ics2->kind == ck_ambig
6291           || ics2->kind == ck_identity)
6292         /* At this point, ICS1 cannot be a proper subsequence of
6293            ICS2.  We can get a USER_CONV when we are comparing the
6294            second standard conversion sequence of two user conversion
6295            sequences.  */
6296         return false;
6297
6298       ics2 = ics2->u.next;
6299
6300       if (ics2->kind == ics1->kind
6301           && same_type_p (ics2->type, ics1->type)
6302           && same_type_p (ics2->u.next->type,
6303                           ics1->u.next->type))
6304         return true;
6305     }
6306 }
6307
6308 /* Returns nonzero iff DERIVED is derived from BASE.  The inputs may
6309    be any _TYPE nodes.  */
6310
6311 bool
6312 is_properly_derived_from (tree derived, tree base)
6313 {
6314   if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6315     return false;
6316
6317   /* We only allow proper derivation here.  The DERIVED_FROM_P macro
6318      considers every class derived from itself.  */
6319   return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6320           && DERIVED_FROM_P (base, derived));
6321 }
6322
6323 /* We build the ICS for an implicit object parameter as a pointer
6324    conversion sequence.  However, such a sequence should be compared
6325    as if it were a reference conversion sequence.  If ICS is the
6326    implicit conversion sequence for an implicit object parameter,
6327    modify it accordingly.  */
6328
6329 static void
6330 maybe_handle_implicit_object (conversion **ics)
6331 {
6332   if ((*ics)->this_p)
6333     {
6334       /* [over.match.funcs]
6335
6336          For non-static member functions, the type of the
6337          implicit object parameter is "reference to cv X"
6338          where X is the class of which the function is a
6339          member and cv is the cv-qualification on the member
6340          function declaration.  */
6341       conversion *t = *ics;
6342       tree reference_type;
6343
6344       /* The `this' parameter is a pointer to a class type.  Make the
6345          implicit conversion talk about a reference to that same class
6346          type.  */
6347       reference_type = TREE_TYPE (t->type);
6348       reference_type = build_reference_type (reference_type);
6349
6350       if (t->kind == ck_qual)
6351         t = t->u.next;
6352       if (t->kind == ck_ptr)
6353         t = t->u.next;
6354       t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6355       t = direct_reference_binding (reference_type, t);
6356       t->this_p = 1;
6357       t->rvaluedness_matches_p = 0;
6358       *ics = t;
6359     }
6360 }
6361
6362 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6363    and return the initial reference binding conversion. Otherwise,
6364    leave *ICS unchanged and return NULL.  */
6365
6366 static conversion *
6367 maybe_handle_ref_bind (conversion **ics)
6368 {
6369   if ((*ics)->kind == ck_ref_bind)
6370     {
6371       conversion *old_ics = *ics;
6372       *ics = old_ics->u.next;
6373       (*ics)->user_conv_p = old_ics->user_conv_p;
6374       (*ics)->bad_p = old_ics->bad_p;
6375       return old_ics;
6376     }
6377
6378   return NULL;
6379 }
6380
6381 /* Compare two implicit conversion sequences according to the rules set out in
6382    [over.ics.rank].  Return values:
6383
6384       1: ics1 is better than ics2
6385      -1: ics2 is better than ics1
6386       0: ics1 and ics2 are indistinguishable */
6387
6388 static int
6389 compare_ics (conversion *ics1, conversion *ics2)
6390 {
6391   tree from_type1;
6392   tree from_type2;
6393   tree to_type1;
6394   tree to_type2;
6395   tree deref_from_type1 = NULL_TREE;
6396   tree deref_from_type2 = NULL_TREE;
6397   tree deref_to_type1 = NULL_TREE;
6398   tree deref_to_type2 = NULL_TREE;
6399   conversion_rank rank1, rank2;
6400
6401   /* REF_BINDING is nonzero if the result of the conversion sequence
6402      is a reference type.   In that case REF_CONV is the reference
6403      binding conversion. */
6404   conversion *ref_conv1;
6405   conversion *ref_conv2;
6406
6407   /* Handle implicit object parameters.  */
6408   maybe_handle_implicit_object (&ics1);
6409   maybe_handle_implicit_object (&ics2);
6410
6411   /* Handle reference parameters.  */
6412   ref_conv1 = maybe_handle_ref_bind (&ics1);
6413   ref_conv2 = maybe_handle_ref_bind (&ics2);
6414
6415   /* [over.ics.rank]
6416
6417      When  comparing  the  basic forms of implicit conversion sequences (as
6418      defined in _over.best.ics_)
6419
6420      --a standard conversion sequence (_over.ics.scs_) is a better
6421        conversion sequence than a user-defined conversion sequence
6422        or an ellipsis conversion sequence, and
6423
6424      --a user-defined conversion sequence (_over.ics.user_) is a
6425        better conversion sequence than an ellipsis conversion sequence
6426        (_over.ics.ellipsis_).  */
6427   rank1 = CONVERSION_RANK (ics1);
6428   rank2 = CONVERSION_RANK (ics2);
6429
6430   if (rank1 > rank2)
6431     return -1;
6432   else if (rank1 < rank2)
6433     return 1;
6434
6435   if (rank1 == cr_bad)
6436     {
6437       /* XXX Isn't this an extension? */
6438       /* Both ICS are bad.  We try to make a decision based on what
6439          would have happened if they'd been good.  */
6440       if (ics1->user_conv_p > ics2->user_conv_p
6441           || ics1->rank  > ics2->rank)
6442         return -1;
6443       else if (ics1->user_conv_p < ics2->user_conv_p
6444                || ics1->rank < ics2->rank)
6445         return 1;
6446
6447       /* We couldn't make up our minds; try to figure it out below.  */
6448     }
6449
6450   if (ics1->ellipsis_p)
6451     /* Both conversions are ellipsis conversions.  */
6452     return 0;
6453
6454   /* User-defined  conversion sequence U1 is a better conversion sequence
6455      than another user-defined conversion sequence U2 if they contain the
6456      same user-defined conversion operator or constructor and if the sec-
6457      ond standard conversion sequence of U1 is  better  than  the  second
6458      standard conversion sequence of U2.  */
6459
6460   if (ics1->user_conv_p)
6461     {
6462       conversion *t1;
6463       conversion *t2;
6464
6465       for (t1 = ics1; t1->kind != ck_user && t1->kind != ck_list; t1 = t1->u.next)
6466         if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6467           return 0;
6468       for (t2 = ics2; t2->kind != ck_user && t2->kind != ck_list; t2 = t2->u.next)
6469         if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6470           return 0;
6471
6472       /* Conversion to std::initializer_list is better than other
6473          user-defined conversions.  */
6474       if (t1->kind == ck_list
6475           || t2->kind == ck_list)
6476         {
6477           if (t2->kind != ck_list)
6478             return 1;
6479           else if (t1->kind != ck_list)
6480             return -1;
6481           else
6482             return 0;
6483         }
6484
6485       if (t1->cand->fn != t2->cand->fn)
6486         return 0;
6487
6488       /* We can just fall through here, after setting up
6489          FROM_TYPE1 and FROM_TYPE2.  */
6490       from_type1 = t1->type;
6491       from_type2 = t2->type;
6492     }
6493   else
6494     {
6495       conversion *t1;
6496       conversion *t2;
6497
6498       /* We're dealing with two standard conversion sequences.
6499
6500          [over.ics.rank]
6501
6502          Standard conversion sequence S1 is a better conversion
6503          sequence than standard conversion sequence S2 if
6504
6505          --S1 is a proper subsequence of S2 (comparing the conversion
6506            sequences in the canonical form defined by _over.ics.scs_,
6507            excluding any Lvalue Transformation; the identity
6508            conversion sequence is considered to be a subsequence of
6509            any non-identity conversion sequence */
6510
6511       t1 = ics1;
6512       while (t1->kind != ck_identity)
6513         t1 = t1->u.next;
6514       from_type1 = t1->type;
6515
6516       t2 = ics2;
6517       while (t2->kind != ck_identity)
6518         t2 = t2->u.next;
6519       from_type2 = t2->type;
6520     }
6521
6522   /* One sequence can only be a subsequence of the other if they start with
6523      the same type.  They can start with different types when comparing the
6524      second standard conversion sequence in two user-defined conversion
6525      sequences.  */
6526   if (same_type_p (from_type1, from_type2))
6527     {
6528       if (is_subseq (ics1, ics2))
6529         return 1;
6530       if (is_subseq (ics2, ics1))
6531         return -1;
6532     }
6533
6534   /* [over.ics.rank]
6535
6536      Or, if not that,
6537
6538      --the rank of S1 is better than the rank of S2 (by the rules
6539        defined below):
6540
6541     Standard conversion sequences are ordered by their ranks: an Exact
6542     Match is a better conversion than a Promotion, which is a better
6543     conversion than a Conversion.
6544
6545     Two conversion sequences with the same rank are indistinguishable
6546     unless one of the following rules applies:
6547
6548     --A conversion that is not a conversion of a pointer, or pointer
6549       to member, to bool is better than another conversion that is such
6550       a conversion.
6551
6552     The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6553     so that we do not have to check it explicitly.  */
6554   if (ics1->rank < ics2->rank)
6555     return 1;
6556   else if (ics2->rank < ics1->rank)
6557     return -1;
6558
6559   to_type1 = ics1->type;
6560   to_type2 = ics2->type;
6561
6562   /* A conversion from scalar arithmetic type to complex is worse than a
6563      conversion between scalar arithmetic types.  */
6564   if (same_type_p (from_type1, from_type2)
6565       && ARITHMETIC_TYPE_P (from_type1)
6566       && ARITHMETIC_TYPE_P (to_type1)
6567       && ARITHMETIC_TYPE_P (to_type2)
6568       && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6569           != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6570     {
6571       if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6572         return -1;
6573       else
6574         return 1;
6575     }
6576
6577   if (TYPE_PTR_P (from_type1)
6578       && TYPE_PTR_P (from_type2)
6579       && TYPE_PTR_P (to_type1)
6580       && TYPE_PTR_P (to_type2))
6581     {
6582       deref_from_type1 = TREE_TYPE (from_type1);
6583       deref_from_type2 = TREE_TYPE (from_type2);
6584       deref_to_type1 = TREE_TYPE (to_type1);
6585       deref_to_type2 = TREE_TYPE (to_type2);
6586     }
6587   /* The rules for pointers to members A::* are just like the rules
6588      for pointers A*, except opposite: if B is derived from A then
6589      A::* converts to B::*, not vice versa.  For that reason, we
6590      switch the from_ and to_ variables here.  */
6591   else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6592             && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6593            || (TYPE_PTRMEMFUNC_P (from_type1)
6594                && TYPE_PTRMEMFUNC_P (from_type2)
6595                && TYPE_PTRMEMFUNC_P (to_type1)
6596                && TYPE_PTRMEMFUNC_P (to_type2)))
6597     {
6598       deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6599       deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6600       deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6601       deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6602     }
6603
6604   if (deref_from_type1 != NULL_TREE
6605       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6606       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6607     {
6608       /* This was one of the pointer or pointer-like conversions.
6609
6610          [over.ics.rank]
6611
6612          --If class B is derived directly or indirectly from class A,
6613            conversion of B* to A* is better than conversion of B* to
6614            void*, and conversion of A* to void* is better than
6615            conversion of B* to void*.  */
6616       if (TREE_CODE (deref_to_type1) == VOID_TYPE
6617           && TREE_CODE (deref_to_type2) == VOID_TYPE)
6618         {
6619           if (is_properly_derived_from (deref_from_type1,
6620                                         deref_from_type2))
6621             return -1;
6622           else if (is_properly_derived_from (deref_from_type2,
6623                                              deref_from_type1))
6624             return 1;
6625         }
6626       else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6627                || TREE_CODE (deref_to_type2) == VOID_TYPE)
6628         {
6629           if (same_type_p (deref_from_type1, deref_from_type2))
6630             {
6631               if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6632                 {
6633                   if (is_properly_derived_from (deref_from_type1,
6634                                                 deref_to_type1))
6635                     return 1;
6636                 }
6637               /* We know that DEREF_TO_TYPE1 is `void' here.  */
6638               else if (is_properly_derived_from (deref_from_type1,
6639                                                  deref_to_type2))
6640                 return -1;
6641             }
6642         }
6643       else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6644                && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6645         {
6646           /* [over.ics.rank]
6647
6648              --If class B is derived directly or indirectly from class A
6649                and class C is derived directly or indirectly from B,
6650
6651              --conversion of C* to B* is better than conversion of C* to
6652                A*,
6653
6654              --conversion of B* to A* is better than conversion of C* to
6655                A*  */
6656           if (same_type_p (deref_from_type1, deref_from_type2))
6657             {
6658               if (is_properly_derived_from (deref_to_type1,
6659                                             deref_to_type2))
6660                 return 1;
6661               else if (is_properly_derived_from (deref_to_type2,
6662                                                  deref_to_type1))
6663                 return -1;
6664             }
6665           else if (same_type_p (deref_to_type1, deref_to_type2))
6666             {
6667               if (is_properly_derived_from (deref_from_type2,
6668                                             deref_from_type1))
6669                 return 1;
6670               else if (is_properly_derived_from (deref_from_type1,
6671                                                  deref_from_type2))
6672                 return -1;
6673             }
6674         }
6675     }
6676   else if (CLASS_TYPE_P (non_reference (from_type1))
6677            && same_type_p (from_type1, from_type2))
6678     {
6679       tree from = non_reference (from_type1);
6680
6681       /* [over.ics.rank]
6682
6683          --binding of an expression of type C to a reference of type
6684            B& is better than binding an expression of type C to a
6685            reference of type A&
6686
6687          --conversion of C to B is better than conversion of C to A,  */
6688       if (is_properly_derived_from (from, to_type1)
6689           && is_properly_derived_from (from, to_type2))
6690         {
6691           if (is_properly_derived_from (to_type1, to_type2))
6692             return 1;
6693           else if (is_properly_derived_from (to_type2, to_type1))
6694             return -1;
6695         }
6696     }
6697   else if (CLASS_TYPE_P (non_reference (to_type1))
6698            && same_type_p (to_type1, to_type2))
6699     {
6700       tree to = non_reference (to_type1);
6701
6702       /* [over.ics.rank]
6703
6704          --binding of an expression of type B to a reference of type
6705            A& is better than binding an expression of type C to a
6706            reference of type A&,
6707
6708          --conversion of B to A is better than conversion of C to A  */
6709       if (is_properly_derived_from (from_type1, to)
6710           && is_properly_derived_from (from_type2, to))
6711         {
6712           if (is_properly_derived_from (from_type2, from_type1))
6713             return 1;
6714           else if (is_properly_derived_from (from_type1, from_type2))
6715             return -1;
6716         }
6717     }
6718
6719   /* [over.ics.rank]
6720
6721      --S1 and S2 differ only in their qualification conversion and  yield
6722        similar  types  T1 and T2 (_conv.qual_), respectively, and the cv-
6723        qualification signature of type T1 is a proper subset of  the  cv-
6724        qualification signature of type T2  */
6725   if (ics1->kind == ck_qual
6726       && ics2->kind == ck_qual
6727       && same_type_p (from_type1, from_type2))
6728     {
6729       int result = comp_cv_qual_signature (to_type1, to_type2);
6730       if (result != 0)
6731         return result;
6732     }
6733
6734   /* [over.ics.rank]
6735
6736      --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6737      to an implicit object parameter, and either S1 binds an lvalue reference
6738      to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6739      reference to an rvalue and S2 binds an lvalue reference
6740      (C++0x draft standard, 13.3.3.2)
6741
6742      --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6743      types to which the references refer are the same type except for
6744      top-level cv-qualifiers, and the type to which the reference
6745      initialized by S2 refers is more cv-qualified than the type to
6746      which the reference initialized by S1 refers */
6747
6748   if (ref_conv1 && ref_conv2)
6749     {
6750       if (!ref_conv1->this_p && !ref_conv2->this_p
6751           && (TYPE_REF_IS_RVALUE (ref_conv1->type)
6752               != TYPE_REF_IS_RVALUE (ref_conv2->type)))
6753         {
6754           if (ref_conv1->rvaluedness_matches_p)
6755             return 1;
6756           if (ref_conv2->rvaluedness_matches_p)
6757             return -1;
6758         }
6759
6760       if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
6761         return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
6762                                       TREE_TYPE (ref_conv1->type));
6763     }
6764
6765   /* Neither conversion sequence is better than the other.  */
6766   return 0;
6767 }
6768
6769 /* The source type for this standard conversion sequence.  */
6770
6771 static tree
6772 source_type (conversion *t)
6773 {
6774   for (;; t = t->u.next)
6775     {
6776       if (t->kind == ck_user
6777           || t->kind == ck_ambig
6778           || t->kind == ck_identity)
6779         return t->type;
6780     }
6781   gcc_unreachable ();
6782 }
6783
6784 /* Note a warning about preferring WINNER to LOSER.  We do this by storing
6785    a pointer to LOSER and re-running joust to produce the warning if WINNER
6786    is actually used.  */
6787
6788 static void
6789 add_warning (struct z_candidate *winner, struct z_candidate *loser)
6790 {
6791   candidate_warning *cw = (candidate_warning *)
6792     conversion_obstack_alloc (sizeof (candidate_warning));
6793   cw->loser = loser;
6794   cw->next = winner->warnings;
6795   winner->warnings = cw;
6796 }
6797
6798 /* Compare two candidates for overloading as described in
6799    [over.match.best].  Return values:
6800
6801       1: cand1 is better than cand2
6802      -1: cand2 is better than cand1
6803       0: cand1 and cand2 are indistinguishable */
6804
6805 static int
6806 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6807 {
6808   int winner = 0;
6809   int off1 = 0, off2 = 0;
6810   size_t i;
6811   size_t len;
6812
6813   /* Candidates that involve bad conversions are always worse than those
6814      that don't.  */
6815   if (cand1->viable > cand2->viable)
6816     return 1;
6817   if (cand1->viable < cand2->viable)
6818     return -1;
6819
6820   /* If we have two pseudo-candidates for conversions to the same type,
6821      or two candidates for the same function, arbitrarily pick one.  */
6822   if (cand1->fn == cand2->fn
6823       && (IS_TYPE_OR_DECL_P (cand1->fn)))
6824     return 1;
6825
6826   /* a viable function F1
6827      is defined to be a better function than another viable function F2  if
6828      for  all arguments i, ICSi(F1) is not a worse conversion sequence than
6829      ICSi(F2), and then */
6830
6831   /* for some argument j, ICSj(F1) is a better conversion  sequence  than
6832      ICSj(F2) */
6833
6834   /* For comparing static and non-static member functions, we ignore
6835      the implicit object parameter of the non-static function.  The
6836      standard says to pretend that the static function has an object
6837      parm, but that won't work with operator overloading.  */
6838   len = cand1->num_convs;
6839   if (len != cand2->num_convs)
6840     {
6841       int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6842       int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6843
6844       gcc_assert (static_1 != static_2);
6845
6846       if (static_1)
6847         off2 = 1;
6848       else
6849         {
6850           off1 = 1;
6851           --len;
6852         }
6853     }
6854
6855   for (i = 0; i < len; ++i)
6856     {
6857       conversion *t1 = cand1->convs[i + off1];
6858       conversion *t2 = cand2->convs[i + off2];
6859       int comp = compare_ics (t1, t2);
6860
6861       if (comp != 0)
6862         {
6863           if (warn_sign_promo
6864               && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6865                   == cr_std + cr_promotion)
6866               && t1->kind == ck_std
6867               && t2->kind == ck_std
6868               && TREE_CODE (t1->type) == INTEGER_TYPE
6869               && TREE_CODE (t2->type) == INTEGER_TYPE
6870               && (TYPE_PRECISION (t1->type)
6871                   == TYPE_PRECISION (t2->type))
6872               && (TYPE_UNSIGNED (t1->u.next->type)
6873                   || (TREE_CODE (t1->u.next->type)
6874                       == ENUMERAL_TYPE)))
6875             {
6876               tree type = t1->u.next->type;
6877               tree type1, type2;
6878               struct z_candidate *w, *l;
6879               if (comp > 0)
6880                 type1 = t1->type, type2 = t2->type,
6881                   w = cand1, l = cand2;
6882               else
6883                 type1 = t2->type, type2 = t1->type,
6884                   w = cand2, l = cand1;
6885
6886               if (warn)
6887                 {
6888                   warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6889                            type, type1, type2);
6890                   warning (OPT_Wsign_promo, "  in call to %qD", w->fn);
6891                 }
6892               else
6893                 add_warning (w, l);
6894             }
6895
6896           if (winner && comp != winner)
6897             {
6898               winner = 0;
6899               goto tweak;
6900             }
6901           winner = comp;
6902         }
6903     }
6904
6905   /* warn about confusing overload resolution for user-defined conversions,
6906      either between a constructor and a conversion op, or between two
6907      conversion ops.  */
6908   if (winner && warn_conversion && cand1->second_conv
6909       && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6910       && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6911     {
6912       struct z_candidate *w, *l;
6913       bool give_warning = false;
6914
6915       if (winner == 1)
6916         w = cand1, l = cand2;
6917       else
6918         w = cand2, l = cand1;
6919
6920       /* We don't want to complain about `X::operator T1 ()'
6921          beating `X::operator T2 () const', when T2 is a no less
6922          cv-qualified version of T1.  */
6923       if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6924           && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6925         {
6926           tree t = TREE_TYPE (TREE_TYPE (l->fn));
6927           tree f = TREE_TYPE (TREE_TYPE (w->fn));
6928
6929           if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6930             {
6931               t = TREE_TYPE (t);
6932               f = TREE_TYPE (f);
6933             }
6934           if (!comp_ptr_ttypes (t, f))
6935             give_warning = true;
6936         }
6937       else
6938         give_warning = true;
6939
6940       if (!give_warning)
6941         /*NOP*/;
6942       else if (warn)
6943         {
6944           tree source = source_type (w->convs[0]);
6945           if (! DECL_CONSTRUCTOR_P (w->fn))
6946             source = TREE_TYPE (source);
6947           if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
6948               && warning (OPT_Wconversion, "  for conversion from %qT to %qT",
6949                           source, w->second_conv->type))
6950             {
6951               inform (input_location, "  because conversion sequence for the argument is better");
6952             }
6953         }
6954       else
6955         add_warning (w, l);
6956     }
6957
6958   if (winner)
6959     return winner;
6960
6961   /* or, if not that,
6962      F1 is a non-template function and F2 is a template function
6963      specialization.  */
6964
6965   if (!cand1->template_decl && cand2->template_decl)
6966     return 1;
6967   else if (cand1->template_decl && !cand2->template_decl)
6968     return -1;
6969
6970   /* or, if not that,
6971      F1 and F2 are template functions and the function template for F1 is
6972      more specialized than the template for F2 according to the partial
6973      ordering rules.  */
6974
6975   if (cand1->template_decl && cand2->template_decl)
6976     {
6977       winner = more_specialized_fn
6978         (TI_TEMPLATE (cand1->template_decl),
6979          TI_TEMPLATE (cand2->template_decl),
6980          /* [temp.func.order]: The presence of unused ellipsis and default
6981             arguments has no effect on the partial ordering of function
6982             templates.   add_function_candidate() will not have
6983             counted the "this" argument for constructors.  */
6984          cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6985       if (winner)
6986         return winner;
6987     }
6988
6989   /* or, if not that,
6990      the  context  is  an  initialization by user-defined conversion (see
6991      _dcl.init_  and  _over.match.user_)  and  the  standard   conversion
6992      sequence  from  the return type of F1 to the destination type (i.e.,
6993      the type of the entity being initialized)  is  a  better  conversion
6994      sequence  than the standard conversion sequence from the return type
6995      of F2 to the destination type.  */
6996
6997   if (cand1->second_conv)
6998     {
6999       winner = compare_ics (cand1->second_conv, cand2->second_conv);
7000       if (winner)
7001         return winner;
7002     }
7003
7004   /* Check whether we can discard a builtin candidate, either because we
7005      have two identical ones or matching builtin and non-builtin candidates.
7006
7007      (Pedantically in the latter case the builtin which matched the user
7008      function should not be added to the overload set, but we spot it here.
7009
7010      [over.match.oper]
7011      ... the builtin candidates include ...
7012      - do not have the same parameter type list as any non-template
7013        non-member candidate.  */
7014
7015   if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7016       || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7017     {
7018       for (i = 0; i < len; ++i)
7019         if (!same_type_p (cand1->convs[i]->type,
7020                           cand2->convs[i]->type))
7021           break;
7022       if (i == cand1->num_convs)
7023         {
7024           if (cand1->fn == cand2->fn)
7025             /* Two built-in candidates; arbitrarily pick one.  */
7026             return 1;
7027           else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7028             /* cand1 is built-in; prefer cand2.  */
7029             return -1;
7030           else
7031             /* cand2 is built-in; prefer cand1.  */
7032             return 1;
7033         }
7034     }
7035
7036   /* If the two function declarations represent the same function (this can
7037      happen with declarations in multiple scopes and arg-dependent lookup),
7038      arbitrarily choose one.  But first make sure the default args we're
7039      using match.  */
7040   if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7041       && equal_functions (cand1->fn, cand2->fn))
7042     {
7043       tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7044       tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7045
7046       gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7047
7048       for (i = 0; i < len; ++i)
7049         {
7050           /* Don't crash if the fn is variadic.  */
7051           if (!parms1)
7052             break;
7053           parms1 = TREE_CHAIN (parms1);
7054           parms2 = TREE_CHAIN (parms2);
7055         }
7056
7057       if (off1)
7058         parms1 = TREE_CHAIN (parms1);
7059       else if (off2)
7060         parms2 = TREE_CHAIN (parms2);
7061
7062       for (; parms1; ++i)
7063         {
7064           if (!cp_tree_equal (TREE_PURPOSE (parms1),
7065                               TREE_PURPOSE (parms2)))
7066             {
7067               if (warn)
7068                 {
7069                   permerror (input_location, "default argument mismatch in "
7070                              "overload resolution");
7071                   inform (input_location,
7072                           " candidate 1: %q+#F", cand1->fn);
7073                   inform (input_location,
7074                           " candidate 2: %q+#F", cand2->fn);
7075                 }
7076               else
7077                 add_warning (cand1, cand2);
7078               break;
7079             }
7080           parms1 = TREE_CHAIN (parms1);
7081           parms2 = TREE_CHAIN (parms2);
7082         }
7083
7084       return 1;
7085     }
7086
7087 tweak:
7088
7089   /* Extension: If the worst conversion for one candidate is worse than the
7090      worst conversion for the other, take the first.  */
7091   if (!pedantic)
7092     {
7093       conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7094       struct z_candidate *w = 0, *l = 0;
7095
7096       for (i = 0; i < len; ++i)
7097         {
7098           if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7099             rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7100           if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7101             rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7102         }
7103       if (rank1 < rank2)
7104         winner = 1, w = cand1, l = cand2;
7105       if (rank1 > rank2)
7106         winner = -1, w = cand2, l = cand1;
7107       if (winner)
7108         {
7109           if (warn)
7110             {
7111               pedwarn (input_location, 0,
7112               "ISO C++ says that these are ambiguous, even "
7113               "though the worst conversion for the first is better than "
7114               "the worst conversion for the second:");
7115               print_z_candidate (_("candidate 1:"), w);
7116               print_z_candidate (_("candidate 2:"), l);
7117             }
7118           else
7119             add_warning (w, l);
7120           return winner;
7121         }
7122     }
7123
7124   gcc_assert (!winner);
7125   return 0;
7126 }
7127
7128 /* Given a list of candidates for overloading, find the best one, if any.
7129    This algorithm has a worst case of O(2n) (winner is last), and a best
7130    case of O(n/2) (totally ambiguous); much better than a sorting
7131    algorithm.  */
7132
7133 static struct z_candidate *
7134 tourney (struct z_candidate *candidates)
7135 {
7136   struct z_candidate *champ = candidates, *challenger;
7137   int fate;
7138   int champ_compared_to_predecessor = 0;
7139
7140   /* Walk through the list once, comparing each current champ to the next
7141      candidate, knocking out a candidate or two with each comparison.  */
7142
7143   for (challenger = champ->next; challenger; )
7144     {
7145       fate = joust (champ, challenger, 0);
7146       if (fate == 1)
7147         challenger = challenger->next;
7148       else
7149         {
7150           if (fate == 0)
7151             {
7152               champ = challenger->next;
7153               if (champ == 0)
7154                 return NULL;
7155               champ_compared_to_predecessor = 0;
7156             }
7157           else
7158             {
7159               champ = challenger;
7160               champ_compared_to_predecessor = 1;
7161             }
7162
7163           challenger = champ->next;
7164         }
7165     }
7166
7167   /* Make sure the champ is better than all the candidates it hasn't yet
7168      been compared to.  */
7169
7170   for (challenger = candidates;
7171        challenger != champ
7172          && !(champ_compared_to_predecessor && challenger->next == champ);
7173        challenger = challenger->next)
7174     {
7175       fate = joust (champ, challenger, 0);
7176       if (fate != 1)
7177         return NULL;
7178     }
7179
7180   return champ;
7181 }
7182
7183 /* Returns nonzero if things of type FROM can be converted to TO.  */
7184
7185 bool
7186 can_convert (tree to, tree from)
7187 {
7188   return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
7189 }
7190
7191 /* Returns nonzero if ARG (of type FROM) can be converted to TO.  */
7192
7193 bool
7194 can_convert_arg (tree to, tree from, tree arg, int flags)
7195 {
7196   conversion *t;
7197   void *p;
7198   bool ok_p;
7199
7200   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7201   p = conversion_obstack_alloc (0);
7202
7203   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7204                             flags);
7205   ok_p = (t && !t->bad_p);
7206
7207   /* Free all the conversions we allocated.  */
7208   obstack_free (&conversion_obstack, p);
7209
7210   return ok_p;
7211 }
7212
7213 /* Like can_convert_arg, but allows dubious conversions as well.  */
7214
7215 bool
7216 can_convert_arg_bad (tree to, tree from, tree arg)
7217 {
7218   conversion *t;
7219   void *p;
7220
7221   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7222   p = conversion_obstack_alloc (0);
7223   /* Try to perform the conversion.  */
7224   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7225                             LOOKUP_NORMAL);
7226   /* Free all the conversions we allocated.  */
7227   obstack_free (&conversion_obstack, p);
7228
7229   return t != NULL;
7230 }
7231
7232 /* Convert EXPR to TYPE.  Return the converted expression.
7233
7234    Note that we allow bad conversions here because by the time we get to
7235    this point we are committed to doing the conversion.  If we end up
7236    doing a bad conversion, convert_like will complain.  */
7237
7238 tree
7239 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7240 {
7241   conversion *conv;
7242   void *p;
7243
7244   if (error_operand_p (expr))
7245     return error_mark_node;
7246
7247   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7248   p = conversion_obstack_alloc (0);
7249
7250   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7251                               /*c_cast_p=*/false,
7252                               flags);
7253
7254   if (!conv)
7255     {
7256       if (complain & tf_error)
7257         {
7258           /* If expr has unknown type, then it is an overloaded function.
7259              Call instantiate_type to get good error messages.  */
7260           if (TREE_TYPE (expr) == unknown_type_node)
7261             instantiate_type (type, expr, complain);
7262           else if (invalid_nonstatic_memfn_p (expr, complain))
7263             /* We gave an error.  */;
7264           else
7265             error ("could not convert %qE to %qT", expr, type);
7266         }
7267       expr = error_mark_node;
7268     }
7269   else if (processing_template_decl)
7270     {
7271       /* In a template, we are only concerned about determining the
7272          type of non-dependent expressions, so we do not have to
7273          perform the actual conversion.  */
7274       if (TREE_TYPE (expr) != type)
7275         expr = build_nop (type, expr);
7276     }
7277   else
7278     expr = convert_like (conv, expr, complain);
7279
7280   /* Free all the conversions we allocated.  */
7281   obstack_free (&conversion_obstack, p);
7282
7283   return expr;
7284 }
7285
7286 tree
7287 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7288 {
7289   return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
7290 }
7291
7292 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7293    permitted.  If the conversion is valid, the converted expression is
7294    returned.  Otherwise, NULL_TREE is returned, except in the case
7295    that TYPE is a class type; in that case, an error is issued.  If
7296    C_CAST_P is true, then this direction initialization is taking
7297    place as part of a static_cast being attempted as part of a C-style
7298    cast.  */
7299
7300 tree
7301 perform_direct_initialization_if_possible (tree type,
7302                                            tree expr,
7303                                            bool c_cast_p,
7304                                            tsubst_flags_t complain)
7305 {
7306   conversion *conv;
7307   void *p;
7308
7309   if (type == error_mark_node || error_operand_p (expr))
7310     return error_mark_node;
7311   /* [dcl.init]
7312
7313      If the destination type is a (possibly cv-qualified) class type:
7314
7315      -- If the initialization is direct-initialization ...,
7316      constructors are considered. ... If no constructor applies, or
7317      the overload resolution is ambiguous, the initialization is
7318      ill-formed.  */
7319   if (CLASS_TYPE_P (type))
7320     {
7321       VEC(tree,gc) *args = make_tree_vector_single (expr);
7322       expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7323                                         &args, type, LOOKUP_NORMAL, complain);
7324       release_tree_vector (args);
7325       return build_cplus_new (type, expr);
7326     }
7327
7328   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7329   p = conversion_obstack_alloc (0);
7330
7331   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7332                               c_cast_p,
7333                               LOOKUP_NORMAL);
7334   if (!conv || conv->bad_p)
7335     expr = NULL_TREE;
7336   else
7337     expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7338                               /*issue_conversion_warnings=*/false,
7339                               c_cast_p,
7340                               tf_warning_or_error);
7341
7342   /* Free all the conversions we allocated.  */
7343   obstack_free (&conversion_obstack, p);
7344
7345   return expr;
7346 }
7347
7348 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE.  The reference
7349    is being bound to a temporary.  Create and return a new VAR_DECL
7350    with the indicated TYPE; this variable will store the value to
7351    which the reference is bound.  */
7352
7353 tree
7354 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7355 {
7356   tree var;
7357
7358   /* Create the variable.  */
7359   var = create_temporary_var (type);
7360
7361   /* Register the variable.  */
7362   if (TREE_STATIC (decl))
7363     {
7364       /* Namespace-scope or local static; give it a mangled name.  */
7365       tree name;
7366
7367       TREE_STATIC (var) = 1;
7368       name = mangle_ref_init_variable (decl);
7369       DECL_NAME (var) = name;
7370       SET_DECL_ASSEMBLER_NAME (var, name);
7371       var = pushdecl_top_level (var);
7372     }
7373   else
7374     /* Create a new cleanup level if necessary.  */
7375     maybe_push_cleanup_level (type);
7376
7377   return var;
7378 }
7379
7380 /* EXPR is the initializer for a variable DECL of reference or
7381    std::initializer_list type.  Create, push and return a new VAR_DECL
7382    for the initializer so that it will live as long as DECL.  Any
7383    cleanup for the new variable is returned through CLEANUP, and the
7384    code to initialize the new variable is returned through INITP.  */
7385
7386 tree
7387 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7388 {
7389   tree init;
7390   tree type;
7391   tree var;
7392
7393   /* Create the temporary variable.  */
7394   type = TREE_TYPE (expr);
7395   var = make_temporary_var_for_ref_to_temp (decl, type);
7396   layout_decl (var, 0);
7397   /* If the rvalue is the result of a function call it will be
7398      a TARGET_EXPR.  If it is some other construct (such as a
7399      member access expression where the underlying object is
7400      itself the result of a function call), turn it into a
7401      TARGET_EXPR here.  It is important that EXPR be a
7402      TARGET_EXPR below since otherwise the INIT_EXPR will
7403      attempt to make a bitwise copy of EXPR to initialize
7404      VAR.  */
7405   if (TREE_CODE (expr) != TARGET_EXPR)
7406     expr = get_target_expr (expr);
7407   /* Create the INIT_EXPR that will initialize the temporary
7408      variable.  */
7409   init = build2 (INIT_EXPR, type, var, expr);
7410   if (at_function_scope_p ())
7411     {
7412       add_decl_expr (var);
7413
7414       if (TREE_STATIC (var))
7415         init = add_stmt_to_compound (init, register_dtor_fn (var));
7416       else
7417         *cleanup = cxx_maybe_build_cleanup (var);
7418
7419       /* We must be careful to destroy the temporary only
7420          after its initialization has taken place.  If the
7421          initialization throws an exception, then the
7422          destructor should not be run.  We cannot simply
7423          transform INIT into something like:
7424
7425          (INIT, ({ CLEANUP_STMT; }))
7426
7427          because emit_local_var always treats the
7428          initializer as a full-expression.  Thus, the
7429          destructor would run too early; it would run at the
7430          end of initializing the reference variable, rather
7431          than at the end of the block enclosing the
7432          reference variable.
7433
7434          The solution is to pass back a cleanup expression
7435          which the caller is responsible for attaching to
7436          the statement tree.  */
7437     }
7438   else
7439     {
7440       rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7441       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7442         static_aggregates = tree_cons (NULL_TREE, var,
7443                                        static_aggregates);
7444     }
7445
7446   *initp = init;
7447   return var;
7448 }
7449
7450 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7451    initializing a variable of that TYPE.  If DECL is non-NULL, it is
7452    the VAR_DECL being initialized with the EXPR.  (In that case, the
7453    type of DECL will be TYPE.)  If DECL is non-NULL, then CLEANUP must
7454    also be non-NULL, and with *CLEANUP initialized to NULL.  Upon
7455    return, if *CLEANUP is no longer NULL, it will be an expression
7456    that should be pushed as a cleanup after the returned expression
7457    is used to initialize DECL.
7458
7459    Return the converted expression.  */
7460
7461 tree
7462 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
7463 {
7464   conversion *conv;
7465   void *p;
7466
7467   if (type == error_mark_node || error_operand_p (expr))
7468     return error_mark_node;
7469
7470   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7471   p = conversion_obstack_alloc (0);
7472
7473   conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7474                             LOOKUP_NORMAL);
7475   if (!conv || conv->bad_p)
7476     {
7477       if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
7478           && !real_lvalue_p (expr))
7479         error ("invalid initialization of non-const reference of "
7480                "type %qT from a temporary of type %qT",
7481                type, TREE_TYPE (expr));
7482       else
7483         error ("invalid initialization of reference of type "
7484                "%qT from expression of type %qT", type,
7485                TREE_TYPE (expr));
7486       return error_mark_node;
7487     }
7488
7489   /* If DECL is non-NULL, then this special rule applies:
7490
7491        [class.temporary]
7492
7493        The temporary to which the reference is bound or the temporary
7494        that is the complete object to which the reference is bound
7495        persists for the lifetime of the reference.
7496
7497        The temporaries created during the evaluation of the expression
7498        initializing the reference, except the temporary to which the
7499        reference is bound, are destroyed at the end of the
7500        full-expression in which they are created.
7501
7502      In that case, we store the converted expression into a new
7503      VAR_DECL in a new scope.
7504
7505      However, we want to be careful not to create temporaries when
7506      they are not required.  For example, given:
7507
7508        struct B {};
7509        struct D : public B {};
7510        D f();
7511        const B& b = f();
7512
7513      there is no need to copy the return value from "f"; we can just
7514      extend its lifetime.  Similarly, given:
7515
7516        struct S {};
7517        struct T { operator S(); };
7518        T t;
7519        const S& s = t;
7520
7521     we can extend the lifetime of the return value of the conversion
7522     operator.  */
7523   gcc_assert (conv->kind == ck_ref_bind);
7524   if (decl)
7525     {
7526       tree var;
7527       tree base_conv_type;
7528
7529       /* Skip over the REF_BIND.  */
7530       conv = conv->u.next;
7531       /* If the next conversion is a BASE_CONV, skip that too -- but
7532          remember that the conversion was required.  */
7533       if (conv->kind == ck_base)
7534         {
7535           base_conv_type = conv->type;
7536           conv = conv->u.next;
7537         }
7538       else
7539         base_conv_type = NULL_TREE;
7540       /* Perform the remainder of the conversion.  */
7541       expr = convert_like_real (conv, expr,
7542                                 /*fn=*/NULL_TREE, /*argnum=*/0,
7543                                 /*inner=*/-1,
7544                                 /*issue_conversion_warnings=*/true,
7545                                 /*c_cast_p=*/false,
7546                                 tf_warning_or_error);
7547       if (error_operand_p (expr))
7548         expr = error_mark_node;
7549       else
7550         {
7551           if (!real_lvalue_p (expr))
7552             {
7553               tree init;
7554               var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7555               /* Use its address to initialize the reference variable.  */
7556               expr = build_address (var);
7557               if (base_conv_type)
7558                 expr = convert_to_base (expr,
7559                                         build_pointer_type (base_conv_type),
7560                                         /*check_access=*/true,
7561                                         /*nonnull=*/true);
7562               expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7563             }
7564           else
7565             /* Take the address of EXPR.  */
7566             expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7567           /* If a BASE_CONV was required, perform it now.  */
7568           if (base_conv_type)
7569             expr = (perform_implicit_conversion
7570                     (build_pointer_type (base_conv_type), expr,
7571                      tf_warning_or_error));
7572           expr = build_nop (type, expr);
7573         }
7574     }
7575   else
7576     /* Perform the conversion.  */
7577     expr = convert_like (conv, expr, tf_warning_or_error);
7578
7579   /* Free all the conversions we allocated.  */
7580   obstack_free (&conversion_obstack, p);
7581
7582   return expr;
7583 }
7584
7585 /* Returns true iff TYPE is some variant of std::initializer_list.  */
7586
7587 bool
7588 is_std_init_list (tree type)
7589 {
7590   return (CLASS_TYPE_P (type)
7591           && CP_TYPE_CONTEXT (type) == std_node
7592           && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7593 }
7594
7595 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7596    will accept an argument list of a single std::initializer_list<T>.  */
7597
7598 bool
7599 is_list_ctor (tree decl)
7600 {
7601   tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7602   tree arg;
7603
7604   if (!args || args == void_list_node)
7605     return false;
7606
7607   arg = non_reference (TREE_VALUE (args));
7608   if (!is_std_init_list (arg))
7609     return false;
7610
7611   args = TREE_CHAIN (args);
7612
7613   if (args && args != void_list_node && !TREE_PURPOSE (args))
7614     /* There are more non-defaulted parms.  */
7615     return false;
7616
7617   return true;
7618 }
7619
7620 #include "gt-cp-call.h"