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