gcc/cp/call.c

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